1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2020 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"
48 #include "gdb-demangle.h"
49 #include "filenames.h" /* for DOSish file names */
52 #include "complaints.h"
53 #include "dwarf2/expr.h"
54 #include "dwarf2/loc.h"
55 #include "cp-support.h"
61 #include "typeprint.h"
66 #include "gdbcore.h" /* for gnutarget */
67 #include "gdb/gdb-index.h"
72 #include "namespace.h"
73 #include "gdbsupport/function-view.h"
74 #include "gdbsupport/gdb_optional.h"
75 #include "gdbsupport/underlying.h"
76 #include "gdbsupport/hash_enum.h"
77 #include "filename-seen-cache.h"
81 #include <unordered_map>
82 #include "gdbsupport/selftest.h"
83 #include "rust-lang.h"
84 #include "gdbsupport/pathstuff.h"
85 #include "count-one-bits.h"
86 #include "debuginfod-support.h"
88 /* When == 1, print basic high level tracing messages.
89 When > 1, be more verbose.
90 This is in contrast to the low level DIE reading of dwarf_die_debug. */
91 static unsigned int dwarf_read_debug
= 0;
93 /* When non-zero, dump DIEs after they are read in. */
94 static unsigned int dwarf_die_debug
= 0;
96 /* When non-zero, dump line number entries as they are read in. */
97 unsigned int dwarf_line_debug
= 0;
99 /* When true, cross-check physname against demangler. */
100 static bool check_physname
= false;
102 /* When true, do not reject deprecated .gdb_index sections. */
103 static bool use_deprecated_index_sections
= false;
105 static const struct objfile_key
<dwarf2_per_objfile
> dwarf2_objfile_data_key
;
107 /* The "aclass" indices for various kinds of computed DWARF symbols. */
109 static int dwarf2_locexpr_index
;
110 static int dwarf2_loclist_index
;
111 static int dwarf2_locexpr_block_index
;
112 static int dwarf2_loclist_block_index
;
114 /* An index into a (C++) symbol name component in a symbol name as
115 recorded in the mapped_index's symbol table. For each C++ symbol
116 in the symbol table, we record one entry for the start of each
117 component in the symbol in a table of name components, and then
118 sort the table, in order to be able to binary search symbol names,
119 ignoring leading namespaces, both completion and regular look up.
120 For example, for symbol "A::B::C", we'll have an entry that points
121 to "A::B::C", another that points to "B::C", and another for "C".
122 Note that function symbols in GDB index have no parameter
123 information, just the function/method names. You can convert a
124 name_component to a "const char *" using the
125 'mapped_index::symbol_name_at(offset_type)' method. */
127 struct name_component
129 /* Offset in the symbol name where the component starts. Stored as
130 a (32-bit) offset instead of a pointer to save memory and improve
131 locality on 64-bit architectures. */
132 offset_type name_offset
;
134 /* The symbol's index in the symbol and constant pool tables of a
139 /* Base class containing bits shared by both .gdb_index and
140 .debug_name indexes. */
142 struct mapped_index_base
144 mapped_index_base () = default;
145 DISABLE_COPY_AND_ASSIGN (mapped_index_base
);
147 /* The name_component table (a sorted vector). See name_component's
148 description above. */
149 std::vector
<name_component
> name_components
;
151 /* How NAME_COMPONENTS is sorted. */
152 enum case_sensitivity name_components_casing
;
154 /* Return the number of names in the symbol table. */
155 virtual size_t symbol_name_count () const = 0;
157 /* Get the name of the symbol at IDX in the symbol table. */
158 virtual const char *symbol_name_at (offset_type idx
) const = 0;
160 /* Return whether the name at IDX in the symbol table should be
162 virtual bool symbol_name_slot_invalid (offset_type idx
) const
167 /* Build the symbol name component sorted vector, if we haven't
169 void build_name_components ();
171 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
172 possible matches for LN_NO_PARAMS in the name component
174 std::pair
<std::vector
<name_component
>::const_iterator
,
175 std::vector
<name_component
>::const_iterator
>
176 find_name_components_bounds (const lookup_name_info
&ln_no_params
,
177 enum language lang
) const;
179 /* Prevent deleting/destroying via a base class pointer. */
181 ~mapped_index_base() = default;
184 /* A description of the mapped index. The file format is described in
185 a comment by the code that writes the index. */
186 struct mapped_index final
: public mapped_index_base
188 /* A slot/bucket in the symbol table hash. */
189 struct symbol_table_slot
191 const offset_type name
;
192 const offset_type vec
;
195 /* Index data format version. */
198 /* The address table data. */
199 gdb::array_view
<const gdb_byte
> address_table
;
201 /* The symbol table, implemented as a hash table. */
202 gdb::array_view
<symbol_table_slot
> symbol_table
;
204 /* A pointer to the constant pool. */
205 const char *constant_pool
= nullptr;
207 bool symbol_name_slot_invalid (offset_type idx
) const override
209 const auto &bucket
= this->symbol_table
[idx
];
210 return bucket
.name
== 0 && bucket
.vec
== 0;
213 /* Convenience method to get at the name of the symbol at IDX in the
215 const char *symbol_name_at (offset_type idx
) const override
216 { return this->constant_pool
+ MAYBE_SWAP (this->symbol_table
[idx
].name
); }
218 size_t symbol_name_count () const override
219 { return this->symbol_table
.size (); }
222 /* A description of the mapped .debug_names.
223 Uninitialized map has CU_COUNT 0. */
224 struct mapped_debug_names final
: public mapped_index_base
226 mapped_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile_
)
227 : dwarf2_per_objfile (dwarf2_per_objfile_
)
230 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
231 bfd_endian dwarf5_byte_order
;
232 bool dwarf5_is_dwarf64
;
233 bool augmentation_is_gdb
;
235 uint32_t cu_count
= 0;
236 uint32_t tu_count
, bucket_count
, name_count
;
237 const gdb_byte
*cu_table_reordered
, *tu_table_reordered
;
238 const uint32_t *bucket_table_reordered
, *hash_table_reordered
;
239 const gdb_byte
*name_table_string_offs_reordered
;
240 const gdb_byte
*name_table_entry_offs_reordered
;
241 const gdb_byte
*entry_pool
;
248 /* Attribute name DW_IDX_*. */
251 /* Attribute form DW_FORM_*. */
254 /* Value if FORM is DW_FORM_implicit_const. */
255 LONGEST implicit_const
;
257 std::vector
<attr
> attr_vec
;
260 std::unordered_map
<ULONGEST
, index_val
> abbrev_map
;
262 const char *namei_to_name (uint32_t namei
) const;
264 /* Implementation of the mapped_index_base virtual interface, for
265 the name_components cache. */
267 const char *symbol_name_at (offset_type idx
) const override
268 { return namei_to_name (idx
); }
270 size_t symbol_name_count () const override
271 { return this->name_count
; }
274 /* See dwarf2read.h. */
277 get_dwarf2_per_objfile (struct objfile
*objfile
)
279 return dwarf2_objfile_data_key
.get (objfile
);
282 /* Default names of the debugging sections. */
284 /* Note that if the debugging section has been compressed, it might
285 have a name like .zdebug_info. */
287 static const struct dwarf2_debug_sections dwarf2_elf_names
=
289 { ".debug_info", ".zdebug_info" },
290 { ".debug_abbrev", ".zdebug_abbrev" },
291 { ".debug_line", ".zdebug_line" },
292 { ".debug_loc", ".zdebug_loc" },
293 { ".debug_loclists", ".zdebug_loclists" },
294 { ".debug_macinfo", ".zdebug_macinfo" },
295 { ".debug_macro", ".zdebug_macro" },
296 { ".debug_str", ".zdebug_str" },
297 { ".debug_str_offsets", ".zdebug_str_offsets" },
298 { ".debug_line_str", ".zdebug_line_str" },
299 { ".debug_ranges", ".zdebug_ranges" },
300 { ".debug_rnglists", ".zdebug_rnglists" },
301 { ".debug_types", ".zdebug_types" },
302 { ".debug_addr", ".zdebug_addr" },
303 { ".debug_frame", ".zdebug_frame" },
304 { ".eh_frame", NULL
},
305 { ".gdb_index", ".zgdb_index" },
306 { ".debug_names", ".zdebug_names" },
307 { ".debug_aranges", ".zdebug_aranges" },
311 /* List of DWO/DWP sections. */
313 static const struct dwop_section_names
315 struct dwarf2_section_names abbrev_dwo
;
316 struct dwarf2_section_names info_dwo
;
317 struct dwarf2_section_names line_dwo
;
318 struct dwarf2_section_names loc_dwo
;
319 struct dwarf2_section_names loclists_dwo
;
320 struct dwarf2_section_names macinfo_dwo
;
321 struct dwarf2_section_names macro_dwo
;
322 struct dwarf2_section_names str_dwo
;
323 struct dwarf2_section_names str_offsets_dwo
;
324 struct dwarf2_section_names types_dwo
;
325 struct dwarf2_section_names cu_index
;
326 struct dwarf2_section_names tu_index
;
330 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
331 { ".debug_info.dwo", ".zdebug_info.dwo" },
332 { ".debug_line.dwo", ".zdebug_line.dwo" },
333 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
334 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
335 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
336 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
337 { ".debug_str.dwo", ".zdebug_str.dwo" },
338 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
339 { ".debug_types.dwo", ".zdebug_types.dwo" },
340 { ".debug_cu_index", ".zdebug_cu_index" },
341 { ".debug_tu_index", ".zdebug_tu_index" },
344 /* local data types */
346 /* Type used for delaying computation of method physnames.
347 See comments for compute_delayed_physnames. */
348 struct delayed_method_info
350 /* The type to which the method is attached, i.e., its parent class. */
353 /* The index of the method in the type's function fieldlists. */
356 /* The index of the method in the fieldlist. */
359 /* The name of the DIE. */
362 /* The DIE associated with this method. */
363 struct die_info
*die
;
366 /* Internal state when decoding a particular compilation unit. */
369 explicit dwarf2_cu (struct dwarf2_per_cu_data
*per_cu
);
372 DISABLE_COPY_AND_ASSIGN (dwarf2_cu
);
374 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
375 Create the set of symtabs used by this TU, or if this TU is sharing
376 symtabs with another TU and the symtabs have already been created
377 then restore those symtabs in the line header.
378 We don't need the pc/line-number mapping for type units. */
379 void setup_type_unit_groups (struct die_info
*die
);
381 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
382 buildsym_compunit constructor. */
383 struct compunit_symtab
*start_symtab (const char *name
,
384 const char *comp_dir
,
387 /* Reset the builder. */
388 void reset_builder () { m_builder
.reset (); }
390 /* The header of the compilation unit. */
391 struct comp_unit_head header
{};
393 /* Base address of this compilation unit. */
394 CORE_ADDR base_address
= 0;
396 /* Non-zero if base_address has been set. */
399 /* The language we are debugging. */
400 enum language language
= language_unknown
;
401 const struct language_defn
*language_defn
= nullptr;
403 const char *producer
= nullptr;
406 /* The symtab builder for this CU. This is only non-NULL when full
407 symbols are being read. */
408 std::unique_ptr
<buildsym_compunit
> m_builder
;
411 /* The generic symbol table building routines have separate lists for
412 file scope symbols and all all other scopes (local scopes). So
413 we need to select the right one to pass to add_symbol_to_list().
414 We do it by keeping a pointer to the correct list in list_in_scope.
416 FIXME: The original dwarf code just treated the file scope as the
417 first local scope, and all other local scopes as nested local
418 scopes, and worked fine. Check to see if we really need to
419 distinguish these in buildsym.c. */
420 struct pending
**list_in_scope
= nullptr;
422 /* Hash table holding all the loaded partial DIEs
423 with partial_die->offset.SECT_OFF as hash. */
424 htab_t partial_dies
= nullptr;
426 /* Storage for things with the same lifetime as this read-in compilation
427 unit, including partial DIEs. */
428 auto_obstack comp_unit_obstack
;
430 /* When multiple dwarf2_cu structures are living in memory, this field
431 chains them all together, so that they can be released efficiently.
432 We will probably also want a generation counter so that most-recently-used
433 compilation units are cached... */
434 struct dwarf2_per_cu_data
*read_in_chain
= nullptr;
436 /* Backlink to our per_cu entry. */
437 struct dwarf2_per_cu_data
*per_cu
;
439 /* How many compilation units ago was this CU last referenced? */
442 /* A hash table of DIE cu_offset for following references with
443 die_info->offset.sect_off as hash. */
444 htab_t die_hash
= nullptr;
446 /* Full DIEs if read in. */
447 struct die_info
*dies
= nullptr;
449 /* A set of pointers to dwarf2_per_cu_data objects for compilation
450 units referenced by this one. Only set during full symbol processing;
451 partial symbol tables do not have dependencies. */
452 htab_t dependencies
= nullptr;
454 /* Header data from the line table, during full symbol processing. */
455 struct line_header
*line_header
= nullptr;
456 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
457 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
458 this is the DW_TAG_compile_unit die for this CU. We'll hold on
459 to the line header as long as this DIE is being processed. See
460 process_die_scope. */
461 die_info
*line_header_die_owner
= nullptr;
463 /* A list of methods which need to have physnames computed
464 after all type information has been read. */
465 std::vector
<delayed_method_info
> method_list
;
467 /* To be copied to symtab->call_site_htab. */
468 htab_t call_site_htab
= nullptr;
470 /* Non-NULL if this CU came from a DWO file.
471 There is an invariant here that is important to remember:
472 Except for attributes copied from the top level DIE in the "main"
473 (or "stub") file in preparation for reading the DWO file
474 (e.g., DW_AT_addr_base), we KISS: there is only *one* CU.
475 Either there isn't a DWO file (in which case this is NULL and the point
476 is moot), or there is and either we're not going to read it (in which
477 case this is NULL) or there is and we are reading it (in which case this
479 struct dwo_unit
*dwo_unit
= nullptr;
481 /* The DW_AT_addr_base (DW_AT_GNU_addr_base) attribute if present.
482 Note this value comes from the Fission stub CU/TU's DIE. */
483 gdb::optional
<ULONGEST
> addr_base
;
485 /* The DW_AT_rnglists_base attribute if present.
486 Note this value comes from the Fission stub CU/TU's DIE.
487 Also note that the value is zero in the non-DWO case so this value can
488 be used without needing to know whether DWO files are in use or not.
489 N.B. This does not apply to DW_AT_ranges appearing in
490 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
491 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
492 DW_AT_rnglists_base *would* have to be applied, and we'd have to care
493 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
494 ULONGEST ranges_base
= 0;
496 /* When reading debug info generated by older versions of rustc, we
497 have to rewrite some union types to be struct types with a
498 variant part. This rewriting must be done after the CU is fully
499 read in, because otherwise at the point of rewriting some struct
500 type might not have been fully processed. So, we keep a list of
501 all such types here and process them after expansion. */
502 std::vector
<struct type
*> rust_unions
;
504 /* The DW_AT_str_offsets_base attribute if present. For DWARF 4 version DWO
505 files, the value is implicitly zero. For DWARF 5 version DWO files, the
506 value is often implicit and is the size of the header of
507 .debug_str_offsets section (8 or 4, depending on the address size). */
508 gdb::optional
<ULONGEST
> str_offsets_base
;
510 /* Mark used when releasing cached dies. */
513 /* This CU references .debug_loc. See the symtab->locations_valid field.
514 This test is imperfect as there may exist optimized debug code not using
515 any location list and still facing inlining issues if handled as
516 unoptimized code. For a future better test see GCC PR other/32998. */
517 bool has_loclist
: 1;
519 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is true
520 if all the producer_is_* fields are valid. This information is cached
521 because profiling CU expansion showed excessive time spent in
522 producer_is_gxx_lt_4_6. */
523 bool checked_producer
: 1;
524 bool producer_is_gxx_lt_4_6
: 1;
525 bool producer_is_gcc_lt_4_3
: 1;
526 bool producer_is_icc
: 1;
527 bool producer_is_icc_lt_14
: 1;
528 bool producer_is_codewarrior
: 1;
530 /* When true, the file that we're processing is known to have
531 debugging info for C++ namespaces. GCC 3.3.x did not produce
532 this information, but later versions do. */
534 bool processing_has_namespace_info
: 1;
536 struct partial_die_info
*find_partial_die (sect_offset sect_off
);
538 /* If this CU was inherited by another CU (via specification,
539 abstract_origin, etc), this is the ancestor CU. */
542 /* Get the buildsym_compunit for this CU. */
543 buildsym_compunit
*get_builder ()
545 /* If this CU has a builder associated with it, use that. */
546 if (m_builder
!= nullptr)
547 return m_builder
.get ();
549 /* Otherwise, search ancestors for a valid builder. */
550 if (ancestor
!= nullptr)
551 return ancestor
->get_builder ();
557 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
558 This includes type_unit_group and quick_file_names. */
560 struct stmt_list_hash
562 /* The DWO unit this table is from or NULL if there is none. */
563 struct dwo_unit
*dwo_unit
;
565 /* Offset in .debug_line or .debug_line.dwo. */
566 sect_offset line_sect_off
;
569 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
570 an object of this type. */
572 struct type_unit_group
574 /* dwarf2read.c's main "handle" on a TU symtab.
575 To simplify things we create an artificial CU that "includes" all the
576 type units using this stmt_list so that the rest of the code still has
577 a "per_cu" handle on the symtab. */
578 struct dwarf2_per_cu_data per_cu
;
580 /* The TUs that share this DW_AT_stmt_list entry.
581 This is added to while parsing type units to build partial symtabs,
582 and is deleted afterwards and not used again. */
583 std::vector
<signatured_type
*> *tus
;
585 /* The compunit symtab.
586 Type units in a group needn't all be defined in the same source file,
587 so we create an essentially anonymous symtab as the compunit symtab. */
588 struct compunit_symtab
*compunit_symtab
;
590 /* The data used to construct the hash key. */
591 struct stmt_list_hash hash
;
593 /* The symbol tables for this TU (obtained from the files listed in
595 WARNING: The order of entries here must match the order of entries
596 in the line header. After the first TU using this type_unit_group, the
597 line header for the subsequent TUs is recreated from this. This is done
598 because we need to use the same symtabs for each TU using the same
599 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
600 there's no guarantee the line header doesn't have duplicate entries. */
601 struct symtab
**symtabs
;
604 /* These sections are what may appear in a (real or virtual) DWO file. */
608 struct dwarf2_section_info abbrev
;
609 struct dwarf2_section_info line
;
610 struct dwarf2_section_info loc
;
611 struct dwarf2_section_info loclists
;
612 struct dwarf2_section_info macinfo
;
613 struct dwarf2_section_info macro
;
614 struct dwarf2_section_info str
;
615 struct dwarf2_section_info str_offsets
;
616 /* In the case of a virtual DWO file, these two are unused. */
617 struct dwarf2_section_info info
;
618 std::vector
<dwarf2_section_info
> types
;
621 /* CUs/TUs in DWP/DWO files. */
625 /* Backlink to the containing struct dwo_file. */
626 struct dwo_file
*dwo_file
;
628 /* The "id" that distinguishes this CU/TU.
629 .debug_info calls this "dwo_id", .debug_types calls this "signature".
630 Since signatures came first, we stick with it for consistency. */
633 /* The section this CU/TU lives in, in the DWO file. */
634 struct dwarf2_section_info
*section
;
636 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
637 sect_offset sect_off
;
640 /* For types, offset in the type's DIE of the type defined by this TU. */
641 cu_offset type_offset_in_tu
;
644 /* include/dwarf2.h defines the DWP section codes.
645 It defines a max value but it doesn't define a min value, which we
646 use for error checking, so provide one. */
648 enum dwp_v2_section_ids
653 /* Data for one DWO file.
655 This includes virtual DWO files (a virtual DWO file is a DWO file as it
656 appears in a DWP file). DWP files don't really have DWO files per se -
657 comdat folding of types "loses" the DWO file they came from, and from
658 a high level view DWP files appear to contain a mass of random types.
659 However, to maintain consistency with the non-DWP case we pretend DWP
660 files contain virtual DWO files, and we assign each TU with one virtual
661 DWO file (generally based on the line and abbrev section offsets -
662 a heuristic that seems to work in practice). */
666 dwo_file () = default;
667 DISABLE_COPY_AND_ASSIGN (dwo_file
);
669 /* The DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute.
670 For virtual DWO files the name is constructed from the section offsets
671 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
672 from related CU+TUs. */
673 const char *dwo_name
= nullptr;
675 /* The DW_AT_comp_dir attribute. */
676 const char *comp_dir
= nullptr;
678 /* The bfd, when the file is open. Otherwise this is NULL.
679 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
680 gdb_bfd_ref_ptr dbfd
;
682 /* The sections that make up this DWO file.
683 Remember that for virtual DWO files in DWP V2, these are virtual
684 sections (for lack of a better name). */
685 struct dwo_sections sections
{};
687 /* The CUs in the file.
688 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
689 an extension to handle LLVM's Link Time Optimization output (where
690 multiple source files may be compiled into a single object/dwo pair). */
693 /* Table of TUs in the file.
694 Each element is a struct dwo_unit. */
698 /* These sections are what may appear in a DWP file. */
702 /* These are used by both DWP version 1 and 2. */
703 struct dwarf2_section_info str
;
704 struct dwarf2_section_info cu_index
;
705 struct dwarf2_section_info tu_index
;
707 /* These are only used by DWP version 2 files.
708 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
709 sections are referenced by section number, and are not recorded here.
710 In DWP version 2 there is at most one copy of all these sections, each
711 section being (effectively) comprised of the concatenation of all of the
712 individual sections that exist in the version 1 format.
713 To keep the code simple we treat each of these concatenated pieces as a
714 section itself (a virtual section?). */
715 struct dwarf2_section_info abbrev
;
716 struct dwarf2_section_info info
;
717 struct dwarf2_section_info line
;
718 struct dwarf2_section_info loc
;
719 struct dwarf2_section_info macinfo
;
720 struct dwarf2_section_info macro
;
721 struct dwarf2_section_info str_offsets
;
722 struct dwarf2_section_info types
;
725 /* These sections are what may appear in a virtual DWO file in DWP version 1.
726 A virtual DWO file is a DWO file as it appears in a DWP file. */
728 struct virtual_v1_dwo_sections
730 struct dwarf2_section_info abbrev
;
731 struct dwarf2_section_info line
;
732 struct dwarf2_section_info loc
;
733 struct dwarf2_section_info macinfo
;
734 struct dwarf2_section_info macro
;
735 struct dwarf2_section_info str_offsets
;
736 /* Each DWP hash table entry records one CU or one TU.
737 That is recorded here, and copied to dwo_unit.section. */
738 struct dwarf2_section_info info_or_types
;
741 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
742 In version 2, the sections of the DWO files are concatenated together
743 and stored in one section of that name. Thus each ELF section contains
744 several "virtual" sections. */
746 struct virtual_v2_dwo_sections
748 bfd_size_type abbrev_offset
;
749 bfd_size_type abbrev_size
;
751 bfd_size_type line_offset
;
752 bfd_size_type line_size
;
754 bfd_size_type loc_offset
;
755 bfd_size_type loc_size
;
757 bfd_size_type macinfo_offset
;
758 bfd_size_type macinfo_size
;
760 bfd_size_type macro_offset
;
761 bfd_size_type macro_size
;
763 bfd_size_type str_offsets_offset
;
764 bfd_size_type str_offsets_size
;
766 /* Each DWP hash table entry records one CU or one TU.
767 That is recorded here, and copied to dwo_unit.section. */
768 bfd_size_type info_or_types_offset
;
769 bfd_size_type info_or_types_size
;
772 /* Contents of DWP hash tables. */
774 struct dwp_hash_table
776 uint32_t version
, nr_columns
;
777 uint32_t nr_units
, nr_slots
;
778 const gdb_byte
*hash_table
, *unit_table
;
783 const gdb_byte
*indices
;
787 /* This is indexed by column number and gives the id of the section
789 #define MAX_NR_V2_DWO_SECTIONS \
790 (1 /* .debug_info or .debug_types */ \
791 + 1 /* .debug_abbrev */ \
792 + 1 /* .debug_line */ \
793 + 1 /* .debug_loc */ \
794 + 1 /* .debug_str_offsets */ \
795 + 1 /* .debug_macro or .debug_macinfo */)
796 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
797 const gdb_byte
*offsets
;
798 const gdb_byte
*sizes
;
803 /* Data for one DWP file. */
807 dwp_file (const char *name_
, gdb_bfd_ref_ptr
&&abfd
)
809 dbfd (std::move (abfd
))
813 /* Name of the file. */
816 /* File format version. */
820 gdb_bfd_ref_ptr dbfd
;
822 /* Section info for this file. */
823 struct dwp_sections sections
{};
825 /* Table of CUs in the file. */
826 const struct dwp_hash_table
*cus
= nullptr;
828 /* Table of TUs in the file. */
829 const struct dwp_hash_table
*tus
= nullptr;
831 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
835 /* Table to map ELF section numbers to their sections.
836 This is only needed for the DWP V1 file format. */
837 unsigned int num_sections
= 0;
838 asection
**elf_sections
= nullptr;
841 /* Struct used to pass misc. parameters to read_die_and_children, et
842 al. which are used for both .debug_info and .debug_types dies.
843 All parameters here are unchanging for the life of the call. This
844 struct exists to abstract away the constant parameters of die reading. */
846 struct die_reader_specs
848 /* The bfd of die_section. */
851 /* The CU of the DIE we are parsing. */
852 struct dwarf2_cu
*cu
;
854 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
855 struct dwo_file
*dwo_file
;
857 /* The section the die comes from.
858 This is either .debug_info or .debug_types, or the .dwo variants. */
859 struct dwarf2_section_info
*die_section
;
861 /* die_section->buffer. */
862 const gdb_byte
*buffer
;
864 /* The end of the buffer. */
865 const gdb_byte
*buffer_end
;
867 /* The abbreviation table to use when reading the DIEs. */
868 struct abbrev_table
*abbrev_table
;
871 /* A subclass of die_reader_specs that holds storage and has complex
872 constructor and destructor behavior. */
874 class cutu_reader
: public die_reader_specs
878 cutu_reader (struct dwarf2_per_cu_data
*this_cu
,
879 struct abbrev_table
*abbrev_table
,
883 explicit cutu_reader (struct dwarf2_per_cu_data
*this_cu
,
884 struct dwarf2_cu
*parent_cu
= nullptr,
885 struct dwo_file
*dwo_file
= nullptr);
887 DISABLE_COPY_AND_ASSIGN (cutu_reader
);
889 const gdb_byte
*info_ptr
= nullptr;
890 struct die_info
*comp_unit_die
= nullptr;
891 bool dummy_p
= false;
893 /* Release the new CU, putting it on the chain. This cannot be done
898 void init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
899 int use_existing_cu
);
901 struct dwarf2_per_cu_data
*m_this_cu
;
902 std::unique_ptr
<dwarf2_cu
> m_new_cu
;
904 /* The ordinary abbreviation table. */
905 abbrev_table_up m_abbrev_table_holder
;
907 /* The DWO abbreviation table. */
908 abbrev_table_up m_dwo_abbrev_table
;
911 /* When we construct a partial symbol table entry we only
912 need this much information. */
913 struct partial_die_info
: public allocate_on_obstack
915 partial_die_info (sect_offset sect_off
, struct abbrev_info
*abbrev
);
917 /* Disable assign but still keep copy ctor, which is needed
918 load_partial_dies. */
919 partial_die_info
& operator=(const partial_die_info
& rhs
) = delete;
921 /* Adjust the partial die before generating a symbol for it. This
922 function may set the is_external flag or change the DIE's
924 void fixup (struct dwarf2_cu
*cu
);
926 /* Read a minimal amount of information into the minimal die
928 const gdb_byte
*read (const struct die_reader_specs
*reader
,
929 const struct abbrev_info
&abbrev
,
930 const gdb_byte
*info_ptr
);
932 /* Offset of this DIE. */
933 const sect_offset sect_off
;
935 /* DWARF-2 tag for this DIE. */
936 const ENUM_BITFIELD(dwarf_tag
) tag
: 16;
938 /* Assorted flags describing the data found in this DIE. */
939 const unsigned int has_children
: 1;
941 unsigned int is_external
: 1;
942 unsigned int is_declaration
: 1;
943 unsigned int has_type
: 1;
944 unsigned int has_specification
: 1;
945 unsigned int has_pc_info
: 1;
946 unsigned int may_be_inlined
: 1;
948 /* This DIE has been marked DW_AT_main_subprogram. */
949 unsigned int main_subprogram
: 1;
951 /* Flag set if the SCOPE field of this structure has been
953 unsigned int scope_set
: 1;
955 /* Flag set if the DIE has a byte_size attribute. */
956 unsigned int has_byte_size
: 1;
958 /* Flag set if the DIE has a DW_AT_const_value attribute. */
959 unsigned int has_const_value
: 1;
961 /* Flag set if any of the DIE's children are template arguments. */
962 unsigned int has_template_arguments
: 1;
964 /* Flag set if fixup has been called on this die. */
965 unsigned int fixup_called
: 1;
967 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
968 unsigned int is_dwz
: 1;
970 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
971 unsigned int spec_is_dwz
: 1;
973 /* The name of this DIE. Normally the value of DW_AT_name, but
974 sometimes a default name for unnamed DIEs. */
975 const char *name
= nullptr;
977 /* The linkage name, if present. */
978 const char *linkage_name
= nullptr;
980 /* The scope to prepend to our children. This is generally
981 allocated on the comp_unit_obstack, so will disappear
982 when this compilation unit leaves the cache. */
983 const char *scope
= nullptr;
985 /* Some data associated with the partial DIE. The tag determines
986 which field is live. */
989 /* The location description associated with this DIE, if any. */
990 struct dwarf_block
*locdesc
;
991 /* The offset of an import, for DW_TAG_imported_unit. */
992 sect_offset sect_off
;
995 /* If HAS_PC_INFO, the PC range associated with this DIE. */
997 CORE_ADDR highpc
= 0;
999 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1000 DW_AT_sibling, if any. */
1001 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1002 could return DW_AT_sibling values to its caller load_partial_dies. */
1003 const gdb_byte
*sibling
= nullptr;
1005 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1006 DW_AT_specification (or DW_AT_abstract_origin or
1007 DW_AT_extension). */
1008 sect_offset spec_offset
{};
1010 /* Pointers to this DIE's parent, first child, and next sibling,
1012 struct partial_die_info
*die_parent
= nullptr;
1013 struct partial_die_info
*die_child
= nullptr;
1014 struct partial_die_info
*die_sibling
= nullptr;
1016 friend struct partial_die_info
*
1017 dwarf2_cu::find_partial_die (sect_offset sect_off
);
1020 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1021 partial_die_info (sect_offset sect_off
)
1022 : partial_die_info (sect_off
, DW_TAG_padding
, 0)
1026 partial_die_info (sect_offset sect_off_
, enum dwarf_tag tag_
,
1028 : sect_off (sect_off_
), tag (tag_
), has_children (has_children_
)
1033 has_specification
= 0;
1036 main_subprogram
= 0;
1039 has_const_value
= 0;
1040 has_template_arguments
= 0;
1047 /* This data structure holds a complete die structure. */
1050 /* DWARF-2 tag for this DIE. */
1051 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1053 /* Number of attributes */
1054 unsigned char num_attrs
;
1056 /* True if we're presently building the full type name for the
1057 type derived from this DIE. */
1058 unsigned char building_fullname
: 1;
1060 /* True if this die is in process. PR 16581. */
1061 unsigned char in_process
: 1;
1063 /* True if this DIE has children. */
1064 unsigned char has_children
: 1;
1067 unsigned int abbrev
;
1069 /* Offset in .debug_info or .debug_types section. */
1070 sect_offset sect_off
;
1072 /* The dies in a compilation unit form an n-ary tree. PARENT
1073 points to this die's parent; CHILD points to the first child of
1074 this node; and all the children of a given node are chained
1075 together via their SIBLING fields. */
1076 struct die_info
*child
; /* Its first child, if any. */
1077 struct die_info
*sibling
; /* Its next sibling, if any. */
1078 struct die_info
*parent
; /* Its parent, if any. */
1080 /* An array of attributes, with NUM_ATTRS elements. There may be
1081 zero, but it's not common and zero-sized arrays are not
1082 sufficiently portable C. */
1083 struct attribute attrs
[1];
1086 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1087 but this would require a corresponding change in unpack_field_as_long
1089 static int bits_per_byte
= 8;
1091 /* When reading a variant or variant part, we track a bit more
1092 information about the field, and store it in an object of this
1095 struct variant_field
1097 /* If we see a DW_TAG_variant, then this will be the discriminant
1099 ULONGEST discriminant_value
;
1100 /* If we see a DW_TAG_variant, then this will be set if this is the
1102 bool default_branch
;
1103 /* While reading a DW_TAG_variant_part, this will be set if this
1104 field is the discriminant. */
1105 bool is_discriminant
;
1110 int accessibility
= 0;
1112 /* Extra information to describe a variant or variant part. */
1113 struct variant_field variant
{};
1114 struct field field
{};
1119 const char *name
= nullptr;
1120 std::vector
<struct fn_field
> fnfields
;
1123 /* The routines that read and process dies for a C struct or C++ class
1124 pass lists of data member fields and lists of member function fields
1125 in an instance of a field_info structure, as defined below. */
1128 /* List of data member and baseclasses fields. */
1129 std::vector
<struct nextfield
> fields
;
1130 std::vector
<struct nextfield
> baseclasses
;
1132 /* Set if the accessibility of one of the fields is not public. */
1133 int non_public_fields
= 0;
1135 /* Member function fieldlist array, contains name of possibly overloaded
1136 member function, number of overloaded member functions and a pointer
1137 to the head of the member function field chain. */
1138 std::vector
<struct fnfieldlist
> fnfieldlists
;
1140 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1141 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1142 std::vector
<struct decl_field
> typedef_field_list
;
1144 /* Nested types defined by this class and the number of elements in this
1146 std::vector
<struct decl_field
> nested_types_list
;
1148 /* Return the total number of fields (including baseclasses). */
1149 int nfields () const
1151 return fields
.size () + baseclasses
.size ();
1155 /* Loaded secondary compilation units are kept in memory until they
1156 have not been referenced for the processing of this many
1157 compilation units. Set this to zero to disable caching. Cache
1158 sizes of up to at least twenty will improve startup time for
1159 typical inter-CU-reference binaries, at an obvious memory cost. */
1160 static int dwarf_max_cache_age
= 5;
1162 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1163 struct cmd_list_element
*c
, const char *value
)
1165 fprintf_filtered (file
, _("The upper bound on the age of cached "
1166 "DWARF compilation units is %s.\n"),
1170 /* local function prototypes */
1172 static void dwarf2_find_base_address (struct die_info
*die
,
1173 struct dwarf2_cu
*cu
);
1175 static dwarf2_psymtab
*create_partial_symtab
1176 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1178 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1179 const gdb_byte
*info_ptr
,
1180 struct die_info
*type_unit_die
);
1182 static void dwarf2_build_psymtabs_hard
1183 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1185 static void scan_partial_symbols (struct partial_die_info
*,
1186 CORE_ADDR
*, CORE_ADDR
*,
1187 int, struct dwarf2_cu
*);
1189 static void add_partial_symbol (struct partial_die_info
*,
1190 struct dwarf2_cu
*);
1192 static void add_partial_namespace (struct partial_die_info
*pdi
,
1193 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1194 int set_addrmap
, struct dwarf2_cu
*cu
);
1196 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1197 CORE_ADDR
*highpc
, int set_addrmap
,
1198 struct dwarf2_cu
*cu
);
1200 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1201 struct dwarf2_cu
*cu
);
1203 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1204 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1205 int need_pc
, struct dwarf2_cu
*cu
);
1207 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1209 static struct partial_die_info
*load_partial_dies
1210 (const struct die_reader_specs
*, const gdb_byte
*, int);
1212 /* A pair of partial_die_info and compilation unit. */
1213 struct cu_partial_die_info
1215 /* The compilation unit of the partial_die_info. */
1216 struct dwarf2_cu
*cu
;
1217 /* A partial_die_info. */
1218 struct partial_die_info
*pdi
;
1220 cu_partial_die_info (struct dwarf2_cu
*cu
, struct partial_die_info
*pdi
)
1226 cu_partial_die_info () = delete;
1229 static const struct cu_partial_die_info
find_partial_die (sect_offset
, int,
1230 struct dwarf2_cu
*);
1232 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1233 struct attribute
*, struct attr_abbrev
*,
1234 const gdb_byte
*, bool *need_reprocess
);
1236 static void read_attribute_reprocess (const struct die_reader_specs
*reader
,
1237 struct attribute
*attr
);
1239 static CORE_ADDR
read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
);
1241 static LONGEST read_checked_initial_length_and_offset
1242 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1243 unsigned int *, unsigned int *);
1245 static sect_offset read_abbrev_offset
1246 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1247 struct dwarf2_section_info
*, sect_offset
);
1249 static const char *read_indirect_string
1250 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*, const gdb_byte
*,
1251 const struct comp_unit_head
*, unsigned int *);
1253 static const char *read_indirect_line_string
1254 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*, const gdb_byte
*,
1255 const struct comp_unit_head
*, unsigned int *);
1257 static const char *read_indirect_string_at_offset
1258 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
1259 LONGEST str_offset
);
1261 static const char *read_indirect_string_from_dwz
1262 (struct objfile
*objfile
, struct dwz_file
*, LONGEST
);
1264 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1268 static const char *read_dwo_str_index (const struct die_reader_specs
*reader
,
1269 ULONGEST str_index
);
1271 static const char *read_stub_str_index (struct dwarf2_cu
*cu
,
1272 ULONGEST str_index
);
1274 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1276 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1277 struct dwarf2_cu
*);
1279 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1282 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1283 struct dwarf2_cu
*cu
);
1285 static const char *dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
1287 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1288 struct dwarf2_cu
*cu
);
1290 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1292 static struct die_info
*die_specification (struct die_info
*die
,
1293 struct dwarf2_cu
**);
1295 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1296 struct dwarf2_cu
*cu
);
1298 static void dwarf_decode_lines (struct line_header
*, const char *,
1299 struct dwarf2_cu
*, dwarf2_psymtab
*,
1300 CORE_ADDR
, int decode_mapping
);
1302 static void dwarf2_start_subfile (struct dwarf2_cu
*, const char *,
1305 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1306 struct dwarf2_cu
*, struct symbol
* = NULL
);
1308 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1309 struct dwarf2_cu
*);
1311 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1314 struct obstack
*obstack
,
1315 struct dwarf2_cu
*cu
, LONGEST
*value
,
1316 const gdb_byte
**bytes
,
1317 struct dwarf2_locexpr_baton
**baton
);
1319 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1321 static int need_gnat_info (struct dwarf2_cu
*);
1323 static struct type
*die_descriptive_type (struct die_info
*,
1324 struct dwarf2_cu
*);
1326 static void set_descriptive_type (struct type
*, struct die_info
*,
1327 struct dwarf2_cu
*);
1329 static struct type
*die_containing_type (struct die_info
*,
1330 struct dwarf2_cu
*);
1332 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1333 struct dwarf2_cu
*);
1335 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1337 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1339 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1341 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1342 const char *suffix
, int physname
,
1343 struct dwarf2_cu
*cu
);
1345 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1347 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1349 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1351 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1353 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1355 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1357 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1358 struct dwarf2_cu
*, dwarf2_psymtab
*);
1360 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1361 values. Keep the items ordered with increasing constraints compliance. */
1364 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1365 PC_BOUNDS_NOT_PRESENT
,
1367 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1368 were present but they do not form a valid range of PC addresses. */
1371 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1374 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1378 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1379 CORE_ADDR
*, CORE_ADDR
*,
1383 static void get_scope_pc_bounds (struct die_info
*,
1384 CORE_ADDR
*, CORE_ADDR
*,
1385 struct dwarf2_cu
*);
1387 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1388 CORE_ADDR
, struct dwarf2_cu
*);
1390 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1391 struct dwarf2_cu
*);
1393 static void dwarf2_attach_fields_to_type (struct field_info
*,
1394 struct type
*, struct dwarf2_cu
*);
1396 static void dwarf2_add_member_fn (struct field_info
*,
1397 struct die_info
*, struct type
*,
1398 struct dwarf2_cu
*);
1400 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1402 struct dwarf2_cu
*);
1404 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1406 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1408 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1410 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1412 static struct using_direct
**using_directives (struct dwarf2_cu
*cu
);
1414 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1416 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1418 static struct type
*read_module_type (struct die_info
*die
,
1419 struct dwarf2_cu
*cu
);
1421 static const char *namespace_name (struct die_info
*die
,
1422 int *is_anonymous
, struct dwarf2_cu
*);
1424 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1426 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1428 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1429 struct dwarf2_cu
*);
1431 static struct die_info
*read_die_and_siblings_1
1432 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1435 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1436 const gdb_byte
*info_ptr
,
1437 const gdb_byte
**new_info_ptr
,
1438 struct die_info
*parent
);
1440 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1441 struct die_info
**, const gdb_byte
*,
1444 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1445 struct die_info
**, const gdb_byte
*);
1447 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1449 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1452 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1454 static const char *dwarf2_full_name (const char *name
,
1455 struct die_info
*die
,
1456 struct dwarf2_cu
*cu
);
1458 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1459 struct dwarf2_cu
*cu
);
1461 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1462 struct dwarf2_cu
**);
1464 static const char *dwarf_tag_name (unsigned int);
1466 static const char *dwarf_attr_name (unsigned int);
1468 static const char *dwarf_form_name (unsigned int);
1470 static const char *dwarf_bool_name (unsigned int);
1472 static const char *dwarf_type_encoding_name (unsigned int);
1474 static struct die_info
*sibling_die (struct die_info
*);
1476 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1478 static void dump_die_for_error (struct die_info
*);
1480 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1483 /*static*/ void dump_die (struct die_info
*, int max_level
);
1485 static void store_in_ref_table (struct die_info
*,
1486 struct dwarf2_cu
*);
1488 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
1490 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
1492 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1493 const struct attribute
*,
1494 struct dwarf2_cu
**);
1496 static struct die_info
*follow_die_ref (struct die_info
*,
1497 const struct attribute
*,
1498 struct dwarf2_cu
**);
1500 static struct die_info
*follow_die_sig (struct die_info
*,
1501 const struct attribute
*,
1502 struct dwarf2_cu
**);
1504 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1505 struct dwarf2_cu
*);
1507 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1508 const struct attribute
*,
1509 struct dwarf2_cu
*);
1511 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1513 static void read_signatured_type (struct signatured_type
*);
1515 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1516 struct die_info
*die
, struct dwarf2_cu
*cu
,
1517 struct dynamic_prop
*prop
, struct type
*type
);
1519 /* memory allocation interface */
1521 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1523 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1525 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1527 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1528 struct dwarf2_loclist_baton
*baton
,
1529 const struct attribute
*attr
);
1531 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1533 struct dwarf2_cu
*cu
,
1536 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1537 const gdb_byte
*info_ptr
,
1538 struct abbrev_info
*abbrev
);
1540 static hashval_t
partial_die_hash (const void *item
);
1542 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1544 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1545 (sect_offset sect_off
, unsigned int offset_in_dwz
,
1546 struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1548 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1549 struct die_info
*comp_unit_die
,
1550 enum language pretend_language
);
1552 static void age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1554 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1556 static struct type
*set_die_type (struct die_info
*, struct type
*,
1557 struct dwarf2_cu
*);
1559 static void create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1561 static int create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1563 static void load_full_comp_unit (struct dwarf2_per_cu_data
*, bool,
1566 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1569 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1572 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1573 struct dwarf2_per_cu_data
*);
1575 static void dwarf2_mark (struct dwarf2_cu
*);
1577 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1579 static struct type
*get_die_type_at_offset (sect_offset
,
1580 struct dwarf2_per_cu_data
*);
1582 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1584 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1585 enum language pretend_language
);
1587 static void process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1589 /* Class, the destructor of which frees all allocated queue entries. This
1590 will only have work to do if an error was thrown while processing the
1591 dwarf. If no error was thrown then the queue entries should have all
1592 been processed, and freed, as we went along. */
1594 class dwarf2_queue_guard
1597 explicit dwarf2_queue_guard (dwarf2_per_objfile
*per_objfile
)
1598 : m_per_objfile (per_objfile
)
1602 /* Free any entries remaining on the queue. There should only be
1603 entries left if we hit an error while processing the dwarf. */
1604 ~dwarf2_queue_guard ()
1606 /* Ensure that no memory is allocated by the queue. */
1607 std::queue
<dwarf2_queue_item
> empty
;
1608 std::swap (m_per_objfile
->queue
, empty
);
1611 DISABLE_COPY_AND_ASSIGN (dwarf2_queue_guard
);
1614 dwarf2_per_objfile
*m_per_objfile
;
1617 dwarf2_queue_item::~dwarf2_queue_item ()
1619 /* Anything still marked queued is likely to be in an
1620 inconsistent state, so discard it. */
1623 if (per_cu
->cu
!= NULL
)
1624 free_one_cached_comp_unit (per_cu
);
1629 /* The return type of find_file_and_directory. Note, the enclosed
1630 string pointers are only valid while this object is valid. */
1632 struct file_and_directory
1634 /* The filename. This is never NULL. */
1637 /* The compilation directory. NULL if not known. If we needed to
1638 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1639 points directly to the DW_AT_comp_dir string attribute owned by
1640 the obstack that owns the DIE. */
1641 const char *comp_dir
;
1643 /* If we needed to build a new string for comp_dir, this is what
1644 owns the storage. */
1645 std::string comp_dir_storage
;
1648 static file_and_directory
find_file_and_directory (struct die_info
*die
,
1649 struct dwarf2_cu
*cu
);
1651 static htab_up
allocate_signatured_type_table ();
1653 static htab_up
allocate_dwo_unit_table ();
1655 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1656 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1657 struct dwp_file
*dwp_file
, const char *comp_dir
,
1658 ULONGEST signature
, int is_debug_types
);
1660 static struct dwp_file
*get_dwp_file
1661 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1663 static struct dwo_unit
*lookup_dwo_comp_unit
1664 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
1666 static struct dwo_unit
*lookup_dwo_type_unit
1667 (struct signatured_type
*, const char *, const char *);
1669 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
1671 /* A unique pointer to a dwo_file. */
1673 typedef std::unique_ptr
<struct dwo_file
> dwo_file_up
;
1675 static void process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1677 static void check_producer (struct dwarf2_cu
*cu
);
1679 static void free_line_header_voidp (void *arg
);
1681 /* Various complaints about symbol reading that don't abort the process. */
1684 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1686 complaint (_("statement list doesn't fit in .debug_line section"));
1690 dwarf2_debug_line_missing_file_complaint (void)
1692 complaint (_(".debug_line section has line data without a file"));
1696 dwarf2_debug_line_missing_end_sequence_complaint (void)
1698 complaint (_(".debug_line section has line "
1699 "program sequence without an end"));
1703 dwarf2_complex_location_expr_complaint (void)
1705 complaint (_("location expression too complex"));
1709 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1712 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
1717 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
1719 complaint (_("debug info runs off end of %s section"
1721 section
->get_name (),
1722 section
->get_file_name ());
1726 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
1728 complaint (_("macro debug info contains a "
1729 "malformed macro definition:\n`%s'"),
1734 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1736 complaint (_("invalid attribute class or form for '%s' in '%s'"),
1740 /* Hash function for line_header_hash. */
1743 line_header_hash (const struct line_header
*ofs
)
1745 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
1748 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1751 line_header_hash_voidp (const void *item
)
1753 const struct line_header
*ofs
= (const struct line_header
*) item
;
1755 return line_header_hash (ofs
);
1758 /* Equality function for line_header_hash. */
1761 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
1763 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
1764 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
1766 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
1767 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
1772 /* See declaration. */
1774 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile
*objfile_
,
1775 const dwarf2_debug_sections
*names
,
1777 : objfile (objfile_
),
1778 can_copy (can_copy_
)
1781 names
= &dwarf2_elf_names
;
1783 bfd
*obfd
= objfile
->obfd
;
1785 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
1786 locate_sections (obfd
, sec
, *names
);
1789 dwarf2_per_objfile::~dwarf2_per_objfile ()
1791 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
1792 free_cached_comp_units ();
1794 for (dwarf2_per_cu_data
*per_cu
: all_comp_units
)
1795 per_cu
->imported_symtabs_free ();
1797 for (signatured_type
*sig_type
: all_type_units
)
1798 sig_type
->per_cu
.imported_symtabs_free ();
1800 /* Everything else should be on the objfile obstack. */
1803 /* See declaration. */
1806 dwarf2_per_objfile::free_cached_comp_units ()
1808 dwarf2_per_cu_data
*per_cu
= read_in_chain
;
1809 dwarf2_per_cu_data
**last_chain
= &read_in_chain
;
1810 while (per_cu
!= NULL
)
1812 dwarf2_per_cu_data
*next_cu
= per_cu
->cu
->read_in_chain
;
1815 *last_chain
= next_cu
;
1820 /* A helper class that calls free_cached_comp_units on
1823 class free_cached_comp_units
1827 explicit free_cached_comp_units (dwarf2_per_objfile
*per_objfile
)
1828 : m_per_objfile (per_objfile
)
1832 ~free_cached_comp_units ()
1834 m_per_objfile
->free_cached_comp_units ();
1837 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units
);
1841 dwarf2_per_objfile
*m_per_objfile
;
1844 /* Try to locate the sections we need for DWARF 2 debugging
1845 information and return true if we have enough to do something.
1846 NAMES points to the dwarf2 section names, or is NULL if the standard
1847 ELF names are used. CAN_COPY is true for formats where symbol
1848 interposition is possible and so symbol values must follow copy
1849 relocation rules. */
1852 dwarf2_has_info (struct objfile
*objfile
,
1853 const struct dwarf2_debug_sections
*names
,
1856 if (objfile
->flags
& OBJF_READNEVER
)
1859 struct dwarf2_per_objfile
*dwarf2_per_objfile
1860 = get_dwarf2_per_objfile (objfile
);
1862 if (dwarf2_per_objfile
== NULL
)
1863 dwarf2_per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
,
1867 return (!dwarf2_per_objfile
->info
.is_virtual
1868 && dwarf2_per_objfile
->info
.s
.section
!= NULL
1869 && !dwarf2_per_objfile
->abbrev
.is_virtual
1870 && dwarf2_per_objfile
->abbrev
.s
.section
!= NULL
);
1873 /* When loading sections, we look either for uncompressed section or for
1874 compressed section names. */
1877 section_is_p (const char *section_name
,
1878 const struct dwarf2_section_names
*names
)
1880 if (names
->normal
!= NULL
1881 && strcmp (section_name
, names
->normal
) == 0)
1883 if (names
->compressed
!= NULL
1884 && strcmp (section_name
, names
->compressed
) == 0)
1889 /* See declaration. */
1892 dwarf2_per_objfile::locate_sections (bfd
*abfd
, asection
*sectp
,
1893 const dwarf2_debug_sections
&names
)
1895 flagword aflag
= bfd_section_flags (sectp
);
1897 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
1900 else if (elf_section_data (sectp
)->this_hdr
.sh_size
1901 > bfd_get_file_size (abfd
))
1903 bfd_size_type size
= elf_section_data (sectp
)->this_hdr
.sh_size
;
1904 warning (_("Discarding section %s which has a section size (%s"
1905 ") larger than the file size [in module %s]"),
1906 bfd_section_name (sectp
), phex_nz (size
, sizeof (size
)),
1907 bfd_get_filename (abfd
));
1909 else if (section_is_p (sectp
->name
, &names
.info
))
1911 this->info
.s
.section
= sectp
;
1912 this->info
.size
= bfd_section_size (sectp
);
1914 else if (section_is_p (sectp
->name
, &names
.abbrev
))
1916 this->abbrev
.s
.section
= sectp
;
1917 this->abbrev
.size
= bfd_section_size (sectp
);
1919 else if (section_is_p (sectp
->name
, &names
.line
))
1921 this->line
.s
.section
= sectp
;
1922 this->line
.size
= bfd_section_size (sectp
);
1924 else if (section_is_p (sectp
->name
, &names
.loc
))
1926 this->loc
.s
.section
= sectp
;
1927 this->loc
.size
= bfd_section_size (sectp
);
1929 else if (section_is_p (sectp
->name
, &names
.loclists
))
1931 this->loclists
.s
.section
= sectp
;
1932 this->loclists
.size
= bfd_section_size (sectp
);
1934 else if (section_is_p (sectp
->name
, &names
.macinfo
))
1936 this->macinfo
.s
.section
= sectp
;
1937 this->macinfo
.size
= bfd_section_size (sectp
);
1939 else if (section_is_p (sectp
->name
, &names
.macro
))
1941 this->macro
.s
.section
= sectp
;
1942 this->macro
.size
= bfd_section_size (sectp
);
1944 else if (section_is_p (sectp
->name
, &names
.str
))
1946 this->str
.s
.section
= sectp
;
1947 this->str
.size
= bfd_section_size (sectp
);
1949 else if (section_is_p (sectp
->name
, &names
.str_offsets
))
1951 this->str_offsets
.s
.section
= sectp
;
1952 this->str_offsets
.size
= bfd_section_size (sectp
);
1954 else if (section_is_p (sectp
->name
, &names
.line_str
))
1956 this->line_str
.s
.section
= sectp
;
1957 this->line_str
.size
= bfd_section_size (sectp
);
1959 else if (section_is_p (sectp
->name
, &names
.addr
))
1961 this->addr
.s
.section
= sectp
;
1962 this->addr
.size
= bfd_section_size (sectp
);
1964 else if (section_is_p (sectp
->name
, &names
.frame
))
1966 this->frame
.s
.section
= sectp
;
1967 this->frame
.size
= bfd_section_size (sectp
);
1969 else if (section_is_p (sectp
->name
, &names
.eh_frame
))
1971 this->eh_frame
.s
.section
= sectp
;
1972 this->eh_frame
.size
= bfd_section_size (sectp
);
1974 else if (section_is_p (sectp
->name
, &names
.ranges
))
1976 this->ranges
.s
.section
= sectp
;
1977 this->ranges
.size
= bfd_section_size (sectp
);
1979 else if (section_is_p (sectp
->name
, &names
.rnglists
))
1981 this->rnglists
.s
.section
= sectp
;
1982 this->rnglists
.size
= bfd_section_size (sectp
);
1984 else if (section_is_p (sectp
->name
, &names
.types
))
1986 struct dwarf2_section_info type_section
;
1988 memset (&type_section
, 0, sizeof (type_section
));
1989 type_section
.s
.section
= sectp
;
1990 type_section
.size
= bfd_section_size (sectp
);
1992 this->types
.push_back (type_section
);
1994 else if (section_is_p (sectp
->name
, &names
.gdb_index
))
1996 this->gdb_index
.s
.section
= sectp
;
1997 this->gdb_index
.size
= bfd_section_size (sectp
);
1999 else if (section_is_p (sectp
->name
, &names
.debug_names
))
2001 this->debug_names
.s
.section
= sectp
;
2002 this->debug_names
.size
= bfd_section_size (sectp
);
2004 else if (section_is_p (sectp
->name
, &names
.debug_aranges
))
2006 this->debug_aranges
.s
.section
= sectp
;
2007 this->debug_aranges
.size
= bfd_section_size (sectp
);
2010 if ((bfd_section_flags (sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2011 && bfd_section_vma (sectp
) == 0)
2012 this->has_section_at_zero
= true;
2015 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2019 dwarf2_get_section_info (struct objfile
*objfile
,
2020 enum dwarf2_section_enum sect
,
2021 asection
**sectp
, const gdb_byte
**bufp
,
2022 bfd_size_type
*sizep
)
2024 struct dwarf2_per_objfile
*data
= dwarf2_objfile_data_key
.get (objfile
);
2025 struct dwarf2_section_info
*info
;
2027 /* We may see an objfile without any DWARF, in which case we just
2038 case DWARF2_DEBUG_FRAME
:
2039 info
= &data
->frame
;
2041 case DWARF2_EH_FRAME
:
2042 info
= &data
->eh_frame
;
2045 gdb_assert_not_reached ("unexpected section");
2048 info
->read (objfile
);
2050 *sectp
= info
->get_bfd_section ();
2051 *bufp
= info
->buffer
;
2052 *sizep
= info
->size
;
2055 /* A helper function to find the sections for a .dwz file. */
2058 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2060 struct dwz_file
*dwz_file
= (struct dwz_file
*) arg
;
2062 /* Note that we only support the standard ELF names, because .dwz
2063 is ELF-only (at the time of writing). */
2064 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2066 dwz_file
->abbrev
.s
.section
= sectp
;
2067 dwz_file
->abbrev
.size
= bfd_section_size (sectp
);
2069 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2071 dwz_file
->info
.s
.section
= sectp
;
2072 dwz_file
->info
.size
= bfd_section_size (sectp
);
2074 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2076 dwz_file
->str
.s
.section
= sectp
;
2077 dwz_file
->str
.size
= bfd_section_size (sectp
);
2079 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2081 dwz_file
->line
.s
.section
= sectp
;
2082 dwz_file
->line
.size
= bfd_section_size (sectp
);
2084 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2086 dwz_file
->macro
.s
.section
= sectp
;
2087 dwz_file
->macro
.size
= bfd_section_size (sectp
);
2089 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2091 dwz_file
->gdb_index
.s
.section
= sectp
;
2092 dwz_file
->gdb_index
.size
= bfd_section_size (sectp
);
2094 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.debug_names
))
2096 dwz_file
->debug_names
.s
.section
= sectp
;
2097 dwz_file
->debug_names
.size
= bfd_section_size (sectp
);
2101 /* See dwarf2read.h. */
2104 dwarf2_get_dwz_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
2106 const char *filename
;
2107 bfd_size_type buildid_len_arg
;
2111 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2112 return dwarf2_per_objfile
->dwz_file
.get ();
2114 bfd_set_error (bfd_error_no_error
);
2115 gdb::unique_xmalloc_ptr
<char> data
2116 (bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2117 &buildid_len_arg
, &buildid
));
2120 if (bfd_get_error () == bfd_error_no_error
)
2122 error (_("could not read '.gnu_debugaltlink' section: %s"),
2123 bfd_errmsg (bfd_get_error ()));
2126 gdb::unique_xmalloc_ptr
<bfd_byte
> buildid_holder (buildid
);
2128 buildid_len
= (size_t) buildid_len_arg
;
2130 filename
= data
.get ();
2132 std::string abs_storage
;
2133 if (!IS_ABSOLUTE_PATH (filename
))
2135 gdb::unique_xmalloc_ptr
<char> abs
2136 = gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2138 abs_storage
= ldirname (abs
.get ()) + SLASH_STRING
+ filename
;
2139 filename
= abs_storage
.c_str ();
2142 /* First try the file name given in the section. If that doesn't
2143 work, try to use the build-id instead. */
2144 gdb_bfd_ref_ptr
dwz_bfd (gdb_bfd_open (filename
, gnutarget
, -1));
2145 if (dwz_bfd
!= NULL
)
2147 if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2148 dwz_bfd
.reset (nullptr);
2151 if (dwz_bfd
== NULL
)
2152 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2154 if (dwz_bfd
== nullptr)
2156 gdb::unique_xmalloc_ptr
<char> alt_filename
;
2157 const char *origname
= dwarf2_per_objfile
->objfile
->original_name
;
2159 scoped_fd
fd (debuginfod_debuginfo_query (buildid
,
2166 /* File successfully retrieved from server. */
2167 dwz_bfd
= gdb_bfd_open (alt_filename
.get (), gnutarget
, -1);
2169 if (dwz_bfd
== nullptr)
2170 warning (_("File \"%s\" from debuginfod cannot be opened as bfd"),
2171 alt_filename
.get ());
2172 else if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2173 dwz_bfd
.reset (nullptr);
2177 if (dwz_bfd
== NULL
)
2178 error (_("could not find '.gnu_debugaltlink' file for %s"),
2179 objfile_name (dwarf2_per_objfile
->objfile
));
2181 std::unique_ptr
<struct dwz_file
> result
2182 (new struct dwz_file (std::move (dwz_bfd
)));
2184 bfd_map_over_sections (result
->dwz_bfd
.get (), locate_dwz_sections
,
2187 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
,
2188 result
->dwz_bfd
.get ());
2189 dwarf2_per_objfile
->dwz_file
= std::move (result
);
2190 return dwarf2_per_objfile
->dwz_file
.get ();
2193 /* DWARF quick_symbols_functions support. */
2195 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2196 unique line tables, so we maintain a separate table of all .debug_line
2197 derived entries to support the sharing.
2198 All the quick functions need is the list of file names. We discard the
2199 line_header when we're done and don't need to record it here. */
2200 struct quick_file_names
2202 /* The data used to construct the hash key. */
2203 struct stmt_list_hash hash
;
2205 /* The number of entries in file_names, real_names. */
2206 unsigned int num_file_names
;
2208 /* The file names from the line table, after being run through
2210 const char **file_names
;
2212 /* The file names from the line table after being run through
2213 gdb_realpath. These are computed lazily. */
2214 const char **real_names
;
2217 /* When using the index (and thus not using psymtabs), each CU has an
2218 object of this type. This is used to hold information needed by
2219 the various "quick" methods. */
2220 struct dwarf2_per_cu_quick_data
2222 /* The file table. This can be NULL if there was no file table
2223 or it's currently not read in.
2224 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2225 struct quick_file_names
*file_names
;
2227 /* The corresponding symbol table. This is NULL if symbols for this
2228 CU have not yet been read. */
2229 struct compunit_symtab
*compunit_symtab
;
2231 /* A temporary mark bit used when iterating over all CUs in
2232 expand_symtabs_matching. */
2233 unsigned int mark
: 1;
2235 /* True if we've tried to read the file table and found there isn't one.
2236 There will be no point in trying to read it again next time. */
2237 unsigned int no_file_data
: 1;
2240 /* Utility hash function for a stmt_list_hash. */
2243 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2247 if (stmt_list_hash
->dwo_unit
!= NULL
)
2248 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2249 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2253 /* Utility equality function for a stmt_list_hash. */
2256 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2257 const struct stmt_list_hash
*rhs
)
2259 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2261 if (lhs
->dwo_unit
!= NULL
2262 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2265 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2268 /* Hash function for a quick_file_names. */
2271 hash_file_name_entry (const void *e
)
2273 const struct quick_file_names
*file_data
2274 = (const struct quick_file_names
*) e
;
2276 return hash_stmt_list_entry (&file_data
->hash
);
2279 /* Equality function for a quick_file_names. */
2282 eq_file_name_entry (const void *a
, const void *b
)
2284 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2285 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2287 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2290 /* Delete function for a quick_file_names. */
2293 delete_file_name_entry (void *e
)
2295 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2298 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2300 xfree ((void*) file_data
->file_names
[i
]);
2301 if (file_data
->real_names
)
2302 xfree ((void*) file_data
->real_names
[i
]);
2305 /* The space for the struct itself lives on objfile_obstack,
2306 so we don't free it here. */
2309 /* Create a quick_file_names hash table. */
2312 create_quick_file_names_table (unsigned int nr_initial_entries
)
2314 return htab_up (htab_create_alloc (nr_initial_entries
,
2315 hash_file_name_entry
, eq_file_name_entry
,
2316 delete_file_name_entry
, xcalloc
, xfree
));
2319 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2320 have to be created afterwards. You should call age_cached_comp_units after
2321 processing PER_CU->CU. dw2_setup must have been already called. */
2324 load_cu (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2326 if (per_cu
->is_debug_types
)
2327 load_full_type_unit (per_cu
);
2329 load_full_comp_unit (per_cu
, skip_partial
, language_minimal
);
2331 if (per_cu
->cu
== NULL
)
2332 return; /* Dummy CU. */
2334 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2337 /* Read in the symbols for PER_CU. */
2340 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2342 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
2344 /* Skip type_unit_groups, reading the type units they contain
2345 is handled elsewhere. */
2346 if (per_cu
->type_unit_group_p ())
2349 /* The destructor of dwarf2_queue_guard frees any entries left on
2350 the queue. After this point we're guaranteed to leave this function
2351 with the dwarf queue empty. */
2352 dwarf2_queue_guard
q_guard (dwarf2_per_objfile
);
2354 if (dwarf2_per_objfile
->using_index
2355 ? per_cu
->v
.quick
->compunit_symtab
== NULL
2356 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2358 queue_comp_unit (per_cu
, language_minimal
);
2359 load_cu (per_cu
, skip_partial
);
2361 /* If we just loaded a CU from a DWO, and we're working with an index
2362 that may badly handle TUs, load all the TUs in that DWO as well.
2363 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2364 if (!per_cu
->is_debug_types
2365 && per_cu
->cu
!= NULL
2366 && per_cu
->cu
->dwo_unit
!= NULL
2367 && dwarf2_per_objfile
->index_table
!= NULL
2368 && dwarf2_per_objfile
->index_table
->version
<= 7
2369 /* DWP files aren't supported yet. */
2370 && get_dwp_file (dwarf2_per_objfile
) == NULL
)
2371 queue_and_load_all_dwo_tus (per_cu
);
2374 process_queue (dwarf2_per_objfile
);
2376 /* Age the cache, releasing compilation units that have not
2377 been used recently. */
2378 age_cached_comp_units (dwarf2_per_objfile
);
2381 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2382 the objfile from which this CU came. Returns the resulting symbol
2385 static struct compunit_symtab
*
2386 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2388 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
2390 gdb_assert (dwarf2_per_objfile
->using_index
);
2391 if (!per_cu
->v
.quick
->compunit_symtab
)
2393 free_cached_comp_units
freer (dwarf2_per_objfile
);
2394 scoped_restore decrementer
= increment_reading_symtab ();
2395 dw2_do_instantiate_symtab (per_cu
, skip_partial
);
2396 process_cu_includes (dwarf2_per_objfile
);
2399 return per_cu
->v
.quick
->compunit_symtab
;
2402 /* See declaration. */
2404 dwarf2_per_cu_data
*
2405 dwarf2_per_objfile::get_cutu (int index
)
2407 if (index
>= this->all_comp_units
.size ())
2409 index
-= this->all_comp_units
.size ();
2410 gdb_assert (index
< this->all_type_units
.size ());
2411 return &this->all_type_units
[index
]->per_cu
;
2414 return this->all_comp_units
[index
];
2417 /* See declaration. */
2419 dwarf2_per_cu_data
*
2420 dwarf2_per_objfile::get_cu (int index
)
2422 gdb_assert (index
>= 0 && index
< this->all_comp_units
.size ());
2424 return this->all_comp_units
[index
];
2427 /* See declaration. */
2430 dwarf2_per_objfile::get_tu (int index
)
2432 gdb_assert (index
>= 0 && index
< this->all_type_units
.size ());
2434 return this->all_type_units
[index
];
2437 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2438 objfile_obstack, and constructed with the specified field
2441 static dwarf2_per_cu_data
*
2442 create_cu_from_index_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2443 struct dwarf2_section_info
*section
,
2445 sect_offset sect_off
, ULONGEST length
)
2447 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2448 dwarf2_per_cu_data
*the_cu
2449 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2450 struct dwarf2_per_cu_data
);
2451 the_cu
->sect_off
= sect_off
;
2452 the_cu
->length
= length
;
2453 the_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
2454 the_cu
->section
= section
;
2455 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2456 struct dwarf2_per_cu_quick_data
);
2457 the_cu
->is_dwz
= is_dwz
;
2461 /* A helper for create_cus_from_index that handles a given list of
2465 create_cus_from_index_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2466 const gdb_byte
*cu_list
, offset_type n_elements
,
2467 struct dwarf2_section_info
*section
,
2470 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
2472 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2474 sect_offset sect_off
2475 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2476 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2479 dwarf2_per_cu_data
*per_cu
2480 = create_cu_from_index_list (dwarf2_per_objfile
, section
, is_dwz
,
2482 dwarf2_per_objfile
->all_comp_units
.push_back (per_cu
);
2486 /* Read the CU list from the mapped index, and use it to create all
2487 the CU objects for this objfile. */
2490 create_cus_from_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2491 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2492 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2494 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
2495 dwarf2_per_objfile
->all_comp_units
.reserve
2496 ((cu_list_elements
+ dwz_elements
) / 2);
2498 create_cus_from_index_list (dwarf2_per_objfile
, cu_list
, cu_list_elements
,
2499 &dwarf2_per_objfile
->info
, 0);
2501 if (dwz_elements
== 0)
2504 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
2505 create_cus_from_index_list (dwarf2_per_objfile
, dwz_list
, dwz_elements
,
2509 /* Create the signatured type hash table from the index. */
2512 create_signatured_type_table_from_index
2513 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2514 struct dwarf2_section_info
*section
,
2515 const gdb_byte
*bytes
,
2516 offset_type elements
)
2518 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2520 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
2521 dwarf2_per_objfile
->all_type_units
.reserve (elements
/ 3);
2523 htab_up sig_types_hash
= allocate_signatured_type_table ();
2525 for (offset_type i
= 0; i
< elements
; i
+= 3)
2527 struct signatured_type
*sig_type
;
2530 cu_offset type_offset_in_tu
;
2532 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2533 sect_offset sect_off
2534 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2536 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
2538 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2541 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2542 struct signatured_type
);
2543 sig_type
->signature
= signature
;
2544 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
2545 sig_type
->per_cu
.is_debug_types
= 1;
2546 sig_type
->per_cu
.section
= section
;
2547 sig_type
->per_cu
.sect_off
= sect_off
;
2548 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
2549 sig_type
->per_cu
.v
.quick
2550 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2551 struct dwarf2_per_cu_quick_data
);
2553 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2556 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
2559 dwarf2_per_objfile
->signatured_types
= std::move (sig_types_hash
);
2562 /* Create the signatured type hash table from .debug_names. */
2565 create_signatured_type_table_from_debug_names
2566 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2567 const mapped_debug_names
&map
,
2568 struct dwarf2_section_info
*section
,
2569 struct dwarf2_section_info
*abbrev_section
)
2571 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2573 section
->read (objfile
);
2574 abbrev_section
->read (objfile
);
2576 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
2577 dwarf2_per_objfile
->all_type_units
.reserve (map
.tu_count
);
2579 htab_up sig_types_hash
= allocate_signatured_type_table ();
2581 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
2583 struct signatured_type
*sig_type
;
2586 sect_offset sect_off
2587 = (sect_offset
) (extract_unsigned_integer
2588 (map
.tu_table_reordered
+ i
* map
.offset_size
,
2590 map
.dwarf5_byte_order
));
2592 comp_unit_head cu_header
;
2593 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
2595 section
->buffer
+ to_underlying (sect_off
),
2598 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2599 struct signatured_type
);
2600 sig_type
->signature
= cu_header
.signature
;
2601 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
2602 sig_type
->per_cu
.is_debug_types
= 1;
2603 sig_type
->per_cu
.section
= section
;
2604 sig_type
->per_cu
.sect_off
= sect_off
;
2605 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
2606 sig_type
->per_cu
.v
.quick
2607 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2608 struct dwarf2_per_cu_quick_data
);
2610 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2613 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
2616 dwarf2_per_objfile
->signatured_types
= std::move (sig_types_hash
);
2619 /* Read the address map data from the mapped index, and use it to
2620 populate the objfile's psymtabs_addrmap. */
2623 create_addrmap_from_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2624 struct mapped_index
*index
)
2626 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2627 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2628 const gdb_byte
*iter
, *end
;
2629 struct addrmap
*mutable_map
;
2632 auto_obstack temp_obstack
;
2634 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2636 iter
= index
->address_table
.data ();
2637 end
= iter
+ index
->address_table
.size ();
2639 baseaddr
= objfile
->text_section_offset ();
2643 ULONGEST hi
, lo
, cu_index
;
2644 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2646 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2648 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2653 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
2654 hex_string (lo
), hex_string (hi
));
2658 if (cu_index
>= dwarf2_per_objfile
->all_comp_units
.size ())
2660 complaint (_(".gdb_index address table has invalid CU number %u"),
2661 (unsigned) cu_index
);
2665 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
2666 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
2667 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
2668 dwarf2_per_objfile
->get_cu (cu_index
));
2671 objfile
->partial_symtabs
->psymtabs_addrmap
2672 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
2675 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
2676 populate the objfile's psymtabs_addrmap. */
2679 create_addrmap_from_aranges (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2680 struct dwarf2_section_info
*section
)
2682 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2683 bfd
*abfd
= objfile
->obfd
;
2684 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
2685 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
2687 auto_obstack temp_obstack
;
2688 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
2690 std::unordered_map
<sect_offset
,
2691 dwarf2_per_cu_data
*,
2692 gdb::hash_enum
<sect_offset
>>
2693 debug_info_offset_to_per_cu
;
2694 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
2696 const auto insertpair
2697 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
, per_cu
);
2698 if (!insertpair
.second
)
2700 warning (_("Section .debug_aranges in %s has duplicate "
2701 "debug_info_offset %s, ignoring .debug_aranges."),
2702 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
2707 section
->read (objfile
);
2709 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
2711 const gdb_byte
*addr
= section
->buffer
;
2713 while (addr
< section
->buffer
+ section
->size
)
2715 const gdb_byte
*const entry_addr
= addr
;
2716 unsigned int bytes_read
;
2718 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
2722 const gdb_byte
*const entry_end
= addr
+ entry_length
;
2723 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
2724 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
2725 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
2727 warning (_("Section .debug_aranges in %s entry at offset %s "
2728 "length %s exceeds section length %s, "
2729 "ignoring .debug_aranges."),
2730 objfile_name (objfile
),
2731 plongest (entry_addr
- section
->buffer
),
2732 plongest (bytes_read
+ entry_length
),
2733 pulongest (section
->size
));
2737 /* The version number. */
2738 const uint16_t version
= read_2_bytes (abfd
, addr
);
2742 warning (_("Section .debug_aranges in %s entry at offset %s "
2743 "has unsupported version %d, ignoring .debug_aranges."),
2744 objfile_name (objfile
),
2745 plongest (entry_addr
- section
->buffer
), version
);
2749 const uint64_t debug_info_offset
2750 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
2751 addr
+= offset_size
;
2752 const auto per_cu_it
2753 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
2754 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
2756 warning (_("Section .debug_aranges in %s entry at offset %s "
2757 "debug_info_offset %s does not exists, "
2758 "ignoring .debug_aranges."),
2759 objfile_name (objfile
),
2760 plongest (entry_addr
- section
->buffer
),
2761 pulongest (debug_info_offset
));
2764 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
2766 const uint8_t address_size
= *addr
++;
2767 if (address_size
< 1 || address_size
> 8)
2769 warning (_("Section .debug_aranges in %s entry at offset %s "
2770 "address_size %u is invalid, ignoring .debug_aranges."),
2771 objfile_name (objfile
),
2772 plongest (entry_addr
- section
->buffer
), address_size
);
2776 const uint8_t segment_selector_size
= *addr
++;
2777 if (segment_selector_size
!= 0)
2779 warning (_("Section .debug_aranges in %s entry at offset %s "
2780 "segment_selector_size %u is not supported, "
2781 "ignoring .debug_aranges."),
2782 objfile_name (objfile
),
2783 plongest (entry_addr
- section
->buffer
),
2784 segment_selector_size
);
2788 /* Must pad to an alignment boundary that is twice the address
2789 size. It is undocumented by the DWARF standard but GCC does
2791 for (size_t padding
= ((-(addr
- section
->buffer
))
2792 & (2 * address_size
- 1));
2793 padding
> 0; padding
--)
2796 warning (_("Section .debug_aranges in %s entry at offset %s "
2797 "padding is not zero, ignoring .debug_aranges."),
2798 objfile_name (objfile
),
2799 plongest (entry_addr
- section
->buffer
));
2805 if (addr
+ 2 * address_size
> entry_end
)
2807 warning (_("Section .debug_aranges in %s entry at offset %s "
2808 "address list is not properly terminated, "
2809 "ignoring .debug_aranges."),
2810 objfile_name (objfile
),
2811 plongest (entry_addr
- section
->buffer
));
2814 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
2816 addr
+= address_size
;
2817 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
2819 addr
+= address_size
;
2820 if (start
== 0 && length
== 0)
2822 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
2824 /* Symbol was eliminated due to a COMDAT group. */
2827 ULONGEST end
= start
+ length
;
2828 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
2830 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
2832 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
2836 objfile
->partial_symtabs
->psymtabs_addrmap
2837 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
2840 /* Find a slot in the mapped index INDEX for the object named NAME.
2841 If NAME is found, set *VEC_OUT to point to the CU vector in the
2842 constant pool and return true. If NAME cannot be found, return
2846 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2847 offset_type
**vec_out
)
2850 offset_type slot
, step
;
2851 int (*cmp
) (const char *, const char *);
2853 gdb::unique_xmalloc_ptr
<char> without_params
;
2854 if (current_language
->la_language
== language_cplus
2855 || current_language
->la_language
== language_fortran
2856 || current_language
->la_language
== language_d
)
2858 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2861 if (strchr (name
, '(') != NULL
)
2863 without_params
= cp_remove_params (name
);
2865 if (without_params
!= NULL
)
2866 name
= without_params
.get ();
2870 /* Index version 4 did not support case insensitive searches. But the
2871 indices for case insensitive languages are built in lowercase, therefore
2872 simulate our NAME being searched is also lowercased. */
2873 hash
= mapped_index_string_hash ((index
->version
== 4
2874 && case_sensitivity
== case_sensitive_off
2875 ? 5 : index
->version
),
2878 slot
= hash
& (index
->symbol_table
.size () - 1);
2879 step
= ((hash
* 17) & (index
->symbol_table
.size () - 1)) | 1;
2880 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2886 const auto &bucket
= index
->symbol_table
[slot
];
2887 if (bucket
.name
== 0 && bucket
.vec
== 0)
2890 str
= index
->constant_pool
+ MAYBE_SWAP (bucket
.name
);
2891 if (!cmp (name
, str
))
2893 *vec_out
= (offset_type
*) (index
->constant_pool
2894 + MAYBE_SWAP (bucket
.vec
));
2898 slot
= (slot
+ step
) & (index
->symbol_table
.size () - 1);
2902 /* A helper function that reads the .gdb_index from BUFFER and fills
2903 in MAP. FILENAME is the name of the file containing the data;
2904 it is used for error reporting. DEPRECATED_OK is true if it is
2905 ok to use deprecated sections.
2907 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2908 out parameters that are filled in with information about the CU and
2909 TU lists in the section.
2911 Returns true if all went well, false otherwise. */
2914 read_gdb_index_from_buffer (struct objfile
*objfile
,
2915 const char *filename
,
2917 gdb::array_view
<const gdb_byte
> buffer
,
2918 struct mapped_index
*map
,
2919 const gdb_byte
**cu_list
,
2920 offset_type
*cu_list_elements
,
2921 const gdb_byte
**types_list
,
2922 offset_type
*types_list_elements
)
2924 const gdb_byte
*addr
= &buffer
[0];
2926 /* Version check. */
2927 offset_type version
= MAYBE_SWAP (*(offset_type
*) addr
);
2928 /* Versions earlier than 3 emitted every copy of a psymbol. This
2929 causes the index to behave very poorly for certain requests. Version 3
2930 contained incomplete addrmap. So, it seems better to just ignore such
2934 static int warning_printed
= 0;
2935 if (!warning_printed
)
2937 warning (_("Skipping obsolete .gdb_index section in %s."),
2939 warning_printed
= 1;
2943 /* Index version 4 uses a different hash function than index version
2946 Versions earlier than 6 did not emit psymbols for inlined
2947 functions. Using these files will cause GDB not to be able to
2948 set breakpoints on inlined functions by name, so we ignore these
2949 indices unless the user has done
2950 "set use-deprecated-index-sections on". */
2951 if (version
< 6 && !deprecated_ok
)
2953 static int warning_printed
= 0;
2954 if (!warning_printed
)
2957 Skipping deprecated .gdb_index section in %s.\n\
2958 Do \"set use-deprecated-index-sections on\" before the file is read\n\
2959 to use the section anyway."),
2961 warning_printed
= 1;
2965 /* Version 7 indices generated by gold refer to the CU for a symbol instead
2966 of the TU (for symbols coming from TUs),
2967 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
2968 Plus gold-generated indices can have duplicate entries for global symbols,
2969 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
2970 These are just performance bugs, and we can't distinguish gdb-generated
2971 indices from gold-generated ones, so issue no warning here. */
2973 /* Indexes with higher version than the one supported by GDB may be no
2974 longer backward compatible. */
2978 map
->version
= version
;
2980 offset_type
*metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
2983 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2984 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
2988 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
2989 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
2990 - MAYBE_SWAP (metadata
[i
]))
2994 const gdb_byte
*address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
2995 const gdb_byte
*address_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
2997 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
3000 const gdb_byte
*symbol_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3001 const gdb_byte
*symbol_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3003 = gdb::array_view
<mapped_index::symbol_table_slot
>
3004 ((mapped_index::symbol_table_slot
*) symbol_table
,
3005 (mapped_index::symbol_table_slot
*) symbol_table_end
);
3008 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3013 /* Callback types for dwarf2_read_gdb_index. */
3015 typedef gdb::function_view
3016 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_objfile
*)>
3017 get_gdb_index_contents_ftype
;
3018 typedef gdb::function_view
3019 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
3020 get_gdb_index_contents_dwz_ftype
;
3022 /* Read .gdb_index. If everything went ok, initialize the "quick"
3023 elements of all the CUs and return 1. Otherwise, return 0. */
3026 dwarf2_read_gdb_index
3027 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3028 get_gdb_index_contents_ftype get_gdb_index_contents
,
3029 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
3031 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3032 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3033 struct dwz_file
*dwz
;
3034 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3036 gdb::array_view
<const gdb_byte
> main_index_contents
3037 = get_gdb_index_contents (objfile
, dwarf2_per_objfile
);
3039 if (main_index_contents
.empty ())
3042 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
3043 if (!read_gdb_index_from_buffer (objfile
, objfile_name (objfile
),
3044 use_deprecated_index_sections
,
3045 main_index_contents
, map
.get (), &cu_list
,
3046 &cu_list_elements
, &types_list
,
3047 &types_list_elements
))
3050 /* Don't use the index if it's empty. */
3051 if (map
->symbol_table
.empty ())
3054 /* If there is a .dwz file, read it so we can get its CU list as
3056 dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
3059 struct mapped_index dwz_map
;
3060 const gdb_byte
*dwz_types_ignore
;
3061 offset_type dwz_types_elements_ignore
;
3063 gdb::array_view
<const gdb_byte
> dwz_index_content
3064 = get_gdb_index_contents_dwz (objfile
, dwz
);
3066 if (dwz_index_content
.empty ())
3069 if (!read_gdb_index_from_buffer (objfile
,
3070 bfd_get_filename (dwz
->dwz_bfd
.get ()),
3071 1, dwz_index_content
, &dwz_map
,
3072 &dwz_list
, &dwz_list_elements
,
3074 &dwz_types_elements_ignore
))
3076 warning (_("could not read '.gdb_index' section from %s; skipping"),
3077 bfd_get_filename (dwz
->dwz_bfd
.get ()));
3082 create_cus_from_index (dwarf2_per_objfile
, cu_list
, cu_list_elements
,
3083 dwz_list
, dwz_list_elements
);
3085 if (types_list_elements
)
3087 /* We can only handle a single .debug_types when we have an
3089 if (dwarf2_per_objfile
->types
.size () != 1)
3092 dwarf2_section_info
*section
= &dwarf2_per_objfile
->types
[0];
3094 create_signatured_type_table_from_index (dwarf2_per_objfile
, section
,
3095 types_list
, types_list_elements
);
3098 create_addrmap_from_index (dwarf2_per_objfile
, map
.get ());
3100 dwarf2_per_objfile
->index_table
= std::move (map
);
3101 dwarf2_per_objfile
->using_index
= 1;
3102 dwarf2_per_objfile
->quick_file_names_table
=
3103 create_quick_file_names_table (dwarf2_per_objfile
->all_comp_units
.size ());
3108 /* die_reader_func for dw2_get_file_names. */
3111 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3112 const gdb_byte
*info_ptr
,
3113 struct die_info
*comp_unit_die
)
3115 struct dwarf2_cu
*cu
= reader
->cu
;
3116 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3117 struct dwarf2_per_objfile
*dwarf2_per_objfile
3118 = cu
->per_cu
->dwarf2_per_objfile
;
3119 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3120 struct dwarf2_per_cu_data
*lh_cu
;
3121 struct attribute
*attr
;
3123 struct quick_file_names
*qfn
;
3125 gdb_assert (! this_cu
->is_debug_types
);
3127 /* Our callers never want to match partial units -- instead they
3128 will match the enclosing full CU. */
3129 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3131 this_cu
->v
.quick
->no_file_data
= 1;
3139 sect_offset line_offset
{};
3141 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3142 if (attr
!= nullptr)
3144 struct quick_file_names find_entry
;
3146 line_offset
= (sect_offset
) DW_UNSND (attr
);
3148 /* We may have already read in this line header (TU line header sharing).
3149 If we have we're done. */
3150 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3151 find_entry
.hash
.line_sect_off
= line_offset
;
3152 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
.get (),
3153 &find_entry
, INSERT
);
3156 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3160 lh
= dwarf_decode_line_header (line_offset
, cu
);
3164 lh_cu
->v
.quick
->no_file_data
= 1;
3168 qfn
= XOBNEW (&objfile
->objfile_obstack
, struct quick_file_names
);
3169 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3170 qfn
->hash
.line_sect_off
= line_offset
;
3171 gdb_assert (slot
!= NULL
);
3174 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3177 if (strcmp (fnd
.name
, "<unknown>") != 0)
3180 qfn
->num_file_names
= offset
+ lh
->file_names_size ();
3182 XOBNEWVEC (&objfile
->objfile_obstack
, const char *, qfn
->num_file_names
);
3184 qfn
->file_names
[0] = xstrdup (fnd
.name
);
3185 for (int i
= 0; i
< lh
->file_names_size (); ++i
)
3186 qfn
->file_names
[i
+ offset
] = lh
->file_full_name (i
+ 1,
3187 fnd
.comp_dir
).release ();
3188 qfn
->real_names
= NULL
;
3190 lh_cu
->v
.quick
->file_names
= qfn
;
3193 /* A helper for the "quick" functions which attempts to read the line
3194 table for THIS_CU. */
3196 static struct quick_file_names
*
3197 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
3199 /* This should never be called for TUs. */
3200 gdb_assert (! this_cu
->is_debug_types
);
3201 /* Nor type unit groups. */
3202 gdb_assert (! this_cu
->type_unit_group_p ());
3204 if (this_cu
->v
.quick
->file_names
!= NULL
)
3205 return this_cu
->v
.quick
->file_names
;
3206 /* If we know there is no line data, no point in looking again. */
3207 if (this_cu
->v
.quick
->no_file_data
)
3210 cutu_reader
reader (this_cu
);
3211 if (!reader
.dummy_p
)
3212 dw2_get_file_names_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
);
3214 if (this_cu
->v
.quick
->no_file_data
)
3216 return this_cu
->v
.quick
->file_names
;
3219 /* A helper for the "quick" functions which computes and caches the
3220 real path for a given file name from the line table. */
3223 dw2_get_real_path (struct objfile
*objfile
,
3224 struct quick_file_names
*qfn
, int index
)
3226 if (qfn
->real_names
== NULL
)
3227 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3228 qfn
->num_file_names
, const char *);
3230 if (qfn
->real_names
[index
] == NULL
)
3231 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3233 return qfn
->real_names
[index
];
3236 static struct symtab
*
3237 dw2_find_last_source_symtab (struct objfile
*objfile
)
3239 struct dwarf2_per_objfile
*dwarf2_per_objfile
3240 = get_dwarf2_per_objfile (objfile
);
3241 dwarf2_per_cu_data
*dwarf_cu
= dwarf2_per_objfile
->all_comp_units
.back ();
3242 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, false);
3247 return compunit_primary_filetab (cust
);
3250 /* Traversal function for dw2_forget_cached_source_info. */
3253 dw2_free_cached_file_names (void **slot
, void *info
)
3255 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3257 if (file_data
->real_names
)
3261 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3263 xfree ((void*) file_data
->real_names
[i
]);
3264 file_data
->real_names
[i
] = NULL
;
3272 dw2_forget_cached_source_info (struct objfile
*objfile
)
3274 struct dwarf2_per_objfile
*dwarf2_per_objfile
3275 = get_dwarf2_per_objfile (objfile
);
3277 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
.get (),
3278 dw2_free_cached_file_names
, NULL
);
3281 /* Helper function for dw2_map_symtabs_matching_filename that expands
3282 the symtabs and calls the iterator. */
3285 dw2_map_expand_apply (struct objfile
*objfile
,
3286 struct dwarf2_per_cu_data
*per_cu
,
3287 const char *name
, const char *real_path
,
3288 gdb::function_view
<bool (symtab
*)> callback
)
3290 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3292 /* Don't visit already-expanded CUs. */
3293 if (per_cu
->v
.quick
->compunit_symtab
)
3296 /* This may expand more than one symtab, and we want to iterate over
3298 dw2_instantiate_symtab (per_cu
, false);
3300 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
3301 last_made
, callback
);
3304 /* Implementation of the map_symtabs_matching_filename method. */
3307 dw2_map_symtabs_matching_filename
3308 (struct objfile
*objfile
, const char *name
, const char *real_path
,
3309 gdb::function_view
<bool (symtab
*)> callback
)
3311 const char *name_basename
= lbasename (name
);
3312 struct dwarf2_per_objfile
*dwarf2_per_objfile
3313 = get_dwarf2_per_objfile (objfile
);
3315 /* The rule is CUs specify all the files, including those used by
3316 any TU, so there's no need to scan TUs here. */
3318 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
3320 /* We only need to look at symtabs not already expanded. */
3321 if (per_cu
->v
.quick
->compunit_symtab
)
3324 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
3325 if (file_data
== NULL
)
3328 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3330 const char *this_name
= file_data
->file_names
[j
];
3331 const char *this_real_name
;
3333 if (compare_filenames_for_search (this_name
, name
))
3335 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3341 /* Before we invoke realpath, which can get expensive when many
3342 files are involved, do a quick comparison of the basenames. */
3343 if (! basenames_may_differ
3344 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3347 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3348 if (compare_filenames_for_search (this_real_name
, name
))
3350 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3356 if (real_path
!= NULL
)
3358 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3359 gdb_assert (IS_ABSOLUTE_PATH (name
));
3360 if (this_real_name
!= NULL
3361 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3363 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3375 /* Struct used to manage iterating over all CUs looking for a symbol. */
3377 struct dw2_symtab_iterator
3379 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3380 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
3381 /* If set, only look for symbols that match that block. Valid values are
3382 GLOBAL_BLOCK and STATIC_BLOCK. */
3383 gdb::optional
<block_enum
> block_index
;
3384 /* The kind of symbol we're looking for. */
3386 /* The list of CUs from the index entry of the symbol,
3387 or NULL if not found. */
3389 /* The next element in VEC to look at. */
3391 /* The number of elements in VEC, or zero if there is no match. */
3393 /* Have we seen a global version of the symbol?
3394 If so we can ignore all further global instances.
3395 This is to work around gold/15646, inefficient gold-generated
3400 /* Initialize the index symtab iterator ITER. */
3403 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3404 struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3405 gdb::optional
<block_enum
> block_index
,
3409 iter
->dwarf2_per_objfile
= dwarf2_per_objfile
;
3410 iter
->block_index
= block_index
;
3411 iter
->domain
= domain
;
3413 iter
->global_seen
= 0;
3415 mapped_index
*index
= dwarf2_per_objfile
->index_table
.get ();
3417 /* index is NULL if OBJF_READNOW. */
3418 if (index
!= NULL
&& find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3419 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3427 /* Return the next matching CU or NULL if there are no more. */
3429 static struct dwarf2_per_cu_data
*
3430 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3432 struct dwarf2_per_objfile
*dwarf2_per_objfile
= iter
->dwarf2_per_objfile
;
3434 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3436 offset_type cu_index_and_attrs
=
3437 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3438 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3439 gdb_index_symbol_kind symbol_kind
=
3440 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3441 /* Only check the symbol attributes if they're present.
3442 Indices prior to version 7 don't record them,
3443 and indices >= 7 may elide them for certain symbols
3444 (gold does this). */
3446 (dwarf2_per_objfile
->index_table
->version
>= 7
3447 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3449 /* Don't crash on bad data. */
3450 if (cu_index
>= (dwarf2_per_objfile
->all_comp_units
.size ()
3451 + dwarf2_per_objfile
->all_type_units
.size ()))
3453 complaint (_(".gdb_index entry has bad CU index"
3455 objfile_name (dwarf2_per_objfile
->objfile
));
3459 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (cu_index
);
3461 /* Skip if already read in. */
3462 if (per_cu
->v
.quick
->compunit_symtab
)
3465 /* Check static vs global. */
3468 bool is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3470 if (iter
->block_index
.has_value ())
3472 bool want_static
= *iter
->block_index
== STATIC_BLOCK
;
3474 if (is_static
!= want_static
)
3478 /* Work around gold/15646. */
3479 if (!is_static
&& iter
->global_seen
)
3482 iter
->global_seen
= 1;
3485 /* Only check the symbol's kind if it has one. */
3488 switch (iter
->domain
)
3491 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3492 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3493 /* Some types are also in VAR_DOMAIN. */
3494 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3498 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3502 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3506 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3521 static struct compunit_symtab
*
3522 dw2_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
3523 const char *name
, domain_enum domain
)
3525 struct compunit_symtab
*stab_best
= NULL
;
3526 struct dwarf2_per_objfile
*dwarf2_per_objfile
3527 = get_dwarf2_per_objfile (objfile
);
3529 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
3531 struct dw2_symtab_iterator iter
;
3532 struct dwarf2_per_cu_data
*per_cu
;
3534 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, block_index
, domain
, name
);
3536 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3538 struct symbol
*sym
, *with_opaque
= NULL
;
3539 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
, false);
3540 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
3541 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3543 sym
= block_find_symbol (block
, name
, domain
,
3544 block_find_non_opaque_type_preferred
,
3547 /* Some caution must be observed with overloaded functions
3548 and methods, since the index will not contain any overload
3549 information (but NAME might contain it). */
3552 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
3554 if (with_opaque
!= NULL
3555 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
3558 /* Keep looking through other CUs. */
3565 dw2_print_stats (struct objfile
*objfile
)
3567 struct dwarf2_per_objfile
*dwarf2_per_objfile
3568 = get_dwarf2_per_objfile (objfile
);
3569 int total
= (dwarf2_per_objfile
->all_comp_units
.size ()
3570 + dwarf2_per_objfile
->all_type_units
.size ());
3573 for (int i
= 0; i
< total
; ++i
)
3575 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
3577 if (!per_cu
->v
.quick
->compunit_symtab
)
3580 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3581 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3584 /* This dumps minimal information about the index.
3585 It is called via "mt print objfiles".
3586 One use is to verify .gdb_index has been loaded by the
3587 gdb.dwarf2/gdb-index.exp testcase. */
3590 dw2_dump (struct objfile
*objfile
)
3592 struct dwarf2_per_objfile
*dwarf2_per_objfile
3593 = get_dwarf2_per_objfile (objfile
);
3595 gdb_assert (dwarf2_per_objfile
->using_index
);
3596 printf_filtered (".gdb_index:");
3597 if (dwarf2_per_objfile
->index_table
!= NULL
)
3599 printf_filtered (" version %d\n",
3600 dwarf2_per_objfile
->index_table
->version
);
3603 printf_filtered (" faked for \"readnow\"\n");
3604 printf_filtered ("\n");
3608 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
3609 const char *func_name
)
3611 struct dwarf2_per_objfile
*dwarf2_per_objfile
3612 = get_dwarf2_per_objfile (objfile
);
3614 struct dw2_symtab_iterator iter
;
3615 struct dwarf2_per_cu_data
*per_cu
;
3617 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, {}, VAR_DOMAIN
, func_name
);
3619 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3620 dw2_instantiate_symtab (per_cu
, false);
3625 dw2_expand_all_symtabs (struct objfile
*objfile
)
3627 struct dwarf2_per_objfile
*dwarf2_per_objfile
3628 = get_dwarf2_per_objfile (objfile
);
3629 int total_units
= (dwarf2_per_objfile
->all_comp_units
.size ()
3630 + dwarf2_per_objfile
->all_type_units
.size ());
3632 for (int i
= 0; i
< total_units
; ++i
)
3634 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
3636 /* We don't want to directly expand a partial CU, because if we
3637 read it with the wrong language, then assertion failures can
3638 be triggered later on. See PR symtab/23010. So, tell
3639 dw2_instantiate_symtab to skip partial CUs -- any important
3640 partial CU will be read via DW_TAG_imported_unit anyway. */
3641 dw2_instantiate_symtab (per_cu
, true);
3646 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
3647 const char *fullname
)
3649 struct dwarf2_per_objfile
*dwarf2_per_objfile
3650 = get_dwarf2_per_objfile (objfile
);
3652 /* We don't need to consider type units here.
3653 This is only called for examining code, e.g. expand_line_sal.
3654 There can be an order of magnitude (or more) more type units
3655 than comp units, and we avoid them if we can. */
3657 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
3659 /* We only need to look at symtabs not already expanded. */
3660 if (per_cu
->v
.quick
->compunit_symtab
)
3663 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
3664 if (file_data
== NULL
)
3667 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3669 const char *this_fullname
= file_data
->file_names
[j
];
3671 if (filename_cmp (this_fullname
, fullname
) == 0)
3673 dw2_instantiate_symtab (per_cu
, false);
3681 dw2_map_matching_symbols
3682 (struct objfile
*objfile
,
3683 const lookup_name_info
&name
, domain_enum domain
,
3685 gdb::function_view
<symbol_found_callback_ftype
> callback
,
3686 symbol_compare_ftype
*ordered_compare
)
3688 /* Currently unimplemented; used for Ada. The function can be called if the
3689 current language is Ada for a non-Ada objfile using GNU index. As Ada
3690 does not look for non-Ada symbols this function should just return. */
3693 /* Starting from a search name, return the string that finds the upper
3694 bound of all strings that start with SEARCH_NAME in a sorted name
3695 list. Returns the empty string to indicate that the upper bound is
3696 the end of the list. */
3699 make_sort_after_prefix_name (const char *search_name
)
3701 /* When looking to complete "func", we find the upper bound of all
3702 symbols that start with "func" by looking for where we'd insert
3703 the closest string that would follow "func" in lexicographical
3704 order. Usually, that's "func"-with-last-character-incremented,
3705 i.e. "fund". Mind non-ASCII characters, though. Usually those
3706 will be UTF-8 multi-byte sequences, but we can't be certain.
3707 Especially mind the 0xff character, which is a valid character in
3708 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
3709 rule out compilers allowing it in identifiers. Note that
3710 conveniently, strcmp/strcasecmp are specified to compare
3711 characters interpreted as unsigned char. So what we do is treat
3712 the whole string as a base 256 number composed of a sequence of
3713 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
3714 to 0, and carries 1 to the following more-significant position.
3715 If the very first character in SEARCH_NAME ends up incremented
3716 and carries/overflows, then the upper bound is the end of the
3717 list. The string after the empty string is also the empty
3720 Some examples of this operation:
3722 SEARCH_NAME => "+1" RESULT
3726 "\xff" "a" "\xff" => "\xff" "b"
3731 Then, with these symbols for example:
3737 completing "func" looks for symbols between "func" and
3738 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
3739 which finds "func" and "func1", but not "fund".
3743 funcÿ (Latin1 'ÿ' [0xff])
3747 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
3748 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
3752 ÿÿ (Latin1 'ÿ' [0xff])
3755 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
3756 the end of the list.
3758 std::string after
= search_name
;
3759 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
3761 if (!after
.empty ())
3762 after
.back () = (unsigned char) after
.back () + 1;
3766 /* See declaration. */
3768 std::pair
<std::vector
<name_component
>::const_iterator
,
3769 std::vector
<name_component
>::const_iterator
>
3770 mapped_index_base::find_name_components_bounds
3771 (const lookup_name_info
&lookup_name_without_params
, language lang
) const
3774 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
3776 const char *lang_name
3777 = lookup_name_without_params
.language_lookup_name (lang
).c_str ();
3779 /* Comparison function object for lower_bound that matches against a
3780 given symbol name. */
3781 auto lookup_compare_lower
= [&] (const name_component
&elem
,
3784 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
3785 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3786 return name_cmp (elem_name
, name
) < 0;
3789 /* Comparison function object for upper_bound that matches against a
3790 given symbol name. */
3791 auto lookup_compare_upper
= [&] (const char *name
,
3792 const name_component
&elem
)
3794 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
3795 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3796 return name_cmp (name
, elem_name
) < 0;
3799 auto begin
= this->name_components
.begin ();
3800 auto end
= this->name_components
.end ();
3802 /* Find the lower bound. */
3805 if (lookup_name_without_params
.completion_mode () && lang_name
[0] == '\0')
3808 return std::lower_bound (begin
, end
, lang_name
, lookup_compare_lower
);
3811 /* Find the upper bound. */
3814 if (lookup_name_without_params
.completion_mode ())
3816 /* In completion mode, we want UPPER to point past all
3817 symbols names that have the same prefix. I.e., with
3818 these symbols, and completing "func":
3820 function << lower bound
3822 other_function << upper bound
3824 We find the upper bound by looking for the insertion
3825 point of "func"-with-last-character-incremented,
3827 std::string after
= make_sort_after_prefix_name (lang_name
);
3830 return std::lower_bound (lower
, end
, after
.c_str (),
3831 lookup_compare_lower
);
3834 return std::upper_bound (lower
, end
, lang_name
, lookup_compare_upper
);
3837 return {lower
, upper
};
3840 /* See declaration. */
3843 mapped_index_base::build_name_components ()
3845 if (!this->name_components
.empty ())
3848 this->name_components_casing
= case_sensitivity
;
3850 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
3852 /* The code below only knows how to break apart components of C++
3853 symbol names (and other languages that use '::' as
3854 namespace/module separator) and Ada symbol names. */
3855 auto count
= this->symbol_name_count ();
3856 for (offset_type idx
= 0; idx
< count
; idx
++)
3858 if (this->symbol_name_slot_invalid (idx
))
3861 const char *name
= this->symbol_name_at (idx
);
3863 /* Add each name component to the name component table. */
3864 unsigned int previous_len
= 0;
3866 if (strstr (name
, "::") != nullptr)
3868 for (unsigned int current_len
= cp_find_first_component (name
);
3869 name
[current_len
] != '\0';
3870 current_len
+= cp_find_first_component (name
+ current_len
))
3872 gdb_assert (name
[current_len
] == ':');
3873 this->name_components
.push_back ({previous_len
, idx
});
3874 /* Skip the '::'. */
3876 previous_len
= current_len
;
3881 /* Handle the Ada encoded (aka mangled) form here. */
3882 for (const char *iter
= strstr (name
, "__");
3884 iter
= strstr (iter
, "__"))
3886 this->name_components
.push_back ({previous_len
, idx
});
3888 previous_len
= iter
- name
;
3892 this->name_components
.push_back ({previous_len
, idx
});
3895 /* Sort name_components elements by name. */
3896 auto name_comp_compare
= [&] (const name_component
&left
,
3897 const name_component
&right
)
3899 const char *left_qualified
= this->symbol_name_at (left
.idx
);
3900 const char *right_qualified
= this->symbol_name_at (right
.idx
);
3902 const char *left_name
= left_qualified
+ left
.name_offset
;
3903 const char *right_name
= right_qualified
+ right
.name_offset
;
3905 return name_cmp (left_name
, right_name
) < 0;
3908 std::sort (this->name_components
.begin (),
3909 this->name_components
.end (),
3913 /* Helper for dw2_expand_symtabs_matching that works with a
3914 mapped_index_base instead of the containing objfile. This is split
3915 to a separate function in order to be able to unit test the
3916 name_components matching using a mock mapped_index_base. For each
3917 symbol name that matches, calls MATCH_CALLBACK, passing it the
3918 symbol's index in the mapped_index_base symbol table. */
3921 dw2_expand_symtabs_matching_symbol
3922 (mapped_index_base
&index
,
3923 const lookup_name_info
&lookup_name_in
,
3924 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3925 enum search_domain kind
,
3926 gdb::function_view
<bool (offset_type
)> match_callback
)
3928 lookup_name_info lookup_name_without_params
3929 = lookup_name_in
.make_ignore_params ();
3931 /* Build the symbol name component sorted vector, if we haven't
3933 index
.build_name_components ();
3935 /* The same symbol may appear more than once in the range though.
3936 E.g., if we're looking for symbols that complete "w", and we have
3937 a symbol named "w1::w2", we'll find the two name components for
3938 that same symbol in the range. To be sure we only call the
3939 callback once per symbol, we first collect the symbol name
3940 indexes that matched in a temporary vector and ignore
3942 std::vector
<offset_type
> matches
;
3944 struct name_and_matcher
3946 symbol_name_matcher_ftype
*matcher
;
3947 const std::string
&name
;
3949 bool operator== (const name_and_matcher
&other
) const
3951 return matcher
== other
.matcher
&& name
== other
.name
;
3955 /* A vector holding all the different symbol name matchers, for all
3957 std::vector
<name_and_matcher
> matchers
;
3959 for (int i
= 0; i
< nr_languages
; i
++)
3961 enum language lang_e
= (enum language
) i
;
3963 const language_defn
*lang
= language_def (lang_e
);
3964 symbol_name_matcher_ftype
*name_matcher
3965 = get_symbol_name_matcher (lang
, lookup_name_without_params
);
3967 name_and_matcher key
{
3969 lookup_name_without_params
.language_lookup_name (lang_e
)
3972 /* Don't insert the same comparison routine more than once.
3973 Note that we do this linear walk. This is not a problem in
3974 practice because the number of supported languages is
3976 if (std::find (matchers
.begin (), matchers
.end (), key
)
3979 matchers
.push_back (std::move (key
));
3982 = index
.find_name_components_bounds (lookup_name_without_params
,
3985 /* Now for each symbol name in range, check to see if we have a name
3986 match, and if so, call the MATCH_CALLBACK callback. */
3988 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
3990 const char *qualified
= index
.symbol_name_at (bounds
.first
->idx
);
3992 if (!name_matcher (qualified
, lookup_name_without_params
, NULL
)
3993 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
3996 matches
.push_back (bounds
.first
->idx
);
4000 std::sort (matches
.begin (), matches
.end ());
4002 /* Finally call the callback, once per match. */
4004 for (offset_type idx
: matches
)
4008 if (!match_callback (idx
))
4014 /* Above we use a type wider than idx's for 'prev', since 0 and
4015 (offset_type)-1 are both possible values. */
4016 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
4021 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
4023 /* A mock .gdb_index/.debug_names-like name index table, enough to
4024 exercise dw2_expand_symtabs_matching_symbol, which works with the
4025 mapped_index_base interface. Builds an index from the symbol list
4026 passed as parameter to the constructor. */
4027 class mock_mapped_index
: public mapped_index_base
4030 mock_mapped_index (gdb::array_view
<const char *> symbols
)
4031 : m_symbol_table (symbols
)
4034 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
4036 /* Return the number of names in the symbol table. */
4037 size_t symbol_name_count () const override
4039 return m_symbol_table
.size ();
4042 /* Get the name of the symbol at IDX in the symbol table. */
4043 const char *symbol_name_at (offset_type idx
) const override
4045 return m_symbol_table
[idx
];
4049 gdb::array_view
<const char *> m_symbol_table
;
4052 /* Convenience function that converts a NULL pointer to a "<null>"
4053 string, to pass to print routines. */
4056 string_or_null (const char *str
)
4058 return str
!= NULL
? str
: "<null>";
4061 /* Check if a lookup_name_info built from
4062 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4063 index. EXPECTED_LIST is the list of expected matches, in expected
4064 matching order. If no match expected, then an empty list is
4065 specified. Returns true on success. On failure prints a warning
4066 indicating the file:line that failed, and returns false. */
4069 check_match (const char *file
, int line
,
4070 mock_mapped_index
&mock_index
,
4071 const char *name
, symbol_name_match_type match_type
,
4072 bool completion_mode
,
4073 std::initializer_list
<const char *> expected_list
)
4075 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4077 bool matched
= true;
4079 auto mismatch
= [&] (const char *expected_str
,
4082 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4083 "expected=\"%s\", got=\"%s\"\n"),
4085 (match_type
== symbol_name_match_type::FULL
4087 name
, string_or_null (expected_str
), string_or_null (got
));
4091 auto expected_it
= expected_list
.begin ();
4092 auto expected_end
= expected_list
.end ();
4094 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
4096 [&] (offset_type idx
)
4098 const char *matched_name
= mock_index
.symbol_name_at (idx
);
4099 const char *expected_str
4100 = expected_it
== expected_end
? NULL
: *expected_it
++;
4102 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4103 mismatch (expected_str
, matched_name
);
4107 const char *expected_str
4108 = expected_it
== expected_end
? NULL
: *expected_it
++;
4109 if (expected_str
!= NULL
)
4110 mismatch (expected_str
, NULL
);
4115 /* The symbols added to the mock mapped_index for testing (in
4117 static const char *test_symbols
[] = {
4126 "ns2::tmpl<int>::foo2",
4127 "(anonymous namespace)::A::B::C",
4129 /* These are used to check that the increment-last-char in the
4130 matching algorithm for completion doesn't match "t1_fund" when
4131 completing "t1_func". */
4137 /* A UTF-8 name with multi-byte sequences to make sure that
4138 cp-name-parser understands this as a single identifier ("função"
4139 is "function" in PT). */
4142 /* \377 (0xff) is Latin1 'ÿ'. */
4145 /* \377 (0xff) is Latin1 'ÿ'. */
4149 /* A name with all sorts of complications. Starts with "z" to make
4150 it easier for the completion tests below. */
4151 #define Z_SYM_NAME \
4152 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4153 "::tuple<(anonymous namespace)::ui*, " \
4154 "std::default_delete<(anonymous namespace)::ui>, void>"
4159 /* Returns true if the mapped_index_base::find_name_component_bounds
4160 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4161 in completion mode. */
4164 check_find_bounds_finds (mapped_index_base
&index
,
4165 const char *search_name
,
4166 gdb::array_view
<const char *> expected_syms
)
4168 lookup_name_info
lookup_name (search_name
,
4169 symbol_name_match_type::FULL
, true);
4171 auto bounds
= index
.find_name_components_bounds (lookup_name
,
4174 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
4175 if (distance
!= expected_syms
.size ())
4178 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
4180 auto nc_elem
= bounds
.first
+ exp_elem
;
4181 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
);
4182 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
4189 /* Test the lower-level mapped_index::find_name_component_bounds
4193 test_mapped_index_find_name_component_bounds ()
4195 mock_mapped_index
mock_index (test_symbols
);
4197 mock_index
.build_name_components ();
4199 /* Test the lower-level mapped_index::find_name_component_bounds
4200 method in completion mode. */
4202 static const char *expected_syms
[] = {
4207 SELF_CHECK (check_find_bounds_finds (mock_index
,
4208 "t1_func", expected_syms
));
4211 /* Check that the increment-last-char in the name matching algorithm
4212 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4214 static const char *expected_syms1
[] = {
4218 SELF_CHECK (check_find_bounds_finds (mock_index
,
4219 "\377", expected_syms1
));
4221 static const char *expected_syms2
[] = {
4224 SELF_CHECK (check_find_bounds_finds (mock_index
,
4225 "\377\377", expected_syms2
));
4229 /* Test dw2_expand_symtabs_matching_symbol. */
4232 test_dw2_expand_symtabs_matching_symbol ()
4234 mock_mapped_index
mock_index (test_symbols
);
4236 /* We let all tests run until the end even if some fails, for debug
4238 bool any_mismatch
= false;
4240 /* Create the expected symbols list (an initializer_list). Needed
4241 because lists have commas, and we need to pass them to CHECK,
4242 which is a macro. */
4243 #define EXPECT(...) { __VA_ARGS__ }
4245 /* Wrapper for check_match that passes down the current
4246 __FILE__/__LINE__. */
4247 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4248 any_mismatch |= !check_match (__FILE__, __LINE__, \
4250 NAME, MATCH_TYPE, COMPLETION_MODE, \
4253 /* Identity checks. */
4254 for (const char *sym
: test_symbols
)
4256 /* Should be able to match all existing symbols. */
4257 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4260 /* Should be able to match all existing symbols with
4262 std::string with_params
= std::string (sym
) + "(int)";
4263 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4266 /* Should be able to match all existing symbols with
4267 parameters and qualifiers. */
4268 with_params
= std::string (sym
) + " ( int ) const";
4269 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4272 /* This should really find sym, but cp-name-parser.y doesn't
4273 know about lvalue/rvalue qualifiers yet. */
4274 with_params
= std::string (sym
) + " ( int ) &&";
4275 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4279 /* Check that the name matching algorithm for completion doesn't get
4280 confused with Latin1 'ÿ' / 0xff. */
4282 static const char str
[] = "\377";
4283 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4284 EXPECT ("\377", "\377\377123"));
4287 /* Check that the increment-last-char in the matching algorithm for
4288 completion doesn't match "t1_fund" when completing "t1_func". */
4290 static const char str
[] = "t1_func";
4291 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4292 EXPECT ("t1_func", "t1_func1"));
4295 /* Check that completion mode works at each prefix of the expected
4298 static const char str
[] = "function(int)";
4299 size_t len
= strlen (str
);
4302 for (size_t i
= 1; i
< len
; i
++)
4304 lookup
.assign (str
, i
);
4305 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4306 EXPECT ("function"));
4310 /* While "w" is a prefix of both components, the match function
4311 should still only be called once. */
4313 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4315 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4319 /* Same, with a "complicated" symbol. */
4321 static const char str
[] = Z_SYM_NAME
;
4322 size_t len
= strlen (str
);
4325 for (size_t i
= 1; i
< len
; i
++)
4327 lookup
.assign (str
, i
);
4328 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4329 EXPECT (Z_SYM_NAME
));
4333 /* In FULL mode, an incomplete symbol doesn't match. */
4335 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4339 /* A complete symbol with parameters matches any overload, since the
4340 index has no overload info. */
4342 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4343 EXPECT ("std::zfunction", "std::zfunction2"));
4344 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4345 EXPECT ("std::zfunction", "std::zfunction2"));
4346 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4347 EXPECT ("std::zfunction", "std::zfunction2"));
4350 /* Check that whitespace is ignored appropriately. A symbol with a
4351 template argument list. */
4353 static const char expected
[] = "ns::foo<int>";
4354 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4356 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4360 /* Check that whitespace is ignored appropriately. A symbol with a
4361 template argument list that includes a pointer. */
4363 static const char expected
[] = "ns::foo<char*>";
4364 /* Try both completion and non-completion modes. */
4365 static const bool completion_mode
[2] = {false, true};
4366 for (size_t i
= 0; i
< 2; i
++)
4368 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4369 completion_mode
[i
], EXPECT (expected
));
4370 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4371 completion_mode
[i
], EXPECT (expected
));
4373 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4374 completion_mode
[i
], EXPECT (expected
));
4375 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4376 completion_mode
[i
], EXPECT (expected
));
4381 /* Check method qualifiers are ignored. */
4382 static const char expected
[] = "ns::foo<char*>";
4383 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4384 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4385 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4386 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4387 CHECK_MATCH ("foo < char * > ( int ) const",
4388 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4389 CHECK_MATCH ("foo < char * > ( int ) &&",
4390 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4393 /* Test lookup names that don't match anything. */
4395 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4398 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4402 /* Some wild matching tests, exercising "(anonymous namespace)",
4403 which should not be confused with a parameter list. */
4405 static const char *syms
[] = {
4409 "A :: B :: C ( int )",
4414 for (const char *s
: syms
)
4416 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4417 EXPECT ("(anonymous namespace)::A::B::C"));
4422 static const char expected
[] = "ns2::tmpl<int>::foo2";
4423 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4425 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4429 SELF_CHECK (!any_mismatch
);
4438 test_mapped_index_find_name_component_bounds ();
4439 test_dw2_expand_symtabs_matching_symbol ();
4442 }} // namespace selftests::dw2_expand_symtabs_matching
4444 #endif /* GDB_SELF_TEST */
4446 /* If FILE_MATCHER is NULL or if PER_CU has
4447 dwarf2_per_cu_quick_data::MARK set (see
4448 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4449 EXPANSION_NOTIFY on it. */
4452 dw2_expand_symtabs_matching_one
4453 (struct dwarf2_per_cu_data
*per_cu
,
4454 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4455 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4457 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4459 bool symtab_was_null
4460 = (per_cu
->v
.quick
->compunit_symtab
== NULL
);
4462 dw2_instantiate_symtab (per_cu
, false);
4464 if (expansion_notify
!= NULL
4466 && per_cu
->v
.quick
->compunit_symtab
!= NULL
)
4467 expansion_notify (per_cu
->v
.quick
->compunit_symtab
);
4471 /* Helper for dw2_expand_matching symtabs. Called on each symbol
4472 matched, to expand corresponding CUs that were marked. IDX is the
4473 index of the symbol name that matched. */
4476 dw2_expand_marked_cus
4477 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, offset_type idx
,
4478 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4479 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4482 offset_type
*vec
, vec_len
, vec_idx
;
4483 bool global_seen
= false;
4484 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
4486 vec
= (offset_type
*) (index
.constant_pool
4487 + MAYBE_SWAP (index
.symbol_table
[idx
].vec
));
4488 vec_len
= MAYBE_SWAP (vec
[0]);
4489 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
4491 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
4492 /* This value is only valid for index versions >= 7. */
4493 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4494 gdb_index_symbol_kind symbol_kind
=
4495 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
4496 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
4497 /* Only check the symbol attributes if they're present.
4498 Indices prior to version 7 don't record them,
4499 and indices >= 7 may elide them for certain symbols
4500 (gold does this). */
4503 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
4505 /* Work around gold/15646. */
4508 if (!is_static
&& global_seen
)
4514 /* Only check the symbol's kind if it has one. */
4519 case VARIABLES_DOMAIN
:
4520 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
4523 case FUNCTIONS_DOMAIN
:
4524 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4528 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4531 case MODULES_DOMAIN
:
4532 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4540 /* Don't crash on bad data. */
4541 if (cu_index
>= (dwarf2_per_objfile
->all_comp_units
.size ()
4542 + dwarf2_per_objfile
->all_type_units
.size ()))
4544 complaint (_(".gdb_index entry has bad CU index"
4546 objfile_name (dwarf2_per_objfile
->objfile
));
4550 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (cu_index
);
4551 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
4556 /* If FILE_MATCHER is non-NULL, set all the
4557 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
4558 that match FILE_MATCHER. */
4561 dw_expand_symtabs_matching_file_matcher
4562 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
4563 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
4565 if (file_matcher
== NULL
)
4568 objfile
*const objfile
= dwarf2_per_objfile
->objfile
;
4570 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
4572 NULL
, xcalloc
, xfree
));
4573 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
4575 NULL
, xcalloc
, xfree
));
4577 /* The rule is CUs specify all the files, including those used by
4578 any TU, so there's no need to scan TUs here. */
4580 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
4584 per_cu
->v
.quick
->mark
= 0;
4586 /* We only need to look at symtabs not already expanded. */
4587 if (per_cu
->v
.quick
->compunit_symtab
)
4590 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
4591 if (file_data
== NULL
)
4594 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
4596 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
4598 per_cu
->v
.quick
->mark
= 1;
4602 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4604 const char *this_real_name
;
4606 if (file_matcher (file_data
->file_names
[j
], false))
4608 per_cu
->v
.quick
->mark
= 1;
4612 /* Before we invoke realpath, which can get expensive when many
4613 files are involved, do a quick comparison of the basenames. */
4614 if (!basenames_may_differ
4615 && !file_matcher (lbasename (file_data
->file_names
[j
]),
4619 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
4620 if (file_matcher (this_real_name
, false))
4622 per_cu
->v
.quick
->mark
= 1;
4627 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
4628 ? visited_found
.get ()
4629 : visited_not_found
.get (),
4636 dw2_expand_symtabs_matching
4637 (struct objfile
*objfile
,
4638 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4639 const lookup_name_info
&lookup_name
,
4640 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4641 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4642 enum search_domain kind
)
4644 struct dwarf2_per_objfile
*dwarf2_per_objfile
4645 = get_dwarf2_per_objfile (objfile
);
4647 /* index_table is NULL if OBJF_READNOW. */
4648 if (!dwarf2_per_objfile
->index_table
)
4651 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
4653 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
4655 dw2_expand_symtabs_matching_symbol (index
, lookup_name
,
4657 kind
, [&] (offset_type idx
)
4659 dw2_expand_marked_cus (dwarf2_per_objfile
, idx
, file_matcher
,
4660 expansion_notify
, kind
);
4665 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4668 static struct compunit_symtab
*
4669 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4674 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4675 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4678 if (cust
->includes
== NULL
)
4681 for (i
= 0; cust
->includes
[i
]; ++i
)
4683 struct compunit_symtab
*s
= cust
->includes
[i
];
4685 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
4693 static struct compunit_symtab
*
4694 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
4695 struct bound_minimal_symbol msymbol
,
4697 struct obj_section
*section
,
4700 struct dwarf2_per_cu_data
*data
;
4701 struct compunit_symtab
*result
;
4703 if (!objfile
->partial_symtabs
->psymtabs_addrmap
)
4706 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
4707 data
= (struct dwarf2_per_cu_data
*) addrmap_find
4708 (objfile
->partial_symtabs
->psymtabs_addrmap
, pc
- baseaddr
);
4712 if (warn_if_readin
&& data
->v
.quick
->compunit_symtab
)
4713 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4714 paddress (get_objfile_arch (objfile
), pc
));
4717 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data
,
4720 gdb_assert (result
!= NULL
);
4725 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
4726 void *data
, int need_fullname
)
4728 struct dwarf2_per_objfile
*dwarf2_per_objfile
4729 = get_dwarf2_per_objfile (objfile
);
4731 if (!dwarf2_per_objfile
->filenames_cache
)
4733 dwarf2_per_objfile
->filenames_cache
.emplace ();
4735 htab_up
visited (htab_create_alloc (10,
4736 htab_hash_pointer
, htab_eq_pointer
,
4737 NULL
, xcalloc
, xfree
));
4739 /* The rule is CUs specify all the files, including those used
4740 by any TU, so there's no need to scan TUs here. We can
4741 ignore file names coming from already-expanded CUs. */
4743 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
4745 if (per_cu
->v
.quick
->compunit_symtab
)
4747 void **slot
= htab_find_slot (visited
.get (),
4748 per_cu
->v
.quick
->file_names
,
4751 *slot
= per_cu
->v
.quick
->file_names
;
4755 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
4757 /* We only need to look at symtabs not already expanded. */
4758 if (per_cu
->v
.quick
->compunit_symtab
)
4761 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
4762 if (file_data
== NULL
)
4765 void **slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
4768 /* Already visited. */
4773 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4775 const char *filename
= file_data
->file_names
[j
];
4776 dwarf2_per_objfile
->filenames_cache
->seen (filename
);
4781 dwarf2_per_objfile
->filenames_cache
->traverse ([&] (const char *filename
)
4783 gdb::unique_xmalloc_ptr
<char> this_real_name
;
4786 this_real_name
= gdb_realpath (filename
);
4787 (*fun
) (filename
, this_real_name
.get (), data
);
4792 dw2_has_symbols (struct objfile
*objfile
)
4797 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
4800 dw2_find_last_source_symtab
,
4801 dw2_forget_cached_source_info
,
4802 dw2_map_symtabs_matching_filename
,
4806 dw2_expand_symtabs_for_function
,
4807 dw2_expand_all_symtabs
,
4808 dw2_expand_symtabs_with_fullname
,
4809 dw2_map_matching_symbols
,
4810 dw2_expand_symtabs_matching
,
4811 dw2_find_pc_sect_compunit_symtab
,
4813 dw2_map_symbol_filenames
4816 /* DWARF-5 debug_names reader. */
4818 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
4819 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
4821 /* A helper function that reads the .debug_names section in SECTION
4822 and fills in MAP. FILENAME is the name of the file containing the
4823 section; it is used for error reporting.
4825 Returns true if all went well, false otherwise. */
4828 read_debug_names_from_section (struct objfile
*objfile
,
4829 const char *filename
,
4830 struct dwarf2_section_info
*section
,
4831 mapped_debug_names
&map
)
4833 if (section
->empty ())
4836 /* Older elfutils strip versions could keep the section in the main
4837 executable while splitting it for the separate debug info file. */
4838 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
4841 section
->read (objfile
);
4843 map
.dwarf5_byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
4845 const gdb_byte
*addr
= section
->buffer
;
4847 bfd
*const abfd
= section
->get_bfd_owner ();
4849 unsigned int bytes_read
;
4850 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
4853 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
4854 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
4855 if (bytes_read
+ length
!= section
->size
)
4857 /* There may be multiple per-CU indices. */
4858 warning (_("Section .debug_names in %s length %s does not match "
4859 "section length %s, ignoring .debug_names."),
4860 filename
, plongest (bytes_read
+ length
),
4861 pulongest (section
->size
));
4865 /* The version number. */
4866 uint16_t version
= read_2_bytes (abfd
, addr
);
4870 warning (_("Section .debug_names in %s has unsupported version %d, "
4871 "ignoring .debug_names."),
4877 uint16_t padding
= read_2_bytes (abfd
, addr
);
4881 warning (_("Section .debug_names in %s has unsupported padding %d, "
4882 "ignoring .debug_names."),
4887 /* comp_unit_count - The number of CUs in the CU list. */
4888 map
.cu_count
= read_4_bytes (abfd
, addr
);
4891 /* local_type_unit_count - The number of TUs in the local TU
4893 map
.tu_count
= read_4_bytes (abfd
, addr
);
4896 /* foreign_type_unit_count - The number of TUs in the foreign TU
4898 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
4900 if (foreign_tu_count
!= 0)
4902 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
4903 "ignoring .debug_names."),
4904 filename
, static_cast<unsigned long> (foreign_tu_count
));
4908 /* bucket_count - The number of hash buckets in the hash lookup
4910 map
.bucket_count
= read_4_bytes (abfd
, addr
);
4913 /* name_count - The number of unique names in the index. */
4914 map
.name_count
= read_4_bytes (abfd
, addr
);
4917 /* abbrev_table_size - The size in bytes of the abbreviations
4919 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
4922 /* augmentation_string_size - The size in bytes of the augmentation
4923 string. This value is rounded up to a multiple of 4. */
4924 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
4926 map
.augmentation_is_gdb
= ((augmentation_string_size
4927 == sizeof (dwarf5_augmentation
))
4928 && memcmp (addr
, dwarf5_augmentation
,
4929 sizeof (dwarf5_augmentation
)) == 0);
4930 augmentation_string_size
+= (-augmentation_string_size
) & 3;
4931 addr
+= augmentation_string_size
;
4934 map
.cu_table_reordered
= addr
;
4935 addr
+= map
.cu_count
* map
.offset_size
;
4937 /* List of Local TUs */
4938 map
.tu_table_reordered
= addr
;
4939 addr
+= map
.tu_count
* map
.offset_size
;
4941 /* Hash Lookup Table */
4942 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
4943 addr
+= map
.bucket_count
* 4;
4944 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
4945 addr
+= map
.name_count
* 4;
4948 map
.name_table_string_offs_reordered
= addr
;
4949 addr
+= map
.name_count
* map
.offset_size
;
4950 map
.name_table_entry_offs_reordered
= addr
;
4951 addr
+= map
.name_count
* map
.offset_size
;
4953 const gdb_byte
*abbrev_table_start
= addr
;
4956 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4961 const auto insertpair
4962 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
4963 if (!insertpair
.second
)
4965 warning (_("Section .debug_names in %s has duplicate index %s, "
4966 "ignoring .debug_names."),
4967 filename
, pulongest (index_num
));
4970 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
4971 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4976 mapped_debug_names::index_val::attr attr
;
4977 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4979 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
4981 if (attr
.form
== DW_FORM_implicit_const
)
4983 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
4987 if (attr
.dw_idx
== 0 && attr
.form
== 0)
4989 indexval
.attr_vec
.push_back (std::move (attr
));
4992 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
4994 warning (_("Section .debug_names in %s has abbreviation_table "
4995 "of size %s vs. written as %u, ignoring .debug_names."),
4996 filename
, plongest (addr
- abbrev_table_start
),
5000 map
.entry_pool
= addr
;
5005 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5009 create_cus_from_debug_names_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5010 const mapped_debug_names
&map
,
5011 dwarf2_section_info
§ion
,
5014 sect_offset sect_off_prev
;
5015 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
5017 sect_offset sect_off_next
;
5018 if (i
< map
.cu_count
)
5021 = (sect_offset
) (extract_unsigned_integer
5022 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5024 map
.dwarf5_byte_order
));
5027 sect_off_next
= (sect_offset
) section
.size
;
5030 const ULONGEST length
= sect_off_next
- sect_off_prev
;
5031 dwarf2_per_cu_data
*per_cu
5032 = create_cu_from_index_list (dwarf2_per_objfile
, §ion
, is_dwz
,
5033 sect_off_prev
, length
);
5034 dwarf2_per_objfile
->all_comp_units
.push_back (per_cu
);
5036 sect_off_prev
= sect_off_next
;
5040 /* Read the CU list from the mapped index, and use it to create all
5041 the CU objects for this dwarf2_per_objfile. */
5044 create_cus_from_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5045 const mapped_debug_names
&map
,
5046 const mapped_debug_names
&dwz_map
)
5048 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
5049 dwarf2_per_objfile
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
5051 create_cus_from_debug_names_list (dwarf2_per_objfile
, map
,
5052 dwarf2_per_objfile
->info
,
5053 false /* is_dwz */);
5055 if (dwz_map
.cu_count
== 0)
5058 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5059 create_cus_from_debug_names_list (dwarf2_per_objfile
, dwz_map
, dwz
->info
,
5063 /* Read .debug_names. If everything went ok, initialize the "quick"
5064 elements of all the CUs and return true. Otherwise, return false. */
5067 dwarf2_read_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
5069 std::unique_ptr
<mapped_debug_names
> map
5070 (new mapped_debug_names (dwarf2_per_objfile
));
5071 mapped_debug_names
dwz_map (dwarf2_per_objfile
);
5072 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5074 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
5075 &dwarf2_per_objfile
->debug_names
,
5079 /* Don't use the index if it's empty. */
5080 if (map
->name_count
== 0)
5083 /* If there is a .dwz file, read it so we can get its CU list as
5085 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5088 if (!read_debug_names_from_section (objfile
,
5089 bfd_get_filename (dwz
->dwz_bfd
.get ()),
5090 &dwz
->debug_names
, dwz_map
))
5092 warning (_("could not read '.debug_names' section from %s; skipping"),
5093 bfd_get_filename (dwz
->dwz_bfd
.get ()));
5098 create_cus_from_debug_names (dwarf2_per_objfile
, *map
, dwz_map
);
5100 if (map
->tu_count
!= 0)
5102 /* We can only handle a single .debug_types when we have an
5104 if (dwarf2_per_objfile
->types
.size () != 1)
5107 dwarf2_section_info
*section
= &dwarf2_per_objfile
->types
[0];
5109 create_signatured_type_table_from_debug_names
5110 (dwarf2_per_objfile
, *map
, section
, &dwarf2_per_objfile
->abbrev
);
5113 create_addrmap_from_aranges (dwarf2_per_objfile
,
5114 &dwarf2_per_objfile
->debug_aranges
);
5116 dwarf2_per_objfile
->debug_names_table
= std::move (map
);
5117 dwarf2_per_objfile
->using_index
= 1;
5118 dwarf2_per_objfile
->quick_file_names_table
=
5119 create_quick_file_names_table (dwarf2_per_objfile
->all_comp_units
.size ());
5124 /* Type used to manage iterating over all CUs looking for a symbol for
5127 class dw2_debug_names_iterator
5130 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5131 gdb::optional
<block_enum
> block_index
,
5134 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5135 m_addr (find_vec_in_debug_names (map
, name
))
5138 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5139 search_domain search
, uint32_t namei
)
5142 m_addr (find_vec_in_debug_names (map
, namei
))
5145 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5146 block_enum block_index
, domain_enum domain
,
5148 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5149 m_addr (find_vec_in_debug_names (map
, namei
))
5152 /* Return the next matching CU or NULL if there are no more. */
5153 dwarf2_per_cu_data
*next ();
5156 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5158 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5161 /* The internalized form of .debug_names. */
5162 const mapped_debug_names
&m_map
;
5164 /* If set, only look for symbols that match that block. Valid values are
5165 GLOBAL_BLOCK and STATIC_BLOCK. */
5166 const gdb::optional
<block_enum
> m_block_index
;
5168 /* The kind of symbol we're looking for. */
5169 const domain_enum m_domain
= UNDEF_DOMAIN
;
5170 const search_domain m_search
= ALL_DOMAIN
;
5172 /* The list of CUs from the index entry of the symbol, or NULL if
5174 const gdb_byte
*m_addr
;
5178 mapped_debug_names::namei_to_name (uint32_t namei
) const
5180 const ULONGEST namei_string_offs
5181 = extract_unsigned_integer ((name_table_string_offs_reordered
5182 + namei
* offset_size
),
5185 return read_indirect_string_at_offset
5186 (dwarf2_per_objfile
, dwarf2_per_objfile
->objfile
->obfd
, namei_string_offs
);
5189 /* Find a slot in .debug_names for the object named NAME. If NAME is
5190 found, return pointer to its pool data. If NAME cannot be found,
5194 dw2_debug_names_iterator::find_vec_in_debug_names
5195 (const mapped_debug_names
&map
, const char *name
)
5197 int (*cmp
) (const char *, const char *);
5199 gdb::unique_xmalloc_ptr
<char> without_params
;
5200 if (current_language
->la_language
== language_cplus
5201 || current_language
->la_language
== language_fortran
5202 || current_language
->la_language
== language_d
)
5204 /* NAME is already canonical. Drop any qualifiers as
5205 .debug_names does not contain any. */
5207 if (strchr (name
, '(') != NULL
)
5209 without_params
= cp_remove_params (name
);
5210 if (without_params
!= NULL
)
5211 name
= without_params
.get ();
5215 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
5217 const uint32_t full_hash
= dwarf5_djb_hash (name
);
5219 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5220 (map
.bucket_table_reordered
5221 + (full_hash
% map
.bucket_count
)), 4,
5222 map
.dwarf5_byte_order
);
5226 if (namei
>= map
.name_count
)
5228 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5230 namei
, map
.name_count
,
5231 objfile_name (map
.dwarf2_per_objfile
->objfile
));
5237 const uint32_t namei_full_hash
5238 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5239 (map
.hash_table_reordered
+ namei
), 4,
5240 map
.dwarf5_byte_order
);
5241 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
5244 if (full_hash
== namei_full_hash
)
5246 const char *const namei_string
= map
.namei_to_name (namei
);
5248 #if 0 /* An expensive sanity check. */
5249 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
5251 complaint (_("Wrong .debug_names hash for string at index %u "
5253 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
5258 if (cmp (namei_string
, name
) == 0)
5260 const ULONGEST namei_entry_offs
5261 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5262 + namei
* map
.offset_size
),
5263 map
.offset_size
, map
.dwarf5_byte_order
);
5264 return map
.entry_pool
+ namei_entry_offs
;
5269 if (namei
>= map
.name_count
)
5275 dw2_debug_names_iterator::find_vec_in_debug_names
5276 (const mapped_debug_names
&map
, uint32_t namei
)
5278 if (namei
>= map
.name_count
)
5280 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5282 namei
, map
.name_count
,
5283 objfile_name (map
.dwarf2_per_objfile
->objfile
));
5287 const ULONGEST namei_entry_offs
5288 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5289 + namei
* map
.offset_size
),
5290 map
.offset_size
, map
.dwarf5_byte_order
);
5291 return map
.entry_pool
+ namei_entry_offs
;
5294 /* See dw2_debug_names_iterator. */
5296 dwarf2_per_cu_data
*
5297 dw2_debug_names_iterator::next ()
5302 struct dwarf2_per_objfile
*dwarf2_per_objfile
= m_map
.dwarf2_per_objfile
;
5303 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5304 bfd
*const abfd
= objfile
->obfd
;
5308 unsigned int bytes_read
;
5309 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5310 m_addr
+= bytes_read
;
5314 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5315 if (indexval_it
== m_map
.abbrev_map
.cend ())
5317 complaint (_("Wrong .debug_names undefined abbrev code %s "
5319 pulongest (abbrev
), objfile_name (objfile
));
5322 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5323 enum class symbol_linkage
{
5327 } symbol_linkage_
= symbol_linkage::unknown
;
5328 dwarf2_per_cu_data
*per_cu
= NULL
;
5329 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5334 case DW_FORM_implicit_const
:
5335 ull
= attr
.implicit_const
;
5337 case DW_FORM_flag_present
:
5341 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5342 m_addr
+= bytes_read
;
5345 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5346 dwarf_form_name (attr
.form
),
5347 objfile_name (objfile
));
5350 switch (attr
.dw_idx
)
5352 case DW_IDX_compile_unit
:
5353 /* Don't crash on bad data. */
5354 if (ull
>= dwarf2_per_objfile
->all_comp_units
.size ())
5356 complaint (_(".debug_names entry has bad CU index %s"
5359 objfile_name (dwarf2_per_objfile
->objfile
));
5362 per_cu
= dwarf2_per_objfile
->get_cutu (ull
);
5364 case DW_IDX_type_unit
:
5365 /* Don't crash on bad data. */
5366 if (ull
>= dwarf2_per_objfile
->all_type_units
.size ())
5368 complaint (_(".debug_names entry has bad TU index %s"
5371 objfile_name (dwarf2_per_objfile
->objfile
));
5374 per_cu
= &dwarf2_per_objfile
->get_tu (ull
)->per_cu
;
5376 case DW_IDX_GNU_internal
:
5377 if (!m_map
.augmentation_is_gdb
)
5379 symbol_linkage_
= symbol_linkage::static_
;
5381 case DW_IDX_GNU_external
:
5382 if (!m_map
.augmentation_is_gdb
)
5384 symbol_linkage_
= symbol_linkage::extern_
;
5389 /* Skip if already read in. */
5390 if (per_cu
->v
.quick
->compunit_symtab
)
5393 /* Check static vs global. */
5394 if (symbol_linkage_
!= symbol_linkage::unknown
&& m_block_index
.has_value ())
5396 const bool want_static
= *m_block_index
== STATIC_BLOCK
;
5397 const bool symbol_is_static
=
5398 symbol_linkage_
== symbol_linkage::static_
;
5399 if (want_static
!= symbol_is_static
)
5403 /* Match dw2_symtab_iter_next, symbol_kind
5404 and debug_names::psymbol_tag. */
5408 switch (indexval
.dwarf_tag
)
5410 case DW_TAG_variable
:
5411 case DW_TAG_subprogram
:
5412 /* Some types are also in VAR_DOMAIN. */
5413 case DW_TAG_typedef
:
5414 case DW_TAG_structure_type
:
5421 switch (indexval
.dwarf_tag
)
5423 case DW_TAG_typedef
:
5424 case DW_TAG_structure_type
:
5431 switch (indexval
.dwarf_tag
)
5434 case DW_TAG_variable
:
5441 switch (indexval
.dwarf_tag
)
5453 /* Match dw2_expand_symtabs_matching, symbol_kind and
5454 debug_names::psymbol_tag. */
5457 case VARIABLES_DOMAIN
:
5458 switch (indexval
.dwarf_tag
)
5460 case DW_TAG_variable
:
5466 case FUNCTIONS_DOMAIN
:
5467 switch (indexval
.dwarf_tag
)
5469 case DW_TAG_subprogram
:
5476 switch (indexval
.dwarf_tag
)
5478 case DW_TAG_typedef
:
5479 case DW_TAG_structure_type
:
5485 case MODULES_DOMAIN
:
5486 switch (indexval
.dwarf_tag
)
5500 static struct compunit_symtab
*
5501 dw2_debug_names_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
5502 const char *name
, domain_enum domain
)
5504 struct dwarf2_per_objfile
*dwarf2_per_objfile
5505 = get_dwarf2_per_objfile (objfile
);
5507 const auto &mapp
= dwarf2_per_objfile
->debug_names_table
;
5510 /* index is NULL if OBJF_READNOW. */
5513 const auto &map
= *mapp
;
5515 dw2_debug_names_iterator
iter (map
, block_index
, domain
, name
);
5517 struct compunit_symtab
*stab_best
= NULL
;
5518 struct dwarf2_per_cu_data
*per_cu
;
5519 while ((per_cu
= iter
.next ()) != NULL
)
5521 struct symbol
*sym
, *with_opaque
= NULL
;
5522 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
, false);
5523 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
5524 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
5526 sym
= block_find_symbol (block
, name
, domain
,
5527 block_find_non_opaque_type_preferred
,
5530 /* Some caution must be observed with overloaded functions and
5531 methods, since the index will not contain any overload
5532 information (but NAME might contain it). */
5535 && strcmp_iw (sym
->search_name (), name
) == 0)
5537 if (with_opaque
!= NULL
5538 && strcmp_iw (with_opaque
->search_name (), name
) == 0)
5541 /* Keep looking through other CUs. */
5547 /* This dumps minimal information about .debug_names. It is called
5548 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
5549 uses this to verify that .debug_names has been loaded. */
5552 dw2_debug_names_dump (struct objfile
*objfile
)
5554 struct dwarf2_per_objfile
*dwarf2_per_objfile
5555 = get_dwarf2_per_objfile (objfile
);
5557 gdb_assert (dwarf2_per_objfile
->using_index
);
5558 printf_filtered (".debug_names:");
5559 if (dwarf2_per_objfile
->debug_names_table
)
5560 printf_filtered (" exists\n");
5562 printf_filtered (" faked for \"readnow\"\n");
5563 printf_filtered ("\n");
5567 dw2_debug_names_expand_symtabs_for_function (struct objfile
*objfile
,
5568 const char *func_name
)
5570 struct dwarf2_per_objfile
*dwarf2_per_objfile
5571 = get_dwarf2_per_objfile (objfile
);
5573 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
5574 if (dwarf2_per_objfile
->debug_names_table
)
5576 const mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
5578 dw2_debug_names_iterator
iter (map
, {}, VAR_DOMAIN
, func_name
);
5580 struct dwarf2_per_cu_data
*per_cu
;
5581 while ((per_cu
= iter
.next ()) != NULL
)
5582 dw2_instantiate_symtab (per_cu
, false);
5587 dw2_debug_names_map_matching_symbols
5588 (struct objfile
*objfile
,
5589 const lookup_name_info
&name
, domain_enum domain
,
5591 gdb::function_view
<symbol_found_callback_ftype
> callback
,
5592 symbol_compare_ftype
*ordered_compare
)
5594 struct dwarf2_per_objfile
*dwarf2_per_objfile
5595 = get_dwarf2_per_objfile (objfile
);
5597 /* debug_names_table is NULL if OBJF_READNOW. */
5598 if (!dwarf2_per_objfile
->debug_names_table
)
5601 mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
5602 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
5604 const char *match_name
= name
.ada ().lookup_name ().c_str ();
5605 auto matcher
= [&] (const char *symname
)
5607 if (ordered_compare
== nullptr)
5609 return ordered_compare (symname
, match_name
) == 0;
5612 dw2_expand_symtabs_matching_symbol (map
, name
, matcher
, ALL_DOMAIN
,
5613 [&] (offset_type namei
)
5615 /* The name was matched, now expand corresponding CUs that were
5617 dw2_debug_names_iterator
iter (map
, block_kind
, domain
, namei
);
5619 struct dwarf2_per_cu_data
*per_cu
;
5620 while ((per_cu
= iter
.next ()) != NULL
)
5621 dw2_expand_symtabs_matching_one (per_cu
, nullptr, nullptr);
5625 /* It's a shame we couldn't do this inside the
5626 dw2_expand_symtabs_matching_symbol callback, but that skips CUs
5627 that have already been expanded. Instead, this loop matches what
5628 the psymtab code does. */
5629 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5631 struct compunit_symtab
*cust
= per_cu
->v
.quick
->compunit_symtab
;
5632 if (cust
!= nullptr)
5634 const struct block
*block
5635 = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
5636 if (!iterate_over_symbols_terminated (block
, name
,
5644 dw2_debug_names_expand_symtabs_matching
5645 (struct objfile
*objfile
,
5646 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5647 const lookup_name_info
&lookup_name
,
5648 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5649 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5650 enum search_domain kind
)
5652 struct dwarf2_per_objfile
*dwarf2_per_objfile
5653 = get_dwarf2_per_objfile (objfile
);
5655 /* debug_names_table is NULL if OBJF_READNOW. */
5656 if (!dwarf2_per_objfile
->debug_names_table
)
5659 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
5661 mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
5663 dw2_expand_symtabs_matching_symbol (map
, lookup_name
,
5665 kind
, [&] (offset_type namei
)
5667 /* The name was matched, now expand corresponding CUs that were
5669 dw2_debug_names_iterator
iter (map
, kind
, namei
);
5671 struct dwarf2_per_cu_data
*per_cu
;
5672 while ((per_cu
= iter
.next ()) != NULL
)
5673 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
5679 const struct quick_symbol_functions dwarf2_debug_names_functions
=
5682 dw2_find_last_source_symtab
,
5683 dw2_forget_cached_source_info
,
5684 dw2_map_symtabs_matching_filename
,
5685 dw2_debug_names_lookup_symbol
,
5687 dw2_debug_names_dump
,
5688 dw2_debug_names_expand_symtabs_for_function
,
5689 dw2_expand_all_symtabs
,
5690 dw2_expand_symtabs_with_fullname
,
5691 dw2_debug_names_map_matching_symbols
,
5692 dw2_debug_names_expand_symtabs_matching
,
5693 dw2_find_pc_sect_compunit_symtab
,
5695 dw2_map_symbol_filenames
5698 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
5699 to either a dwarf2_per_objfile or dwz_file object. */
5701 template <typename T
>
5702 static gdb::array_view
<const gdb_byte
>
5703 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
5705 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
5707 if (section
->empty ())
5710 /* Older elfutils strip versions could keep the section in the main
5711 executable while splitting it for the separate debug info file. */
5712 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
5715 section
->read (obj
);
5717 /* dwarf2_section_info::size is a bfd_size_type, while
5718 gdb::array_view works with size_t. On 32-bit hosts, with
5719 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
5720 is 32-bit. So we need an explicit narrowing conversion here.
5721 This is fine, because it's impossible to allocate or mmap an
5722 array/buffer larger than what size_t can represent. */
5723 return gdb::make_array_view (section
->buffer
, section
->size
);
5726 /* Lookup the index cache for the contents of the index associated to
5729 static gdb::array_view
<const gdb_byte
>
5730 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_objfile
*dwarf2_obj
)
5732 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
5733 if (build_id
== nullptr)
5736 return global_index_cache
.lookup_gdb_index (build_id
,
5737 &dwarf2_obj
->index_cache_res
);
5740 /* Same as the above, but for DWZ. */
5742 static gdb::array_view
<const gdb_byte
>
5743 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
5745 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
5746 if (build_id
== nullptr)
5749 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
5752 /* See symfile.h. */
5755 dwarf2_initialize_objfile (struct objfile
*objfile
, dw_index_kind
*index_kind
)
5757 struct dwarf2_per_objfile
*dwarf2_per_objfile
5758 = get_dwarf2_per_objfile (objfile
);
5760 /* If we're about to read full symbols, don't bother with the
5761 indices. In this case we also don't care if some other debug
5762 format is making psymtabs, because they are all about to be
5764 if ((objfile
->flags
& OBJF_READNOW
))
5766 dwarf2_per_objfile
->using_index
= 1;
5767 create_all_comp_units (dwarf2_per_objfile
);
5768 create_all_type_units (dwarf2_per_objfile
);
5769 dwarf2_per_objfile
->quick_file_names_table
5770 = create_quick_file_names_table
5771 (dwarf2_per_objfile
->all_comp_units
.size ());
5773 for (int i
= 0; i
< (dwarf2_per_objfile
->all_comp_units
.size ()
5774 + dwarf2_per_objfile
->all_type_units
.size ()); ++i
)
5776 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
5778 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
5779 struct dwarf2_per_cu_quick_data
);
5782 /* Return 1 so that gdb sees the "quick" functions. However,
5783 these functions will be no-ops because we will have expanded
5785 *index_kind
= dw_index_kind::GDB_INDEX
;
5789 if (dwarf2_read_debug_names (dwarf2_per_objfile
))
5791 *index_kind
= dw_index_kind::DEBUG_NAMES
;
5795 if (dwarf2_read_gdb_index (dwarf2_per_objfile
,
5796 get_gdb_index_contents_from_section
<struct dwarf2_per_objfile
>,
5797 get_gdb_index_contents_from_section
<dwz_file
>))
5799 *index_kind
= dw_index_kind::GDB_INDEX
;
5803 /* ... otherwise, try to find the index in the index cache. */
5804 if (dwarf2_read_gdb_index (dwarf2_per_objfile
,
5805 get_gdb_index_contents_from_cache
,
5806 get_gdb_index_contents_from_cache_dwz
))
5808 global_index_cache
.hit ();
5809 *index_kind
= dw_index_kind::GDB_INDEX
;
5813 global_index_cache
.miss ();
5819 /* Build a partial symbol table. */
5822 dwarf2_build_psymtabs (struct objfile
*objfile
)
5824 struct dwarf2_per_objfile
*dwarf2_per_objfile
5825 = get_dwarf2_per_objfile (objfile
);
5827 init_psymbol_list (objfile
, 1024);
5831 /* This isn't really ideal: all the data we allocate on the
5832 objfile's obstack is still uselessly kept around. However,
5833 freeing it seems unsafe. */
5834 psymtab_discarder
psymtabs (objfile
);
5835 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
);
5838 /* (maybe) store an index in the cache. */
5839 global_index_cache
.store (dwarf2_per_objfile
);
5841 catch (const gdb_exception_error
&except
)
5843 exception_print (gdb_stderr
, except
);
5847 /* Find the base address of the compilation unit for range lists and
5848 location lists. It will normally be specified by DW_AT_low_pc.
5849 In DWARF-3 draft 4, the base address could be overridden by
5850 DW_AT_entry_pc. It's been removed, but GCC still uses this for
5851 compilation units with discontinuous ranges. */
5854 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
5856 struct attribute
*attr
;
5859 cu
->base_address
= 0;
5861 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
5862 if (attr
!= nullptr)
5864 cu
->base_address
= attr
->value_as_address ();
5869 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
5870 if (attr
!= nullptr)
5872 cu
->base_address
= attr
->value_as_address ();
5878 /* Helper function that returns the proper abbrev section for
5881 static struct dwarf2_section_info
*
5882 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
5884 struct dwarf2_section_info
*abbrev
;
5885 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
5887 if (this_cu
->is_dwz
)
5888 abbrev
= &dwarf2_get_dwz_file (dwarf2_per_objfile
)->abbrev
;
5890 abbrev
= &dwarf2_per_objfile
->abbrev
;
5895 /* Fetch the abbreviation table offset from a comp or type unit header. */
5898 read_abbrev_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5899 struct dwarf2_section_info
*section
,
5900 sect_offset sect_off
)
5902 bfd
*abfd
= section
->get_bfd_owner ();
5903 const gdb_byte
*info_ptr
;
5904 unsigned int initial_length_size
, offset_size
;
5907 section
->read (dwarf2_per_objfile
->objfile
);
5908 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
5909 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
5910 offset_size
= initial_length_size
== 4 ? 4 : 8;
5911 info_ptr
+= initial_length_size
;
5913 version
= read_2_bytes (abfd
, info_ptr
);
5917 /* Skip unit type and address size. */
5921 return (sect_offset
) read_offset (abfd
, info_ptr
, offset_size
);
5924 /* A partial symtab that is used only for include files. */
5925 struct dwarf2_include_psymtab
: public partial_symtab
5927 dwarf2_include_psymtab (const char *filename
, struct objfile
*objfile
)
5928 : partial_symtab (filename
, objfile
)
5932 void read_symtab (struct objfile
*objfile
) override
5934 expand_psymtab (objfile
);
5937 void expand_psymtab (struct objfile
*objfile
) override
5941 /* It's an include file, no symbols to read for it.
5942 Everything is in the parent symtab. */
5943 read_dependencies (objfile
);
5947 bool readin_p () const override
5952 struct compunit_symtab
*get_compunit_symtab () const override
5959 bool m_readin
= false;
5962 /* Allocate a new partial symtab for file named NAME and mark this new
5963 partial symtab as being an include of PST. */
5966 dwarf2_create_include_psymtab (const char *name
, dwarf2_psymtab
*pst
,
5967 struct objfile
*objfile
)
5969 dwarf2_include_psymtab
*subpst
= new dwarf2_include_psymtab (name
, objfile
);
5971 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
5973 /* It shares objfile->objfile_obstack. */
5974 subpst
->dirname
= pst
->dirname
;
5977 subpst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (1);
5978 subpst
->dependencies
[0] = pst
;
5979 subpst
->number_of_dependencies
= 1;
5982 /* Read the Line Number Program data and extract the list of files
5983 included by the source file represented by PST. Build an include
5984 partial symtab for each of these included files. */
5987 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
5988 struct die_info
*die
,
5989 dwarf2_psymtab
*pst
)
5992 struct attribute
*attr
;
5994 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
5995 if (attr
!= nullptr)
5996 lh
= dwarf_decode_line_header ((sect_offset
) DW_UNSND (attr
), cu
);
5998 return; /* No linetable, so no includes. */
6000 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6001 that we pass in the raw text_low here; that is ok because we're
6002 only decoding the line table to make include partial symtabs, and
6003 so the addresses aren't really used. */
6004 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
6005 pst
->raw_text_low (), 1);
6009 hash_signatured_type (const void *item
)
6011 const struct signatured_type
*sig_type
6012 = (const struct signatured_type
*) item
;
6014 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6015 return sig_type
->signature
;
6019 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6021 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6022 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6024 return lhs
->signature
== rhs
->signature
;
6027 /* Allocate a hash table for signatured types. */
6030 allocate_signatured_type_table ()
6032 return htab_up (htab_create_alloc (41,
6033 hash_signatured_type
,
6035 NULL
, xcalloc
, xfree
));
6038 /* A helper function to add a signatured type CU to a table. */
6041 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6043 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6044 std::vector
<signatured_type
*> *all_type_units
6045 = (std::vector
<signatured_type
*> *) datum
;
6047 all_type_units
->push_back (sigt
);
6052 /* A helper for create_debug_types_hash_table. Read types from SECTION
6053 and fill them into TYPES_HTAB. It will process only type units,
6054 therefore DW_UT_type. */
6057 create_debug_type_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6058 struct dwo_file
*dwo_file
,
6059 dwarf2_section_info
*section
, htab_up
&types_htab
,
6060 rcuh_kind section_kind
)
6062 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6063 struct dwarf2_section_info
*abbrev_section
;
6065 const gdb_byte
*info_ptr
, *end_ptr
;
6067 abbrev_section
= (dwo_file
!= NULL
6068 ? &dwo_file
->sections
.abbrev
6069 : &dwarf2_per_objfile
->abbrev
);
6071 if (dwarf_read_debug
)
6072 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
6073 section
->get_name (),
6074 abbrev_section
->get_file_name ());
6076 section
->read (objfile
);
6077 info_ptr
= section
->buffer
;
6079 if (info_ptr
== NULL
)
6082 /* We can't set abfd until now because the section may be empty or
6083 not present, in which case the bfd is unknown. */
6084 abfd
= section
->get_bfd_owner ();
6086 /* We don't use cutu_reader here because we don't need to read
6087 any dies: the signature is in the header. */
6089 end_ptr
= info_ptr
+ section
->size
;
6090 while (info_ptr
< end_ptr
)
6092 struct signatured_type
*sig_type
;
6093 struct dwo_unit
*dwo_tu
;
6095 const gdb_byte
*ptr
= info_ptr
;
6096 struct comp_unit_head header
;
6097 unsigned int length
;
6099 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
6101 /* Initialize it due to a false compiler warning. */
6102 header
.signature
= -1;
6103 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
6105 /* We need to read the type's signature in order to build the hash
6106 table, but we don't need anything else just yet. */
6108 ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
, &header
, section
,
6109 abbrev_section
, ptr
, section_kind
);
6111 length
= header
.get_length ();
6113 /* Skip dummy type units. */
6114 if (ptr
>= info_ptr
+ length
6115 || peek_abbrev_code (abfd
, ptr
) == 0
6116 || header
.unit_type
!= DW_UT_type
)
6122 if (types_htab
== NULL
)
6125 types_htab
= allocate_dwo_unit_table ();
6127 types_htab
= allocate_signatured_type_table ();
6133 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6135 dwo_tu
->dwo_file
= dwo_file
;
6136 dwo_tu
->signature
= header
.signature
;
6137 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6138 dwo_tu
->section
= section
;
6139 dwo_tu
->sect_off
= sect_off
;
6140 dwo_tu
->length
= length
;
6144 /* N.B.: type_offset is not usable if this type uses a DWO file.
6145 The real type_offset is in the DWO file. */
6147 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6148 struct signatured_type
);
6149 sig_type
->signature
= header
.signature
;
6150 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6151 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
6152 sig_type
->per_cu
.is_debug_types
= 1;
6153 sig_type
->per_cu
.section
= section
;
6154 sig_type
->per_cu
.sect_off
= sect_off
;
6155 sig_type
->per_cu
.length
= length
;
6158 slot
= htab_find_slot (types_htab
.get (),
6159 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
6161 gdb_assert (slot
!= NULL
);
6164 sect_offset dup_sect_off
;
6168 const struct dwo_unit
*dup_tu
6169 = (const struct dwo_unit
*) *slot
;
6171 dup_sect_off
= dup_tu
->sect_off
;
6175 const struct signatured_type
*dup_tu
6176 = (const struct signatured_type
*) *slot
;
6178 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
6181 complaint (_("debug type entry at offset %s is duplicate to"
6182 " the entry at offset %s, signature %s"),
6183 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
6184 hex_string (header
.signature
));
6186 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
6188 if (dwarf_read_debug
> 1)
6189 fprintf_unfiltered (gdb_stdlog
, " offset %s, signature %s\n",
6190 sect_offset_str (sect_off
),
6191 hex_string (header
.signature
));
6197 /* Create the hash table of all entries in the .debug_types
6198 (or .debug_types.dwo) section(s).
6199 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6200 otherwise it is NULL.
6202 The result is a pointer to the hash table or NULL if there are no types.
6204 Note: This function processes DWO files only, not DWP files. */
6207 create_debug_types_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6208 struct dwo_file
*dwo_file
,
6209 gdb::array_view
<dwarf2_section_info
> type_sections
,
6210 htab_up
&types_htab
)
6212 for (dwarf2_section_info
§ion
: type_sections
)
6213 create_debug_type_hash_table (dwarf2_per_objfile
, dwo_file
, §ion
,
6214 types_htab
, rcuh_kind::TYPE
);
6217 /* Create the hash table of all entries in the .debug_types section,
6218 and initialize all_type_units.
6219 The result is zero if there is an error (e.g. missing .debug_types section),
6220 otherwise non-zero. */
6223 create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
6227 create_debug_type_hash_table (dwarf2_per_objfile
, NULL
,
6228 &dwarf2_per_objfile
->info
, types_htab
,
6229 rcuh_kind::COMPILE
);
6230 create_debug_types_hash_table (dwarf2_per_objfile
, NULL
,
6231 dwarf2_per_objfile
->types
, types_htab
);
6232 if (types_htab
== NULL
)
6234 dwarf2_per_objfile
->signatured_types
= NULL
;
6238 dwarf2_per_objfile
->signatured_types
= std::move (types_htab
);
6240 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
6241 dwarf2_per_objfile
->all_type_units
.reserve
6242 (htab_elements (dwarf2_per_objfile
->signatured_types
.get ()));
6244 htab_traverse_noresize (dwarf2_per_objfile
->signatured_types
.get (),
6245 add_signatured_type_cu_to_table
,
6246 &dwarf2_per_objfile
->all_type_units
);
6251 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6252 If SLOT is non-NULL, it is the entry to use in the hash table.
6253 Otherwise we find one. */
6255 static struct signatured_type
*
6256 add_type_unit (struct dwarf2_per_objfile
*dwarf2_per_objfile
, ULONGEST sig
,
6259 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6261 if (dwarf2_per_objfile
->all_type_units
.size ()
6262 == dwarf2_per_objfile
->all_type_units
.capacity ())
6263 ++dwarf2_per_objfile
->tu_stats
.nr_all_type_units_reallocs
;
6265 signatured_type
*sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6266 struct signatured_type
);
6268 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
6269 sig_type
->signature
= sig
;
6270 sig_type
->per_cu
.is_debug_types
= 1;
6271 if (dwarf2_per_objfile
->using_index
)
6273 sig_type
->per_cu
.v
.quick
=
6274 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6275 struct dwarf2_per_cu_quick_data
);
6280 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
.get (),
6283 gdb_assert (*slot
== NULL
);
6285 /* The rest of sig_type must be filled in by the caller. */
6289 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6290 Fill in SIG_ENTRY with DWO_ENTRY. */
6293 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6294 struct signatured_type
*sig_entry
,
6295 struct dwo_unit
*dwo_entry
)
6297 /* Make sure we're not clobbering something we don't expect to. */
6298 gdb_assert (! sig_entry
->per_cu
.queued
);
6299 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
6300 if (dwarf2_per_objfile
->using_index
)
6302 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
6303 gdb_assert (sig_entry
->per_cu
.v
.quick
->compunit_symtab
== NULL
);
6306 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
6307 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
6308 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
6309 gdb_assert (sig_entry
->type_unit_group
== NULL
);
6310 gdb_assert (sig_entry
->dwo_unit
== NULL
);
6312 sig_entry
->per_cu
.section
= dwo_entry
->section
;
6313 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
6314 sig_entry
->per_cu
.length
= dwo_entry
->length
;
6315 sig_entry
->per_cu
.reading_dwo_directly
= 1;
6316 sig_entry
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
6317 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
6318 sig_entry
->dwo_unit
= dwo_entry
;
6321 /* Subroutine of lookup_signatured_type.
6322 If we haven't read the TU yet, create the signatured_type data structure
6323 for a TU to be read in directly from a DWO file, bypassing the stub.
6324 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6325 using .gdb_index, then when reading a CU we want to stay in the DWO file
6326 containing that CU. Otherwise we could end up reading several other DWO
6327 files (due to comdat folding) to process the transitive closure of all the
6328 mentioned TUs, and that can be slow. The current DWO file will have every
6329 type signature that it needs.
6330 We only do this for .gdb_index because in the psymtab case we already have
6331 to read all the DWOs to build the type unit groups. */
6333 static struct signatured_type
*
6334 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6336 struct dwarf2_per_objfile
*dwarf2_per_objfile
6337 = cu
->per_cu
->dwarf2_per_objfile
;
6338 struct dwo_file
*dwo_file
;
6339 struct dwo_unit find_dwo_entry
, *dwo_entry
;
6340 struct signatured_type find_sig_entry
, *sig_entry
;
6343 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
6345 /* If TU skeletons have been removed then we may not have read in any
6347 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6348 dwarf2_per_objfile
->signatured_types
= allocate_signatured_type_table ();
6350 /* We only ever need to read in one copy of a signatured type.
6351 Use the global signatured_types array to do our own comdat-folding
6352 of types. If this is the first time we're reading this TU, and
6353 the TU has an entry in .gdb_index, replace the recorded data from
6354 .gdb_index with this TU. */
6356 find_sig_entry
.signature
= sig
;
6357 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
.get (),
6358 &find_sig_entry
, INSERT
);
6359 sig_entry
= (struct signatured_type
*) *slot
;
6361 /* We can get here with the TU already read, *or* in the process of being
6362 read. Don't reassign the global entry to point to this DWO if that's
6363 the case. Also note that if the TU is already being read, it may not
6364 have come from a DWO, the program may be a mix of Fission-compiled
6365 code and non-Fission-compiled code. */
6367 /* Have we already tried to read this TU?
6368 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6369 needn't exist in the global table yet). */
6370 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
6373 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6374 dwo_unit of the TU itself. */
6375 dwo_file
= cu
->dwo_unit
->dwo_file
;
6377 /* Ok, this is the first time we're reading this TU. */
6378 if (dwo_file
->tus
== NULL
)
6380 find_dwo_entry
.signature
= sig
;
6381 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
6383 if (dwo_entry
== NULL
)
6386 /* If the global table doesn't have an entry for this TU, add one. */
6387 if (sig_entry
== NULL
)
6388 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
6390 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
6391 sig_entry
->per_cu
.tu_read
= 1;
6395 /* Subroutine of lookup_signatured_type.
6396 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6397 then try the DWP file. If the TU stub (skeleton) has been removed then
6398 it won't be in .gdb_index. */
6400 static struct signatured_type
*
6401 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6403 struct dwarf2_per_objfile
*dwarf2_per_objfile
6404 = cu
->per_cu
->dwarf2_per_objfile
;
6405 struct dwp_file
*dwp_file
= get_dwp_file (dwarf2_per_objfile
);
6406 struct dwo_unit
*dwo_entry
;
6407 struct signatured_type find_sig_entry
, *sig_entry
;
6410 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
6411 gdb_assert (dwp_file
!= NULL
);
6413 /* If TU skeletons have been removed then we may not have read in any
6415 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6416 dwarf2_per_objfile
->signatured_types
= allocate_signatured_type_table ();
6418 find_sig_entry
.signature
= sig
;
6419 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
.get (),
6420 &find_sig_entry
, INSERT
);
6421 sig_entry
= (struct signatured_type
*) *slot
;
6423 /* Have we already tried to read this TU?
6424 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6425 needn't exist in the global table yet). */
6426 if (sig_entry
!= NULL
)
6429 if (dwp_file
->tus
== NULL
)
6431 dwo_entry
= lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, NULL
,
6432 sig
, 1 /* is_debug_types */);
6433 if (dwo_entry
== NULL
)
6436 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
6437 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
6442 /* Lookup a signature based type for DW_FORM_ref_sig8.
6443 Returns NULL if signature SIG is not present in the table.
6444 It is up to the caller to complain about this. */
6446 static struct signatured_type
*
6447 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6449 struct dwarf2_per_objfile
*dwarf2_per_objfile
6450 = cu
->per_cu
->dwarf2_per_objfile
;
6453 && dwarf2_per_objfile
->using_index
)
6455 /* We're in a DWO/DWP file, and we're using .gdb_index.
6456 These cases require special processing. */
6457 if (get_dwp_file (dwarf2_per_objfile
) == NULL
)
6458 return lookup_dwo_signatured_type (cu
, sig
);
6460 return lookup_dwp_signatured_type (cu
, sig
);
6464 struct signatured_type find_entry
, *entry
;
6466 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6468 find_entry
.signature
= sig
;
6469 entry
= ((struct signatured_type
*)
6470 htab_find (dwarf2_per_objfile
->signatured_types
.get (),
6476 /* Return the address base of the compile unit, which, if exists, is stored
6477 either at the attribute DW_AT_GNU_addr_base, or DW_AT_addr_base. */
6478 static gdb::optional
<ULONGEST
>
6479 lookup_addr_base (struct die_info
*comp_unit_die
)
6481 struct attribute
*attr
;
6482 attr
= dwarf2_attr_no_follow (comp_unit_die
, DW_AT_addr_base
);
6483 if (attr
== nullptr)
6484 attr
= dwarf2_attr_no_follow (comp_unit_die
, DW_AT_GNU_addr_base
);
6485 if (attr
== nullptr)
6486 return gdb::optional
<ULONGEST
> ();
6487 return DW_UNSND (attr
);
6490 /* Return range lists base of the compile unit, which, if exists, is stored
6491 either at the attribute DW_AT_rnglists_base or DW_AT_GNU_ranges_base. */
6493 lookup_ranges_base (struct die_info
*comp_unit_die
)
6495 struct attribute
*attr
;
6496 attr
= dwarf2_attr_no_follow (comp_unit_die
, DW_AT_rnglists_base
);
6497 if (attr
== nullptr)
6498 attr
= dwarf2_attr_no_follow (comp_unit_die
, DW_AT_GNU_ranges_base
);
6499 if (attr
== nullptr)
6501 return DW_UNSND (attr
);
6504 /* Low level DIE reading support. */
6506 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
6509 init_cu_die_reader (struct die_reader_specs
*reader
,
6510 struct dwarf2_cu
*cu
,
6511 struct dwarf2_section_info
*section
,
6512 struct dwo_file
*dwo_file
,
6513 struct abbrev_table
*abbrev_table
)
6515 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
6516 reader
->abfd
= section
->get_bfd_owner ();
6518 reader
->dwo_file
= dwo_file
;
6519 reader
->die_section
= section
;
6520 reader
->buffer
= section
->buffer
;
6521 reader
->buffer_end
= section
->buffer
+ section
->size
;
6522 reader
->abbrev_table
= abbrev_table
;
6525 /* Subroutine of cutu_reader to simplify it.
6526 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
6527 There's just a lot of work to do, and cutu_reader is big enough
6530 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
6531 from it to the DIE in the DWO. If NULL we are skipping the stub.
6532 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
6533 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
6534 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
6535 STUB_COMP_DIR may be non-NULL.
6536 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE
6537 are filled in with the info of the DIE from the DWO file.
6538 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
6539 from the dwo. Since *RESULT_READER references this abbrev table, it must be
6540 kept around for at least as long as *RESULT_READER.
6542 The result is non-zero if a valid (non-dummy) DIE was found. */
6545 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
6546 struct dwo_unit
*dwo_unit
,
6547 struct die_info
*stub_comp_unit_die
,
6548 const char *stub_comp_dir
,
6549 struct die_reader_specs
*result_reader
,
6550 const gdb_byte
**result_info_ptr
,
6551 struct die_info
**result_comp_unit_die
,
6552 abbrev_table_up
*result_dwo_abbrev_table
)
6554 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
6555 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6556 struct dwarf2_cu
*cu
= this_cu
->cu
;
6558 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6559 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
6560 int i
,num_extra_attrs
;
6561 struct dwarf2_section_info
*dwo_abbrev_section
;
6562 struct die_info
*comp_unit_die
;
6564 /* At most one of these may be provided. */
6565 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
6567 /* These attributes aren't processed until later:
6568 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
6569 DW_AT_comp_dir is used now, to find the DWO file, but it is also
6570 referenced later. However, these attributes are found in the stub
6571 which we won't have later. In order to not impose this complication
6572 on the rest of the code, we read them here and copy them to the
6581 if (stub_comp_unit_die
!= NULL
)
6583 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
6585 if (! this_cu
->is_debug_types
)
6586 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
6587 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
6588 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
6589 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
6590 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
6592 cu
->addr_base
= lookup_addr_base (stub_comp_unit_die
);
6594 /* There should be a DW_AT_rnglists_base (DW_AT_GNU_ranges_base) attribute
6595 here (if needed). We need the value before we can process
6597 cu
->ranges_base
= lookup_ranges_base (stub_comp_unit_die
);
6599 else if (stub_comp_dir
!= NULL
)
6601 /* Reconstruct the comp_dir attribute to simplify the code below. */
6602 comp_dir
= XOBNEW (&cu
->comp_unit_obstack
, struct attribute
);
6603 comp_dir
->name
= DW_AT_comp_dir
;
6604 comp_dir
->form
= DW_FORM_string
;
6605 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
6606 DW_STRING (comp_dir
) = stub_comp_dir
;
6609 /* Set up for reading the DWO CU/TU. */
6610 cu
->dwo_unit
= dwo_unit
;
6611 dwarf2_section_info
*section
= dwo_unit
->section
;
6612 section
->read (objfile
);
6613 abfd
= section
->get_bfd_owner ();
6614 begin_info_ptr
= info_ptr
= (section
->buffer
6615 + to_underlying (dwo_unit
->sect_off
));
6616 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
6618 if (this_cu
->is_debug_types
)
6620 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
6622 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
6623 &cu
->header
, section
,
6625 info_ptr
, rcuh_kind::TYPE
);
6626 /* This is not an assert because it can be caused by bad debug info. */
6627 if (sig_type
->signature
!= cu
->header
.signature
)
6629 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
6630 " TU at offset %s [in module %s]"),
6631 hex_string (sig_type
->signature
),
6632 hex_string (cu
->header
.signature
),
6633 sect_offset_str (dwo_unit
->sect_off
),
6634 bfd_get_filename (abfd
));
6636 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6637 /* For DWOs coming from DWP files, we don't know the CU length
6638 nor the type's offset in the TU until now. */
6639 dwo_unit
->length
= cu
->header
.get_length ();
6640 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
6642 /* Establish the type offset that can be used to lookup the type.
6643 For DWO files, we don't know it until now. */
6644 sig_type
->type_offset_in_section
6645 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
6649 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
6650 &cu
->header
, section
,
6652 info_ptr
, rcuh_kind::COMPILE
);
6653 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6654 /* For DWOs coming from DWP files, we don't know the CU length
6656 dwo_unit
->length
= cu
->header
.get_length ();
6659 *result_dwo_abbrev_table
6660 = abbrev_table::read (objfile
, dwo_abbrev_section
,
6661 cu
->header
.abbrev_sect_off
);
6662 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
6663 result_dwo_abbrev_table
->get ());
6665 /* Read in the die, but leave space to copy over the attributes
6666 from the stub. This has the benefit of simplifying the rest of
6667 the code - all the work to maintain the illusion of a single
6668 DW_TAG_{compile,type}_unit DIE is done here. */
6669 num_extra_attrs
= ((stmt_list
!= NULL
)
6673 + (comp_dir
!= NULL
));
6674 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
6677 /* Copy over the attributes from the stub to the DIE we just read in. */
6678 comp_unit_die
= *result_comp_unit_die
;
6679 i
= comp_unit_die
->num_attrs
;
6680 if (stmt_list
!= NULL
)
6681 comp_unit_die
->attrs
[i
++] = *stmt_list
;
6683 comp_unit_die
->attrs
[i
++] = *low_pc
;
6684 if (high_pc
!= NULL
)
6685 comp_unit_die
->attrs
[i
++] = *high_pc
;
6687 comp_unit_die
->attrs
[i
++] = *ranges
;
6688 if (comp_dir
!= NULL
)
6689 comp_unit_die
->attrs
[i
++] = *comp_dir
;
6690 comp_unit_die
->num_attrs
+= num_extra_attrs
;
6692 if (dwarf_die_debug
)
6694 fprintf_unfiltered (gdb_stdlog
,
6695 "Read die from %s@0x%x of %s:\n",
6696 section
->get_name (),
6697 (unsigned) (begin_info_ptr
- section
->buffer
),
6698 bfd_get_filename (abfd
));
6699 dump_die (comp_unit_die
, dwarf_die_debug
);
6702 /* Skip dummy compilation units. */
6703 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
6704 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6707 *result_info_ptr
= info_ptr
;
6711 /* Return the signature of the compile unit, if found. In DWARF 4 and before,
6712 the signature is in the DW_AT_GNU_dwo_id attribute. In DWARF 5 and later, the
6713 signature is part of the header. */
6714 static gdb::optional
<ULONGEST
>
6715 lookup_dwo_id (struct dwarf2_cu
*cu
, struct die_info
* comp_unit_die
)
6717 if (cu
->header
.version
>= 5)
6718 return cu
->header
.signature
;
6719 struct attribute
*attr
;
6720 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
6721 if (attr
== nullptr)
6722 return gdb::optional
<ULONGEST
> ();
6723 return DW_UNSND (attr
);
6726 /* Subroutine of cutu_reader to simplify it.
6727 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
6728 Returns NULL if the specified DWO unit cannot be found. */
6730 static struct dwo_unit
*
6731 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
6732 struct die_info
*comp_unit_die
,
6733 const char *dwo_name
)
6735 struct dwarf2_cu
*cu
= this_cu
->cu
;
6736 struct dwo_unit
*dwo_unit
;
6737 const char *comp_dir
;
6739 gdb_assert (cu
!= NULL
);
6741 /* Yeah, we look dwo_name up again, but it simplifies the code. */
6742 dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
6743 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
6745 if (this_cu
->is_debug_types
)
6747 struct signatured_type
*sig_type
;
6749 /* Since this_cu is the first member of struct signatured_type,
6750 we can go from a pointer to one to a pointer to the other. */
6751 sig_type
= (struct signatured_type
*) this_cu
;
6752 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
6756 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
6757 if (!signature
.has_value ())
6758 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
6760 dwo_name
, objfile_name (this_cu
->dwarf2_per_objfile
->objfile
));
6761 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
6768 /* Subroutine of cutu_reader to simplify it.
6769 See it for a description of the parameters.
6770 Read a TU directly from a DWO file, bypassing the stub. */
6773 cutu_reader::init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
6774 int use_existing_cu
)
6776 struct signatured_type
*sig_type
;
6778 /* Verify we can do the following downcast, and that we have the
6780 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
6781 sig_type
= (struct signatured_type
*) this_cu
;
6782 gdb_assert (sig_type
->dwo_unit
!= NULL
);
6784 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
6786 gdb_assert (this_cu
->cu
->dwo_unit
== sig_type
->dwo_unit
);
6787 /* There's no need to do the rereading_dwo_cu handling that
6788 cutu_reader does since we don't read the stub. */
6792 /* If !use_existing_cu, this_cu->cu must be NULL. */
6793 gdb_assert (this_cu
->cu
== NULL
);
6794 m_new_cu
.reset (new dwarf2_cu (this_cu
));
6797 /* A future optimization, if needed, would be to use an existing
6798 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
6799 could share abbrev tables. */
6801 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
6802 NULL
/* stub_comp_unit_die */,
6803 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
6806 &m_dwo_abbrev_table
) == 0)
6813 /* Initialize a CU (or TU) and read its DIEs.
6814 If the CU defers to a DWO file, read the DWO file as well.
6816 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
6817 Otherwise the table specified in the comp unit header is read in and used.
6818 This is an optimization for when we already have the abbrev table.
6820 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
6821 Otherwise, a new CU is allocated with xmalloc. */
6823 cutu_reader::cutu_reader (struct dwarf2_per_cu_data
*this_cu
,
6824 struct abbrev_table
*abbrev_table
,
6825 int use_existing_cu
,
6827 : die_reader_specs
{},
6830 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
6831 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6832 struct dwarf2_section_info
*section
= this_cu
->section
;
6833 bfd
*abfd
= section
->get_bfd_owner ();
6834 struct dwarf2_cu
*cu
;
6835 const gdb_byte
*begin_info_ptr
;
6836 struct signatured_type
*sig_type
= NULL
;
6837 struct dwarf2_section_info
*abbrev_section
;
6838 /* Non-zero if CU currently points to a DWO file and we need to
6839 reread it. When this happens we need to reread the skeleton die
6840 before we can reread the DWO file (this only applies to CUs, not TUs). */
6841 int rereading_dwo_cu
= 0;
6843 if (dwarf_die_debug
)
6844 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
6845 this_cu
->is_debug_types
? "type" : "comp",
6846 sect_offset_str (this_cu
->sect_off
));
6848 /* If we're reading a TU directly from a DWO file, including a virtual DWO
6849 file (instead of going through the stub), short-circuit all of this. */
6850 if (this_cu
->reading_dwo_directly
)
6852 /* Narrow down the scope of possibilities to have to understand. */
6853 gdb_assert (this_cu
->is_debug_types
);
6854 gdb_assert (abbrev_table
== NULL
);
6855 init_tu_and_read_dwo_dies (this_cu
, use_existing_cu
);
6859 /* This is cheap if the section is already read in. */
6860 section
->read (objfile
);
6862 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
6864 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
6866 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
6869 /* If this CU is from a DWO file we need to start over, we need to
6870 refetch the attributes from the skeleton CU.
6871 This could be optimized by retrieving those attributes from when we
6872 were here the first time: the previous comp_unit_die was stored in
6873 comp_unit_obstack. But there's no data yet that we need this
6875 if (cu
->dwo_unit
!= NULL
)
6876 rereading_dwo_cu
= 1;
6880 /* If !use_existing_cu, this_cu->cu must be NULL. */
6881 gdb_assert (this_cu
->cu
== NULL
);
6882 m_new_cu
.reset (new dwarf2_cu (this_cu
));
6883 cu
= m_new_cu
.get ();
6886 /* Get the header. */
6887 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
6889 /* We already have the header, there's no need to read it in again. */
6890 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
6894 if (this_cu
->is_debug_types
)
6896 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
6897 &cu
->header
, section
,
6898 abbrev_section
, info_ptr
,
6901 /* Since per_cu is the first member of struct signatured_type,
6902 we can go from a pointer to one to a pointer to the other. */
6903 sig_type
= (struct signatured_type
*) this_cu
;
6904 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
6905 gdb_assert (sig_type
->type_offset_in_tu
6906 == cu
->header
.type_cu_offset_in_tu
);
6907 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
6909 /* LENGTH has not been set yet for type units if we're
6910 using .gdb_index. */
6911 this_cu
->length
= cu
->header
.get_length ();
6913 /* Establish the type offset that can be used to lookup the type. */
6914 sig_type
->type_offset_in_section
=
6915 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
6917 this_cu
->dwarf_version
= cu
->header
.version
;
6921 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
6922 &cu
->header
, section
,
6925 rcuh_kind::COMPILE
);
6927 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
6928 gdb_assert (this_cu
->length
== cu
->header
.get_length ());
6929 this_cu
->dwarf_version
= cu
->header
.version
;
6933 /* Skip dummy compilation units. */
6934 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
6935 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6941 /* If we don't have them yet, read the abbrevs for this compilation unit.
6942 And if we need to read them now, make sure they're freed when we're
6944 if (abbrev_table
!= NULL
)
6945 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
6948 m_abbrev_table_holder
6949 = abbrev_table::read (objfile
, abbrev_section
,
6950 cu
->header
.abbrev_sect_off
);
6951 abbrev_table
= m_abbrev_table_holder
.get ();
6954 /* Read the top level CU/TU die. */
6955 init_cu_die_reader (this, cu
, section
, NULL
, abbrev_table
);
6956 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
6958 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
6964 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
6965 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
6966 table from the DWO file and pass the ownership over to us. It will be
6967 referenced from READER, so we must make sure to free it after we're done
6970 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
6971 DWO CU, that this test will fail (the attribute will not be present). */
6972 const char *dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
6973 if (dwo_name
!= nullptr)
6975 struct dwo_unit
*dwo_unit
;
6976 struct die_info
*dwo_comp_unit_die
;
6978 if (comp_unit_die
->has_children
)
6980 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
6981 " has children (offset %s) [in module %s]"),
6982 sect_offset_str (this_cu
->sect_off
),
6983 bfd_get_filename (abfd
));
6985 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
, dwo_name
);
6986 if (dwo_unit
!= NULL
)
6988 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
6989 comp_unit_die
, NULL
,
6992 &m_dwo_abbrev_table
) == 0)
6998 comp_unit_die
= dwo_comp_unit_die
;
7002 /* Yikes, we couldn't find the rest of the DIE, we only have
7003 the stub. A complaint has already been logged. There's
7004 not much more we can do except pass on the stub DIE to
7005 die_reader_func. We don't want to throw an error on bad
7012 cutu_reader::keep ()
7014 /* Done, clean up. */
7015 gdb_assert (!dummy_p
);
7016 if (m_new_cu
!= NULL
)
7018 struct dwarf2_per_objfile
*dwarf2_per_objfile
7019 = m_this_cu
->dwarf2_per_objfile
;
7020 /* Link this CU into read_in_chain. */
7021 m_this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
7022 dwarf2_per_objfile
->read_in_chain
= m_this_cu
;
7023 /* The chain owns it now. */
7024 m_new_cu
.release ();
7028 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name (DW_AT_dwo_name)
7029 if present. DWO_FILE, if non-NULL, is the DWO file to read (the caller is
7030 assumed to have already done the lookup to find the DWO file).
7032 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7033 THIS_CU->is_debug_types, but nothing else.
7035 We fill in THIS_CU->length.
7037 THIS_CU->cu is always freed when done.
7038 This is done in order to not leave THIS_CU->cu in a state where we have
7039 to care whether it refers to the "main" CU or the DWO CU.
7041 When parent_cu is passed, it is used to provide a default value for
7042 str_offsets_base and addr_base from the parent. */
7044 cutu_reader::cutu_reader (struct dwarf2_per_cu_data
*this_cu
,
7045 struct dwarf2_cu
*parent_cu
,
7046 struct dwo_file
*dwo_file
)
7047 : die_reader_specs
{},
7050 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7051 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7052 struct dwarf2_section_info
*section
= this_cu
->section
;
7053 bfd
*abfd
= section
->get_bfd_owner ();
7054 struct dwarf2_section_info
*abbrev_section
;
7055 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7057 if (dwarf_die_debug
)
7058 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7059 this_cu
->is_debug_types
? "type" : "comp",
7060 sect_offset_str (this_cu
->sect_off
));
7062 gdb_assert (this_cu
->cu
== NULL
);
7064 abbrev_section
= (dwo_file
!= NULL
7065 ? &dwo_file
->sections
.abbrev
7066 : get_abbrev_section_for_cu (this_cu
));
7068 /* This is cheap if the section is already read in. */
7069 section
->read (objfile
);
7071 m_new_cu
.reset (new dwarf2_cu (this_cu
));
7073 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7074 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7075 &m_new_cu
->header
, section
,
7076 abbrev_section
, info_ptr
,
7077 (this_cu
->is_debug_types
7079 : rcuh_kind::COMPILE
));
7081 if (parent_cu
!= nullptr)
7083 m_new_cu
->str_offsets_base
= parent_cu
->str_offsets_base
;
7084 m_new_cu
->addr_base
= parent_cu
->addr_base
;
7086 this_cu
->length
= m_new_cu
->header
.get_length ();
7088 /* Skip dummy compilation units. */
7089 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7090 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7096 m_abbrev_table_holder
7097 = abbrev_table::read (objfile
, abbrev_section
,
7098 m_new_cu
->header
.abbrev_sect_off
);
7100 init_cu_die_reader (this, m_new_cu
.get (), section
, dwo_file
,
7101 m_abbrev_table_holder
.get ());
7102 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7106 /* Type Unit Groups.
7108 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7109 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7110 so that all types coming from the same compilation (.o file) are grouped
7111 together. A future step could be to put the types in the same symtab as
7112 the CU the types ultimately came from. */
7115 hash_type_unit_group (const void *item
)
7117 const struct type_unit_group
*tu_group
7118 = (const struct type_unit_group
*) item
;
7120 return hash_stmt_list_entry (&tu_group
->hash
);
7124 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
7126 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
7127 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
7129 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
7132 /* Allocate a hash table for type unit groups. */
7135 allocate_type_unit_groups_table ()
7137 return htab_up (htab_create_alloc (3,
7138 hash_type_unit_group
,
7140 NULL
, xcalloc
, xfree
));
7143 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7144 partial symtabs. We combine several TUs per psymtab to not let the size
7145 of any one psymtab grow too big. */
7146 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7147 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7149 /* Helper routine for get_type_unit_group.
7150 Create the type_unit_group object used to hold one or more TUs. */
7152 static struct type_unit_group
*
7153 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
7155 struct dwarf2_per_objfile
*dwarf2_per_objfile
7156 = cu
->per_cu
->dwarf2_per_objfile
;
7157 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7158 struct dwarf2_per_cu_data
*per_cu
;
7159 struct type_unit_group
*tu_group
;
7161 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7162 struct type_unit_group
);
7163 per_cu
= &tu_group
->per_cu
;
7164 per_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
7166 if (dwarf2_per_objfile
->using_index
)
7168 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7169 struct dwarf2_per_cu_quick_data
);
7173 unsigned int line_offset
= to_underlying (line_offset_struct
);
7174 dwarf2_psymtab
*pst
;
7177 /* Give the symtab a useful name for debug purposes. */
7178 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
7179 name
= string_printf ("<type_units_%d>",
7180 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
7182 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
7184 pst
= create_partial_symtab (per_cu
, name
.c_str ());
7185 pst
->anonymous
= true;
7188 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
7189 tu_group
->hash
.line_sect_off
= line_offset_struct
;
7194 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7195 STMT_LIST is a DW_AT_stmt_list attribute. */
7197 static struct type_unit_group
*
7198 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
7200 struct dwarf2_per_objfile
*dwarf2_per_objfile
7201 = cu
->per_cu
->dwarf2_per_objfile
;
7202 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
7203 struct type_unit_group
*tu_group
;
7205 unsigned int line_offset
;
7206 struct type_unit_group type_unit_group_for_lookup
;
7208 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
7209 dwarf2_per_objfile
->type_unit_groups
= allocate_type_unit_groups_table ();
7211 /* Do we need to create a new group, or can we use an existing one? */
7215 line_offset
= DW_UNSND (stmt_list
);
7216 ++tu_stats
->nr_symtab_sharers
;
7220 /* Ugh, no stmt_list. Rare, but we have to handle it.
7221 We can do various things here like create one group per TU or
7222 spread them over multiple groups to split up the expansion work.
7223 To avoid worst case scenarios (too many groups or too large groups)
7224 we, umm, group them in bunches. */
7225 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7226 | (tu_stats
->nr_stmt_less_type_units
7227 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
7228 ++tu_stats
->nr_stmt_less_type_units
;
7231 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
7232 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
7233 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
.get (),
7234 &type_unit_group_for_lookup
, INSERT
);
7237 tu_group
= (struct type_unit_group
*) *slot
;
7238 gdb_assert (tu_group
!= NULL
);
7242 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
7243 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
7245 ++tu_stats
->nr_symtabs
;
7251 /* Partial symbol tables. */
7253 /* Create a psymtab named NAME and assign it to PER_CU.
7255 The caller must fill in the following details:
7256 dirname, textlow, texthigh. */
7258 static dwarf2_psymtab
*
7259 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
7261 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
7262 dwarf2_psymtab
*pst
;
7264 pst
= new dwarf2_psymtab (name
, objfile
, 0);
7266 pst
->psymtabs_addrmap_supported
= true;
7268 /* This is the glue that links PST into GDB's symbol API. */
7269 pst
->per_cu_data
= per_cu
;
7270 per_cu
->v
.psymtab
= pst
;
7275 /* DIE reader function for process_psymtab_comp_unit. */
7278 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
7279 const gdb_byte
*info_ptr
,
7280 struct die_info
*comp_unit_die
,
7281 enum language pretend_language
)
7283 struct dwarf2_cu
*cu
= reader
->cu
;
7284 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
7285 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7286 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7288 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
7289 dwarf2_psymtab
*pst
;
7290 enum pc_bounds_kind cu_bounds_kind
;
7291 const char *filename
;
7293 gdb_assert (! per_cu
->is_debug_types
);
7295 prepare_one_comp_unit (cu
, comp_unit_die
, pretend_language
);
7297 /* Allocate a new partial symbol table structure. */
7298 gdb::unique_xmalloc_ptr
<char> debug_filename
;
7299 static const char artificial
[] = "<artificial>";
7300 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
7301 if (filename
== NULL
)
7303 else if (strcmp (filename
, artificial
) == 0)
7305 debug_filename
.reset (concat (artificial
, "@",
7306 sect_offset_str (per_cu
->sect_off
),
7308 filename
= debug_filename
.get ();
7311 pst
= create_partial_symtab (per_cu
, filename
);
7313 /* This must be done before calling dwarf2_build_include_psymtabs. */
7314 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7316 baseaddr
= objfile
->text_section_offset ();
7318 dwarf2_find_base_address (comp_unit_die
, cu
);
7320 /* Possibly set the default values of LOWPC and HIGHPC from
7322 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
7323 &best_highpc
, cu
, pst
);
7324 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
7327 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
7330 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
7332 /* Store the contiguous range if it is not empty; it can be
7333 empty for CUs with no code. */
7334 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
7338 /* Check if comp unit has_children.
7339 If so, read the rest of the partial symbols from this comp unit.
7340 If not, there's no more debug_info for this comp unit. */
7341 if (comp_unit_die
->has_children
)
7343 struct partial_die_info
*first_die
;
7344 CORE_ADDR lowpc
, highpc
;
7346 lowpc
= ((CORE_ADDR
) -1);
7347 highpc
= ((CORE_ADDR
) 0);
7349 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7351 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
7352 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
7354 /* If we didn't find a lowpc, set it to highpc to avoid
7355 complaints from `maint check'. */
7356 if (lowpc
== ((CORE_ADDR
) -1))
7359 /* If the compilation unit didn't have an explicit address range,
7360 then use the information extracted from its child dies. */
7361 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
7364 best_highpc
= highpc
;
7367 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
7368 best_lowpc
+ baseaddr
)
7370 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
7371 best_highpc
+ baseaddr
)
7374 end_psymtab_common (objfile
, pst
);
7376 if (!cu
->per_cu
->imported_symtabs_empty ())
7379 int len
= cu
->per_cu
->imported_symtabs_size ();
7381 /* Fill in 'dependencies' here; we fill in 'users' in a
7383 pst
->number_of_dependencies
= len
;
7385 = objfile
->partial_symtabs
->allocate_dependencies (len
);
7386 for (i
= 0; i
< len
; ++i
)
7388 pst
->dependencies
[i
]
7389 = cu
->per_cu
->imported_symtabs
->at (i
)->v
.psymtab
;
7392 cu
->per_cu
->imported_symtabs_free ();
7395 /* Get the list of files included in the current compilation unit,
7396 and build a psymtab for each of them. */
7397 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
7399 if (dwarf_read_debug
)
7400 fprintf_unfiltered (gdb_stdlog
,
7401 "Psymtab for %s unit @%s: %s - %s"
7402 ", %d global, %d static syms\n",
7403 per_cu
->is_debug_types
? "type" : "comp",
7404 sect_offset_str (per_cu
->sect_off
),
7405 paddress (gdbarch
, pst
->text_low (objfile
)),
7406 paddress (gdbarch
, pst
->text_high (objfile
)),
7407 pst
->n_global_syms
, pst
->n_static_syms
);
7410 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7411 Process compilation unit THIS_CU for a psymtab. */
7414 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
7415 bool want_partial_unit
,
7416 enum language pretend_language
)
7418 /* If this compilation unit was already read in, free the
7419 cached copy in order to read it in again. This is
7420 necessary because we skipped some symbols when we first
7421 read in the compilation unit (see load_partial_dies).
7422 This problem could be avoided, but the benefit is unclear. */
7423 if (this_cu
->cu
!= NULL
)
7424 free_one_cached_comp_unit (this_cu
);
7426 cutu_reader
reader (this_cu
, NULL
, 0, false);
7432 else if (this_cu
->is_debug_types
)
7433 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7434 reader
.comp_unit_die
);
7435 else if (want_partial_unit
7436 || reader
.comp_unit_die
->tag
!= DW_TAG_partial_unit
)
7437 process_psymtab_comp_unit_reader (&reader
, reader
.info_ptr
,
7438 reader
.comp_unit_die
,
7441 /* Age out any secondary CUs. */
7442 age_cached_comp_units (this_cu
->dwarf2_per_objfile
);
7445 /* Reader function for build_type_psymtabs. */
7448 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
7449 const gdb_byte
*info_ptr
,
7450 struct die_info
*type_unit_die
)
7452 struct dwarf2_per_objfile
*dwarf2_per_objfile
7453 = reader
->cu
->per_cu
->dwarf2_per_objfile
;
7454 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7455 struct dwarf2_cu
*cu
= reader
->cu
;
7456 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7457 struct signatured_type
*sig_type
;
7458 struct type_unit_group
*tu_group
;
7459 struct attribute
*attr
;
7460 struct partial_die_info
*first_die
;
7461 CORE_ADDR lowpc
, highpc
;
7462 dwarf2_psymtab
*pst
;
7464 gdb_assert (per_cu
->is_debug_types
);
7465 sig_type
= (struct signatured_type
*) per_cu
;
7467 if (! type_unit_die
->has_children
)
7470 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
7471 tu_group
= get_type_unit_group (cu
, attr
);
7473 if (tu_group
->tus
== nullptr)
7474 tu_group
->tus
= new std::vector
<signatured_type
*>;
7475 tu_group
->tus
->push_back (sig_type
);
7477 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
7478 pst
= create_partial_symtab (per_cu
, "");
7479 pst
->anonymous
= true;
7481 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7483 lowpc
= (CORE_ADDR
) -1;
7484 highpc
= (CORE_ADDR
) 0;
7485 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
7487 end_psymtab_common (objfile
, pst
);
7490 /* Struct used to sort TUs by their abbreviation table offset. */
7492 struct tu_abbrev_offset
7494 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
7495 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
7498 signatured_type
*sig_type
;
7499 sect_offset abbrev_offset
;
7502 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
7505 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset
&a
,
7506 const struct tu_abbrev_offset
&b
)
7508 return a
.abbrev_offset
< b
.abbrev_offset
;
7511 /* Efficiently read all the type units.
7512 This does the bulk of the work for build_type_psymtabs.
7514 The efficiency is because we sort TUs by the abbrev table they use and
7515 only read each abbrev table once. In one program there are 200K TUs
7516 sharing 8K abbrev tables.
7518 The main purpose of this function is to support building the
7519 dwarf2_per_objfile->type_unit_groups table.
7520 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
7521 can collapse the search space by grouping them by stmt_list.
7522 The savings can be significant, in the same program from above the 200K TUs
7523 share 8K stmt_list tables.
7525 FUNC is expected to call get_type_unit_group, which will create the
7526 struct type_unit_group if necessary and add it to
7527 dwarf2_per_objfile->type_unit_groups. */
7530 build_type_psymtabs_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
7532 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
7533 abbrev_table_up abbrev_table
;
7534 sect_offset abbrev_offset
;
7536 /* It's up to the caller to not call us multiple times. */
7537 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
7539 if (dwarf2_per_objfile
->all_type_units
.empty ())
7542 /* TUs typically share abbrev tables, and there can be way more TUs than
7543 abbrev tables. Sort by abbrev table to reduce the number of times we
7544 read each abbrev table in.
7545 Alternatives are to punt or to maintain a cache of abbrev tables.
7546 This is simpler and efficient enough for now.
7548 Later we group TUs by their DW_AT_stmt_list value (as this defines the
7549 symtab to use). Typically TUs with the same abbrev offset have the same
7550 stmt_list value too so in practice this should work well.
7552 The basic algorithm here is:
7554 sort TUs by abbrev table
7555 for each TU with same abbrev table:
7556 read abbrev table if first user
7557 read TU top level DIE
7558 [IWBN if DWO skeletons had DW_AT_stmt_list]
7561 if (dwarf_read_debug
)
7562 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
7564 /* Sort in a separate table to maintain the order of all_type_units
7565 for .gdb_index: TU indices directly index all_type_units. */
7566 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
7567 sorted_by_abbrev
.reserve (dwarf2_per_objfile
->all_type_units
.size ());
7569 for (signatured_type
*sig_type
: dwarf2_per_objfile
->all_type_units
)
7570 sorted_by_abbrev
.emplace_back
7571 (sig_type
, read_abbrev_offset (dwarf2_per_objfile
,
7572 sig_type
->per_cu
.section
,
7573 sig_type
->per_cu
.sect_off
));
7575 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end (),
7576 sort_tu_by_abbrev_offset
);
7578 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
7580 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
7582 /* Switch to the next abbrev table if necessary. */
7583 if (abbrev_table
== NULL
7584 || tu
.abbrev_offset
!= abbrev_offset
)
7586 abbrev_offset
= tu
.abbrev_offset
;
7588 abbrev_table::read (dwarf2_per_objfile
->objfile
,
7589 &dwarf2_per_objfile
->abbrev
,
7591 ++tu_stats
->nr_uniq_abbrev_tables
;
7594 cutu_reader
reader (&tu
.sig_type
->per_cu
, abbrev_table
.get (),
7596 if (!reader
.dummy_p
)
7597 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7598 reader
.comp_unit_die
);
7602 /* Print collected type unit statistics. */
7605 print_tu_stats (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
7607 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
7609 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
7610 fprintf_unfiltered (gdb_stdlog
, " %zu TUs\n",
7611 dwarf2_per_objfile
->all_type_units
.size ());
7612 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
7613 tu_stats
->nr_uniq_abbrev_tables
);
7614 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
7615 tu_stats
->nr_symtabs
);
7616 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
7617 tu_stats
->nr_symtab_sharers
);
7618 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
7619 tu_stats
->nr_stmt_less_type_units
);
7620 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
7621 tu_stats
->nr_all_type_units_reallocs
);
7624 /* Traversal function for build_type_psymtabs. */
7627 build_type_psymtab_dependencies (void **slot
, void *info
)
7629 struct dwarf2_per_objfile
*dwarf2_per_objfile
7630 = (struct dwarf2_per_objfile
*) info
;
7631 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7632 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
7633 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
7634 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
7635 int len
= (tu_group
->tus
== nullptr) ? 0 : tu_group
->tus
->size ();
7638 gdb_assert (len
> 0);
7639 gdb_assert (per_cu
->type_unit_group_p ());
7641 pst
->number_of_dependencies
= len
;
7642 pst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (len
);
7643 for (i
= 0; i
< len
; ++i
)
7645 struct signatured_type
*iter
= tu_group
->tus
->at (i
);
7646 gdb_assert (iter
->per_cu
.is_debug_types
);
7647 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
7648 iter
->type_unit_group
= tu_group
;
7651 delete tu_group
->tus
;
7652 tu_group
->tus
= nullptr;
7657 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7658 Build partial symbol tables for the .debug_types comp-units. */
7661 build_type_psymtabs (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
7663 if (! create_all_type_units (dwarf2_per_objfile
))
7666 build_type_psymtabs_1 (dwarf2_per_objfile
);
7669 /* Traversal function for process_skeletonless_type_unit.
7670 Read a TU in a DWO file and build partial symbols for it. */
7673 process_skeletonless_type_unit (void **slot
, void *info
)
7675 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
7676 struct dwarf2_per_objfile
*dwarf2_per_objfile
7677 = (struct dwarf2_per_objfile
*) info
;
7678 struct signatured_type find_entry
, *entry
;
7680 /* If this TU doesn't exist in the global table, add it and read it in. */
7682 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7683 dwarf2_per_objfile
->signatured_types
= allocate_signatured_type_table ();
7685 find_entry
.signature
= dwo_unit
->signature
;
7686 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
.get (),
7687 &find_entry
, INSERT
);
7688 /* If we've already seen this type there's nothing to do. What's happening
7689 is we're doing our own version of comdat-folding here. */
7693 /* This does the job that create_all_type_units would have done for
7695 entry
= add_type_unit (dwarf2_per_objfile
, dwo_unit
->signature
, slot
);
7696 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, entry
, dwo_unit
);
7699 /* This does the job that build_type_psymtabs_1 would have done. */
7700 cutu_reader
reader (&entry
->per_cu
, NULL
, 0, false);
7701 if (!reader
.dummy_p
)
7702 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7703 reader
.comp_unit_die
);
7708 /* Traversal function for process_skeletonless_type_units. */
7711 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
7713 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
7715 if (dwo_file
->tus
!= NULL
)
7716 htab_traverse_noresize (dwo_file
->tus
.get (),
7717 process_skeletonless_type_unit
, info
);
7722 /* Scan all TUs of DWO files, verifying we've processed them.
7723 This is needed in case a TU was emitted without its skeleton.
7724 Note: This can't be done until we know what all the DWO files are. */
7727 process_skeletonless_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
7729 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
7730 if (get_dwp_file (dwarf2_per_objfile
) == NULL
7731 && dwarf2_per_objfile
->dwo_files
!= NULL
)
7733 htab_traverse_noresize (dwarf2_per_objfile
->dwo_files
.get (),
7734 process_dwo_file_for_skeletonless_type_units
,
7735 dwarf2_per_objfile
);
7739 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
7742 set_partial_user (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
7744 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
7746 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
7751 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
7753 /* Set the 'user' field only if it is not already set. */
7754 if (pst
->dependencies
[j
]->user
== NULL
)
7755 pst
->dependencies
[j
]->user
= pst
;
7760 /* Build the partial symbol table by doing a quick pass through the
7761 .debug_info and .debug_abbrev sections. */
7764 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
7766 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7768 if (dwarf_read_debug
)
7770 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
7771 objfile_name (objfile
));
7774 scoped_restore restore_reading_psyms
7775 = make_scoped_restore (&dwarf2_per_objfile
->reading_partial_symbols
,
7778 dwarf2_per_objfile
->info
.read (objfile
);
7780 /* Any cached compilation units will be linked by the per-objfile
7781 read_in_chain. Make sure to free them when we're done. */
7782 free_cached_comp_units
freer (dwarf2_per_objfile
);
7784 build_type_psymtabs (dwarf2_per_objfile
);
7786 create_all_comp_units (dwarf2_per_objfile
);
7788 /* Create a temporary address map on a temporary obstack. We later
7789 copy this to the final obstack. */
7790 auto_obstack temp_obstack
;
7792 scoped_restore save_psymtabs_addrmap
7793 = make_scoped_restore (&objfile
->partial_symtabs
->psymtabs_addrmap
,
7794 addrmap_create_mutable (&temp_obstack
));
7796 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
7797 process_psymtab_comp_unit (per_cu
, false, language_minimal
);
7799 /* This has to wait until we read the CUs, we need the list of DWOs. */
7800 process_skeletonless_type_units (dwarf2_per_objfile
);
7802 /* Now that all TUs have been processed we can fill in the dependencies. */
7803 if (dwarf2_per_objfile
->type_unit_groups
!= NULL
)
7805 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
.get (),
7806 build_type_psymtab_dependencies
, dwarf2_per_objfile
);
7809 if (dwarf_read_debug
)
7810 print_tu_stats (dwarf2_per_objfile
);
7812 set_partial_user (dwarf2_per_objfile
);
7814 objfile
->partial_symtabs
->psymtabs_addrmap
7815 = addrmap_create_fixed (objfile
->partial_symtabs
->psymtabs_addrmap
,
7816 objfile
->partial_symtabs
->obstack ());
7817 /* At this point we want to keep the address map. */
7818 save_psymtabs_addrmap
.release ();
7820 if (dwarf_read_debug
)
7821 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
7822 objfile_name (objfile
));
7825 /* Load the partial DIEs for a secondary CU into memory.
7826 This is also used when rereading a primary CU with load_all_dies. */
7829 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
7831 cutu_reader
reader (this_cu
, NULL
, 1, false);
7833 if (!reader
.dummy_p
)
7835 prepare_one_comp_unit (reader
.cu
, reader
.comp_unit_die
,
7838 /* Check if comp unit has_children.
7839 If so, read the rest of the partial symbols from this comp unit.
7840 If not, there's no more debug_info for this comp unit. */
7841 if (reader
.comp_unit_die
->has_children
)
7842 load_partial_dies (&reader
, reader
.info_ptr
, 0);
7849 read_comp_units_from_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
7850 struct dwarf2_section_info
*section
,
7851 struct dwarf2_section_info
*abbrev_section
,
7852 unsigned int is_dwz
)
7854 const gdb_byte
*info_ptr
;
7855 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7857 if (dwarf_read_debug
)
7858 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
7859 section
->get_name (),
7860 section
->get_file_name ());
7862 section
->read (objfile
);
7864 info_ptr
= section
->buffer
;
7866 while (info_ptr
< section
->buffer
+ section
->size
)
7868 struct dwarf2_per_cu_data
*this_cu
;
7870 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
7872 comp_unit_head cu_header
;
7873 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
7874 abbrev_section
, info_ptr
,
7875 rcuh_kind::COMPILE
);
7877 /* Save the compilation unit for later lookup. */
7878 if (cu_header
.unit_type
!= DW_UT_type
)
7880 this_cu
= XOBNEW (&objfile
->objfile_obstack
,
7881 struct dwarf2_per_cu_data
);
7882 memset (this_cu
, 0, sizeof (*this_cu
));
7886 auto sig_type
= XOBNEW (&objfile
->objfile_obstack
,
7887 struct signatured_type
);
7888 memset (sig_type
, 0, sizeof (*sig_type
));
7889 sig_type
->signature
= cu_header
.signature
;
7890 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
7891 this_cu
= &sig_type
->per_cu
;
7893 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
7894 this_cu
->sect_off
= sect_off
;
7895 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
7896 this_cu
->is_dwz
= is_dwz
;
7897 this_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
7898 this_cu
->section
= section
;
7900 dwarf2_per_objfile
->all_comp_units
.push_back (this_cu
);
7902 info_ptr
= info_ptr
+ this_cu
->length
;
7906 /* Create a list of all compilation units in OBJFILE.
7907 This is only done for -readnow and building partial symtabs. */
7910 create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
7912 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
7913 read_comp_units_from_section (dwarf2_per_objfile
, &dwarf2_per_objfile
->info
,
7914 &dwarf2_per_objfile
->abbrev
, 0);
7916 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
7918 read_comp_units_from_section (dwarf2_per_objfile
, &dwz
->info
, &dwz
->abbrev
,
7922 /* Process all loaded DIEs for compilation unit CU, starting at
7923 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
7924 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
7925 DW_AT_ranges). See the comments of add_partial_subprogram on how
7926 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
7929 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
7930 CORE_ADDR
*highpc
, int set_addrmap
,
7931 struct dwarf2_cu
*cu
)
7933 struct partial_die_info
*pdi
;
7935 /* Now, march along the PDI's, descending into ones which have
7936 interesting children but skipping the children of the other ones,
7937 until we reach the end of the compilation unit. */
7945 /* Anonymous namespaces or modules have no name but have interesting
7946 children, so we need to look at them. Ditto for anonymous
7949 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
7950 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
7951 || pdi
->tag
== DW_TAG_imported_unit
7952 || pdi
->tag
== DW_TAG_inlined_subroutine
)
7956 case DW_TAG_subprogram
:
7957 case DW_TAG_inlined_subroutine
:
7958 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7960 case DW_TAG_constant
:
7961 case DW_TAG_variable
:
7962 case DW_TAG_typedef
:
7963 case DW_TAG_union_type
:
7964 if (!pdi
->is_declaration
)
7966 add_partial_symbol (pdi
, cu
);
7969 case DW_TAG_class_type
:
7970 case DW_TAG_interface_type
:
7971 case DW_TAG_structure_type
:
7972 if (!pdi
->is_declaration
)
7974 add_partial_symbol (pdi
, cu
);
7976 if ((cu
->language
== language_rust
7977 || cu
->language
== language_cplus
) && pdi
->has_children
)
7978 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
7981 case DW_TAG_enumeration_type
:
7982 if (!pdi
->is_declaration
)
7983 add_partial_enumeration (pdi
, cu
);
7985 case DW_TAG_base_type
:
7986 case DW_TAG_subrange_type
:
7987 /* File scope base type definitions are added to the partial
7989 add_partial_symbol (pdi
, cu
);
7991 case DW_TAG_namespace
:
7992 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7995 if (!pdi
->is_declaration
)
7996 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
7998 case DW_TAG_imported_unit
:
8000 struct dwarf2_per_cu_data
*per_cu
;
8002 /* For now we don't handle imported units in type units. */
8003 if (cu
->per_cu
->is_debug_types
)
8005 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8006 " supported in type units [in module %s]"),
8007 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
8010 per_cu
= dwarf2_find_containing_comp_unit
8011 (pdi
->d
.sect_off
, pdi
->is_dwz
,
8012 cu
->per_cu
->dwarf2_per_objfile
);
8014 /* Go read the partial unit, if needed. */
8015 if (per_cu
->v
.psymtab
== NULL
)
8016 process_psymtab_comp_unit (per_cu
, true, cu
->language
);
8018 cu
->per_cu
->imported_symtabs_push (per_cu
);
8021 case DW_TAG_imported_declaration
:
8022 add_partial_symbol (pdi
, cu
);
8029 /* If the die has a sibling, skip to the sibling. */
8031 pdi
= pdi
->die_sibling
;
8035 /* Functions used to compute the fully scoped name of a partial DIE.
8037 Normally, this is simple. For C++, the parent DIE's fully scoped
8038 name is concatenated with "::" and the partial DIE's name.
8039 Enumerators are an exception; they use the scope of their parent
8040 enumeration type, i.e. the name of the enumeration type is not
8041 prepended to the enumerator.
8043 There are two complexities. One is DW_AT_specification; in this
8044 case "parent" means the parent of the target of the specification,
8045 instead of the direct parent of the DIE. The other is compilers
8046 which do not emit DW_TAG_namespace; in this case we try to guess
8047 the fully qualified name of structure types from their members'
8048 linkage names. This must be done using the DIE's children rather
8049 than the children of any DW_AT_specification target. We only need
8050 to do this for structures at the top level, i.e. if the target of
8051 any DW_AT_specification (if any; otherwise the DIE itself) does not
8054 /* Compute the scope prefix associated with PDI's parent, in
8055 compilation unit CU. The result will be allocated on CU's
8056 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8057 field. NULL is returned if no prefix is necessary. */
8059 partial_die_parent_scope (struct partial_die_info
*pdi
,
8060 struct dwarf2_cu
*cu
)
8062 const char *grandparent_scope
;
8063 struct partial_die_info
*parent
, *real_pdi
;
8065 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8066 then this means the parent of the specification DIE. */
8069 while (real_pdi
->has_specification
)
8071 auto res
= find_partial_die (real_pdi
->spec_offset
,
8072 real_pdi
->spec_is_dwz
, cu
);
8077 parent
= real_pdi
->die_parent
;
8081 if (parent
->scope_set
)
8082 return parent
->scope
;
8086 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
8088 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8089 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8090 Work around this problem here. */
8091 if (cu
->language
== language_cplus
8092 && parent
->tag
== DW_TAG_namespace
8093 && strcmp (parent
->name
, "::") == 0
8094 && grandparent_scope
== NULL
)
8096 parent
->scope
= NULL
;
8097 parent
->scope_set
= 1;
8101 /* Nested subroutines in Fortran get a prefix. */
8102 if (pdi
->tag
== DW_TAG_enumerator
)
8103 /* Enumerators should not get the name of the enumeration as a prefix. */
8104 parent
->scope
= grandparent_scope
;
8105 else if (parent
->tag
== DW_TAG_namespace
8106 || parent
->tag
== DW_TAG_module
8107 || parent
->tag
== DW_TAG_structure_type
8108 || parent
->tag
== DW_TAG_class_type
8109 || parent
->tag
== DW_TAG_interface_type
8110 || parent
->tag
== DW_TAG_union_type
8111 || parent
->tag
== DW_TAG_enumeration_type
8112 || (cu
->language
== language_fortran
8113 && parent
->tag
== DW_TAG_subprogram
8114 && pdi
->tag
== DW_TAG_subprogram
))
8116 if (grandparent_scope
== NULL
)
8117 parent
->scope
= parent
->name
;
8119 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
8121 parent
->name
, 0, cu
);
8125 /* FIXME drow/2004-04-01: What should we be doing with
8126 function-local names? For partial symbols, we should probably be
8128 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8129 dwarf_tag_name (parent
->tag
),
8130 sect_offset_str (pdi
->sect_off
));
8131 parent
->scope
= grandparent_scope
;
8134 parent
->scope_set
= 1;
8135 return parent
->scope
;
8138 /* Return the fully scoped name associated with PDI, from compilation unit
8139 CU. The result will be allocated with malloc. */
8141 static gdb::unique_xmalloc_ptr
<char>
8142 partial_die_full_name (struct partial_die_info
*pdi
,
8143 struct dwarf2_cu
*cu
)
8145 const char *parent_scope
;
8147 /* If this is a template instantiation, we can not work out the
8148 template arguments from partial DIEs. So, unfortunately, we have
8149 to go through the full DIEs. At least any work we do building
8150 types here will be reused if full symbols are loaded later. */
8151 if (pdi
->has_template_arguments
)
8155 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
8157 struct die_info
*die
;
8158 struct attribute attr
;
8159 struct dwarf2_cu
*ref_cu
= cu
;
8161 /* DW_FORM_ref_addr is using section offset. */
8162 attr
.name
= (enum dwarf_attribute
) 0;
8163 attr
.form
= DW_FORM_ref_addr
;
8164 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
8165 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
8167 return make_unique_xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
8171 parent_scope
= partial_die_parent_scope (pdi
, cu
);
8172 if (parent_scope
== NULL
)
8175 return gdb::unique_xmalloc_ptr
<char> (typename_concat (NULL
, parent_scope
,
8180 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
8182 struct dwarf2_per_objfile
*dwarf2_per_objfile
8183 = cu
->per_cu
->dwarf2_per_objfile
;
8184 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8185 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8187 const char *actual_name
= NULL
;
8190 baseaddr
= objfile
->text_section_offset ();
8192 gdb::unique_xmalloc_ptr
<char> built_actual_name
8193 = partial_die_full_name (pdi
, cu
);
8194 if (built_actual_name
!= NULL
)
8195 actual_name
= built_actual_name
.get ();
8197 if (actual_name
== NULL
)
8198 actual_name
= pdi
->name
;
8202 case DW_TAG_inlined_subroutine
:
8203 case DW_TAG_subprogram
:
8204 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
8206 if (pdi
->is_external
8207 || cu
->language
== language_ada
8208 || (cu
->language
== language_fortran
8209 && pdi
->die_parent
!= NULL
8210 && pdi
->die_parent
->tag
== DW_TAG_subprogram
))
8212 /* Normally, only "external" DIEs are part of the global scope.
8213 But in Ada and Fortran, we want to be able to access nested
8214 procedures globally. So all Ada and Fortran subprograms are
8215 stored in the global scope. */
8216 add_psymbol_to_list (actual_name
,
8217 built_actual_name
!= NULL
,
8218 VAR_DOMAIN
, LOC_BLOCK
,
8219 SECT_OFF_TEXT (objfile
),
8220 psymbol_placement::GLOBAL
,
8222 cu
->language
, objfile
);
8226 add_psymbol_to_list (actual_name
,
8227 built_actual_name
!= NULL
,
8228 VAR_DOMAIN
, LOC_BLOCK
,
8229 SECT_OFF_TEXT (objfile
),
8230 psymbol_placement::STATIC
,
8231 addr
, cu
->language
, objfile
);
8234 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8235 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
8237 case DW_TAG_constant
:
8238 add_psymbol_to_list (actual_name
,
8239 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
8240 -1, (pdi
->is_external
8241 ? psymbol_placement::GLOBAL
8242 : psymbol_placement::STATIC
),
8243 0, cu
->language
, objfile
);
8245 case DW_TAG_variable
:
8247 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
8251 && !dwarf2_per_objfile
->has_section_at_zero
)
8253 /* A global or static variable may also have been stripped
8254 out by the linker if unused, in which case its address
8255 will be nullified; do not add such variables into partial
8256 symbol table then. */
8258 else if (pdi
->is_external
)
8261 Don't enter into the minimal symbol tables as there is
8262 a minimal symbol table entry from the ELF symbols already.
8263 Enter into partial symbol table if it has a location
8264 descriptor or a type.
8265 If the location descriptor is missing, new_symbol will create
8266 a LOC_UNRESOLVED symbol, the address of the variable will then
8267 be determined from the minimal symbol table whenever the variable
8269 The address for the partial symbol table entry is not
8270 used by GDB, but it comes in handy for debugging partial symbol
8273 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8274 add_psymbol_to_list (actual_name
,
8275 built_actual_name
!= NULL
,
8276 VAR_DOMAIN
, LOC_STATIC
,
8277 SECT_OFF_TEXT (objfile
),
8278 psymbol_placement::GLOBAL
,
8279 addr
, cu
->language
, objfile
);
8283 int has_loc
= pdi
->d
.locdesc
!= NULL
;
8285 /* Static Variable. Skip symbols whose value we cannot know (those
8286 without location descriptors or constant values). */
8287 if (!has_loc
&& !pdi
->has_const_value
)
8290 add_psymbol_to_list (actual_name
,
8291 built_actual_name
!= NULL
,
8292 VAR_DOMAIN
, LOC_STATIC
,
8293 SECT_OFF_TEXT (objfile
),
8294 psymbol_placement::STATIC
,
8296 cu
->language
, objfile
);
8299 case DW_TAG_typedef
:
8300 case DW_TAG_base_type
:
8301 case DW_TAG_subrange_type
:
8302 add_psymbol_to_list (actual_name
,
8303 built_actual_name
!= NULL
,
8304 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
8305 psymbol_placement::STATIC
,
8306 0, cu
->language
, objfile
);
8308 case DW_TAG_imported_declaration
:
8309 case DW_TAG_namespace
:
8310 add_psymbol_to_list (actual_name
,
8311 built_actual_name
!= NULL
,
8312 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
8313 psymbol_placement::GLOBAL
,
8314 0, cu
->language
, objfile
);
8317 /* With Fortran 77 there might be a "BLOCK DATA" module
8318 available without any name. If so, we skip the module as it
8319 doesn't bring any value. */
8320 if (actual_name
!= nullptr)
8321 add_psymbol_to_list (actual_name
,
8322 built_actual_name
!= NULL
,
8323 MODULE_DOMAIN
, LOC_TYPEDEF
, -1,
8324 psymbol_placement::GLOBAL
,
8325 0, cu
->language
, objfile
);
8327 case DW_TAG_class_type
:
8328 case DW_TAG_interface_type
:
8329 case DW_TAG_structure_type
:
8330 case DW_TAG_union_type
:
8331 case DW_TAG_enumeration_type
:
8332 /* Skip external references. The DWARF standard says in the section
8333 about "Structure, Union, and Class Type Entries": "An incomplete
8334 structure, union or class type is represented by a structure,
8335 union or class entry that does not have a byte size attribute
8336 and that has a DW_AT_declaration attribute." */
8337 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
8340 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8341 static vs. global. */
8342 add_psymbol_to_list (actual_name
,
8343 built_actual_name
!= NULL
,
8344 STRUCT_DOMAIN
, LOC_TYPEDEF
, -1,
8345 cu
->language
== language_cplus
8346 ? psymbol_placement::GLOBAL
8347 : psymbol_placement::STATIC
,
8348 0, cu
->language
, objfile
);
8351 case DW_TAG_enumerator
:
8352 add_psymbol_to_list (actual_name
,
8353 built_actual_name
!= NULL
,
8354 VAR_DOMAIN
, LOC_CONST
, -1,
8355 cu
->language
== language_cplus
8356 ? psymbol_placement::GLOBAL
8357 : psymbol_placement::STATIC
,
8358 0, cu
->language
, objfile
);
8365 /* Read a partial die corresponding to a namespace; also, add a symbol
8366 corresponding to that namespace to the symbol table. NAMESPACE is
8367 the name of the enclosing namespace. */
8370 add_partial_namespace (struct partial_die_info
*pdi
,
8371 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8372 int set_addrmap
, struct dwarf2_cu
*cu
)
8374 /* Add a symbol for the namespace. */
8376 add_partial_symbol (pdi
, cu
);
8378 /* Now scan partial symbols in that namespace. */
8380 if (pdi
->has_children
)
8381 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8384 /* Read a partial die corresponding to a Fortran module. */
8387 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
8388 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
8390 /* Add a symbol for the namespace. */
8392 add_partial_symbol (pdi
, cu
);
8394 /* Now scan partial symbols in that module. */
8396 if (pdi
->has_children
)
8397 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8400 /* Read a partial die corresponding to a subprogram or an inlined
8401 subprogram and create a partial symbol for that subprogram.
8402 When the CU language allows it, this routine also defines a partial
8403 symbol for each nested subprogram that this subprogram contains.
8404 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
8405 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
8407 PDI may also be a lexical block, in which case we simply search
8408 recursively for subprograms defined inside that lexical block.
8409 Again, this is only performed when the CU language allows this
8410 type of definitions. */
8413 add_partial_subprogram (struct partial_die_info
*pdi
,
8414 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8415 int set_addrmap
, struct dwarf2_cu
*cu
)
8417 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
8419 if (pdi
->has_pc_info
)
8421 if (pdi
->lowpc
< *lowpc
)
8422 *lowpc
= pdi
->lowpc
;
8423 if (pdi
->highpc
> *highpc
)
8424 *highpc
= pdi
->highpc
;
8427 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
8428 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8430 CORE_ADDR this_highpc
;
8431 CORE_ADDR this_lowpc
;
8433 baseaddr
= objfile
->text_section_offset ();
8435 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8436 pdi
->lowpc
+ baseaddr
)
8439 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8440 pdi
->highpc
+ baseaddr
)
8442 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
8443 this_lowpc
, this_highpc
- 1,
8444 cu
->per_cu
->v
.psymtab
);
8448 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
8450 if (!pdi
->is_declaration
)
8451 /* Ignore subprogram DIEs that do not have a name, they are
8452 illegal. Do not emit a complaint at this point, we will
8453 do so when we convert this psymtab into a symtab. */
8455 add_partial_symbol (pdi
, cu
);
8459 if (! pdi
->has_children
)
8462 if (cu
->language
== language_ada
|| cu
->language
== language_fortran
)
8464 pdi
= pdi
->die_child
;
8468 if (pdi
->tag
== DW_TAG_subprogram
8469 || pdi
->tag
== DW_TAG_inlined_subroutine
8470 || pdi
->tag
== DW_TAG_lexical_block
)
8471 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8472 pdi
= pdi
->die_sibling
;
8477 /* Read a partial die corresponding to an enumeration type. */
8480 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
8481 struct dwarf2_cu
*cu
)
8483 struct partial_die_info
*pdi
;
8485 if (enum_pdi
->name
!= NULL
)
8486 add_partial_symbol (enum_pdi
, cu
);
8488 pdi
= enum_pdi
->die_child
;
8491 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
8492 complaint (_("malformed enumerator DIE ignored"));
8494 add_partial_symbol (pdi
, cu
);
8495 pdi
= pdi
->die_sibling
;
8499 /* Return the initial uleb128 in the die at INFO_PTR. */
8502 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
8504 unsigned int bytes_read
;
8506 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8509 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
8510 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
8512 Return the corresponding abbrev, or NULL if the number is zero (indicating
8513 an empty DIE). In either case *BYTES_READ will be set to the length of
8514 the initial number. */
8516 static struct abbrev_info
*
8517 peek_die_abbrev (const die_reader_specs
&reader
,
8518 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
8520 dwarf2_cu
*cu
= reader
.cu
;
8521 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
8522 unsigned int abbrev_number
8523 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
8525 if (abbrev_number
== 0)
8528 abbrev_info
*abbrev
= reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
8531 error (_("Dwarf Error: Could not find abbrev number %d in %s"
8532 " at offset %s [in module %s]"),
8533 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
8534 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
8540 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8541 Returns a pointer to the end of a series of DIEs, terminated by an empty
8542 DIE. Any children of the skipped DIEs will also be skipped. */
8544 static const gdb_byte
*
8545 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
8549 unsigned int bytes_read
;
8550 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
8553 return info_ptr
+ bytes_read
;
8555 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
8559 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8560 INFO_PTR should point just after the initial uleb128 of a DIE, and the
8561 abbrev corresponding to that skipped uleb128 should be passed in
8562 ABBREV. Returns a pointer to this DIE's sibling, skipping any
8565 static const gdb_byte
*
8566 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
8567 struct abbrev_info
*abbrev
)
8569 unsigned int bytes_read
;
8570 struct attribute attr
;
8571 bfd
*abfd
= reader
->abfd
;
8572 struct dwarf2_cu
*cu
= reader
->cu
;
8573 const gdb_byte
*buffer
= reader
->buffer
;
8574 const gdb_byte
*buffer_end
= reader
->buffer_end
;
8575 unsigned int form
, i
;
8577 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
8579 /* The only abbrev we care about is DW_AT_sibling. */
8580 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
8583 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
,
8585 if (attr
.form
== DW_FORM_ref_addr
)
8586 complaint (_("ignoring absolute DW_AT_sibling"));
8589 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
8590 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
8592 if (sibling_ptr
< info_ptr
)
8593 complaint (_("DW_AT_sibling points backwards"));
8594 else if (sibling_ptr
> reader
->buffer_end
)
8595 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
8601 /* If it isn't DW_AT_sibling, skip this attribute. */
8602 form
= abbrev
->attrs
[i
].form
;
8606 case DW_FORM_ref_addr
:
8607 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
8608 and later it is offset sized. */
8609 if (cu
->header
.version
== 2)
8610 info_ptr
+= cu
->header
.addr_size
;
8612 info_ptr
+= cu
->header
.offset_size
;
8614 case DW_FORM_GNU_ref_alt
:
8615 info_ptr
+= cu
->header
.offset_size
;
8618 info_ptr
+= cu
->header
.addr_size
;
8626 case DW_FORM_flag_present
:
8627 case DW_FORM_implicit_const
:
8644 case DW_FORM_ref_sig8
:
8647 case DW_FORM_data16
:
8650 case DW_FORM_string
:
8651 read_direct_string (abfd
, info_ptr
, &bytes_read
);
8652 info_ptr
+= bytes_read
;
8654 case DW_FORM_sec_offset
:
8656 case DW_FORM_GNU_strp_alt
:
8657 info_ptr
+= cu
->header
.offset_size
;
8659 case DW_FORM_exprloc
:
8661 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8662 info_ptr
+= bytes_read
;
8664 case DW_FORM_block1
:
8665 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
8667 case DW_FORM_block2
:
8668 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
8670 case DW_FORM_block4
:
8671 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
8677 case DW_FORM_ref_udata
:
8678 case DW_FORM_GNU_addr_index
:
8679 case DW_FORM_GNU_str_index
:
8680 case DW_FORM_rnglistx
:
8681 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
8683 case DW_FORM_indirect
:
8684 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8685 info_ptr
+= bytes_read
;
8686 /* We need to continue parsing from here, so just go back to
8688 goto skip_attribute
;
8691 error (_("Dwarf Error: Cannot handle %s "
8692 "in DWARF reader [in module %s]"),
8693 dwarf_form_name (form
),
8694 bfd_get_filename (abfd
));
8698 if (abbrev
->has_children
)
8699 return skip_children (reader
, info_ptr
);
8704 /* Locate ORIG_PDI's sibling.
8705 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
8707 static const gdb_byte
*
8708 locate_pdi_sibling (const struct die_reader_specs
*reader
,
8709 struct partial_die_info
*orig_pdi
,
8710 const gdb_byte
*info_ptr
)
8712 /* Do we know the sibling already? */
8714 if (orig_pdi
->sibling
)
8715 return orig_pdi
->sibling
;
8717 /* Are there any children to deal with? */
8719 if (!orig_pdi
->has_children
)
8722 /* Skip the children the long way. */
8724 return skip_children (reader
, info_ptr
);
8727 /* Expand this partial symbol table into a full symbol table. SELF is
8731 dwarf2_psymtab::read_symtab (struct objfile
*objfile
)
8733 struct dwarf2_per_objfile
*dwarf2_per_objfile
8734 = get_dwarf2_per_objfile (objfile
);
8736 gdb_assert (!readin
);
8737 /* If this psymtab is constructed from a debug-only objfile, the
8738 has_section_at_zero flag will not necessarily be correct. We
8739 can get the correct value for this flag by looking at the data
8740 associated with the (presumably stripped) associated objfile. */
8741 if (objfile
->separate_debug_objfile_backlink
)
8743 struct dwarf2_per_objfile
*dpo_backlink
8744 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
8746 dwarf2_per_objfile
->has_section_at_zero
8747 = dpo_backlink
->has_section_at_zero
;
8750 expand_psymtab (objfile
);
8752 process_cu_includes (dwarf2_per_objfile
);
8755 /* Reading in full CUs. */
8757 /* Add PER_CU to the queue. */
8760 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
8761 enum language pretend_language
)
8764 per_cu
->dwarf2_per_objfile
->queue
.emplace (per_cu
, pretend_language
);
8767 /* If PER_CU is not yet queued, add it to the queue.
8768 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
8770 The result is non-zero if PER_CU was queued, otherwise the result is zero
8771 meaning either PER_CU is already queued or it is already loaded.
8773 N.B. There is an invariant here that if a CU is queued then it is loaded.
8774 The caller is required to load PER_CU if we return non-zero. */
8777 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
8778 struct dwarf2_per_cu_data
*per_cu
,
8779 enum language pretend_language
)
8781 /* We may arrive here during partial symbol reading, if we need full
8782 DIEs to process an unusual case (e.g. template arguments). Do
8783 not queue PER_CU, just tell our caller to load its DIEs. */
8784 if (per_cu
->dwarf2_per_objfile
->reading_partial_symbols
)
8786 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
8791 /* Mark the dependence relation so that we don't flush PER_CU
8793 if (dependent_cu
!= NULL
)
8794 dwarf2_add_dependence (dependent_cu
, per_cu
);
8796 /* If it's already on the queue, we have nothing to do. */
8800 /* If the compilation unit is already loaded, just mark it as
8802 if (per_cu
->cu
!= NULL
)
8804 per_cu
->cu
->last_used
= 0;
8808 /* Add it to the queue. */
8809 queue_comp_unit (per_cu
, pretend_language
);
8814 /* Process the queue. */
8817 process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8819 if (dwarf_read_debug
)
8821 fprintf_unfiltered (gdb_stdlog
,
8822 "Expanding one or more symtabs of objfile %s ...\n",
8823 objfile_name (dwarf2_per_objfile
->objfile
));
8826 /* The queue starts out with one item, but following a DIE reference
8827 may load a new CU, adding it to the end of the queue. */
8828 while (!dwarf2_per_objfile
->queue
.empty ())
8830 dwarf2_queue_item
&item
= dwarf2_per_objfile
->queue
.front ();
8832 if ((dwarf2_per_objfile
->using_index
8833 ? !item
.per_cu
->v
.quick
->compunit_symtab
8834 : (item
.per_cu
->v
.psymtab
&& !item
.per_cu
->v
.psymtab
->readin
))
8835 /* Skip dummy CUs. */
8836 && item
.per_cu
->cu
!= NULL
)
8838 struct dwarf2_per_cu_data
*per_cu
= item
.per_cu
;
8839 unsigned int debug_print_threshold
;
8842 if (per_cu
->is_debug_types
)
8844 struct signatured_type
*sig_type
=
8845 (struct signatured_type
*) per_cu
;
8847 sprintf (buf
, "TU %s at offset %s",
8848 hex_string (sig_type
->signature
),
8849 sect_offset_str (per_cu
->sect_off
));
8850 /* There can be 100s of TUs.
8851 Only print them in verbose mode. */
8852 debug_print_threshold
= 2;
8856 sprintf (buf
, "CU at offset %s",
8857 sect_offset_str (per_cu
->sect_off
));
8858 debug_print_threshold
= 1;
8861 if (dwarf_read_debug
>= debug_print_threshold
)
8862 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
8864 if (per_cu
->is_debug_types
)
8865 process_full_type_unit (per_cu
, item
.pretend_language
);
8867 process_full_comp_unit (per_cu
, item
.pretend_language
);
8869 if (dwarf_read_debug
>= debug_print_threshold
)
8870 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
8873 item
.per_cu
->queued
= 0;
8874 dwarf2_per_objfile
->queue
.pop ();
8877 if (dwarf_read_debug
)
8879 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
8880 objfile_name (dwarf2_per_objfile
->objfile
));
8884 /* Read in full symbols for PST, and anything it depends on. */
8887 dwarf2_psymtab::expand_psymtab (struct objfile
*objfile
)
8892 read_dependencies (objfile
);
8894 dw2_do_instantiate_symtab (per_cu_data
, false);
8895 gdb_assert (get_compunit_symtab () != nullptr);
8898 /* Trivial hash function for die_info: the hash value of a DIE
8899 is its offset in .debug_info for this objfile. */
8902 die_hash (const void *item
)
8904 const struct die_info
*die
= (const struct die_info
*) item
;
8906 return to_underlying (die
->sect_off
);
8909 /* Trivial comparison function for die_info structures: two DIEs
8910 are equal if they have the same offset. */
8913 die_eq (const void *item_lhs
, const void *item_rhs
)
8915 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
8916 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
8918 return die_lhs
->sect_off
== die_rhs
->sect_off
;
8921 /* Load the DIEs associated with PER_CU into memory. */
8924 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
8926 enum language pretend_language
)
8928 gdb_assert (! this_cu
->is_debug_types
);
8930 cutu_reader
reader (this_cu
, NULL
, 1, skip_partial
);
8934 struct dwarf2_cu
*cu
= reader
.cu
;
8935 const gdb_byte
*info_ptr
= reader
.info_ptr
;
8937 gdb_assert (cu
->die_hash
== NULL
);
8939 htab_create_alloc_ex (cu
->header
.length
/ 12,
8943 &cu
->comp_unit_obstack
,
8944 hashtab_obstack_allocate
,
8945 dummy_obstack_deallocate
);
8947 if (reader
.comp_unit_die
->has_children
)
8948 reader
.comp_unit_die
->child
8949 = read_die_and_siblings (&reader
, reader
.info_ptr
,
8950 &info_ptr
, reader
.comp_unit_die
);
8951 cu
->dies
= reader
.comp_unit_die
;
8952 /* comp_unit_die is not stored in die_hash, no need. */
8954 /* We try not to read any attributes in this function, because not
8955 all CUs needed for references have been loaded yet, and symbol
8956 table processing isn't initialized. But we have to set the CU language,
8957 or we won't be able to build types correctly.
8958 Similarly, if we do not read the producer, we can not apply
8959 producer-specific interpretation. */
8960 prepare_one_comp_unit (cu
, cu
->dies
, pretend_language
);
8965 /* Add a DIE to the delayed physname list. */
8968 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
8969 const char *name
, struct die_info
*die
,
8970 struct dwarf2_cu
*cu
)
8972 struct delayed_method_info mi
;
8974 mi
.fnfield_index
= fnfield_index
;
8978 cu
->method_list
.push_back (mi
);
8981 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
8982 "const" / "volatile". If so, decrements LEN by the length of the
8983 modifier and return true. Otherwise return false. */
8987 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
8989 size_t mod_len
= sizeof (mod
) - 1;
8990 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
8998 /* Compute the physnames of any methods on the CU's method list.
9000 The computation of method physnames is delayed in order to avoid the
9001 (bad) condition that one of the method's formal parameters is of an as yet
9005 compute_delayed_physnames (struct dwarf2_cu
*cu
)
9007 /* Only C++ delays computing physnames. */
9008 if (cu
->method_list
.empty ())
9010 gdb_assert (cu
->language
== language_cplus
);
9012 for (const delayed_method_info
&mi
: cu
->method_list
)
9014 const char *physname
;
9015 struct fn_fieldlist
*fn_flp
9016 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
9017 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
9018 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
9019 = physname
? physname
: "";
9021 /* Since there's no tag to indicate whether a method is a
9022 const/volatile overload, extract that information out of the
9024 if (physname
!= NULL
)
9026 size_t len
= strlen (physname
);
9030 if (physname
[len
] == ')') /* shortcut */
9032 else if (check_modifier (physname
, len
, " const"))
9033 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
9034 else if (check_modifier (physname
, len
, " volatile"))
9035 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
9042 /* The list is no longer needed. */
9043 cu
->method_list
.clear ();
9046 /* Go objects should be embedded in a DW_TAG_module DIE,
9047 and it's not clear if/how imported objects will appear.
9048 To keep Go support simple until that's worked out,
9049 go back through what we've read and create something usable.
9050 We could do this while processing each DIE, and feels kinda cleaner,
9051 but that way is more invasive.
9052 This is to, for example, allow the user to type "p var" or "b main"
9053 without having to specify the package name, and allow lookups
9054 of module.object to work in contexts that use the expression
9058 fixup_go_packaging (struct dwarf2_cu
*cu
)
9060 gdb::unique_xmalloc_ptr
<char> package_name
;
9061 struct pending
*list
;
9064 for (list
= *cu
->get_builder ()->get_global_symbols ();
9068 for (i
= 0; i
< list
->nsyms
; ++i
)
9070 struct symbol
*sym
= list
->symbol
[i
];
9072 if (sym
->language () == language_go
9073 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
9075 gdb::unique_xmalloc_ptr
<char> this_package_name
9076 (go_symbol_package_name (sym
));
9078 if (this_package_name
== NULL
)
9080 if (package_name
== NULL
)
9081 package_name
= std::move (this_package_name
);
9084 struct objfile
*objfile
9085 = cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9086 if (strcmp (package_name
.get (), this_package_name
.get ()) != 0)
9087 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9088 (symbol_symtab (sym
) != NULL
9089 ? symtab_to_filename_for_display
9090 (symbol_symtab (sym
))
9091 : objfile_name (objfile
)),
9092 this_package_name
.get (), package_name
.get ());
9098 if (package_name
!= NULL
)
9100 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9101 const char *saved_package_name
= objfile
->intern (package_name
.get ());
9102 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9103 saved_package_name
);
9106 sym
= allocate_symbol (objfile
);
9107 sym
->set_language (language_go
, &objfile
->objfile_obstack
);
9108 sym
->compute_and_set_names (saved_package_name
, false, objfile
->per_bfd
);
9109 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9110 e.g., "main" finds the "main" module and not C's main(). */
9111 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9112 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9113 SYMBOL_TYPE (sym
) = type
;
9115 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
9119 /* Allocate a fully-qualified name consisting of the two parts on the
9123 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
9125 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
9128 /* A helper that allocates a struct discriminant_info to attach to a
9131 static struct discriminant_info
*
9132 alloc_discriminant_info (struct type
*type
, int discriminant_index
,
9135 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
9136 gdb_assert (discriminant_index
== -1
9137 || (discriminant_index
>= 0
9138 && discriminant_index
< TYPE_NFIELDS (type
)));
9139 gdb_assert (default_index
== -1
9140 || (default_index
>= 0 && default_index
< TYPE_NFIELDS (type
)));
9142 TYPE_FLAG_DISCRIMINATED_UNION (type
) = 1;
9144 struct discriminant_info
*disc
9145 = ((struct discriminant_info
*)
9147 offsetof (struct discriminant_info
, discriminants
)
9148 + TYPE_NFIELDS (type
) * sizeof (disc
->discriminants
[0])));
9149 disc
->default_index
= default_index
;
9150 disc
->discriminant_index
= discriminant_index
;
9152 struct dynamic_prop prop
;
9153 prop
.kind
= PROP_UNDEFINED
;
9154 prop
.data
.baton
= disc
;
9156 add_dyn_prop (DYN_PROP_DISCRIMINATED
, prop
, type
);
9161 /* Some versions of rustc emitted enums in an unusual way.
9163 Ordinary enums were emitted as unions. The first element of each
9164 structure in the union was named "RUST$ENUM$DISR". This element
9165 held the discriminant.
9167 These versions of Rust also implemented the "non-zero"
9168 optimization. When the enum had two values, and one is empty and
9169 the other holds a pointer that cannot be zero, the pointer is used
9170 as the discriminant, with a zero value meaning the empty variant.
9171 Here, the union's first member is of the form
9172 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9173 where the fieldnos are the indices of the fields that should be
9174 traversed in order to find the field (which may be several fields deep)
9175 and the variantname is the name of the variant of the case when the
9178 This function recognizes whether TYPE is of one of these forms,
9179 and, if so, smashes it to be a variant type. */
9182 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
9184 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
9186 /* We don't need to deal with empty enums. */
9187 if (TYPE_NFIELDS (type
) == 0)
9190 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9191 if (TYPE_NFIELDS (type
) == 1
9192 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
9194 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
9196 /* Decode the field name to find the offset of the
9198 ULONGEST bit_offset
= 0;
9199 struct type
*field_type
= TYPE_FIELD_TYPE (type
, 0);
9200 while (name
[0] >= '0' && name
[0] <= '9')
9203 unsigned long index
= strtoul (name
, &tail
, 10);
9206 || index
>= TYPE_NFIELDS (field_type
)
9207 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
9208 != FIELD_LOC_KIND_BITPOS
))
9210 complaint (_("Could not parse Rust enum encoding string \"%s\""
9212 TYPE_FIELD_NAME (type
, 0),
9213 objfile_name (objfile
));
9218 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
9219 field_type
= TYPE_FIELD_TYPE (field_type
, index
);
9222 /* Make a union to hold the variants. */
9223 struct type
*union_type
= alloc_type (objfile
);
9224 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
9225 TYPE_NFIELDS (union_type
) = 3;
9226 TYPE_FIELDS (union_type
)
9227 = (struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
));
9228 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
9229 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
9231 /* Put the discriminant must at index 0. */
9232 TYPE_FIELD_TYPE (union_type
, 0) = field_type
;
9233 TYPE_FIELD_ARTIFICIAL (union_type
, 0) = 1;
9234 TYPE_FIELD_NAME (union_type
, 0) = "<<discriminant>>";
9235 SET_FIELD_BITPOS (TYPE_FIELD (union_type
, 0), bit_offset
);
9237 /* The order of fields doesn't really matter, so put the real
9238 field at index 1 and the data-less field at index 2. */
9239 struct discriminant_info
*disc
9240 = alloc_discriminant_info (union_type
, 0, 1);
9241 TYPE_FIELD (union_type
, 1) = TYPE_FIELD (type
, 0);
9242 TYPE_FIELD_NAME (union_type
, 1)
9243 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type
, 1)));
9244 TYPE_NAME (TYPE_FIELD_TYPE (union_type
, 1))
9245 = rust_fully_qualify (&objfile
->objfile_obstack
, TYPE_NAME (type
),
9246 TYPE_FIELD_NAME (union_type
, 1));
9248 const char *dataless_name
9249 = rust_fully_qualify (&objfile
->objfile_obstack
, TYPE_NAME (type
),
9251 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
9253 TYPE_FIELD_TYPE (union_type
, 2) = dataless_type
;
9254 /* NAME points into the original discriminant name, which
9255 already has the correct lifetime. */
9256 TYPE_FIELD_NAME (union_type
, 2) = name
;
9257 SET_FIELD_BITPOS (TYPE_FIELD (union_type
, 2), 0);
9258 disc
->discriminants
[2] = 0;
9260 /* Smash this type to be a structure type. We have to do this
9261 because the type has already been recorded. */
9262 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
9263 TYPE_NFIELDS (type
) = 1;
9265 = (struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
));
9267 /* Install the variant part. */
9268 TYPE_FIELD_TYPE (type
, 0) = union_type
;
9269 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
9270 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
9272 /* A union with a single anonymous field is probably an old-style
9274 else if (TYPE_NFIELDS (type
) == 1 && streq (TYPE_FIELD_NAME (type
, 0), ""))
9276 /* Smash this type to be a structure type. We have to do this
9277 because the type has already been recorded. */
9278 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
9280 /* Make a union to hold the variants. */
9281 struct type
*union_type
= alloc_type (objfile
);
9282 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
9283 TYPE_NFIELDS (union_type
) = TYPE_NFIELDS (type
);
9284 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
9285 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
9286 TYPE_FIELDS (union_type
) = TYPE_FIELDS (type
);
9288 struct type
*field_type
= TYPE_FIELD_TYPE (union_type
, 0);
9289 const char *variant_name
9290 = rust_last_path_segment (TYPE_NAME (field_type
));
9291 TYPE_FIELD_NAME (union_type
, 0) = variant_name
;
9292 TYPE_NAME (field_type
)
9293 = rust_fully_qualify (&objfile
->objfile_obstack
,
9294 TYPE_NAME (type
), variant_name
);
9296 /* Install the union in the outer struct type. */
9297 TYPE_NFIELDS (type
) = 1;
9299 = (struct field
*) TYPE_ZALLOC (union_type
, sizeof (struct field
));
9300 TYPE_FIELD_TYPE (type
, 0) = union_type
;
9301 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
9302 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
9304 alloc_discriminant_info (union_type
, -1, 0);
9308 struct type
*disr_type
= nullptr;
9309 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
9311 disr_type
= TYPE_FIELD_TYPE (type
, i
);
9313 if (TYPE_CODE (disr_type
) != TYPE_CODE_STRUCT
)
9315 /* All fields of a true enum will be structs. */
9318 else if (TYPE_NFIELDS (disr_type
) == 0)
9320 /* Could be data-less variant, so keep going. */
9321 disr_type
= nullptr;
9323 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
9324 "RUST$ENUM$DISR") != 0)
9326 /* Not a Rust enum. */
9336 /* If we got here without a discriminant, then it's probably
9338 if (disr_type
== nullptr)
9341 /* Smash this type to be a structure type. We have to do this
9342 because the type has already been recorded. */
9343 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
9345 /* Make a union to hold the variants. */
9346 struct field
*disr_field
= &TYPE_FIELD (disr_type
, 0);
9347 struct type
*union_type
= alloc_type (objfile
);
9348 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
9349 TYPE_NFIELDS (union_type
) = 1 + TYPE_NFIELDS (type
);
9350 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
9351 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
9352 TYPE_FIELDS (union_type
)
9353 = (struct field
*) TYPE_ZALLOC (union_type
,
9354 (TYPE_NFIELDS (union_type
)
9355 * sizeof (struct field
)));
9357 memcpy (TYPE_FIELDS (union_type
) + 1, TYPE_FIELDS (type
),
9358 TYPE_NFIELDS (type
) * sizeof (struct field
));
9360 /* Install the discriminant at index 0 in the union. */
9361 TYPE_FIELD (union_type
, 0) = *disr_field
;
9362 TYPE_FIELD_ARTIFICIAL (union_type
, 0) = 1;
9363 TYPE_FIELD_NAME (union_type
, 0) = "<<discriminant>>";
9365 /* Install the union in the outer struct type. */
9366 TYPE_FIELD_TYPE (type
, 0) = union_type
;
9367 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
9368 TYPE_NFIELDS (type
) = 1;
9370 /* Set the size and offset of the union type. */
9371 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
9373 /* We need a way to find the correct discriminant given a
9374 variant name. For convenience we build a map here. */
9375 struct type
*enum_type
= FIELD_TYPE (*disr_field
);
9376 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
9377 for (int i
= 0; i
< TYPE_NFIELDS (enum_type
); ++i
)
9379 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
9382 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
9383 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
9387 int n_fields
= TYPE_NFIELDS (union_type
);
9388 struct discriminant_info
*disc
9389 = alloc_discriminant_info (union_type
, 0, -1);
9390 /* Skip the discriminant here. */
9391 for (int i
= 1; i
< n_fields
; ++i
)
9393 /* Find the final word in the name of this variant's type.
9394 That name can be used to look up the correct
9396 const char *variant_name
9397 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type
,
9400 auto iter
= discriminant_map
.find (variant_name
);
9401 if (iter
!= discriminant_map
.end ())
9402 disc
->discriminants
[i
] = iter
->second
;
9404 /* Remove the discriminant field, if it exists. */
9405 struct type
*sub_type
= TYPE_FIELD_TYPE (union_type
, i
);
9406 if (TYPE_NFIELDS (sub_type
) > 0)
9408 --TYPE_NFIELDS (sub_type
);
9409 ++TYPE_FIELDS (sub_type
);
9411 TYPE_FIELD_NAME (union_type
, i
) = variant_name
;
9412 TYPE_NAME (sub_type
)
9413 = rust_fully_qualify (&objfile
->objfile_obstack
,
9414 TYPE_NAME (type
), variant_name
);
9419 /* Rewrite some Rust unions to be structures with variants parts. */
9422 rust_union_quirks (struct dwarf2_cu
*cu
)
9424 gdb_assert (cu
->language
== language_rust
);
9425 for (type
*type_
: cu
->rust_unions
)
9426 quirk_rust_enum (type_
, cu
->per_cu
->dwarf2_per_objfile
->objfile
);
9427 /* We don't need this any more. */
9428 cu
->rust_unions
.clear ();
9431 /* Return the symtab for PER_CU. This works properly regardless of
9432 whether we're using the index or psymtabs. */
9434 static struct compunit_symtab
*
9435 get_compunit_symtab (struct dwarf2_per_cu_data
*per_cu
)
9437 return (per_cu
->dwarf2_per_objfile
->using_index
9438 ? per_cu
->v
.quick
->compunit_symtab
9439 : per_cu
->v
.psymtab
->compunit_symtab
);
9442 /* A helper function for computing the list of all symbol tables
9443 included by PER_CU. */
9446 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
9447 htab_t all_children
, htab_t all_type_symtabs
,
9448 struct dwarf2_per_cu_data
*per_cu
,
9449 struct compunit_symtab
*immediate_parent
)
9452 struct compunit_symtab
*cust
;
9454 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
9457 /* This inclusion and its children have been processed. */
9462 /* Only add a CU if it has a symbol table. */
9463 cust
= get_compunit_symtab (per_cu
);
9466 /* If this is a type unit only add its symbol table if we haven't
9467 seen it yet (type unit per_cu's can share symtabs). */
9468 if (per_cu
->is_debug_types
)
9470 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
9474 result
->push_back (cust
);
9475 if (cust
->user
== NULL
)
9476 cust
->user
= immediate_parent
;
9481 result
->push_back (cust
);
9482 if (cust
->user
== NULL
)
9483 cust
->user
= immediate_parent
;
9487 if (!per_cu
->imported_symtabs_empty ())
9488 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9490 recursively_compute_inclusions (result
, all_children
,
9491 all_type_symtabs
, ptr
, cust
);
9495 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
9499 compute_compunit_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
9501 gdb_assert (! per_cu
->is_debug_types
);
9503 if (!per_cu
->imported_symtabs_empty ())
9506 std::vector
<compunit_symtab
*> result_symtabs
;
9507 htab_t all_children
, all_type_symtabs
;
9508 struct compunit_symtab
*cust
= get_compunit_symtab (per_cu
);
9510 /* If we don't have a symtab, we can just skip this case. */
9514 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
9515 NULL
, xcalloc
, xfree
);
9516 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
9517 NULL
, xcalloc
, xfree
);
9519 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9521 recursively_compute_inclusions (&result_symtabs
, all_children
,
9522 all_type_symtabs
, ptr
, cust
);
9525 /* Now we have a transitive closure of all the included symtabs. */
9526 len
= result_symtabs
.size ();
9528 = XOBNEWVEC (&per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
,
9529 struct compunit_symtab
*, len
+ 1);
9530 memcpy (cust
->includes
, result_symtabs
.data (),
9531 len
* sizeof (compunit_symtab
*));
9532 cust
->includes
[len
] = NULL
;
9534 htab_delete (all_children
);
9535 htab_delete (all_type_symtabs
);
9539 /* Compute the 'includes' field for the symtabs of all the CUs we just
9543 process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
9545 for (dwarf2_per_cu_data
*iter
: dwarf2_per_objfile
->just_read_cus
)
9547 if (! iter
->is_debug_types
)
9548 compute_compunit_symtab_includes (iter
);
9551 dwarf2_per_objfile
->just_read_cus
.clear ();
9554 /* Generate full symbol information for PER_CU, whose DIEs have
9555 already been loaded into memory. */
9558 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
9559 enum language pretend_language
)
9561 struct dwarf2_cu
*cu
= per_cu
->cu
;
9562 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
9563 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9564 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9565 CORE_ADDR lowpc
, highpc
;
9566 struct compunit_symtab
*cust
;
9568 struct block
*static_block
;
9571 baseaddr
= objfile
->text_section_offset ();
9573 /* Clear the list here in case something was left over. */
9574 cu
->method_list
.clear ();
9576 cu
->language
= pretend_language
;
9577 cu
->language_defn
= language_def (cu
->language
);
9579 /* Do line number decoding in read_file_scope () */
9580 process_die (cu
->dies
, cu
);
9582 /* For now fudge the Go package. */
9583 if (cu
->language
== language_go
)
9584 fixup_go_packaging (cu
);
9586 /* Now that we have processed all the DIEs in the CU, all the types
9587 should be complete, and it should now be safe to compute all of the
9589 compute_delayed_physnames (cu
);
9591 if (cu
->language
== language_rust
)
9592 rust_union_quirks (cu
);
9594 /* Some compilers don't define a DW_AT_high_pc attribute for the
9595 compilation unit. If the DW_AT_high_pc is missing, synthesize
9596 it, by scanning the DIE's below the compilation unit. */
9597 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
9599 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
9600 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
9602 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
9603 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
9604 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
9605 addrmap to help ensure it has an accurate map of pc values belonging to
9607 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
9609 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
9610 SECT_OFF_TEXT (objfile
),
9615 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
9617 /* Set symtab language to language from DW_AT_language. If the
9618 compilation is from a C file generated by language preprocessors, do
9619 not set the language if it was already deduced by start_subfile. */
9620 if (!(cu
->language
== language_c
9621 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
9622 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
9624 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
9625 produce DW_AT_location with location lists but it can be possibly
9626 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
9627 there were bugs in prologue debug info, fixed later in GCC-4.5
9628 by "unwind info for epilogues" patch (which is not directly related).
9630 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
9631 needed, it would be wrong due to missing DW_AT_producer there.
9633 Still one can confuse GDB by using non-standard GCC compilation
9634 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
9636 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
9637 cust
->locations_valid
= 1;
9639 if (gcc_4_minor
>= 5)
9640 cust
->epilogue_unwind_valid
= 1;
9642 cust
->call_site_htab
= cu
->call_site_htab
;
9645 if (dwarf2_per_objfile
->using_index
)
9646 per_cu
->v
.quick
->compunit_symtab
= cust
;
9649 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
9650 pst
->compunit_symtab
= cust
;
9654 /* Push it for inclusion processing later. */
9655 dwarf2_per_objfile
->just_read_cus
.push_back (per_cu
);
9657 /* Not needed any more. */
9658 cu
->reset_builder ();
9661 /* Generate full symbol information for type unit PER_CU, whose DIEs have
9662 already been loaded into memory. */
9665 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
9666 enum language pretend_language
)
9668 struct dwarf2_cu
*cu
= per_cu
->cu
;
9669 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
9670 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
9671 struct compunit_symtab
*cust
;
9672 struct signatured_type
*sig_type
;
9674 gdb_assert (per_cu
->is_debug_types
);
9675 sig_type
= (struct signatured_type
*) per_cu
;
9677 /* Clear the list here in case something was left over. */
9678 cu
->method_list
.clear ();
9680 cu
->language
= pretend_language
;
9681 cu
->language_defn
= language_def (cu
->language
);
9683 /* The symbol tables are set up in read_type_unit_scope. */
9684 process_die (cu
->dies
, cu
);
9686 /* For now fudge the Go package. */
9687 if (cu
->language
== language_go
)
9688 fixup_go_packaging (cu
);
9690 /* Now that we have processed all the DIEs in the CU, all the types
9691 should be complete, and it should now be safe to compute all of the
9693 compute_delayed_physnames (cu
);
9695 if (cu
->language
== language_rust
)
9696 rust_union_quirks (cu
);
9698 /* TUs share symbol tables.
9699 If this is the first TU to use this symtab, complete the construction
9700 of it with end_expandable_symtab. Otherwise, complete the addition of
9701 this TU's symbols to the existing symtab. */
9702 if (sig_type
->type_unit_group
->compunit_symtab
== NULL
)
9704 buildsym_compunit
*builder
= cu
->get_builder ();
9705 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
9706 sig_type
->type_unit_group
->compunit_symtab
= cust
;
9710 /* Set symtab language to language from DW_AT_language. If the
9711 compilation is from a C file generated by language preprocessors,
9712 do not set the language if it was already deduced by
9714 if (!(cu
->language
== language_c
9715 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
9716 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
9721 cu
->get_builder ()->augment_type_symtab ();
9722 cust
= sig_type
->type_unit_group
->compunit_symtab
;
9725 if (dwarf2_per_objfile
->using_index
)
9726 per_cu
->v
.quick
->compunit_symtab
= cust
;
9729 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
9730 pst
->compunit_symtab
= cust
;
9734 /* Not needed any more. */
9735 cu
->reset_builder ();
9738 /* Process an imported unit DIE. */
9741 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
9743 struct attribute
*attr
;
9745 /* For now we don't handle imported units in type units. */
9746 if (cu
->per_cu
->is_debug_types
)
9748 error (_("Dwarf Error: DW_TAG_imported_unit is not"
9749 " supported in type units [in module %s]"),
9750 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
9753 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
9756 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
9757 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
9758 dwarf2_per_cu_data
*per_cu
9759 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
,
9760 cu
->per_cu
->dwarf2_per_objfile
);
9762 /* If necessary, add it to the queue and load its DIEs. */
9763 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
9764 load_full_comp_unit (per_cu
, false, cu
->language
);
9766 cu
->per_cu
->imported_symtabs_push (per_cu
);
9770 /* RAII object that represents a process_die scope: i.e.,
9771 starts/finishes processing a DIE. */
9772 class process_die_scope
9775 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
9776 : m_die (die
), m_cu (cu
)
9778 /* We should only be processing DIEs not already in process. */
9779 gdb_assert (!m_die
->in_process
);
9780 m_die
->in_process
= true;
9783 ~process_die_scope ()
9785 m_die
->in_process
= false;
9787 /* If we're done processing the DIE for the CU that owns the line
9788 header, we don't need the line header anymore. */
9789 if (m_cu
->line_header_die_owner
== m_die
)
9791 delete m_cu
->line_header
;
9792 m_cu
->line_header
= NULL
;
9793 m_cu
->line_header_die_owner
= NULL
;
9802 /* Process a die and its children. */
9805 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
9807 process_die_scope
scope (die
, cu
);
9811 case DW_TAG_padding
:
9813 case DW_TAG_compile_unit
:
9814 case DW_TAG_partial_unit
:
9815 read_file_scope (die
, cu
);
9817 case DW_TAG_type_unit
:
9818 read_type_unit_scope (die
, cu
);
9820 case DW_TAG_subprogram
:
9821 /* Nested subprograms in Fortran get a prefix. */
9822 if (cu
->language
== language_fortran
9823 && die
->parent
!= NULL
9824 && die
->parent
->tag
== DW_TAG_subprogram
)
9825 cu
->processing_has_namespace_info
= true;
9827 case DW_TAG_inlined_subroutine
:
9828 read_func_scope (die
, cu
);
9830 case DW_TAG_lexical_block
:
9831 case DW_TAG_try_block
:
9832 case DW_TAG_catch_block
:
9833 read_lexical_block_scope (die
, cu
);
9835 case DW_TAG_call_site
:
9836 case DW_TAG_GNU_call_site
:
9837 read_call_site_scope (die
, cu
);
9839 case DW_TAG_class_type
:
9840 case DW_TAG_interface_type
:
9841 case DW_TAG_structure_type
:
9842 case DW_TAG_union_type
:
9843 process_structure_scope (die
, cu
);
9845 case DW_TAG_enumeration_type
:
9846 process_enumeration_scope (die
, cu
);
9849 /* These dies have a type, but processing them does not create
9850 a symbol or recurse to process the children. Therefore we can
9851 read them on-demand through read_type_die. */
9852 case DW_TAG_subroutine_type
:
9853 case DW_TAG_set_type
:
9854 case DW_TAG_array_type
:
9855 case DW_TAG_pointer_type
:
9856 case DW_TAG_ptr_to_member_type
:
9857 case DW_TAG_reference_type
:
9858 case DW_TAG_rvalue_reference_type
:
9859 case DW_TAG_string_type
:
9862 case DW_TAG_base_type
:
9863 case DW_TAG_subrange_type
:
9864 case DW_TAG_typedef
:
9865 /* Add a typedef symbol for the type definition, if it has a
9867 new_symbol (die
, read_type_die (die
, cu
), cu
);
9869 case DW_TAG_common_block
:
9870 read_common_block (die
, cu
);
9872 case DW_TAG_common_inclusion
:
9874 case DW_TAG_namespace
:
9875 cu
->processing_has_namespace_info
= true;
9876 read_namespace (die
, cu
);
9879 cu
->processing_has_namespace_info
= true;
9880 read_module (die
, cu
);
9882 case DW_TAG_imported_declaration
:
9883 cu
->processing_has_namespace_info
= true;
9884 if (read_namespace_alias (die
, cu
))
9886 /* The declaration is not a global namespace alias. */
9888 case DW_TAG_imported_module
:
9889 cu
->processing_has_namespace_info
= true;
9890 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
9891 || cu
->language
!= language_fortran
))
9892 complaint (_("Tag '%s' has unexpected children"),
9893 dwarf_tag_name (die
->tag
));
9894 read_import_statement (die
, cu
);
9897 case DW_TAG_imported_unit
:
9898 process_imported_unit_die (die
, cu
);
9901 case DW_TAG_variable
:
9902 read_variable (die
, cu
);
9906 new_symbol (die
, NULL
, cu
);
9911 /* DWARF name computation. */
9913 /* A helper function for dwarf2_compute_name which determines whether DIE
9914 needs to have the name of the scope prepended to the name listed in the
9918 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
9920 struct attribute
*attr
;
9924 case DW_TAG_namespace
:
9925 case DW_TAG_typedef
:
9926 case DW_TAG_class_type
:
9927 case DW_TAG_interface_type
:
9928 case DW_TAG_structure_type
:
9929 case DW_TAG_union_type
:
9930 case DW_TAG_enumeration_type
:
9931 case DW_TAG_enumerator
:
9932 case DW_TAG_subprogram
:
9933 case DW_TAG_inlined_subroutine
:
9935 case DW_TAG_imported_declaration
:
9938 case DW_TAG_variable
:
9939 case DW_TAG_constant
:
9940 /* We only need to prefix "globally" visible variables. These include
9941 any variable marked with DW_AT_external or any variable that
9942 lives in a namespace. [Variables in anonymous namespaces
9943 require prefixing, but they are not DW_AT_external.] */
9945 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
9947 struct dwarf2_cu
*spec_cu
= cu
;
9949 return die_needs_namespace (die_specification (die
, &spec_cu
),
9953 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
9954 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
9955 && die
->parent
->tag
!= DW_TAG_module
)
9957 /* A variable in a lexical block of some kind does not need a
9958 namespace, even though in C++ such variables may be external
9959 and have a mangled name. */
9960 if (die
->parent
->tag
== DW_TAG_lexical_block
9961 || die
->parent
->tag
== DW_TAG_try_block
9962 || die
->parent
->tag
== DW_TAG_catch_block
9963 || die
->parent
->tag
== DW_TAG_subprogram
)
9972 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
9973 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
9974 defined for the given DIE. */
9976 static struct attribute
*
9977 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
9979 struct attribute
*attr
;
9981 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
9983 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
9988 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
9989 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
9990 defined for the given DIE. */
9993 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
9995 const char *linkage_name
;
9997 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
9998 if (linkage_name
== NULL
)
9999 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10001 return linkage_name
;
10004 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10005 compute the physname for the object, which include a method's:
10006 - formal parameters (C++),
10007 - receiver type (Go),
10009 The term "physname" is a bit confusing.
10010 For C++, for example, it is the demangled name.
10011 For Go, for example, it's the mangled name.
10013 For Ada, return the DIE's linkage name rather than the fully qualified
10014 name. PHYSNAME is ignored..
10016 The result is allocated on the objfile_obstack and canonicalized. */
10018 static const char *
10019 dwarf2_compute_name (const char *name
,
10020 struct die_info
*die
, struct dwarf2_cu
*cu
,
10023 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
10026 name
= dwarf2_name (die
, cu
);
10028 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10029 but otherwise compute it by typename_concat inside GDB.
10030 FIXME: Actually this is not really true, or at least not always true.
10031 It's all very confusing. compute_and_set_names doesn't try to demangle
10032 Fortran names because there is no mangling standard. So new_symbol
10033 will set the demangled name to the result of dwarf2_full_name, and it is
10034 the demangled name that GDB uses if it exists. */
10035 if (cu
->language
== language_ada
10036 || (cu
->language
== language_fortran
&& physname
))
10038 /* For Ada unit, we prefer the linkage name over the name, as
10039 the former contains the exported name, which the user expects
10040 to be able to reference. Ideally, we want the user to be able
10041 to reference this entity using either natural or linkage name,
10042 but we haven't started looking at this enhancement yet. */
10043 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10045 if (linkage_name
!= NULL
)
10046 return linkage_name
;
10049 /* These are the only languages we know how to qualify names in. */
10051 && (cu
->language
== language_cplus
10052 || cu
->language
== language_fortran
|| cu
->language
== language_d
10053 || cu
->language
== language_rust
))
10055 if (die_needs_namespace (die
, cu
))
10057 const char *prefix
;
10058 const char *canonical_name
= NULL
;
10062 prefix
= determine_prefix (die
, cu
);
10063 if (*prefix
!= '\0')
10065 gdb::unique_xmalloc_ptr
<char> prefixed_name
10066 (typename_concat (NULL
, prefix
, name
, physname
, cu
));
10068 buf
.puts (prefixed_name
.get ());
10073 /* Template parameters may be specified in the DIE's DW_AT_name, or
10074 as children with DW_TAG_template_type_param or
10075 DW_TAG_value_type_param. If the latter, add them to the name
10076 here. If the name already has template parameters, then
10077 skip this step; some versions of GCC emit both, and
10078 it is more efficient to use the pre-computed name.
10080 Something to keep in mind about this process: it is very
10081 unlikely, or in some cases downright impossible, to produce
10082 something that will match the mangled name of a function.
10083 If the definition of the function has the same debug info,
10084 we should be able to match up with it anyway. But fallbacks
10085 using the minimal symbol, for instance to find a method
10086 implemented in a stripped copy of libstdc++, will not work.
10087 If we do not have debug info for the definition, we will have to
10088 match them up some other way.
10090 When we do name matching there is a related problem with function
10091 templates; two instantiated function templates are allowed to
10092 differ only by their return types, which we do not add here. */
10094 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
10096 struct attribute
*attr
;
10097 struct die_info
*child
;
10100 die
->building_fullname
= 1;
10102 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
10106 const gdb_byte
*bytes
;
10107 struct dwarf2_locexpr_baton
*baton
;
10110 if (child
->tag
!= DW_TAG_template_type_param
10111 && child
->tag
!= DW_TAG_template_value_param
)
10122 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10125 complaint (_("template parameter missing DW_AT_type"));
10126 buf
.puts ("UNKNOWN_TYPE");
10129 type
= die_type (child
, cu
);
10131 if (child
->tag
== DW_TAG_template_type_param
)
10133 c_print_type (type
, "", &buf
, -1, 0, cu
->language
,
10134 &type_print_raw_options
);
10138 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10141 complaint (_("template parameter missing "
10142 "DW_AT_const_value"));
10143 buf
.puts ("UNKNOWN_VALUE");
10147 dwarf2_const_value_attr (attr
, type
, name
,
10148 &cu
->comp_unit_obstack
, cu
,
10149 &value
, &bytes
, &baton
);
10151 if (TYPE_NOSIGN (type
))
10152 /* GDB prints characters as NUMBER 'CHAR'. If that's
10153 changed, this can use value_print instead. */
10154 c_printchar (value
, type
, &buf
);
10157 struct value_print_options opts
;
10160 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
10164 else if (bytes
!= NULL
)
10166 v
= allocate_value (type
);
10167 memcpy (value_contents_writeable (v
), bytes
,
10168 TYPE_LENGTH (type
));
10171 v
= value_from_longest (type
, value
);
10173 /* Specify decimal so that we do not depend on
10175 get_formatted_print_options (&opts
, 'd');
10177 value_print (v
, &buf
, &opts
);
10182 die
->building_fullname
= 0;
10186 /* Close the argument list, with a space if necessary
10187 (nested templates). */
10188 if (!buf
.empty () && buf
.string ().back () == '>')
10195 /* For C++ methods, append formal parameter type
10196 information, if PHYSNAME. */
10198 if (physname
&& die
->tag
== DW_TAG_subprogram
10199 && cu
->language
== language_cplus
)
10201 struct type
*type
= read_type_die (die
, cu
);
10203 c_type_print_args (type
, &buf
, 1, cu
->language
,
10204 &type_print_raw_options
);
10206 if (cu
->language
== language_cplus
)
10208 /* Assume that an artificial first parameter is
10209 "this", but do not crash if it is not. RealView
10210 marks unnamed (and thus unused) parameters as
10211 artificial; there is no way to differentiate
10213 if (TYPE_NFIELDS (type
) > 0
10214 && TYPE_FIELD_ARTIFICIAL (type
, 0)
10215 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
10216 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
10218 buf
.puts (" const");
10222 const std::string
&intermediate_name
= buf
.string ();
10224 if (cu
->language
== language_cplus
)
10226 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
10229 /* If we only computed INTERMEDIATE_NAME, or if
10230 INTERMEDIATE_NAME is already canonical, then we need to
10232 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
10233 name
= objfile
->intern (intermediate_name
);
10235 name
= canonical_name
;
10242 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10243 If scope qualifiers are appropriate they will be added. The result
10244 will be allocated on the storage_obstack, or NULL if the DIE does
10245 not have a name. NAME may either be from a previous call to
10246 dwarf2_name or NULL.
10248 The output string will be canonicalized (if C++). */
10250 static const char *
10251 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10253 return dwarf2_compute_name (name
, die
, cu
, 0);
10256 /* Construct a physname for the given DIE in CU. NAME may either be
10257 from a previous call to dwarf2_name or NULL. The result will be
10258 allocated on the objfile_objstack or NULL if the DIE does not have a
10261 The output string will be canonicalized (if C++). */
10263 static const char *
10264 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10266 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
10267 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
10270 /* In this case dwarf2_compute_name is just a shortcut not building anything
10272 if (!die_needs_namespace (die
, cu
))
10273 return dwarf2_compute_name (name
, die
, cu
, 1);
10275 mangled
= dw2_linkage_name (die
, cu
);
10277 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
10278 See https://github.com/rust-lang/rust/issues/32925. */
10279 if (cu
->language
== language_rust
&& mangled
!= NULL
10280 && strchr (mangled
, '{') != NULL
)
10283 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
10285 gdb::unique_xmalloc_ptr
<char> demangled
;
10286 if (mangled
!= NULL
)
10289 if (language_def (cu
->language
)->la_store_sym_names_in_linkage_form_p
)
10291 /* Do nothing (do not demangle the symbol name). */
10293 else if (cu
->language
== language_go
)
10295 /* This is a lie, but we already lie to the caller new_symbol.
10296 new_symbol assumes we return the mangled name.
10297 This just undoes that lie until things are cleaned up. */
10301 /* Use DMGL_RET_DROP for C++ template functions to suppress
10302 their return type. It is easier for GDB users to search
10303 for such functions as `name(params)' than `long name(params)'.
10304 In such case the minimal symbol names do not match the full
10305 symbol names but for template functions there is never a need
10306 to look up their definition from their declaration so
10307 the only disadvantage remains the minimal symbol variant
10308 `long name(params)' does not have the proper inferior type. */
10309 demangled
.reset (gdb_demangle (mangled
,
10310 (DMGL_PARAMS
| DMGL_ANSI
10311 | DMGL_RET_DROP
)));
10314 canon
= demangled
.get ();
10322 if (canon
== NULL
|| check_physname
)
10324 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
10326 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
10328 /* It may not mean a bug in GDB. The compiler could also
10329 compute DW_AT_linkage_name incorrectly. But in such case
10330 GDB would need to be bug-to-bug compatible. */
10332 complaint (_("Computed physname <%s> does not match demangled <%s> "
10333 "(from linkage <%s>) - DIE at %s [in module %s]"),
10334 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
10335 objfile_name (objfile
));
10337 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
10338 is available here - over computed PHYSNAME. It is safer
10339 against both buggy GDB and buggy compilers. */
10353 retval
= objfile
->intern (retval
);
10358 /* Inspect DIE in CU for a namespace alias. If one exists, record
10359 a new symbol for it.
10361 Returns 1 if a namespace alias was recorded, 0 otherwise. */
10364 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
10366 struct attribute
*attr
;
10368 /* If the die does not have a name, this is not a namespace
10370 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
10374 struct die_info
*d
= die
;
10375 struct dwarf2_cu
*imported_cu
= cu
;
10377 /* If the compiler has nested DW_AT_imported_declaration DIEs,
10378 keep inspecting DIEs until we hit the underlying import. */
10379 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
10380 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
10382 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
10386 d
= follow_die_ref (d
, attr
, &imported_cu
);
10387 if (d
->tag
!= DW_TAG_imported_declaration
)
10391 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
10393 complaint (_("DIE at %s has too many recursively imported "
10394 "declarations"), sect_offset_str (d
->sect_off
));
10401 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
10403 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
10404 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
10406 /* This declaration is a global namespace alias. Add
10407 a symbol for it whose type is the aliased namespace. */
10408 new_symbol (die
, type
, cu
);
10417 /* Return the using directives repository (global or local?) to use in the
10418 current context for CU.
10420 For Ada, imported declarations can materialize renamings, which *may* be
10421 global. However it is impossible (for now?) in DWARF to distinguish
10422 "external" imported declarations and "static" ones. As all imported
10423 declarations seem to be static in all other languages, make them all CU-wide
10424 global only in Ada. */
10426 static struct using_direct
**
10427 using_directives (struct dwarf2_cu
*cu
)
10429 if (cu
->language
== language_ada
10430 && cu
->get_builder ()->outermost_context_p ())
10431 return cu
->get_builder ()->get_global_using_directives ();
10433 return cu
->get_builder ()->get_local_using_directives ();
10436 /* Read the import statement specified by the given die and record it. */
10439 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
10441 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
10442 struct attribute
*import_attr
;
10443 struct die_info
*imported_die
, *child_die
;
10444 struct dwarf2_cu
*imported_cu
;
10445 const char *imported_name
;
10446 const char *imported_name_prefix
;
10447 const char *canonical_name
;
10448 const char *import_alias
;
10449 const char *imported_declaration
= NULL
;
10450 const char *import_prefix
;
10451 std::vector
<const char *> excludes
;
10453 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10454 if (import_attr
== NULL
)
10456 complaint (_("Tag '%s' has no DW_AT_import"),
10457 dwarf_tag_name (die
->tag
));
10462 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
10463 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10464 if (imported_name
== NULL
)
10466 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
10468 The import in the following code:
10482 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
10483 <52> DW_AT_decl_file : 1
10484 <53> DW_AT_decl_line : 6
10485 <54> DW_AT_import : <0x75>
10486 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
10487 <59> DW_AT_name : B
10488 <5b> DW_AT_decl_file : 1
10489 <5c> DW_AT_decl_line : 2
10490 <5d> DW_AT_type : <0x6e>
10492 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
10493 <76> DW_AT_byte_size : 4
10494 <77> DW_AT_encoding : 5 (signed)
10496 imports the wrong die ( 0x75 instead of 0x58 ).
10497 This case will be ignored until the gcc bug is fixed. */
10501 /* Figure out the local name after import. */
10502 import_alias
= dwarf2_name (die
, cu
);
10504 /* Figure out where the statement is being imported to. */
10505 import_prefix
= determine_prefix (die
, cu
);
10507 /* Figure out what the scope of the imported die is and prepend it
10508 to the name of the imported die. */
10509 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
10511 if (imported_die
->tag
!= DW_TAG_namespace
10512 && imported_die
->tag
!= DW_TAG_module
)
10514 imported_declaration
= imported_name
;
10515 canonical_name
= imported_name_prefix
;
10517 else if (strlen (imported_name_prefix
) > 0)
10518 canonical_name
= obconcat (&objfile
->objfile_obstack
,
10519 imported_name_prefix
,
10520 (cu
->language
== language_d
? "." : "::"),
10521 imported_name
, (char *) NULL
);
10523 canonical_name
= imported_name
;
10525 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
10526 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
10527 child_die
= sibling_die (child_die
))
10529 /* DWARF-4: A Fortran use statement with a “rename list” may be
10530 represented by an imported module entry with an import attribute
10531 referring to the module and owned entries corresponding to those
10532 entities that are renamed as part of being imported. */
10534 if (child_die
->tag
!= DW_TAG_imported_declaration
)
10536 complaint (_("child DW_TAG_imported_declaration expected "
10537 "- DIE at %s [in module %s]"),
10538 sect_offset_str (child_die
->sect_off
),
10539 objfile_name (objfile
));
10543 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
10544 if (import_attr
== NULL
)
10546 complaint (_("Tag '%s' has no DW_AT_import"),
10547 dwarf_tag_name (child_die
->tag
));
10552 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
10554 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10555 if (imported_name
== NULL
)
10557 complaint (_("child DW_TAG_imported_declaration has unknown "
10558 "imported name - DIE at %s [in module %s]"),
10559 sect_offset_str (child_die
->sect_off
),
10560 objfile_name (objfile
));
10564 excludes
.push_back (imported_name
);
10566 process_die (child_die
, cu
);
10569 add_using_directive (using_directives (cu
),
10573 imported_declaration
,
10576 &objfile
->objfile_obstack
);
10579 /* ICC<14 does not output the required DW_AT_declaration on incomplete
10580 types, but gives them a size of zero. Starting with version 14,
10581 ICC is compatible with GCC. */
10584 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
10586 if (!cu
->checked_producer
)
10587 check_producer (cu
);
10589 return cu
->producer_is_icc_lt_14
;
10592 /* ICC generates a DW_AT_type for C void functions. This was observed on
10593 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
10594 which says that void functions should not have a DW_AT_type. */
10597 producer_is_icc (struct dwarf2_cu
*cu
)
10599 if (!cu
->checked_producer
)
10600 check_producer (cu
);
10602 return cu
->producer_is_icc
;
10605 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
10606 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
10607 this, it was first present in GCC release 4.3.0. */
10610 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
10612 if (!cu
->checked_producer
)
10613 check_producer (cu
);
10615 return cu
->producer_is_gcc_lt_4_3
;
10618 static file_and_directory
10619 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
10621 file_and_directory res
;
10623 /* Find the filename. Do not use dwarf2_name here, since the filename
10624 is not a source language identifier. */
10625 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
10626 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
10628 if (res
.comp_dir
== NULL
10629 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
10630 && IS_ABSOLUTE_PATH (res
.name
))
10632 res
.comp_dir_storage
= ldirname (res
.name
);
10633 if (!res
.comp_dir_storage
.empty ())
10634 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
10636 if (res
.comp_dir
!= NULL
)
10638 /* Irix 6.2 native cc prepends <machine>.: to the compilation
10639 directory, get rid of it. */
10640 const char *cp
= strchr (res
.comp_dir
, ':');
10642 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
10643 res
.comp_dir
= cp
+ 1;
10646 if (res
.name
== NULL
)
10647 res
.name
= "<unknown>";
10652 /* Handle DW_AT_stmt_list for a compilation unit.
10653 DIE is the DW_TAG_compile_unit die for CU.
10654 COMP_DIR is the compilation directory. LOWPC is passed to
10655 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
10658 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
10659 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
10661 struct dwarf2_per_objfile
*dwarf2_per_objfile
10662 = cu
->per_cu
->dwarf2_per_objfile
;
10663 struct attribute
*attr
;
10664 struct line_header line_header_local
;
10665 hashval_t line_header_local_hash
;
10667 int decode_mapping
;
10669 gdb_assert (! cu
->per_cu
->is_debug_types
);
10671 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
10675 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
10677 /* The line header hash table is only created if needed (it exists to
10678 prevent redundant reading of the line table for partial_units).
10679 If we're given a partial_unit, we'll need it. If we're given a
10680 compile_unit, then use the line header hash table if it's already
10681 created, but don't create one just yet. */
10683 if (dwarf2_per_objfile
->line_header_hash
== NULL
10684 && die
->tag
== DW_TAG_partial_unit
)
10686 dwarf2_per_objfile
->line_header_hash
10687 .reset (htab_create_alloc (127, line_header_hash_voidp
,
10688 line_header_eq_voidp
,
10689 free_line_header_voidp
,
10693 line_header_local
.sect_off
= line_offset
;
10694 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
10695 line_header_local_hash
= line_header_hash (&line_header_local
);
10696 if (dwarf2_per_objfile
->line_header_hash
!= NULL
)
10698 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
.get (),
10699 &line_header_local
,
10700 line_header_local_hash
, NO_INSERT
);
10702 /* For DW_TAG_compile_unit we need info like symtab::linetable which
10703 is not present in *SLOT (since if there is something in *SLOT then
10704 it will be for a partial_unit). */
10705 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
10707 gdb_assert (*slot
!= NULL
);
10708 cu
->line_header
= (struct line_header
*) *slot
;
10713 /* dwarf_decode_line_header does not yet provide sufficient information.
10714 We always have to call also dwarf_decode_lines for it. */
10715 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
10719 cu
->line_header
= lh
.release ();
10720 cu
->line_header_die_owner
= die
;
10722 if (dwarf2_per_objfile
->line_header_hash
== NULL
)
10726 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
.get (),
10727 &line_header_local
,
10728 line_header_local_hash
, INSERT
);
10729 gdb_assert (slot
!= NULL
);
10731 if (slot
!= NULL
&& *slot
== NULL
)
10733 /* This newly decoded line number information unit will be owned
10734 by line_header_hash hash table. */
10735 *slot
= cu
->line_header
;
10736 cu
->line_header_die_owner
= NULL
;
10740 /* We cannot free any current entry in (*slot) as that struct line_header
10741 may be already used by multiple CUs. Create only temporary decoded
10742 line_header for this CU - it may happen at most once for each line
10743 number information unit. And if we're not using line_header_hash
10744 then this is what we want as well. */
10745 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
10747 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
10748 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
10753 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
10756 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
10758 struct dwarf2_per_objfile
*dwarf2_per_objfile
10759 = cu
->per_cu
->dwarf2_per_objfile
;
10760 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10761 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10762 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
10763 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
10764 struct attribute
*attr
;
10765 struct die_info
*child_die
;
10766 CORE_ADDR baseaddr
;
10768 prepare_one_comp_unit (cu
, die
, cu
->language
);
10769 baseaddr
= objfile
->text_section_offset ();
10771 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
10773 /* If we didn't find a lowpc, set it to highpc to avoid complaints
10774 from finish_block. */
10775 if (lowpc
== ((CORE_ADDR
) -1))
10777 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
10779 file_and_directory fnd
= find_file_and_directory (die
, cu
);
10781 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
10782 standardised yet. As a workaround for the language detection we fall
10783 back to the DW_AT_producer string. */
10784 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
10785 cu
->language
= language_opencl
;
10787 /* Similar hack for Go. */
10788 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
10789 set_cu_language (DW_LANG_Go
, cu
);
10791 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
10793 /* Decode line number information if present. We do this before
10794 processing child DIEs, so that the line header table is available
10795 for DW_AT_decl_file. */
10796 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
10798 /* Process all dies in compilation unit. */
10799 if (die
->child
!= NULL
)
10801 child_die
= die
->child
;
10802 while (child_die
&& child_die
->tag
)
10804 process_die (child_die
, cu
);
10805 child_die
= sibling_die (child_die
);
10809 /* Decode macro information, if present. Dwarf 2 macro information
10810 refers to information in the line number info statement program
10811 header, so we can only read it if we've read the header
10813 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
10815 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
10816 if (attr
&& cu
->line_header
)
10818 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
10819 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
10821 dwarf_decode_macros (cu
, DW_UNSND (attr
), 1);
10825 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
10826 if (attr
&& cu
->line_header
)
10828 unsigned int macro_offset
= DW_UNSND (attr
);
10830 dwarf_decode_macros (cu
, macro_offset
, 0);
10836 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
10838 struct type_unit_group
*tu_group
;
10840 struct attribute
*attr
;
10842 struct signatured_type
*sig_type
;
10844 gdb_assert (per_cu
->is_debug_types
);
10845 sig_type
= (struct signatured_type
*) per_cu
;
10847 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
10849 /* If we're using .gdb_index (includes -readnow) then
10850 per_cu->type_unit_group may not have been set up yet. */
10851 if (sig_type
->type_unit_group
== NULL
)
10852 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
10853 tu_group
= sig_type
->type_unit_group
;
10855 /* If we've already processed this stmt_list there's no real need to
10856 do it again, we could fake it and just recreate the part we need
10857 (file name,index -> symtab mapping). If data shows this optimization
10858 is useful we can do it then. */
10859 first_time
= tu_group
->compunit_symtab
== NULL
;
10861 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
10866 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
10867 lh
= dwarf_decode_line_header (line_offset
, this);
10872 start_symtab ("", NULL
, 0);
10875 gdb_assert (tu_group
->symtabs
== NULL
);
10876 gdb_assert (m_builder
== nullptr);
10877 struct compunit_symtab
*cust
= tu_group
->compunit_symtab
;
10878 m_builder
.reset (new struct buildsym_compunit
10879 (COMPUNIT_OBJFILE (cust
), "",
10880 COMPUNIT_DIRNAME (cust
),
10881 compunit_language (cust
),
10887 line_header
= lh
.release ();
10888 line_header_die_owner
= die
;
10892 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
10894 /* Note: We don't assign tu_group->compunit_symtab yet because we're
10895 still initializing it, and our caller (a few levels up)
10896 process_full_type_unit still needs to know if this is the first
10900 = XOBNEWVEC (&COMPUNIT_OBJFILE (cust
)->objfile_obstack
,
10901 struct symtab
*, line_header
->file_names_size ());
10903 auto &file_names
= line_header
->file_names ();
10904 for (i
= 0; i
< file_names
.size (); ++i
)
10906 file_entry
&fe
= file_names
[i
];
10907 dwarf2_start_subfile (this, fe
.name
,
10908 fe
.include_dir (line_header
));
10909 buildsym_compunit
*b
= get_builder ();
10910 if (b
->get_current_subfile ()->symtab
== NULL
)
10912 /* NOTE: start_subfile will recognize when it's been
10913 passed a file it has already seen. So we can't
10914 assume there's a simple mapping from
10915 cu->line_header->file_names to subfiles, plus
10916 cu->line_header->file_names may contain dups. */
10917 b
->get_current_subfile ()->symtab
10918 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
10921 fe
.symtab
= b
->get_current_subfile ()->symtab
;
10922 tu_group
->symtabs
[i
] = fe
.symtab
;
10927 gdb_assert (m_builder
== nullptr);
10928 struct compunit_symtab
*cust
= tu_group
->compunit_symtab
;
10929 m_builder
.reset (new struct buildsym_compunit
10930 (COMPUNIT_OBJFILE (cust
), "",
10931 COMPUNIT_DIRNAME (cust
),
10932 compunit_language (cust
),
10935 auto &file_names
= line_header
->file_names ();
10936 for (i
= 0; i
< file_names
.size (); ++i
)
10938 file_entry
&fe
= file_names
[i
];
10939 fe
.symtab
= tu_group
->symtabs
[i
];
10943 /* The main symtab is allocated last. Type units don't have DW_AT_name
10944 so they don't have a "real" (so to speak) symtab anyway.
10945 There is later code that will assign the main symtab to all symbols
10946 that don't have one. We need to handle the case of a symbol with a
10947 missing symtab (DW_AT_decl_file) anyway. */
10950 /* Process DW_TAG_type_unit.
10951 For TUs we want to skip the first top level sibling if it's not the
10952 actual type being defined by this TU. In this case the first top
10953 level sibling is there to provide context only. */
10956 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
10958 struct die_info
*child_die
;
10960 prepare_one_comp_unit (cu
, die
, language_minimal
);
10962 /* Initialize (or reinitialize) the machinery for building symtabs.
10963 We do this before processing child DIEs, so that the line header table
10964 is available for DW_AT_decl_file. */
10965 cu
->setup_type_unit_groups (die
);
10967 if (die
->child
!= NULL
)
10969 child_die
= die
->child
;
10970 while (child_die
&& child_die
->tag
)
10972 process_die (child_die
, cu
);
10973 child_die
= sibling_die (child_die
);
10980 http://gcc.gnu.org/wiki/DebugFission
10981 http://gcc.gnu.org/wiki/DebugFissionDWP
10983 To simplify handling of both DWO files ("object" files with the DWARF info)
10984 and DWP files (a file with the DWOs packaged up into one file), we treat
10985 DWP files as having a collection of virtual DWO files. */
10988 hash_dwo_file (const void *item
)
10990 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
10993 hash
= htab_hash_string (dwo_file
->dwo_name
);
10994 if (dwo_file
->comp_dir
!= NULL
)
10995 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11000 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11002 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11003 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11005 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11007 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11008 return lhs
->comp_dir
== rhs
->comp_dir
;
11009 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11012 /* Allocate a hash table for DWO files. */
11015 allocate_dwo_file_hash_table ()
11017 auto delete_dwo_file
= [] (void *item
)
11019 struct dwo_file
*dwo_file
= (struct dwo_file
*) item
;
11024 return htab_up (htab_create_alloc (41,
11031 /* Lookup DWO file DWO_NAME. */
11034 lookup_dwo_file_slot (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11035 const char *dwo_name
,
11036 const char *comp_dir
)
11038 struct dwo_file find_entry
;
11041 if (dwarf2_per_objfile
->dwo_files
== NULL
)
11042 dwarf2_per_objfile
->dwo_files
= allocate_dwo_file_hash_table ();
11044 find_entry
.dwo_name
= dwo_name
;
11045 find_entry
.comp_dir
= comp_dir
;
11046 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
.get (), &find_entry
,
11053 hash_dwo_unit (const void *item
)
11055 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11057 /* This drops the top 32 bits of the id, but is ok for a hash. */
11058 return dwo_unit
->signature
;
11062 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11064 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11065 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11067 /* The signature is assumed to be unique within the DWO file.
11068 So while object file CU dwo_id's always have the value zero,
11069 that's OK, assuming each object file DWO file has only one CU,
11070 and that's the rule for now. */
11071 return lhs
->signature
== rhs
->signature
;
11074 /* Allocate a hash table for DWO CUs,TUs.
11075 There is one of these tables for each of CUs,TUs for each DWO file. */
11078 allocate_dwo_unit_table ()
11080 /* Start out with a pretty small number.
11081 Generally DWO files contain only one CU and maybe some TUs. */
11082 return htab_up (htab_create_alloc (3,
11085 NULL
, xcalloc
, xfree
));
11088 /* die_reader_func for create_dwo_cu. */
11091 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
11092 const gdb_byte
*info_ptr
,
11093 struct die_info
*comp_unit_die
,
11094 struct dwo_file
*dwo_file
,
11095 struct dwo_unit
*dwo_unit
)
11097 struct dwarf2_cu
*cu
= reader
->cu
;
11098 sect_offset sect_off
= cu
->per_cu
->sect_off
;
11099 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
11101 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
11102 if (!signature
.has_value ())
11104 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11105 " its dwo_id [in module %s]"),
11106 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
11110 dwo_unit
->dwo_file
= dwo_file
;
11111 dwo_unit
->signature
= *signature
;
11112 dwo_unit
->section
= section
;
11113 dwo_unit
->sect_off
= sect_off
;
11114 dwo_unit
->length
= cu
->per_cu
->length
;
11116 if (dwarf_read_debug
)
11117 fprintf_unfiltered (gdb_stdlog
, " offset %s, dwo_id %s\n",
11118 sect_offset_str (sect_off
),
11119 hex_string (dwo_unit
->signature
));
11122 /* Create the dwo_units for the CUs in a DWO_FILE.
11123 Note: This function processes DWO files only, not DWP files. */
11126 create_cus_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11127 dwarf2_cu
*cu
, struct dwo_file
&dwo_file
,
11128 dwarf2_section_info
§ion
, htab_up
&cus_htab
)
11130 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11131 const gdb_byte
*info_ptr
, *end_ptr
;
11133 section
.read (objfile
);
11134 info_ptr
= section
.buffer
;
11136 if (info_ptr
== NULL
)
11139 if (dwarf_read_debug
)
11141 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
11142 section
.get_name (),
11143 section
.get_file_name ());
11146 end_ptr
= info_ptr
+ section
.size
;
11147 while (info_ptr
< end_ptr
)
11149 struct dwarf2_per_cu_data per_cu
;
11150 struct dwo_unit read_unit
{};
11151 struct dwo_unit
*dwo_unit
;
11153 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
11155 memset (&per_cu
, 0, sizeof (per_cu
));
11156 per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
11157 per_cu
.is_debug_types
= 0;
11158 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
11159 per_cu
.section
= §ion
;
11161 cutu_reader
reader (&per_cu
, cu
, &dwo_file
);
11162 if (!reader
.dummy_p
)
11163 create_dwo_cu_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
,
11164 &dwo_file
, &read_unit
);
11165 info_ptr
+= per_cu
.length
;
11167 // If the unit could not be parsed, skip it.
11168 if (read_unit
.dwo_file
== NULL
)
11171 if (cus_htab
== NULL
)
11172 cus_htab
= allocate_dwo_unit_table ();
11174 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
11175 *dwo_unit
= read_unit
;
11176 slot
= htab_find_slot (cus_htab
.get (), dwo_unit
, INSERT
);
11177 gdb_assert (slot
!= NULL
);
11180 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
11181 sect_offset dup_sect_off
= dup_cu
->sect_off
;
11183 complaint (_("debug cu entry at offset %s is duplicate to"
11184 " the entry at offset %s, signature %s"),
11185 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
11186 hex_string (dwo_unit
->signature
));
11188 *slot
= (void *)dwo_unit
;
11192 /* DWP file .debug_{cu,tu}_index section format:
11193 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11197 Both index sections have the same format, and serve to map a 64-bit
11198 signature to a set of section numbers. Each section begins with a header,
11199 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11200 indexes, and a pool of 32-bit section numbers. The index sections will be
11201 aligned at 8-byte boundaries in the file.
11203 The index section header consists of:
11205 V, 32 bit version number
11207 N, 32 bit number of compilation units or type units in the index
11208 M, 32 bit number of slots in the hash table
11210 Numbers are recorded using the byte order of the application binary.
11212 The hash table begins at offset 16 in the section, and consists of an array
11213 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11214 order of the application binary). Unused slots in the hash table are 0.
11215 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11217 The parallel table begins immediately after the hash table
11218 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11219 array of 32-bit indexes (using the byte order of the application binary),
11220 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11221 table contains a 32-bit index into the pool of section numbers. For unused
11222 hash table slots, the corresponding entry in the parallel table will be 0.
11224 The pool of section numbers begins immediately following the hash table
11225 (at offset 16 + 12 * M from the beginning of the section). The pool of
11226 section numbers consists of an array of 32-bit words (using the byte order
11227 of the application binary). Each item in the array is indexed starting
11228 from 0. The hash table entry provides the index of the first section
11229 number in the set. Additional section numbers in the set follow, and the
11230 set is terminated by a 0 entry (section number 0 is not used in ELF).
11232 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
11233 section must be the first entry in the set, and the .debug_abbrev.dwo must
11234 be the second entry. Other members of the set may follow in any order.
11240 DWP Version 2 combines all the .debug_info, etc. sections into one,
11241 and the entries in the index tables are now offsets into these sections.
11242 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
11245 Index Section Contents:
11247 Hash Table of Signatures dwp_hash_table.hash_table
11248 Parallel Table of Indices dwp_hash_table.unit_table
11249 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
11250 Table of Section Sizes dwp_hash_table.v2.sizes
11252 The index section header consists of:
11254 V, 32 bit version number
11255 L, 32 bit number of columns in the table of section offsets
11256 N, 32 bit number of compilation units or type units in the index
11257 M, 32 bit number of slots in the hash table
11259 Numbers are recorded using the byte order of the application binary.
11261 The hash table has the same format as version 1.
11262 The parallel table of indices has the same format as version 1,
11263 except that the entries are origin-1 indices into the table of sections
11264 offsets and the table of section sizes.
11266 The table of offsets begins immediately following the parallel table
11267 (at offset 16 + 12 * M from the beginning of the section). The table is
11268 a two-dimensional array of 32-bit words (using the byte order of the
11269 application binary), with L columns and N+1 rows, in row-major order.
11270 Each row in the array is indexed starting from 0. The first row provides
11271 a key to the remaining rows: each column in this row provides an identifier
11272 for a debug section, and the offsets in the same column of subsequent rows
11273 refer to that section. The section identifiers are:
11275 DW_SECT_INFO 1 .debug_info.dwo
11276 DW_SECT_TYPES 2 .debug_types.dwo
11277 DW_SECT_ABBREV 3 .debug_abbrev.dwo
11278 DW_SECT_LINE 4 .debug_line.dwo
11279 DW_SECT_LOC 5 .debug_loc.dwo
11280 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
11281 DW_SECT_MACINFO 7 .debug_macinfo.dwo
11282 DW_SECT_MACRO 8 .debug_macro.dwo
11284 The offsets provided by the CU and TU index sections are the base offsets
11285 for the contributions made by each CU or TU to the corresponding section
11286 in the package file. Each CU and TU header contains an abbrev_offset
11287 field, used to find the abbreviations table for that CU or TU within the
11288 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
11289 be interpreted as relative to the base offset given in the index section.
11290 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
11291 should be interpreted as relative to the base offset for .debug_line.dwo,
11292 and offsets into other debug sections obtained from DWARF attributes should
11293 also be interpreted as relative to the corresponding base offset.
11295 The table of sizes begins immediately following the table of offsets.
11296 Like the table of offsets, it is a two-dimensional array of 32-bit words,
11297 with L columns and N rows, in row-major order. Each row in the array is
11298 indexed starting from 1 (row 0 is shared by the two tables).
11302 Hash table lookup is handled the same in version 1 and 2:
11304 We assume that N and M will not exceed 2^32 - 1.
11305 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
11307 Given a 64-bit compilation unit signature or a type signature S, an entry
11308 in the hash table is located as follows:
11310 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
11311 the low-order k bits all set to 1.
11313 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
11315 3) If the hash table entry at index H matches the signature, use that
11316 entry. If the hash table entry at index H is unused (all zeroes),
11317 terminate the search: the signature is not present in the table.
11319 4) Let H = (H + H') modulo M. Repeat at Step 3.
11321 Because M > N and H' and M are relatively prime, the search is guaranteed
11322 to stop at an unused slot or find the match. */
11324 /* Create a hash table to map DWO IDs to their CU/TU entry in
11325 .debug_{info,types}.dwo in DWP_FILE.
11326 Returns NULL if there isn't one.
11327 Note: This function processes DWP files only, not DWO files. */
11329 static struct dwp_hash_table
*
11330 create_dwp_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11331 struct dwp_file
*dwp_file
, int is_debug_types
)
11333 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11334 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11335 const gdb_byte
*index_ptr
, *index_end
;
11336 struct dwarf2_section_info
*index
;
11337 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
11338 struct dwp_hash_table
*htab
;
11340 if (is_debug_types
)
11341 index
= &dwp_file
->sections
.tu_index
;
11343 index
= &dwp_file
->sections
.cu_index
;
11345 if (index
->empty ())
11347 index
->read (objfile
);
11349 index_ptr
= index
->buffer
;
11350 index_end
= index_ptr
+ index
->size
;
11352 version
= read_4_bytes (dbfd
, index_ptr
);
11355 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
11359 nr_units
= read_4_bytes (dbfd
, index_ptr
);
11361 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
11364 if (version
!= 1 && version
!= 2)
11366 error (_("Dwarf Error: unsupported DWP file version (%s)"
11367 " [in module %s]"),
11368 pulongest (version
), dwp_file
->name
);
11370 if (nr_slots
!= (nr_slots
& -nr_slots
))
11372 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
11373 " is not power of 2 [in module %s]"),
11374 pulongest (nr_slots
), dwp_file
->name
);
11377 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
11378 htab
->version
= version
;
11379 htab
->nr_columns
= nr_columns
;
11380 htab
->nr_units
= nr_units
;
11381 htab
->nr_slots
= nr_slots
;
11382 htab
->hash_table
= index_ptr
;
11383 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
11385 /* Exit early if the table is empty. */
11386 if (nr_slots
== 0 || nr_units
== 0
11387 || (version
== 2 && nr_columns
== 0))
11389 /* All must be zero. */
11390 if (nr_slots
!= 0 || nr_units
!= 0
11391 || (version
== 2 && nr_columns
!= 0))
11393 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
11394 " all zero [in modules %s]"),
11402 htab
->section_pool
.v1
.indices
=
11403 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11404 /* It's harder to decide whether the section is too small in v1.
11405 V1 is deprecated anyway so we punt. */
11409 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11410 int *ids
= htab
->section_pool
.v2
.section_ids
;
11411 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
11412 /* Reverse map for error checking. */
11413 int ids_seen
[DW_SECT_MAX
+ 1];
11416 if (nr_columns
< 2)
11418 error (_("Dwarf Error: bad DWP hash table, too few columns"
11419 " in section table [in module %s]"),
11422 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
11424 error (_("Dwarf Error: bad DWP hash table, too many columns"
11425 " in section table [in module %s]"),
11428 memset (ids
, 255, sizeof_ids
);
11429 memset (ids_seen
, 255, sizeof (ids_seen
));
11430 for (i
= 0; i
< nr_columns
; ++i
)
11432 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11434 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
11436 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11437 " in section table [in module %s]"),
11438 id
, dwp_file
->name
);
11440 if (ids_seen
[id
] != -1)
11442 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11443 " id %d in section table [in module %s]"),
11444 id
, dwp_file
->name
);
11449 /* Must have exactly one info or types section. */
11450 if (((ids_seen
[DW_SECT_INFO
] != -1)
11451 + (ids_seen
[DW_SECT_TYPES
] != -1))
11454 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11455 " DWO info/types section [in module %s]"),
11458 /* Must have an abbrev section. */
11459 if (ids_seen
[DW_SECT_ABBREV
] == -1)
11461 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11462 " section [in module %s]"),
11465 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11466 htab
->section_pool
.v2
.sizes
=
11467 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
11468 * nr_units
* nr_columns
);
11469 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
11470 * nr_units
* nr_columns
))
11473 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11474 " [in module %s]"),
11482 /* Update SECTIONS with the data from SECTP.
11484 This function is like the other "locate" section routines that are
11485 passed to bfd_map_over_sections, but in this context the sections to
11486 read comes from the DWP V1 hash table, not the full ELF section table.
11488 The result is non-zero for success, or zero if an error was found. */
11491 locate_v1_virtual_dwo_sections (asection
*sectp
,
11492 struct virtual_v1_dwo_sections
*sections
)
11494 const struct dwop_section_names
*names
= &dwop_section_names
;
11496 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
11498 /* There can be only one. */
11499 if (sections
->abbrev
.s
.section
!= NULL
)
11501 sections
->abbrev
.s
.section
= sectp
;
11502 sections
->abbrev
.size
= bfd_section_size (sectp
);
11504 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
11505 || section_is_p (sectp
->name
, &names
->types_dwo
))
11507 /* There can be only one. */
11508 if (sections
->info_or_types
.s
.section
!= NULL
)
11510 sections
->info_or_types
.s
.section
= sectp
;
11511 sections
->info_or_types
.size
= bfd_section_size (sectp
);
11513 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
11515 /* There can be only one. */
11516 if (sections
->line
.s
.section
!= NULL
)
11518 sections
->line
.s
.section
= sectp
;
11519 sections
->line
.size
= bfd_section_size (sectp
);
11521 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
11523 /* There can be only one. */
11524 if (sections
->loc
.s
.section
!= NULL
)
11526 sections
->loc
.s
.section
= sectp
;
11527 sections
->loc
.size
= bfd_section_size (sectp
);
11529 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
11531 /* There can be only one. */
11532 if (sections
->macinfo
.s
.section
!= NULL
)
11534 sections
->macinfo
.s
.section
= sectp
;
11535 sections
->macinfo
.size
= bfd_section_size (sectp
);
11537 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
11539 /* There can be only one. */
11540 if (sections
->macro
.s
.section
!= NULL
)
11542 sections
->macro
.s
.section
= sectp
;
11543 sections
->macro
.size
= bfd_section_size (sectp
);
11545 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
11547 /* There can be only one. */
11548 if (sections
->str_offsets
.s
.section
!= NULL
)
11550 sections
->str_offsets
.s
.section
= sectp
;
11551 sections
->str_offsets
.size
= bfd_section_size (sectp
);
11555 /* No other kind of section is valid. */
11562 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11563 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11564 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11565 This is for DWP version 1 files. */
11567 static struct dwo_unit
*
11568 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11569 struct dwp_file
*dwp_file
,
11570 uint32_t unit_index
,
11571 const char *comp_dir
,
11572 ULONGEST signature
, int is_debug_types
)
11574 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11575 const struct dwp_hash_table
*dwp_htab
=
11576 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11577 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11578 const char *kind
= is_debug_types
? "TU" : "CU";
11579 struct dwo_file
*dwo_file
;
11580 struct dwo_unit
*dwo_unit
;
11581 struct virtual_v1_dwo_sections sections
;
11582 void **dwo_file_slot
;
11585 gdb_assert (dwp_file
->version
== 1);
11587 if (dwarf_read_debug
)
11589 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
11591 pulongest (unit_index
), hex_string (signature
),
11595 /* Fetch the sections of this DWO unit.
11596 Put a limit on the number of sections we look for so that bad data
11597 doesn't cause us to loop forever. */
11599 #define MAX_NR_V1_DWO_SECTIONS \
11600 (1 /* .debug_info or .debug_types */ \
11601 + 1 /* .debug_abbrev */ \
11602 + 1 /* .debug_line */ \
11603 + 1 /* .debug_loc */ \
11604 + 1 /* .debug_str_offsets */ \
11605 + 1 /* .debug_macro or .debug_macinfo */ \
11606 + 1 /* trailing zero */)
11608 memset (§ions
, 0, sizeof (sections
));
11610 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
11613 uint32_t section_nr
=
11614 read_4_bytes (dbfd
,
11615 dwp_htab
->section_pool
.v1
.indices
11616 + (unit_index
+ i
) * sizeof (uint32_t));
11618 if (section_nr
== 0)
11620 if (section_nr
>= dwp_file
->num_sections
)
11622 error (_("Dwarf Error: bad DWP hash table, section number too large"
11623 " [in module %s]"),
11627 sectp
= dwp_file
->elf_sections
[section_nr
];
11628 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
11630 error (_("Dwarf Error: bad DWP hash table, invalid section found"
11631 " [in module %s]"),
11637 || sections
.info_or_types
.empty ()
11638 || sections
.abbrev
.empty ())
11640 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
11641 " [in module %s]"),
11644 if (i
== MAX_NR_V1_DWO_SECTIONS
)
11646 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
11647 " [in module %s]"),
11651 /* It's easier for the rest of the code if we fake a struct dwo_file and
11652 have dwo_unit "live" in that. At least for now.
11654 The DWP file can be made up of a random collection of CUs and TUs.
11655 However, for each CU + set of TUs that came from the same original DWO
11656 file, we can combine them back into a virtual DWO file to save space
11657 (fewer struct dwo_file objects to allocate). Remember that for really
11658 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
11660 std::string virtual_dwo_name
=
11661 string_printf ("virtual-dwo/%d-%d-%d-%d",
11662 sections
.abbrev
.get_id (),
11663 sections
.line
.get_id (),
11664 sections
.loc
.get_id (),
11665 sections
.str_offsets
.get_id ());
11666 /* Can we use an existing virtual DWO file? */
11667 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
11668 virtual_dwo_name
.c_str (),
11670 /* Create one if necessary. */
11671 if (*dwo_file_slot
== NULL
)
11673 if (dwarf_read_debug
)
11675 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
11676 virtual_dwo_name
.c_str ());
11678 dwo_file
= new struct dwo_file
;
11679 dwo_file
->dwo_name
= objfile
->intern (virtual_dwo_name
);
11680 dwo_file
->comp_dir
= comp_dir
;
11681 dwo_file
->sections
.abbrev
= sections
.abbrev
;
11682 dwo_file
->sections
.line
= sections
.line
;
11683 dwo_file
->sections
.loc
= sections
.loc
;
11684 dwo_file
->sections
.macinfo
= sections
.macinfo
;
11685 dwo_file
->sections
.macro
= sections
.macro
;
11686 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
11687 /* The "str" section is global to the entire DWP file. */
11688 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
11689 /* The info or types section is assigned below to dwo_unit,
11690 there's no need to record it in dwo_file.
11691 Also, we can't simply record type sections in dwo_file because
11692 we record a pointer into the vector in dwo_unit. As we collect more
11693 types we'll grow the vector and eventually have to reallocate space
11694 for it, invalidating all copies of pointers into the previous
11696 *dwo_file_slot
= dwo_file
;
11700 if (dwarf_read_debug
)
11702 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
11703 virtual_dwo_name
.c_str ());
11705 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
11708 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
11709 dwo_unit
->dwo_file
= dwo_file
;
11710 dwo_unit
->signature
= signature
;
11711 dwo_unit
->section
=
11712 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
11713 *dwo_unit
->section
= sections
.info_or_types
;
11714 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
11719 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
11720 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
11721 piece within that section used by a TU/CU, return a virtual section
11722 of just that piece. */
11724 static struct dwarf2_section_info
11725 create_dwp_v2_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11726 struct dwarf2_section_info
*section
,
11727 bfd_size_type offset
, bfd_size_type size
)
11729 struct dwarf2_section_info result
;
11732 gdb_assert (section
!= NULL
);
11733 gdb_assert (!section
->is_virtual
);
11735 memset (&result
, 0, sizeof (result
));
11736 result
.s
.containing_section
= section
;
11737 result
.is_virtual
= true;
11742 sectp
= section
->get_bfd_section ();
11744 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
11745 bounds of the real section. This is a pretty-rare event, so just
11746 flag an error (easier) instead of a warning and trying to cope. */
11748 || offset
+ size
> bfd_section_size (sectp
))
11750 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
11751 " in section %s [in module %s]"),
11752 sectp
? bfd_section_name (sectp
) : "<unknown>",
11753 objfile_name (dwarf2_per_objfile
->objfile
));
11756 result
.virtual_offset
= offset
;
11757 result
.size
= size
;
11761 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
11762 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
11763 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
11764 This is for DWP version 2 files. */
11766 static struct dwo_unit
*
11767 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11768 struct dwp_file
*dwp_file
,
11769 uint32_t unit_index
,
11770 const char *comp_dir
,
11771 ULONGEST signature
, int is_debug_types
)
11773 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11774 const struct dwp_hash_table
*dwp_htab
=
11775 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11776 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11777 const char *kind
= is_debug_types
? "TU" : "CU";
11778 struct dwo_file
*dwo_file
;
11779 struct dwo_unit
*dwo_unit
;
11780 struct virtual_v2_dwo_sections sections
;
11781 void **dwo_file_slot
;
11784 gdb_assert (dwp_file
->version
== 2);
11786 if (dwarf_read_debug
)
11788 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
11790 pulongest (unit_index
), hex_string (signature
),
11794 /* Fetch the section offsets of this DWO unit. */
11796 memset (§ions
, 0, sizeof (sections
));
11798 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
11800 uint32_t offset
= read_4_bytes (dbfd
,
11801 dwp_htab
->section_pool
.v2
.offsets
11802 + (((unit_index
- 1) * dwp_htab
->nr_columns
11804 * sizeof (uint32_t)));
11805 uint32_t size
= read_4_bytes (dbfd
,
11806 dwp_htab
->section_pool
.v2
.sizes
11807 + (((unit_index
- 1) * dwp_htab
->nr_columns
11809 * sizeof (uint32_t)));
11811 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
11814 case DW_SECT_TYPES
:
11815 sections
.info_or_types_offset
= offset
;
11816 sections
.info_or_types_size
= size
;
11818 case DW_SECT_ABBREV
:
11819 sections
.abbrev_offset
= offset
;
11820 sections
.abbrev_size
= size
;
11823 sections
.line_offset
= offset
;
11824 sections
.line_size
= size
;
11827 sections
.loc_offset
= offset
;
11828 sections
.loc_size
= size
;
11830 case DW_SECT_STR_OFFSETS
:
11831 sections
.str_offsets_offset
= offset
;
11832 sections
.str_offsets_size
= size
;
11834 case DW_SECT_MACINFO
:
11835 sections
.macinfo_offset
= offset
;
11836 sections
.macinfo_size
= size
;
11838 case DW_SECT_MACRO
:
11839 sections
.macro_offset
= offset
;
11840 sections
.macro_size
= size
;
11845 /* It's easier for the rest of the code if we fake a struct dwo_file and
11846 have dwo_unit "live" in that. At least for now.
11848 The DWP file can be made up of a random collection of CUs and TUs.
11849 However, for each CU + set of TUs that came from the same original DWO
11850 file, we can combine them back into a virtual DWO file to save space
11851 (fewer struct dwo_file objects to allocate). Remember that for really
11852 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
11854 std::string virtual_dwo_name
=
11855 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
11856 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
11857 (long) (sections
.line_size
? sections
.line_offset
: 0),
11858 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
11859 (long) (sections
.str_offsets_size
11860 ? sections
.str_offsets_offset
: 0));
11861 /* Can we use an existing virtual DWO file? */
11862 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
11863 virtual_dwo_name
.c_str (),
11865 /* Create one if necessary. */
11866 if (*dwo_file_slot
== NULL
)
11868 if (dwarf_read_debug
)
11870 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
11871 virtual_dwo_name
.c_str ());
11873 dwo_file
= new struct dwo_file
;
11874 dwo_file
->dwo_name
= objfile
->intern (virtual_dwo_name
);
11875 dwo_file
->comp_dir
= comp_dir
;
11876 dwo_file
->sections
.abbrev
=
11877 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.abbrev
,
11878 sections
.abbrev_offset
, sections
.abbrev_size
);
11879 dwo_file
->sections
.line
=
11880 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.line
,
11881 sections
.line_offset
, sections
.line_size
);
11882 dwo_file
->sections
.loc
=
11883 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.loc
,
11884 sections
.loc_offset
, sections
.loc_size
);
11885 dwo_file
->sections
.macinfo
=
11886 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macinfo
,
11887 sections
.macinfo_offset
, sections
.macinfo_size
);
11888 dwo_file
->sections
.macro
=
11889 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macro
,
11890 sections
.macro_offset
, sections
.macro_size
);
11891 dwo_file
->sections
.str_offsets
=
11892 create_dwp_v2_section (dwarf2_per_objfile
,
11893 &dwp_file
->sections
.str_offsets
,
11894 sections
.str_offsets_offset
,
11895 sections
.str_offsets_size
);
11896 /* The "str" section is global to the entire DWP file. */
11897 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
11898 /* The info or types section is assigned below to dwo_unit,
11899 there's no need to record it in dwo_file.
11900 Also, we can't simply record type sections in dwo_file because
11901 we record a pointer into the vector in dwo_unit. As we collect more
11902 types we'll grow the vector and eventually have to reallocate space
11903 for it, invalidating all copies of pointers into the previous
11905 *dwo_file_slot
= dwo_file
;
11909 if (dwarf_read_debug
)
11911 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
11912 virtual_dwo_name
.c_str ());
11914 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
11917 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
11918 dwo_unit
->dwo_file
= dwo_file
;
11919 dwo_unit
->signature
= signature
;
11920 dwo_unit
->section
=
11921 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
11922 *dwo_unit
->section
= create_dwp_v2_section (dwarf2_per_objfile
,
11924 ? &dwp_file
->sections
.types
11925 : &dwp_file
->sections
.info
,
11926 sections
.info_or_types_offset
,
11927 sections
.info_or_types_size
);
11928 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
11933 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
11934 Returns NULL if the signature isn't found. */
11936 static struct dwo_unit
*
11937 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11938 struct dwp_file
*dwp_file
, const char *comp_dir
,
11939 ULONGEST signature
, int is_debug_types
)
11941 const struct dwp_hash_table
*dwp_htab
=
11942 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
11943 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11944 uint32_t mask
= dwp_htab
->nr_slots
- 1;
11945 uint32_t hash
= signature
& mask
;
11946 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
11949 struct dwo_unit find_dwo_cu
;
11951 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
11952 find_dwo_cu
.signature
= signature
;
11953 slot
= htab_find_slot (is_debug_types
11954 ? dwp_file
->loaded_tus
.get ()
11955 : dwp_file
->loaded_cus
.get (),
11956 &find_dwo_cu
, INSERT
);
11959 return (struct dwo_unit
*) *slot
;
11961 /* Use a for loop so that we don't loop forever on bad debug info. */
11962 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
11964 ULONGEST signature_in_table
;
11966 signature_in_table
=
11967 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
11968 if (signature_in_table
== signature
)
11970 uint32_t unit_index
=
11971 read_4_bytes (dbfd
,
11972 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
11974 if (dwp_file
->version
== 1)
11976 *slot
= create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
,
11977 dwp_file
, unit_index
,
11978 comp_dir
, signature
,
11983 *slot
= create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
,
11984 dwp_file
, unit_index
,
11985 comp_dir
, signature
,
11988 return (struct dwo_unit
*) *slot
;
11990 if (signature_in_table
== 0)
11992 hash
= (hash
+ hash2
) & mask
;
11995 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
11996 " [in module %s]"),
12000 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12001 Open the file specified by FILE_NAME and hand it off to BFD for
12002 preliminary analysis. Return a newly initialized bfd *, which
12003 includes a canonicalized copy of FILE_NAME.
12004 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12005 SEARCH_CWD is true if the current directory is to be searched.
12006 It will be searched before debug-file-directory.
12007 If successful, the file is added to the bfd include table of the
12008 objfile's bfd (see gdb_bfd_record_inclusion).
12009 If unable to find/open the file, return NULL.
12010 NOTE: This function is derived from symfile_bfd_open. */
12012 static gdb_bfd_ref_ptr
12013 try_open_dwop_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12014 const char *file_name
, int is_dwp
, int search_cwd
)
12017 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12018 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12019 to debug_file_directory. */
12020 const char *search_path
;
12021 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12023 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12026 if (*debug_file_directory
!= '\0')
12028 search_path_holder
.reset (concat (".", dirname_separator_string
,
12029 debug_file_directory
,
12031 search_path
= search_path_holder
.get ();
12037 search_path
= debug_file_directory
;
12039 openp_flags flags
= OPF_RETURN_REALPATH
;
12041 flags
|= OPF_SEARCH_IN_PATH
;
12043 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12044 desc
= openp (search_path
, flags
, file_name
,
12045 O_RDONLY
| O_BINARY
, &absolute_name
);
12049 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12051 if (sym_bfd
== NULL
)
12053 bfd_set_cacheable (sym_bfd
.get (), 1);
12055 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12058 /* Success. Record the bfd as having been included by the objfile's bfd.
12059 This is important because things like demangled_names_hash lives in the
12060 objfile's per_bfd space and may have references to things like symbol
12061 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12062 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12067 /* Try to open DWO file FILE_NAME.
12068 COMP_DIR is the DW_AT_comp_dir attribute.
12069 The result is the bfd handle of the file.
12070 If there is a problem finding or opening the file, return NULL.
12071 Upon success, the canonicalized path of the file is stored in the bfd,
12072 same as symfile_bfd_open. */
12074 static gdb_bfd_ref_ptr
12075 open_dwo_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12076 const char *file_name
, const char *comp_dir
)
12078 if (IS_ABSOLUTE_PATH (file_name
))
12079 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12080 0 /*is_dwp*/, 0 /*search_cwd*/);
12082 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12084 if (comp_dir
!= NULL
)
12086 gdb::unique_xmalloc_ptr
<char> path_to_try
12087 (concat (comp_dir
, SLASH_STRING
, file_name
, (char *) NULL
));
12089 /* NOTE: If comp_dir is a relative path, this will also try the
12090 search path, which seems useful. */
12091 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
,
12092 path_to_try
.get (),
12094 1 /*search_cwd*/));
12099 /* That didn't work, try debug-file-directory, which, despite its name,
12100 is a list of paths. */
12102 if (*debug_file_directory
== '\0')
12105 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12106 0 /*is_dwp*/, 1 /*search_cwd*/);
12109 /* This function is mapped across the sections and remembers the offset and
12110 size of each of the DWO debugging sections we are interested in. */
12113 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
12115 struct dwo_sections
*dwo_sections
= (struct dwo_sections
*) dwo_sections_ptr
;
12116 const struct dwop_section_names
*names
= &dwop_section_names
;
12118 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12120 dwo_sections
->abbrev
.s
.section
= sectp
;
12121 dwo_sections
->abbrev
.size
= bfd_section_size (sectp
);
12123 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12125 dwo_sections
->info
.s
.section
= sectp
;
12126 dwo_sections
->info
.size
= bfd_section_size (sectp
);
12128 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12130 dwo_sections
->line
.s
.section
= sectp
;
12131 dwo_sections
->line
.size
= bfd_section_size (sectp
);
12133 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12135 dwo_sections
->loc
.s
.section
= sectp
;
12136 dwo_sections
->loc
.size
= bfd_section_size (sectp
);
12138 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12140 dwo_sections
->macinfo
.s
.section
= sectp
;
12141 dwo_sections
->macinfo
.size
= bfd_section_size (sectp
);
12143 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12145 dwo_sections
->macro
.s
.section
= sectp
;
12146 dwo_sections
->macro
.size
= bfd_section_size (sectp
);
12148 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
12150 dwo_sections
->str
.s
.section
= sectp
;
12151 dwo_sections
->str
.size
= bfd_section_size (sectp
);
12153 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12155 dwo_sections
->str_offsets
.s
.section
= sectp
;
12156 dwo_sections
->str_offsets
.size
= bfd_section_size (sectp
);
12158 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
12160 struct dwarf2_section_info type_section
;
12162 memset (&type_section
, 0, sizeof (type_section
));
12163 type_section
.s
.section
= sectp
;
12164 type_section
.size
= bfd_section_size (sectp
);
12165 dwo_sections
->types
.push_back (type_section
);
12169 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12170 by PER_CU. This is for the non-DWP case.
12171 The result is NULL if DWO_NAME can't be found. */
12173 static struct dwo_file
*
12174 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
12175 const char *dwo_name
, const char *comp_dir
)
12177 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
12179 gdb_bfd_ref_ptr dbfd
= open_dwo_file (dwarf2_per_objfile
, dwo_name
, comp_dir
);
12182 if (dwarf_read_debug
)
12183 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
12187 dwo_file_up
dwo_file (new struct dwo_file
);
12188 dwo_file
->dwo_name
= dwo_name
;
12189 dwo_file
->comp_dir
= comp_dir
;
12190 dwo_file
->dbfd
= std::move (dbfd
);
12192 bfd_map_over_sections (dwo_file
->dbfd
.get (), dwarf2_locate_dwo_sections
,
12193 &dwo_file
->sections
);
12195 create_cus_hash_table (dwarf2_per_objfile
, per_cu
->cu
, *dwo_file
,
12196 dwo_file
->sections
.info
, dwo_file
->cus
);
12198 create_debug_types_hash_table (dwarf2_per_objfile
, dwo_file
.get (),
12199 dwo_file
->sections
.types
, dwo_file
->tus
);
12201 if (dwarf_read_debug
)
12202 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
12204 return dwo_file
.release ();
12207 /* This function is mapped across the sections and remembers the offset and
12208 size of each of the DWP debugging sections common to version 1 and 2 that
12209 we are interested in. */
12212 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
12213 void *dwp_file_ptr
)
12215 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12216 const struct dwop_section_names
*names
= &dwop_section_names
;
12217 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12219 /* Record the ELF section number for later lookup: this is what the
12220 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12221 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12222 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12224 /* Look for specific sections that we need. */
12225 if (section_is_p (sectp
->name
, &names
->str_dwo
))
12227 dwp_file
->sections
.str
.s
.section
= sectp
;
12228 dwp_file
->sections
.str
.size
= bfd_section_size (sectp
);
12230 else if (section_is_p (sectp
->name
, &names
->cu_index
))
12232 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
12233 dwp_file
->sections
.cu_index
.size
= bfd_section_size (sectp
);
12235 else if (section_is_p (sectp
->name
, &names
->tu_index
))
12237 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
12238 dwp_file
->sections
.tu_index
.size
= bfd_section_size (sectp
);
12242 /* This function is mapped across the sections and remembers the offset and
12243 size of each of the DWP version 2 debugging sections that we are interested
12244 in. This is split into a separate function because we don't know if we
12245 have version 1 or 2 until we parse the cu_index/tu_index sections. */
12248 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12250 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12251 const struct dwop_section_names
*names
= &dwop_section_names
;
12252 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12254 /* Record the ELF section number for later lookup: this is what the
12255 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12256 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12257 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12259 /* Look for specific sections that we need. */
12260 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12262 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12263 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12265 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12267 dwp_file
->sections
.info
.s
.section
= sectp
;
12268 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12270 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12272 dwp_file
->sections
.line
.s
.section
= sectp
;
12273 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12275 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12277 dwp_file
->sections
.loc
.s
.section
= sectp
;
12278 dwp_file
->sections
.loc
.size
= bfd_section_size (sectp
);
12280 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12282 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
12283 dwp_file
->sections
.macinfo
.size
= bfd_section_size (sectp
);
12285 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12287 dwp_file
->sections
.macro
.s
.section
= sectp
;
12288 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12290 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12292 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12293 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12295 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
12297 dwp_file
->sections
.types
.s
.section
= sectp
;
12298 dwp_file
->sections
.types
.size
= bfd_section_size (sectp
);
12302 /* Hash function for dwp_file loaded CUs/TUs. */
12305 hash_dwp_loaded_cutus (const void *item
)
12307 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
12309 /* This drops the top 32 bits of the signature, but is ok for a hash. */
12310 return dwo_unit
->signature
;
12313 /* Equality function for dwp_file loaded CUs/TUs. */
12316 eq_dwp_loaded_cutus (const void *a
, const void *b
)
12318 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
12319 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
12321 return dua
->signature
== dub
->signature
;
12324 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
12327 allocate_dwp_loaded_cutus_table ()
12329 return htab_up (htab_create_alloc (3,
12330 hash_dwp_loaded_cutus
,
12331 eq_dwp_loaded_cutus
,
12332 NULL
, xcalloc
, xfree
));
12335 /* Try to open DWP file FILE_NAME.
12336 The result is the bfd handle of the file.
12337 If there is a problem finding or opening the file, return NULL.
12338 Upon success, the canonicalized path of the file is stored in the bfd,
12339 same as symfile_bfd_open. */
12341 static gdb_bfd_ref_ptr
12342 open_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12343 const char *file_name
)
12345 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12347 1 /*search_cwd*/));
12351 /* Work around upstream bug 15652.
12352 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
12353 [Whether that's a "bug" is debatable, but it is getting in our way.]
12354 We have no real idea where the dwp file is, because gdb's realpath-ing
12355 of the executable's path may have discarded the needed info.
12356 [IWBN if the dwp file name was recorded in the executable, akin to
12357 .gnu_debuglink, but that doesn't exist yet.]
12358 Strip the directory from FILE_NAME and search again. */
12359 if (*debug_file_directory
!= '\0')
12361 /* Don't implicitly search the current directory here.
12362 If the user wants to search "." to handle this case,
12363 it must be added to debug-file-directory. */
12364 return try_open_dwop_file (dwarf2_per_objfile
,
12365 lbasename (file_name
), 1 /*is_dwp*/,
12372 /* Initialize the use of the DWP file for the current objfile.
12373 By convention the name of the DWP file is ${objfile}.dwp.
12374 The result is NULL if it can't be found. */
12376 static std::unique_ptr
<struct dwp_file
>
12377 open_and_init_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
12379 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12381 /* Try to find first .dwp for the binary file before any symbolic links
12384 /* If the objfile is a debug file, find the name of the real binary
12385 file and get the name of dwp file from there. */
12386 std::string dwp_name
;
12387 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
12389 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
12390 const char *backlink_basename
= lbasename (backlink
->original_name
);
12392 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
12395 dwp_name
= objfile
->original_name
;
12397 dwp_name
+= ".dwp";
12399 gdb_bfd_ref_ptr
dbfd (open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ()));
12401 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
12403 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
12404 dwp_name
= objfile_name (objfile
);
12405 dwp_name
+= ".dwp";
12406 dbfd
= open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ());
12411 if (dwarf_read_debug
)
12412 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
.c_str ());
12413 return std::unique_ptr
<dwp_file
> ();
12416 const char *name
= bfd_get_filename (dbfd
.get ());
12417 std::unique_ptr
<struct dwp_file
> dwp_file
12418 (new struct dwp_file (name
, std::move (dbfd
)));
12420 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
12421 dwp_file
->elf_sections
=
12422 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
12423 dwp_file
->num_sections
, asection
*);
12425 bfd_map_over_sections (dwp_file
->dbfd
.get (),
12426 dwarf2_locate_common_dwp_sections
,
12429 dwp_file
->cus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
.get (),
12432 dwp_file
->tus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
.get (),
12435 /* The DWP file version is stored in the hash table. Oh well. */
12436 if (dwp_file
->cus
&& dwp_file
->tus
12437 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
12439 /* Technically speaking, we should try to limp along, but this is
12440 pretty bizarre. We use pulongest here because that's the established
12441 portability solution (e.g, we cannot use %u for uint32_t). */
12442 error (_("Dwarf Error: DWP file CU version %s doesn't match"
12443 " TU version %s [in DWP file %s]"),
12444 pulongest (dwp_file
->cus
->version
),
12445 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
12449 dwp_file
->version
= dwp_file
->cus
->version
;
12450 else if (dwp_file
->tus
)
12451 dwp_file
->version
= dwp_file
->tus
->version
;
12453 dwp_file
->version
= 2;
12455 if (dwp_file
->version
== 2)
12456 bfd_map_over_sections (dwp_file
->dbfd
.get (),
12457 dwarf2_locate_v2_dwp_sections
,
12460 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table ();
12461 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table ();
12463 if (dwarf_read_debug
)
12465 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
12466 fprintf_unfiltered (gdb_stdlog
,
12467 " %s CUs, %s TUs\n",
12468 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
12469 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
12475 /* Wrapper around open_and_init_dwp_file, only open it once. */
12477 static struct dwp_file
*
12478 get_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
12480 if (! dwarf2_per_objfile
->dwp_checked
)
12482 dwarf2_per_objfile
->dwp_file
12483 = open_and_init_dwp_file (dwarf2_per_objfile
);
12484 dwarf2_per_objfile
->dwp_checked
= 1;
12486 return dwarf2_per_objfile
->dwp_file
.get ();
12489 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
12490 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
12491 or in the DWP file for the objfile, referenced by THIS_UNIT.
12492 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
12493 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
12495 This is called, for example, when wanting to read a variable with a
12496 complex location. Therefore we don't want to do file i/o for every call.
12497 Therefore we don't want to look for a DWO file on every call.
12498 Therefore we first see if we've already seen SIGNATURE in a DWP file,
12499 then we check if we've already seen DWO_NAME, and only THEN do we check
12502 The result is a pointer to the dwo_unit object or NULL if we didn't find it
12503 (dwo_id mismatch or couldn't find the DWO/DWP file). */
12505 static struct dwo_unit
*
12506 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
12507 const char *dwo_name
, const char *comp_dir
,
12508 ULONGEST signature
, int is_debug_types
)
12510 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_unit
->dwarf2_per_objfile
;
12511 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12512 const char *kind
= is_debug_types
? "TU" : "CU";
12513 void **dwo_file_slot
;
12514 struct dwo_file
*dwo_file
;
12515 struct dwp_file
*dwp_file
;
12517 /* First see if there's a DWP file.
12518 If we have a DWP file but didn't find the DWO inside it, don't
12519 look for the original DWO file. It makes gdb behave differently
12520 depending on whether one is debugging in the build tree. */
12522 dwp_file
= get_dwp_file (dwarf2_per_objfile
);
12523 if (dwp_file
!= NULL
)
12525 const struct dwp_hash_table
*dwp_htab
=
12526 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12528 if (dwp_htab
!= NULL
)
12530 struct dwo_unit
*dwo_cutu
=
12531 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, comp_dir
,
12532 signature
, is_debug_types
);
12534 if (dwo_cutu
!= NULL
)
12536 if (dwarf_read_debug
)
12538 fprintf_unfiltered (gdb_stdlog
,
12539 "Virtual DWO %s %s found: @%s\n",
12540 kind
, hex_string (signature
),
12541 host_address_to_string (dwo_cutu
));
12549 /* No DWP file, look for the DWO file. */
12551 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
12552 dwo_name
, comp_dir
);
12553 if (*dwo_file_slot
== NULL
)
12555 /* Read in the file and build a table of the CUs/TUs it contains. */
12556 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
12558 /* NOTE: This will be NULL if unable to open the file. */
12559 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12561 if (dwo_file
!= NULL
)
12563 struct dwo_unit
*dwo_cutu
= NULL
;
12565 if (is_debug_types
&& dwo_file
->tus
)
12567 struct dwo_unit find_dwo_cutu
;
12569 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
12570 find_dwo_cutu
.signature
= signature
;
12572 = (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
12575 else if (!is_debug_types
&& dwo_file
->cus
)
12577 struct dwo_unit find_dwo_cutu
;
12579 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
12580 find_dwo_cutu
.signature
= signature
;
12581 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
.get (),
12585 if (dwo_cutu
!= NULL
)
12587 if (dwarf_read_debug
)
12589 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
12590 kind
, dwo_name
, hex_string (signature
),
12591 host_address_to_string (dwo_cutu
));
12598 /* We didn't find it. This could mean a dwo_id mismatch, or
12599 someone deleted the DWO/DWP file, or the search path isn't set up
12600 correctly to find the file. */
12602 if (dwarf_read_debug
)
12604 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
12605 kind
, dwo_name
, hex_string (signature
));
12608 /* This is a warning and not a complaint because it can be caused by
12609 pilot error (e.g., user accidentally deleting the DWO). */
12611 /* Print the name of the DWP file if we looked there, helps the user
12612 better diagnose the problem. */
12613 std::string dwp_text
;
12615 if (dwp_file
!= NULL
)
12616 dwp_text
= string_printf (" [in DWP file %s]",
12617 lbasename (dwp_file
->name
));
12619 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
12620 " [in module %s]"),
12621 kind
, dwo_name
, hex_string (signature
),
12623 this_unit
->is_debug_types
? "TU" : "CU",
12624 sect_offset_str (this_unit
->sect_off
), objfile_name (objfile
));
12629 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
12630 See lookup_dwo_cutu_unit for details. */
12632 static struct dwo_unit
*
12633 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
12634 const char *dwo_name
, const char *comp_dir
,
12635 ULONGEST signature
)
12637 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
12640 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
12641 See lookup_dwo_cutu_unit for details. */
12643 static struct dwo_unit
*
12644 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
12645 const char *dwo_name
, const char *comp_dir
)
12647 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
12650 /* Traversal function for queue_and_load_all_dwo_tus. */
12653 queue_and_load_dwo_tu (void **slot
, void *info
)
12655 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
12656 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
12657 ULONGEST signature
= dwo_unit
->signature
;
12658 struct signatured_type
*sig_type
=
12659 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
12661 if (sig_type
!= NULL
)
12663 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
12665 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
12666 a real dependency of PER_CU on SIG_TYPE. That is detected later
12667 while processing PER_CU. */
12668 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
12669 load_full_type_unit (sig_cu
);
12670 per_cu
->imported_symtabs_push (sig_cu
);
12676 /* Queue all TUs contained in the DWO of PER_CU to be read in.
12677 The DWO may have the only definition of the type, though it may not be
12678 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
12679 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
12682 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
12684 struct dwo_unit
*dwo_unit
;
12685 struct dwo_file
*dwo_file
;
12687 gdb_assert (!per_cu
->is_debug_types
);
12688 gdb_assert (get_dwp_file (per_cu
->dwarf2_per_objfile
) == NULL
);
12689 gdb_assert (per_cu
->cu
!= NULL
);
12691 dwo_unit
= per_cu
->cu
->dwo_unit
;
12692 gdb_assert (dwo_unit
!= NULL
);
12694 dwo_file
= dwo_unit
->dwo_file
;
12695 if (dwo_file
->tus
!= NULL
)
12696 htab_traverse_noresize (dwo_file
->tus
.get (), queue_and_load_dwo_tu
,
12700 /* Read in various DIEs. */
12702 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
12703 Inherit only the children of the DW_AT_abstract_origin DIE not being
12704 already referenced by DW_AT_abstract_origin from the children of the
12708 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
12710 struct die_info
*child_die
;
12711 sect_offset
*offsetp
;
12712 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
12713 struct die_info
*origin_die
;
12714 /* Iterator of the ORIGIN_DIE children. */
12715 struct die_info
*origin_child_die
;
12716 struct attribute
*attr
;
12717 struct dwarf2_cu
*origin_cu
;
12718 struct pending
**origin_previous_list_in_scope
;
12720 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
12724 /* Note that following die references may follow to a die in a
12728 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
12730 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
12732 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
12733 origin_cu
->list_in_scope
= cu
->list_in_scope
;
12735 if (die
->tag
!= origin_die
->tag
12736 && !(die
->tag
== DW_TAG_inlined_subroutine
12737 && origin_die
->tag
== DW_TAG_subprogram
))
12738 complaint (_("DIE %s and its abstract origin %s have different tags"),
12739 sect_offset_str (die
->sect_off
),
12740 sect_offset_str (origin_die
->sect_off
));
12742 std::vector
<sect_offset
> offsets
;
12744 for (child_die
= die
->child
;
12745 child_die
&& child_die
->tag
;
12746 child_die
= sibling_die (child_die
))
12748 struct die_info
*child_origin_die
;
12749 struct dwarf2_cu
*child_origin_cu
;
12751 /* We are trying to process concrete instance entries:
12752 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
12753 it's not relevant to our analysis here. i.e. detecting DIEs that are
12754 present in the abstract instance but not referenced in the concrete
12756 if (child_die
->tag
== DW_TAG_call_site
12757 || child_die
->tag
== DW_TAG_GNU_call_site
)
12760 /* For each CHILD_DIE, find the corresponding child of
12761 ORIGIN_DIE. If there is more than one layer of
12762 DW_AT_abstract_origin, follow them all; there shouldn't be,
12763 but GCC versions at least through 4.4 generate this (GCC PR
12765 child_origin_die
= child_die
;
12766 child_origin_cu
= cu
;
12769 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
12773 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
12777 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
12778 counterpart may exist. */
12779 if (child_origin_die
!= child_die
)
12781 if (child_die
->tag
!= child_origin_die
->tag
12782 && !(child_die
->tag
== DW_TAG_inlined_subroutine
12783 && child_origin_die
->tag
== DW_TAG_subprogram
))
12784 complaint (_("Child DIE %s and its abstract origin %s have "
12786 sect_offset_str (child_die
->sect_off
),
12787 sect_offset_str (child_origin_die
->sect_off
));
12788 if (child_origin_die
->parent
!= origin_die
)
12789 complaint (_("Child DIE %s and its abstract origin %s have "
12790 "different parents"),
12791 sect_offset_str (child_die
->sect_off
),
12792 sect_offset_str (child_origin_die
->sect_off
));
12794 offsets
.push_back (child_origin_die
->sect_off
);
12797 std::sort (offsets
.begin (), offsets
.end ());
12798 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
12799 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
12800 if (offsetp
[-1] == *offsetp
)
12801 complaint (_("Multiple children of DIE %s refer "
12802 "to DIE %s as their abstract origin"),
12803 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
12805 offsetp
= offsets
.data ();
12806 origin_child_die
= origin_die
->child
;
12807 while (origin_child_die
&& origin_child_die
->tag
)
12809 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
12810 while (offsetp
< offsets_end
12811 && *offsetp
< origin_child_die
->sect_off
)
12813 if (offsetp
>= offsets_end
12814 || *offsetp
> origin_child_die
->sect_off
)
12816 /* Found that ORIGIN_CHILD_DIE is really not referenced.
12817 Check whether we're already processing ORIGIN_CHILD_DIE.
12818 This can happen with mutually referenced abstract_origins.
12820 if (!origin_child_die
->in_process
)
12821 process_die (origin_child_die
, origin_cu
);
12823 origin_child_die
= sibling_die (origin_child_die
);
12825 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
12827 if (cu
!= origin_cu
)
12828 compute_delayed_physnames (origin_cu
);
12832 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
12834 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
12835 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
12836 struct context_stack
*newobj
;
12839 struct die_info
*child_die
;
12840 struct attribute
*attr
, *call_line
, *call_file
;
12842 CORE_ADDR baseaddr
;
12843 struct block
*block
;
12844 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
12845 std::vector
<struct symbol
*> template_args
;
12846 struct template_symbol
*templ_func
= NULL
;
12850 /* If we do not have call site information, we can't show the
12851 caller of this inlined function. That's too confusing, so
12852 only use the scope for local variables. */
12853 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
12854 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
12855 if (call_line
== NULL
|| call_file
== NULL
)
12857 read_lexical_block_scope (die
, cu
);
12862 baseaddr
= objfile
->text_section_offset ();
12864 name
= dwarf2_name (die
, cu
);
12866 /* Ignore functions with missing or empty names. These are actually
12867 illegal according to the DWARF standard. */
12870 complaint (_("missing name for subprogram DIE at %s"),
12871 sect_offset_str (die
->sect_off
));
12875 /* Ignore functions with missing or invalid low and high pc attributes. */
12876 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
12877 <= PC_BOUNDS_INVALID
)
12879 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
12880 if (!attr
|| !DW_UNSND (attr
))
12881 complaint (_("cannot get low and high bounds "
12882 "for subprogram DIE at %s"),
12883 sect_offset_str (die
->sect_off
));
12887 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
12888 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
12890 /* If we have any template arguments, then we must allocate a
12891 different sort of symbol. */
12892 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
12894 if (child_die
->tag
== DW_TAG_template_type_param
12895 || child_die
->tag
== DW_TAG_template_value_param
)
12897 templ_func
= allocate_template_symbol (objfile
);
12898 templ_func
->subclass
= SYMBOL_TEMPLATE
;
12903 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
12904 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
12905 (struct symbol
*) templ_func
);
12907 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
12908 set_objfile_main_name (objfile
, newobj
->name
->linkage_name (),
12911 /* If there is a location expression for DW_AT_frame_base, record
12913 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
12914 if (attr
!= nullptr)
12915 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
12917 /* If there is a location for the static link, record it. */
12918 newobj
->static_link
= NULL
;
12919 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
12920 if (attr
!= nullptr)
12922 newobj
->static_link
12923 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
12924 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
12925 cu
->per_cu
->addr_type ());
12928 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
12930 if (die
->child
!= NULL
)
12932 child_die
= die
->child
;
12933 while (child_die
&& child_die
->tag
)
12935 if (child_die
->tag
== DW_TAG_template_type_param
12936 || child_die
->tag
== DW_TAG_template_value_param
)
12938 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
12941 template_args
.push_back (arg
);
12944 process_die (child_die
, cu
);
12945 child_die
= sibling_die (child_die
);
12949 inherit_abstract_dies (die
, cu
);
12951 /* If we have a DW_AT_specification, we might need to import using
12952 directives from the context of the specification DIE. See the
12953 comment in determine_prefix. */
12954 if (cu
->language
== language_cplus
12955 && dwarf2_attr (die
, DW_AT_specification
, cu
))
12957 struct dwarf2_cu
*spec_cu
= cu
;
12958 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
12962 child_die
= spec_die
->child
;
12963 while (child_die
&& child_die
->tag
)
12965 if (child_die
->tag
== DW_TAG_imported_module
)
12966 process_die (child_die
, spec_cu
);
12967 child_die
= sibling_die (child_die
);
12970 /* In some cases, GCC generates specification DIEs that
12971 themselves contain DW_AT_specification attributes. */
12972 spec_die
= die_specification (spec_die
, &spec_cu
);
12976 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
12977 /* Make a block for the local symbols within. */
12978 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
12979 cstk
.static_link
, lowpc
, highpc
);
12981 /* For C++, set the block's scope. */
12982 if ((cu
->language
== language_cplus
12983 || cu
->language
== language_fortran
12984 || cu
->language
== language_d
12985 || cu
->language
== language_rust
)
12986 && cu
->processing_has_namespace_info
)
12987 block_set_scope (block
, determine_prefix (die
, cu
),
12988 &objfile
->objfile_obstack
);
12990 /* If we have address ranges, record them. */
12991 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
12993 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
12995 /* Attach template arguments to function. */
12996 if (!template_args
.empty ())
12998 gdb_assert (templ_func
!= NULL
);
13000 templ_func
->n_template_arguments
= template_args
.size ();
13001 templ_func
->template_arguments
13002 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13003 templ_func
->n_template_arguments
);
13004 memcpy (templ_func
->template_arguments
,
13005 template_args
.data (),
13006 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13008 /* Make sure that the symtab is set on the new symbols. Even
13009 though they don't appear in this symtab directly, other parts
13010 of gdb assume that symbols do, and this is reasonably
13012 for (symbol
*sym
: template_args
)
13013 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13016 /* In C++, we can have functions nested inside functions (e.g., when
13017 a function declares a class that has methods). This means that
13018 when we finish processing a function scope, we may need to go
13019 back to building a containing block's symbol lists. */
13020 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13021 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13023 /* If we've finished processing a top-level function, subsequent
13024 symbols go in the file symbol list. */
13025 if (cu
->get_builder ()->outermost_context_p ())
13026 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13029 /* Process all the DIES contained within a lexical block scope. Start
13030 a new scope, process the dies, and then close the scope. */
13033 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13035 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13036 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13037 CORE_ADDR lowpc
, highpc
;
13038 struct die_info
*child_die
;
13039 CORE_ADDR baseaddr
;
13041 baseaddr
= objfile
->text_section_offset ();
13043 /* Ignore blocks with missing or invalid low and high pc attributes. */
13044 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13045 as multiple lexical blocks? Handling children in a sane way would
13046 be nasty. Might be easier to properly extend generic blocks to
13047 describe ranges. */
13048 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13050 case PC_BOUNDS_NOT_PRESENT
:
13051 /* DW_TAG_lexical_block has no attributes, process its children as if
13052 there was no wrapping by that DW_TAG_lexical_block.
13053 GCC does no longer produces such DWARF since GCC r224161. */
13054 for (child_die
= die
->child
;
13055 child_die
!= NULL
&& child_die
->tag
;
13056 child_die
= sibling_die (child_die
))
13057 process_die (child_die
, cu
);
13059 case PC_BOUNDS_INVALID
:
13062 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13063 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13065 cu
->get_builder ()->push_context (0, lowpc
);
13066 if (die
->child
!= NULL
)
13068 child_die
= die
->child
;
13069 while (child_die
&& child_die
->tag
)
13071 process_die (child_die
, cu
);
13072 child_die
= sibling_die (child_die
);
13075 inherit_abstract_dies (die
, cu
);
13076 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13078 if (*cu
->get_builder ()->get_local_symbols () != NULL
13079 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13081 struct block
*block
13082 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13083 cstk
.start_addr
, highpc
);
13085 /* Note that recording ranges after traversing children, as we
13086 do here, means that recording a parent's ranges entails
13087 walking across all its children's ranges as they appear in
13088 the address map, which is quadratic behavior.
13090 It would be nicer to record the parent's ranges before
13091 traversing its children, simply overriding whatever you find
13092 there. But since we don't even decide whether to create a
13093 block until after we've traversed its children, that's hard
13095 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13097 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13098 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13101 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13104 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13106 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13107 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13108 CORE_ADDR pc
, baseaddr
;
13109 struct attribute
*attr
;
13110 struct call_site
*call_site
, call_site_local
;
13113 struct die_info
*child_die
;
13115 baseaddr
= objfile
->text_section_offset ();
13117 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13120 /* This was a pre-DWARF-5 GNU extension alias
13121 for DW_AT_call_return_pc. */
13122 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13126 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13127 "DIE %s [in module %s]"),
13128 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13131 pc
= attr
->value_as_address () + baseaddr
;
13132 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13134 if (cu
->call_site_htab
== NULL
)
13135 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13136 NULL
, &objfile
->objfile_obstack
,
13137 hashtab_obstack_allocate
, NULL
);
13138 call_site_local
.pc
= pc
;
13139 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13142 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13143 "DIE %s [in module %s]"),
13144 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13145 objfile_name (objfile
));
13149 /* Count parameters at the caller. */
13152 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13153 child_die
= sibling_die (child_die
))
13155 if (child_die
->tag
!= DW_TAG_call_site_parameter
13156 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13158 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13159 "DW_TAG_call_site child DIE %s [in module %s]"),
13160 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
13161 objfile_name (objfile
));
13169 = ((struct call_site
*)
13170 obstack_alloc (&objfile
->objfile_obstack
,
13171 sizeof (*call_site
)
13172 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
13174 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
13175 call_site
->pc
= pc
;
13177 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
13178 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
13180 struct die_info
*func_die
;
13182 /* Skip also over DW_TAG_inlined_subroutine. */
13183 for (func_die
= die
->parent
;
13184 func_die
&& func_die
->tag
!= DW_TAG_subprogram
13185 && func_die
->tag
!= DW_TAG_subroutine_type
;
13186 func_die
= func_die
->parent
);
13188 /* DW_AT_call_all_calls is a superset
13189 of DW_AT_call_all_tail_calls. */
13191 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
13192 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
13193 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
13194 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
13196 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13197 not complete. But keep CALL_SITE for look ups via call_site_htab,
13198 both the initial caller containing the real return address PC and
13199 the final callee containing the current PC of a chain of tail
13200 calls do not need to have the tail call list complete. But any
13201 function candidate for a virtual tail call frame searched via
13202 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13203 determined unambiguously. */
13207 struct type
*func_type
= NULL
;
13210 func_type
= get_die_type (func_die
, cu
);
13211 if (func_type
!= NULL
)
13213 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
13215 /* Enlist this call site to the function. */
13216 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
13217 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
13220 complaint (_("Cannot find function owning DW_TAG_call_site "
13221 "DIE %s [in module %s]"),
13222 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13226 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
13228 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
13230 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
13233 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
13234 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13236 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
13237 if (!attr
|| (attr
->form_is_block () && DW_BLOCK (attr
)->size
== 0))
13238 /* Keep NULL DWARF_BLOCK. */;
13239 else if (attr
->form_is_block ())
13241 struct dwarf2_locexpr_baton
*dlbaton
;
13243 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
13244 dlbaton
->data
= DW_BLOCK (attr
)->data
;
13245 dlbaton
->size
= DW_BLOCK (attr
)->size
;
13246 dlbaton
->per_cu
= cu
->per_cu
;
13248 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
13250 else if (attr
->form_is_ref ())
13252 struct dwarf2_cu
*target_cu
= cu
;
13253 struct die_info
*target_die
;
13255 target_die
= follow_die_ref (die
, attr
, &target_cu
);
13256 gdb_assert (target_cu
->per_cu
->dwarf2_per_objfile
->objfile
== objfile
);
13257 if (die_is_declaration (target_die
, target_cu
))
13259 const char *target_physname
;
13261 /* Prefer the mangled name; otherwise compute the demangled one. */
13262 target_physname
= dw2_linkage_name (target_die
, target_cu
);
13263 if (target_physname
== NULL
)
13264 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
13265 if (target_physname
== NULL
)
13266 complaint (_("DW_AT_call_target target DIE has invalid "
13267 "physname, for referencing DIE %s [in module %s]"),
13268 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13270 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
13276 /* DW_AT_entry_pc should be preferred. */
13277 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
13278 <= PC_BOUNDS_INVALID
)
13279 complaint (_("DW_AT_call_target target DIE has invalid "
13280 "low pc, for referencing DIE %s [in module %s]"),
13281 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13284 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13285 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
13290 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
13291 "block nor reference, for DIE %s [in module %s]"),
13292 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13294 call_site
->per_cu
= cu
->per_cu
;
13296 for (child_die
= die
->child
;
13297 child_die
&& child_die
->tag
;
13298 child_die
= sibling_die (child_die
))
13300 struct call_site_parameter
*parameter
;
13301 struct attribute
*loc
, *origin
;
13303 if (child_die
->tag
!= DW_TAG_call_site_parameter
13304 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13306 /* Already printed the complaint above. */
13310 gdb_assert (call_site
->parameter_count
< nparams
);
13311 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
13313 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
13314 specifies DW_TAG_formal_parameter. Value of the data assumed for the
13315 register is contained in DW_AT_call_value. */
13317 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
13318 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
13319 if (origin
== NULL
)
13321 /* This was a pre-DWARF-5 GNU extension alias
13322 for DW_AT_call_parameter. */
13323 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
13325 if (loc
== NULL
&& origin
!= NULL
&& origin
->form_is_ref ())
13327 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
13329 sect_offset sect_off
13330 = (sect_offset
) dwarf2_get_ref_die_offset (origin
);
13331 if (!cu
->header
.offset_in_cu_p (sect_off
))
13333 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
13334 binding can be done only inside one CU. Such referenced DIE
13335 therefore cannot be even moved to DW_TAG_partial_unit. */
13336 complaint (_("DW_AT_call_parameter offset is not in CU for "
13337 "DW_TAG_call_site child DIE %s [in module %s]"),
13338 sect_offset_str (child_die
->sect_off
),
13339 objfile_name (objfile
));
13342 parameter
->u
.param_cu_off
13343 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
13345 else if (loc
== NULL
|| origin
!= NULL
|| !loc
->form_is_block ())
13347 complaint (_("No DW_FORM_block* DW_AT_location for "
13348 "DW_TAG_call_site child DIE %s [in module %s]"),
13349 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
13354 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
13355 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
13356 if (parameter
->u
.dwarf_reg
!= -1)
13357 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
13358 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
13359 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
13360 ¶meter
->u
.fb_offset
))
13361 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
13364 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
13365 "for DW_FORM_block* DW_AT_location is supported for "
13366 "DW_TAG_call_site child DIE %s "
13368 sect_offset_str (child_die
->sect_off
),
13369 objfile_name (objfile
));
13374 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
13376 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
13377 if (attr
== NULL
|| !attr
->form_is_block ())
13379 complaint (_("No DW_FORM_block* DW_AT_call_value for "
13380 "DW_TAG_call_site child DIE %s [in module %s]"),
13381 sect_offset_str (child_die
->sect_off
),
13382 objfile_name (objfile
));
13385 parameter
->value
= DW_BLOCK (attr
)->data
;
13386 parameter
->value_size
= DW_BLOCK (attr
)->size
;
13388 /* Parameters are not pre-cleared by memset above. */
13389 parameter
->data_value
= NULL
;
13390 parameter
->data_value_size
= 0;
13391 call_site
->parameter_count
++;
13393 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
13395 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
13396 if (attr
!= nullptr)
13398 if (!attr
->form_is_block ())
13399 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
13400 "DW_TAG_call_site child DIE %s [in module %s]"),
13401 sect_offset_str (child_die
->sect_off
),
13402 objfile_name (objfile
));
13405 parameter
->data_value
= DW_BLOCK (attr
)->data
;
13406 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
13412 /* Helper function for read_variable. If DIE represents a virtual
13413 table, then return the type of the concrete object that is
13414 associated with the virtual table. Otherwise, return NULL. */
13416 static struct type
*
13417 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
13419 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
13423 /* Find the type DIE. */
13424 struct die_info
*type_die
= NULL
;
13425 struct dwarf2_cu
*type_cu
= cu
;
13427 if (attr
->form_is_ref ())
13428 type_die
= follow_die_ref (die
, attr
, &type_cu
);
13429 if (type_die
== NULL
)
13432 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
13434 return die_containing_type (type_die
, type_cu
);
13437 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
13440 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
13442 struct rust_vtable_symbol
*storage
= NULL
;
13444 if (cu
->language
== language_rust
)
13446 struct type
*containing_type
= rust_containing_type (die
, cu
);
13448 if (containing_type
!= NULL
)
13450 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13452 storage
= new (&objfile
->objfile_obstack
) rust_vtable_symbol ();
13453 initialize_objfile_symbol (storage
);
13454 storage
->concrete_type
= containing_type
;
13455 storage
->subclass
= SYMBOL_RUST_VTABLE
;
13459 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
13460 struct attribute
*abstract_origin
13461 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13462 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
13463 if (res
== NULL
&& loc
&& abstract_origin
)
13465 /* We have a variable without a name, but with a location and an abstract
13466 origin. This may be a concrete instance of an abstract variable
13467 referenced from an DW_OP_GNU_variable_value, so save it to find it back
13469 struct dwarf2_cu
*origin_cu
= cu
;
13470 struct die_info
*origin_die
13471 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
13472 dwarf2_per_objfile
*dpo
= cu
->per_cu
->dwarf2_per_objfile
;
13473 dpo
->abstract_to_concrete
[origin_die
->sect_off
].push_back (die
->sect_off
);
13477 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
13478 reading .debug_rnglists.
13479 Callback's type should be:
13480 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
13481 Return true if the attributes are present and valid, otherwise,
13484 template <typename Callback
>
13486 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
13487 Callback
&&callback
)
13489 struct dwarf2_per_objfile
*dwarf2_per_objfile
13490 = cu
->per_cu
->dwarf2_per_objfile
;
13491 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13492 bfd
*obfd
= objfile
->obfd
;
13493 /* Base address selection entry. */
13496 const gdb_byte
*buffer
;
13497 CORE_ADDR baseaddr
;
13498 bool overflow
= false;
13500 found_base
= cu
->base_known
;
13501 base
= cu
->base_address
;
13503 dwarf2_per_objfile
->rnglists
.read (objfile
);
13504 if (offset
>= dwarf2_per_objfile
->rnglists
.size
)
13506 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
13510 buffer
= dwarf2_per_objfile
->rnglists
.buffer
+ offset
;
13512 baseaddr
= objfile
->text_section_offset ();
13516 /* Initialize it due to a false compiler warning. */
13517 CORE_ADDR range_beginning
= 0, range_end
= 0;
13518 const gdb_byte
*buf_end
= (dwarf2_per_objfile
->rnglists
.buffer
13519 + dwarf2_per_objfile
->rnglists
.size
);
13520 unsigned int bytes_read
;
13522 if (buffer
== buf_end
)
13527 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
13530 case DW_RLE_end_of_list
:
13532 case DW_RLE_base_address
:
13533 if (buffer
+ cu
->header
.addr_size
> buf_end
)
13538 base
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
13540 buffer
+= bytes_read
;
13542 case DW_RLE_start_length
:
13543 if (buffer
+ cu
->header
.addr_size
> buf_end
)
13548 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
13550 buffer
+= bytes_read
;
13551 range_end
= (range_beginning
13552 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
13553 buffer
+= bytes_read
;
13554 if (buffer
> buf_end
)
13560 case DW_RLE_offset_pair
:
13561 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13562 buffer
+= bytes_read
;
13563 if (buffer
> buf_end
)
13568 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
13569 buffer
+= bytes_read
;
13570 if (buffer
> buf_end
)
13576 case DW_RLE_start_end
:
13577 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
13582 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
13584 buffer
+= bytes_read
;
13585 range_end
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
13586 buffer
+= bytes_read
;
13589 complaint (_("Invalid .debug_rnglists data (no base address)"));
13592 if (rlet
== DW_RLE_end_of_list
|| overflow
)
13594 if (rlet
== DW_RLE_base_address
)
13599 /* We have no valid base address for the ranges
13601 complaint (_("Invalid .debug_rnglists data (no base address)"));
13605 if (range_beginning
> range_end
)
13607 /* Inverted range entries are invalid. */
13608 complaint (_("Invalid .debug_rnglists data (inverted range)"));
13612 /* Empty range entries have no effect. */
13613 if (range_beginning
== range_end
)
13616 range_beginning
+= base
;
13619 /* A not-uncommon case of bad debug info.
13620 Don't pollute the addrmap with bad data. */
13621 if (range_beginning
+ baseaddr
== 0
13622 && !dwarf2_per_objfile
->has_section_at_zero
)
13624 complaint (_(".debug_rnglists entry has start address of zero"
13625 " [in module %s]"), objfile_name (objfile
));
13629 callback (range_beginning
, range_end
);
13634 complaint (_("Offset %d is not terminated "
13635 "for DW_AT_ranges attribute"),
13643 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
13644 Callback's type should be:
13645 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
13646 Return 1 if the attributes are present and valid, otherwise, return 0. */
13648 template <typename Callback
>
13650 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
,
13651 Callback
&&callback
)
13653 struct dwarf2_per_objfile
*dwarf2_per_objfile
13654 = cu
->per_cu
->dwarf2_per_objfile
;
13655 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13656 struct comp_unit_head
*cu_header
= &cu
->header
;
13657 bfd
*obfd
= objfile
->obfd
;
13658 unsigned int addr_size
= cu_header
->addr_size
;
13659 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
13660 /* Base address selection entry. */
13663 unsigned int dummy
;
13664 const gdb_byte
*buffer
;
13665 CORE_ADDR baseaddr
;
13667 if (cu_header
->version
>= 5)
13668 return dwarf2_rnglists_process (offset
, cu
, callback
);
13670 found_base
= cu
->base_known
;
13671 base
= cu
->base_address
;
13673 dwarf2_per_objfile
->ranges
.read (objfile
);
13674 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
13676 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
13680 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
13682 baseaddr
= objfile
->text_section_offset ();
13686 CORE_ADDR range_beginning
, range_end
;
13688 range_beginning
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
13689 buffer
+= addr_size
;
13690 range_end
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
13691 buffer
+= addr_size
;
13692 offset
+= 2 * addr_size
;
13694 /* An end of list marker is a pair of zero addresses. */
13695 if (range_beginning
== 0 && range_end
== 0)
13696 /* Found the end of list entry. */
13699 /* Each base address selection entry is a pair of 2 values.
13700 The first is the largest possible address, the second is
13701 the base address. Check for a base address here. */
13702 if ((range_beginning
& mask
) == mask
)
13704 /* If we found the largest possible address, then we already
13705 have the base address in range_end. */
13713 /* We have no valid base address for the ranges
13715 complaint (_("Invalid .debug_ranges data (no base address)"));
13719 if (range_beginning
> range_end
)
13721 /* Inverted range entries are invalid. */
13722 complaint (_("Invalid .debug_ranges data (inverted range)"));
13726 /* Empty range entries have no effect. */
13727 if (range_beginning
== range_end
)
13730 range_beginning
+= base
;
13733 /* A not-uncommon case of bad debug info.
13734 Don't pollute the addrmap with bad data. */
13735 if (range_beginning
+ baseaddr
== 0
13736 && !dwarf2_per_objfile
->has_section_at_zero
)
13738 complaint (_(".debug_ranges entry has start address of zero"
13739 " [in module %s]"), objfile_name (objfile
));
13743 callback (range_beginning
, range_end
);
13749 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
13750 Return 1 if the attributes are present and valid, otherwise, return 0.
13751 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
13754 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
13755 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
13756 dwarf2_psymtab
*ranges_pst
)
13758 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13759 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13760 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
13763 CORE_ADDR high
= 0;
13766 retval
= dwarf2_ranges_process (offset
, cu
,
13767 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
13769 if (ranges_pst
!= NULL
)
13774 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
13775 range_beginning
+ baseaddr
)
13777 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
13778 range_end
+ baseaddr
)
13780 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
13781 lowpc
, highpc
- 1, ranges_pst
);
13784 /* FIXME: This is recording everything as a low-high
13785 segment of consecutive addresses. We should have a
13786 data structure for discontiguous block ranges
13790 low
= range_beginning
;
13796 if (range_beginning
< low
)
13797 low
= range_beginning
;
13798 if (range_end
> high
)
13806 /* If the first entry is an end-of-list marker, the range
13807 describes an empty scope, i.e. no instructions. */
13813 *high_return
= high
;
13817 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
13818 definition for the return value. *LOWPC and *HIGHPC are set iff
13819 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
13821 static enum pc_bounds_kind
13822 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
13823 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
13824 dwarf2_psymtab
*pst
)
13826 struct dwarf2_per_objfile
*dwarf2_per_objfile
13827 = cu
->per_cu
->dwarf2_per_objfile
;
13828 struct attribute
*attr
;
13829 struct attribute
*attr_high
;
13831 CORE_ADDR high
= 0;
13832 enum pc_bounds_kind ret
;
13834 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
13837 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13838 if (attr
!= nullptr)
13840 low
= attr
->value_as_address ();
13841 high
= attr_high
->value_as_address ();
13842 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
13846 /* Found high w/o low attribute. */
13847 return PC_BOUNDS_INVALID
;
13849 /* Found consecutive range of addresses. */
13850 ret
= PC_BOUNDS_HIGH_LOW
;
13854 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
13857 /* DW_AT_rnglists_base does not apply to DIEs from the DWO skeleton.
13858 We take advantage of the fact that DW_AT_ranges does not appear
13859 in DW_TAG_compile_unit of DWO files. */
13860 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
13861 unsigned int ranges_offset
= (DW_UNSND (attr
)
13862 + (need_ranges_base
13866 /* Value of the DW_AT_ranges attribute is the offset in the
13867 .debug_ranges section. */
13868 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
13869 return PC_BOUNDS_INVALID
;
13870 /* Found discontinuous range of addresses. */
13871 ret
= PC_BOUNDS_RANGES
;
13874 return PC_BOUNDS_NOT_PRESENT
;
13877 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
13879 return PC_BOUNDS_INVALID
;
13881 /* When using the GNU linker, .gnu.linkonce. sections are used to
13882 eliminate duplicate copies of functions and vtables and such.
13883 The linker will arbitrarily choose one and discard the others.
13884 The AT_*_pc values for such functions refer to local labels in
13885 these sections. If the section from that file was discarded, the
13886 labels are not in the output, so the relocs get a value of 0.
13887 If this is a discarded function, mark the pc bounds as invalid,
13888 so that GDB will ignore it. */
13889 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
13890 return PC_BOUNDS_INVALID
;
13898 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
13899 its low and high PC addresses. Do nothing if these addresses could not
13900 be determined. Otherwise, set LOWPC to the low address if it is smaller,
13901 and HIGHPC to the high address if greater than HIGHPC. */
13904 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
13905 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
13906 struct dwarf2_cu
*cu
)
13908 CORE_ADDR low
, high
;
13909 struct die_info
*child
= die
->child
;
13911 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
13913 *lowpc
= std::min (*lowpc
, low
);
13914 *highpc
= std::max (*highpc
, high
);
13917 /* If the language does not allow nested subprograms (either inside
13918 subprograms or lexical blocks), we're done. */
13919 if (cu
->language
!= language_ada
)
13922 /* Check all the children of the given DIE. If it contains nested
13923 subprograms, then check their pc bounds. Likewise, we need to
13924 check lexical blocks as well, as they may also contain subprogram
13926 while (child
&& child
->tag
)
13928 if (child
->tag
== DW_TAG_subprogram
13929 || child
->tag
== DW_TAG_lexical_block
)
13930 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
13931 child
= sibling_die (child
);
13935 /* Get the low and high pc's represented by the scope DIE, and store
13936 them in *LOWPC and *HIGHPC. If the correct values can't be
13937 determined, set *LOWPC to -1 and *HIGHPC to 0. */
13940 get_scope_pc_bounds (struct die_info
*die
,
13941 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
13942 struct dwarf2_cu
*cu
)
13944 CORE_ADDR best_low
= (CORE_ADDR
) -1;
13945 CORE_ADDR best_high
= (CORE_ADDR
) 0;
13946 CORE_ADDR current_low
, current_high
;
13948 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
13949 >= PC_BOUNDS_RANGES
)
13951 best_low
= current_low
;
13952 best_high
= current_high
;
13956 struct die_info
*child
= die
->child
;
13958 while (child
&& child
->tag
)
13960 switch (child
->tag
) {
13961 case DW_TAG_subprogram
:
13962 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
13964 case DW_TAG_namespace
:
13965 case DW_TAG_module
:
13966 /* FIXME: carlton/2004-01-16: Should we do this for
13967 DW_TAG_class_type/DW_TAG_structure_type, too? I think
13968 that current GCC's always emit the DIEs corresponding
13969 to definitions of methods of classes as children of a
13970 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
13971 the DIEs giving the declarations, which could be
13972 anywhere). But I don't see any reason why the
13973 standards says that they have to be there. */
13974 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
13976 if (current_low
!= ((CORE_ADDR
) -1))
13978 best_low
= std::min (best_low
, current_low
);
13979 best_high
= std::max (best_high
, current_high
);
13987 child
= sibling_die (child
);
13992 *highpc
= best_high
;
13995 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
13999 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14000 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14002 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14003 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14004 struct attribute
*attr
;
14005 struct attribute
*attr_high
;
14007 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14010 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14011 if (attr
!= nullptr)
14013 CORE_ADDR low
= attr
->value_as_address ();
14014 CORE_ADDR high
= attr_high
->value_as_address ();
14016 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14019 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14020 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14021 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14025 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14026 if (attr
!= nullptr)
14028 /* DW_AT_rnglists_base does not apply to DIEs from the DWO skeleton.
14029 We take advantage of the fact that DW_AT_ranges does not appear
14030 in DW_TAG_compile_unit of DWO files. */
14031 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
14033 /* The value of the DW_AT_ranges attribute is the offset of the
14034 address range list in the .debug_ranges section. */
14035 unsigned long offset
= (DW_UNSND (attr
)
14036 + (need_ranges_base
? cu
->ranges_base
: 0));
14038 std::vector
<blockrange
> blockvec
;
14039 dwarf2_ranges_process (offset
, cu
,
14040 [&] (CORE_ADDR start
, CORE_ADDR end
)
14044 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14045 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14046 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14047 blockvec
.emplace_back (start
, end
);
14050 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14054 /* Check whether the producer field indicates either of GCC < 4.6, or the
14055 Intel C/C++ compiler, and cache the result in CU. */
14058 check_producer (struct dwarf2_cu
*cu
)
14062 if (cu
->producer
== NULL
)
14064 /* For unknown compilers expect their behavior is DWARF version
14067 GCC started to support .debug_types sections by -gdwarf-4 since
14068 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14069 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14070 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14071 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14073 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14075 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14076 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14078 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14080 cu
->producer_is_icc
= true;
14081 cu
->producer_is_icc_lt_14
= major
< 14;
14083 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14084 cu
->producer_is_codewarrior
= true;
14087 /* For other non-GCC compilers, expect their behavior is DWARF version
14091 cu
->checked_producer
= true;
14094 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14095 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14096 during 4.6.0 experimental. */
14099 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14101 if (!cu
->checked_producer
)
14102 check_producer (cu
);
14104 return cu
->producer_is_gxx_lt_4_6
;
14108 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14109 with incorrect is_stmt attributes. */
14112 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14114 if (!cu
->checked_producer
)
14115 check_producer (cu
);
14117 return cu
->producer_is_codewarrior
;
14120 /* Return the default accessibility type if it is not overridden by
14121 DW_AT_accessibility. */
14123 static enum dwarf_access_attribute
14124 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14126 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14128 /* The default DWARF 2 accessibility for members is public, the default
14129 accessibility for inheritance is private. */
14131 if (die
->tag
!= DW_TAG_inheritance
)
14132 return DW_ACCESS_public
;
14134 return DW_ACCESS_private
;
14138 /* DWARF 3+ defines the default accessibility a different way. The same
14139 rules apply now for DW_TAG_inheritance as for the members and it only
14140 depends on the container kind. */
14142 if (die
->parent
->tag
== DW_TAG_class_type
)
14143 return DW_ACCESS_private
;
14145 return DW_ACCESS_public
;
14149 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14150 offset. If the attribute was not found return 0, otherwise return
14151 1. If it was found but could not properly be handled, set *OFFSET
14155 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14158 struct attribute
*attr
;
14160 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14165 /* Note that we do not check for a section offset first here.
14166 This is because DW_AT_data_member_location is new in DWARF 4,
14167 so if we see it, we can assume that a constant form is really
14168 a constant and not a section offset. */
14169 if (attr
->form_is_constant ())
14170 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
14171 else if (attr
->form_is_section_offset ())
14172 dwarf2_complex_location_expr_complaint ();
14173 else if (attr
->form_is_block ())
14174 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
14176 dwarf2_complex_location_expr_complaint ();
14184 /* Add an aggregate field to the field list. */
14187 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
14188 struct dwarf2_cu
*cu
)
14190 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14191 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14192 struct nextfield
*new_field
;
14193 struct attribute
*attr
;
14195 const char *fieldname
= "";
14197 if (die
->tag
== DW_TAG_inheritance
)
14199 fip
->baseclasses
.emplace_back ();
14200 new_field
= &fip
->baseclasses
.back ();
14204 fip
->fields
.emplace_back ();
14205 new_field
= &fip
->fields
.back ();
14208 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14209 if (attr
!= nullptr)
14210 new_field
->accessibility
= DW_UNSND (attr
);
14212 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
14213 if (new_field
->accessibility
!= DW_ACCESS_public
)
14214 fip
->non_public_fields
= 1;
14216 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
14217 if (attr
!= nullptr)
14218 new_field
->virtuality
= DW_UNSND (attr
);
14220 new_field
->virtuality
= DW_VIRTUALITY_none
;
14222 fp
= &new_field
->field
;
14224 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
14228 /* Data member other than a C++ static data member. */
14230 /* Get type of field. */
14231 fp
->type
= die_type (die
, cu
);
14233 SET_FIELD_BITPOS (*fp
, 0);
14235 /* Get bit size of field (zero if none). */
14236 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
14237 if (attr
!= nullptr)
14239 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
14243 FIELD_BITSIZE (*fp
) = 0;
14246 /* Get bit offset of field. */
14247 if (handle_data_member_location (die
, cu
, &offset
))
14248 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
14249 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
14250 if (attr
!= nullptr)
14252 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
14254 /* For big endian bits, the DW_AT_bit_offset gives the
14255 additional bit offset from the MSB of the containing
14256 anonymous object to the MSB of the field. We don't
14257 have to do anything special since we don't need to
14258 know the size of the anonymous object. */
14259 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
14263 /* For little endian bits, compute the bit offset to the
14264 MSB of the anonymous object, subtract off the number of
14265 bits from the MSB of the field to the MSB of the
14266 object, and then subtract off the number of bits of
14267 the field itself. The result is the bit offset of
14268 the LSB of the field. */
14269 int anonymous_size
;
14270 int bit_offset
= DW_UNSND (attr
);
14272 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
14273 if (attr
!= nullptr)
14275 /* The size of the anonymous object containing
14276 the bit field is explicit, so use the
14277 indicated size (in bytes). */
14278 anonymous_size
= DW_UNSND (attr
);
14282 /* The size of the anonymous object containing
14283 the bit field must be inferred from the type
14284 attribute of the data member containing the
14286 anonymous_size
= TYPE_LENGTH (fp
->type
);
14288 SET_FIELD_BITPOS (*fp
,
14289 (FIELD_BITPOS (*fp
)
14290 + anonymous_size
* bits_per_byte
14291 - bit_offset
- FIELD_BITSIZE (*fp
)));
14294 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
14296 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
14297 + dwarf2_get_attr_constant_value (attr
, 0)));
14299 /* Get name of field. */
14300 fieldname
= dwarf2_name (die
, cu
);
14301 if (fieldname
== NULL
)
14304 /* The name is already allocated along with this objfile, so we don't
14305 need to duplicate it for the type. */
14306 fp
->name
= fieldname
;
14308 /* Change accessibility for artificial fields (e.g. virtual table
14309 pointer or virtual base class pointer) to private. */
14310 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
14312 FIELD_ARTIFICIAL (*fp
) = 1;
14313 new_field
->accessibility
= DW_ACCESS_private
;
14314 fip
->non_public_fields
= 1;
14317 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
14319 /* C++ static member. */
14321 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
14322 is a declaration, but all versions of G++ as of this writing
14323 (so through at least 3.2.1) incorrectly generate
14324 DW_TAG_variable tags. */
14326 const char *physname
;
14328 /* Get name of field. */
14329 fieldname
= dwarf2_name (die
, cu
);
14330 if (fieldname
== NULL
)
14333 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
14335 /* Only create a symbol if this is an external value.
14336 new_symbol checks this and puts the value in the global symbol
14337 table, which we want. If it is not external, new_symbol
14338 will try to put the value in cu->list_in_scope which is wrong. */
14339 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
14341 /* A static const member, not much different than an enum as far as
14342 we're concerned, except that we can support more types. */
14343 new_symbol (die
, NULL
, cu
);
14346 /* Get physical name. */
14347 physname
= dwarf2_physname (fieldname
, die
, cu
);
14349 /* The name is already allocated along with this objfile, so we don't
14350 need to duplicate it for the type. */
14351 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
14352 FIELD_TYPE (*fp
) = die_type (die
, cu
);
14353 FIELD_NAME (*fp
) = fieldname
;
14355 else if (die
->tag
== DW_TAG_inheritance
)
14359 /* C++ base class field. */
14360 if (handle_data_member_location (die
, cu
, &offset
))
14361 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
14362 FIELD_BITSIZE (*fp
) = 0;
14363 FIELD_TYPE (*fp
) = die_type (die
, cu
);
14364 FIELD_NAME (*fp
) = TYPE_NAME (fp
->type
);
14366 else if (die
->tag
== DW_TAG_variant_part
)
14368 /* process_structure_scope will treat this DIE as a union. */
14369 process_structure_scope (die
, cu
);
14371 /* The variant part is relative to the start of the enclosing
14373 SET_FIELD_BITPOS (*fp
, 0);
14374 fp
->type
= get_die_type (die
, cu
);
14375 fp
->artificial
= 1;
14376 fp
->name
= "<<variant>>";
14378 /* Normally a DW_TAG_variant_part won't have a size, but our
14379 representation requires one, so set it to the maximum of the
14380 child sizes, being sure to account for the offset at which
14381 each child is seen. */
14382 if (TYPE_LENGTH (fp
->type
) == 0)
14385 for (int i
= 0; i
< TYPE_NFIELDS (fp
->type
); ++i
)
14387 unsigned len
= ((TYPE_FIELD_BITPOS (fp
->type
, i
) + 7) / 8
14388 + TYPE_LENGTH (TYPE_FIELD_TYPE (fp
->type
, i
)));
14392 TYPE_LENGTH (fp
->type
) = max
;
14396 gdb_assert_not_reached ("missing case in dwarf2_add_field");
14399 /* Can the type given by DIE define another type? */
14402 type_can_define_types (const struct die_info
*die
)
14406 case DW_TAG_typedef
:
14407 case DW_TAG_class_type
:
14408 case DW_TAG_structure_type
:
14409 case DW_TAG_union_type
:
14410 case DW_TAG_enumeration_type
:
14418 /* Add a type definition defined in the scope of the FIP's class. */
14421 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
14422 struct dwarf2_cu
*cu
)
14424 struct decl_field fp
;
14425 memset (&fp
, 0, sizeof (fp
));
14427 gdb_assert (type_can_define_types (die
));
14429 /* Get name of field. NULL is okay here, meaning an anonymous type. */
14430 fp
.name
= dwarf2_name (die
, cu
);
14431 fp
.type
= read_type_die (die
, cu
);
14433 /* Save accessibility. */
14434 enum dwarf_access_attribute accessibility
;
14435 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14437 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
14439 accessibility
= dwarf2_default_access_attribute (die
, cu
);
14440 switch (accessibility
)
14442 case DW_ACCESS_public
:
14443 /* The assumed value if neither private nor protected. */
14445 case DW_ACCESS_private
:
14448 case DW_ACCESS_protected
:
14449 fp
.is_protected
= 1;
14452 complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility
);
14455 if (die
->tag
== DW_TAG_typedef
)
14456 fip
->typedef_field_list
.push_back (fp
);
14458 fip
->nested_types_list
.push_back (fp
);
14461 /* Create the vector of fields, and attach it to the type. */
14464 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
14465 struct dwarf2_cu
*cu
)
14467 int nfields
= fip
->nfields ();
14469 /* Record the field count, allocate space for the array of fields,
14470 and create blank accessibility bitfields if necessary. */
14471 TYPE_NFIELDS (type
) = nfields
;
14472 TYPE_FIELDS (type
) = (struct field
*)
14473 TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
);
14475 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
14477 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14479 TYPE_FIELD_PRIVATE_BITS (type
) =
14480 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14481 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
14483 TYPE_FIELD_PROTECTED_BITS (type
) =
14484 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14485 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
14487 TYPE_FIELD_IGNORE_BITS (type
) =
14488 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
14489 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
14492 /* If the type has baseclasses, allocate and clear a bit vector for
14493 TYPE_FIELD_VIRTUAL_BITS. */
14494 if (!fip
->baseclasses
.empty () && cu
->language
!= language_ada
)
14496 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
14497 unsigned char *pointer
;
14499 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14500 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
14501 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
14502 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
14503 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
14506 if (TYPE_FLAG_DISCRIMINATED_UNION (type
))
14508 struct discriminant_info
*di
= alloc_discriminant_info (type
, -1, -1);
14510 for (int index
= 0; index
< nfields
; ++index
)
14512 struct nextfield
&field
= fip
->fields
[index
];
14514 if (field
.variant
.is_discriminant
)
14515 di
->discriminant_index
= index
;
14516 else if (field
.variant
.default_branch
)
14517 di
->default_index
= index
;
14519 di
->discriminants
[index
] = field
.variant
.discriminant_value
;
14523 /* Copy the saved-up fields into the field vector. */
14524 for (int i
= 0; i
< nfields
; ++i
)
14526 struct nextfield
&field
14527 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
14528 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
14530 TYPE_FIELD (type
, i
) = field
.field
;
14531 switch (field
.accessibility
)
14533 case DW_ACCESS_private
:
14534 if (cu
->language
!= language_ada
)
14535 SET_TYPE_FIELD_PRIVATE (type
, i
);
14538 case DW_ACCESS_protected
:
14539 if (cu
->language
!= language_ada
)
14540 SET_TYPE_FIELD_PROTECTED (type
, i
);
14543 case DW_ACCESS_public
:
14547 /* Unknown accessibility. Complain and treat it as public. */
14549 complaint (_("unsupported accessibility %d"),
14550 field
.accessibility
);
14554 if (i
< fip
->baseclasses
.size ())
14556 switch (field
.virtuality
)
14558 case DW_VIRTUALITY_virtual
:
14559 case DW_VIRTUALITY_pure_virtual
:
14560 if (cu
->language
== language_ada
)
14561 error (_("unexpected virtuality in component of Ada type"));
14562 SET_TYPE_FIELD_VIRTUAL (type
, i
);
14569 /* Return true if this member function is a constructor, false
14573 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
14575 const char *fieldname
;
14576 const char *type_name
;
14579 if (die
->parent
== NULL
)
14582 if (die
->parent
->tag
!= DW_TAG_structure_type
14583 && die
->parent
->tag
!= DW_TAG_union_type
14584 && die
->parent
->tag
!= DW_TAG_class_type
)
14587 fieldname
= dwarf2_name (die
, cu
);
14588 type_name
= dwarf2_name (die
->parent
, cu
);
14589 if (fieldname
== NULL
|| type_name
== NULL
)
14592 len
= strlen (fieldname
);
14593 return (strncmp (fieldname
, type_name
, len
) == 0
14594 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
14597 /* Check if the given VALUE is a recognized enum
14598 dwarf_defaulted_attribute constant according to DWARF5 spec,
14602 is_valid_DW_AT_defaulted (ULONGEST value
)
14606 case DW_DEFAULTED_no
:
14607 case DW_DEFAULTED_in_class
:
14608 case DW_DEFAULTED_out_of_class
:
14612 complaint (_("unrecognized DW_AT_defaulted value (%s)"), pulongest (value
));
14616 /* Add a member function to the proper fieldlist. */
14619 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
14620 struct type
*type
, struct dwarf2_cu
*cu
)
14622 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14623 struct attribute
*attr
;
14625 struct fnfieldlist
*flp
= nullptr;
14626 struct fn_field
*fnp
;
14627 const char *fieldname
;
14628 struct type
*this_type
;
14629 enum dwarf_access_attribute accessibility
;
14631 if (cu
->language
== language_ada
)
14632 error (_("unexpected member function in Ada type"));
14634 /* Get name of member function. */
14635 fieldname
= dwarf2_name (die
, cu
);
14636 if (fieldname
== NULL
)
14639 /* Look up member function name in fieldlist. */
14640 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
14642 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
14644 flp
= &fip
->fnfieldlists
[i
];
14649 /* Create a new fnfieldlist if necessary. */
14650 if (flp
== nullptr)
14652 fip
->fnfieldlists
.emplace_back ();
14653 flp
= &fip
->fnfieldlists
.back ();
14654 flp
->name
= fieldname
;
14655 i
= fip
->fnfieldlists
.size () - 1;
14658 /* Create a new member function field and add it to the vector of
14660 flp
->fnfields
.emplace_back ();
14661 fnp
= &flp
->fnfields
.back ();
14663 /* Delay processing of the physname until later. */
14664 if (cu
->language
== language_cplus
)
14665 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
14669 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
14670 fnp
->physname
= physname
? physname
: "";
14673 fnp
->type
= alloc_type (objfile
);
14674 this_type
= read_type_die (die
, cu
);
14675 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
14677 int nparams
= TYPE_NFIELDS (this_type
);
14679 /* TYPE is the domain of this method, and THIS_TYPE is the type
14680 of the method itself (TYPE_CODE_METHOD). */
14681 smash_to_method_type (fnp
->type
, type
,
14682 TYPE_TARGET_TYPE (this_type
),
14683 TYPE_FIELDS (this_type
),
14684 TYPE_NFIELDS (this_type
),
14685 TYPE_VARARGS (this_type
));
14687 /* Handle static member functions.
14688 Dwarf2 has no clean way to discern C++ static and non-static
14689 member functions. G++ helps GDB by marking the first
14690 parameter for non-static member functions (which is the this
14691 pointer) as artificial. We obtain this information from
14692 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
14693 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
14694 fnp
->voffset
= VOFFSET_STATIC
;
14697 complaint (_("member function type missing for '%s'"),
14698 dwarf2_full_name (fieldname
, die
, cu
));
14700 /* Get fcontext from DW_AT_containing_type if present. */
14701 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
14702 fnp
->fcontext
= die_containing_type (die
, cu
);
14704 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
14705 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
14707 /* Get accessibility. */
14708 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14709 if (attr
!= nullptr)
14710 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
14712 accessibility
= dwarf2_default_access_attribute (die
, cu
);
14713 switch (accessibility
)
14715 case DW_ACCESS_private
:
14716 fnp
->is_private
= 1;
14718 case DW_ACCESS_protected
:
14719 fnp
->is_protected
= 1;
14723 /* Check for artificial methods. */
14724 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
14725 if (attr
&& DW_UNSND (attr
) != 0)
14726 fnp
->is_artificial
= 1;
14728 /* Check for defaulted methods. */
14729 attr
= dwarf2_attr (die
, DW_AT_defaulted
, cu
);
14730 if (attr
!= nullptr && is_valid_DW_AT_defaulted (DW_UNSND (attr
)))
14731 fnp
->defaulted
= (enum dwarf_defaulted_attribute
) DW_UNSND (attr
);
14733 /* Check for deleted methods. */
14734 attr
= dwarf2_attr (die
, DW_AT_deleted
, cu
);
14735 if (attr
!= nullptr && DW_UNSND (attr
) != 0)
14736 fnp
->is_deleted
= 1;
14738 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
14740 /* Get index in virtual function table if it is a virtual member
14741 function. For older versions of GCC, this is an offset in the
14742 appropriate virtual table, as specified by DW_AT_containing_type.
14743 For everyone else, it is an expression to be evaluated relative
14744 to the object address. */
14746 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
14747 if (attr
!= nullptr)
14749 if (attr
->form_is_block () && DW_BLOCK (attr
)->size
> 0)
14751 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
14753 /* Old-style GCC. */
14754 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
14756 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
14757 || (DW_BLOCK (attr
)->size
> 1
14758 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
14759 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
14761 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
14762 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
14763 dwarf2_complex_location_expr_complaint ();
14765 fnp
->voffset
/= cu
->header
.addr_size
;
14769 dwarf2_complex_location_expr_complaint ();
14771 if (!fnp
->fcontext
)
14773 /* If there is no `this' field and no DW_AT_containing_type,
14774 we cannot actually find a base class context for the
14776 if (TYPE_NFIELDS (this_type
) == 0
14777 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
14779 complaint (_("cannot determine context for virtual member "
14780 "function \"%s\" (offset %s)"),
14781 fieldname
, sect_offset_str (die
->sect_off
));
14786 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
14790 else if (attr
->form_is_section_offset ())
14792 dwarf2_complex_location_expr_complaint ();
14796 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
14802 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
14803 if (attr
&& DW_UNSND (attr
))
14805 /* GCC does this, as of 2008-08-25; PR debug/37237. */
14806 complaint (_("Member function \"%s\" (offset %s) is virtual "
14807 "but the vtable offset is not specified"),
14808 fieldname
, sect_offset_str (die
->sect_off
));
14809 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14810 TYPE_CPLUS_DYNAMIC (type
) = 1;
14815 /* Create the vector of member function fields, and attach it to the type. */
14818 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
14819 struct dwarf2_cu
*cu
)
14821 if (cu
->language
== language_ada
)
14822 error (_("unexpected member functions in Ada type"));
14824 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
14825 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
14827 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
14829 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
14831 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
14832 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
14834 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
14835 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
14836 fn_flp
->fn_fields
= (struct fn_field
*)
14837 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
14839 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
14840 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
14843 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
14846 /* Returns non-zero if NAME is the name of a vtable member in CU's
14847 language, zero otherwise. */
14849 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
14851 static const char vptr
[] = "_vptr";
14853 /* Look for the C++ form of the vtable. */
14854 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
14860 /* GCC outputs unnamed structures that are really pointers to member
14861 functions, with the ABI-specified layout. If TYPE describes
14862 such a structure, smash it into a member function type.
14864 GCC shouldn't do this; it should just output pointer to member DIEs.
14865 This is GCC PR debug/28767. */
14868 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
14870 struct type
*pfn_type
, *self_type
, *new_type
;
14872 /* Check for a structure with no name and two children. */
14873 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
14876 /* Check for __pfn and __delta members. */
14877 if (TYPE_FIELD_NAME (type
, 0) == NULL
14878 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
14879 || TYPE_FIELD_NAME (type
, 1) == NULL
14880 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
14883 /* Find the type of the method. */
14884 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
14885 if (pfn_type
== NULL
14886 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
14887 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
14890 /* Look for the "this" argument. */
14891 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
14892 if (TYPE_NFIELDS (pfn_type
) == 0
14893 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
14894 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
14897 self_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
14898 new_type
= alloc_type (objfile
);
14899 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
14900 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
14901 TYPE_VARARGS (pfn_type
));
14902 smash_to_methodptr_type (type
, new_type
);
14905 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
14906 appropriate error checking and issuing complaints if there is a
14910 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
14912 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
14914 if (attr
== nullptr)
14917 if (!attr
->form_is_constant ())
14919 complaint (_("DW_AT_alignment must have constant form"
14920 " - DIE at %s [in module %s]"),
14921 sect_offset_str (die
->sect_off
),
14922 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
14927 if (attr
->form
== DW_FORM_sdata
)
14929 LONGEST val
= DW_SND (attr
);
14932 complaint (_("DW_AT_alignment value must not be negative"
14933 " - DIE at %s [in module %s]"),
14934 sect_offset_str (die
->sect_off
),
14935 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
14941 align
= DW_UNSND (attr
);
14945 complaint (_("DW_AT_alignment value must not be zero"
14946 " - DIE at %s [in module %s]"),
14947 sect_offset_str (die
->sect_off
),
14948 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
14951 if ((align
& (align
- 1)) != 0)
14953 complaint (_("DW_AT_alignment value must be a power of 2"
14954 " - DIE at %s [in module %s]"),
14955 sect_offset_str (die
->sect_off
),
14956 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
14963 /* If the DIE has a DW_AT_alignment attribute, use its value to set
14964 the alignment for TYPE. */
14967 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
14970 if (!set_type_align (type
, get_alignment (cu
, die
)))
14971 complaint (_("DW_AT_alignment value too large"
14972 " - DIE at %s [in module %s]"),
14973 sect_offset_str (die
->sect_off
),
14974 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
14977 /* Check if the given VALUE is a valid enum dwarf_calling_convention
14978 constant for a type, according to DWARF5 spec, Table 5.5. */
14981 is_valid_DW_AT_calling_convention_for_type (ULONGEST value
)
14986 case DW_CC_pass_by_reference
:
14987 case DW_CC_pass_by_value
:
14991 complaint (_("unrecognized DW_AT_calling_convention value "
14992 "(%s) for a type"), pulongest (value
));
14997 /* Check if the given VALUE is a valid enum dwarf_calling_convention
14998 constant for a subroutine, according to DWARF5 spec, Table 3.3, and
14999 also according to GNU-specific values (see include/dwarf2.h). */
15002 is_valid_DW_AT_calling_convention_for_subroutine (ULONGEST value
)
15007 case DW_CC_program
:
15011 case DW_CC_GNU_renesas_sh
:
15012 case DW_CC_GNU_borland_fastcall_i386
:
15013 case DW_CC_GDB_IBM_OpenCL
:
15017 complaint (_("unrecognized DW_AT_calling_convention value "
15018 "(%s) for a subroutine"), pulongest (value
));
15023 /* Called when we find the DIE that starts a structure or union scope
15024 (definition) to create a type for the structure or union. Fill in
15025 the type's name and general properties; the members will not be
15026 processed until process_structure_scope. A symbol table entry for
15027 the type will also not be done until process_structure_scope (assuming
15028 the type has a name).
15030 NOTE: we need to call these functions regardless of whether or not the
15031 DIE has a DW_AT_name attribute, since it might be an anonymous
15032 structure or union. This gets the type entered into our set of
15033 user defined types. */
15035 static struct type
*
15036 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15038 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15040 struct attribute
*attr
;
15043 /* If the definition of this type lives in .debug_types, read that type.
15044 Don't follow DW_AT_specification though, that will take us back up
15045 the chain and we want to go down. */
15046 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
15047 if (attr
!= nullptr)
15049 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15051 /* The type's CU may not be the same as CU.
15052 Ensure TYPE is recorded with CU in die_type_hash. */
15053 return set_die_type (die
, type
, cu
);
15056 type
= alloc_type (objfile
);
15057 INIT_CPLUS_SPECIFIC (type
);
15059 name
= dwarf2_name (die
, cu
);
15062 if (cu
->language
== language_cplus
15063 || cu
->language
== language_d
15064 || cu
->language
== language_rust
)
15066 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
15068 /* dwarf2_full_name might have already finished building the DIE's
15069 type. If so, there is no need to continue. */
15070 if (get_die_type (die
, cu
) != NULL
)
15071 return get_die_type (die
, cu
);
15073 TYPE_NAME (type
) = full_name
;
15077 /* The name is already allocated along with this objfile, so
15078 we don't need to duplicate it for the type. */
15079 TYPE_NAME (type
) = name
;
15083 if (die
->tag
== DW_TAG_structure_type
)
15085 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15087 else if (die
->tag
== DW_TAG_union_type
)
15089 TYPE_CODE (type
) = TYPE_CODE_UNION
;
15091 else if (die
->tag
== DW_TAG_variant_part
)
15093 TYPE_CODE (type
) = TYPE_CODE_UNION
;
15094 TYPE_FLAG_DISCRIMINATED_UNION (type
) = 1;
15098 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15101 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
15102 TYPE_DECLARED_CLASS (type
) = 1;
15104 /* Store the calling convention in the type if it's available in
15105 the die. Otherwise the calling convention remains set to
15106 the default value DW_CC_normal. */
15107 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
15108 if (attr
!= nullptr
15109 && is_valid_DW_AT_calling_convention_for_type (DW_UNSND (attr
)))
15111 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15112 TYPE_CPLUS_CALLING_CONVENTION (type
)
15113 = (enum dwarf_calling_convention
) (DW_UNSND (attr
));
15116 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15117 if (attr
!= nullptr)
15119 if (attr
->form_is_constant ())
15120 TYPE_LENGTH (type
) = DW_UNSND (attr
);
15123 /* For the moment, dynamic type sizes are not supported
15124 by GDB's struct type. The actual size is determined
15125 on-demand when resolving the type of a given object,
15126 so set the type's length to zero for now. Otherwise,
15127 we record an expression as the length, and that expression
15128 could lead to a very large value, which could eventually
15129 lead to us trying to allocate that much memory when creating
15130 a value of that type. */
15131 TYPE_LENGTH (type
) = 0;
15136 TYPE_LENGTH (type
) = 0;
15139 maybe_set_alignment (cu
, die
, type
);
15141 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
15143 /* ICC<14 does not output the required DW_AT_declaration on
15144 incomplete types, but gives them a size of zero. */
15145 TYPE_STUB (type
) = 1;
15148 TYPE_STUB_SUPPORTED (type
) = 1;
15150 if (die_is_declaration (die
, cu
))
15151 TYPE_STUB (type
) = 1;
15152 else if (attr
== NULL
&& die
->child
== NULL
15153 && producer_is_realview (cu
->producer
))
15154 /* RealView does not output the required DW_AT_declaration
15155 on incomplete types. */
15156 TYPE_STUB (type
) = 1;
15158 /* We need to add the type field to the die immediately so we don't
15159 infinitely recurse when dealing with pointers to the structure
15160 type within the structure itself. */
15161 set_die_type (die
, type
, cu
);
15163 /* set_die_type should be already done. */
15164 set_descriptive_type (type
, die
, cu
);
15169 /* A helper for process_structure_scope that handles a single member
15173 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
15174 struct field_info
*fi
,
15175 std::vector
<struct symbol
*> *template_args
,
15176 struct dwarf2_cu
*cu
)
15178 if (child_die
->tag
== DW_TAG_member
15179 || child_die
->tag
== DW_TAG_variable
15180 || child_die
->tag
== DW_TAG_variant_part
)
15182 /* NOTE: carlton/2002-11-05: A C++ static data member
15183 should be a DW_TAG_member that is a declaration, but
15184 all versions of G++ as of this writing (so through at
15185 least 3.2.1) incorrectly generate DW_TAG_variable
15186 tags for them instead. */
15187 dwarf2_add_field (fi
, child_die
, cu
);
15189 else if (child_die
->tag
== DW_TAG_subprogram
)
15191 /* Rust doesn't have member functions in the C++ sense.
15192 However, it does emit ordinary functions as children
15193 of a struct DIE. */
15194 if (cu
->language
== language_rust
)
15195 read_func_scope (child_die
, cu
);
15198 /* C++ member function. */
15199 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
15202 else if (child_die
->tag
== DW_TAG_inheritance
)
15204 /* C++ base class field. */
15205 dwarf2_add_field (fi
, child_die
, cu
);
15207 else if (type_can_define_types (child_die
))
15208 dwarf2_add_type_defn (fi
, child_die
, cu
);
15209 else if (child_die
->tag
== DW_TAG_template_type_param
15210 || child_die
->tag
== DW_TAG_template_value_param
)
15212 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
15215 template_args
->push_back (arg
);
15217 else if (child_die
->tag
== DW_TAG_variant
)
15219 /* In a variant we want to get the discriminant and also add a
15220 field for our sole member child. */
15221 struct attribute
*discr
= dwarf2_attr (child_die
, DW_AT_discr_value
, cu
);
15223 for (die_info
*variant_child
= child_die
->child
;
15224 variant_child
!= NULL
;
15225 variant_child
= sibling_die (variant_child
))
15227 if (variant_child
->tag
== DW_TAG_member
)
15229 handle_struct_member_die (variant_child
, type
, fi
,
15230 template_args
, cu
);
15231 /* Only handle the one. */
15236 /* We don't handle this but we might as well report it if we see
15238 if (dwarf2_attr (child_die
, DW_AT_discr_list
, cu
) != nullptr)
15239 complaint (_("DW_AT_discr_list is not supported yet"
15240 " - DIE at %s [in module %s]"),
15241 sect_offset_str (child_die
->sect_off
),
15242 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15244 /* The first field was just added, so we can stash the
15245 discriminant there. */
15246 gdb_assert (!fi
->fields
.empty ());
15248 fi
->fields
.back ().variant
.default_branch
= true;
15250 fi
->fields
.back ().variant
.discriminant_value
= DW_UNSND (discr
);
15254 /* Finish creating a structure or union type, including filling in
15255 its members and creating a symbol for it. */
15258 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
15260 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15261 struct die_info
*child_die
;
15264 type
= get_die_type (die
, cu
);
15266 type
= read_structure_type (die
, cu
);
15268 /* When reading a DW_TAG_variant_part, we need to notice when we
15269 read the discriminant member, so we can record it later in the
15270 discriminant_info. */
15271 bool is_variant_part
= TYPE_FLAG_DISCRIMINATED_UNION (type
);
15272 sect_offset discr_offset
{};
15273 bool has_template_parameters
= false;
15275 if (is_variant_part
)
15277 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
15280 /* Maybe it's a univariant form, an extension we support.
15281 In this case arrange not to check the offset. */
15282 is_variant_part
= false;
15284 else if (discr
->form_is_ref ())
15286 struct dwarf2_cu
*target_cu
= cu
;
15287 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
15289 discr_offset
= target_die
->sect_off
;
15293 complaint (_("DW_AT_discr does not have DIE reference form"
15294 " - DIE at %s [in module %s]"),
15295 sect_offset_str (die
->sect_off
),
15296 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15297 is_variant_part
= false;
15301 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
15303 struct field_info fi
;
15304 std::vector
<struct symbol
*> template_args
;
15306 child_die
= die
->child
;
15308 while (child_die
&& child_die
->tag
)
15310 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
15312 if (is_variant_part
&& discr_offset
== child_die
->sect_off
)
15313 fi
.fields
.back ().variant
.is_discriminant
= true;
15315 child_die
= sibling_die (child_die
);
15318 /* Attach template arguments to type. */
15319 if (!template_args
.empty ())
15321 has_template_parameters
= true;
15322 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15323 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
15324 TYPE_TEMPLATE_ARGUMENTS (type
)
15325 = XOBNEWVEC (&objfile
->objfile_obstack
,
15327 TYPE_N_TEMPLATE_ARGUMENTS (type
));
15328 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
15329 template_args
.data (),
15330 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
15331 * sizeof (struct symbol
*)));
15334 /* Attach fields and member functions to the type. */
15335 if (fi
.nfields () > 0)
15336 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
15337 if (!fi
.fnfieldlists
.empty ())
15339 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
15341 /* Get the type which refers to the base class (possibly this
15342 class itself) which contains the vtable pointer for the current
15343 class from the DW_AT_containing_type attribute. This use of
15344 DW_AT_containing_type is a GNU extension. */
15346 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15348 struct type
*t
= die_containing_type (die
, cu
);
15350 set_type_vptr_basetype (type
, t
);
15355 /* Our own class provides vtbl ptr. */
15356 for (i
= TYPE_NFIELDS (t
) - 1;
15357 i
>= TYPE_N_BASECLASSES (t
);
15360 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
15362 if (is_vtable_name (fieldname
, cu
))
15364 set_type_vptr_fieldno (type
, i
);
15369 /* Complain if virtual function table field not found. */
15370 if (i
< TYPE_N_BASECLASSES (t
))
15371 complaint (_("virtual function table pointer "
15372 "not found when defining class '%s'"),
15373 TYPE_NAME (type
) ? TYPE_NAME (type
) : "");
15377 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
15380 else if (cu
->producer
15381 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
15383 /* The IBM XLC compiler does not provide direct indication
15384 of the containing type, but the vtable pointer is
15385 always named __vfp. */
15389 for (i
= TYPE_NFIELDS (type
) - 1;
15390 i
>= TYPE_N_BASECLASSES (type
);
15393 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
15395 set_type_vptr_fieldno (type
, i
);
15396 set_type_vptr_basetype (type
, type
);
15403 /* Copy fi.typedef_field_list linked list elements content into the
15404 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
15405 if (!fi
.typedef_field_list
.empty ())
15407 int count
= fi
.typedef_field_list
.size ();
15409 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15410 TYPE_TYPEDEF_FIELD_ARRAY (type
)
15411 = ((struct decl_field
*)
15413 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
15414 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
15416 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
15417 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
15420 /* Copy fi.nested_types_list linked list elements content into the
15421 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
15422 if (!fi
.nested_types_list
.empty () && cu
->language
!= language_ada
)
15424 int count
= fi
.nested_types_list
.size ();
15426 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15427 TYPE_NESTED_TYPES_ARRAY (type
)
15428 = ((struct decl_field
*)
15429 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
15430 TYPE_NESTED_TYPES_COUNT (type
) = count
;
15432 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
15433 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
15437 quirk_gcc_member_function_pointer (type
, objfile
);
15438 if (cu
->language
== language_rust
&& die
->tag
== DW_TAG_union_type
)
15439 cu
->rust_unions
.push_back (type
);
15441 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
15442 snapshots) has been known to create a die giving a declaration
15443 for a class that has, as a child, a die giving a definition for a
15444 nested class. So we have to process our children even if the
15445 current die is a declaration. Normally, of course, a declaration
15446 won't have any children at all. */
15448 child_die
= die
->child
;
15450 while (child_die
!= NULL
&& child_die
->tag
)
15452 if (child_die
->tag
== DW_TAG_member
15453 || child_die
->tag
== DW_TAG_variable
15454 || child_die
->tag
== DW_TAG_inheritance
15455 || child_die
->tag
== DW_TAG_template_value_param
15456 || child_die
->tag
== DW_TAG_template_type_param
)
15461 process_die (child_die
, cu
);
15463 child_die
= sibling_die (child_die
);
15466 /* Do not consider external references. According to the DWARF standard,
15467 these DIEs are identified by the fact that they have no byte_size
15468 attribute, and a declaration attribute. */
15469 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
15470 || !die_is_declaration (die
, cu
))
15472 struct symbol
*sym
= new_symbol (die
, type
, cu
);
15474 if (has_template_parameters
)
15476 struct symtab
*symtab
;
15477 if (sym
!= nullptr)
15478 symtab
= symbol_symtab (sym
);
15479 else if (cu
->line_header
!= nullptr)
15481 /* Any related symtab will do. */
15483 = cu
->line_header
->file_names ()[0].symtab
;
15488 complaint (_("could not find suitable "
15489 "symtab for template parameter"
15490 " - DIE at %s [in module %s]"),
15491 sect_offset_str (die
->sect_off
),
15492 objfile_name (objfile
));
15495 if (symtab
!= nullptr)
15497 /* Make sure that the symtab is set on the new symbols.
15498 Even though they don't appear in this symtab directly,
15499 other parts of gdb assume that symbols do, and this is
15500 reasonably true. */
15501 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
15502 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
15508 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
15509 update TYPE using some information only available in DIE's children. */
15512 update_enumeration_type_from_children (struct die_info
*die
,
15514 struct dwarf2_cu
*cu
)
15516 struct die_info
*child_die
;
15517 int unsigned_enum
= 1;
15520 auto_obstack obstack
;
15522 for (child_die
= die
->child
;
15523 child_die
!= NULL
&& child_die
->tag
;
15524 child_die
= sibling_die (child_die
))
15526 struct attribute
*attr
;
15528 const gdb_byte
*bytes
;
15529 struct dwarf2_locexpr_baton
*baton
;
15532 if (child_die
->tag
!= DW_TAG_enumerator
)
15535 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
15539 name
= dwarf2_name (child_die
, cu
);
15541 name
= "<anonymous enumerator>";
15543 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
15544 &value
, &bytes
, &baton
);
15552 if (count_one_bits_ll (value
) >= 2)
15556 /* If we already know that the enum type is neither unsigned, nor
15557 a flag type, no need to look at the rest of the enumerates. */
15558 if (!unsigned_enum
&& !flag_enum
)
15563 TYPE_UNSIGNED (type
) = 1;
15565 TYPE_FLAG_ENUM (type
) = 1;
15568 /* Given a DW_AT_enumeration_type die, set its type. We do not
15569 complete the type's fields yet, or create any symbols. */
15571 static struct type
*
15572 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15574 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15576 struct attribute
*attr
;
15579 /* If the definition of this type lives in .debug_types, read that type.
15580 Don't follow DW_AT_specification though, that will take us back up
15581 the chain and we want to go down. */
15582 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
15583 if (attr
!= nullptr)
15585 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15587 /* The type's CU may not be the same as CU.
15588 Ensure TYPE is recorded with CU in die_type_hash. */
15589 return set_die_type (die
, type
, cu
);
15592 type
= alloc_type (objfile
);
15594 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
15595 name
= dwarf2_full_name (NULL
, die
, cu
);
15597 TYPE_NAME (type
) = name
;
15599 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
15602 struct type
*underlying_type
= die_type (die
, cu
);
15604 TYPE_TARGET_TYPE (type
) = underlying_type
;
15607 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15608 if (attr
!= nullptr)
15610 TYPE_LENGTH (type
) = DW_UNSND (attr
);
15614 TYPE_LENGTH (type
) = 0;
15617 maybe_set_alignment (cu
, die
, type
);
15619 /* The enumeration DIE can be incomplete. In Ada, any type can be
15620 declared as private in the package spec, and then defined only
15621 inside the package body. Such types are known as Taft Amendment
15622 Types. When another package uses such a type, an incomplete DIE
15623 may be generated by the compiler. */
15624 if (die_is_declaration (die
, cu
))
15625 TYPE_STUB (type
) = 1;
15627 /* Finish the creation of this type by using the enum's children.
15628 We must call this even when the underlying type has been provided
15629 so that we can determine if we're looking at a "flag" enum. */
15630 update_enumeration_type_from_children (die
, type
, cu
);
15632 /* If this type has an underlying type that is not a stub, then we
15633 may use its attributes. We always use the "unsigned" attribute
15634 in this situation, because ordinarily we guess whether the type
15635 is unsigned -- but the guess can be wrong and the underlying type
15636 can tell us the reality. However, we defer to a local size
15637 attribute if one exists, because this lets the compiler override
15638 the underlying type if needed. */
15639 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_STUB (TYPE_TARGET_TYPE (type
)))
15641 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
));
15642 if (TYPE_LENGTH (type
) == 0)
15643 TYPE_LENGTH (type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
15644 if (TYPE_RAW_ALIGN (type
) == 0
15645 && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type
)) != 0)
15646 set_type_align (type
, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type
)));
15649 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
15651 return set_die_type (die
, type
, cu
);
15654 /* Given a pointer to a die which begins an enumeration, process all
15655 the dies that define the members of the enumeration, and create the
15656 symbol for the enumeration type.
15658 NOTE: We reverse the order of the element list. */
15661 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
15663 struct type
*this_type
;
15665 this_type
= get_die_type (die
, cu
);
15666 if (this_type
== NULL
)
15667 this_type
= read_enumeration_type (die
, cu
);
15669 if (die
->child
!= NULL
)
15671 struct die_info
*child_die
;
15672 struct symbol
*sym
;
15673 std::vector
<struct field
> fields
;
15676 child_die
= die
->child
;
15677 while (child_die
&& child_die
->tag
)
15679 if (child_die
->tag
!= DW_TAG_enumerator
)
15681 process_die (child_die
, cu
);
15685 name
= dwarf2_name (child_die
, cu
);
15688 sym
= new_symbol (child_die
, this_type
, cu
);
15690 fields
.emplace_back ();
15691 struct field
&field
= fields
.back ();
15693 FIELD_NAME (field
) = sym
->linkage_name ();
15694 FIELD_TYPE (field
) = NULL
;
15695 SET_FIELD_ENUMVAL (field
, SYMBOL_VALUE (sym
));
15696 FIELD_BITSIZE (field
) = 0;
15700 child_die
= sibling_die (child_die
);
15703 if (!fields
.empty ())
15705 TYPE_NFIELDS (this_type
) = fields
.size ();
15706 TYPE_FIELDS (this_type
) = (struct field
*)
15707 TYPE_ALLOC (this_type
, sizeof (struct field
) * fields
.size ());
15708 memcpy (TYPE_FIELDS (this_type
), fields
.data (),
15709 sizeof (struct field
) * fields
.size ());
15713 /* If we are reading an enum from a .debug_types unit, and the enum
15714 is a declaration, and the enum is not the signatured type in the
15715 unit, then we do not want to add a symbol for it. Adding a
15716 symbol would in some cases obscure the true definition of the
15717 enum, giving users an incomplete type when the definition is
15718 actually available. Note that we do not want to do this for all
15719 enums which are just declarations, because C++0x allows forward
15720 enum declarations. */
15721 if (cu
->per_cu
->is_debug_types
15722 && die_is_declaration (die
, cu
))
15724 struct signatured_type
*sig_type
;
15726 sig_type
= (struct signatured_type
*) cu
->per_cu
;
15727 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
15728 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
15732 new_symbol (die
, this_type
, cu
);
15735 /* Extract all information from a DW_TAG_array_type DIE and put it in
15736 the DIE's type field. For now, this only handles one dimensional
15739 static struct type
*
15740 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15742 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15743 struct die_info
*child_die
;
15745 struct type
*element_type
, *range_type
, *index_type
;
15746 struct attribute
*attr
;
15748 struct dynamic_prop
*byte_stride_prop
= NULL
;
15749 unsigned int bit_stride
= 0;
15751 element_type
= die_type (die
, cu
);
15753 /* The die_type call above may have already set the type for this DIE. */
15754 type
= get_die_type (die
, cu
);
15758 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
15762 struct type
*prop_type
= cu
->per_cu
->addr_sized_int_type (false);
15765 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
15766 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
15770 complaint (_("unable to read array DW_AT_byte_stride "
15771 " - DIE at %s [in module %s]"),
15772 sect_offset_str (die
->sect_off
),
15773 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15774 /* Ignore this attribute. We will likely not be able to print
15775 arrays of this type correctly, but there is little we can do
15776 to help if we cannot read the attribute's value. */
15777 byte_stride_prop
= NULL
;
15781 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
15783 bit_stride
= DW_UNSND (attr
);
15785 /* Irix 6.2 native cc creates array types without children for
15786 arrays with unspecified length. */
15787 if (die
->child
== NULL
)
15789 index_type
= objfile_type (objfile
)->builtin_int
;
15790 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
15791 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
15792 byte_stride_prop
, bit_stride
);
15793 return set_die_type (die
, type
, cu
);
15796 std::vector
<struct type
*> range_types
;
15797 child_die
= die
->child
;
15798 while (child_die
&& child_die
->tag
)
15800 if (child_die
->tag
== DW_TAG_subrange_type
)
15802 struct type
*child_type
= read_type_die (child_die
, cu
);
15804 if (child_type
!= NULL
)
15806 /* The range type was succesfully read. Save it for the
15807 array type creation. */
15808 range_types
.push_back (child_type
);
15811 child_die
= sibling_die (child_die
);
15814 /* Dwarf2 dimensions are output from left to right, create the
15815 necessary array types in backwards order. */
15817 type
= element_type
;
15819 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
15823 while (i
< range_types
.size ())
15824 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
15825 byte_stride_prop
, bit_stride
);
15829 size_t ndim
= range_types
.size ();
15831 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
15832 byte_stride_prop
, bit_stride
);
15835 /* Understand Dwarf2 support for vector types (like they occur on
15836 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
15837 array type. This is not part of the Dwarf2/3 standard yet, but a
15838 custom vendor extension. The main difference between a regular
15839 array and the vector variant is that vectors are passed by value
15841 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
15842 if (attr
!= nullptr)
15843 make_vector_type (type
);
15845 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
15846 implementation may choose to implement triple vectors using this
15848 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15849 if (attr
!= nullptr)
15851 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
15852 TYPE_LENGTH (type
) = DW_UNSND (attr
);
15854 complaint (_("DW_AT_byte_size for array type smaller "
15855 "than the total size of elements"));
15858 name
= dwarf2_name (die
, cu
);
15860 TYPE_NAME (type
) = name
;
15862 maybe_set_alignment (cu
, die
, type
);
15864 /* Install the type in the die. */
15865 set_die_type (die
, type
, cu
);
15867 /* set_die_type should be already done. */
15868 set_descriptive_type (type
, die
, cu
);
15873 static enum dwarf_array_dim_ordering
15874 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
15876 struct attribute
*attr
;
15878 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
15880 if (attr
!= nullptr)
15881 return (enum dwarf_array_dim_ordering
) DW_SND (attr
);
15883 /* GNU F77 is a special case, as at 08/2004 array type info is the
15884 opposite order to the dwarf2 specification, but data is still
15885 laid out as per normal fortran.
15887 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
15888 version checking. */
15890 if (cu
->language
== language_fortran
15891 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
15893 return DW_ORD_row_major
;
15896 switch (cu
->language_defn
->la_array_ordering
)
15898 case array_column_major
:
15899 return DW_ORD_col_major
;
15900 case array_row_major
:
15902 return DW_ORD_row_major
;
15906 /* Extract all information from a DW_TAG_set_type DIE and put it in
15907 the DIE's type field. */
15909 static struct type
*
15910 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15912 struct type
*domain_type
, *set_type
;
15913 struct attribute
*attr
;
15915 domain_type
= die_type (die
, cu
);
15917 /* The die_type call above may have already set the type for this DIE. */
15918 set_type
= get_die_type (die
, cu
);
15922 set_type
= create_set_type (NULL
, domain_type
);
15924 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15925 if (attr
!= nullptr)
15926 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
15928 maybe_set_alignment (cu
, die
, set_type
);
15930 return set_die_type (die
, set_type
, cu
);
15933 /* A helper for read_common_block that creates a locexpr baton.
15934 SYM is the symbol which we are marking as computed.
15935 COMMON_DIE is the DIE for the common block.
15936 COMMON_LOC is the location expression attribute for the common
15938 MEMBER_LOC is the location expression attribute for the particular
15939 member of the common block that we are processing.
15940 CU is the CU from which the above come. */
15943 mark_common_block_symbol_computed (struct symbol
*sym
,
15944 struct die_info
*common_die
,
15945 struct attribute
*common_loc
,
15946 struct attribute
*member_loc
,
15947 struct dwarf2_cu
*cu
)
15949 struct dwarf2_per_objfile
*dwarf2_per_objfile
15950 = cu
->per_cu
->dwarf2_per_objfile
;
15951 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
15952 struct dwarf2_locexpr_baton
*baton
;
15954 unsigned int cu_off
;
15955 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
15956 LONGEST offset
= 0;
15958 gdb_assert (common_loc
&& member_loc
);
15959 gdb_assert (common_loc
->form_is_block ());
15960 gdb_assert (member_loc
->form_is_block ()
15961 || member_loc
->form_is_constant ());
15963 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
15964 baton
->per_cu
= cu
->per_cu
;
15965 gdb_assert (baton
->per_cu
);
15967 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
15969 if (member_loc
->form_is_constant ())
15971 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
15972 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
15975 baton
->size
+= DW_BLOCK (member_loc
)->size
;
15977 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
15980 *ptr
++ = DW_OP_call4
;
15981 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
15982 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
15985 if (member_loc
->form_is_constant ())
15987 *ptr
++ = DW_OP_addr
;
15988 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
15989 ptr
+= cu
->header
.addr_size
;
15993 /* We have to copy the data here, because DW_OP_call4 will only
15994 use a DW_AT_location attribute. */
15995 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
15996 ptr
+= DW_BLOCK (member_loc
)->size
;
15999 *ptr
++ = DW_OP_plus
;
16000 gdb_assert (ptr
- baton
->data
== baton
->size
);
16002 SYMBOL_LOCATION_BATON (sym
) = baton
;
16003 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
16006 /* Create appropriate locally-scoped variables for all the
16007 DW_TAG_common_block entries. Also create a struct common_block
16008 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16009 is used to separate the common blocks name namespace from regular
16013 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
16015 struct attribute
*attr
;
16017 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16018 if (attr
!= nullptr)
16020 /* Support the .debug_loc offsets. */
16021 if (attr
->form_is_block ())
16025 else if (attr
->form_is_section_offset ())
16027 dwarf2_complex_location_expr_complaint ();
16032 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16033 "common block member");
16038 if (die
->child
!= NULL
)
16040 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16041 struct die_info
*child_die
;
16042 size_t n_entries
= 0, size
;
16043 struct common_block
*common_block
;
16044 struct symbol
*sym
;
16046 for (child_die
= die
->child
;
16047 child_die
&& child_die
->tag
;
16048 child_die
= sibling_die (child_die
))
16051 size
= (sizeof (struct common_block
)
16052 + (n_entries
- 1) * sizeof (struct symbol
*));
16054 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
16056 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
16057 common_block
->n_entries
= 0;
16059 for (child_die
= die
->child
;
16060 child_die
&& child_die
->tag
;
16061 child_die
= sibling_die (child_die
))
16063 /* Create the symbol in the DW_TAG_common_block block in the current
16065 sym
= new_symbol (child_die
, NULL
, cu
);
16068 struct attribute
*member_loc
;
16070 common_block
->contents
[common_block
->n_entries
++] = sym
;
16072 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
16076 /* GDB has handled this for a long time, but it is
16077 not specified by DWARF. It seems to have been
16078 emitted by gfortran at least as recently as:
16079 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16080 complaint (_("Variable in common block has "
16081 "DW_AT_data_member_location "
16082 "- DIE at %s [in module %s]"),
16083 sect_offset_str (child_die
->sect_off
),
16084 objfile_name (objfile
));
16086 if (member_loc
->form_is_section_offset ())
16087 dwarf2_complex_location_expr_complaint ();
16088 else if (member_loc
->form_is_constant ()
16089 || member_loc
->form_is_block ())
16091 if (attr
!= nullptr)
16092 mark_common_block_symbol_computed (sym
, die
, attr
,
16096 dwarf2_complex_location_expr_complaint ();
16101 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
16102 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
16106 /* Create a type for a C++ namespace. */
16108 static struct type
*
16109 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16111 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16112 const char *previous_prefix
, *name
;
16116 /* For extensions, reuse the type of the original namespace. */
16117 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
16119 struct die_info
*ext_die
;
16120 struct dwarf2_cu
*ext_cu
= cu
;
16122 ext_die
= dwarf2_extension (die
, &ext_cu
);
16123 type
= read_type_die (ext_die
, ext_cu
);
16125 /* EXT_CU may not be the same as CU.
16126 Ensure TYPE is recorded with CU in die_type_hash. */
16127 return set_die_type (die
, type
, cu
);
16130 name
= namespace_name (die
, &is_anonymous
, cu
);
16132 /* Now build the name of the current namespace. */
16134 previous_prefix
= determine_prefix (die
, cu
);
16135 if (previous_prefix
[0] != '\0')
16136 name
= typename_concat (&objfile
->objfile_obstack
,
16137 previous_prefix
, name
, 0, cu
);
16139 /* Create the type. */
16140 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
16142 return set_die_type (die
, type
, cu
);
16145 /* Read a namespace scope. */
16148 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
16150 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16153 /* Add a symbol associated to this if we haven't seen the namespace
16154 before. Also, add a using directive if it's an anonymous
16157 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
16161 type
= read_type_die (die
, cu
);
16162 new_symbol (die
, type
, cu
);
16164 namespace_name (die
, &is_anonymous
, cu
);
16167 const char *previous_prefix
= determine_prefix (die
, cu
);
16169 std::vector
<const char *> excludes
;
16170 add_using_directive (using_directives (cu
),
16171 previous_prefix
, TYPE_NAME (type
), NULL
,
16172 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
16176 if (die
->child
!= NULL
)
16178 struct die_info
*child_die
= die
->child
;
16180 while (child_die
&& child_die
->tag
)
16182 process_die (child_die
, cu
);
16183 child_die
= sibling_die (child_die
);
16188 /* Read a Fortran module as type. This DIE can be only a declaration used for
16189 imported module. Still we need that type as local Fortran "use ... only"
16190 declaration imports depend on the created type in determine_prefix. */
16192 static struct type
*
16193 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16195 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16196 const char *module_name
;
16199 module_name
= dwarf2_name (die
, cu
);
16200 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
16202 return set_die_type (die
, type
, cu
);
16205 /* Read a Fortran module. */
16208 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
16210 struct die_info
*child_die
= die
->child
;
16213 type
= read_type_die (die
, cu
);
16214 new_symbol (die
, type
, cu
);
16216 while (child_die
&& child_die
->tag
)
16218 process_die (child_die
, cu
);
16219 child_die
= sibling_die (child_die
);
16223 /* Return the name of the namespace represented by DIE. Set
16224 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16227 static const char *
16228 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
16230 struct die_info
*current_die
;
16231 const char *name
= NULL
;
16233 /* Loop through the extensions until we find a name. */
16235 for (current_die
= die
;
16236 current_die
!= NULL
;
16237 current_die
= dwarf2_extension (die
, &cu
))
16239 /* We don't use dwarf2_name here so that we can detect the absence
16240 of a name -> anonymous namespace. */
16241 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
16247 /* Is it an anonymous namespace? */
16249 *is_anonymous
= (name
== NULL
);
16251 name
= CP_ANONYMOUS_NAMESPACE_STR
;
16256 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16257 the user defined type vector. */
16259 static struct type
*
16260 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16262 struct gdbarch
*gdbarch
16263 = get_objfile_arch (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
16264 struct comp_unit_head
*cu_header
= &cu
->header
;
16266 struct attribute
*attr_byte_size
;
16267 struct attribute
*attr_address_class
;
16268 int byte_size
, addr_class
;
16269 struct type
*target_type
;
16271 target_type
= die_type (die
, cu
);
16273 /* The die_type call above may have already set the type for this DIE. */
16274 type
= get_die_type (die
, cu
);
16278 type
= lookup_pointer_type (target_type
);
16280 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16281 if (attr_byte_size
)
16282 byte_size
= DW_UNSND (attr_byte_size
);
16284 byte_size
= cu_header
->addr_size
;
16286 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
16287 if (attr_address_class
)
16288 addr_class
= DW_UNSND (attr_address_class
);
16290 addr_class
= DW_ADDR_none
;
16292 ULONGEST alignment
= get_alignment (cu
, die
);
16294 /* If the pointer size, alignment, or address class is different
16295 than the default, create a type variant marked as such and set
16296 the length accordingly. */
16297 if (TYPE_LENGTH (type
) != byte_size
16298 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
16299 && alignment
!= TYPE_RAW_ALIGN (type
))
16300 || addr_class
!= DW_ADDR_none
)
16302 if (gdbarch_address_class_type_flags_p (gdbarch
))
16306 type_flags
= gdbarch_address_class_type_flags
16307 (gdbarch
, byte_size
, addr_class
);
16308 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
16310 type
= make_type_with_address_space (type
, type_flags
);
16312 else if (TYPE_LENGTH (type
) != byte_size
)
16314 complaint (_("invalid pointer size %d"), byte_size
);
16316 else if (TYPE_RAW_ALIGN (type
) != alignment
)
16318 complaint (_("Invalid DW_AT_alignment"
16319 " - DIE at %s [in module %s]"),
16320 sect_offset_str (die
->sect_off
),
16321 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
16325 /* Should we also complain about unhandled address classes? */
16329 TYPE_LENGTH (type
) = byte_size
;
16330 set_type_align (type
, alignment
);
16331 return set_die_type (die
, type
, cu
);
16334 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
16335 the user defined type vector. */
16337 static struct type
*
16338 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16341 struct type
*to_type
;
16342 struct type
*domain
;
16344 to_type
= die_type (die
, cu
);
16345 domain
= die_containing_type (die
, cu
);
16347 /* The calls above may have already set the type for this DIE. */
16348 type
= get_die_type (die
, cu
);
16352 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
16353 type
= lookup_methodptr_type (to_type
);
16354 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
16356 struct type
*new_type
16357 = alloc_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
16359 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
16360 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
16361 TYPE_VARARGS (to_type
));
16362 type
= lookup_methodptr_type (new_type
);
16365 type
= lookup_memberptr_type (to_type
, domain
);
16367 return set_die_type (die
, type
, cu
);
16370 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
16371 the user defined type vector. */
16373 static struct type
*
16374 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
16375 enum type_code refcode
)
16377 struct comp_unit_head
*cu_header
= &cu
->header
;
16378 struct type
*type
, *target_type
;
16379 struct attribute
*attr
;
16381 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
16383 target_type
= die_type (die
, cu
);
16385 /* The die_type call above may have already set the type for this DIE. */
16386 type
= get_die_type (die
, cu
);
16390 type
= lookup_reference_type (target_type
, refcode
);
16391 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16392 if (attr
!= nullptr)
16394 TYPE_LENGTH (type
) = DW_UNSND (attr
);
16398 TYPE_LENGTH (type
) = cu_header
->addr_size
;
16400 maybe_set_alignment (cu
, die
, type
);
16401 return set_die_type (die
, type
, cu
);
16404 /* Add the given cv-qualifiers to the element type of the array. GCC
16405 outputs DWARF type qualifiers that apply to an array, not the
16406 element type. But GDB relies on the array element type to carry
16407 the cv-qualifiers. This mimics section 6.7.3 of the C99
16410 static struct type
*
16411 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
16412 struct type
*base_type
, int cnst
, int voltl
)
16414 struct type
*el_type
, *inner_array
;
16416 base_type
= copy_type (base_type
);
16417 inner_array
= base_type
;
16419 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
16421 TYPE_TARGET_TYPE (inner_array
) =
16422 copy_type (TYPE_TARGET_TYPE (inner_array
));
16423 inner_array
= TYPE_TARGET_TYPE (inner_array
);
16426 el_type
= TYPE_TARGET_TYPE (inner_array
);
16427 cnst
|= TYPE_CONST (el_type
);
16428 voltl
|= TYPE_VOLATILE (el_type
);
16429 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
16431 return set_die_type (die
, base_type
, cu
);
16434 static struct type
*
16435 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16437 struct type
*base_type
, *cv_type
;
16439 base_type
= die_type (die
, cu
);
16441 /* The die_type call above may have already set the type for this DIE. */
16442 cv_type
= get_die_type (die
, cu
);
16446 /* In case the const qualifier is applied to an array type, the element type
16447 is so qualified, not the array type (section 6.7.3 of C99). */
16448 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
16449 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
16451 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
16452 return set_die_type (die
, cv_type
, cu
);
16455 static struct type
*
16456 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16458 struct type
*base_type
, *cv_type
;
16460 base_type
= die_type (die
, cu
);
16462 /* The die_type call above may have already set the type for this DIE. */
16463 cv_type
= get_die_type (die
, cu
);
16467 /* In case the volatile qualifier is applied to an array type, the
16468 element type is so qualified, not the array type (section 6.7.3
16470 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
16471 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
16473 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
16474 return set_die_type (die
, cv_type
, cu
);
16477 /* Handle DW_TAG_restrict_type. */
16479 static struct type
*
16480 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16482 struct type
*base_type
, *cv_type
;
16484 base_type
= die_type (die
, cu
);
16486 /* The die_type call above may have already set the type for this DIE. */
16487 cv_type
= get_die_type (die
, cu
);
16491 cv_type
= make_restrict_type (base_type
);
16492 return set_die_type (die
, cv_type
, cu
);
16495 /* Handle DW_TAG_atomic_type. */
16497 static struct type
*
16498 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16500 struct type
*base_type
, *cv_type
;
16502 base_type
= die_type (die
, cu
);
16504 /* The die_type call above may have already set the type for this DIE. */
16505 cv_type
= get_die_type (die
, cu
);
16509 cv_type
= make_atomic_type (base_type
);
16510 return set_die_type (die
, cv_type
, cu
);
16513 /* Extract all information from a DW_TAG_string_type DIE and add to
16514 the user defined type vector. It isn't really a user defined type,
16515 but it behaves like one, with other DIE's using an AT_user_def_type
16516 attribute to reference it. */
16518 static struct type
*
16519 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16521 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16522 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16523 struct type
*type
, *range_type
, *index_type
, *char_type
;
16524 struct attribute
*attr
;
16525 struct dynamic_prop prop
;
16526 bool length_is_constant
= true;
16529 /* There are a couple of places where bit sizes might be made use of
16530 when parsing a DW_TAG_string_type, however, no producer that we know
16531 of make use of these. Handling bit sizes that are a multiple of the
16532 byte size is easy enough, but what about other bit sizes? Lets deal
16533 with that problem when we have to. Warn about these attributes being
16534 unsupported, then parse the type and ignore them like we always
16536 if (dwarf2_attr (die
, DW_AT_bit_size
, cu
) != nullptr
16537 || dwarf2_attr (die
, DW_AT_string_length_bit_size
, cu
) != nullptr)
16539 static bool warning_printed
= false;
16540 if (!warning_printed
)
16542 warning (_("DW_AT_bit_size and DW_AT_string_length_bit_size not "
16543 "currently supported on DW_TAG_string_type."));
16544 warning_printed
= true;
16548 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
16549 if (attr
!= nullptr && !attr
->form_is_constant ())
16551 /* The string length describes the location at which the length of
16552 the string can be found. The size of the length field can be
16553 specified with one of the attributes below. */
16554 struct type
*prop_type
;
16555 struct attribute
*len
16556 = dwarf2_attr (die
, DW_AT_string_length_byte_size
, cu
);
16557 if (len
== nullptr)
16558 len
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16559 if (len
!= nullptr && len
->form_is_constant ())
16561 /* Pass 0 as the default as we know this attribute is constant
16562 and the default value will not be returned. */
16563 LONGEST sz
= dwarf2_get_attr_constant_value (len
, 0);
16564 prop_type
= cu
->per_cu
->int_type (sz
, true);
16568 /* If the size is not specified then we assume it is the size of
16569 an address on this target. */
16570 prop_type
= cu
->per_cu
->addr_sized_int_type (true);
16573 /* Convert the attribute into a dynamic property. */
16574 if (!attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
16577 length_is_constant
= false;
16579 else if (attr
!= nullptr)
16581 /* This DW_AT_string_length just contains the length with no
16582 indirection. There's no need to create a dynamic property in this
16583 case. Pass 0 for the default value as we know it will not be
16584 returned in this case. */
16585 length
= dwarf2_get_attr_constant_value (attr
, 0);
16587 else if ((attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
)) != nullptr)
16589 /* We don't currently support non-constant byte sizes for strings. */
16590 length
= dwarf2_get_attr_constant_value (attr
, 1);
16594 /* Use 1 as a fallback length if we have nothing else. */
16598 index_type
= objfile_type (objfile
)->builtin_int
;
16599 if (length_is_constant
)
16600 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
16603 struct dynamic_prop low_bound
;
16605 low_bound
.kind
= PROP_CONST
;
16606 low_bound
.data
.const_val
= 1;
16607 range_type
= create_range_type (NULL
, index_type
, &low_bound
, &prop
, 0);
16609 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
16610 type
= create_string_type (NULL
, char_type
, range_type
);
16612 return set_die_type (die
, type
, cu
);
16615 /* Assuming that DIE corresponds to a function, returns nonzero
16616 if the function is prototyped. */
16619 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
16621 struct attribute
*attr
;
16623 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
16624 if (attr
&& (DW_UNSND (attr
) != 0))
16627 /* The DWARF standard implies that the DW_AT_prototyped attribute
16628 is only meaningful for C, but the concept also extends to other
16629 languages that allow unprototyped functions (Eg: Objective C).
16630 For all other languages, assume that functions are always
16632 if (cu
->language
!= language_c
16633 && cu
->language
!= language_objc
16634 && cu
->language
!= language_opencl
)
16637 /* RealView does not emit DW_AT_prototyped. We can not distinguish
16638 prototyped and unprototyped functions; default to prototyped,
16639 since that is more common in modern code (and RealView warns
16640 about unprototyped functions). */
16641 if (producer_is_realview (cu
->producer
))
16647 /* Handle DIES due to C code like:
16651 int (*funcp)(int a, long l);
16655 ('funcp' generates a DW_TAG_subroutine_type DIE). */
16657 static struct type
*
16658 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16660 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16661 struct type
*type
; /* Type that this function returns. */
16662 struct type
*ftype
; /* Function that returns above type. */
16663 struct attribute
*attr
;
16665 type
= die_type (die
, cu
);
16667 /* The die_type call above may have already set the type for this DIE. */
16668 ftype
= get_die_type (die
, cu
);
16672 ftype
= lookup_function_type (type
);
16674 if (prototyped_function_p (die
, cu
))
16675 TYPE_PROTOTYPED (ftype
) = 1;
16677 /* Store the calling convention in the type if it's available in
16678 the subroutine die. Otherwise set the calling convention to
16679 the default value DW_CC_normal. */
16680 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
16681 if (attr
!= nullptr
16682 && is_valid_DW_AT_calling_convention_for_subroutine (DW_UNSND (attr
)))
16683 TYPE_CALLING_CONVENTION (ftype
)
16684 = (enum dwarf_calling_convention
) (DW_UNSND (attr
));
16685 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
16686 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
16688 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
16690 /* Record whether the function returns normally to its caller or not
16691 if the DWARF producer set that information. */
16692 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
16693 if (attr
&& (DW_UNSND (attr
) != 0))
16694 TYPE_NO_RETURN (ftype
) = 1;
16696 /* We need to add the subroutine type to the die immediately so
16697 we don't infinitely recurse when dealing with parameters
16698 declared as the same subroutine type. */
16699 set_die_type (die
, ftype
, cu
);
16701 if (die
->child
!= NULL
)
16703 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
16704 struct die_info
*child_die
;
16705 int nparams
, iparams
;
16707 /* Count the number of parameters.
16708 FIXME: GDB currently ignores vararg functions, but knows about
16709 vararg member functions. */
16711 child_die
= die
->child
;
16712 while (child_die
&& child_die
->tag
)
16714 if (child_die
->tag
== DW_TAG_formal_parameter
)
16716 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
16717 TYPE_VARARGS (ftype
) = 1;
16718 child_die
= sibling_die (child_die
);
16721 /* Allocate storage for parameters and fill them in. */
16722 TYPE_NFIELDS (ftype
) = nparams
;
16723 TYPE_FIELDS (ftype
) = (struct field
*)
16724 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
16726 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
16727 even if we error out during the parameters reading below. */
16728 for (iparams
= 0; iparams
< nparams
; iparams
++)
16729 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
16732 child_die
= die
->child
;
16733 while (child_die
&& child_die
->tag
)
16735 if (child_die
->tag
== DW_TAG_formal_parameter
)
16737 struct type
*arg_type
;
16739 /* DWARF version 2 has no clean way to discern C++
16740 static and non-static member functions. G++ helps
16741 GDB by marking the first parameter for non-static
16742 member functions (which is the this pointer) as
16743 artificial. We pass this information to
16744 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
16746 DWARF version 3 added DW_AT_object_pointer, which GCC
16747 4.5 does not yet generate. */
16748 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
16749 if (attr
!= nullptr)
16750 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
16752 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
16753 arg_type
= die_type (child_die
, cu
);
16755 /* RealView does not mark THIS as const, which the testsuite
16756 expects. GCC marks THIS as const in method definitions,
16757 but not in the class specifications (GCC PR 43053). */
16758 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
16759 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
16762 struct dwarf2_cu
*arg_cu
= cu
;
16763 const char *name
= dwarf2_name (child_die
, cu
);
16765 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
16766 if (attr
!= nullptr)
16768 /* If the compiler emits this, use it. */
16769 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
16772 else if (name
&& strcmp (name
, "this") == 0)
16773 /* Function definitions will have the argument names. */
16775 else if (name
== NULL
&& iparams
== 0)
16776 /* Declarations may not have the names, so like
16777 elsewhere in GDB, assume an artificial first
16778 argument is "this". */
16782 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
16786 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
16789 child_die
= sibling_die (child_die
);
16796 static struct type
*
16797 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
16799 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16800 const char *name
= NULL
;
16801 struct type
*this_type
, *target_type
;
16803 name
= dwarf2_full_name (NULL
, die
, cu
);
16804 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
16805 TYPE_TARGET_STUB (this_type
) = 1;
16806 set_die_type (die
, this_type
, cu
);
16807 target_type
= die_type (die
, cu
);
16808 if (target_type
!= this_type
)
16809 TYPE_TARGET_TYPE (this_type
) = target_type
;
16812 /* Self-referential typedefs are, it seems, not allowed by the DWARF
16813 spec and cause infinite loops in GDB. */
16814 complaint (_("Self-referential DW_TAG_typedef "
16815 "- DIE at %s [in module %s]"),
16816 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
16817 TYPE_TARGET_TYPE (this_type
) = NULL
;
16822 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
16823 (which may be different from NAME) to the architecture back-end to allow
16824 it to guess the correct format if necessary. */
16826 static struct type
*
16827 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
16828 const char *name_hint
, enum bfd_endian byte_order
)
16830 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16831 const struct floatformat
**format
;
16834 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
16836 type
= init_float_type (objfile
, bits
, name
, format
, byte_order
);
16838 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
16843 /* Allocate an integer type of size BITS and name NAME. */
16845 static struct type
*
16846 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
16847 int bits
, int unsigned_p
, const char *name
)
16851 /* Versions of Intel's C Compiler generate an integer type called "void"
16852 instead of using DW_TAG_unspecified_type. This has been seen on
16853 at least versions 14, 17, and 18. */
16854 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
16855 && strcmp (name
, "void") == 0)
16856 type
= objfile_type (objfile
)->builtin_void
;
16858 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
16863 /* Initialise and return a floating point type of size BITS suitable for
16864 use as a component of a complex number. The NAME_HINT is passed through
16865 when initialising the floating point type and is the name of the complex
16868 As DWARF doesn't currently provide an explicit name for the components
16869 of a complex number, but it can be helpful to have these components
16870 named, we try to select a suitable name based on the size of the
16872 static struct type
*
16873 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
16874 struct objfile
*objfile
,
16875 int bits
, const char *name_hint
,
16876 enum bfd_endian byte_order
)
16878 gdbarch
*gdbarch
= get_objfile_arch (objfile
);
16879 struct type
*tt
= nullptr;
16881 /* Try to find a suitable floating point builtin type of size BITS.
16882 We're going to use the name of this type as the name for the complex
16883 target type that we are about to create. */
16884 switch (cu
->language
)
16886 case language_fortran
:
16890 tt
= builtin_f_type (gdbarch
)->builtin_real
;
16893 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
16895 case 96: /* The x86-32 ABI specifies 96-bit long double. */
16897 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
16905 tt
= builtin_type (gdbarch
)->builtin_float
;
16908 tt
= builtin_type (gdbarch
)->builtin_double
;
16910 case 96: /* The x86-32 ABI specifies 96-bit long double. */
16912 tt
= builtin_type (gdbarch
)->builtin_long_double
;
16918 /* If the type we found doesn't match the size we were looking for, then
16919 pretend we didn't find a type at all, the complex target type we
16920 create will then be nameless. */
16921 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
16924 const char *name
= (tt
== nullptr) ? nullptr : TYPE_NAME (tt
);
16925 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
, byte_order
);
16928 /* Find a representation of a given base type and install
16929 it in the TYPE field of the die. */
16931 static struct type
*
16932 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16934 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16936 struct attribute
*attr
;
16937 int encoding
= 0, bits
= 0;
16941 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
16942 if (attr
!= nullptr)
16943 encoding
= DW_UNSND (attr
);
16944 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16945 if (attr
!= nullptr)
16946 bits
= DW_UNSND (attr
) * TARGET_CHAR_BIT
;
16947 name
= dwarf2_name (die
, cu
);
16949 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
16951 arch
= get_objfile_arch (objfile
);
16952 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
16954 attr
= dwarf2_attr (die
, DW_AT_endianity
, cu
);
16957 int endianity
= DW_UNSND (attr
);
16962 byte_order
= BFD_ENDIAN_BIG
;
16964 case DW_END_little
:
16965 byte_order
= BFD_ENDIAN_LITTLE
;
16968 complaint (_("DW_AT_endianity has unrecognized value %d"), endianity
);
16975 case DW_ATE_address
:
16976 /* Turn DW_ATE_address into a void * pointer. */
16977 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
16978 type
= init_pointer_type (objfile
, bits
, name
, type
);
16980 case DW_ATE_boolean
:
16981 type
= init_boolean_type (objfile
, bits
, 1, name
);
16983 case DW_ATE_complex_float
:
16984 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
,
16986 type
= init_complex_type (objfile
, name
, type
);
16988 case DW_ATE_decimal_float
:
16989 type
= init_decfloat_type (objfile
, bits
, name
);
16992 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
, byte_order
);
16994 case DW_ATE_signed
:
16995 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
16997 case DW_ATE_unsigned
:
16998 if (cu
->language
== language_fortran
17000 && startswith (name
, "character("))
17001 type
= init_character_type (objfile
, bits
, 1, name
);
17003 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17005 case DW_ATE_signed_char
:
17006 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17007 || cu
->language
== language_pascal
17008 || cu
->language
== language_fortran
)
17009 type
= init_character_type (objfile
, bits
, 0, name
);
17011 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
17013 case DW_ATE_unsigned_char
:
17014 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17015 || cu
->language
== language_pascal
17016 || cu
->language
== language_fortran
17017 || cu
->language
== language_rust
)
17018 type
= init_character_type (objfile
, bits
, 1, name
);
17020 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17025 type
= builtin_type (arch
)->builtin_char16
;
17026 else if (bits
== 32)
17027 type
= builtin_type (arch
)->builtin_char32
;
17030 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17032 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17034 return set_die_type (die
, type
, cu
);
17039 complaint (_("unsupported DW_AT_encoding: '%s'"),
17040 dwarf_type_encoding_name (encoding
));
17041 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17045 if (name
&& strcmp (name
, "char") == 0)
17046 TYPE_NOSIGN (type
) = 1;
17048 maybe_set_alignment (cu
, die
, type
);
17050 TYPE_ENDIANITY_NOT_DEFAULT (type
) = gdbarch_byte_order (arch
) != byte_order
;
17052 return set_die_type (die
, type
, cu
);
17055 /* Parse dwarf attribute if it's a block, reference or constant and put the
17056 resulting value of the attribute into struct bound_prop.
17057 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17060 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
17061 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
17062 struct type
*default_type
)
17064 struct dwarf2_property_baton
*baton
;
17065 struct obstack
*obstack
17066 = &cu
->per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
;
17068 gdb_assert (default_type
!= NULL
);
17070 if (attr
== NULL
|| prop
== NULL
)
17073 if (attr
->form_is_block ())
17075 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17076 baton
->property_type
= default_type
;
17077 baton
->locexpr
.per_cu
= cu
->per_cu
;
17078 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
17079 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
17080 switch (attr
->name
)
17082 case DW_AT_string_length
:
17083 baton
->locexpr
.is_reference
= true;
17086 baton
->locexpr
.is_reference
= false;
17089 prop
->data
.baton
= baton
;
17090 prop
->kind
= PROP_LOCEXPR
;
17091 gdb_assert (prop
->data
.baton
!= NULL
);
17093 else if (attr
->form_is_ref ())
17095 struct dwarf2_cu
*target_cu
= cu
;
17096 struct die_info
*target_die
;
17097 struct attribute
*target_attr
;
17099 target_die
= follow_die_ref (die
, attr
, &target_cu
);
17100 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
17101 if (target_attr
== NULL
)
17102 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
17104 if (target_attr
== NULL
)
17107 switch (target_attr
->name
)
17109 case DW_AT_location
:
17110 if (target_attr
->form_is_section_offset ())
17112 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17113 baton
->property_type
= die_type (target_die
, target_cu
);
17114 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
17115 prop
->data
.baton
= baton
;
17116 prop
->kind
= PROP_LOCLIST
;
17117 gdb_assert (prop
->data
.baton
!= NULL
);
17119 else if (target_attr
->form_is_block ())
17121 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17122 baton
->property_type
= die_type (target_die
, target_cu
);
17123 baton
->locexpr
.per_cu
= cu
->per_cu
;
17124 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
17125 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
17126 baton
->locexpr
.is_reference
= true;
17127 prop
->data
.baton
= baton
;
17128 prop
->kind
= PROP_LOCEXPR
;
17129 gdb_assert (prop
->data
.baton
!= NULL
);
17133 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17134 "dynamic property");
17138 case DW_AT_data_member_location
:
17142 if (!handle_data_member_location (target_die
, target_cu
,
17146 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17147 baton
->property_type
= read_type_die (target_die
->parent
,
17149 baton
->offset_info
.offset
= offset
;
17150 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
17151 prop
->data
.baton
= baton
;
17152 prop
->kind
= PROP_ADDR_OFFSET
;
17157 else if (attr
->form_is_constant ())
17159 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
17160 prop
->kind
= PROP_CONST
;
17164 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
17165 dwarf2_name (die
, cu
));
17175 dwarf2_per_cu_data::int_type (int size_in_bytes
, bool unsigned_p
) const
17177 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
17178 struct type
*int_type
;
17180 /* Helper macro to examine the various builtin types. */
17181 #define TRY_TYPE(F) \
17182 int_type = (unsigned_p \
17183 ? objfile_type (objfile)->builtin_unsigned_ ## F \
17184 : objfile_type (objfile)->builtin_ ## F); \
17185 if (int_type != NULL && TYPE_LENGTH (int_type) == size_in_bytes) \
17192 TRY_TYPE (long_long
);
17196 gdb_assert_not_reached ("unable to find suitable integer type");
17202 dwarf2_per_cu_data::addr_sized_int_type (bool unsigned_p
) const
17204 int addr_size
= this->addr_size ();
17205 return int_type (addr_size
, unsigned_p
);
17208 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
17209 present (which is valid) then compute the default type based on the
17210 compilation units address size. */
17212 static struct type
*
17213 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17215 struct type
*index_type
= die_type (die
, cu
);
17217 /* Dwarf-2 specifications explicitly allows to create subrange types
17218 without specifying a base type.
17219 In that case, the base type must be set to the type of
17220 the lower bound, upper bound or count, in that order, if any of these
17221 three attributes references an object that has a type.
17222 If no base type is found, the Dwarf-2 specifications say that
17223 a signed integer type of size equal to the size of an address should
17225 For the following C code: `extern char gdb_int [];'
17226 GCC produces an empty range DIE.
17227 FIXME: muller/2010-05-28: Possible references to object for low bound,
17228 high bound or count are not yet handled by this code. */
17229 if (TYPE_CODE (index_type
) == TYPE_CODE_VOID
)
17230 index_type
= cu
->per_cu
->addr_sized_int_type (false);
17235 /* Read the given DW_AT_subrange DIE. */
17237 static struct type
*
17238 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17240 struct type
*base_type
, *orig_base_type
;
17241 struct type
*range_type
;
17242 struct attribute
*attr
;
17243 struct dynamic_prop low
, high
;
17244 int low_default_is_valid
;
17245 int high_bound_is_count
= 0;
17247 ULONGEST negative_mask
;
17249 orig_base_type
= read_subrange_index_type (die
, cu
);
17251 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17252 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17253 creating the range type, but we use the result of check_typedef
17254 when examining properties of the type. */
17255 base_type
= check_typedef (orig_base_type
);
17257 /* The die_type call above may have already set the type for this DIE. */
17258 range_type
= get_die_type (die
, cu
);
17262 low
.kind
= PROP_CONST
;
17263 high
.kind
= PROP_CONST
;
17264 high
.data
.const_val
= 0;
17266 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17267 omitting DW_AT_lower_bound. */
17268 switch (cu
->language
)
17271 case language_cplus
:
17272 low
.data
.const_val
= 0;
17273 low_default_is_valid
= 1;
17275 case language_fortran
:
17276 low
.data
.const_val
= 1;
17277 low_default_is_valid
= 1;
17280 case language_objc
:
17281 case language_rust
:
17282 low
.data
.const_val
= 0;
17283 low_default_is_valid
= (cu
->header
.version
>= 4);
17287 case language_pascal
:
17288 low
.data
.const_val
= 1;
17289 low_default_is_valid
= (cu
->header
.version
>= 4);
17292 low
.data
.const_val
= 0;
17293 low_default_is_valid
= 0;
17297 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
17298 if (attr
!= nullptr)
17299 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
17300 else if (!low_default_is_valid
)
17301 complaint (_("Missing DW_AT_lower_bound "
17302 "- DIE at %s [in module %s]"),
17303 sect_offset_str (die
->sect_off
),
17304 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17306 struct attribute
*attr_ub
, *attr_count
;
17307 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
17308 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
17310 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
17311 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
17313 /* If bounds are constant do the final calculation here. */
17314 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
17315 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
17317 high_bound_is_count
= 1;
17321 if (attr_ub
!= NULL
)
17322 complaint (_("Unresolved DW_AT_upper_bound "
17323 "- DIE at %s [in module %s]"),
17324 sect_offset_str (die
->sect_off
),
17325 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17326 if (attr_count
!= NULL
)
17327 complaint (_("Unresolved DW_AT_count "
17328 "- DIE at %s [in module %s]"),
17329 sect_offset_str (die
->sect_off
),
17330 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17335 struct attribute
*bias_attr
= dwarf2_attr (die
, DW_AT_GNU_bias
, cu
);
17336 if (bias_attr
!= nullptr && bias_attr
->form_is_constant ())
17337 bias
= dwarf2_get_attr_constant_value (bias_attr
, 0);
17339 /* Normally, the DWARF producers are expected to use a signed
17340 constant form (Eg. DW_FORM_sdata) to express negative bounds.
17341 But this is unfortunately not always the case, as witnessed
17342 with GCC, for instance, where the ambiguous DW_FORM_dataN form
17343 is used instead. To work around that ambiguity, we treat
17344 the bounds as signed, and thus sign-extend their values, when
17345 the base type is signed. */
17347 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
17348 if (low
.kind
== PROP_CONST
17349 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
17350 low
.data
.const_val
|= negative_mask
;
17351 if (high
.kind
== PROP_CONST
17352 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
17353 high
.data
.const_val
|= negative_mask
;
17355 /* Check for bit and byte strides. */
17356 struct dynamic_prop byte_stride_prop
;
17357 attribute
*attr_byte_stride
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
17358 if (attr_byte_stride
!= nullptr)
17360 struct type
*prop_type
= cu
->per_cu
->addr_sized_int_type (false);
17361 attr_to_dynamic_prop (attr_byte_stride
, die
, cu
, &byte_stride_prop
,
17365 struct dynamic_prop bit_stride_prop
;
17366 attribute
*attr_bit_stride
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
17367 if (attr_bit_stride
!= nullptr)
17369 /* It only makes sense to have either a bit or byte stride. */
17370 if (attr_byte_stride
!= nullptr)
17372 complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
17373 "- DIE at %s [in module %s]"),
17374 sect_offset_str (die
->sect_off
),
17375 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17376 attr_bit_stride
= nullptr;
17380 struct type
*prop_type
= cu
->per_cu
->addr_sized_int_type (false);
17381 attr_to_dynamic_prop (attr_bit_stride
, die
, cu
, &bit_stride_prop
,
17386 if (attr_byte_stride
!= nullptr
17387 || attr_bit_stride
!= nullptr)
17389 bool byte_stride_p
= (attr_byte_stride
!= nullptr);
17390 struct dynamic_prop
*stride
17391 = byte_stride_p
? &byte_stride_prop
: &bit_stride_prop
;
17394 = create_range_type_with_stride (NULL
, orig_base_type
, &low
,
17395 &high
, bias
, stride
, byte_stride_p
);
17398 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
, bias
);
17400 if (high_bound_is_count
)
17401 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
17403 /* Ada expects an empty array on no boundary attributes. */
17404 if (attr
== NULL
&& cu
->language
!= language_ada
)
17405 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
17407 name
= dwarf2_name (die
, cu
);
17409 TYPE_NAME (range_type
) = name
;
17411 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17412 if (attr
!= nullptr)
17413 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
17415 maybe_set_alignment (cu
, die
, range_type
);
17417 set_die_type (die
, range_type
, cu
);
17419 /* set_die_type should be already done. */
17420 set_descriptive_type (range_type
, die
, cu
);
17425 static struct type
*
17426 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17430 type
= init_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
, TYPE_CODE_VOID
,0,
17432 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
17434 /* In Ada, an unspecified type is typically used when the description
17435 of the type is deferred to a different unit. When encountering
17436 such a type, we treat it as a stub, and try to resolve it later on,
17438 if (cu
->language
== language_ada
)
17439 TYPE_STUB (type
) = 1;
17441 return set_die_type (die
, type
, cu
);
17444 /* Read a single die and all its descendents. Set the die's sibling
17445 field to NULL; set other fields in the die correctly, and set all
17446 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
17447 location of the info_ptr after reading all of those dies. PARENT
17448 is the parent of the die in question. */
17450 static struct die_info
*
17451 read_die_and_children (const struct die_reader_specs
*reader
,
17452 const gdb_byte
*info_ptr
,
17453 const gdb_byte
**new_info_ptr
,
17454 struct die_info
*parent
)
17456 struct die_info
*die
;
17457 const gdb_byte
*cur_ptr
;
17459 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, 0);
17462 *new_info_ptr
= cur_ptr
;
17465 store_in_ref_table (die
, reader
->cu
);
17467 if (die
->has_children
)
17468 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
17472 *new_info_ptr
= cur_ptr
;
17475 die
->sibling
= NULL
;
17476 die
->parent
= parent
;
17480 /* Read a die, all of its descendents, and all of its siblings; set
17481 all of the fields of all of the dies correctly. Arguments are as
17482 in read_die_and_children. */
17484 static struct die_info
*
17485 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
17486 const gdb_byte
*info_ptr
,
17487 const gdb_byte
**new_info_ptr
,
17488 struct die_info
*parent
)
17490 struct die_info
*first_die
, *last_sibling
;
17491 const gdb_byte
*cur_ptr
;
17493 cur_ptr
= info_ptr
;
17494 first_die
= last_sibling
= NULL
;
17498 struct die_info
*die
17499 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
17503 *new_info_ptr
= cur_ptr
;
17510 last_sibling
->sibling
= die
;
17512 last_sibling
= die
;
17516 /* Read a die, all of its descendents, and all of its siblings; set
17517 all of the fields of all of the dies correctly. Arguments are as
17518 in read_die_and_children.
17519 This the main entry point for reading a DIE and all its children. */
17521 static struct die_info
*
17522 read_die_and_siblings (const struct die_reader_specs
*reader
,
17523 const gdb_byte
*info_ptr
,
17524 const gdb_byte
**new_info_ptr
,
17525 struct die_info
*parent
)
17527 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
17528 new_info_ptr
, parent
);
17530 if (dwarf_die_debug
)
17532 fprintf_unfiltered (gdb_stdlog
,
17533 "Read die from %s@0x%x of %s:\n",
17534 reader
->die_section
->get_name (),
17535 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
17536 bfd_get_filename (reader
->abfd
));
17537 dump_die (die
, dwarf_die_debug
);
17543 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
17545 The caller is responsible for filling in the extra attributes
17546 and updating (*DIEP)->num_attrs.
17547 Set DIEP to point to a newly allocated die with its information,
17548 except for its child, sibling, and parent fields. */
17550 static const gdb_byte
*
17551 read_full_die_1 (const struct die_reader_specs
*reader
,
17552 struct die_info
**diep
, const gdb_byte
*info_ptr
,
17553 int num_extra_attrs
)
17555 unsigned int abbrev_number
, bytes_read
, i
;
17556 struct abbrev_info
*abbrev
;
17557 struct die_info
*die
;
17558 struct dwarf2_cu
*cu
= reader
->cu
;
17559 bfd
*abfd
= reader
->abfd
;
17561 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
17562 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
17563 info_ptr
+= bytes_read
;
17564 if (!abbrev_number
)
17570 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
17572 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
17574 bfd_get_filename (abfd
));
17576 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
17577 die
->sect_off
= sect_off
;
17578 die
->tag
= abbrev
->tag
;
17579 die
->abbrev
= abbrev_number
;
17580 die
->has_children
= abbrev
->has_children
;
17582 /* Make the result usable.
17583 The caller needs to update num_attrs after adding the extra
17585 die
->num_attrs
= abbrev
->num_attrs
;
17587 std::vector
<int> indexes_that_need_reprocess
;
17588 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
17590 bool need_reprocess
;
17592 read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
17593 info_ptr
, &need_reprocess
);
17594 if (need_reprocess
)
17595 indexes_that_need_reprocess
.push_back (i
);
17598 struct attribute
*attr
= dwarf2_attr_no_follow (die
, DW_AT_str_offsets_base
);
17599 if (attr
!= nullptr)
17600 cu
->str_offsets_base
= DW_UNSND (attr
);
17602 auto maybe_addr_base
= lookup_addr_base(die
);
17603 if (maybe_addr_base
.has_value ())
17604 cu
->addr_base
= *maybe_addr_base
;
17605 for (int index
: indexes_that_need_reprocess
)
17606 read_attribute_reprocess (reader
, &die
->attrs
[index
]);
17611 /* Read a die and all its attributes.
17612 Set DIEP to point to a newly allocated die with its information,
17613 except for its child, sibling, and parent fields. */
17615 static const gdb_byte
*
17616 read_full_die (const struct die_reader_specs
*reader
,
17617 struct die_info
**diep
, const gdb_byte
*info_ptr
)
17619 const gdb_byte
*result
;
17621 result
= read_full_die_1 (reader
, diep
, info_ptr
, 0);
17623 if (dwarf_die_debug
)
17625 fprintf_unfiltered (gdb_stdlog
,
17626 "Read die from %s@0x%x of %s:\n",
17627 reader
->die_section
->get_name (),
17628 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
17629 bfd_get_filename (reader
->abfd
));
17630 dump_die (*diep
, dwarf_die_debug
);
17637 /* Returns nonzero if TAG represents a type that we might generate a partial
17641 is_type_tag_for_partial (int tag
)
17646 /* Some types that would be reasonable to generate partial symbols for,
17647 that we don't at present. */
17648 case DW_TAG_array_type
:
17649 case DW_TAG_file_type
:
17650 case DW_TAG_ptr_to_member_type
:
17651 case DW_TAG_set_type
:
17652 case DW_TAG_string_type
:
17653 case DW_TAG_subroutine_type
:
17655 case DW_TAG_base_type
:
17656 case DW_TAG_class_type
:
17657 case DW_TAG_interface_type
:
17658 case DW_TAG_enumeration_type
:
17659 case DW_TAG_structure_type
:
17660 case DW_TAG_subrange_type
:
17661 case DW_TAG_typedef
:
17662 case DW_TAG_union_type
:
17669 /* Load all DIEs that are interesting for partial symbols into memory. */
17671 static struct partial_die_info
*
17672 load_partial_dies (const struct die_reader_specs
*reader
,
17673 const gdb_byte
*info_ptr
, int building_psymtab
)
17675 struct dwarf2_cu
*cu
= reader
->cu
;
17676 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17677 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
17678 unsigned int bytes_read
;
17679 unsigned int load_all
= 0;
17680 int nesting_level
= 1;
17685 gdb_assert (cu
->per_cu
!= NULL
);
17686 if (cu
->per_cu
->load_all_dies
)
17690 = htab_create_alloc_ex (cu
->header
.length
/ 12,
17694 &cu
->comp_unit_obstack
,
17695 hashtab_obstack_allocate
,
17696 dummy_obstack_deallocate
);
17700 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
17702 /* A NULL abbrev means the end of a series of children. */
17703 if (abbrev
== NULL
)
17705 if (--nesting_level
== 0)
17708 info_ptr
+= bytes_read
;
17709 last_die
= parent_die
;
17710 parent_die
= parent_die
->die_parent
;
17714 /* Check for template arguments. We never save these; if
17715 they're seen, we just mark the parent, and go on our way. */
17716 if (parent_die
!= NULL
17717 && cu
->language
== language_cplus
17718 && (abbrev
->tag
== DW_TAG_template_type_param
17719 || abbrev
->tag
== DW_TAG_template_value_param
))
17721 parent_die
->has_template_arguments
= 1;
17725 /* We don't need a partial DIE for the template argument. */
17726 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
17731 /* We only recurse into c++ subprograms looking for template arguments.
17732 Skip their other children. */
17734 && cu
->language
== language_cplus
17735 && parent_die
!= NULL
17736 && parent_die
->tag
== DW_TAG_subprogram
)
17738 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
17742 /* Check whether this DIE is interesting enough to save. Normally
17743 we would not be interested in members here, but there may be
17744 later variables referencing them via DW_AT_specification (for
17745 static members). */
17747 && !is_type_tag_for_partial (abbrev
->tag
)
17748 && abbrev
->tag
!= DW_TAG_constant
17749 && abbrev
->tag
!= DW_TAG_enumerator
17750 && abbrev
->tag
!= DW_TAG_subprogram
17751 && abbrev
->tag
!= DW_TAG_inlined_subroutine
17752 && abbrev
->tag
!= DW_TAG_lexical_block
17753 && abbrev
->tag
!= DW_TAG_variable
17754 && abbrev
->tag
!= DW_TAG_namespace
17755 && abbrev
->tag
!= DW_TAG_module
17756 && abbrev
->tag
!= DW_TAG_member
17757 && abbrev
->tag
!= DW_TAG_imported_unit
17758 && abbrev
->tag
!= DW_TAG_imported_declaration
)
17760 /* Otherwise we skip to the next sibling, if any. */
17761 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
17765 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
17768 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
17770 /* This two-pass algorithm for processing partial symbols has a
17771 high cost in cache pressure. Thus, handle some simple cases
17772 here which cover the majority of C partial symbols. DIEs
17773 which neither have specification tags in them, nor could have
17774 specification tags elsewhere pointing at them, can simply be
17775 processed and discarded.
17777 This segment is also optional; scan_partial_symbols and
17778 add_partial_symbol will handle these DIEs if we chain
17779 them in normally. When compilers which do not emit large
17780 quantities of duplicate debug information are more common,
17781 this code can probably be removed. */
17783 /* Any complete simple types at the top level (pretty much all
17784 of them, for a language without namespaces), can be processed
17786 if (parent_die
== NULL
17787 && pdi
.has_specification
== 0
17788 && pdi
.is_declaration
== 0
17789 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
17790 || pdi
.tag
== DW_TAG_base_type
17791 || pdi
.tag
== DW_TAG_subrange_type
))
17793 if (building_psymtab
&& pdi
.name
!= NULL
)
17794 add_psymbol_to_list (pdi
.name
, false,
17795 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
17796 psymbol_placement::STATIC
,
17797 0, cu
->language
, objfile
);
17798 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
17802 /* The exception for DW_TAG_typedef with has_children above is
17803 a workaround of GCC PR debug/47510. In the case of this complaint
17804 type_name_or_error will error on such types later.
17806 GDB skipped children of DW_TAG_typedef by the shortcut above and then
17807 it could not find the child DIEs referenced later, this is checked
17808 above. In correct DWARF DW_TAG_typedef should have no children. */
17810 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
17811 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
17812 "- DIE at %s [in module %s]"),
17813 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
17815 /* If we're at the second level, and we're an enumerator, and
17816 our parent has no specification (meaning possibly lives in a
17817 namespace elsewhere), then we can add the partial symbol now
17818 instead of queueing it. */
17819 if (pdi
.tag
== DW_TAG_enumerator
17820 && parent_die
!= NULL
17821 && parent_die
->die_parent
== NULL
17822 && parent_die
->tag
== DW_TAG_enumeration_type
17823 && parent_die
->has_specification
== 0)
17825 if (pdi
.name
== NULL
)
17826 complaint (_("malformed enumerator DIE ignored"));
17827 else if (building_psymtab
)
17828 add_psymbol_to_list (pdi
.name
, false,
17829 VAR_DOMAIN
, LOC_CONST
, -1,
17830 cu
->language
== language_cplus
17831 ? psymbol_placement::GLOBAL
17832 : psymbol_placement::STATIC
,
17833 0, cu
->language
, objfile
);
17835 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
17839 struct partial_die_info
*part_die
17840 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
17842 /* We'll save this DIE so link it in. */
17843 part_die
->die_parent
= parent_die
;
17844 part_die
->die_sibling
= NULL
;
17845 part_die
->die_child
= NULL
;
17847 if (last_die
&& last_die
== parent_die
)
17848 last_die
->die_child
= part_die
;
17850 last_die
->die_sibling
= part_die
;
17852 last_die
= part_die
;
17854 if (first_die
== NULL
)
17855 first_die
= part_die
;
17857 /* Maybe add the DIE to the hash table. Not all DIEs that we
17858 find interesting need to be in the hash table, because we
17859 also have the parent/sibling/child chains; only those that we
17860 might refer to by offset later during partial symbol reading.
17862 For now this means things that might have be the target of a
17863 DW_AT_specification, DW_AT_abstract_origin, or
17864 DW_AT_extension. DW_AT_extension will refer only to
17865 namespaces; DW_AT_abstract_origin refers to functions (and
17866 many things under the function DIE, but we do not recurse
17867 into function DIEs during partial symbol reading) and
17868 possibly variables as well; DW_AT_specification refers to
17869 declarations. Declarations ought to have the DW_AT_declaration
17870 flag. It happens that GCC forgets to put it in sometimes, but
17871 only for functions, not for types.
17873 Adding more things than necessary to the hash table is harmless
17874 except for the performance cost. Adding too few will result in
17875 wasted time in find_partial_die, when we reread the compilation
17876 unit with load_all_dies set. */
17879 || abbrev
->tag
== DW_TAG_constant
17880 || abbrev
->tag
== DW_TAG_subprogram
17881 || abbrev
->tag
== DW_TAG_variable
17882 || abbrev
->tag
== DW_TAG_namespace
17883 || part_die
->is_declaration
)
17887 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
17888 to_underlying (part_die
->sect_off
),
17893 /* For some DIEs we want to follow their children (if any). For C
17894 we have no reason to follow the children of structures; for other
17895 languages we have to, so that we can get at method physnames
17896 to infer fully qualified class names, for DW_AT_specification,
17897 and for C++ template arguments. For C++, we also look one level
17898 inside functions to find template arguments (if the name of the
17899 function does not already contain the template arguments).
17901 For Ada and Fortran, we need to scan the children of subprograms
17902 and lexical blocks as well because these languages allow the
17903 definition of nested entities that could be interesting for the
17904 debugger, such as nested subprograms for instance. */
17905 if (last_die
->has_children
17907 || last_die
->tag
== DW_TAG_namespace
17908 || last_die
->tag
== DW_TAG_module
17909 || last_die
->tag
== DW_TAG_enumeration_type
17910 || (cu
->language
== language_cplus
17911 && last_die
->tag
== DW_TAG_subprogram
17912 && (last_die
->name
== NULL
17913 || strchr (last_die
->name
, '<') == NULL
))
17914 || (cu
->language
!= language_c
17915 && (last_die
->tag
== DW_TAG_class_type
17916 || last_die
->tag
== DW_TAG_interface_type
17917 || last_die
->tag
== DW_TAG_structure_type
17918 || last_die
->tag
== DW_TAG_union_type
))
17919 || ((cu
->language
== language_ada
17920 || cu
->language
== language_fortran
)
17921 && (last_die
->tag
== DW_TAG_subprogram
17922 || last_die
->tag
== DW_TAG_lexical_block
))))
17925 parent_die
= last_die
;
17929 /* Otherwise we skip to the next sibling, if any. */
17930 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
17932 /* Back to the top, do it again. */
17936 partial_die_info::partial_die_info (sect_offset sect_off_
,
17937 struct abbrev_info
*abbrev
)
17938 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
17942 /* Read a minimal amount of information into the minimal die structure.
17943 INFO_PTR should point just after the initial uleb128 of a DIE. */
17946 partial_die_info::read (const struct die_reader_specs
*reader
,
17947 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
17949 struct dwarf2_cu
*cu
= reader
->cu
;
17950 struct dwarf2_per_objfile
*dwarf2_per_objfile
17951 = cu
->per_cu
->dwarf2_per_objfile
;
17953 int has_low_pc_attr
= 0;
17954 int has_high_pc_attr
= 0;
17955 int high_pc_relative
= 0;
17957 std::vector
<struct attribute
> attr_vec (abbrev
.num_attrs
);
17958 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
17960 bool need_reprocess
;
17961 info_ptr
= read_attribute (reader
, &attr_vec
[i
], &abbrev
.attrs
[i
],
17962 info_ptr
, &need_reprocess
);
17963 /* String and address offsets that need to do the reprocessing have
17964 already been read at this point, so there is no need to wait until
17965 the loop terminates to do the reprocessing. */
17966 if (need_reprocess
)
17967 read_attribute_reprocess (reader
, &attr_vec
[i
]);
17968 attribute
&attr
= attr_vec
[i
];
17969 /* Store the data if it is of an attribute we want to keep in a
17970 partial symbol table. */
17976 case DW_TAG_compile_unit
:
17977 case DW_TAG_partial_unit
:
17978 case DW_TAG_type_unit
:
17979 /* Compilation units have a DW_AT_name that is a filename, not
17980 a source language identifier. */
17981 case DW_TAG_enumeration_type
:
17982 case DW_TAG_enumerator
:
17983 /* These tags always have simple identifiers already; no need
17984 to canonicalize them. */
17985 name
= DW_STRING (&attr
);
17989 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
17992 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
, objfile
);
17997 case DW_AT_linkage_name
:
17998 case DW_AT_MIPS_linkage_name
:
17999 /* Note that both forms of linkage name might appear. We
18000 assume they will be the same, and we only store the last
18002 linkage_name
= DW_STRING (&attr
);
18005 has_low_pc_attr
= 1;
18006 lowpc
= attr
.value_as_address ();
18008 case DW_AT_high_pc
:
18009 has_high_pc_attr
= 1;
18010 highpc
= attr
.value_as_address ();
18011 if (cu
->header
.version
>= 4 && attr
.form_is_constant ())
18012 high_pc_relative
= 1;
18014 case DW_AT_location
:
18015 /* Support the .debug_loc offsets. */
18016 if (attr
.form_is_block ())
18018 d
.locdesc
= DW_BLOCK (&attr
);
18020 else if (attr
.form_is_section_offset ())
18022 dwarf2_complex_location_expr_complaint ();
18026 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18027 "partial symbol information");
18030 case DW_AT_external
:
18031 is_external
= DW_UNSND (&attr
);
18033 case DW_AT_declaration
:
18034 is_declaration
= DW_UNSND (&attr
);
18039 case DW_AT_abstract_origin
:
18040 case DW_AT_specification
:
18041 case DW_AT_extension
:
18042 has_specification
= 1;
18043 spec_offset
= dwarf2_get_ref_die_offset (&attr
);
18044 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
18045 || cu
->per_cu
->is_dwz
);
18047 case DW_AT_sibling
:
18048 /* Ignore absolute siblings, they might point outside of
18049 the current compile unit. */
18050 if (attr
.form
== DW_FORM_ref_addr
)
18051 complaint (_("ignoring absolute DW_AT_sibling"));
18054 const gdb_byte
*buffer
= reader
->buffer
;
18055 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
18056 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
18058 if (sibling_ptr
< info_ptr
)
18059 complaint (_("DW_AT_sibling points backwards"));
18060 else if (sibling_ptr
> reader
->buffer_end
)
18061 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
18063 sibling
= sibling_ptr
;
18066 case DW_AT_byte_size
:
18069 case DW_AT_const_value
:
18070 has_const_value
= 1;
18072 case DW_AT_calling_convention
:
18073 /* DWARF doesn't provide a way to identify a program's source-level
18074 entry point. DW_AT_calling_convention attributes are only meant
18075 to describe functions' calling conventions.
18077 However, because it's a necessary piece of information in
18078 Fortran, and before DWARF 4 DW_CC_program was the only
18079 piece of debugging information whose definition refers to
18080 a 'main program' at all, several compilers marked Fortran
18081 main programs with DW_CC_program --- even when those
18082 functions use the standard calling conventions.
18084 Although DWARF now specifies a way to provide this
18085 information, we support this practice for backward
18087 if (DW_UNSND (&attr
) == DW_CC_program
18088 && cu
->language
== language_fortran
)
18089 main_subprogram
= 1;
18092 if (DW_UNSND (&attr
) == DW_INL_inlined
18093 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
18094 may_be_inlined
= 1;
18098 if (tag
== DW_TAG_imported_unit
)
18100 d
.sect_off
= dwarf2_get_ref_die_offset (&attr
);
18101 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
18102 || cu
->per_cu
->is_dwz
);
18106 case DW_AT_main_subprogram
:
18107 main_subprogram
= DW_UNSND (&attr
);
18112 /* It would be nice to reuse dwarf2_get_pc_bounds here,
18113 but that requires a full DIE, so instead we just
18115 int need_ranges_base
= tag
!= DW_TAG_compile_unit
;
18116 unsigned int ranges_offset
= (DW_UNSND (&attr
)
18117 + (need_ranges_base
18121 /* Value of the DW_AT_ranges attribute is the offset in the
18122 .debug_ranges section. */
18123 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
18134 /* For Ada, if both the name and the linkage name appear, we prefer
18135 the latter. This lets "catch exception" work better, regardless
18136 of the order in which the name and linkage name were emitted.
18137 Really, though, this is just a workaround for the fact that gdb
18138 doesn't store both the name and the linkage name. */
18139 if (cu
->language
== language_ada
&& linkage_name
!= nullptr)
18140 name
= linkage_name
;
18142 if (high_pc_relative
)
18145 if (has_low_pc_attr
&& has_high_pc_attr
)
18147 /* When using the GNU linker, .gnu.linkonce. sections are used to
18148 eliminate duplicate copies of functions and vtables and such.
18149 The linker will arbitrarily choose one and discard the others.
18150 The AT_*_pc values for such functions refer to local labels in
18151 these sections. If the section from that file was discarded, the
18152 labels are not in the output, so the relocs get a value of 0.
18153 If this is a discarded function, mark the pc bounds as invalid,
18154 so that GDB will ignore it. */
18155 if (lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
18157 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18158 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18160 complaint (_("DW_AT_low_pc %s is zero "
18161 "for DIE at %s [in module %s]"),
18162 paddress (gdbarch
, lowpc
),
18163 sect_offset_str (sect_off
),
18164 objfile_name (objfile
));
18166 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18167 else if (lowpc
>= highpc
)
18169 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18170 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18172 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18173 "for DIE at %s [in module %s]"),
18174 paddress (gdbarch
, lowpc
),
18175 paddress (gdbarch
, highpc
),
18176 sect_offset_str (sect_off
),
18177 objfile_name (objfile
));
18186 /* Find a cached partial DIE at OFFSET in CU. */
18188 struct partial_die_info
*
18189 dwarf2_cu::find_partial_die (sect_offset sect_off
)
18191 struct partial_die_info
*lookup_die
= NULL
;
18192 struct partial_die_info
part_die (sect_off
);
18194 lookup_die
= ((struct partial_die_info
*)
18195 htab_find_with_hash (partial_dies
, &part_die
,
18196 to_underlying (sect_off
)));
18201 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18202 except in the case of .debug_types DIEs which do not reference
18203 outside their CU (they do however referencing other types via
18204 DW_FORM_ref_sig8). */
18206 static const struct cu_partial_die_info
18207 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
18209 struct dwarf2_per_objfile
*dwarf2_per_objfile
18210 = cu
->per_cu
->dwarf2_per_objfile
;
18211 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18212 struct dwarf2_per_cu_data
*per_cu
= NULL
;
18213 struct partial_die_info
*pd
= NULL
;
18215 if (offset_in_dwz
== cu
->per_cu
->is_dwz
18216 && cu
->header
.offset_in_cu_p (sect_off
))
18218 pd
= cu
->find_partial_die (sect_off
);
18221 /* We missed recording what we needed.
18222 Load all dies and try again. */
18223 per_cu
= cu
->per_cu
;
18227 /* TUs don't reference other CUs/TUs (except via type signatures). */
18228 if (cu
->per_cu
->is_debug_types
)
18230 error (_("Dwarf Error: Type Unit at offset %s contains"
18231 " external reference to offset %s [in module %s].\n"),
18232 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
18233 bfd_get_filename (objfile
->obfd
));
18235 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
18236 dwarf2_per_objfile
);
18238 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
18239 load_partial_comp_unit (per_cu
);
18241 per_cu
->cu
->last_used
= 0;
18242 pd
= per_cu
->cu
->find_partial_die (sect_off
);
18245 /* If we didn't find it, and not all dies have been loaded,
18246 load them all and try again. */
18248 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
18250 per_cu
->load_all_dies
= 1;
18252 /* This is nasty. When we reread the DIEs, somewhere up the call chain
18253 THIS_CU->cu may already be in use. So we can't just free it and
18254 replace its DIEs with the ones we read in. Instead, we leave those
18255 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18256 and clobber THIS_CU->cu->partial_dies with the hash table for the new
18258 load_partial_comp_unit (per_cu
);
18260 pd
= per_cu
->cu
->find_partial_die (sect_off
);
18264 internal_error (__FILE__
, __LINE__
,
18265 _("could not find partial DIE %s "
18266 "in cache [from module %s]\n"),
18267 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
18268 return { per_cu
->cu
, pd
};
18271 /* See if we can figure out if the class lives in a namespace. We do
18272 this by looking for a member function; its demangled name will
18273 contain namespace info, if there is any. */
18276 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
18277 struct dwarf2_cu
*cu
)
18279 /* NOTE: carlton/2003-10-07: Getting the info this way changes
18280 what template types look like, because the demangler
18281 frequently doesn't give the same name as the debug info. We
18282 could fix this by only using the demangled name to get the
18283 prefix (but see comment in read_structure_type). */
18285 struct partial_die_info
*real_pdi
;
18286 struct partial_die_info
*child_pdi
;
18288 /* If this DIE (this DIE's specification, if any) has a parent, then
18289 we should not do this. We'll prepend the parent's fully qualified
18290 name when we create the partial symbol. */
18292 real_pdi
= struct_pdi
;
18293 while (real_pdi
->has_specification
)
18295 auto res
= find_partial_die (real_pdi
->spec_offset
,
18296 real_pdi
->spec_is_dwz
, cu
);
18297 real_pdi
= res
.pdi
;
18301 if (real_pdi
->die_parent
!= NULL
)
18304 for (child_pdi
= struct_pdi
->die_child
;
18306 child_pdi
= child_pdi
->die_sibling
)
18308 if (child_pdi
->tag
== DW_TAG_subprogram
18309 && child_pdi
->linkage_name
!= NULL
)
18311 gdb::unique_xmalloc_ptr
<char> actual_class_name
18312 (language_class_name_from_physname (cu
->language_defn
,
18313 child_pdi
->linkage_name
));
18314 if (actual_class_name
!= NULL
)
18316 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
18317 struct_pdi
->name
= objfile
->intern (actual_class_name
.get ());
18325 partial_die_info::fixup (struct dwarf2_cu
*cu
)
18327 /* Once we've fixed up a die, there's no point in doing so again.
18328 This also avoids a memory leak if we were to call
18329 guess_partial_die_structure_name multiple times. */
18333 /* If we found a reference attribute and the DIE has no name, try
18334 to find a name in the referred to DIE. */
18336 if (name
== NULL
&& has_specification
)
18338 struct partial_die_info
*spec_die
;
18340 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
18341 spec_die
= res
.pdi
;
18344 spec_die
->fixup (cu
);
18346 if (spec_die
->name
)
18348 name
= spec_die
->name
;
18350 /* Copy DW_AT_external attribute if it is set. */
18351 if (spec_die
->is_external
)
18352 is_external
= spec_die
->is_external
;
18356 /* Set default names for some unnamed DIEs. */
18358 if (name
== NULL
&& tag
== DW_TAG_namespace
)
18359 name
= CP_ANONYMOUS_NAMESPACE_STR
;
18361 /* If there is no parent die to provide a namespace, and there are
18362 children, see if we can determine the namespace from their linkage
18364 if (cu
->language
== language_cplus
18365 && !cu
->per_cu
->dwarf2_per_objfile
->types
.empty ()
18366 && die_parent
== NULL
18368 && (tag
== DW_TAG_class_type
18369 || tag
== DW_TAG_structure_type
18370 || tag
== DW_TAG_union_type
))
18371 guess_partial_die_structure_name (this, cu
);
18373 /* GCC might emit a nameless struct or union that has a linkage
18374 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18376 && (tag
== DW_TAG_class_type
18377 || tag
== DW_TAG_interface_type
18378 || tag
== DW_TAG_structure_type
18379 || tag
== DW_TAG_union_type
)
18380 && linkage_name
!= NULL
)
18382 gdb::unique_xmalloc_ptr
<char> demangled
18383 (gdb_demangle (linkage_name
, DMGL_TYPES
));
18384 if (demangled
!= nullptr)
18388 /* Strip any leading namespaces/classes, keep only the base name.
18389 DW_AT_name for named DIEs does not contain the prefixes. */
18390 base
= strrchr (demangled
.get (), ':');
18391 if (base
&& base
> demangled
.get () && base
[-1] == ':')
18394 base
= demangled
.get ();
18396 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
18397 name
= objfile
->intern (base
);
18404 /* Process the attributes that had to be skipped in the first round. These
18405 attributes are the ones that need str_offsets_base or addr_base attributes.
18406 They could not have been processed in the first round, because at the time
18407 the values of str_offsets_base or addr_base may not have been known. */
18408 void read_attribute_reprocess (const struct die_reader_specs
*reader
,
18409 struct attribute
*attr
)
18411 struct dwarf2_cu
*cu
= reader
->cu
;
18412 switch (attr
->form
)
18414 case DW_FORM_addrx
:
18415 case DW_FORM_GNU_addr_index
:
18416 DW_ADDR (attr
) = read_addr_index (cu
, DW_UNSND (attr
));
18419 case DW_FORM_strx1
:
18420 case DW_FORM_strx2
:
18421 case DW_FORM_strx3
:
18422 case DW_FORM_strx4
:
18423 case DW_FORM_GNU_str_index
:
18425 unsigned int str_index
= DW_UNSND (attr
);
18426 if (reader
->dwo_file
!= NULL
)
18428 DW_STRING (attr
) = read_dwo_str_index (reader
, str_index
);
18429 DW_STRING_IS_CANONICAL (attr
) = 0;
18433 DW_STRING (attr
) = read_stub_str_index (cu
, str_index
);
18434 DW_STRING_IS_CANONICAL (attr
) = 0;
18439 gdb_assert_not_reached (_("Unexpected DWARF form."));
18443 /* Read an attribute value described by an attribute form. */
18445 static const gdb_byte
*
18446 read_attribute_value (const struct die_reader_specs
*reader
,
18447 struct attribute
*attr
, unsigned form
,
18448 LONGEST implicit_const
, const gdb_byte
*info_ptr
,
18449 bool *need_reprocess
)
18451 struct dwarf2_cu
*cu
= reader
->cu
;
18452 struct dwarf2_per_objfile
*dwarf2_per_objfile
18453 = cu
->per_cu
->dwarf2_per_objfile
;
18454 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18455 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18456 bfd
*abfd
= reader
->abfd
;
18457 struct comp_unit_head
*cu_header
= &cu
->header
;
18458 unsigned int bytes_read
;
18459 struct dwarf_block
*blk
;
18460 *need_reprocess
= false;
18462 attr
->form
= (enum dwarf_form
) form
;
18465 case DW_FORM_ref_addr
:
18466 if (cu
->header
.version
== 2)
18467 DW_UNSND (attr
) = cu
->header
.read_address (abfd
, info_ptr
,
18470 DW_UNSND (attr
) = cu
->header
.read_offset (abfd
, info_ptr
,
18472 info_ptr
+= bytes_read
;
18474 case DW_FORM_GNU_ref_alt
:
18475 DW_UNSND (attr
) = cu
->header
.read_offset (abfd
, info_ptr
, &bytes_read
);
18476 info_ptr
+= bytes_read
;
18479 DW_ADDR (attr
) = cu
->header
.read_address (abfd
, info_ptr
, &bytes_read
);
18480 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
18481 info_ptr
+= bytes_read
;
18483 case DW_FORM_block2
:
18484 blk
= dwarf_alloc_block (cu
);
18485 blk
->size
= read_2_bytes (abfd
, info_ptr
);
18487 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
18488 info_ptr
+= blk
->size
;
18489 DW_BLOCK (attr
) = blk
;
18491 case DW_FORM_block4
:
18492 blk
= dwarf_alloc_block (cu
);
18493 blk
->size
= read_4_bytes (abfd
, info_ptr
);
18495 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
18496 info_ptr
+= blk
->size
;
18497 DW_BLOCK (attr
) = blk
;
18499 case DW_FORM_data2
:
18500 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
18503 case DW_FORM_data4
:
18504 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
18507 case DW_FORM_data8
:
18508 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
18511 case DW_FORM_data16
:
18512 blk
= dwarf_alloc_block (cu
);
18514 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
18516 DW_BLOCK (attr
) = blk
;
18518 case DW_FORM_sec_offset
:
18519 DW_UNSND (attr
) = cu
->header
.read_offset (abfd
, info_ptr
, &bytes_read
);
18520 info_ptr
+= bytes_read
;
18522 case DW_FORM_string
:
18523 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
18524 DW_STRING_IS_CANONICAL (attr
) = 0;
18525 info_ptr
+= bytes_read
;
18528 if (!cu
->per_cu
->is_dwz
)
18530 DW_STRING (attr
) = read_indirect_string (dwarf2_per_objfile
,
18531 abfd
, info_ptr
, cu_header
,
18533 DW_STRING_IS_CANONICAL (attr
) = 0;
18534 info_ptr
+= bytes_read
;
18538 case DW_FORM_line_strp
:
18539 if (!cu
->per_cu
->is_dwz
)
18541 DW_STRING (attr
) = read_indirect_line_string (dwarf2_per_objfile
,
18543 cu_header
, &bytes_read
);
18544 DW_STRING_IS_CANONICAL (attr
) = 0;
18545 info_ptr
+= bytes_read
;
18549 case DW_FORM_GNU_strp_alt
:
18551 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
18552 LONGEST str_offset
= cu_header
->read_offset (abfd
, info_ptr
,
18555 DW_STRING (attr
) = read_indirect_string_from_dwz (objfile
,
18557 DW_STRING_IS_CANONICAL (attr
) = 0;
18558 info_ptr
+= bytes_read
;
18561 case DW_FORM_exprloc
:
18562 case DW_FORM_block
:
18563 blk
= dwarf_alloc_block (cu
);
18564 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18565 info_ptr
+= bytes_read
;
18566 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
18567 info_ptr
+= blk
->size
;
18568 DW_BLOCK (attr
) = blk
;
18570 case DW_FORM_block1
:
18571 blk
= dwarf_alloc_block (cu
);
18572 blk
->size
= read_1_byte (abfd
, info_ptr
);
18574 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
18575 info_ptr
+= blk
->size
;
18576 DW_BLOCK (attr
) = blk
;
18578 case DW_FORM_data1
:
18579 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
18583 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
18586 case DW_FORM_flag_present
:
18587 DW_UNSND (attr
) = 1;
18589 case DW_FORM_sdata
:
18590 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
18591 info_ptr
+= bytes_read
;
18593 case DW_FORM_udata
:
18594 case DW_FORM_rnglistx
:
18595 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18596 info_ptr
+= bytes_read
;
18599 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
18600 + read_1_byte (abfd
, info_ptr
));
18604 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
18605 + read_2_bytes (abfd
, info_ptr
));
18609 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
18610 + read_4_bytes (abfd
, info_ptr
));
18614 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
18615 + read_8_bytes (abfd
, info_ptr
));
18618 case DW_FORM_ref_sig8
:
18619 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
18622 case DW_FORM_ref_udata
:
18623 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
18624 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
18625 info_ptr
+= bytes_read
;
18627 case DW_FORM_indirect
:
18628 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18629 info_ptr
+= bytes_read
;
18630 if (form
== DW_FORM_implicit_const
)
18632 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
18633 info_ptr
+= bytes_read
;
18635 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
18636 info_ptr
, need_reprocess
);
18638 case DW_FORM_implicit_const
:
18639 DW_SND (attr
) = implicit_const
;
18641 case DW_FORM_addrx
:
18642 case DW_FORM_GNU_addr_index
:
18643 *need_reprocess
= true;
18644 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18645 info_ptr
+= bytes_read
;
18648 case DW_FORM_strx1
:
18649 case DW_FORM_strx2
:
18650 case DW_FORM_strx3
:
18651 case DW_FORM_strx4
:
18652 case DW_FORM_GNU_str_index
:
18654 ULONGEST str_index
;
18655 if (form
== DW_FORM_strx1
)
18657 str_index
= read_1_byte (abfd
, info_ptr
);
18660 else if (form
== DW_FORM_strx2
)
18662 str_index
= read_2_bytes (abfd
, info_ptr
);
18665 else if (form
== DW_FORM_strx3
)
18667 str_index
= read_3_bytes (abfd
, info_ptr
);
18670 else if (form
== DW_FORM_strx4
)
18672 str_index
= read_4_bytes (abfd
, info_ptr
);
18677 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18678 info_ptr
+= bytes_read
;
18680 *need_reprocess
= true;
18681 DW_UNSND (attr
) = str_index
;
18685 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
18686 dwarf_form_name (form
),
18687 bfd_get_filename (abfd
));
18691 if (cu
->per_cu
->is_dwz
&& attr
->form_is_ref ())
18692 attr
->form
= DW_FORM_GNU_ref_alt
;
18694 /* We have seen instances where the compiler tried to emit a byte
18695 size attribute of -1 which ended up being encoded as an unsigned
18696 0xffffffff. Although 0xffffffff is technically a valid size value,
18697 an object of this size seems pretty unlikely so we can relatively
18698 safely treat these cases as if the size attribute was invalid and
18699 treat them as zero by default. */
18700 if (attr
->name
== DW_AT_byte_size
18701 && form
== DW_FORM_data4
18702 && DW_UNSND (attr
) >= 0xffffffff)
18705 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
18706 hex_string (DW_UNSND (attr
)));
18707 DW_UNSND (attr
) = 0;
18713 /* Read an attribute described by an abbreviated attribute. */
18715 static const gdb_byte
*
18716 read_attribute (const struct die_reader_specs
*reader
,
18717 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
18718 const gdb_byte
*info_ptr
, bool *need_reprocess
)
18720 attr
->name
= abbrev
->name
;
18721 return read_attribute_value (reader
, attr
, abbrev
->form
,
18722 abbrev
->implicit_const
, info_ptr
,
18726 /* Cover function for read_initial_length.
18727 Returns the length of the object at BUF, and stores the size of the
18728 initial length in *BYTES_READ and stores the size that offsets will be in
18730 If the initial length size is not equivalent to that specified in
18731 CU_HEADER then issue a complaint.
18732 This is useful when reading non-comp-unit headers. */
18735 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
18736 const struct comp_unit_head
*cu_header
,
18737 unsigned int *bytes_read
,
18738 unsigned int *offset_size
)
18740 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
18742 gdb_assert (cu_header
->initial_length_size
== 4
18743 || cu_header
->initial_length_size
== 8
18744 || cu_header
->initial_length_size
== 12);
18746 if (cu_header
->initial_length_size
!= *bytes_read
)
18747 complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
18749 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
18753 /* Return pointer to string at section SECT offset STR_OFFSET with error
18754 reporting strings FORM_NAME and SECT_NAME. */
18756 static const char *
18757 read_indirect_string_at_offset_from (struct objfile
*objfile
,
18758 bfd
*abfd
, LONGEST str_offset
,
18759 struct dwarf2_section_info
*sect
,
18760 const char *form_name
,
18761 const char *sect_name
)
18763 sect
->read (objfile
);
18764 if (sect
->buffer
== NULL
)
18765 error (_("%s used without %s section [in module %s]"),
18766 form_name
, sect_name
, bfd_get_filename (abfd
));
18767 if (str_offset
>= sect
->size
)
18768 error (_("%s pointing outside of %s section [in module %s]"),
18769 form_name
, sect_name
, bfd_get_filename (abfd
));
18770 gdb_assert (HOST_CHAR_BIT
== 8);
18771 if (sect
->buffer
[str_offset
] == '\0')
18773 return (const char *) (sect
->buffer
+ str_offset
);
18776 /* Return pointer to string at .debug_str offset STR_OFFSET. */
18778 static const char *
18779 read_indirect_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
18780 bfd
*abfd
, LONGEST str_offset
)
18782 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
18784 &dwarf2_per_objfile
->str
,
18785 "DW_FORM_strp", ".debug_str");
18788 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
18790 static const char *
18791 read_indirect_line_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
18792 bfd
*abfd
, LONGEST str_offset
)
18794 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
18796 &dwarf2_per_objfile
->line_str
,
18797 "DW_FORM_line_strp",
18798 ".debug_line_str");
18801 /* Read a string at offset STR_OFFSET in the .debug_str section from
18802 the .dwz file DWZ. Throw an error if the offset is too large. If
18803 the string consists of a single NUL byte, return NULL; otherwise
18804 return a pointer to the string. */
18806 static const char *
18807 read_indirect_string_from_dwz (struct objfile
*objfile
, struct dwz_file
*dwz
,
18808 LONGEST str_offset
)
18810 dwz
->str
.read (objfile
);
18812 if (dwz
->str
.buffer
== NULL
)
18813 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
18814 "section [in module %s]"),
18815 bfd_get_filename (dwz
->dwz_bfd
.get ()));
18816 if (str_offset
>= dwz
->str
.size
)
18817 error (_("DW_FORM_GNU_strp_alt pointing outside of "
18818 ".debug_str section [in module %s]"),
18819 bfd_get_filename (dwz
->dwz_bfd
.get ()));
18820 gdb_assert (HOST_CHAR_BIT
== 8);
18821 if (dwz
->str
.buffer
[str_offset
] == '\0')
18823 return (const char *) (dwz
->str
.buffer
+ str_offset
);
18826 /* Return pointer to string at .debug_str offset as read from BUF.
18827 BUF is assumed to be in a compilation unit described by CU_HEADER.
18828 Return *BYTES_READ_PTR count of bytes read from BUF. */
18830 static const char *
18831 read_indirect_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
18832 const gdb_byte
*buf
,
18833 const struct comp_unit_head
*cu_header
,
18834 unsigned int *bytes_read_ptr
)
18836 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
18838 return read_indirect_string_at_offset (dwarf2_per_objfile
, abfd
, str_offset
);
18841 /* Return pointer to string at .debug_line_str offset as read from BUF.
18842 BUF is assumed to be in a compilation unit described by CU_HEADER.
18843 Return *BYTES_READ_PTR count of bytes read from BUF. */
18845 static const char *
18846 read_indirect_line_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
18847 bfd
*abfd
, const gdb_byte
*buf
,
18848 const struct comp_unit_head
*cu_header
,
18849 unsigned int *bytes_read_ptr
)
18851 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
18853 return read_indirect_line_string_at_offset (dwarf2_per_objfile
, abfd
,
18857 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
18858 ADDR_BASE is the DW_AT_addr_base (DW_AT_GNU_addr_base) attribute or zero.
18859 ADDR_SIZE is the size of addresses from the CU header. */
18862 read_addr_index_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
18863 unsigned int addr_index
, gdb::optional
<ULONGEST
> addr_base
,
18866 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18867 bfd
*abfd
= objfile
->obfd
;
18868 const gdb_byte
*info_ptr
;
18869 ULONGEST addr_base_or_zero
= addr_base
.has_value () ? *addr_base
: 0;
18871 dwarf2_per_objfile
->addr
.read (objfile
);
18872 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
18873 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
18874 objfile_name (objfile
));
18875 if (addr_base_or_zero
+ addr_index
* addr_size
18876 >= dwarf2_per_objfile
->addr
.size
)
18877 error (_("DW_FORM_addr_index pointing outside of "
18878 ".debug_addr section [in module %s]"),
18879 objfile_name (objfile
));
18880 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
18881 + addr_base_or_zero
+ addr_index
* addr_size
);
18882 if (addr_size
== 4)
18883 return bfd_get_32 (abfd
, info_ptr
);
18885 return bfd_get_64 (abfd
, info_ptr
);
18888 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
18891 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
18893 return read_addr_index_1 (cu
->per_cu
->dwarf2_per_objfile
, addr_index
,
18894 cu
->addr_base
, cu
->header
.addr_size
);
18897 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
18900 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
18901 unsigned int *bytes_read
)
18903 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
18904 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
18906 return read_addr_index (cu
, addr_index
);
18912 dwarf2_read_addr_index (dwarf2_per_cu_data
*per_cu
, unsigned int addr_index
)
18914 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
18915 struct dwarf2_cu
*cu
= per_cu
->cu
;
18916 gdb::optional
<ULONGEST
> addr_base
;
18919 /* We need addr_base and addr_size.
18920 If we don't have PER_CU->cu, we have to get it.
18921 Nasty, but the alternative is storing the needed info in PER_CU,
18922 which at this point doesn't seem justified: it's not clear how frequently
18923 it would get used and it would increase the size of every PER_CU.
18924 Entry points like dwarf2_per_cu_addr_size do a similar thing
18925 so we're not in uncharted territory here.
18926 Alas we need to be a bit more complicated as addr_base is contained
18929 We don't need to read the entire CU(/TU).
18930 We just need the header and top level die.
18932 IWBN to use the aging mechanism to let us lazily later discard the CU.
18933 For now we skip this optimization. */
18937 addr_base
= cu
->addr_base
;
18938 addr_size
= cu
->header
.addr_size
;
18942 cutu_reader
reader (per_cu
, NULL
, 0, false);
18943 addr_base
= reader
.cu
->addr_base
;
18944 addr_size
= reader
.cu
->header
.addr_size
;
18947 return read_addr_index_1 (dwarf2_per_objfile
, addr_index
, addr_base
,
18951 /* Given a DW_FORM_GNU_str_index value STR_INDEX, fetch the string.
18952 STR_SECTION, STR_OFFSETS_SECTION can be from a Fission stub or a
18955 static const char *
18956 read_str_index (struct dwarf2_cu
*cu
,
18957 struct dwarf2_section_info
*str_section
,
18958 struct dwarf2_section_info
*str_offsets_section
,
18959 ULONGEST str_offsets_base
, ULONGEST str_index
)
18961 struct dwarf2_per_objfile
*dwarf2_per_objfile
18962 = cu
->per_cu
->dwarf2_per_objfile
;
18963 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18964 const char *objf_name
= objfile_name (objfile
);
18965 bfd
*abfd
= objfile
->obfd
;
18966 const gdb_byte
*info_ptr
;
18967 ULONGEST str_offset
;
18968 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
18970 str_section
->read (objfile
);
18971 str_offsets_section
->read (objfile
);
18972 if (str_section
->buffer
== NULL
)
18973 error (_("%s used without %s section"
18974 " in CU at offset %s [in module %s]"),
18975 form_name
, str_section
->get_name (),
18976 sect_offset_str (cu
->header
.sect_off
), objf_name
);
18977 if (str_offsets_section
->buffer
== NULL
)
18978 error (_("%s used without %s section"
18979 " in CU at offset %s [in module %s]"),
18980 form_name
, str_section
->get_name (),
18981 sect_offset_str (cu
->header
.sect_off
), objf_name
);
18982 info_ptr
= (str_offsets_section
->buffer
18984 + str_index
* cu
->header
.offset_size
);
18985 if (cu
->header
.offset_size
== 4)
18986 str_offset
= bfd_get_32 (abfd
, info_ptr
);
18988 str_offset
= bfd_get_64 (abfd
, info_ptr
);
18989 if (str_offset
>= str_section
->size
)
18990 error (_("Offset from %s pointing outside of"
18991 " .debug_str.dwo section in CU at offset %s [in module %s]"),
18992 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
18993 return (const char *) (str_section
->buffer
+ str_offset
);
18996 /* Given a DW_FORM_GNU_str_index from a DWO file, fetch the string. */
18998 static const char *
18999 read_dwo_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
19001 ULONGEST str_offsets_base
= reader
->cu
->header
.version
>= 5
19002 ? reader
->cu
->header
.addr_size
: 0;
19003 return read_str_index (reader
->cu
,
19004 &reader
->dwo_file
->sections
.str
,
19005 &reader
->dwo_file
->sections
.str_offsets
,
19006 str_offsets_base
, str_index
);
19009 /* Given a DW_FORM_GNU_str_index from a Fission stub, fetch the string. */
19011 static const char *
19012 read_stub_str_index (struct dwarf2_cu
*cu
, ULONGEST str_index
)
19014 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
19015 const char *objf_name
= objfile_name (objfile
);
19016 static const char form_name
[] = "DW_FORM_GNU_str_index";
19017 static const char str_offsets_attr_name
[] = "DW_AT_str_offsets";
19019 if (!cu
->str_offsets_base
.has_value ())
19020 error (_("%s used in Fission stub without %s"
19021 " in CU at offset 0x%lx [in module %s]"),
19022 form_name
, str_offsets_attr_name
,
19023 (long) cu
->header
.offset_size
, objf_name
);
19025 return read_str_index (cu
,
19026 &cu
->per_cu
->dwarf2_per_objfile
->str
,
19027 &cu
->per_cu
->dwarf2_per_objfile
->str_offsets
,
19028 *cu
->str_offsets_base
, str_index
);
19031 /* Return the length of an LEB128 number in BUF. */
19034 leb128_size (const gdb_byte
*buf
)
19036 const gdb_byte
*begin
= buf
;
19042 if ((byte
& 128) == 0)
19043 return buf
- begin
;
19048 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
19057 cu
->language
= language_c
;
19060 case DW_LANG_C_plus_plus
:
19061 case DW_LANG_C_plus_plus_11
:
19062 case DW_LANG_C_plus_plus_14
:
19063 cu
->language
= language_cplus
;
19066 cu
->language
= language_d
;
19068 case DW_LANG_Fortran77
:
19069 case DW_LANG_Fortran90
:
19070 case DW_LANG_Fortran95
:
19071 case DW_LANG_Fortran03
:
19072 case DW_LANG_Fortran08
:
19073 cu
->language
= language_fortran
;
19076 cu
->language
= language_go
;
19078 case DW_LANG_Mips_Assembler
:
19079 cu
->language
= language_asm
;
19081 case DW_LANG_Ada83
:
19082 case DW_LANG_Ada95
:
19083 cu
->language
= language_ada
;
19085 case DW_LANG_Modula2
:
19086 cu
->language
= language_m2
;
19088 case DW_LANG_Pascal83
:
19089 cu
->language
= language_pascal
;
19092 cu
->language
= language_objc
;
19095 case DW_LANG_Rust_old
:
19096 cu
->language
= language_rust
;
19098 case DW_LANG_Cobol74
:
19099 case DW_LANG_Cobol85
:
19101 cu
->language
= language_minimal
;
19104 cu
->language_defn
= language_def (cu
->language
);
19107 /* Return the named attribute or NULL if not there. */
19109 static struct attribute
*
19110 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
19115 struct attribute
*spec
= NULL
;
19117 for (i
= 0; i
< die
->num_attrs
; ++i
)
19119 if (die
->attrs
[i
].name
== name
)
19120 return &die
->attrs
[i
];
19121 if (die
->attrs
[i
].name
== DW_AT_specification
19122 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
19123 spec
= &die
->attrs
[i
];
19129 die
= follow_die_ref (die
, spec
, &cu
);
19135 /* Return the named attribute or NULL if not there,
19136 but do not follow DW_AT_specification, etc.
19137 This is for use in contexts where we're reading .debug_types dies.
19138 Following DW_AT_specification, DW_AT_abstract_origin will take us
19139 back up the chain, and we want to go down. */
19141 static struct attribute
*
19142 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
19146 for (i
= 0; i
< die
->num_attrs
; ++i
)
19147 if (die
->attrs
[i
].name
== name
)
19148 return &die
->attrs
[i
];
19153 /* Return the string associated with a string-typed attribute, or NULL if it
19154 is either not found or is of an incorrect type. */
19156 static const char *
19157 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
19159 struct attribute
*attr
;
19160 const char *str
= NULL
;
19162 attr
= dwarf2_attr (die
, name
, cu
);
19166 if (attr
->form
== DW_FORM_strp
|| attr
->form
== DW_FORM_line_strp
19167 || attr
->form
== DW_FORM_string
19168 || attr
->form
== DW_FORM_strx
19169 || attr
->form
== DW_FORM_strx1
19170 || attr
->form
== DW_FORM_strx2
19171 || attr
->form
== DW_FORM_strx3
19172 || attr
->form
== DW_FORM_strx4
19173 || attr
->form
== DW_FORM_GNU_str_index
19174 || attr
->form
== DW_FORM_GNU_strp_alt
)
19175 str
= DW_STRING (attr
);
19177 complaint (_("string type expected for attribute %s for "
19178 "DIE at %s in module %s"),
19179 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
19180 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
19186 /* Return the dwo name or NULL if not present. If present, it is in either
19187 DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute. */
19188 static const char *
19189 dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
19191 const char *dwo_name
= dwarf2_string_attr (die
, DW_AT_GNU_dwo_name
, cu
);
19192 if (dwo_name
== nullptr)
19193 dwo_name
= dwarf2_string_attr (die
, DW_AT_dwo_name
, cu
);
19197 /* Return non-zero iff the attribute NAME is defined for the given DIE,
19198 and holds a non-zero value. This function should only be used for
19199 DW_FORM_flag or DW_FORM_flag_present attributes. */
19202 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
19204 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
19206 return (attr
&& DW_UNSND (attr
));
19210 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
19212 /* A DIE is a declaration if it has a DW_AT_declaration attribute
19213 which value is non-zero. However, we have to be careful with
19214 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
19215 (via dwarf2_flag_true_p) follows this attribute. So we may
19216 end up accidently finding a declaration attribute that belongs
19217 to a different DIE referenced by the specification attribute,
19218 even though the given DIE does not have a declaration attribute. */
19219 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
19220 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
19223 /* Return the die giving the specification for DIE, if there is
19224 one. *SPEC_CU is the CU containing DIE on input, and the CU
19225 containing the return value on output. If there is no
19226 specification, but there is an abstract origin, that is
19229 static struct die_info
*
19230 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
19232 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
19235 if (spec_attr
== NULL
)
19236 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
19238 if (spec_attr
== NULL
)
19241 return follow_die_ref (die
, spec_attr
, spec_cu
);
19244 /* Stub for free_line_header to match void * callback types. */
19247 free_line_header_voidp (void *arg
)
19249 struct line_header
*lh
= (struct line_header
*) arg
;
19254 /* A convenience function to find the proper .debug_line section for a CU. */
19256 static struct dwarf2_section_info
*
19257 get_debug_line_section (struct dwarf2_cu
*cu
)
19259 struct dwarf2_section_info
*section
;
19260 struct dwarf2_per_objfile
*dwarf2_per_objfile
19261 = cu
->per_cu
->dwarf2_per_objfile
;
19263 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
19265 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
19266 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
19267 else if (cu
->per_cu
->is_dwz
)
19269 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
19271 section
= &dwz
->line
;
19274 section
= &dwarf2_per_objfile
->line
;
19279 /* Read directory or file name entry format, starting with byte of
19280 format count entries, ULEB128 pairs of entry formats, ULEB128 of
19281 entries count and the entries themselves in the described entry
19285 read_formatted_entries (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19286 bfd
*abfd
, const gdb_byte
**bufp
,
19287 struct line_header
*lh
,
19288 const struct comp_unit_head
*cu_header
,
19289 void (*callback
) (struct line_header
*lh
,
19292 unsigned int mod_time
,
19293 unsigned int length
))
19295 gdb_byte format_count
, formati
;
19296 ULONGEST data_count
, datai
;
19297 const gdb_byte
*buf
= *bufp
;
19298 const gdb_byte
*format_header_data
;
19299 unsigned int bytes_read
;
19301 format_count
= read_1_byte (abfd
, buf
);
19303 format_header_data
= buf
;
19304 for (formati
= 0; formati
< format_count
; formati
++)
19306 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
19308 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
19312 data_count
= read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
19314 for (datai
= 0; datai
< data_count
; datai
++)
19316 const gdb_byte
*format
= format_header_data
;
19317 struct file_entry fe
;
19319 for (formati
= 0; formati
< format_count
; formati
++)
19321 ULONGEST content_type
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
19322 format
+= bytes_read
;
19324 ULONGEST form
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
19325 format
+= bytes_read
;
19327 gdb::optional
<const char *> string
;
19328 gdb::optional
<unsigned int> uint
;
19332 case DW_FORM_string
:
19333 string
.emplace (read_direct_string (abfd
, buf
, &bytes_read
));
19337 case DW_FORM_line_strp
:
19338 string
.emplace (read_indirect_line_string (dwarf2_per_objfile
,
19345 case DW_FORM_data1
:
19346 uint
.emplace (read_1_byte (abfd
, buf
));
19350 case DW_FORM_data2
:
19351 uint
.emplace (read_2_bytes (abfd
, buf
));
19355 case DW_FORM_data4
:
19356 uint
.emplace (read_4_bytes (abfd
, buf
));
19360 case DW_FORM_data8
:
19361 uint
.emplace (read_8_bytes (abfd
, buf
));
19365 case DW_FORM_data16
:
19366 /* This is used for MD5, but file_entry does not record MD5s. */
19370 case DW_FORM_udata
:
19371 uint
.emplace (read_unsigned_leb128 (abfd
, buf
, &bytes_read
));
19375 case DW_FORM_block
:
19376 /* It is valid only for DW_LNCT_timestamp which is ignored by
19381 switch (content_type
)
19384 if (string
.has_value ())
19387 case DW_LNCT_directory_index
:
19388 if (uint
.has_value ())
19389 fe
.d_index
= (dir_index
) *uint
;
19391 case DW_LNCT_timestamp
:
19392 if (uint
.has_value ())
19393 fe
.mod_time
= *uint
;
19396 if (uint
.has_value ())
19402 complaint (_("Unknown format content type %s"),
19403 pulongest (content_type
));
19407 callback (lh
, fe
.name
, fe
.d_index
, fe
.mod_time
, fe
.length
);
19413 /* Read the statement program header starting at OFFSET in
19414 .debug_line, or .debug_line.dwo. Return a pointer
19415 to a struct line_header, allocated using xmalloc.
19416 Returns NULL if there is a problem reading the header, e.g., if it
19417 has a version we don't understand.
19419 NOTE: the strings in the include directory and file name tables of
19420 the returned object point into the dwarf line section buffer,
19421 and must not be freed. */
19423 static line_header_up
19424 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
19426 const gdb_byte
*line_ptr
;
19427 unsigned int bytes_read
, offset_size
;
19429 const char *cur_dir
, *cur_file
;
19430 struct dwarf2_section_info
*section
;
19432 struct dwarf2_per_objfile
*dwarf2_per_objfile
19433 = cu
->per_cu
->dwarf2_per_objfile
;
19435 section
= get_debug_line_section (cu
);
19436 section
->read (dwarf2_per_objfile
->objfile
);
19437 if (section
->buffer
== NULL
)
19439 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
19440 complaint (_("missing .debug_line.dwo section"));
19442 complaint (_("missing .debug_line section"));
19446 /* We can't do this until we know the section is non-empty.
19447 Only then do we know we have such a section. */
19448 abfd
= section
->get_bfd_owner ();
19450 /* Make sure that at least there's room for the total_length field.
19451 That could be 12 bytes long, but we're just going to fudge that. */
19452 if (to_underlying (sect_off
) + 4 >= section
->size
)
19454 dwarf2_statement_list_fits_in_line_number_section_complaint ();
19458 line_header_up
lh (new line_header ());
19460 lh
->sect_off
= sect_off
;
19461 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
19463 line_ptr
= section
->buffer
+ to_underlying (sect_off
);
19465 /* Read in the header. */
19467 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
19468 &bytes_read
, &offset_size
);
19469 line_ptr
+= bytes_read
;
19471 const gdb_byte
*start_here
= line_ptr
;
19473 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
19475 dwarf2_statement_list_fits_in_line_number_section_complaint ();
19478 lh
->statement_program_end
= start_here
+ lh
->total_length
;
19479 lh
->version
= read_2_bytes (abfd
, line_ptr
);
19481 if (lh
->version
> 5)
19483 /* This is a version we don't understand. The format could have
19484 changed in ways we don't handle properly so just punt. */
19485 complaint (_("unsupported version in .debug_line section"));
19488 if (lh
->version
>= 5)
19490 gdb_byte segment_selector_size
;
19492 /* Skip address size. */
19493 read_1_byte (abfd
, line_ptr
);
19496 segment_selector_size
= read_1_byte (abfd
, line_ptr
);
19498 if (segment_selector_size
!= 0)
19500 complaint (_("unsupported segment selector size %u "
19501 "in .debug_line section"),
19502 segment_selector_size
);
19506 lh
->header_length
= read_offset (abfd
, line_ptr
, offset_size
);
19507 line_ptr
+= offset_size
;
19508 lh
->statement_program_start
= line_ptr
+ lh
->header_length
;
19509 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
19511 if (lh
->version
>= 4)
19513 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
19517 lh
->maximum_ops_per_instruction
= 1;
19519 if (lh
->maximum_ops_per_instruction
== 0)
19521 lh
->maximum_ops_per_instruction
= 1;
19522 complaint (_("invalid maximum_ops_per_instruction "
19523 "in `.debug_line' section"));
19526 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
19528 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
19530 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
19532 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
19534 lh
->standard_opcode_lengths
.reset (new unsigned char[lh
->opcode_base
]);
19536 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
19537 for (i
= 1; i
< lh
->opcode_base
; ++i
)
19539 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
19543 if (lh
->version
>= 5)
19545 /* Read directory table. */
19546 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
19548 [] (struct line_header
*header
, const char *name
,
19549 dir_index d_index
, unsigned int mod_time
,
19550 unsigned int length
)
19552 header
->add_include_dir (name
);
19555 /* Read file name table. */
19556 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
19558 [] (struct line_header
*header
, const char *name
,
19559 dir_index d_index
, unsigned int mod_time
,
19560 unsigned int length
)
19562 header
->add_file_name (name
, d_index
, mod_time
, length
);
19567 /* Read directory table. */
19568 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
19570 line_ptr
+= bytes_read
;
19571 lh
->add_include_dir (cur_dir
);
19573 line_ptr
+= bytes_read
;
19575 /* Read file name table. */
19576 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
19578 unsigned int mod_time
, length
;
19581 line_ptr
+= bytes_read
;
19582 d_index
= (dir_index
) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
19583 line_ptr
+= bytes_read
;
19584 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
19585 line_ptr
+= bytes_read
;
19586 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
19587 line_ptr
+= bytes_read
;
19589 lh
->add_file_name (cur_file
, d_index
, mod_time
, length
);
19591 line_ptr
+= bytes_read
;
19594 if (line_ptr
> (section
->buffer
+ section
->size
))
19595 complaint (_("line number info header doesn't "
19596 "fit in `.debug_line' section"));
19601 /* Subroutine of dwarf_decode_lines to simplify it.
19602 Return the file name of the psymtab for the given file_entry.
19603 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
19604 If space for the result is malloc'd, *NAME_HOLDER will be set.
19605 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
19607 static const char *
19608 psymtab_include_file_name (const struct line_header
*lh
, const file_entry
&fe
,
19609 const dwarf2_psymtab
*pst
,
19610 const char *comp_dir
,
19611 gdb::unique_xmalloc_ptr
<char> *name_holder
)
19613 const char *include_name
= fe
.name
;
19614 const char *include_name_to_compare
= include_name
;
19615 const char *pst_filename
;
19618 const char *dir_name
= fe
.include_dir (lh
);
19620 gdb::unique_xmalloc_ptr
<char> hold_compare
;
19621 if (!IS_ABSOLUTE_PATH (include_name
)
19622 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
19624 /* Avoid creating a duplicate psymtab for PST.
19625 We do this by comparing INCLUDE_NAME and PST_FILENAME.
19626 Before we do the comparison, however, we need to account
19627 for DIR_NAME and COMP_DIR.
19628 First prepend dir_name (if non-NULL). If we still don't
19629 have an absolute path prepend comp_dir (if non-NULL).
19630 However, the directory we record in the include-file's
19631 psymtab does not contain COMP_DIR (to match the
19632 corresponding symtab(s)).
19637 bash$ gcc -g ./hello.c
19638 include_name = "hello.c"
19640 DW_AT_comp_dir = comp_dir = "/tmp"
19641 DW_AT_name = "./hello.c"
19645 if (dir_name
!= NULL
)
19647 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
19648 include_name
, (char *) NULL
));
19649 include_name
= name_holder
->get ();
19650 include_name_to_compare
= include_name
;
19652 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
19654 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
19655 include_name
, (char *) NULL
));
19656 include_name_to_compare
= hold_compare
.get ();
19660 pst_filename
= pst
->filename
;
19661 gdb::unique_xmalloc_ptr
<char> copied_name
;
19662 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
19664 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
19665 pst_filename
, (char *) NULL
));
19666 pst_filename
= copied_name
.get ();
19669 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
19673 return include_name
;
19676 /* State machine to track the state of the line number program. */
19678 class lnp_state_machine
19681 /* Initialize a machine state for the start of a line number
19683 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
19684 bool record_lines_p
);
19686 file_entry
*current_file ()
19688 /* lh->file_names is 0-based, but the file name numbers in the
19689 statement program are 1-based. */
19690 return m_line_header
->file_name_at (m_file
);
19693 /* Record the line in the state machine. END_SEQUENCE is true if
19694 we're processing the end of a sequence. */
19695 void record_line (bool end_sequence
);
19697 /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
19698 nop-out rest of the lines in this sequence. */
19699 void check_line_address (struct dwarf2_cu
*cu
,
19700 const gdb_byte
*line_ptr
,
19701 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
19703 void handle_set_discriminator (unsigned int discriminator
)
19705 m_discriminator
= discriminator
;
19706 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
19709 /* Handle DW_LNE_set_address. */
19710 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
19713 address
+= baseaddr
;
19714 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
19717 /* Handle DW_LNS_advance_pc. */
19718 void handle_advance_pc (CORE_ADDR adjust
);
19720 /* Handle a special opcode. */
19721 void handle_special_opcode (unsigned char op_code
);
19723 /* Handle DW_LNS_advance_line. */
19724 void handle_advance_line (int line_delta
)
19726 advance_line (line_delta
);
19729 /* Handle DW_LNS_set_file. */
19730 void handle_set_file (file_name_index file
);
19732 /* Handle DW_LNS_negate_stmt. */
19733 void handle_negate_stmt ()
19735 m_is_stmt
= !m_is_stmt
;
19738 /* Handle DW_LNS_const_add_pc. */
19739 void handle_const_add_pc ();
19741 /* Handle DW_LNS_fixed_advance_pc. */
19742 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
19744 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
19748 /* Handle DW_LNS_copy. */
19749 void handle_copy ()
19751 record_line (false);
19752 m_discriminator
= 0;
19755 /* Handle DW_LNE_end_sequence. */
19756 void handle_end_sequence ()
19758 m_currently_recording_lines
= true;
19762 /* Advance the line by LINE_DELTA. */
19763 void advance_line (int line_delta
)
19765 m_line
+= line_delta
;
19767 if (line_delta
!= 0)
19768 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
19771 struct dwarf2_cu
*m_cu
;
19773 gdbarch
*m_gdbarch
;
19775 /* True if we're recording lines.
19776 Otherwise we're building partial symtabs and are just interested in
19777 finding include files mentioned by the line number program. */
19778 bool m_record_lines_p
;
19780 /* The line number header. */
19781 line_header
*m_line_header
;
19783 /* These are part of the standard DWARF line number state machine,
19784 and initialized according to the DWARF spec. */
19786 unsigned char m_op_index
= 0;
19787 /* The line table index of the current file. */
19788 file_name_index m_file
= 1;
19789 unsigned int m_line
= 1;
19791 /* These are initialized in the constructor. */
19793 CORE_ADDR m_address
;
19795 unsigned int m_discriminator
;
19797 /* Additional bits of state we need to track. */
19799 /* The last file that we called dwarf2_start_subfile for.
19800 This is only used for TLLs. */
19801 unsigned int m_last_file
= 0;
19802 /* The last file a line number was recorded for. */
19803 struct subfile
*m_last_subfile
= NULL
;
19805 /* When true, record the lines we decode. */
19806 bool m_currently_recording_lines
= false;
19808 /* The last line number that was recorded, used to coalesce
19809 consecutive entries for the same line. This can happen, for
19810 example, when discriminators are present. PR 17276. */
19811 unsigned int m_last_line
= 0;
19812 bool m_line_has_non_zero_discriminator
= false;
19816 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
19818 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
19819 / m_line_header
->maximum_ops_per_instruction
)
19820 * m_line_header
->minimum_instruction_length
);
19821 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
19822 m_op_index
= ((m_op_index
+ adjust
)
19823 % m_line_header
->maximum_ops_per_instruction
);
19827 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
19829 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
19830 unsigned char adj_opcode_d
= adj_opcode
/ m_line_header
->line_range
;
19831 unsigned char adj_opcode_r
= adj_opcode
% m_line_header
->line_range
;
19832 CORE_ADDR addr_adj
= (((m_op_index
+ adj_opcode_d
)
19833 / m_line_header
->maximum_ops_per_instruction
)
19834 * m_line_header
->minimum_instruction_length
);
19835 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
19836 m_op_index
= ((m_op_index
+ adj_opcode_d
)
19837 % m_line_header
->maximum_ops_per_instruction
);
19839 int line_delta
= m_line_header
->line_base
+ adj_opcode_r
;
19840 advance_line (line_delta
);
19841 record_line (false);
19842 m_discriminator
= 0;
19846 lnp_state_machine::handle_set_file (file_name_index file
)
19850 const file_entry
*fe
= current_file ();
19852 dwarf2_debug_line_missing_file_complaint ();
19853 else if (m_record_lines_p
)
19855 const char *dir
= fe
->include_dir (m_line_header
);
19857 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
19858 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
19859 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
19864 lnp_state_machine::handle_const_add_pc ()
19867 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
19870 = (((m_op_index
+ adjust
)
19871 / m_line_header
->maximum_ops_per_instruction
)
19872 * m_line_header
->minimum_instruction_length
);
19874 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
19875 m_op_index
= ((m_op_index
+ adjust
)
19876 % m_line_header
->maximum_ops_per_instruction
);
19879 /* Return non-zero if we should add LINE to the line number table.
19880 LINE is the line to add, LAST_LINE is the last line that was added,
19881 LAST_SUBFILE is the subfile for LAST_LINE.
19882 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
19883 had a non-zero discriminator.
19885 We have to be careful in the presence of discriminators.
19886 E.g., for this line:
19888 for (i = 0; i < 100000; i++);
19890 clang can emit four line number entries for that one line,
19891 each with a different discriminator.
19892 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
19894 However, we want gdb to coalesce all four entries into one.
19895 Otherwise the user could stepi into the middle of the line and
19896 gdb would get confused about whether the pc really was in the
19897 middle of the line.
19899 Things are further complicated by the fact that two consecutive
19900 line number entries for the same line is a heuristic used by gcc
19901 to denote the end of the prologue. So we can't just discard duplicate
19902 entries, we have to be selective about it. The heuristic we use is
19903 that we only collapse consecutive entries for the same line if at least
19904 one of those entries has a non-zero discriminator. PR 17276.
19906 Note: Addresses in the line number state machine can never go backwards
19907 within one sequence, thus this coalescing is ok. */
19910 dwarf_record_line_p (struct dwarf2_cu
*cu
,
19911 unsigned int line
, unsigned int last_line
,
19912 int line_has_non_zero_discriminator
,
19913 struct subfile
*last_subfile
)
19915 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
19917 if (line
!= last_line
)
19919 /* Same line for the same file that we've seen already.
19920 As a last check, for pr 17276, only record the line if the line
19921 has never had a non-zero discriminator. */
19922 if (!line_has_non_zero_discriminator
)
19927 /* Use the CU's builder to record line number LINE beginning at
19928 address ADDRESS in the line table of subfile SUBFILE. */
19931 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
19932 unsigned int line
, CORE_ADDR address
,
19933 struct dwarf2_cu
*cu
)
19935 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
19937 if (dwarf_line_debug
)
19939 fprintf_unfiltered (gdb_stdlog
,
19940 "Recording line %u, file %s, address %s\n",
19941 line
, lbasename (subfile
->name
),
19942 paddress (gdbarch
, address
));
19946 cu
->get_builder ()->record_line (subfile
, line
, addr
);
19949 /* Subroutine of dwarf_decode_lines_1 to simplify it.
19950 Mark the end of a set of line number records.
19951 The arguments are the same as for dwarf_record_line_1.
19952 If SUBFILE is NULL the request is ignored. */
19955 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
19956 CORE_ADDR address
, struct dwarf2_cu
*cu
)
19958 if (subfile
== NULL
)
19961 if (dwarf_line_debug
)
19963 fprintf_unfiltered (gdb_stdlog
,
19964 "Finishing current line, file %s, address %s\n",
19965 lbasename (subfile
->name
),
19966 paddress (gdbarch
, address
));
19969 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, cu
);
19973 lnp_state_machine::record_line (bool end_sequence
)
19975 if (dwarf_line_debug
)
19977 fprintf_unfiltered (gdb_stdlog
,
19978 "Processing actual line %u: file %u,"
19979 " address %s, is_stmt %u, discrim %u%s\n",
19981 paddress (m_gdbarch
, m_address
),
19982 m_is_stmt
, m_discriminator
,
19983 (end_sequence
? "\t(end sequence)" : ""));
19986 file_entry
*fe
= current_file ();
19989 dwarf2_debug_line_missing_file_complaint ();
19990 /* For now we ignore lines not starting on an instruction boundary.
19991 But not when processing end_sequence for compatibility with the
19992 previous version of the code. */
19993 else if (m_op_index
== 0 || end_sequence
)
19995 fe
->included_p
= 1;
19996 if (m_record_lines_p
19997 && (producer_is_codewarrior (m_cu
) || m_is_stmt
|| end_sequence
))
19999 if (m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ()
20002 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
20003 m_currently_recording_lines
? m_cu
: nullptr);
20008 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
20009 m_line_has_non_zero_discriminator
,
20012 buildsym_compunit
*builder
= m_cu
->get_builder ();
20013 dwarf_record_line_1 (m_gdbarch
,
20014 builder
->get_current_subfile (),
20016 m_currently_recording_lines
? m_cu
: nullptr);
20018 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20019 m_last_line
= m_line
;
20025 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
20026 line_header
*lh
, bool record_lines_p
)
20030 m_record_lines_p
= record_lines_p
;
20031 m_line_header
= lh
;
20033 m_currently_recording_lines
= true;
20035 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20036 was a line entry for it so that the backend has a chance to adjust it
20037 and also record it in case it needs it. This is currently used by MIPS
20038 code, cf. `mips_adjust_dwarf2_line'. */
20039 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
20040 m_is_stmt
= lh
->default_is_stmt
;
20041 m_discriminator
= 0;
20045 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
20046 const gdb_byte
*line_ptr
,
20047 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
20049 /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
20050 the pc range of the CU. However, we restrict the test to only ADDRESS
20051 values of zero to preserve GDB's previous behaviour which is to handle
20052 the specific case of a function being GC'd by the linker. */
20054 if (address
== 0 && address
< unrelocated_lowpc
)
20056 /* This line table is for a function which has been
20057 GCd by the linker. Ignore it. PR gdb/12528 */
20059 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
20060 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
20062 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20063 line_offset
, objfile_name (objfile
));
20064 m_currently_recording_lines
= false;
20065 /* Note: m_currently_recording_lines is left as false until we see
20066 DW_LNE_end_sequence. */
20070 /* Subroutine of dwarf_decode_lines to simplify it.
20071 Process the line number information in LH.
20072 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20073 program in order to set included_p for every referenced header. */
20076 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
20077 const int decode_for_pst_p
, CORE_ADDR lowpc
)
20079 const gdb_byte
*line_ptr
, *extended_end
;
20080 const gdb_byte
*line_end
;
20081 unsigned int bytes_read
, extended_len
;
20082 unsigned char op_code
, extended_op
;
20083 CORE_ADDR baseaddr
;
20084 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
20085 bfd
*abfd
= objfile
->obfd
;
20086 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
20087 /* True if we're recording line info (as opposed to building partial
20088 symtabs and just interested in finding include files mentioned by
20089 the line number program). */
20090 bool record_lines_p
= !decode_for_pst_p
;
20092 baseaddr
= objfile
->text_section_offset ();
20094 line_ptr
= lh
->statement_program_start
;
20095 line_end
= lh
->statement_program_end
;
20097 /* Read the statement sequences until there's nothing left. */
20098 while (line_ptr
< line_end
)
20100 /* The DWARF line number program state machine. Reset the state
20101 machine at the start of each sequence. */
20102 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
20103 bool end_sequence
= false;
20105 if (record_lines_p
)
20107 /* Start a subfile for the current file of the state
20109 const file_entry
*fe
= state_machine
.current_file ();
20112 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
20115 /* Decode the table. */
20116 while (line_ptr
< line_end
&& !end_sequence
)
20118 op_code
= read_1_byte (abfd
, line_ptr
);
20121 if (op_code
>= lh
->opcode_base
)
20123 /* Special opcode. */
20124 state_machine
.handle_special_opcode (op_code
);
20126 else switch (op_code
)
20128 case DW_LNS_extended_op
:
20129 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
20131 line_ptr
+= bytes_read
;
20132 extended_end
= line_ptr
+ extended_len
;
20133 extended_op
= read_1_byte (abfd
, line_ptr
);
20135 switch (extended_op
)
20137 case DW_LNE_end_sequence
:
20138 state_machine
.handle_end_sequence ();
20139 end_sequence
= true;
20141 case DW_LNE_set_address
:
20144 = cu
->header
.read_address (abfd
, line_ptr
, &bytes_read
);
20145 line_ptr
+= bytes_read
;
20147 state_machine
.check_line_address (cu
, line_ptr
,
20148 lowpc
- baseaddr
, address
);
20149 state_machine
.handle_set_address (baseaddr
, address
);
20152 case DW_LNE_define_file
:
20154 const char *cur_file
;
20155 unsigned int mod_time
, length
;
20158 cur_file
= read_direct_string (abfd
, line_ptr
,
20160 line_ptr
+= bytes_read
;
20161 dindex
= (dir_index
)
20162 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20163 line_ptr
+= bytes_read
;
20165 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20166 line_ptr
+= bytes_read
;
20168 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20169 line_ptr
+= bytes_read
;
20170 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
20173 case DW_LNE_set_discriminator
:
20175 /* The discriminator is not interesting to the
20176 debugger; just ignore it. We still need to
20177 check its value though:
20178 if there are consecutive entries for the same
20179 (non-prologue) line we want to coalesce them.
20182 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20183 line_ptr
+= bytes_read
;
20185 state_machine
.handle_set_discriminator (discr
);
20189 complaint (_("mangled .debug_line section"));
20192 /* Make sure that we parsed the extended op correctly. If e.g.
20193 we expected a different address size than the producer used,
20194 we may have read the wrong number of bytes. */
20195 if (line_ptr
!= extended_end
)
20197 complaint (_("mangled .debug_line section"));
20202 state_machine
.handle_copy ();
20204 case DW_LNS_advance_pc
:
20207 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20208 line_ptr
+= bytes_read
;
20210 state_machine
.handle_advance_pc (adjust
);
20213 case DW_LNS_advance_line
:
20216 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
20217 line_ptr
+= bytes_read
;
20219 state_machine
.handle_advance_line (line_delta
);
20222 case DW_LNS_set_file
:
20224 file_name_index file
20225 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
20227 line_ptr
+= bytes_read
;
20229 state_machine
.handle_set_file (file
);
20232 case DW_LNS_set_column
:
20233 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20234 line_ptr
+= bytes_read
;
20236 case DW_LNS_negate_stmt
:
20237 state_machine
.handle_negate_stmt ();
20239 case DW_LNS_set_basic_block
:
20241 /* Add to the address register of the state machine the
20242 address increment value corresponding to special opcode
20243 255. I.e., this value is scaled by the minimum
20244 instruction length since special opcode 255 would have
20245 scaled the increment. */
20246 case DW_LNS_const_add_pc
:
20247 state_machine
.handle_const_add_pc ();
20249 case DW_LNS_fixed_advance_pc
:
20251 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
20254 state_machine
.handle_fixed_advance_pc (addr_adj
);
20259 /* Unknown standard opcode, ignore it. */
20262 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
20264 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20265 line_ptr
+= bytes_read
;
20272 dwarf2_debug_line_missing_end_sequence_complaint ();
20274 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
20275 in which case we still finish recording the last line). */
20276 state_machine
.record_line (true);
20280 /* Decode the Line Number Program (LNP) for the given line_header
20281 structure and CU. The actual information extracted and the type
20282 of structures created from the LNP depends on the value of PST.
20284 1. If PST is NULL, then this procedure uses the data from the program
20285 to create all necessary symbol tables, and their linetables.
20287 2. If PST is not NULL, this procedure reads the program to determine
20288 the list of files included by the unit represented by PST, and
20289 builds all the associated partial symbol tables.
20291 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20292 It is used for relative paths in the line table.
20293 NOTE: When processing partial symtabs (pst != NULL),
20294 comp_dir == pst->dirname.
20296 NOTE: It is important that psymtabs have the same file name (via strcmp)
20297 as the corresponding symtab. Since COMP_DIR is not used in the name of the
20298 symtab we don't use it in the name of the psymtabs we create.
20299 E.g. expand_line_sal requires this when finding psymtabs to expand.
20300 A good testcase for this is mb-inline.exp.
20302 LOWPC is the lowest address in CU (or 0 if not known).
20304 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
20305 for its PC<->lines mapping information. Otherwise only the filename
20306 table is read in. */
20309 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
20310 struct dwarf2_cu
*cu
, dwarf2_psymtab
*pst
,
20311 CORE_ADDR lowpc
, int decode_mapping
)
20313 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
20314 const int decode_for_pst_p
= (pst
!= NULL
);
20316 if (decode_mapping
)
20317 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
20319 if (decode_for_pst_p
)
20321 /* Now that we're done scanning the Line Header Program, we can
20322 create the psymtab of each included file. */
20323 for (auto &file_entry
: lh
->file_names ())
20324 if (file_entry
.included_p
== 1)
20326 gdb::unique_xmalloc_ptr
<char> name_holder
;
20327 const char *include_name
=
20328 psymtab_include_file_name (lh
, file_entry
, pst
,
20329 comp_dir
, &name_holder
);
20330 if (include_name
!= NULL
)
20331 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
20336 /* Make sure a symtab is created for every file, even files
20337 which contain only variables (i.e. no code with associated
20339 buildsym_compunit
*builder
= cu
->get_builder ();
20340 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
20342 for (auto &fe
: lh
->file_names ())
20344 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
20345 if (builder
->get_current_subfile ()->symtab
== NULL
)
20347 builder
->get_current_subfile ()->symtab
20348 = allocate_symtab (cust
,
20349 builder
->get_current_subfile ()->name
);
20351 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
20356 /* Start a subfile for DWARF. FILENAME is the name of the file and
20357 DIRNAME the name of the source directory which contains FILENAME
20358 or NULL if not known.
20359 This routine tries to keep line numbers from identical absolute and
20360 relative file names in a common subfile.
20362 Using the `list' example from the GDB testsuite, which resides in
20363 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
20364 of /srcdir/list0.c yields the following debugging information for list0.c:
20366 DW_AT_name: /srcdir/list0.c
20367 DW_AT_comp_dir: /compdir
20368 files.files[0].name: list0.h
20369 files.files[0].dir: /srcdir
20370 files.files[1].name: list0.c
20371 files.files[1].dir: /srcdir
20373 The line number information for list0.c has to end up in a single
20374 subfile, so that `break /srcdir/list0.c:1' works as expected.
20375 start_subfile will ensure that this happens provided that we pass the
20376 concatenation of files.files[1].dir and files.files[1].name as the
20380 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
20381 const char *dirname
)
20383 gdb::unique_xmalloc_ptr
<char> copy
;
20385 /* In order not to lose the line information directory,
20386 we concatenate it to the filename when it makes sense.
20387 Note that the Dwarf3 standard says (speaking of filenames in line
20388 information): ``The directory index is ignored for file names
20389 that represent full path names''. Thus ignoring dirname in the
20390 `else' branch below isn't an issue. */
20392 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
20394 copy
.reset (concat (dirname
, SLASH_STRING
, filename
, (char *) NULL
));
20395 filename
= copy
.get ();
20398 cu
->get_builder ()->start_subfile (filename
);
20401 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
20402 buildsym_compunit constructor. */
20404 struct compunit_symtab
*
20405 dwarf2_cu::start_symtab (const char *name
, const char *comp_dir
,
20408 gdb_assert (m_builder
== nullptr);
20410 m_builder
.reset (new struct buildsym_compunit
20411 (per_cu
->dwarf2_per_objfile
->objfile
,
20412 name
, comp_dir
, language
, low_pc
));
20414 list_in_scope
= get_builder ()->get_file_symbols ();
20416 get_builder ()->record_debugformat ("DWARF 2");
20417 get_builder ()->record_producer (producer
);
20419 processing_has_namespace_info
= false;
20421 return get_builder ()->get_compunit_symtab ();
20425 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
20426 struct dwarf2_cu
*cu
)
20428 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
20429 struct comp_unit_head
*cu_header
= &cu
->header
;
20431 /* NOTE drow/2003-01-30: There used to be a comment and some special
20432 code here to turn a symbol with DW_AT_external and a
20433 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
20434 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
20435 with some versions of binutils) where shared libraries could have
20436 relocations against symbols in their debug information - the
20437 minimal symbol would have the right address, but the debug info
20438 would not. It's no longer necessary, because we will explicitly
20439 apply relocations when we read in the debug information now. */
20441 /* A DW_AT_location attribute with no contents indicates that a
20442 variable has been optimized away. */
20443 if (attr
->form_is_block () && DW_BLOCK (attr
)->size
== 0)
20445 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
20449 /* Handle one degenerate form of location expression specially, to
20450 preserve GDB's previous behavior when section offsets are
20451 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
20452 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
20454 if (attr
->form_is_block ()
20455 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
20456 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
20457 || ((DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
20458 || DW_BLOCK (attr
)->data
[0] == DW_OP_addrx
)
20459 && (DW_BLOCK (attr
)->size
20460 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
20462 unsigned int dummy
;
20464 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
20465 SET_SYMBOL_VALUE_ADDRESS
20466 (sym
, cu
->header
.read_address (objfile
->obfd
,
20467 DW_BLOCK (attr
)->data
+ 1,
20470 SET_SYMBOL_VALUE_ADDRESS
20471 (sym
, read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1,
20473 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
20474 fixup_symbol_section (sym
, objfile
);
20475 SET_SYMBOL_VALUE_ADDRESS
20477 SYMBOL_VALUE_ADDRESS (sym
)
20478 + objfile
->section_offsets
[SYMBOL_SECTION (sym
)]);
20482 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
20483 expression evaluator, and use LOC_COMPUTED only when necessary
20484 (i.e. when the value of a register or memory location is
20485 referenced, or a thread-local block, etc.). Then again, it might
20486 not be worthwhile. I'm assuming that it isn't unless performance
20487 or memory numbers show me otherwise. */
20489 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
20491 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
20492 cu
->has_loclist
= true;
20495 /* Given a pointer to a DWARF information entry, figure out if we need
20496 to make a symbol table entry for it, and if so, create a new entry
20497 and return a pointer to it.
20498 If TYPE is NULL, determine symbol type from the die, otherwise
20499 used the passed type.
20500 If SPACE is not NULL, use it to hold the new symbol. If it is
20501 NULL, allocate a new symbol on the objfile's obstack. */
20503 static struct symbol
*
20504 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
20505 struct symbol
*space
)
20507 struct dwarf2_per_objfile
*dwarf2_per_objfile
20508 = cu
->per_cu
->dwarf2_per_objfile
;
20509 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
20510 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
20511 struct symbol
*sym
= NULL
;
20513 struct attribute
*attr
= NULL
;
20514 struct attribute
*attr2
= NULL
;
20515 CORE_ADDR baseaddr
;
20516 struct pending
**list_to_add
= NULL
;
20518 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
20520 baseaddr
= objfile
->text_section_offset ();
20522 name
= dwarf2_name (die
, cu
);
20525 const char *linkagename
;
20526 int suppress_add
= 0;
20531 sym
= allocate_symbol (objfile
);
20532 OBJSTAT (objfile
, n_syms
++);
20534 /* Cache this symbol's name and the name's demangled form (if any). */
20535 sym
->set_language (cu
->language
, &objfile
->objfile_obstack
);
20536 linkagename
= dwarf2_physname (name
, die
, cu
);
20537 sym
->compute_and_set_names (linkagename
, false, objfile
->per_bfd
);
20539 /* Fortran does not have mangling standard and the mangling does differ
20540 between gfortran, iFort etc. */
20541 if (cu
->language
== language_fortran
20542 && symbol_get_demangled_name (sym
) == NULL
)
20543 symbol_set_demangled_name (sym
,
20544 dwarf2_full_name (name
, die
, cu
),
20547 /* Default assumptions.
20548 Use the passed type or decode it from the die. */
20549 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
20550 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
20552 SYMBOL_TYPE (sym
) = type
;
20554 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
20555 attr
= dwarf2_attr (die
,
20556 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
20558 if (attr
!= nullptr)
20560 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
20563 attr
= dwarf2_attr (die
,
20564 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
20566 if (attr
!= nullptr)
20568 file_name_index file_index
= (file_name_index
) DW_UNSND (attr
);
20569 struct file_entry
*fe
;
20571 if (cu
->line_header
!= NULL
)
20572 fe
= cu
->line_header
->file_name_at (file_index
);
20577 complaint (_("file index out of range"));
20579 symbol_set_symtab (sym
, fe
->symtab
);
20585 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
20586 if (attr
!= nullptr)
20590 addr
= attr
->value_as_address ();
20591 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
20592 SET_SYMBOL_VALUE_ADDRESS (sym
, addr
);
20594 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
20595 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
20596 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
20597 add_symbol_to_list (sym
, cu
->list_in_scope
);
20599 case DW_TAG_subprogram
:
20600 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
20602 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
20603 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
20604 if ((attr2
&& (DW_UNSND (attr2
) != 0))
20605 || cu
->language
== language_ada
20606 || cu
->language
== language_fortran
)
20608 /* Subprograms marked external are stored as a global symbol.
20609 Ada and Fortran subprograms, whether marked external or
20610 not, are always stored as a global symbol, because we want
20611 to be able to access them globally. For instance, we want
20612 to be able to break on a nested subprogram without having
20613 to specify the context. */
20614 list_to_add
= cu
->get_builder ()->get_global_symbols ();
20618 list_to_add
= cu
->list_in_scope
;
20621 case DW_TAG_inlined_subroutine
:
20622 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
20624 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
20625 SYMBOL_INLINED (sym
) = 1;
20626 list_to_add
= cu
->list_in_scope
;
20628 case DW_TAG_template_value_param
:
20630 /* Fall through. */
20631 case DW_TAG_constant
:
20632 case DW_TAG_variable
:
20633 case DW_TAG_member
:
20634 /* Compilation with minimal debug info may result in
20635 variables with missing type entries. Change the
20636 misleading `void' type to something sensible. */
20637 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
20638 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
20640 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
20641 /* In the case of DW_TAG_member, we should only be called for
20642 static const members. */
20643 if (die
->tag
== DW_TAG_member
)
20645 /* dwarf2_add_field uses die_is_declaration,
20646 so we do the same. */
20647 gdb_assert (die_is_declaration (die
, cu
));
20650 if (attr
!= nullptr)
20652 dwarf2_const_value (attr
, sym
, cu
);
20653 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
20656 if (attr2
&& (DW_UNSND (attr2
) != 0))
20657 list_to_add
= cu
->get_builder ()->get_global_symbols ();
20659 list_to_add
= cu
->list_in_scope
;
20663 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
20664 if (attr
!= nullptr)
20666 var_decode_location (attr
, sym
, cu
);
20667 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
20669 /* Fortran explicitly imports any global symbols to the local
20670 scope by DW_TAG_common_block. */
20671 if (cu
->language
== language_fortran
&& die
->parent
20672 && die
->parent
->tag
== DW_TAG_common_block
)
20675 if (SYMBOL_CLASS (sym
) == LOC_STATIC
20676 && SYMBOL_VALUE_ADDRESS (sym
) == 0
20677 && !dwarf2_per_objfile
->has_section_at_zero
)
20679 /* When a static variable is eliminated by the linker,
20680 the corresponding debug information is not stripped
20681 out, but the variable address is set to null;
20682 do not add such variables into symbol table. */
20684 else if (attr2
&& (DW_UNSND (attr2
) != 0))
20686 if (SYMBOL_CLASS (sym
) == LOC_STATIC
20687 && (objfile
->flags
& OBJF_MAINLINE
) == 0
20688 && dwarf2_per_objfile
->can_copy
)
20690 /* A global static variable might be subject to
20691 copy relocation. We first check for a local
20692 minsym, though, because maybe the symbol was
20693 marked hidden, in which case this would not
20695 bound_minimal_symbol found
20696 = (lookup_minimal_symbol_linkage
20697 (sym
->linkage_name (), objfile
));
20698 if (found
.minsym
!= nullptr)
20699 sym
->maybe_copied
= 1;
20702 /* A variable with DW_AT_external is never static,
20703 but it may be block-scoped. */
20705 = ((cu
->list_in_scope
20706 == cu
->get_builder ()->get_file_symbols ())
20707 ? cu
->get_builder ()->get_global_symbols ()
20708 : cu
->list_in_scope
);
20711 list_to_add
= cu
->list_in_scope
;
20715 /* We do not know the address of this symbol.
20716 If it is an external symbol and we have type information
20717 for it, enter the symbol as a LOC_UNRESOLVED symbol.
20718 The address of the variable will then be determined from
20719 the minimal symbol table whenever the variable is
20721 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
20723 /* Fortran explicitly imports any global symbols to the local
20724 scope by DW_TAG_common_block. */
20725 if (cu
->language
== language_fortran
&& die
->parent
20726 && die
->parent
->tag
== DW_TAG_common_block
)
20728 /* SYMBOL_CLASS doesn't matter here because
20729 read_common_block is going to reset it. */
20731 list_to_add
= cu
->list_in_scope
;
20733 else if (attr2
&& (DW_UNSND (attr2
) != 0)
20734 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
20736 /* A variable with DW_AT_external is never static, but it
20737 may be block-scoped. */
20739 = ((cu
->list_in_scope
20740 == cu
->get_builder ()->get_file_symbols ())
20741 ? cu
->get_builder ()->get_global_symbols ()
20742 : cu
->list_in_scope
);
20744 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
20746 else if (!die_is_declaration (die
, cu
))
20748 /* Use the default LOC_OPTIMIZED_OUT class. */
20749 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
20751 list_to_add
= cu
->list_in_scope
;
20755 case DW_TAG_formal_parameter
:
20757 /* If we are inside a function, mark this as an argument. If
20758 not, we might be looking at an argument to an inlined function
20759 when we do not have enough information to show inlined frames;
20760 pretend it's a local variable in that case so that the user can
20762 struct context_stack
*curr
20763 = cu
->get_builder ()->get_current_context_stack ();
20764 if (curr
!= nullptr && curr
->name
!= nullptr)
20765 SYMBOL_IS_ARGUMENT (sym
) = 1;
20766 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
20767 if (attr
!= nullptr)
20769 var_decode_location (attr
, sym
, cu
);
20771 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
20772 if (attr
!= nullptr)
20774 dwarf2_const_value (attr
, sym
, cu
);
20777 list_to_add
= cu
->list_in_scope
;
20780 case DW_TAG_unspecified_parameters
:
20781 /* From varargs functions; gdb doesn't seem to have any
20782 interest in this information, so just ignore it for now.
20785 case DW_TAG_template_type_param
:
20787 /* Fall through. */
20788 case DW_TAG_class_type
:
20789 case DW_TAG_interface_type
:
20790 case DW_TAG_structure_type
:
20791 case DW_TAG_union_type
:
20792 case DW_TAG_set_type
:
20793 case DW_TAG_enumeration_type
:
20794 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
20795 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
20798 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
20799 really ever be static objects: otherwise, if you try
20800 to, say, break of a class's method and you're in a file
20801 which doesn't mention that class, it won't work unless
20802 the check for all static symbols in lookup_symbol_aux
20803 saves you. See the OtherFileClass tests in
20804 gdb.c++/namespace.exp. */
20808 buildsym_compunit
*builder
= cu
->get_builder ();
20810 = (cu
->list_in_scope
== builder
->get_file_symbols ()
20811 && cu
->language
== language_cplus
20812 ? builder
->get_global_symbols ()
20813 : cu
->list_in_scope
);
20815 /* The semantics of C++ state that "struct foo {
20816 ... }" also defines a typedef for "foo". */
20817 if (cu
->language
== language_cplus
20818 || cu
->language
== language_ada
20819 || cu
->language
== language_d
20820 || cu
->language
== language_rust
)
20822 /* The symbol's name is already allocated along
20823 with this objfile, so we don't need to
20824 duplicate it for the type. */
20825 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
20826 TYPE_NAME (SYMBOL_TYPE (sym
)) = sym
->search_name ();
20831 case DW_TAG_typedef
:
20832 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
20833 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
20834 list_to_add
= cu
->list_in_scope
;
20836 case DW_TAG_base_type
:
20837 case DW_TAG_subrange_type
:
20838 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
20839 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
20840 list_to_add
= cu
->list_in_scope
;
20842 case DW_TAG_enumerator
:
20843 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
20844 if (attr
!= nullptr)
20846 dwarf2_const_value (attr
, sym
, cu
);
20849 /* NOTE: carlton/2003-11-10: See comment above in the
20850 DW_TAG_class_type, etc. block. */
20853 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
20854 && cu
->language
== language_cplus
20855 ? cu
->get_builder ()->get_global_symbols ()
20856 : cu
->list_in_scope
);
20859 case DW_TAG_imported_declaration
:
20860 case DW_TAG_namespace
:
20861 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
20862 list_to_add
= cu
->get_builder ()->get_global_symbols ();
20864 case DW_TAG_module
:
20865 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
20866 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
20867 list_to_add
= cu
->get_builder ()->get_global_symbols ();
20869 case DW_TAG_common_block
:
20870 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
20871 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
20872 add_symbol_to_list (sym
, cu
->list_in_scope
);
20875 /* Not a tag we recognize. Hopefully we aren't processing
20876 trash data, but since we must specifically ignore things
20877 we don't recognize, there is nothing else we should do at
20879 complaint (_("unsupported tag: '%s'"),
20880 dwarf_tag_name (die
->tag
));
20886 sym
->hash_next
= objfile
->template_symbols
;
20887 objfile
->template_symbols
= sym
;
20888 list_to_add
= NULL
;
20891 if (list_to_add
!= NULL
)
20892 add_symbol_to_list (sym
, list_to_add
);
20894 /* For the benefit of old versions of GCC, check for anonymous
20895 namespaces based on the demangled name. */
20896 if (!cu
->processing_has_namespace_info
20897 && cu
->language
== language_cplus
)
20898 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
20903 /* Given an attr with a DW_FORM_dataN value in host byte order,
20904 zero-extend it as appropriate for the symbol's type. The DWARF
20905 standard (v4) is not entirely clear about the meaning of using
20906 DW_FORM_dataN for a constant with a signed type, where the type is
20907 wider than the data. The conclusion of a discussion on the DWARF
20908 list was that this is unspecified. We choose to always zero-extend
20909 because that is the interpretation long in use by GCC. */
20912 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
20913 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
20915 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
20916 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
20917 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
20918 LONGEST l
= DW_UNSND (attr
);
20920 if (bits
< sizeof (*value
) * 8)
20922 l
&= ((LONGEST
) 1 << bits
) - 1;
20925 else if (bits
== sizeof (*value
) * 8)
20929 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
20930 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
20937 /* Read a constant value from an attribute. Either set *VALUE, or if
20938 the value does not fit in *VALUE, set *BYTES - either already
20939 allocated on the objfile obstack, or newly allocated on OBSTACK,
20940 or, set *BATON, if we translated the constant to a location
20944 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
20945 const char *name
, struct obstack
*obstack
,
20946 struct dwarf2_cu
*cu
,
20947 LONGEST
*value
, const gdb_byte
**bytes
,
20948 struct dwarf2_locexpr_baton
**baton
)
20950 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
20951 struct comp_unit_head
*cu_header
= &cu
->header
;
20952 struct dwarf_block
*blk
;
20953 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
20954 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
20960 switch (attr
->form
)
20963 case DW_FORM_addrx
:
20964 case DW_FORM_GNU_addr_index
:
20968 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
20969 dwarf2_const_value_length_mismatch_complaint (name
,
20970 cu_header
->addr_size
,
20971 TYPE_LENGTH (type
));
20972 /* Symbols of this form are reasonably rare, so we just
20973 piggyback on the existing location code rather than writing
20974 a new implementation of symbol_computed_ops. */
20975 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
20976 (*baton
)->per_cu
= cu
->per_cu
;
20977 gdb_assert ((*baton
)->per_cu
);
20979 (*baton
)->size
= 2 + cu_header
->addr_size
;
20980 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
20981 (*baton
)->data
= data
;
20983 data
[0] = DW_OP_addr
;
20984 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
20985 byte_order
, DW_ADDR (attr
));
20986 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
20989 case DW_FORM_string
:
20992 case DW_FORM_GNU_str_index
:
20993 case DW_FORM_GNU_strp_alt
:
20994 /* DW_STRING is already allocated on the objfile obstack, point
20996 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
20998 case DW_FORM_block1
:
20999 case DW_FORM_block2
:
21000 case DW_FORM_block4
:
21001 case DW_FORM_block
:
21002 case DW_FORM_exprloc
:
21003 case DW_FORM_data16
:
21004 blk
= DW_BLOCK (attr
);
21005 if (TYPE_LENGTH (type
) != blk
->size
)
21006 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
21007 TYPE_LENGTH (type
));
21008 *bytes
= blk
->data
;
21011 /* The DW_AT_const_value attributes are supposed to carry the
21012 symbol's value "represented as it would be on the target
21013 architecture." By the time we get here, it's already been
21014 converted to host endianness, so we just need to sign- or
21015 zero-extend it as appropriate. */
21016 case DW_FORM_data1
:
21017 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
21019 case DW_FORM_data2
:
21020 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
21022 case DW_FORM_data4
:
21023 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
21025 case DW_FORM_data8
:
21026 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
21029 case DW_FORM_sdata
:
21030 case DW_FORM_implicit_const
:
21031 *value
= DW_SND (attr
);
21034 case DW_FORM_udata
:
21035 *value
= DW_UNSND (attr
);
21039 complaint (_("unsupported const value attribute form: '%s'"),
21040 dwarf_form_name (attr
->form
));
21047 /* Copy constant value from an attribute to a symbol. */
21050 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
21051 struct dwarf2_cu
*cu
)
21053 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21055 const gdb_byte
*bytes
;
21056 struct dwarf2_locexpr_baton
*baton
;
21058 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
21059 sym
->print_name (),
21060 &objfile
->objfile_obstack
, cu
,
21061 &value
, &bytes
, &baton
);
21065 SYMBOL_LOCATION_BATON (sym
) = baton
;
21066 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
21068 else if (bytes
!= NULL
)
21070 SYMBOL_VALUE_BYTES (sym
) = bytes
;
21071 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
21075 SYMBOL_VALUE (sym
) = value
;
21076 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
21080 /* Return the type of the die in question using its DW_AT_type attribute. */
21082 static struct type
*
21083 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
21085 struct attribute
*type_attr
;
21087 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
21090 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21091 /* A missing DW_AT_type represents a void type. */
21092 return objfile_type (objfile
)->builtin_void
;
21095 return lookup_die_type (die
, type_attr
, cu
);
21098 /* True iff CU's producer generates GNAT Ada auxiliary information
21099 that allows to find parallel types through that information instead
21100 of having to do expensive parallel lookups by type name. */
21103 need_gnat_info (struct dwarf2_cu
*cu
)
21105 /* Assume that the Ada compiler was GNAT, which always produces
21106 the auxiliary information. */
21107 return (cu
->language
== language_ada
);
21110 /* Return the auxiliary type of the die in question using its
21111 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
21112 attribute is not present. */
21114 static struct type
*
21115 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
21117 struct attribute
*type_attr
;
21119 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
21123 return lookup_die_type (die
, type_attr
, cu
);
21126 /* If DIE has a descriptive_type attribute, then set the TYPE's
21127 descriptive type accordingly. */
21130 set_descriptive_type (struct type
*type
, struct die_info
*die
,
21131 struct dwarf2_cu
*cu
)
21133 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
21135 if (descriptive_type
)
21137 ALLOCATE_GNAT_AUX_TYPE (type
);
21138 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
21142 /* Return the containing type of the die in question using its
21143 DW_AT_containing_type attribute. */
21145 static struct type
*
21146 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
21148 struct attribute
*type_attr
;
21149 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21151 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
21153 error (_("Dwarf Error: Problem turning containing type into gdb type "
21154 "[in module %s]"), objfile_name (objfile
));
21156 return lookup_die_type (die
, type_attr
, cu
);
21159 /* Return an error marker type to use for the ill formed type in DIE/CU. */
21161 static struct type
*
21162 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
21164 struct dwarf2_per_objfile
*dwarf2_per_objfile
21165 = cu
->per_cu
->dwarf2_per_objfile
;
21166 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21169 std::string message
21170 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
21171 objfile_name (objfile
),
21172 sect_offset_str (cu
->header
.sect_off
),
21173 sect_offset_str (die
->sect_off
));
21174 saved
= obstack_strdup (&objfile
->objfile_obstack
, message
);
21176 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
21179 /* Look up the type of DIE in CU using its type attribute ATTR.
21180 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
21181 DW_AT_containing_type.
21182 If there is no type substitute an error marker. */
21184 static struct type
*
21185 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
21186 struct dwarf2_cu
*cu
)
21188 struct dwarf2_per_objfile
*dwarf2_per_objfile
21189 = cu
->per_cu
->dwarf2_per_objfile
;
21190 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21191 struct type
*this_type
;
21193 gdb_assert (attr
->name
== DW_AT_type
21194 || attr
->name
== DW_AT_GNAT_descriptive_type
21195 || attr
->name
== DW_AT_containing_type
);
21197 /* First see if we have it cached. */
21199 if (attr
->form
== DW_FORM_GNU_ref_alt
)
21201 struct dwarf2_per_cu_data
*per_cu
;
21202 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
21204 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1,
21205 dwarf2_per_objfile
);
21206 this_type
= get_die_type_at_offset (sect_off
, per_cu
);
21208 else if (attr
->form_is_ref ())
21210 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
21212 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
21214 else if (attr
->form
== DW_FORM_ref_sig8
)
21216 ULONGEST signature
= DW_SIGNATURE (attr
);
21218 return get_signatured_type (die
, signature
, cu
);
21222 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
21223 " at %s [in module %s]"),
21224 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
21225 objfile_name (objfile
));
21226 return build_error_marker_type (cu
, die
);
21229 /* If not cached we need to read it in. */
21231 if (this_type
== NULL
)
21233 struct die_info
*type_die
= NULL
;
21234 struct dwarf2_cu
*type_cu
= cu
;
21236 if (attr
->form_is_ref ())
21237 type_die
= follow_die_ref (die
, attr
, &type_cu
);
21238 if (type_die
== NULL
)
21239 return build_error_marker_type (cu
, die
);
21240 /* If we find the type now, it's probably because the type came
21241 from an inter-CU reference and the type's CU got expanded before
21243 this_type
= read_type_die (type_die
, type_cu
);
21246 /* If we still don't have a type use an error marker. */
21248 if (this_type
== NULL
)
21249 return build_error_marker_type (cu
, die
);
21254 /* Return the type in DIE, CU.
21255 Returns NULL for invalid types.
21257 This first does a lookup in die_type_hash,
21258 and only reads the die in if necessary.
21260 NOTE: This can be called when reading in partial or full symbols. */
21262 static struct type
*
21263 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
21265 struct type
*this_type
;
21267 this_type
= get_die_type (die
, cu
);
21271 return read_type_die_1 (die
, cu
);
21274 /* Read the type in DIE, CU.
21275 Returns NULL for invalid types. */
21277 static struct type
*
21278 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
21280 struct type
*this_type
= NULL
;
21284 case DW_TAG_class_type
:
21285 case DW_TAG_interface_type
:
21286 case DW_TAG_structure_type
:
21287 case DW_TAG_union_type
:
21288 this_type
= read_structure_type (die
, cu
);
21290 case DW_TAG_enumeration_type
:
21291 this_type
= read_enumeration_type (die
, cu
);
21293 case DW_TAG_subprogram
:
21294 case DW_TAG_subroutine_type
:
21295 case DW_TAG_inlined_subroutine
:
21296 this_type
= read_subroutine_type (die
, cu
);
21298 case DW_TAG_array_type
:
21299 this_type
= read_array_type (die
, cu
);
21301 case DW_TAG_set_type
:
21302 this_type
= read_set_type (die
, cu
);
21304 case DW_TAG_pointer_type
:
21305 this_type
= read_tag_pointer_type (die
, cu
);
21307 case DW_TAG_ptr_to_member_type
:
21308 this_type
= read_tag_ptr_to_member_type (die
, cu
);
21310 case DW_TAG_reference_type
:
21311 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
21313 case DW_TAG_rvalue_reference_type
:
21314 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
21316 case DW_TAG_const_type
:
21317 this_type
= read_tag_const_type (die
, cu
);
21319 case DW_TAG_volatile_type
:
21320 this_type
= read_tag_volatile_type (die
, cu
);
21322 case DW_TAG_restrict_type
:
21323 this_type
= read_tag_restrict_type (die
, cu
);
21325 case DW_TAG_string_type
:
21326 this_type
= read_tag_string_type (die
, cu
);
21328 case DW_TAG_typedef
:
21329 this_type
= read_typedef (die
, cu
);
21331 case DW_TAG_subrange_type
:
21332 this_type
= read_subrange_type (die
, cu
);
21334 case DW_TAG_base_type
:
21335 this_type
= read_base_type (die
, cu
);
21337 case DW_TAG_unspecified_type
:
21338 this_type
= read_unspecified_type (die
, cu
);
21340 case DW_TAG_namespace
:
21341 this_type
= read_namespace_type (die
, cu
);
21343 case DW_TAG_module
:
21344 this_type
= read_module_type (die
, cu
);
21346 case DW_TAG_atomic_type
:
21347 this_type
= read_tag_atomic_type (die
, cu
);
21350 complaint (_("unexpected tag in read_type_die: '%s'"),
21351 dwarf_tag_name (die
->tag
));
21358 /* See if we can figure out if the class lives in a namespace. We do
21359 this by looking for a member function; its demangled name will
21360 contain namespace info, if there is any.
21361 Return the computed name or NULL.
21362 Space for the result is allocated on the objfile's obstack.
21363 This is the full-die version of guess_partial_die_structure_name.
21364 In this case we know DIE has no useful parent. */
21366 static const char *
21367 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
21369 struct die_info
*spec_die
;
21370 struct dwarf2_cu
*spec_cu
;
21371 struct die_info
*child
;
21372 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21375 spec_die
= die_specification (die
, &spec_cu
);
21376 if (spec_die
!= NULL
)
21382 for (child
= die
->child
;
21384 child
= child
->sibling
)
21386 if (child
->tag
== DW_TAG_subprogram
)
21388 const char *linkage_name
= dw2_linkage_name (child
, cu
);
21390 if (linkage_name
!= NULL
)
21392 gdb::unique_xmalloc_ptr
<char> actual_name
21393 (language_class_name_from_physname (cu
->language_defn
,
21395 const char *name
= NULL
;
21397 if (actual_name
!= NULL
)
21399 const char *die_name
= dwarf2_name (die
, cu
);
21401 if (die_name
!= NULL
21402 && strcmp (die_name
, actual_name
.get ()) != 0)
21404 /* Strip off the class name from the full name.
21405 We want the prefix. */
21406 int die_name_len
= strlen (die_name
);
21407 int actual_name_len
= strlen (actual_name
.get ());
21408 const char *ptr
= actual_name
.get ();
21410 /* Test for '::' as a sanity check. */
21411 if (actual_name_len
> die_name_len
+ 2
21412 && ptr
[actual_name_len
- die_name_len
- 1] == ':')
21413 name
= obstack_strndup (
21414 &objfile
->per_bfd
->storage_obstack
,
21415 ptr
, actual_name_len
- die_name_len
- 2);
21426 /* GCC might emit a nameless typedef that has a linkage name. Determine the
21427 prefix part in such case. See
21428 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
21430 static const char *
21431 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
21433 struct attribute
*attr
;
21436 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
21437 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
21440 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
21443 attr
= dw2_linkage_name_attr (die
, cu
);
21444 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
21447 /* dwarf2_name had to be already called. */
21448 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
21450 /* Strip the base name, keep any leading namespaces/classes. */
21451 base
= strrchr (DW_STRING (attr
), ':');
21452 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
21455 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21456 return obstack_strndup (&objfile
->per_bfd
->storage_obstack
,
21458 &base
[-1] - DW_STRING (attr
));
21461 /* Return the name of the namespace/class that DIE is defined within,
21462 or "" if we can't tell. The caller should not xfree the result.
21464 For example, if we're within the method foo() in the following
21474 then determine_prefix on foo's die will return "N::C". */
21476 static const char *
21477 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
21479 struct dwarf2_per_objfile
*dwarf2_per_objfile
21480 = cu
->per_cu
->dwarf2_per_objfile
;
21481 struct die_info
*parent
, *spec_die
;
21482 struct dwarf2_cu
*spec_cu
;
21483 struct type
*parent_type
;
21484 const char *retval
;
21486 if (cu
->language
!= language_cplus
21487 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
21488 && cu
->language
!= language_rust
)
21491 retval
= anonymous_struct_prefix (die
, cu
);
21495 /* We have to be careful in the presence of DW_AT_specification.
21496 For example, with GCC 3.4, given the code
21500 // Definition of N::foo.
21504 then we'll have a tree of DIEs like this:
21506 1: DW_TAG_compile_unit
21507 2: DW_TAG_namespace // N
21508 3: DW_TAG_subprogram // declaration of N::foo
21509 4: DW_TAG_subprogram // definition of N::foo
21510 DW_AT_specification // refers to die #3
21512 Thus, when processing die #4, we have to pretend that we're in
21513 the context of its DW_AT_specification, namely the contex of die
21516 spec_die
= die_specification (die
, &spec_cu
);
21517 if (spec_die
== NULL
)
21518 parent
= die
->parent
;
21521 parent
= spec_die
->parent
;
21525 if (parent
== NULL
)
21527 else if (parent
->building_fullname
)
21530 const char *parent_name
;
21532 /* It has been seen on RealView 2.2 built binaries,
21533 DW_TAG_template_type_param types actually _defined_ as
21534 children of the parent class:
21537 template class <class Enum> Class{};
21538 Class<enum E> class_e;
21540 1: DW_TAG_class_type (Class)
21541 2: DW_TAG_enumeration_type (E)
21542 3: DW_TAG_enumerator (enum1:0)
21543 3: DW_TAG_enumerator (enum2:1)
21545 2: DW_TAG_template_type_param
21546 DW_AT_type DW_FORM_ref_udata (E)
21548 Besides being broken debug info, it can put GDB into an
21549 infinite loop. Consider:
21551 When we're building the full name for Class<E>, we'll start
21552 at Class, and go look over its template type parameters,
21553 finding E. We'll then try to build the full name of E, and
21554 reach here. We're now trying to build the full name of E,
21555 and look over the parent DIE for containing scope. In the
21556 broken case, if we followed the parent DIE of E, we'd again
21557 find Class, and once again go look at its template type
21558 arguments, etc., etc. Simply don't consider such parent die
21559 as source-level parent of this die (it can't be, the language
21560 doesn't allow it), and break the loop here. */
21561 name
= dwarf2_name (die
, cu
);
21562 parent_name
= dwarf2_name (parent
, cu
);
21563 complaint (_("template param type '%s' defined within parent '%s'"),
21564 name
? name
: "<unknown>",
21565 parent_name
? parent_name
: "<unknown>");
21569 switch (parent
->tag
)
21571 case DW_TAG_namespace
:
21572 parent_type
= read_type_die (parent
, cu
);
21573 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
21574 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
21575 Work around this problem here. */
21576 if (cu
->language
== language_cplus
21577 && strcmp (TYPE_NAME (parent_type
), "::") == 0)
21579 /* We give a name to even anonymous namespaces. */
21580 return TYPE_NAME (parent_type
);
21581 case DW_TAG_class_type
:
21582 case DW_TAG_interface_type
:
21583 case DW_TAG_structure_type
:
21584 case DW_TAG_union_type
:
21585 case DW_TAG_module
:
21586 parent_type
= read_type_die (parent
, cu
);
21587 if (TYPE_NAME (parent_type
) != NULL
)
21588 return TYPE_NAME (parent_type
);
21590 /* An anonymous structure is only allowed non-static data
21591 members; no typedefs, no member functions, et cetera.
21592 So it does not need a prefix. */
21594 case DW_TAG_compile_unit
:
21595 case DW_TAG_partial_unit
:
21596 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
21597 if (cu
->language
== language_cplus
21598 && !dwarf2_per_objfile
->types
.empty ()
21599 && die
->child
!= NULL
21600 && (die
->tag
== DW_TAG_class_type
21601 || die
->tag
== DW_TAG_structure_type
21602 || die
->tag
== DW_TAG_union_type
))
21604 const char *name
= guess_full_die_structure_name (die
, cu
);
21609 case DW_TAG_subprogram
:
21610 /* Nested subroutines in Fortran get a prefix with the name
21611 of the parent's subroutine. */
21612 if (cu
->language
== language_fortran
)
21614 if ((die
->tag
== DW_TAG_subprogram
)
21615 && (dwarf2_name (parent
, cu
) != NULL
))
21616 return dwarf2_name (parent
, cu
);
21618 return determine_prefix (parent
, cu
);
21619 case DW_TAG_enumeration_type
:
21620 parent_type
= read_type_die (parent
, cu
);
21621 if (TYPE_DECLARED_CLASS (parent_type
))
21623 if (TYPE_NAME (parent_type
) != NULL
)
21624 return TYPE_NAME (parent_type
);
21627 /* Fall through. */
21629 return determine_prefix (parent
, cu
);
21633 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
21634 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
21635 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
21636 an obconcat, otherwise allocate storage for the result. The CU argument is
21637 used to determine the language and hence, the appropriate separator. */
21639 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
21642 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
21643 int physname
, struct dwarf2_cu
*cu
)
21645 const char *lead
= "";
21648 if (suffix
== NULL
|| suffix
[0] == '\0'
21649 || prefix
== NULL
|| prefix
[0] == '\0')
21651 else if (cu
->language
== language_d
)
21653 /* For D, the 'main' function could be defined in any module, but it
21654 should never be prefixed. */
21655 if (strcmp (suffix
, "D main") == 0)
21663 else if (cu
->language
== language_fortran
&& physname
)
21665 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
21666 DW_AT_MIPS_linkage_name is preferred and used instead. */
21674 if (prefix
== NULL
)
21676 if (suffix
== NULL
)
21683 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
21685 strcpy (retval
, lead
);
21686 strcat (retval
, prefix
);
21687 strcat (retval
, sep
);
21688 strcat (retval
, suffix
);
21693 /* We have an obstack. */
21694 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
21698 /* Return sibling of die, NULL if no sibling. */
21700 static struct die_info
*
21701 sibling_die (struct die_info
*die
)
21703 return die
->sibling
;
21706 /* Get name of a die, return NULL if not found. */
21708 static const char *
21709 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
21710 struct objfile
*objfile
)
21712 if (name
&& cu
->language
== language_cplus
)
21714 std::string canon_name
= cp_canonicalize_string (name
);
21716 if (!canon_name
.empty ())
21718 if (canon_name
!= name
)
21719 name
= objfile
->intern (canon_name
);
21726 /* Get name of a die, return NULL if not found.
21727 Anonymous namespaces are converted to their magic string. */
21729 static const char *
21730 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
21732 struct attribute
*attr
;
21733 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21735 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
21736 if ((!attr
|| !DW_STRING (attr
))
21737 && die
->tag
!= DW_TAG_namespace
21738 && die
->tag
!= DW_TAG_class_type
21739 && die
->tag
!= DW_TAG_interface_type
21740 && die
->tag
!= DW_TAG_structure_type
21741 && die
->tag
!= DW_TAG_union_type
)
21746 case DW_TAG_compile_unit
:
21747 case DW_TAG_partial_unit
:
21748 /* Compilation units have a DW_AT_name that is a filename, not
21749 a source language identifier. */
21750 case DW_TAG_enumeration_type
:
21751 case DW_TAG_enumerator
:
21752 /* These tags always have simple identifiers already; no need
21753 to canonicalize them. */
21754 return DW_STRING (attr
);
21756 case DW_TAG_namespace
:
21757 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
21758 return DW_STRING (attr
);
21759 return CP_ANONYMOUS_NAMESPACE_STR
;
21761 case DW_TAG_class_type
:
21762 case DW_TAG_interface_type
:
21763 case DW_TAG_structure_type
:
21764 case DW_TAG_union_type
:
21765 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
21766 structures or unions. These were of the form "._%d" in GCC 4.1,
21767 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
21768 and GCC 4.4. We work around this problem by ignoring these. */
21769 if (attr
&& DW_STRING (attr
)
21770 && (startswith (DW_STRING (attr
), "._")
21771 || startswith (DW_STRING (attr
), "<anonymous")))
21774 /* GCC might emit a nameless typedef that has a linkage name. See
21775 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
21776 if (!attr
|| DW_STRING (attr
) == NULL
)
21778 attr
= dw2_linkage_name_attr (die
, cu
);
21779 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
21782 /* Avoid demangling DW_STRING (attr) the second time on a second
21783 call for the same DIE. */
21784 if (!DW_STRING_IS_CANONICAL (attr
))
21786 gdb::unique_xmalloc_ptr
<char> demangled
21787 (gdb_demangle (DW_STRING (attr
), DMGL_TYPES
));
21788 if (demangled
== nullptr)
21793 DW_STRING (attr
) = objfile
->intern (demangled
.get ());
21794 DW_STRING_IS_CANONICAL (attr
) = 1;
21796 /* Strip any leading namespaces/classes, keep only the base name.
21797 DW_AT_name for named DIEs does not contain the prefixes. */
21798 base
= strrchr (DW_STRING (attr
), ':');
21799 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
21802 return DW_STRING (attr
);
21811 if (!DW_STRING_IS_CANONICAL (attr
))
21813 DW_STRING (attr
) = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
21815 DW_STRING_IS_CANONICAL (attr
) = 1;
21817 return DW_STRING (attr
);
21820 /* Return the die that this die in an extension of, or NULL if there
21821 is none. *EXT_CU is the CU containing DIE on input, and the CU
21822 containing the return value on output. */
21824 static struct die_info
*
21825 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
21827 struct attribute
*attr
;
21829 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
21833 return follow_die_ref (die
, attr
, ext_cu
);
21836 /* A convenience function that returns an "unknown" DWARF name,
21837 including the value of V. STR is the name of the entity being
21838 printed, e.g., "TAG". */
21840 static const char *
21841 dwarf_unknown (const char *str
, unsigned v
)
21843 char *cell
= get_print_cell ();
21844 xsnprintf (cell
, PRINT_CELL_SIZE
, "DW_%s_<unknown: %u>", str
, v
);
21848 /* Convert a DIE tag into its string name. */
21850 static const char *
21851 dwarf_tag_name (unsigned tag
)
21853 const char *name
= get_DW_TAG_name (tag
);
21856 return dwarf_unknown ("TAG", tag
);
21861 /* Convert a DWARF attribute code into its string name. */
21863 static const char *
21864 dwarf_attr_name (unsigned attr
)
21868 #ifdef MIPS /* collides with DW_AT_HP_block_index */
21869 if (attr
== DW_AT_MIPS_fde
)
21870 return "DW_AT_MIPS_fde";
21872 if (attr
== DW_AT_HP_block_index
)
21873 return "DW_AT_HP_block_index";
21876 name
= get_DW_AT_name (attr
);
21879 return dwarf_unknown ("AT", attr
);
21884 /* Convert a DWARF value form code into its string name. */
21886 static const char *
21887 dwarf_form_name (unsigned form
)
21889 const char *name
= get_DW_FORM_name (form
);
21892 return dwarf_unknown ("FORM", form
);
21897 static const char *
21898 dwarf_bool_name (unsigned mybool
)
21906 /* Convert a DWARF type code into its string name. */
21908 static const char *
21909 dwarf_type_encoding_name (unsigned enc
)
21911 const char *name
= get_DW_ATE_name (enc
);
21914 return dwarf_unknown ("ATE", enc
);
21920 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
21924 print_spaces (indent
, f
);
21925 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
21926 dwarf_tag_name (die
->tag
), die
->abbrev
,
21927 sect_offset_str (die
->sect_off
));
21929 if (die
->parent
!= NULL
)
21931 print_spaces (indent
, f
);
21932 fprintf_unfiltered (f
, " parent at offset: %s\n",
21933 sect_offset_str (die
->parent
->sect_off
));
21936 print_spaces (indent
, f
);
21937 fprintf_unfiltered (f
, " has children: %s\n",
21938 dwarf_bool_name (die
->child
!= NULL
));
21940 print_spaces (indent
, f
);
21941 fprintf_unfiltered (f
, " attributes:\n");
21943 for (i
= 0; i
< die
->num_attrs
; ++i
)
21945 print_spaces (indent
, f
);
21946 fprintf_unfiltered (f
, " %s (%s) ",
21947 dwarf_attr_name (die
->attrs
[i
].name
),
21948 dwarf_form_name (die
->attrs
[i
].form
));
21950 switch (die
->attrs
[i
].form
)
21953 case DW_FORM_addrx
:
21954 case DW_FORM_GNU_addr_index
:
21955 fprintf_unfiltered (f
, "address: ");
21956 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
21958 case DW_FORM_block2
:
21959 case DW_FORM_block4
:
21960 case DW_FORM_block
:
21961 case DW_FORM_block1
:
21962 fprintf_unfiltered (f
, "block: size %s",
21963 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
21965 case DW_FORM_exprloc
:
21966 fprintf_unfiltered (f
, "expression: size %s",
21967 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
21969 case DW_FORM_data16
:
21970 fprintf_unfiltered (f
, "constant of 16 bytes");
21972 case DW_FORM_ref_addr
:
21973 fprintf_unfiltered (f
, "ref address: ");
21974 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
21976 case DW_FORM_GNU_ref_alt
:
21977 fprintf_unfiltered (f
, "alt ref address: ");
21978 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
21984 case DW_FORM_ref_udata
:
21985 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
21986 (long) (DW_UNSND (&die
->attrs
[i
])));
21988 case DW_FORM_data1
:
21989 case DW_FORM_data2
:
21990 case DW_FORM_data4
:
21991 case DW_FORM_data8
:
21992 case DW_FORM_udata
:
21993 case DW_FORM_sdata
:
21994 fprintf_unfiltered (f
, "constant: %s",
21995 pulongest (DW_UNSND (&die
->attrs
[i
])));
21997 case DW_FORM_sec_offset
:
21998 fprintf_unfiltered (f
, "section offset: %s",
21999 pulongest (DW_UNSND (&die
->attrs
[i
])));
22001 case DW_FORM_ref_sig8
:
22002 fprintf_unfiltered (f
, "signature: %s",
22003 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
22005 case DW_FORM_string
:
22007 case DW_FORM_line_strp
:
22009 case DW_FORM_GNU_str_index
:
22010 case DW_FORM_GNU_strp_alt
:
22011 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
22012 DW_STRING (&die
->attrs
[i
])
22013 ? DW_STRING (&die
->attrs
[i
]) : "",
22014 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
22017 if (DW_UNSND (&die
->attrs
[i
]))
22018 fprintf_unfiltered (f
, "flag: TRUE");
22020 fprintf_unfiltered (f
, "flag: FALSE");
22022 case DW_FORM_flag_present
:
22023 fprintf_unfiltered (f
, "flag: TRUE");
22025 case DW_FORM_indirect
:
22026 /* The reader will have reduced the indirect form to
22027 the "base form" so this form should not occur. */
22028 fprintf_unfiltered (f
,
22029 "unexpected attribute form: DW_FORM_indirect");
22031 case DW_FORM_implicit_const
:
22032 fprintf_unfiltered (f
, "constant: %s",
22033 plongest (DW_SND (&die
->attrs
[i
])));
22036 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
22037 die
->attrs
[i
].form
);
22040 fprintf_unfiltered (f
, "\n");
22045 dump_die_for_error (struct die_info
*die
)
22047 dump_die_shallow (gdb_stderr
, 0, die
);
22051 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
22053 int indent
= level
* 4;
22055 gdb_assert (die
!= NULL
);
22057 if (level
>= max_level
)
22060 dump_die_shallow (f
, indent
, die
);
22062 if (die
->child
!= NULL
)
22064 print_spaces (indent
, f
);
22065 fprintf_unfiltered (f
, " Children:");
22066 if (level
+ 1 < max_level
)
22068 fprintf_unfiltered (f
, "\n");
22069 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
22073 fprintf_unfiltered (f
,
22074 " [not printed, max nesting level reached]\n");
22078 if (die
->sibling
!= NULL
&& level
> 0)
22080 dump_die_1 (f
, level
, max_level
, die
->sibling
);
22084 /* This is called from the pdie macro in gdbinit.in.
22085 It's not static so gcc will keep a copy callable from gdb. */
22088 dump_die (struct die_info
*die
, int max_level
)
22090 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
22094 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
22098 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
22099 to_underlying (die
->sect_off
),
22105 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
22109 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
22111 if (attr
->form_is_ref ())
22112 return (sect_offset
) DW_UNSND (attr
);
22114 complaint (_("unsupported die ref attribute form: '%s'"),
22115 dwarf_form_name (attr
->form
));
22119 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
22120 * the value held by the attribute is not constant. */
22123 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
22125 if (attr
->form
== DW_FORM_sdata
|| attr
->form
== DW_FORM_implicit_const
)
22126 return DW_SND (attr
);
22127 else if (attr
->form
== DW_FORM_udata
22128 || attr
->form
== DW_FORM_data1
22129 || attr
->form
== DW_FORM_data2
22130 || attr
->form
== DW_FORM_data4
22131 || attr
->form
== DW_FORM_data8
)
22132 return DW_UNSND (attr
);
22135 /* For DW_FORM_data16 see attribute::form_is_constant. */
22136 complaint (_("Attribute value is not a constant (%s)"),
22137 dwarf_form_name (attr
->form
));
22138 return default_value
;
22142 /* Follow reference or signature attribute ATTR of SRC_DIE.
22143 On entry *REF_CU is the CU of SRC_DIE.
22144 On exit *REF_CU is the CU of the result. */
22146 static struct die_info
*
22147 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
22148 struct dwarf2_cu
**ref_cu
)
22150 struct die_info
*die
;
22152 if (attr
->form_is_ref ())
22153 die
= follow_die_ref (src_die
, attr
, ref_cu
);
22154 else if (attr
->form
== DW_FORM_ref_sig8
)
22155 die
= follow_die_sig (src_die
, attr
, ref_cu
);
22158 dump_die_for_error (src_die
);
22159 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
22160 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
22166 /* Follow reference OFFSET.
22167 On entry *REF_CU is the CU of the source die referencing OFFSET.
22168 On exit *REF_CU is the CU of the result.
22169 Returns NULL if OFFSET is invalid. */
22171 static struct die_info
*
22172 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
22173 struct dwarf2_cu
**ref_cu
)
22175 struct die_info temp_die
;
22176 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
22177 struct dwarf2_per_objfile
*dwarf2_per_objfile
22178 = cu
->per_cu
->dwarf2_per_objfile
;
22180 gdb_assert (cu
->per_cu
!= NULL
);
22184 if (cu
->per_cu
->is_debug_types
)
22186 /* .debug_types CUs cannot reference anything outside their CU.
22187 If they need to, they have to reference a signatured type via
22188 DW_FORM_ref_sig8. */
22189 if (!cu
->header
.offset_in_cu_p (sect_off
))
22192 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
22193 || !cu
->header
.offset_in_cu_p (sect_off
))
22195 struct dwarf2_per_cu_data
*per_cu
;
22197 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
22198 dwarf2_per_objfile
);
22200 /* If necessary, add it to the queue and load its DIEs. */
22201 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
22202 load_full_comp_unit (per_cu
, false, cu
->language
);
22204 target_cu
= per_cu
->cu
;
22206 else if (cu
->dies
== NULL
)
22208 /* We're loading full DIEs during partial symbol reading. */
22209 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
22210 load_full_comp_unit (cu
->per_cu
, false, language_minimal
);
22213 *ref_cu
= target_cu
;
22214 temp_die
.sect_off
= sect_off
;
22216 if (target_cu
!= cu
)
22217 target_cu
->ancestor
= cu
;
22219 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
22221 to_underlying (sect_off
));
22224 /* Follow reference attribute ATTR of SRC_DIE.
22225 On entry *REF_CU is the CU of SRC_DIE.
22226 On exit *REF_CU is the CU of the result. */
22228 static struct die_info
*
22229 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
22230 struct dwarf2_cu
**ref_cu
)
22232 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
22233 struct dwarf2_cu
*cu
= *ref_cu
;
22234 struct die_info
*die
;
22236 die
= follow_die_offset (sect_off
,
22237 (attr
->form
== DW_FORM_GNU_ref_alt
22238 || cu
->per_cu
->is_dwz
),
22241 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
22242 "at %s [in module %s]"),
22243 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
22244 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
22251 struct dwarf2_locexpr_baton
22252 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
22253 dwarf2_per_cu_data
*per_cu
,
22254 CORE_ADDR (*get_frame_pc
) (void *baton
),
22255 void *baton
, bool resolve_abstract_p
)
22257 struct dwarf2_cu
*cu
;
22258 struct die_info
*die
;
22259 struct attribute
*attr
;
22260 struct dwarf2_locexpr_baton retval
;
22261 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
22262 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22264 if (per_cu
->cu
== NULL
)
22265 load_cu (per_cu
, false);
22269 /* We shouldn't get here for a dummy CU, but don't crash on the user.
22270 Instead just throw an error, not much else we can do. */
22271 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
22272 sect_offset_str (sect_off
), objfile_name (objfile
));
22275 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
22277 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
22278 sect_offset_str (sect_off
), objfile_name (objfile
));
22280 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
22281 if (!attr
&& resolve_abstract_p
22282 && (dwarf2_per_objfile
->abstract_to_concrete
.find (die
->sect_off
)
22283 != dwarf2_per_objfile
->abstract_to_concrete
.end ()))
22285 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
22286 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
22287 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
22289 for (const auto &cand_off
22290 : dwarf2_per_objfile
->abstract_to_concrete
[die
->sect_off
])
22292 struct dwarf2_cu
*cand_cu
= cu
;
22293 struct die_info
*cand
22294 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
22297 || cand
->parent
->tag
!= DW_TAG_subprogram
)
22300 CORE_ADDR pc_low
, pc_high
;
22301 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
22302 if (pc_low
== ((CORE_ADDR
) -1))
22304 pc_low
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_low
+ baseaddr
);
22305 pc_high
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_high
+ baseaddr
);
22306 if (!(pc_low
<= pc
&& pc
< pc_high
))
22310 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
22317 /* DWARF: "If there is no such attribute, then there is no effect.".
22318 DATA is ignored if SIZE is 0. */
22320 retval
.data
= NULL
;
22323 else if (attr
->form_is_section_offset ())
22325 struct dwarf2_loclist_baton loclist_baton
;
22326 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
22329 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
22331 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
22333 retval
.size
= size
;
22337 if (!attr
->form_is_block ())
22338 error (_("Dwarf Error: DIE at %s referenced in module %s "
22339 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
22340 sect_offset_str (sect_off
), objfile_name (objfile
));
22342 retval
.data
= DW_BLOCK (attr
)->data
;
22343 retval
.size
= DW_BLOCK (attr
)->size
;
22345 retval
.per_cu
= cu
->per_cu
;
22347 age_cached_comp_units (dwarf2_per_objfile
);
22354 struct dwarf2_locexpr_baton
22355 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
22356 dwarf2_per_cu_data
*per_cu
,
22357 CORE_ADDR (*get_frame_pc
) (void *baton
),
22360 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
22362 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, get_frame_pc
, baton
);
22365 /* Write a constant of a given type as target-ordered bytes into
22368 static const gdb_byte
*
22369 write_constant_as_bytes (struct obstack
*obstack
,
22370 enum bfd_endian byte_order
,
22377 *len
= TYPE_LENGTH (type
);
22378 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
22379 store_unsigned_integer (result
, *len
, byte_order
, value
);
22387 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
22388 dwarf2_per_cu_data
*per_cu
,
22392 struct dwarf2_cu
*cu
;
22393 struct die_info
*die
;
22394 struct attribute
*attr
;
22395 const gdb_byte
*result
= NULL
;
22398 enum bfd_endian byte_order
;
22399 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
22401 if (per_cu
->cu
== NULL
)
22402 load_cu (per_cu
, false);
22406 /* We shouldn't get here for a dummy CU, but don't crash on the user.
22407 Instead just throw an error, not much else we can do. */
22408 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
22409 sect_offset_str (sect_off
), objfile_name (objfile
));
22412 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
22414 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
22415 sect_offset_str (sect_off
), objfile_name (objfile
));
22417 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22421 byte_order
= (bfd_big_endian (objfile
->obfd
)
22422 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
22424 switch (attr
->form
)
22427 case DW_FORM_addrx
:
22428 case DW_FORM_GNU_addr_index
:
22432 *len
= cu
->header
.addr_size
;
22433 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
22434 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
22438 case DW_FORM_string
:
22441 case DW_FORM_GNU_str_index
:
22442 case DW_FORM_GNU_strp_alt
:
22443 /* DW_STRING is already allocated on the objfile obstack, point
22445 result
= (const gdb_byte
*) DW_STRING (attr
);
22446 *len
= strlen (DW_STRING (attr
));
22448 case DW_FORM_block1
:
22449 case DW_FORM_block2
:
22450 case DW_FORM_block4
:
22451 case DW_FORM_block
:
22452 case DW_FORM_exprloc
:
22453 case DW_FORM_data16
:
22454 result
= DW_BLOCK (attr
)->data
;
22455 *len
= DW_BLOCK (attr
)->size
;
22458 /* The DW_AT_const_value attributes are supposed to carry the
22459 symbol's value "represented as it would be on the target
22460 architecture." By the time we get here, it's already been
22461 converted to host endianness, so we just need to sign- or
22462 zero-extend it as appropriate. */
22463 case DW_FORM_data1
:
22464 type
= die_type (die
, cu
);
22465 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
22466 if (result
== NULL
)
22467 result
= write_constant_as_bytes (obstack
, byte_order
,
22470 case DW_FORM_data2
:
22471 type
= die_type (die
, cu
);
22472 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
22473 if (result
== NULL
)
22474 result
= write_constant_as_bytes (obstack
, byte_order
,
22477 case DW_FORM_data4
:
22478 type
= die_type (die
, cu
);
22479 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
22480 if (result
== NULL
)
22481 result
= write_constant_as_bytes (obstack
, byte_order
,
22484 case DW_FORM_data8
:
22485 type
= die_type (die
, cu
);
22486 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
22487 if (result
== NULL
)
22488 result
= write_constant_as_bytes (obstack
, byte_order
,
22492 case DW_FORM_sdata
:
22493 case DW_FORM_implicit_const
:
22494 type
= die_type (die
, cu
);
22495 result
= write_constant_as_bytes (obstack
, byte_order
,
22496 type
, DW_SND (attr
), len
);
22499 case DW_FORM_udata
:
22500 type
= die_type (die
, cu
);
22501 result
= write_constant_as_bytes (obstack
, byte_order
,
22502 type
, DW_UNSND (attr
), len
);
22506 complaint (_("unsupported const value attribute form: '%s'"),
22507 dwarf_form_name (attr
->form
));
22517 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
22518 dwarf2_per_cu_data
*per_cu
)
22520 struct dwarf2_cu
*cu
;
22521 struct die_info
*die
;
22523 if (per_cu
->cu
== NULL
)
22524 load_cu (per_cu
, false);
22529 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
22533 return die_type (die
, cu
);
22539 dwarf2_get_die_type (cu_offset die_offset
,
22540 struct dwarf2_per_cu_data
*per_cu
)
22542 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
22543 return get_die_type_at_offset (die_offset_sect
, per_cu
);
22546 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
22547 On entry *REF_CU is the CU of SRC_DIE.
22548 On exit *REF_CU is the CU of the result.
22549 Returns NULL if the referenced DIE isn't found. */
22551 static struct die_info
*
22552 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
22553 struct dwarf2_cu
**ref_cu
)
22555 struct die_info temp_die
;
22556 struct dwarf2_cu
*sig_cu
, *cu
= *ref_cu
;
22557 struct die_info
*die
;
22559 /* While it might be nice to assert sig_type->type == NULL here,
22560 we can get here for DW_AT_imported_declaration where we need
22561 the DIE not the type. */
22563 /* If necessary, add it to the queue and load its DIEs. */
22565 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
22566 read_signatured_type (sig_type
);
22568 sig_cu
= sig_type
->per_cu
.cu
;
22569 gdb_assert (sig_cu
!= NULL
);
22570 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
22571 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
22572 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
22573 to_underlying (temp_die
.sect_off
));
22576 struct dwarf2_per_objfile
*dwarf2_per_objfile
22577 = (*ref_cu
)->per_cu
->dwarf2_per_objfile
;
22579 /* For .gdb_index version 7 keep track of included TUs.
22580 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
22581 if (dwarf2_per_objfile
->index_table
!= NULL
22582 && dwarf2_per_objfile
->index_table
->version
<= 7)
22584 (*ref_cu
)->per_cu
->imported_symtabs_push (sig_cu
->per_cu
);
22589 sig_cu
->ancestor
= cu
;
22597 /* Follow signatured type referenced by ATTR in SRC_DIE.
22598 On entry *REF_CU is the CU of SRC_DIE.
22599 On exit *REF_CU is the CU of the result.
22600 The result is the DIE of the type.
22601 If the referenced type cannot be found an error is thrown. */
22603 static struct die_info
*
22604 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
22605 struct dwarf2_cu
**ref_cu
)
22607 ULONGEST signature
= DW_SIGNATURE (attr
);
22608 struct signatured_type
*sig_type
;
22609 struct die_info
*die
;
22611 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
22613 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
22614 /* sig_type will be NULL if the signatured type is missing from
22616 if (sig_type
== NULL
)
22618 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
22619 " from DIE at %s [in module %s]"),
22620 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
22621 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
22624 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
22627 dump_die_for_error (src_die
);
22628 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
22629 " from DIE at %s [in module %s]"),
22630 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
22631 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
22637 /* Get the type specified by SIGNATURE referenced in DIE/CU,
22638 reading in and processing the type unit if necessary. */
22640 static struct type
*
22641 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
22642 struct dwarf2_cu
*cu
)
22644 struct dwarf2_per_objfile
*dwarf2_per_objfile
22645 = cu
->per_cu
->dwarf2_per_objfile
;
22646 struct signatured_type
*sig_type
;
22647 struct dwarf2_cu
*type_cu
;
22648 struct die_info
*type_die
;
22651 sig_type
= lookup_signatured_type (cu
, signature
);
22652 /* sig_type will be NULL if the signatured type is missing from
22654 if (sig_type
== NULL
)
22656 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
22657 " from DIE at %s [in module %s]"),
22658 hex_string (signature
), sect_offset_str (die
->sect_off
),
22659 objfile_name (dwarf2_per_objfile
->objfile
));
22660 return build_error_marker_type (cu
, die
);
22663 /* If we already know the type we're done. */
22664 if (sig_type
->type
!= NULL
)
22665 return sig_type
->type
;
22668 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
22669 if (type_die
!= NULL
)
22671 /* N.B. We need to call get_die_type to ensure only one type for this DIE
22672 is created. This is important, for example, because for c++ classes
22673 we need TYPE_NAME set which is only done by new_symbol. Blech. */
22674 type
= read_type_die (type_die
, type_cu
);
22677 complaint (_("Dwarf Error: Cannot build signatured type %s"
22678 " referenced from DIE at %s [in module %s]"),
22679 hex_string (signature
), sect_offset_str (die
->sect_off
),
22680 objfile_name (dwarf2_per_objfile
->objfile
));
22681 type
= build_error_marker_type (cu
, die
);
22686 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
22687 " from DIE at %s [in module %s]"),
22688 hex_string (signature
), sect_offset_str (die
->sect_off
),
22689 objfile_name (dwarf2_per_objfile
->objfile
));
22690 type
= build_error_marker_type (cu
, die
);
22692 sig_type
->type
= type
;
22697 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
22698 reading in and processing the type unit if necessary. */
22700 static struct type
*
22701 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
22702 struct dwarf2_cu
*cu
) /* ARI: editCase function */
22704 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
22705 if (attr
->form_is_ref ())
22707 struct dwarf2_cu
*type_cu
= cu
;
22708 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
22710 return read_type_die (type_die
, type_cu
);
22712 else if (attr
->form
== DW_FORM_ref_sig8
)
22714 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
22718 struct dwarf2_per_objfile
*dwarf2_per_objfile
22719 = cu
->per_cu
->dwarf2_per_objfile
;
22721 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
22722 " at %s [in module %s]"),
22723 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
22724 objfile_name (dwarf2_per_objfile
->objfile
));
22725 return build_error_marker_type (cu
, die
);
22729 /* Load the DIEs associated with type unit PER_CU into memory. */
22732 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
22734 struct signatured_type
*sig_type
;
22736 /* Caller is responsible for ensuring type_unit_groups don't get here. */
22737 gdb_assert (! per_cu
->type_unit_group_p ());
22739 /* We have the per_cu, but we need the signatured_type.
22740 Fortunately this is an easy translation. */
22741 gdb_assert (per_cu
->is_debug_types
);
22742 sig_type
= (struct signatured_type
*) per_cu
;
22744 gdb_assert (per_cu
->cu
== NULL
);
22746 read_signatured_type (sig_type
);
22748 gdb_assert (per_cu
->cu
!= NULL
);
22751 /* Read in a signatured type and build its CU and DIEs.
22752 If the type is a stub for the real type in a DWO file,
22753 read in the real type from the DWO file as well. */
22756 read_signatured_type (struct signatured_type
*sig_type
)
22758 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
22760 gdb_assert (per_cu
->is_debug_types
);
22761 gdb_assert (per_cu
->cu
== NULL
);
22763 cutu_reader
reader (per_cu
, NULL
, 0, false);
22765 if (!reader
.dummy_p
)
22767 struct dwarf2_cu
*cu
= reader
.cu
;
22768 const gdb_byte
*info_ptr
= reader
.info_ptr
;
22770 gdb_assert (cu
->die_hash
== NULL
);
22772 htab_create_alloc_ex (cu
->header
.length
/ 12,
22776 &cu
->comp_unit_obstack
,
22777 hashtab_obstack_allocate
,
22778 dummy_obstack_deallocate
);
22780 if (reader
.comp_unit_die
->has_children
)
22781 reader
.comp_unit_die
->child
22782 = read_die_and_siblings (&reader
, info_ptr
, &info_ptr
,
22783 reader
.comp_unit_die
);
22784 cu
->dies
= reader
.comp_unit_die
;
22785 /* comp_unit_die is not stored in die_hash, no need. */
22787 /* We try not to read any attributes in this function, because
22788 not all CUs needed for references have been loaded yet, and
22789 symbol table processing isn't initialized. But we have to
22790 set the CU language, or we won't be able to build types
22791 correctly. Similarly, if we do not read the producer, we can
22792 not apply producer-specific interpretation. */
22793 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
22798 sig_type
->per_cu
.tu_read
= 1;
22801 /* Decode simple location descriptions.
22802 Given a pointer to a dwarf block that defines a location, compute
22803 the location and return the value.
22805 NOTE drow/2003-11-18: This function is called in two situations
22806 now: for the address of static or global variables (partial symbols
22807 only) and for offsets into structures which are expected to be
22808 (more or less) constant. The partial symbol case should go away,
22809 and only the constant case should remain. That will let this
22810 function complain more accurately. A few special modes are allowed
22811 without complaint for global variables (for instance, global
22812 register values and thread-local values).
22814 A location description containing no operations indicates that the
22815 object is optimized out. The return value is 0 for that case.
22816 FIXME drow/2003-11-16: No callers check for this case any more; soon all
22817 callers will only want a very basic result and this can become a
22820 Note that stack[0] is unused except as a default error return. */
22823 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
22825 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22827 size_t size
= blk
->size
;
22828 const gdb_byte
*data
= blk
->data
;
22829 CORE_ADDR stack
[64];
22831 unsigned int bytes_read
, unsnd
;
22837 stack
[++stacki
] = 0;
22876 stack
[++stacki
] = op
- DW_OP_lit0
;
22911 stack
[++stacki
] = op
- DW_OP_reg0
;
22913 dwarf2_complex_location_expr_complaint ();
22917 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
22919 stack
[++stacki
] = unsnd
;
22921 dwarf2_complex_location_expr_complaint ();
22925 stack
[++stacki
] = cu
->header
.read_address (objfile
->obfd
, &data
[i
],
22930 case DW_OP_const1u
:
22931 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
22935 case DW_OP_const1s
:
22936 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
22940 case DW_OP_const2u
:
22941 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
22945 case DW_OP_const2s
:
22946 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
22950 case DW_OP_const4u
:
22951 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
22955 case DW_OP_const4s
:
22956 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
22960 case DW_OP_const8u
:
22961 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
22966 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
22972 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
22977 stack
[stacki
+ 1] = stack
[stacki
];
22982 stack
[stacki
- 1] += stack
[stacki
];
22986 case DW_OP_plus_uconst
:
22987 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
22993 stack
[stacki
- 1] -= stack
[stacki
];
22998 /* If we're not the last op, then we definitely can't encode
22999 this using GDB's address_class enum. This is valid for partial
23000 global symbols, although the variable's address will be bogus
23003 dwarf2_complex_location_expr_complaint ();
23006 case DW_OP_GNU_push_tls_address
:
23007 case DW_OP_form_tls_address
:
23008 /* The top of the stack has the offset from the beginning
23009 of the thread control block at which the variable is located. */
23010 /* Nothing should follow this operator, so the top of stack would
23012 /* This is valid for partial global symbols, but the variable's
23013 address will be bogus in the psymtab. Make it always at least
23014 non-zero to not look as a variable garbage collected by linker
23015 which have DW_OP_addr 0. */
23017 dwarf2_complex_location_expr_complaint ();
23021 case DW_OP_GNU_uninit
:
23025 case DW_OP_GNU_addr_index
:
23026 case DW_OP_GNU_const_index
:
23027 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
23034 const char *name
= get_DW_OP_name (op
);
23037 complaint (_("unsupported stack op: '%s'"),
23040 complaint (_("unsupported stack op: '%02x'"),
23044 return (stack
[stacki
]);
23047 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23048 outside of the allocated space. Also enforce minimum>0. */
23049 if (stacki
>= ARRAY_SIZE (stack
) - 1)
23051 complaint (_("location description stack overflow"));
23057 complaint (_("location description stack underflow"));
23061 return (stack
[stacki
]);
23064 /* memory allocation interface */
23066 static struct dwarf_block
*
23067 dwarf_alloc_block (struct dwarf2_cu
*cu
)
23069 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
23072 static struct die_info
*
23073 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
23075 struct die_info
*die
;
23076 size_t size
= sizeof (struct die_info
);
23079 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
23081 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
23082 memset (die
, 0, sizeof (struct die_info
));
23087 /* Macro support. */
23089 static struct macro_source_file
*
23090 macro_start_file (struct dwarf2_cu
*cu
,
23091 int file
, int line
,
23092 struct macro_source_file
*current_file
,
23093 struct line_header
*lh
)
23095 /* File name relative to the compilation directory of this source file. */
23096 gdb::unique_xmalloc_ptr
<char> file_name
= lh
->file_file_name (file
);
23098 if (! current_file
)
23100 /* Note: We don't create a macro table for this compilation unit
23101 at all until we actually get a filename. */
23102 struct macro_table
*macro_table
= cu
->get_builder ()->get_macro_table ();
23104 /* If we have no current file, then this must be the start_file
23105 directive for the compilation unit's main source file. */
23106 current_file
= macro_set_main (macro_table
, file_name
.get ());
23107 macro_define_special (macro_table
);
23110 current_file
= macro_include (current_file
, line
, file_name
.get ());
23112 return current_file
;
23115 static const char *
23116 consume_improper_spaces (const char *p
, const char *body
)
23120 complaint (_("macro definition contains spaces "
23121 "in formal argument list:\n`%s'"),
23133 parse_macro_definition (struct macro_source_file
*file
, int line
,
23138 /* The body string takes one of two forms. For object-like macro
23139 definitions, it should be:
23141 <macro name> " " <definition>
23143 For function-like macro definitions, it should be:
23145 <macro name> "() " <definition>
23147 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
23149 Spaces may appear only where explicitly indicated, and in the
23152 The Dwarf 2 spec says that an object-like macro's name is always
23153 followed by a space, but versions of GCC around March 2002 omit
23154 the space when the macro's definition is the empty string.
23156 The Dwarf 2 spec says that there should be no spaces between the
23157 formal arguments in a function-like macro's formal argument list,
23158 but versions of GCC around March 2002 include spaces after the
23162 /* Find the extent of the macro name. The macro name is terminated
23163 by either a space or null character (for an object-like macro) or
23164 an opening paren (for a function-like macro). */
23165 for (p
= body
; *p
; p
++)
23166 if (*p
== ' ' || *p
== '(')
23169 if (*p
== ' ' || *p
== '\0')
23171 /* It's an object-like macro. */
23172 int name_len
= p
- body
;
23173 std::string
name (body
, name_len
);
23174 const char *replacement
;
23177 replacement
= body
+ name_len
+ 1;
23180 dwarf2_macro_malformed_definition_complaint (body
);
23181 replacement
= body
+ name_len
;
23184 macro_define_object (file
, line
, name
.c_str (), replacement
);
23186 else if (*p
== '(')
23188 /* It's a function-like macro. */
23189 std::string
name (body
, p
- body
);
23192 char **argv
= XNEWVEC (char *, argv_size
);
23196 p
= consume_improper_spaces (p
, body
);
23198 /* Parse the formal argument list. */
23199 while (*p
&& *p
!= ')')
23201 /* Find the extent of the current argument name. */
23202 const char *arg_start
= p
;
23204 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
23207 if (! *p
|| p
== arg_start
)
23208 dwarf2_macro_malformed_definition_complaint (body
);
23211 /* Make sure argv has room for the new argument. */
23212 if (argc
>= argv_size
)
23215 argv
= XRESIZEVEC (char *, argv
, argv_size
);
23218 argv
[argc
++] = savestring (arg_start
, p
- arg_start
);
23221 p
= consume_improper_spaces (p
, body
);
23223 /* Consume the comma, if present. */
23228 p
= consume_improper_spaces (p
, body
);
23237 /* Perfectly formed definition, no complaints. */
23238 macro_define_function (file
, line
, name
.c_str (),
23239 argc
, (const char **) argv
,
23241 else if (*p
== '\0')
23243 /* Complain, but do define it. */
23244 dwarf2_macro_malformed_definition_complaint (body
);
23245 macro_define_function (file
, line
, name
.c_str (),
23246 argc
, (const char **) argv
,
23250 /* Just complain. */
23251 dwarf2_macro_malformed_definition_complaint (body
);
23254 /* Just complain. */
23255 dwarf2_macro_malformed_definition_complaint (body
);
23260 for (i
= 0; i
< argc
; i
++)
23266 dwarf2_macro_malformed_definition_complaint (body
);
23269 /* Skip some bytes from BYTES according to the form given in FORM.
23270 Returns the new pointer. */
23272 static const gdb_byte
*
23273 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
23274 enum dwarf_form form
,
23275 unsigned int offset_size
,
23276 struct dwarf2_section_info
*section
)
23278 unsigned int bytes_read
;
23282 case DW_FORM_data1
:
23287 case DW_FORM_data2
:
23291 case DW_FORM_data4
:
23295 case DW_FORM_data8
:
23299 case DW_FORM_data16
:
23303 case DW_FORM_string
:
23304 read_direct_string (abfd
, bytes
, &bytes_read
);
23305 bytes
+= bytes_read
;
23308 case DW_FORM_sec_offset
:
23310 case DW_FORM_GNU_strp_alt
:
23311 bytes
+= offset_size
;
23314 case DW_FORM_block
:
23315 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
23316 bytes
+= bytes_read
;
23319 case DW_FORM_block1
:
23320 bytes
+= 1 + read_1_byte (abfd
, bytes
);
23322 case DW_FORM_block2
:
23323 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
23325 case DW_FORM_block4
:
23326 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
23329 case DW_FORM_addrx
:
23330 case DW_FORM_sdata
:
23332 case DW_FORM_udata
:
23333 case DW_FORM_GNU_addr_index
:
23334 case DW_FORM_GNU_str_index
:
23335 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
23338 dwarf2_section_buffer_overflow_complaint (section
);
23343 case DW_FORM_implicit_const
:
23348 complaint (_("invalid form 0x%x in `%s'"),
23349 form
, section
->get_name ());
23357 /* A helper for dwarf_decode_macros that handles skipping an unknown
23358 opcode. Returns an updated pointer to the macro data buffer; or,
23359 on error, issues a complaint and returns NULL. */
23361 static const gdb_byte
*
23362 skip_unknown_opcode (unsigned int opcode
,
23363 const gdb_byte
**opcode_definitions
,
23364 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
23366 unsigned int offset_size
,
23367 struct dwarf2_section_info
*section
)
23369 unsigned int bytes_read
, i
;
23371 const gdb_byte
*defn
;
23373 if (opcode_definitions
[opcode
] == NULL
)
23375 complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
23380 defn
= opcode_definitions
[opcode
];
23381 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
23382 defn
+= bytes_read
;
23384 for (i
= 0; i
< arg
; ++i
)
23386 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
,
23387 (enum dwarf_form
) defn
[i
], offset_size
,
23389 if (mac_ptr
== NULL
)
23391 /* skip_form_bytes already issued the complaint. */
23399 /* A helper function which parses the header of a macro section.
23400 If the macro section is the extended (for now called "GNU") type,
23401 then this updates *OFFSET_SIZE. Returns a pointer to just after
23402 the header, or issues a complaint and returns NULL on error. */
23404 static const gdb_byte
*
23405 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
23407 const gdb_byte
*mac_ptr
,
23408 unsigned int *offset_size
,
23409 int section_is_gnu
)
23411 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
23413 if (section_is_gnu
)
23415 unsigned int version
, flags
;
23417 version
= read_2_bytes (abfd
, mac_ptr
);
23418 if (version
!= 4 && version
!= 5)
23420 complaint (_("unrecognized version `%d' in .debug_macro section"),
23426 flags
= read_1_byte (abfd
, mac_ptr
);
23428 *offset_size
= (flags
& 1) ? 8 : 4;
23430 if ((flags
& 2) != 0)
23431 /* We don't need the line table offset. */
23432 mac_ptr
+= *offset_size
;
23434 /* Vendor opcode descriptions. */
23435 if ((flags
& 4) != 0)
23437 unsigned int i
, count
;
23439 count
= read_1_byte (abfd
, mac_ptr
);
23441 for (i
= 0; i
< count
; ++i
)
23443 unsigned int opcode
, bytes_read
;
23446 opcode
= read_1_byte (abfd
, mac_ptr
);
23448 opcode_definitions
[opcode
] = mac_ptr
;
23449 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23450 mac_ptr
+= bytes_read
;
23459 /* A helper for dwarf_decode_macros that handles the GNU extensions,
23460 including DW_MACRO_import. */
23463 dwarf_decode_macro_bytes (struct dwarf2_cu
*cu
,
23465 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
23466 struct macro_source_file
*current_file
,
23467 struct line_header
*lh
,
23468 struct dwarf2_section_info
*section
,
23469 int section_is_gnu
, int section_is_dwz
,
23470 unsigned int offset_size
,
23471 htab_t include_hash
)
23473 struct dwarf2_per_objfile
*dwarf2_per_objfile
23474 = cu
->per_cu
->dwarf2_per_objfile
;
23475 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
23476 enum dwarf_macro_record_type macinfo_type
;
23477 int at_commandline
;
23478 const gdb_byte
*opcode_definitions
[256];
23480 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
23481 &offset_size
, section_is_gnu
);
23482 if (mac_ptr
== NULL
)
23484 /* We already issued a complaint. */
23488 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
23489 GDB is still reading the definitions from command line. First
23490 DW_MACINFO_start_file will need to be ignored as it was already executed
23491 to create CURRENT_FILE for the main source holding also the command line
23492 definitions. On first met DW_MACINFO_start_file this flag is reset to
23493 normally execute all the remaining DW_MACINFO_start_file macinfos. */
23495 at_commandline
= 1;
23499 /* Do we at least have room for a macinfo type byte? */
23500 if (mac_ptr
>= mac_end
)
23502 dwarf2_section_buffer_overflow_complaint (section
);
23506 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
23509 /* Note that we rely on the fact that the corresponding GNU and
23510 DWARF constants are the same. */
23512 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
23513 switch (macinfo_type
)
23515 /* A zero macinfo type indicates the end of the macro
23520 case DW_MACRO_define
:
23521 case DW_MACRO_undef
:
23522 case DW_MACRO_define_strp
:
23523 case DW_MACRO_undef_strp
:
23524 case DW_MACRO_define_sup
:
23525 case DW_MACRO_undef_sup
:
23527 unsigned int bytes_read
;
23532 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23533 mac_ptr
+= bytes_read
;
23535 if (macinfo_type
== DW_MACRO_define
23536 || macinfo_type
== DW_MACRO_undef
)
23538 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
23539 mac_ptr
+= bytes_read
;
23543 LONGEST str_offset
;
23545 str_offset
= read_offset (abfd
, mac_ptr
, offset_size
);
23546 mac_ptr
+= offset_size
;
23548 if (macinfo_type
== DW_MACRO_define_sup
23549 || macinfo_type
== DW_MACRO_undef_sup
23552 struct dwz_file
*dwz
23553 = dwarf2_get_dwz_file (dwarf2_per_objfile
);
23555 body
= read_indirect_string_from_dwz (objfile
,
23559 body
= read_indirect_string_at_offset (dwarf2_per_objfile
,
23563 is_define
= (macinfo_type
== DW_MACRO_define
23564 || macinfo_type
== DW_MACRO_define_strp
23565 || macinfo_type
== DW_MACRO_define_sup
);
23566 if (! current_file
)
23568 /* DWARF violation as no main source is present. */
23569 complaint (_("debug info with no main source gives macro %s "
23571 is_define
? _("definition") : _("undefinition"),
23575 if ((line
== 0 && !at_commandline
)
23576 || (line
!= 0 && at_commandline
))
23577 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
23578 at_commandline
? _("command-line") : _("in-file"),
23579 is_define
? _("definition") : _("undefinition"),
23580 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
23584 /* Fedora's rpm-build's "debugedit" binary
23585 corrupted .debug_macro sections.
23588 https://bugzilla.redhat.com/show_bug.cgi?id=1708786 */
23589 complaint (_("debug info gives %s invalid macro %s "
23590 "without body (corrupted?) at line %d "
23592 at_commandline
? _("command-line") : _("in-file"),
23593 is_define
? _("definition") : _("undefinition"),
23594 line
, current_file
->filename
);
23596 else if (is_define
)
23597 parse_macro_definition (current_file
, line
, body
);
23600 gdb_assert (macinfo_type
== DW_MACRO_undef
23601 || macinfo_type
== DW_MACRO_undef_strp
23602 || macinfo_type
== DW_MACRO_undef_sup
);
23603 macro_undef (current_file
, line
, body
);
23608 case DW_MACRO_start_file
:
23610 unsigned int bytes_read
;
23613 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23614 mac_ptr
+= bytes_read
;
23615 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23616 mac_ptr
+= bytes_read
;
23618 if ((line
== 0 && !at_commandline
)
23619 || (line
!= 0 && at_commandline
))
23620 complaint (_("debug info gives source %d included "
23621 "from %s at %s line %d"),
23622 file
, at_commandline
? _("command-line") : _("file"),
23623 line
== 0 ? _("zero") : _("non-zero"), line
);
23625 if (at_commandline
)
23627 /* This DW_MACRO_start_file was executed in the
23629 at_commandline
= 0;
23632 current_file
= macro_start_file (cu
, file
, line
, current_file
,
23637 case DW_MACRO_end_file
:
23638 if (! current_file
)
23639 complaint (_("macro debug info has an unmatched "
23640 "`close_file' directive"));
23643 current_file
= current_file
->included_by
;
23644 if (! current_file
)
23646 enum dwarf_macro_record_type next_type
;
23648 /* GCC circa March 2002 doesn't produce the zero
23649 type byte marking the end of the compilation
23650 unit. Complain if it's not there, but exit no
23653 /* Do we at least have room for a macinfo type byte? */
23654 if (mac_ptr
>= mac_end
)
23656 dwarf2_section_buffer_overflow_complaint (section
);
23660 /* We don't increment mac_ptr here, so this is just
23663 = (enum dwarf_macro_record_type
) read_1_byte (abfd
,
23665 if (next_type
!= 0)
23666 complaint (_("no terminating 0-type entry for "
23667 "macros in `.debug_macinfo' section"));
23674 case DW_MACRO_import
:
23675 case DW_MACRO_import_sup
:
23679 bfd
*include_bfd
= abfd
;
23680 struct dwarf2_section_info
*include_section
= section
;
23681 const gdb_byte
*include_mac_end
= mac_end
;
23682 int is_dwz
= section_is_dwz
;
23683 const gdb_byte
*new_mac_ptr
;
23685 offset
= read_offset (abfd
, mac_ptr
, offset_size
);
23686 mac_ptr
+= offset_size
;
23688 if (macinfo_type
== DW_MACRO_import_sup
)
23690 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
23692 dwz
->macro
.read (objfile
);
23694 include_section
= &dwz
->macro
;
23695 include_bfd
= include_section
->get_bfd_owner ();
23696 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
23700 new_mac_ptr
= include_section
->buffer
+ offset
;
23701 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
23705 /* This has actually happened; see
23706 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
23707 complaint (_("recursive DW_MACRO_import in "
23708 ".debug_macro section"));
23712 *slot
= (void *) new_mac_ptr
;
23714 dwarf_decode_macro_bytes (cu
, include_bfd
, new_mac_ptr
,
23715 include_mac_end
, current_file
, lh
,
23716 section
, section_is_gnu
, is_dwz
,
23717 offset_size
, include_hash
);
23719 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
23724 case DW_MACINFO_vendor_ext
:
23725 if (!section_is_gnu
)
23727 unsigned int bytes_read
;
23729 /* This reads the constant, but since we don't recognize
23730 any vendor extensions, we ignore it. */
23731 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23732 mac_ptr
+= bytes_read
;
23733 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
23734 mac_ptr
+= bytes_read
;
23736 /* We don't recognize any vendor extensions. */
23742 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
23743 mac_ptr
, mac_end
, abfd
, offset_size
,
23745 if (mac_ptr
== NULL
)
23750 } while (macinfo_type
!= 0);
23754 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
23755 int section_is_gnu
)
23757 struct dwarf2_per_objfile
*dwarf2_per_objfile
23758 = cu
->per_cu
->dwarf2_per_objfile
;
23759 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
23760 struct line_header
*lh
= cu
->line_header
;
23762 const gdb_byte
*mac_ptr
, *mac_end
;
23763 struct macro_source_file
*current_file
= 0;
23764 enum dwarf_macro_record_type macinfo_type
;
23765 unsigned int offset_size
= cu
->header
.offset_size
;
23766 const gdb_byte
*opcode_definitions
[256];
23768 struct dwarf2_section_info
*section
;
23769 const char *section_name
;
23771 if (cu
->dwo_unit
!= NULL
)
23773 if (section_is_gnu
)
23775 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
23776 section_name
= ".debug_macro.dwo";
23780 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
23781 section_name
= ".debug_macinfo.dwo";
23786 if (section_is_gnu
)
23788 section
= &dwarf2_per_objfile
->macro
;
23789 section_name
= ".debug_macro";
23793 section
= &dwarf2_per_objfile
->macinfo
;
23794 section_name
= ".debug_macinfo";
23798 section
->read (objfile
);
23799 if (section
->buffer
== NULL
)
23801 complaint (_("missing %s section"), section_name
);
23804 abfd
= section
->get_bfd_owner ();
23806 /* First pass: Find the name of the base filename.
23807 This filename is needed in order to process all macros whose definition
23808 (or undefinition) comes from the command line. These macros are defined
23809 before the first DW_MACINFO_start_file entry, and yet still need to be
23810 associated to the base file.
23812 To determine the base file name, we scan the macro definitions until we
23813 reach the first DW_MACINFO_start_file entry. We then initialize
23814 CURRENT_FILE accordingly so that any macro definition found before the
23815 first DW_MACINFO_start_file can still be associated to the base file. */
23817 mac_ptr
= section
->buffer
+ offset
;
23818 mac_end
= section
->buffer
+ section
->size
;
23820 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
23821 &offset_size
, section_is_gnu
);
23822 if (mac_ptr
== NULL
)
23824 /* We already issued a complaint. */
23830 /* Do we at least have room for a macinfo type byte? */
23831 if (mac_ptr
>= mac_end
)
23833 /* Complaint is printed during the second pass as GDB will probably
23834 stop the first pass earlier upon finding
23835 DW_MACINFO_start_file. */
23839 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
23842 /* Note that we rely on the fact that the corresponding GNU and
23843 DWARF constants are the same. */
23845 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
23846 switch (macinfo_type
)
23848 /* A zero macinfo type indicates the end of the macro
23853 case DW_MACRO_define
:
23854 case DW_MACRO_undef
:
23855 /* Only skip the data by MAC_PTR. */
23857 unsigned int bytes_read
;
23859 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23860 mac_ptr
+= bytes_read
;
23861 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
23862 mac_ptr
+= bytes_read
;
23866 case DW_MACRO_start_file
:
23868 unsigned int bytes_read
;
23871 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23872 mac_ptr
+= bytes_read
;
23873 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23874 mac_ptr
+= bytes_read
;
23876 current_file
= macro_start_file (cu
, file
, line
, current_file
, lh
);
23880 case DW_MACRO_end_file
:
23881 /* No data to skip by MAC_PTR. */
23884 case DW_MACRO_define_strp
:
23885 case DW_MACRO_undef_strp
:
23886 case DW_MACRO_define_sup
:
23887 case DW_MACRO_undef_sup
:
23889 unsigned int bytes_read
;
23891 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23892 mac_ptr
+= bytes_read
;
23893 mac_ptr
+= offset_size
;
23897 case DW_MACRO_import
:
23898 case DW_MACRO_import_sup
:
23899 /* Note that, according to the spec, a transparent include
23900 chain cannot call DW_MACRO_start_file. So, we can just
23901 skip this opcode. */
23902 mac_ptr
+= offset_size
;
23905 case DW_MACINFO_vendor_ext
:
23906 /* Only skip the data by MAC_PTR. */
23907 if (!section_is_gnu
)
23909 unsigned int bytes_read
;
23911 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
23912 mac_ptr
+= bytes_read
;
23913 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
23914 mac_ptr
+= bytes_read
;
23919 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
23920 mac_ptr
, mac_end
, abfd
, offset_size
,
23922 if (mac_ptr
== NULL
)
23927 } while (macinfo_type
!= 0 && current_file
== NULL
);
23929 /* Second pass: Process all entries.
23931 Use the AT_COMMAND_LINE flag to determine whether we are still processing
23932 command-line macro definitions/undefinitions. This flag is unset when we
23933 reach the first DW_MACINFO_start_file entry. */
23935 htab_up
include_hash (htab_create_alloc (1, htab_hash_pointer
,
23937 NULL
, xcalloc
, xfree
));
23938 mac_ptr
= section
->buffer
+ offset
;
23939 slot
= htab_find_slot (include_hash
.get (), mac_ptr
, INSERT
);
23940 *slot
= (void *) mac_ptr
;
23941 dwarf_decode_macro_bytes (cu
, abfd
, mac_ptr
, mac_end
,
23942 current_file
, lh
, section
,
23943 section_is_gnu
, 0, offset_size
,
23944 include_hash
.get ());
23947 /* Return the .debug_loc section to use for CU.
23948 For DWO files use .debug_loc.dwo. */
23950 static struct dwarf2_section_info
*
23951 cu_debug_loc_section (struct dwarf2_cu
*cu
)
23953 struct dwarf2_per_objfile
*dwarf2_per_objfile
23954 = cu
->per_cu
->dwarf2_per_objfile
;
23958 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
23960 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
23962 return (cu
->header
.version
>= 5 ? &dwarf2_per_objfile
->loclists
23963 : &dwarf2_per_objfile
->loc
);
23966 /* A helper function that fills in a dwarf2_loclist_baton. */
23969 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
23970 struct dwarf2_loclist_baton
*baton
,
23971 const struct attribute
*attr
)
23973 struct dwarf2_per_objfile
*dwarf2_per_objfile
23974 = cu
->per_cu
->dwarf2_per_objfile
;
23975 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
23977 section
->read (dwarf2_per_objfile
->objfile
);
23979 baton
->per_cu
= cu
->per_cu
;
23980 gdb_assert (baton
->per_cu
);
23981 /* We don't know how long the location list is, but make sure we
23982 don't run off the edge of the section. */
23983 baton
->size
= section
->size
- DW_UNSND (attr
);
23984 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
23985 baton
->base_address
= cu
->base_address
;
23986 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
23990 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
23991 struct dwarf2_cu
*cu
, int is_block
)
23993 struct dwarf2_per_objfile
*dwarf2_per_objfile
23994 = cu
->per_cu
->dwarf2_per_objfile
;
23995 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
23996 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
23998 if (attr
->form_is_section_offset ()
23999 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24000 the section. If so, fall through to the complaint in the
24002 && DW_UNSND (attr
) < section
->get_size (objfile
))
24004 struct dwarf2_loclist_baton
*baton
;
24006 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
24008 fill_in_loclist_baton (cu
, baton
, attr
);
24010 if (cu
->base_known
== 0)
24011 complaint (_("Location list used without "
24012 "specifying the CU base address."));
24014 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24015 ? dwarf2_loclist_block_index
24016 : dwarf2_loclist_index
);
24017 SYMBOL_LOCATION_BATON (sym
) = baton
;
24021 struct dwarf2_locexpr_baton
*baton
;
24023 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
24024 baton
->per_cu
= cu
->per_cu
;
24025 gdb_assert (baton
->per_cu
);
24027 if (attr
->form_is_block ())
24029 /* Note that we're just copying the block's data pointer
24030 here, not the actual data. We're still pointing into the
24031 info_buffer for SYM's objfile; right now we never release
24032 that buffer, but when we do clean up properly this may
24034 baton
->size
= DW_BLOCK (attr
)->size
;
24035 baton
->data
= DW_BLOCK (attr
)->data
;
24039 dwarf2_invalid_attrib_class_complaint ("location description",
24040 sym
->natural_name ());
24044 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24045 ? dwarf2_locexpr_block_index
24046 : dwarf2_locexpr_index
);
24047 SYMBOL_LOCATION_BATON (sym
) = baton
;
24054 dwarf2_per_cu_data::objfile () const
24056 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24058 /* Return the master objfile, so that we can report and look up the
24059 correct file containing this variable. */
24060 if (objfile
->separate_debug_objfile_backlink
)
24061 objfile
= objfile
->separate_debug_objfile_backlink
;
24066 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
24067 (CU_HEADERP is unused in such case) or prepare a temporary copy at
24068 CU_HEADERP first. */
24070 static const struct comp_unit_head
*
24071 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
24072 const struct dwarf2_per_cu_data
*per_cu
)
24074 const gdb_byte
*info_ptr
;
24077 return &per_cu
->cu
->header
;
24079 info_ptr
= per_cu
->section
->buffer
+ to_underlying (per_cu
->sect_off
);
24081 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
24082 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->section
,
24083 rcuh_kind::COMPILE
);
24091 dwarf2_per_cu_data::addr_size () const
24093 struct comp_unit_head cu_header_local
;
24094 const struct comp_unit_head
*cu_headerp
;
24096 cu_headerp
= per_cu_header_read_in (&cu_header_local
, this);
24098 return cu_headerp
->addr_size
;
24104 dwarf2_per_cu_data::offset_size () const
24106 struct comp_unit_head cu_header_local
;
24107 const struct comp_unit_head
*cu_headerp
;
24109 cu_headerp
= per_cu_header_read_in (&cu_header_local
, this);
24111 return cu_headerp
->offset_size
;
24117 dwarf2_per_cu_data::ref_addr_size () const
24119 struct comp_unit_head cu_header_local
;
24120 const struct comp_unit_head
*cu_headerp
;
24122 cu_headerp
= per_cu_header_read_in (&cu_header_local
, this);
24124 if (cu_headerp
->version
== 2)
24125 return cu_headerp
->addr_size
;
24127 return cu_headerp
->offset_size
;
24133 dwarf2_per_cu_data::text_offset () const
24135 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24137 return objfile
->text_section_offset ();
24143 dwarf2_per_cu_data::addr_type () const
24145 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24146 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
24147 struct type
*addr_type
= lookup_pointer_type (void_type
);
24148 int addr_size
= this->addr_size ();
24150 if (TYPE_LENGTH (addr_type
) == addr_size
)
24153 addr_type
= addr_sized_int_type (TYPE_UNSIGNED (addr_type
));
24157 /* A helper function for dwarf2_find_containing_comp_unit that returns
24158 the index of the result, and that searches a vector. It will
24159 return a result even if the offset in question does not actually
24160 occur in any CU. This is separate so that it can be unit
24164 dwarf2_find_containing_comp_unit
24165 (sect_offset sect_off
,
24166 unsigned int offset_in_dwz
,
24167 const std::vector
<dwarf2_per_cu_data
*> &all_comp_units
)
24172 high
= all_comp_units
.size () - 1;
24175 struct dwarf2_per_cu_data
*mid_cu
;
24176 int mid
= low
+ (high
- low
) / 2;
24178 mid_cu
= all_comp_units
[mid
];
24179 if (mid_cu
->is_dwz
> offset_in_dwz
24180 || (mid_cu
->is_dwz
== offset_in_dwz
24181 && mid_cu
->sect_off
+ mid_cu
->length
> sect_off
))
24186 gdb_assert (low
== high
);
24190 /* Locate the .debug_info compilation unit from CU's objfile which contains
24191 the DIE at OFFSET. Raises an error on failure. */
24193 static struct dwarf2_per_cu_data
*
24194 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
24195 unsigned int offset_in_dwz
,
24196 struct dwarf2_per_objfile
*dwarf2_per_objfile
)
24199 = dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
24200 dwarf2_per_objfile
->all_comp_units
);
24201 struct dwarf2_per_cu_data
*this_cu
24202 = dwarf2_per_objfile
->all_comp_units
[low
];
24204 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
24206 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
24207 error (_("Dwarf Error: could not find partial DIE containing "
24208 "offset %s [in module %s]"),
24209 sect_offset_str (sect_off
),
24210 bfd_get_filename (dwarf2_per_objfile
->objfile
->obfd
));
24212 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->sect_off
24214 return dwarf2_per_objfile
->all_comp_units
[low
-1];
24218 if (low
== dwarf2_per_objfile
->all_comp_units
.size () - 1
24219 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
24220 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
24221 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
24228 namespace selftests
{
24229 namespace find_containing_comp_unit
{
24234 struct dwarf2_per_cu_data one
{};
24235 struct dwarf2_per_cu_data two
{};
24236 struct dwarf2_per_cu_data three
{};
24237 struct dwarf2_per_cu_data four
{};
24240 two
.sect_off
= sect_offset (one
.length
);
24245 four
.sect_off
= sect_offset (three
.length
);
24249 std::vector
<dwarf2_per_cu_data
*> units
;
24250 units
.push_back (&one
);
24251 units
.push_back (&two
);
24252 units
.push_back (&three
);
24253 units
.push_back (&four
);
24257 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 0, units
);
24258 SELF_CHECK (units
[result
] == &one
);
24259 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 0, units
);
24260 SELF_CHECK (units
[result
] == &one
);
24261 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 0, units
);
24262 SELF_CHECK (units
[result
] == &two
);
24264 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 1, units
);
24265 SELF_CHECK (units
[result
] == &three
);
24266 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 1, units
);
24267 SELF_CHECK (units
[result
] == &three
);
24268 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 1, units
);
24269 SELF_CHECK (units
[result
] == &four
);
24275 #endif /* GDB_SELF_TEST */
24277 /* Initialize dwarf2_cu CU, owned by PER_CU. */
24279 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data
*per_cu_
)
24280 : per_cu (per_cu_
),
24282 has_loclist (false),
24283 checked_producer (false),
24284 producer_is_gxx_lt_4_6 (false),
24285 producer_is_gcc_lt_4_3 (false),
24286 producer_is_icc (false),
24287 producer_is_icc_lt_14 (false),
24288 producer_is_codewarrior (false),
24289 processing_has_namespace_info (false)
24294 /* Destroy a dwarf2_cu. */
24296 dwarf2_cu::~dwarf2_cu ()
24301 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
24304 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
24305 enum language pretend_language
)
24307 struct attribute
*attr
;
24309 /* Set the language we're debugging. */
24310 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
24311 if (attr
!= nullptr)
24312 set_cu_language (DW_UNSND (attr
), cu
);
24315 cu
->language
= pretend_language
;
24316 cu
->language_defn
= language_def (cu
->language
);
24319 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
24322 /* Increase the age counter on each cached compilation unit, and free
24323 any that are too old. */
24326 age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
24328 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
24330 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
24331 per_cu
= dwarf2_per_objfile
->read_in_chain
;
24332 while (per_cu
!= NULL
)
24334 per_cu
->cu
->last_used
++;
24335 if (per_cu
->cu
->last_used
<= dwarf_max_cache_age
)
24336 dwarf2_mark (per_cu
->cu
);
24337 per_cu
= per_cu
->cu
->read_in_chain
;
24340 per_cu
= dwarf2_per_objfile
->read_in_chain
;
24341 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
24342 while (per_cu
!= NULL
)
24344 struct dwarf2_per_cu_data
*next_cu
;
24346 next_cu
= per_cu
->cu
->read_in_chain
;
24348 if (!per_cu
->cu
->mark
)
24351 *last_chain
= next_cu
;
24354 last_chain
= &per_cu
->cu
->read_in_chain
;
24360 /* Remove a single compilation unit from the cache. */
24363 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
24365 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
24366 struct dwarf2_per_objfile
*dwarf2_per_objfile
24367 = target_per_cu
->dwarf2_per_objfile
;
24369 per_cu
= dwarf2_per_objfile
->read_in_chain
;
24370 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
24371 while (per_cu
!= NULL
)
24373 struct dwarf2_per_cu_data
*next_cu
;
24375 next_cu
= per_cu
->cu
->read_in_chain
;
24377 if (per_cu
== target_per_cu
)
24381 *last_chain
= next_cu
;
24385 last_chain
= &per_cu
->cu
->read_in_chain
;
24391 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
24392 We store these in a hash table separate from the DIEs, and preserve them
24393 when the DIEs are flushed out of cache.
24395 The CU "per_cu" pointer is needed because offset alone is not enough to
24396 uniquely identify the type. A file may have multiple .debug_types sections,
24397 or the type may come from a DWO file. Furthermore, while it's more logical
24398 to use per_cu->section+offset, with Fission the section with the data is in
24399 the DWO file but we don't know that section at the point we need it.
24400 We have to use something in dwarf2_per_cu_data (or the pointer to it)
24401 because we can enter the lookup routine, get_die_type_at_offset, from
24402 outside this file, and thus won't necessarily have PER_CU->cu.
24403 Fortunately, PER_CU is stable for the life of the objfile. */
24405 struct dwarf2_per_cu_offset_and_type
24407 const struct dwarf2_per_cu_data
*per_cu
;
24408 sect_offset sect_off
;
24412 /* Hash function for a dwarf2_per_cu_offset_and_type. */
24415 per_cu_offset_and_type_hash (const void *item
)
24417 const struct dwarf2_per_cu_offset_and_type
*ofs
24418 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
24420 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
24423 /* Equality function for a dwarf2_per_cu_offset_and_type. */
24426 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
24428 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
24429 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
24430 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
24431 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
24433 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
24434 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
24437 /* Set the type associated with DIE to TYPE. Save it in CU's hash
24438 table if necessary. For convenience, return TYPE.
24440 The DIEs reading must have careful ordering to:
24441 * Not cause infinite loops trying to read in DIEs as a prerequisite for
24442 reading current DIE.
24443 * Not trying to dereference contents of still incompletely read in types
24444 while reading in other DIEs.
24445 * Enable referencing still incompletely read in types just by a pointer to
24446 the type without accessing its fields.
24448 Therefore caller should follow these rules:
24449 * Try to fetch any prerequisite types we may need to build this DIE type
24450 before building the type and calling set_die_type.
24451 * After building type call set_die_type for current DIE as soon as
24452 possible before fetching more types to complete the current type.
24453 * Make the type as complete as possible before fetching more types. */
24455 static struct type
*
24456 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
24458 struct dwarf2_per_objfile
*dwarf2_per_objfile
24459 = cu
->per_cu
->dwarf2_per_objfile
;
24460 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
24461 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24462 struct attribute
*attr
;
24463 struct dynamic_prop prop
;
24465 /* For Ada types, make sure that the gnat-specific data is always
24466 initialized (if not already set). There are a few types where
24467 we should not be doing so, because the type-specific area is
24468 already used to hold some other piece of info (eg: TYPE_CODE_FLT
24469 where the type-specific area is used to store the floatformat).
24470 But this is not a problem, because the gnat-specific information
24471 is actually not needed for these types. */
24472 if (need_gnat_info (cu
)
24473 && TYPE_CODE (type
) != TYPE_CODE_FUNC
24474 && TYPE_CODE (type
) != TYPE_CODE_FLT
24475 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
24476 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
24477 && TYPE_CODE (type
) != TYPE_CODE_METHOD
24478 && !HAVE_GNAT_AUX_INFO (type
))
24479 INIT_GNAT_SPECIFIC (type
);
24481 /* Read DW_AT_allocated and set in type. */
24482 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
24483 if (attr
!= NULL
&& attr
->form_is_block ())
24485 struct type
*prop_type
= cu
->per_cu
->addr_sized_int_type (false);
24486 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24487 add_dyn_prop (DYN_PROP_ALLOCATED
, prop
, type
);
24489 else if (attr
!= NULL
)
24491 complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
24492 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
24493 sect_offset_str (die
->sect_off
));
24496 /* Read DW_AT_associated and set in type. */
24497 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
24498 if (attr
!= NULL
&& attr
->form_is_block ())
24500 struct type
*prop_type
= cu
->per_cu
->addr_sized_int_type (false);
24501 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24502 add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
, type
);
24504 else if (attr
!= NULL
)
24506 complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
24507 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
24508 sect_offset_str (die
->sect_off
));
24511 /* Read DW_AT_data_location and set in type. */
24512 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
24513 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
,
24514 cu
->per_cu
->addr_type ()))
24515 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
);
24517 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
24518 dwarf2_per_objfile
->die_type_hash
24519 = htab_up (htab_create_alloc (127,
24520 per_cu_offset_and_type_hash
,
24521 per_cu_offset_and_type_eq
,
24522 NULL
, xcalloc
, xfree
));
24524 ofs
.per_cu
= cu
->per_cu
;
24525 ofs
.sect_off
= die
->sect_off
;
24527 slot
= (struct dwarf2_per_cu_offset_and_type
**)
24528 htab_find_slot (dwarf2_per_objfile
->die_type_hash
.get (), &ofs
, INSERT
);
24530 complaint (_("A problem internal to GDB: DIE %s has type already set"),
24531 sect_offset_str (die
->sect_off
));
24532 *slot
= XOBNEW (&objfile
->objfile_obstack
,
24533 struct dwarf2_per_cu_offset_and_type
);
24538 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
24539 or return NULL if the die does not have a saved type. */
24541 static struct type
*
24542 get_die_type_at_offset (sect_offset sect_off
,
24543 struct dwarf2_per_cu_data
*per_cu
)
24545 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
24546 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
24548 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
24551 ofs
.per_cu
= per_cu
;
24552 ofs
.sect_off
= sect_off
;
24553 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
24554 htab_find (dwarf2_per_objfile
->die_type_hash
.get (), &ofs
));
24561 /* Look up the type for DIE in CU in die_type_hash,
24562 or return NULL if DIE does not have a saved type. */
24564 static struct type
*
24565 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
24567 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
);
24570 /* Add a dependence relationship from CU to REF_PER_CU. */
24573 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
24574 struct dwarf2_per_cu_data
*ref_per_cu
)
24578 if (cu
->dependencies
== NULL
)
24580 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
24581 NULL
, &cu
->comp_unit_obstack
,
24582 hashtab_obstack_allocate
,
24583 dummy_obstack_deallocate
);
24585 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
24587 *slot
= ref_per_cu
;
24590 /* Subroutine of dwarf2_mark to pass to htab_traverse.
24591 Set the mark field in every compilation unit in the
24592 cache that we must keep because we are keeping CU. */
24595 dwarf2_mark_helper (void **slot
, void *data
)
24597 struct dwarf2_per_cu_data
*per_cu
;
24599 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
24601 /* cu->dependencies references may not yet have been ever read if QUIT aborts
24602 reading of the chain. As such dependencies remain valid it is not much
24603 useful to track and undo them during QUIT cleanups. */
24604 if (per_cu
->cu
== NULL
)
24607 if (per_cu
->cu
->mark
)
24609 per_cu
->cu
->mark
= true;
24611 if (per_cu
->cu
->dependencies
!= NULL
)
24612 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
24617 /* Set the mark field in CU and in every other compilation unit in the
24618 cache that we must keep because we are keeping CU. */
24621 dwarf2_mark (struct dwarf2_cu
*cu
)
24626 if (cu
->dependencies
!= NULL
)
24627 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
24631 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
24635 per_cu
->cu
->mark
= false;
24636 per_cu
= per_cu
->cu
->read_in_chain
;
24640 /* Trivial hash function for partial_die_info: the hash value of a DIE
24641 is its offset in .debug_info for this objfile. */
24644 partial_die_hash (const void *item
)
24646 const struct partial_die_info
*part_die
24647 = (const struct partial_die_info
*) item
;
24649 return to_underlying (part_die
->sect_off
);
24652 /* Trivial comparison function for partial_die_info structures: two DIEs
24653 are equal if they have the same offset. */
24656 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
24658 const struct partial_die_info
*part_die_lhs
24659 = (const struct partial_die_info
*) item_lhs
;
24660 const struct partial_die_info
*part_die_rhs
24661 = (const struct partial_die_info
*) item_rhs
;
24663 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
24666 struct cmd_list_element
*set_dwarf_cmdlist
;
24667 struct cmd_list_element
*show_dwarf_cmdlist
;
24670 set_dwarf_cmd (const char *args
, int from_tty
)
24672 help_list (set_dwarf_cmdlist
, "maintenance set dwarf ", all_commands
,
24677 show_dwarf_cmd (const char *args
, int from_tty
)
24679 cmd_show_list (show_dwarf_cmdlist
, from_tty
, "");
24683 show_check_physname (struct ui_file
*file
, int from_tty
,
24684 struct cmd_list_element
*c
, const char *value
)
24686 fprintf_filtered (file
,
24687 _("Whether to check \"physname\" is %s.\n"),
24691 void _initialize_dwarf2_read ();
24693 _initialize_dwarf2_read ()
24695 add_prefix_cmd ("dwarf", class_maintenance
, set_dwarf_cmd
, _("\
24696 Set DWARF specific variables.\n\
24697 Configure DWARF variables such as the cache size."),
24698 &set_dwarf_cmdlist
, "maintenance set dwarf ",
24699 0/*allow-unknown*/, &maintenance_set_cmdlist
);
24701 add_prefix_cmd ("dwarf", class_maintenance
, show_dwarf_cmd
, _("\
24702 Show DWARF specific variables.\n\
24703 Show DWARF variables such as the cache size."),
24704 &show_dwarf_cmdlist
, "maintenance show dwarf ",
24705 0/*allow-unknown*/, &maintenance_show_cmdlist
);
24707 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
24708 &dwarf_max_cache_age
, _("\
24709 Set the upper bound on the age of cached DWARF compilation units."), _("\
24710 Show the upper bound on the age of cached DWARF compilation units."), _("\
24711 A higher limit means that cached compilation units will be stored\n\
24712 in memory longer, and more total memory will be used. Zero disables\n\
24713 caching, which can slow down startup."),
24715 show_dwarf_max_cache_age
,
24716 &set_dwarf_cmdlist
,
24717 &show_dwarf_cmdlist
);
24719 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
24720 Set debugging of the DWARF reader."), _("\
24721 Show debugging of the DWARF reader."), _("\
24722 When enabled (non-zero), debugging messages are printed during DWARF\n\
24723 reading and symtab expansion. A value of 1 (one) provides basic\n\
24724 information. A value greater than 1 provides more verbose information."),
24727 &setdebuglist
, &showdebuglist
);
24729 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
24730 Set debugging of the DWARF DIE reader."), _("\
24731 Show debugging of the DWARF DIE reader."), _("\
24732 When enabled (non-zero), DIEs are dumped after they are read in.\n\
24733 The value is the maximum depth to print."),
24736 &setdebuglist
, &showdebuglist
);
24738 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
24739 Set debugging of the dwarf line reader."), _("\
24740 Show debugging of the dwarf line reader."), _("\
24741 When enabled (non-zero), line number entries are dumped as they are read in.\n\
24742 A value of 1 (one) provides basic information.\n\
24743 A value greater than 1 provides more verbose information."),
24746 &setdebuglist
, &showdebuglist
);
24748 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
24749 Set cross-checking of \"physname\" code against demangler."), _("\
24750 Show cross-checking of \"physname\" code against demangler."), _("\
24751 When enabled, GDB's internal \"physname\" code is checked against\n\
24753 NULL
, show_check_physname
,
24754 &setdebuglist
, &showdebuglist
);
24756 add_setshow_boolean_cmd ("use-deprecated-index-sections",
24757 no_class
, &use_deprecated_index_sections
, _("\
24758 Set whether to use deprecated gdb_index sections."), _("\
24759 Show whether to use deprecated gdb_index sections."), _("\
24760 When enabled, deprecated .gdb_index sections are used anyway.\n\
24761 Normally they are ignored either because of a missing feature or\n\
24762 performance issue.\n\
24763 Warning: This option must be enabled before gdb reads the file."),
24766 &setlist
, &showlist
);
24768 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
24769 &dwarf2_locexpr_funcs
);
24770 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
24771 &dwarf2_loclist_funcs
);
24773 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
24774 &dwarf2_block_frame_base_locexpr_funcs
);
24775 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
24776 &dwarf2_block_frame_base_loclist_funcs
);
24779 selftests::register_test ("dw2_expand_symtabs_matching",
24780 selftests::dw2_expand_symtabs_matching::run_test
);
24781 selftests::register_test ("dwarf2_find_containing_comp_unit",
24782 selftests::find_containing_comp_unit::run_test
);