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"
40 #include "dwarf2/dwz.h"
41 #include "dwarf2/macro.h"
42 #include "dwarf2/die.h"
43 #include "dwarf2/stringify.h"
52 #include "gdb-demangle.h"
53 #include "filenames.h" /* for DOSish file names */
55 #include "complaints.h"
56 #include "dwarf2/expr.h"
57 #include "dwarf2/loc.h"
58 #include "cp-support.h"
64 #include "typeprint.h"
69 #include "gdbcore.h" /* for gnutarget */
70 #include "gdb/gdb-index.h"
75 #include "namespace.h"
76 #include "gdbsupport/function-view.h"
77 #include "gdbsupport/gdb_optional.h"
78 #include "gdbsupport/underlying.h"
79 #include "gdbsupport/hash_enum.h"
80 #include "filename-seen-cache.h"
84 #include <unordered_map>
85 #include "gdbsupport/selftest.h"
86 #include "rust-lang.h"
87 #include "gdbsupport/pathstuff.h"
88 #include "count-one-bits.h"
89 #include "debuginfod-support.h"
91 /* When == 1, print basic high level tracing messages.
92 When > 1, be more verbose.
93 This is in contrast to the low level DIE reading of dwarf_die_debug. */
94 static unsigned int dwarf_read_debug
= 0;
96 /* When non-zero, dump DIEs after they are read in. */
97 static unsigned int dwarf_die_debug
= 0;
99 /* When non-zero, dump line number entries as they are read in. */
100 unsigned int dwarf_line_debug
= 0;
102 /* When true, cross-check physname against demangler. */
103 static bool check_physname
= false;
105 /* When true, do not reject deprecated .gdb_index sections. */
106 static bool use_deprecated_index_sections
= false;
108 /* This is used to store the data that is always per objfile. */
109 static const objfile_key
<dwarf2_per_objfile
> dwarf2_objfile_data_key
;
111 /* These are used to store the dwarf2_per_bfd objects.
113 objfiles having the same BFD, which doesn't require relocations, are going to
114 share a dwarf2_per_bfd object, which is held in the _bfd_data_key version.
116 Other objfiles are not going to share a dwarf2_per_bfd with any other
117 objfiles, so they'll have their own version kept in the _objfile_data_key
119 static const struct bfd_key
<dwarf2_per_bfd
> dwarf2_per_bfd_bfd_data_key
;
120 static const struct objfile_key
<dwarf2_per_bfd
> dwarf2_per_bfd_objfile_data_key
;
122 /* The "aclass" indices for various kinds of computed DWARF symbols. */
124 static int dwarf2_locexpr_index
;
125 static int dwarf2_loclist_index
;
126 static int dwarf2_locexpr_block_index
;
127 static int dwarf2_loclist_block_index
;
129 /* Size of .debug_loclists section header for 32-bit DWARF format. */
130 #define LOCLIST_HEADER_SIZE32 12
132 /* Size of .debug_loclists section header for 64-bit DWARF format. */
133 #define LOCLIST_HEADER_SIZE64 20
135 /* Size of .debug_rnglists section header for 32-bit DWARF format. */
136 #define RNGLIST_HEADER_SIZE32 12
138 /* Size of .debug_rnglists section header for 64-bit DWARF format. */
139 #define RNGLIST_HEADER_SIZE64 20
141 /* An index into a (C++) symbol name component in a symbol name as
142 recorded in the mapped_index's symbol table. For each C++ symbol
143 in the symbol table, we record one entry for the start of each
144 component in the symbol in a table of name components, and then
145 sort the table, in order to be able to binary search symbol names,
146 ignoring leading namespaces, both completion and regular look up.
147 For example, for symbol "A::B::C", we'll have an entry that points
148 to "A::B::C", another that points to "B::C", and another for "C".
149 Note that function symbols in GDB index have no parameter
150 information, just the function/method names. You can convert a
151 name_component to a "const char *" using the
152 'mapped_index::symbol_name_at(offset_type)' method. */
154 struct name_component
156 /* Offset in the symbol name where the component starts. Stored as
157 a (32-bit) offset instead of a pointer to save memory and improve
158 locality on 64-bit architectures. */
159 offset_type name_offset
;
161 /* The symbol's index in the symbol and constant pool tables of a
166 /* Base class containing bits shared by both .gdb_index and
167 .debug_name indexes. */
169 struct mapped_index_base
171 mapped_index_base () = default;
172 DISABLE_COPY_AND_ASSIGN (mapped_index_base
);
174 /* The name_component table (a sorted vector). See name_component's
175 description above. */
176 std::vector
<name_component
> name_components
;
178 /* How NAME_COMPONENTS is sorted. */
179 enum case_sensitivity name_components_casing
;
181 /* Return the number of names in the symbol table. */
182 virtual size_t symbol_name_count () const = 0;
184 /* Get the name of the symbol at IDX in the symbol table. */
185 virtual const char *symbol_name_at
186 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const = 0;
188 /* Return whether the name at IDX in the symbol table should be
190 virtual bool symbol_name_slot_invalid (offset_type idx
) const
195 /* Build the symbol name component sorted vector, if we haven't
197 void build_name_components (dwarf2_per_objfile
*per_objfile
);
199 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
200 possible matches for LN_NO_PARAMS in the name component
202 std::pair
<std::vector
<name_component
>::const_iterator
,
203 std::vector
<name_component
>::const_iterator
>
204 find_name_components_bounds (const lookup_name_info
&ln_no_params
,
206 dwarf2_per_objfile
*per_objfile
) const;
208 /* Prevent deleting/destroying via a base class pointer. */
210 ~mapped_index_base() = default;
213 /* A description of the mapped index. The file format is described in
214 a comment by the code that writes the index. */
215 struct mapped_index final
: public mapped_index_base
217 /* A slot/bucket in the symbol table hash. */
218 struct symbol_table_slot
220 const offset_type name
;
221 const offset_type vec
;
224 /* Index data format version. */
227 /* The address table data. */
228 gdb::array_view
<const gdb_byte
> address_table
;
230 /* The symbol table, implemented as a hash table. */
231 gdb::array_view
<symbol_table_slot
> symbol_table
;
233 /* A pointer to the constant pool. */
234 const char *constant_pool
= nullptr;
236 bool symbol_name_slot_invalid (offset_type idx
) const override
238 const auto &bucket
= this->symbol_table
[idx
];
239 return bucket
.name
== 0 && bucket
.vec
== 0;
242 /* Convenience method to get at the name of the symbol at IDX in the
244 const char *symbol_name_at
245 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
246 { return this->constant_pool
+ MAYBE_SWAP (this->symbol_table
[idx
].name
); }
248 size_t symbol_name_count () const override
249 { return this->symbol_table
.size (); }
252 /* A description of the mapped .debug_names.
253 Uninitialized map has CU_COUNT 0. */
254 struct mapped_debug_names final
: public mapped_index_base
256 bfd_endian dwarf5_byte_order
;
257 bool dwarf5_is_dwarf64
;
258 bool augmentation_is_gdb
;
260 uint32_t cu_count
= 0;
261 uint32_t tu_count
, bucket_count
, name_count
;
262 const gdb_byte
*cu_table_reordered
, *tu_table_reordered
;
263 const uint32_t *bucket_table_reordered
, *hash_table_reordered
;
264 const gdb_byte
*name_table_string_offs_reordered
;
265 const gdb_byte
*name_table_entry_offs_reordered
;
266 const gdb_byte
*entry_pool
;
273 /* Attribute name DW_IDX_*. */
276 /* Attribute form DW_FORM_*. */
279 /* Value if FORM is DW_FORM_implicit_const. */
280 LONGEST implicit_const
;
282 std::vector
<attr
> attr_vec
;
285 std::unordered_map
<ULONGEST
, index_val
> abbrev_map
;
287 const char *namei_to_name
288 (uint32_t namei
, dwarf2_per_objfile
*per_objfile
) const;
290 /* Implementation of the mapped_index_base virtual interface, for
291 the name_components cache. */
293 const char *symbol_name_at
294 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
295 { return namei_to_name (idx
, per_objfile
); }
297 size_t symbol_name_count () const override
298 { return this->name_count
; }
301 /* See dwarf2read.h. */
304 get_dwarf2_per_objfile (struct objfile
*objfile
)
306 return dwarf2_objfile_data_key
.get (objfile
);
309 /* Default names of the debugging sections. */
311 /* Note that if the debugging section has been compressed, it might
312 have a name like .zdebug_info. */
314 static const struct dwarf2_debug_sections dwarf2_elf_names
=
316 { ".debug_info", ".zdebug_info" },
317 { ".debug_abbrev", ".zdebug_abbrev" },
318 { ".debug_line", ".zdebug_line" },
319 { ".debug_loc", ".zdebug_loc" },
320 { ".debug_loclists", ".zdebug_loclists" },
321 { ".debug_macinfo", ".zdebug_macinfo" },
322 { ".debug_macro", ".zdebug_macro" },
323 { ".debug_str", ".zdebug_str" },
324 { ".debug_str_offsets", ".zdebug_str_offsets" },
325 { ".debug_line_str", ".zdebug_line_str" },
326 { ".debug_ranges", ".zdebug_ranges" },
327 { ".debug_rnglists", ".zdebug_rnglists" },
328 { ".debug_types", ".zdebug_types" },
329 { ".debug_addr", ".zdebug_addr" },
330 { ".debug_frame", ".zdebug_frame" },
331 { ".eh_frame", NULL
},
332 { ".gdb_index", ".zgdb_index" },
333 { ".debug_names", ".zdebug_names" },
334 { ".debug_aranges", ".zdebug_aranges" },
338 /* List of DWO/DWP sections. */
340 static const struct dwop_section_names
342 struct dwarf2_section_names abbrev_dwo
;
343 struct dwarf2_section_names info_dwo
;
344 struct dwarf2_section_names line_dwo
;
345 struct dwarf2_section_names loc_dwo
;
346 struct dwarf2_section_names loclists_dwo
;
347 struct dwarf2_section_names macinfo_dwo
;
348 struct dwarf2_section_names macro_dwo
;
349 struct dwarf2_section_names rnglists_dwo
;
350 struct dwarf2_section_names str_dwo
;
351 struct dwarf2_section_names str_offsets_dwo
;
352 struct dwarf2_section_names types_dwo
;
353 struct dwarf2_section_names cu_index
;
354 struct dwarf2_section_names tu_index
;
358 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
359 { ".debug_info.dwo", ".zdebug_info.dwo" },
360 { ".debug_line.dwo", ".zdebug_line.dwo" },
361 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
362 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
363 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
364 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
365 { ".debug_rnglists.dwo", ".zdebug_rnglists.dwo" },
366 { ".debug_str.dwo", ".zdebug_str.dwo" },
367 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
368 { ".debug_types.dwo", ".zdebug_types.dwo" },
369 { ".debug_cu_index", ".zdebug_cu_index" },
370 { ".debug_tu_index", ".zdebug_tu_index" },
373 /* local data types */
375 /* The location list and range list sections (.debug_loclists & .debug_rnglists)
376 begin with a header, which contains the following information. */
377 struct loclists_rnglists_header
379 /* A 4-byte or 12-byte length containing the length of the
380 set of entries for this compilation unit, not including the
381 length field itself. */
384 /* A 2-byte version identifier. */
387 /* A 1-byte unsigned integer containing the size in bytes of an address on
388 the target system. */
389 unsigned char addr_size
;
391 /* A 1-byte unsigned integer containing the size in bytes of a segment selector
392 on the target system. */
393 unsigned char segment_collector_size
;
395 /* A 4-byte count of the number of offsets that follow the header. */
396 unsigned int offset_entry_count
;
399 /* Type used for delaying computation of method physnames.
400 See comments for compute_delayed_physnames. */
401 struct delayed_method_info
403 /* The type to which the method is attached, i.e., its parent class. */
406 /* The index of the method in the type's function fieldlists. */
409 /* The index of the method in the fieldlist. */
412 /* The name of the DIE. */
415 /* The DIE associated with this method. */
416 struct die_info
*die
;
419 /* Internal state when decoding a particular compilation unit. */
422 explicit dwarf2_cu (dwarf2_per_cu_data
*per_cu
,
423 dwarf2_per_objfile
*per_objfile
);
425 DISABLE_COPY_AND_ASSIGN (dwarf2_cu
);
427 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
428 Create the set of symtabs used by this TU, or if this TU is sharing
429 symtabs with another TU and the symtabs have already been created
430 then restore those symtabs in the line header.
431 We don't need the pc/line-number mapping for type units. */
432 void setup_type_unit_groups (struct die_info
*die
);
434 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
435 buildsym_compunit constructor. */
436 struct compunit_symtab
*start_symtab (const char *name
,
437 const char *comp_dir
,
440 /* Reset the builder. */
441 void reset_builder () { m_builder
.reset (); }
443 /* Return a type that is a generic pointer type, the size of which
444 matches the address size given in the compilation unit header for
446 struct type
*addr_type () const;
448 /* Find an integer type the same size as the address size given in
449 the compilation unit header for this CU. UNSIGNED_P controls if
450 the integer is unsigned or not. */
451 struct type
*addr_sized_int_type (bool unsigned_p
) const;
453 /* The header of the compilation unit. */
454 struct comp_unit_head header
{};
456 /* Base address of this compilation unit. */
457 gdb::optional
<CORE_ADDR
> base_address
;
459 /* The language we are debugging. */
460 enum language language
= language_unknown
;
461 const struct language_defn
*language_defn
= nullptr;
463 const char *producer
= nullptr;
466 /* The symtab builder for this CU. This is only non-NULL when full
467 symbols are being read. */
468 std::unique_ptr
<buildsym_compunit
> m_builder
;
471 /* The generic symbol table building routines have separate lists for
472 file scope symbols and all all other scopes (local scopes). So
473 we need to select the right one to pass to add_symbol_to_list().
474 We do it by keeping a pointer to the correct list in list_in_scope.
476 FIXME: The original dwarf code just treated the file scope as the
477 first local scope, and all other local scopes as nested local
478 scopes, and worked fine. Check to see if we really need to
479 distinguish these in buildsym.c. */
480 struct pending
**list_in_scope
= nullptr;
482 /* Hash table holding all the loaded partial DIEs
483 with partial_die->offset.SECT_OFF as hash. */
484 htab_t partial_dies
= nullptr;
486 /* Storage for things with the same lifetime as this read-in compilation
487 unit, including partial DIEs. */
488 auto_obstack comp_unit_obstack
;
490 /* Backlink to our per_cu entry. */
491 struct dwarf2_per_cu_data
*per_cu
;
493 /* The dwarf2_per_objfile that owns this. */
494 dwarf2_per_objfile
*per_objfile
;
496 /* How many compilation units ago was this CU last referenced? */
499 /* A hash table of DIE cu_offset for following references with
500 die_info->offset.sect_off as hash. */
501 htab_t die_hash
= nullptr;
503 /* Full DIEs if read in. */
504 struct die_info
*dies
= nullptr;
506 /* A set of pointers to dwarf2_per_cu_data objects for compilation
507 units referenced by this one. Only set during full symbol processing;
508 partial symbol tables do not have dependencies. */
509 htab_t dependencies
= nullptr;
511 /* Header data from the line table, during full symbol processing. */
512 struct line_header
*line_header
= nullptr;
513 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
514 it's owned by dwarf2_per_bfd::line_header_hash. If non-NULL,
515 this is the DW_TAG_compile_unit die for this CU. We'll hold on
516 to the line header as long as this DIE is being processed. See
517 process_die_scope. */
518 die_info
*line_header_die_owner
= nullptr;
520 /* A list of methods which need to have physnames computed
521 after all type information has been read. */
522 std::vector
<delayed_method_info
> method_list
;
524 /* To be copied to symtab->call_site_htab. */
525 htab_t call_site_htab
= nullptr;
527 /* Non-NULL if this CU came from a DWO file.
528 There is an invariant here that is important to remember:
529 Except for attributes copied from the top level DIE in the "main"
530 (or "stub") file in preparation for reading the DWO file
531 (e.g., DW_AT_addr_base), we KISS: there is only *one* CU.
532 Either there isn't a DWO file (in which case this is NULL and the point
533 is moot), or there is and either we're not going to read it (in which
534 case this is NULL) or there is and we are reading it (in which case this
536 struct dwo_unit
*dwo_unit
= nullptr;
538 /* The DW_AT_addr_base (DW_AT_GNU_addr_base) attribute if present.
539 Note this value comes from the Fission stub CU/TU's DIE. */
540 gdb::optional
<ULONGEST
> addr_base
;
542 /* The DW_AT_rnglists_base attribute if present.
543 Note this value comes from the Fission stub CU/TU's DIE.
544 Also note that the value is zero in the non-DWO case so this value can
545 be used without needing to know whether DWO files are in use or not.
546 N.B. This does not apply to DW_AT_ranges appearing in
547 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
548 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
549 DW_AT_rnglists_base *would* have to be applied, and we'd have to care
550 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
551 ULONGEST ranges_base
= 0;
553 /* The DW_AT_loclists_base attribute if present. */
554 ULONGEST loclist_base
= 0;
556 /* When reading debug info generated by older versions of rustc, we
557 have to rewrite some union types to be struct types with a
558 variant part. This rewriting must be done after the CU is fully
559 read in, because otherwise at the point of rewriting some struct
560 type might not have been fully processed. So, we keep a list of
561 all such types here and process them after expansion. */
562 std::vector
<struct type
*> rust_unions
;
564 /* The DW_AT_str_offsets_base attribute if present. For DWARF 4 version DWO
565 files, the value is implicitly zero. For DWARF 5 version DWO files, the
566 value is often implicit and is the size of the header of
567 .debug_str_offsets section (8 or 4, depending on the address size). */
568 gdb::optional
<ULONGEST
> str_offsets_base
;
570 /* Mark used when releasing cached dies. */
573 /* This CU references .debug_loc. See the symtab->locations_valid field.
574 This test is imperfect as there may exist optimized debug code not using
575 any location list and still facing inlining issues if handled as
576 unoptimized code. For a future better test see GCC PR other/32998. */
577 bool has_loclist
: 1;
579 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is true
580 if all the producer_is_* fields are valid. This information is cached
581 because profiling CU expansion showed excessive time spent in
582 producer_is_gxx_lt_4_6. */
583 bool checked_producer
: 1;
584 bool producer_is_gxx_lt_4_6
: 1;
585 bool producer_is_gcc_lt_4_3
: 1;
586 bool producer_is_icc
: 1;
587 bool producer_is_icc_lt_14
: 1;
588 bool producer_is_codewarrior
: 1;
590 /* When true, the file that we're processing is known to have
591 debugging info for C++ namespaces. GCC 3.3.x did not produce
592 this information, but later versions do. */
594 bool processing_has_namespace_info
: 1;
596 struct partial_die_info
*find_partial_die (sect_offset sect_off
);
598 /* If this CU was inherited by another CU (via specification,
599 abstract_origin, etc), this is the ancestor CU. */
602 /* Get the buildsym_compunit for this CU. */
603 buildsym_compunit
*get_builder ()
605 /* If this CU has a builder associated with it, use that. */
606 if (m_builder
!= nullptr)
607 return m_builder
.get ();
609 /* Otherwise, search ancestors for a valid builder. */
610 if (ancestor
!= nullptr)
611 return ancestor
->get_builder ();
617 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
618 This includes type_unit_group and quick_file_names. */
620 struct stmt_list_hash
622 /* The DWO unit this table is from or NULL if there is none. */
623 struct dwo_unit
*dwo_unit
;
625 /* Offset in .debug_line or .debug_line.dwo. */
626 sect_offset line_sect_off
;
629 /* Each element of dwarf2_per_bfd->type_unit_groups is a pointer to
630 an object of this type. This contains elements of type unit groups
631 that can be shared across objfiles. The non-shareable parts are in
632 type_unit_group_unshareable. */
634 struct type_unit_group
636 /* dwarf2read.c's main "handle" on a TU symtab.
637 To simplify things we create an artificial CU that "includes" all the
638 type units using this stmt_list so that the rest of the code still has
639 a "per_cu" handle on the symtab. */
640 struct dwarf2_per_cu_data per_cu
;
642 /* The TUs that share this DW_AT_stmt_list entry.
643 This is added to while parsing type units to build partial symtabs,
644 and is deleted afterwards and not used again. */
645 std::vector
<signatured_type
*> *tus
;
647 /* The data used to construct the hash key. */
648 struct stmt_list_hash hash
;
651 /* These sections are what may appear in a (real or virtual) DWO file. */
655 struct dwarf2_section_info abbrev
;
656 struct dwarf2_section_info line
;
657 struct dwarf2_section_info loc
;
658 struct dwarf2_section_info loclists
;
659 struct dwarf2_section_info macinfo
;
660 struct dwarf2_section_info macro
;
661 struct dwarf2_section_info rnglists
;
662 struct dwarf2_section_info str
;
663 struct dwarf2_section_info str_offsets
;
664 /* In the case of a virtual DWO file, these two are unused. */
665 struct dwarf2_section_info info
;
666 std::vector
<dwarf2_section_info
> types
;
669 /* CUs/TUs in DWP/DWO files. */
673 /* Backlink to the containing struct dwo_file. */
674 struct dwo_file
*dwo_file
;
676 /* The "id" that distinguishes this CU/TU.
677 .debug_info calls this "dwo_id", .debug_types calls this "signature".
678 Since signatures came first, we stick with it for consistency. */
681 /* The section this CU/TU lives in, in the DWO file. */
682 struct dwarf2_section_info
*section
;
684 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
685 sect_offset sect_off
;
688 /* For types, offset in the type's DIE of the type defined by this TU. */
689 cu_offset type_offset_in_tu
;
692 /* include/dwarf2.h defines the DWP section codes.
693 It defines a max value but it doesn't define a min value, which we
694 use for error checking, so provide one. */
696 enum dwp_v2_section_ids
701 /* Data for one DWO file.
703 This includes virtual DWO files (a virtual DWO file is a DWO file as it
704 appears in a DWP file). DWP files don't really have DWO files per se -
705 comdat folding of types "loses" the DWO file they came from, and from
706 a high level view DWP files appear to contain a mass of random types.
707 However, to maintain consistency with the non-DWP case we pretend DWP
708 files contain virtual DWO files, and we assign each TU with one virtual
709 DWO file (generally based on the line and abbrev section offsets -
710 a heuristic that seems to work in practice). */
714 dwo_file () = default;
715 DISABLE_COPY_AND_ASSIGN (dwo_file
);
717 /* The DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute.
718 For virtual DWO files the name is constructed from the section offsets
719 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
720 from related CU+TUs. */
721 const char *dwo_name
= nullptr;
723 /* The DW_AT_comp_dir attribute. */
724 const char *comp_dir
= nullptr;
726 /* The bfd, when the file is open. Otherwise this is NULL.
727 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
728 gdb_bfd_ref_ptr dbfd
;
730 /* The sections that make up this DWO file.
731 Remember that for virtual DWO files in DWP V2 or DWP V5, these are virtual
732 sections (for lack of a better name). */
733 struct dwo_sections sections
{};
735 /* The CUs in the file.
736 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
737 an extension to handle LLVM's Link Time Optimization output (where
738 multiple source files may be compiled into a single object/dwo pair). */
741 /* Table of TUs in the file.
742 Each element is a struct dwo_unit. */
746 /* These sections are what may appear in a DWP file. */
750 /* These are used by all DWP versions (1, 2 and 5). */
751 struct dwarf2_section_info str
;
752 struct dwarf2_section_info cu_index
;
753 struct dwarf2_section_info tu_index
;
755 /* These are only used by DWP version 2 and version 5 files.
756 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
757 sections are referenced by section number, and are not recorded here.
758 In DWP version 2 or 5 there is at most one copy of all these sections,
759 each section being (effectively) comprised of the concatenation of all of
760 the individual sections that exist in the version 1 format.
761 To keep the code simple we treat each of these concatenated pieces as a
762 section itself (a virtual section?). */
763 struct dwarf2_section_info abbrev
;
764 struct dwarf2_section_info info
;
765 struct dwarf2_section_info line
;
766 struct dwarf2_section_info loc
;
767 struct dwarf2_section_info loclists
;
768 struct dwarf2_section_info macinfo
;
769 struct dwarf2_section_info macro
;
770 struct dwarf2_section_info rnglists
;
771 struct dwarf2_section_info str_offsets
;
772 struct dwarf2_section_info types
;
775 /* These sections are what may appear in a virtual DWO file in DWP version 1.
776 A virtual DWO file is a DWO file as it appears in a DWP file. */
778 struct virtual_v1_dwo_sections
780 struct dwarf2_section_info abbrev
;
781 struct dwarf2_section_info line
;
782 struct dwarf2_section_info loc
;
783 struct dwarf2_section_info macinfo
;
784 struct dwarf2_section_info macro
;
785 struct dwarf2_section_info str_offsets
;
786 /* Each DWP hash table entry records one CU or one TU.
787 That is recorded here, and copied to dwo_unit.section. */
788 struct dwarf2_section_info info_or_types
;
791 /* Similar to virtual_v1_dwo_sections, but for DWP version 2 or 5.
792 In version 2, the sections of the DWO files are concatenated together
793 and stored in one section of that name. Thus each ELF section contains
794 several "virtual" sections. */
796 struct virtual_v2_or_v5_dwo_sections
798 bfd_size_type abbrev_offset
;
799 bfd_size_type abbrev_size
;
801 bfd_size_type line_offset
;
802 bfd_size_type line_size
;
804 bfd_size_type loc_offset
;
805 bfd_size_type loc_size
;
807 bfd_size_type loclists_offset
;
808 bfd_size_type loclists_size
;
810 bfd_size_type macinfo_offset
;
811 bfd_size_type macinfo_size
;
813 bfd_size_type macro_offset
;
814 bfd_size_type macro_size
;
816 bfd_size_type rnglists_offset
;
817 bfd_size_type rnglists_size
;
819 bfd_size_type str_offsets_offset
;
820 bfd_size_type str_offsets_size
;
822 /* Each DWP hash table entry records one CU or one TU.
823 That is recorded here, and copied to dwo_unit.section. */
824 bfd_size_type info_or_types_offset
;
825 bfd_size_type info_or_types_size
;
828 /* Contents of DWP hash tables. */
830 struct dwp_hash_table
832 uint32_t version
, nr_columns
;
833 uint32_t nr_units
, nr_slots
;
834 const gdb_byte
*hash_table
, *unit_table
;
839 const gdb_byte
*indices
;
843 /* This is indexed by column number and gives the id of the section
845 #define MAX_NR_V2_DWO_SECTIONS \
846 (1 /* .debug_info or .debug_types */ \
847 + 1 /* .debug_abbrev */ \
848 + 1 /* .debug_line */ \
849 + 1 /* .debug_loc */ \
850 + 1 /* .debug_str_offsets */ \
851 + 1 /* .debug_macro or .debug_macinfo */)
852 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
853 const gdb_byte
*offsets
;
854 const gdb_byte
*sizes
;
858 /* This is indexed by column number and gives the id of the section
860 #define MAX_NR_V5_DWO_SECTIONS \
861 (1 /* .debug_info */ \
862 + 1 /* .debug_abbrev */ \
863 + 1 /* .debug_line */ \
864 + 1 /* .debug_loclists */ \
865 + 1 /* .debug_str_offsets */ \
866 + 1 /* .debug_macro */ \
867 + 1 /* .debug_rnglists */)
868 int section_ids
[MAX_NR_V5_DWO_SECTIONS
];
869 const gdb_byte
*offsets
;
870 const gdb_byte
*sizes
;
875 /* Data for one DWP file. */
879 dwp_file (const char *name_
, gdb_bfd_ref_ptr
&&abfd
)
881 dbfd (std::move (abfd
))
885 /* Name of the file. */
888 /* File format version. */
892 gdb_bfd_ref_ptr dbfd
;
894 /* Section info for this file. */
895 struct dwp_sections sections
{};
897 /* Table of CUs in the file. */
898 const struct dwp_hash_table
*cus
= nullptr;
900 /* Table of TUs in the file. */
901 const struct dwp_hash_table
*tus
= nullptr;
903 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
907 /* Table to map ELF section numbers to their sections.
908 This is only needed for the DWP V1 file format. */
909 unsigned int num_sections
= 0;
910 asection
**elf_sections
= nullptr;
913 /* Struct used to pass misc. parameters to read_die_and_children, et
914 al. which are used for both .debug_info and .debug_types dies.
915 All parameters here are unchanging for the life of the call. This
916 struct exists to abstract away the constant parameters of die reading. */
918 struct die_reader_specs
920 /* The bfd of die_section. */
923 /* The CU of the DIE we are parsing. */
924 struct dwarf2_cu
*cu
;
926 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
927 struct dwo_file
*dwo_file
;
929 /* The section the die comes from.
930 This is either .debug_info or .debug_types, or the .dwo variants. */
931 struct dwarf2_section_info
*die_section
;
933 /* die_section->buffer. */
934 const gdb_byte
*buffer
;
936 /* The end of the buffer. */
937 const gdb_byte
*buffer_end
;
939 /* The abbreviation table to use when reading the DIEs. */
940 struct abbrev_table
*abbrev_table
;
943 /* A subclass of die_reader_specs that holds storage and has complex
944 constructor and destructor behavior. */
946 class cutu_reader
: public die_reader_specs
950 cutu_reader (dwarf2_per_cu_data
*this_cu
,
951 dwarf2_per_objfile
*per_objfile
,
952 struct abbrev_table
*abbrev_table
,
953 dwarf2_cu
*existing_cu
,
956 explicit cutu_reader (struct dwarf2_per_cu_data
*this_cu
,
957 dwarf2_per_objfile
*per_objfile
,
958 struct dwarf2_cu
*parent_cu
= nullptr,
959 struct dwo_file
*dwo_file
= nullptr);
961 DISABLE_COPY_AND_ASSIGN (cutu_reader
);
963 const gdb_byte
*info_ptr
= nullptr;
964 struct die_info
*comp_unit_die
= nullptr;
965 bool dummy_p
= false;
967 /* Release the new CU, putting it on the chain. This cannot be done
972 void init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
973 dwarf2_per_objfile
*per_objfile
,
974 dwarf2_cu
*existing_cu
);
976 struct dwarf2_per_cu_data
*m_this_cu
;
977 std::unique_ptr
<dwarf2_cu
> m_new_cu
;
979 /* The ordinary abbreviation table. */
980 abbrev_table_up m_abbrev_table_holder
;
982 /* The DWO abbreviation table. */
983 abbrev_table_up m_dwo_abbrev_table
;
986 /* When we construct a partial symbol table entry we only
987 need this much information. */
988 struct partial_die_info
: public allocate_on_obstack
990 partial_die_info (sect_offset sect_off
, struct abbrev_info
*abbrev
);
992 /* Disable assign but still keep copy ctor, which is needed
993 load_partial_dies. */
994 partial_die_info
& operator=(const partial_die_info
& rhs
) = delete;
996 /* Adjust the partial die before generating a symbol for it. This
997 function may set the is_external flag or change the DIE's
999 void fixup (struct dwarf2_cu
*cu
);
1001 /* Read a minimal amount of information into the minimal die
1003 const gdb_byte
*read (const struct die_reader_specs
*reader
,
1004 const struct abbrev_info
&abbrev
,
1005 const gdb_byte
*info_ptr
);
1007 /* Compute the name of this partial DIE. This memoizes the
1008 result, so it is safe to call multiple times. */
1009 const char *name (dwarf2_cu
*cu
);
1011 /* Offset of this DIE. */
1012 const sect_offset sect_off
;
1014 /* DWARF-2 tag for this DIE. */
1015 const ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1017 /* Assorted flags describing the data found in this DIE. */
1018 const unsigned int has_children
: 1;
1020 unsigned int is_external
: 1;
1021 unsigned int is_declaration
: 1;
1022 unsigned int has_type
: 1;
1023 unsigned int has_specification
: 1;
1024 unsigned int has_pc_info
: 1;
1025 unsigned int may_be_inlined
: 1;
1027 /* This DIE has been marked DW_AT_main_subprogram. */
1028 unsigned int main_subprogram
: 1;
1030 /* Flag set if the SCOPE field of this structure has been
1032 unsigned int scope_set
: 1;
1034 /* Flag set if the DIE has a byte_size attribute. */
1035 unsigned int has_byte_size
: 1;
1037 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1038 unsigned int has_const_value
: 1;
1040 /* Flag set if any of the DIE's children are template arguments. */
1041 unsigned int has_template_arguments
: 1;
1043 /* Flag set if fixup has been called on this die. */
1044 unsigned int fixup_called
: 1;
1046 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1047 unsigned int is_dwz
: 1;
1049 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1050 unsigned int spec_is_dwz
: 1;
1052 unsigned int canonical_name
: 1;
1054 /* The name of this DIE. Normally the value of DW_AT_name, but
1055 sometimes a default name for unnamed DIEs. */
1056 const char *raw_name
= nullptr;
1058 /* The linkage name, if present. */
1059 const char *linkage_name
= nullptr;
1061 /* The scope to prepend to our children. This is generally
1062 allocated on the comp_unit_obstack, so will disappear
1063 when this compilation unit leaves the cache. */
1064 const char *scope
= nullptr;
1066 /* Some data associated with the partial DIE. The tag determines
1067 which field is live. */
1070 /* The location description associated with this DIE, if any. */
1071 struct dwarf_block
*locdesc
;
1072 /* The offset of an import, for DW_TAG_imported_unit. */
1073 sect_offset sect_off
;
1076 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1077 CORE_ADDR lowpc
= 0;
1078 CORE_ADDR highpc
= 0;
1080 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1081 DW_AT_sibling, if any. */
1082 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1083 could return DW_AT_sibling values to its caller load_partial_dies. */
1084 const gdb_byte
*sibling
= nullptr;
1086 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1087 DW_AT_specification (or DW_AT_abstract_origin or
1088 DW_AT_extension). */
1089 sect_offset spec_offset
{};
1091 /* Pointers to this DIE's parent, first child, and next sibling,
1093 struct partial_die_info
*die_parent
= nullptr;
1094 struct partial_die_info
*die_child
= nullptr;
1095 struct partial_die_info
*die_sibling
= nullptr;
1097 friend struct partial_die_info
*
1098 dwarf2_cu::find_partial_die (sect_offset sect_off
);
1101 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1102 partial_die_info (sect_offset sect_off
)
1103 : partial_die_info (sect_off
, DW_TAG_padding
, 0)
1107 partial_die_info (sect_offset sect_off_
, enum dwarf_tag tag_
,
1109 : sect_off (sect_off_
), tag (tag_
), has_children (has_children_
)
1114 has_specification
= 0;
1117 main_subprogram
= 0;
1120 has_const_value
= 0;
1121 has_template_arguments
= 0;
1129 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1130 but this would require a corresponding change in unpack_field_as_long
1132 static int bits_per_byte
= 8;
1134 struct variant_part_builder
;
1136 /* When reading a variant, we track a bit more information about the
1137 field, and store it in an object of this type. */
1139 struct variant_field
1141 int first_field
= -1;
1142 int last_field
= -1;
1144 /* A variant can contain other variant parts. */
1145 std::vector
<variant_part_builder
> variant_parts
;
1147 /* If we see a DW_TAG_variant, then this will be set if this is the
1149 bool default_branch
= false;
1150 /* If we see a DW_AT_discr_value, then this will be the discriminant
1152 ULONGEST discriminant_value
= 0;
1153 /* If we see a DW_AT_discr_list, then this is a pointer to the list
1155 struct dwarf_block
*discr_list_data
= nullptr;
1158 /* This represents a DW_TAG_variant_part. */
1160 struct variant_part_builder
1162 /* The offset of the discriminant field. */
1163 sect_offset discriminant_offset
{};
1165 /* Variants that are direct children of this variant part. */
1166 std::vector
<variant_field
> variants
;
1168 /* True if we're currently reading a variant. */
1169 bool processing_variant
= false;
1174 int accessibility
= 0;
1176 /* Variant parts need to find the discriminant, which is a DIE
1177 reference. We track the section offset of each field to make
1180 struct field field
{};
1185 const char *name
= nullptr;
1186 std::vector
<struct fn_field
> fnfields
;
1189 /* The routines that read and process dies for a C struct or C++ class
1190 pass lists of data member fields and lists of member function fields
1191 in an instance of a field_info structure, as defined below. */
1194 /* List of data member and baseclasses fields. */
1195 std::vector
<struct nextfield
> fields
;
1196 std::vector
<struct nextfield
> baseclasses
;
1198 /* Set if the accessibility of one of the fields is not public. */
1199 bool non_public_fields
= false;
1201 /* Member function fieldlist array, contains name of possibly overloaded
1202 member function, number of overloaded member functions and a pointer
1203 to the head of the member function field chain. */
1204 std::vector
<struct fnfieldlist
> fnfieldlists
;
1206 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1207 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1208 std::vector
<struct decl_field
> typedef_field_list
;
1210 /* Nested types defined by this class and the number of elements in this
1212 std::vector
<struct decl_field
> nested_types_list
;
1214 /* If non-null, this is the variant part we are currently
1216 variant_part_builder
*current_variant_part
= nullptr;
1217 /* This holds all the top-level variant parts attached to the type
1219 std::vector
<variant_part_builder
> variant_parts
;
1221 /* Return the total number of fields (including baseclasses). */
1222 int nfields () const
1224 return fields
.size () + baseclasses
.size ();
1228 /* Loaded secondary compilation units are kept in memory until they
1229 have not been referenced for the processing of this many
1230 compilation units. Set this to zero to disable caching. Cache
1231 sizes of up to at least twenty will improve startup time for
1232 typical inter-CU-reference binaries, at an obvious memory cost. */
1233 static int dwarf_max_cache_age
= 5;
1235 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1236 struct cmd_list_element
*c
, const char *value
)
1238 fprintf_filtered (file
, _("The upper bound on the age of cached "
1239 "DWARF compilation units is %s.\n"),
1243 /* local function prototypes */
1245 static void dwarf2_find_base_address (struct die_info
*die
,
1246 struct dwarf2_cu
*cu
);
1248 static dwarf2_psymtab
*create_partial_symtab
1249 (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
1252 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1253 const gdb_byte
*info_ptr
,
1254 struct die_info
*type_unit_die
);
1256 static void dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
);
1258 static void scan_partial_symbols (struct partial_die_info
*,
1259 CORE_ADDR
*, CORE_ADDR
*,
1260 int, struct dwarf2_cu
*);
1262 static void add_partial_symbol (struct partial_die_info
*,
1263 struct dwarf2_cu
*);
1265 static void add_partial_namespace (struct partial_die_info
*pdi
,
1266 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1267 int set_addrmap
, struct dwarf2_cu
*cu
);
1269 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1270 CORE_ADDR
*highpc
, int set_addrmap
,
1271 struct dwarf2_cu
*cu
);
1273 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1274 struct dwarf2_cu
*cu
);
1276 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1277 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1278 int need_pc
, struct dwarf2_cu
*cu
);
1280 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1282 static struct partial_die_info
*load_partial_dies
1283 (const struct die_reader_specs
*, const gdb_byte
*, int);
1285 /* A pair of partial_die_info and compilation unit. */
1286 struct cu_partial_die_info
1288 /* The compilation unit of the partial_die_info. */
1289 struct dwarf2_cu
*cu
;
1290 /* A partial_die_info. */
1291 struct partial_die_info
*pdi
;
1293 cu_partial_die_info (struct dwarf2_cu
*cu
, struct partial_die_info
*pdi
)
1299 cu_partial_die_info () = delete;
1302 static const struct cu_partial_die_info
find_partial_die (sect_offset
, int,
1303 struct dwarf2_cu
*);
1305 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1306 struct attribute
*, struct attr_abbrev
*,
1309 static void read_attribute_reprocess (const struct die_reader_specs
*reader
,
1310 struct attribute
*attr
, dwarf_tag tag
);
1312 static CORE_ADDR
read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
);
1314 static sect_offset
read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
1315 dwarf2_section_info
*, sect_offset
);
1317 static const char *read_indirect_string
1318 (dwarf2_per_objfile
*per_objfile
, bfd
*, const gdb_byte
*,
1319 const struct comp_unit_head
*, unsigned int *);
1321 static const char *read_indirect_string_at_offset
1322 (dwarf2_per_objfile
*per_objfile
, LONGEST str_offset
);
1324 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1328 static const char *read_dwo_str_index (const struct die_reader_specs
*reader
,
1329 ULONGEST str_index
);
1331 static const char *read_stub_str_index (struct dwarf2_cu
*cu
,
1332 ULONGEST str_index
);
1334 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1336 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1337 struct dwarf2_cu
*);
1339 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1340 struct dwarf2_cu
*cu
);
1342 static const char *dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
1344 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1345 struct dwarf2_cu
*cu
);
1347 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1349 static struct die_info
*die_specification (struct die_info
*die
,
1350 struct dwarf2_cu
**);
1352 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1353 struct dwarf2_cu
*cu
);
1355 static void dwarf_decode_lines (struct line_header
*, const char *,
1356 struct dwarf2_cu
*, dwarf2_psymtab
*,
1357 CORE_ADDR
, int decode_mapping
);
1359 static void dwarf2_start_subfile (struct dwarf2_cu
*, const char *,
1362 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1363 struct dwarf2_cu
*, struct symbol
* = NULL
);
1365 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1366 struct dwarf2_cu
*);
1368 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1371 struct obstack
*obstack
,
1372 struct dwarf2_cu
*cu
, LONGEST
*value
,
1373 const gdb_byte
**bytes
,
1374 struct dwarf2_locexpr_baton
**baton
);
1376 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1378 static int need_gnat_info (struct dwarf2_cu
*);
1380 static struct type
*die_descriptive_type (struct die_info
*,
1381 struct dwarf2_cu
*);
1383 static void set_descriptive_type (struct type
*, struct die_info
*,
1384 struct dwarf2_cu
*);
1386 static struct type
*die_containing_type (struct die_info
*,
1387 struct dwarf2_cu
*);
1389 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1390 struct dwarf2_cu
*);
1392 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1394 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1396 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1398 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1399 const char *suffix
, int physname
,
1400 struct dwarf2_cu
*cu
);
1402 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1404 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1406 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1408 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1410 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1412 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1414 /* Return the .debug_loclists section to use for cu. */
1415 static struct dwarf2_section_info
*cu_debug_loc_section (struct dwarf2_cu
*cu
);
1417 /* Return the .debug_rnglists section to use for cu. */
1418 static struct dwarf2_section_info
*cu_debug_rnglists_section
1419 (struct dwarf2_cu
*cu
, dwarf_tag tag
);
1421 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1422 values. Keep the items ordered with increasing constraints compliance. */
1425 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1426 PC_BOUNDS_NOT_PRESENT
,
1428 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1429 were present but they do not form a valid range of PC addresses. */
1432 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1435 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1439 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1440 CORE_ADDR
*, CORE_ADDR
*,
1444 static void get_scope_pc_bounds (struct die_info
*,
1445 CORE_ADDR
*, CORE_ADDR
*,
1446 struct dwarf2_cu
*);
1448 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1449 CORE_ADDR
, struct dwarf2_cu
*);
1451 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1452 struct dwarf2_cu
*);
1454 static void dwarf2_attach_fields_to_type (struct field_info
*,
1455 struct type
*, struct dwarf2_cu
*);
1457 static void dwarf2_add_member_fn (struct field_info
*,
1458 struct die_info
*, struct type
*,
1459 struct dwarf2_cu
*);
1461 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1463 struct dwarf2_cu
*);
1465 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1467 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1469 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1471 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1473 static struct using_direct
**using_directives (struct dwarf2_cu
*cu
);
1475 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1477 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1479 static struct type
*read_module_type (struct die_info
*die
,
1480 struct dwarf2_cu
*cu
);
1482 static const char *namespace_name (struct die_info
*die
,
1483 int *is_anonymous
, struct dwarf2_cu
*);
1485 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1487 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*,
1490 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1491 struct dwarf2_cu
*);
1493 static struct die_info
*read_die_and_siblings_1
1494 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1497 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1498 const gdb_byte
*info_ptr
,
1499 const gdb_byte
**new_info_ptr
,
1500 struct die_info
*parent
);
1502 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1503 struct die_info
**, const gdb_byte
*,
1506 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1507 struct die_info
**, const gdb_byte
*);
1509 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1511 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1514 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1516 static const char *dwarf2_full_name (const char *name
,
1517 struct die_info
*die
,
1518 struct dwarf2_cu
*cu
);
1520 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1521 struct dwarf2_cu
*cu
);
1523 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1524 struct dwarf2_cu
**);
1526 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1528 static void dump_die_for_error (struct die_info
*);
1530 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1533 /*static*/ void dump_die (struct die_info
*, int max_level
);
1535 static void store_in_ref_table (struct die_info
*,
1536 struct dwarf2_cu
*);
1538 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1539 const struct attribute
*,
1540 struct dwarf2_cu
**);
1542 static struct die_info
*follow_die_ref (struct die_info
*,
1543 const struct attribute
*,
1544 struct dwarf2_cu
**);
1546 static struct die_info
*follow_die_sig (struct die_info
*,
1547 const struct attribute
*,
1548 struct dwarf2_cu
**);
1550 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1551 struct dwarf2_cu
*);
1553 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1554 const struct attribute
*,
1555 struct dwarf2_cu
*);
1557 static void load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
1558 dwarf2_per_objfile
*per_objfile
);
1560 static void read_signatured_type (signatured_type
*sig_type
,
1561 dwarf2_per_objfile
*per_objfile
);
1563 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1564 struct die_info
*die
, struct dwarf2_cu
*cu
,
1565 struct dynamic_prop
*prop
, struct type
*type
);
1567 /* memory allocation interface */
1569 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1571 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1573 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1575 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1576 struct dwarf2_loclist_baton
*baton
,
1577 const struct attribute
*attr
);
1579 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1581 struct dwarf2_cu
*cu
,
1584 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1585 const gdb_byte
*info_ptr
,
1586 struct abbrev_info
*abbrev
);
1588 static hashval_t
partial_die_hash (const void *item
);
1590 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1592 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1593 (sect_offset sect_off
, unsigned int offset_in_dwz
,
1594 dwarf2_per_objfile
*per_objfile
);
1596 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1597 struct die_info
*comp_unit_die
,
1598 enum language pretend_language
);
1600 static struct type
*set_die_type (struct die_info
*, struct type
*,
1601 struct dwarf2_cu
*);
1603 static void create_all_comp_units (dwarf2_per_objfile
*per_objfile
);
1605 static int create_all_type_units (dwarf2_per_objfile
*per_objfile
);
1607 static void load_full_comp_unit (dwarf2_per_cu_data
*per_cu
,
1608 dwarf2_per_objfile
*per_objfile
,
1609 dwarf2_cu
*existing_cu
,
1611 enum language pretend_language
);
1613 static void process_full_comp_unit (dwarf2_cu
*cu
,
1614 enum language pretend_language
);
1616 static void process_full_type_unit (dwarf2_cu
*cu
,
1617 enum language pretend_language
);
1619 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1620 struct dwarf2_per_cu_data
*);
1622 static void dwarf2_mark (struct dwarf2_cu
*);
1624 static struct type
*get_die_type_at_offset (sect_offset
,
1625 dwarf2_per_cu_data
*per_cu
,
1626 dwarf2_per_objfile
*per_objfile
);
1628 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1630 static void queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
1631 dwarf2_per_objfile
*per_objfile
,
1632 enum language pretend_language
);
1634 static void process_queue (dwarf2_per_objfile
*per_objfile
);
1636 /* Class, the destructor of which frees all allocated queue entries. This
1637 will only have work to do if an error was thrown while processing the
1638 dwarf. If no error was thrown then the queue entries should have all
1639 been processed, and freed, as we went along. */
1641 class dwarf2_queue_guard
1644 explicit dwarf2_queue_guard (dwarf2_per_objfile
*per_objfile
)
1645 : m_per_objfile (per_objfile
)
1649 /* Free any entries remaining on the queue. There should only be
1650 entries left if we hit an error while processing the dwarf. */
1651 ~dwarf2_queue_guard ()
1653 /* Ensure that no memory is allocated by the queue. */
1654 std::queue
<dwarf2_queue_item
> empty
;
1655 std::swap (m_per_objfile
->per_bfd
->queue
, empty
);
1658 DISABLE_COPY_AND_ASSIGN (dwarf2_queue_guard
);
1661 dwarf2_per_objfile
*m_per_objfile
;
1664 dwarf2_queue_item::~dwarf2_queue_item ()
1666 /* Anything still marked queued is likely to be in an
1667 inconsistent state, so discard it. */
1670 per_objfile
->remove_cu (per_cu
);
1675 /* The return type of find_file_and_directory. Note, the enclosed
1676 string pointers are only valid while this object is valid. */
1678 struct file_and_directory
1680 /* The filename. This is never NULL. */
1683 /* The compilation directory. NULL if not known. If we needed to
1684 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1685 points directly to the DW_AT_comp_dir string attribute owned by
1686 the obstack that owns the DIE. */
1687 const char *comp_dir
;
1689 /* If we needed to build a new string for comp_dir, this is what
1690 owns the storage. */
1691 std::string comp_dir_storage
;
1694 static file_and_directory
find_file_and_directory (struct die_info
*die
,
1695 struct dwarf2_cu
*cu
);
1697 static htab_up
allocate_signatured_type_table ();
1699 static htab_up
allocate_dwo_unit_table ();
1701 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1702 (dwarf2_per_objfile
*per_objfile
, struct dwp_file
*dwp_file
,
1703 const char *comp_dir
, ULONGEST signature
, int is_debug_types
);
1705 static struct dwp_file
*get_dwp_file (dwarf2_per_objfile
*per_objfile
);
1707 static struct dwo_unit
*lookup_dwo_comp_unit
1708 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
1709 ULONGEST signature
);
1711 static struct dwo_unit
*lookup_dwo_type_unit
1712 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
);
1714 static void queue_and_load_all_dwo_tus (dwarf2_cu
*cu
);
1716 /* A unique pointer to a dwo_file. */
1718 typedef std::unique_ptr
<struct dwo_file
> dwo_file_up
;
1720 static void process_cu_includes (dwarf2_per_objfile
*per_objfile
);
1722 static void check_producer (struct dwarf2_cu
*cu
);
1724 static void free_line_header_voidp (void *arg
);
1726 /* Various complaints about symbol reading that don't abort the process. */
1729 dwarf2_debug_line_missing_file_complaint (void)
1731 complaint (_(".debug_line section has line data without a file"));
1735 dwarf2_debug_line_missing_end_sequence_complaint (void)
1737 complaint (_(".debug_line section has line "
1738 "program sequence without an end"));
1742 dwarf2_complex_location_expr_complaint (void)
1744 complaint (_("location expression too complex"));
1748 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1751 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
1756 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1758 complaint (_("invalid attribute class or form for '%s' in '%s'"),
1762 /* Hash function for line_header_hash. */
1765 line_header_hash (const struct line_header
*ofs
)
1767 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
1770 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1773 line_header_hash_voidp (const void *item
)
1775 const struct line_header
*ofs
= (const struct line_header
*) item
;
1777 return line_header_hash (ofs
);
1780 /* Equality function for line_header_hash. */
1783 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
1785 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
1786 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
1788 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
1789 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
1794 /* See declaration. */
1796 dwarf2_per_bfd::dwarf2_per_bfd (bfd
*obfd
, const dwarf2_debug_sections
*names
,
1799 can_copy (can_copy_
)
1802 names
= &dwarf2_elf_names
;
1804 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
1805 locate_sections (obfd
, sec
, *names
);
1808 dwarf2_per_bfd::~dwarf2_per_bfd ()
1810 for (dwarf2_per_cu_data
*per_cu
: all_comp_units
)
1811 per_cu
->imported_symtabs_free ();
1813 for (signatured_type
*sig_type
: all_type_units
)
1814 sig_type
->per_cu
.imported_symtabs_free ();
1816 /* Everything else should be on this->obstack. */
1822 dwarf2_per_objfile::remove_all_cus ()
1824 for (auto pair
: m_dwarf2_cus
)
1827 m_dwarf2_cus
.clear ();
1830 /* A helper class that calls free_cached_comp_units on
1833 class free_cached_comp_units
1837 explicit free_cached_comp_units (dwarf2_per_objfile
*per_objfile
)
1838 : m_per_objfile (per_objfile
)
1842 ~free_cached_comp_units ()
1844 m_per_objfile
->remove_all_cus ();
1847 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units
);
1851 dwarf2_per_objfile
*m_per_objfile
;
1857 dwarf2_per_objfile::symtab_set_p (const dwarf2_per_cu_data
*per_cu
) const
1859 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1861 return this->m_symtabs
[per_cu
->index
] != nullptr;
1867 dwarf2_per_objfile::get_symtab (const dwarf2_per_cu_data
*per_cu
) const
1869 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1871 return this->m_symtabs
[per_cu
->index
];
1877 dwarf2_per_objfile::set_symtab (const dwarf2_per_cu_data
*per_cu
,
1878 compunit_symtab
*symtab
)
1880 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1881 gdb_assert (this->m_symtabs
[per_cu
->index
] == nullptr);
1883 this->m_symtabs
[per_cu
->index
] = symtab
;
1886 /* Try to locate the sections we need for DWARF 2 debugging
1887 information and return true if we have enough to do something.
1888 NAMES points to the dwarf2 section names, or is NULL if the standard
1889 ELF names are used. CAN_COPY is true for formats where symbol
1890 interposition is possible and so symbol values must follow copy
1891 relocation rules. */
1894 dwarf2_has_info (struct objfile
*objfile
,
1895 const struct dwarf2_debug_sections
*names
,
1898 if (objfile
->flags
& OBJF_READNEVER
)
1901 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
1903 if (per_objfile
== NULL
)
1905 dwarf2_per_bfd
*per_bfd
;
1907 /* We can share a "dwarf2_per_bfd" with other objfiles if the BFD
1908 doesn't require relocations and if there aren't partial symbols
1909 from some other reader. */
1910 if (!objfile_has_partial_symbols (objfile
)
1911 && !gdb_bfd_requires_relocations (objfile
->obfd
))
1913 /* See if one has been created for this BFD yet. */
1914 per_bfd
= dwarf2_per_bfd_bfd_data_key
.get (objfile
->obfd
);
1916 if (per_bfd
== nullptr)
1918 /* No, create it now. */
1919 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1920 dwarf2_per_bfd_bfd_data_key
.set (objfile
->obfd
, per_bfd
);
1925 /* No sharing possible, create one specifically for this objfile. */
1926 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1927 dwarf2_per_bfd_objfile_data_key
.set (objfile
, per_bfd
);
1930 per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
, per_bfd
);
1933 return (!per_objfile
->per_bfd
->info
.is_virtual
1934 && per_objfile
->per_bfd
->info
.s
.section
!= NULL
1935 && !per_objfile
->per_bfd
->abbrev
.is_virtual
1936 && per_objfile
->per_bfd
->abbrev
.s
.section
!= NULL
);
1939 /* When loading sections, we look either for uncompressed section or for
1940 compressed section names. */
1943 section_is_p (const char *section_name
,
1944 const struct dwarf2_section_names
*names
)
1946 if (names
->normal
!= NULL
1947 && strcmp (section_name
, names
->normal
) == 0)
1949 if (names
->compressed
!= NULL
1950 && strcmp (section_name
, names
->compressed
) == 0)
1955 /* See declaration. */
1958 dwarf2_per_bfd::locate_sections (bfd
*abfd
, asection
*sectp
,
1959 const dwarf2_debug_sections
&names
)
1961 flagword aflag
= bfd_section_flags (sectp
);
1963 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
1966 else if (elf_section_data (sectp
)->this_hdr
.sh_size
1967 > bfd_get_file_size (abfd
))
1969 bfd_size_type size
= elf_section_data (sectp
)->this_hdr
.sh_size
;
1970 warning (_("Discarding section %s which has a section size (%s"
1971 ") larger than the file size [in module %s]"),
1972 bfd_section_name (sectp
), phex_nz (size
, sizeof (size
)),
1973 bfd_get_filename (abfd
));
1975 else if (section_is_p (sectp
->name
, &names
.info
))
1977 this->info
.s
.section
= sectp
;
1978 this->info
.size
= bfd_section_size (sectp
);
1980 else if (section_is_p (sectp
->name
, &names
.abbrev
))
1982 this->abbrev
.s
.section
= sectp
;
1983 this->abbrev
.size
= bfd_section_size (sectp
);
1985 else if (section_is_p (sectp
->name
, &names
.line
))
1987 this->line
.s
.section
= sectp
;
1988 this->line
.size
= bfd_section_size (sectp
);
1990 else if (section_is_p (sectp
->name
, &names
.loc
))
1992 this->loc
.s
.section
= sectp
;
1993 this->loc
.size
= bfd_section_size (sectp
);
1995 else if (section_is_p (sectp
->name
, &names
.loclists
))
1997 this->loclists
.s
.section
= sectp
;
1998 this->loclists
.size
= bfd_section_size (sectp
);
2000 else if (section_is_p (sectp
->name
, &names
.macinfo
))
2002 this->macinfo
.s
.section
= sectp
;
2003 this->macinfo
.size
= bfd_section_size (sectp
);
2005 else if (section_is_p (sectp
->name
, &names
.macro
))
2007 this->macro
.s
.section
= sectp
;
2008 this->macro
.size
= bfd_section_size (sectp
);
2010 else if (section_is_p (sectp
->name
, &names
.str
))
2012 this->str
.s
.section
= sectp
;
2013 this->str
.size
= bfd_section_size (sectp
);
2015 else if (section_is_p (sectp
->name
, &names
.str_offsets
))
2017 this->str_offsets
.s
.section
= sectp
;
2018 this->str_offsets
.size
= bfd_section_size (sectp
);
2020 else if (section_is_p (sectp
->name
, &names
.line_str
))
2022 this->line_str
.s
.section
= sectp
;
2023 this->line_str
.size
= bfd_section_size (sectp
);
2025 else if (section_is_p (sectp
->name
, &names
.addr
))
2027 this->addr
.s
.section
= sectp
;
2028 this->addr
.size
= bfd_section_size (sectp
);
2030 else if (section_is_p (sectp
->name
, &names
.frame
))
2032 this->frame
.s
.section
= sectp
;
2033 this->frame
.size
= bfd_section_size (sectp
);
2035 else if (section_is_p (sectp
->name
, &names
.eh_frame
))
2037 this->eh_frame
.s
.section
= sectp
;
2038 this->eh_frame
.size
= bfd_section_size (sectp
);
2040 else if (section_is_p (sectp
->name
, &names
.ranges
))
2042 this->ranges
.s
.section
= sectp
;
2043 this->ranges
.size
= bfd_section_size (sectp
);
2045 else if (section_is_p (sectp
->name
, &names
.rnglists
))
2047 this->rnglists
.s
.section
= sectp
;
2048 this->rnglists
.size
= bfd_section_size (sectp
);
2050 else if (section_is_p (sectp
->name
, &names
.types
))
2052 struct dwarf2_section_info type_section
;
2054 memset (&type_section
, 0, sizeof (type_section
));
2055 type_section
.s
.section
= sectp
;
2056 type_section
.size
= bfd_section_size (sectp
);
2058 this->types
.push_back (type_section
);
2060 else if (section_is_p (sectp
->name
, &names
.gdb_index
))
2062 this->gdb_index
.s
.section
= sectp
;
2063 this->gdb_index
.size
= bfd_section_size (sectp
);
2065 else if (section_is_p (sectp
->name
, &names
.debug_names
))
2067 this->debug_names
.s
.section
= sectp
;
2068 this->debug_names
.size
= bfd_section_size (sectp
);
2070 else if (section_is_p (sectp
->name
, &names
.debug_aranges
))
2072 this->debug_aranges
.s
.section
= sectp
;
2073 this->debug_aranges
.size
= bfd_section_size (sectp
);
2076 if ((bfd_section_flags (sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2077 && bfd_section_vma (sectp
) == 0)
2078 this->has_section_at_zero
= true;
2081 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2085 dwarf2_get_section_info (struct objfile
*objfile
,
2086 enum dwarf2_section_enum sect
,
2087 asection
**sectp
, const gdb_byte
**bufp
,
2088 bfd_size_type
*sizep
)
2090 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
2091 struct dwarf2_section_info
*info
;
2093 /* We may see an objfile without any DWARF, in which case we just
2095 if (per_objfile
== NULL
)
2104 case DWARF2_DEBUG_FRAME
:
2105 info
= &per_objfile
->per_bfd
->frame
;
2107 case DWARF2_EH_FRAME
:
2108 info
= &per_objfile
->per_bfd
->eh_frame
;
2111 gdb_assert_not_reached ("unexpected section");
2114 info
->read (objfile
);
2116 *sectp
= info
->get_bfd_section ();
2117 *bufp
= info
->buffer
;
2118 *sizep
= info
->size
;
2121 /* A helper function to find the sections for a .dwz file. */
2124 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, dwz_file
*dwz_file
)
2126 /* Note that we only support the standard ELF names, because .dwz
2127 is ELF-only (at the time of writing). */
2128 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2130 dwz_file
->abbrev
.s
.section
= sectp
;
2131 dwz_file
->abbrev
.size
= bfd_section_size (sectp
);
2133 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2135 dwz_file
->info
.s
.section
= sectp
;
2136 dwz_file
->info
.size
= bfd_section_size (sectp
);
2138 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2140 dwz_file
->str
.s
.section
= sectp
;
2141 dwz_file
->str
.size
= bfd_section_size (sectp
);
2143 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2145 dwz_file
->line
.s
.section
= sectp
;
2146 dwz_file
->line
.size
= bfd_section_size (sectp
);
2148 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2150 dwz_file
->macro
.s
.section
= sectp
;
2151 dwz_file
->macro
.size
= bfd_section_size (sectp
);
2153 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2155 dwz_file
->gdb_index
.s
.section
= sectp
;
2156 dwz_file
->gdb_index
.size
= bfd_section_size (sectp
);
2158 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.debug_names
))
2160 dwz_file
->debug_names
.s
.section
= sectp
;
2161 dwz_file
->debug_names
.size
= bfd_section_size (sectp
);
2165 /* See dwarf2read.h. */
2168 dwarf2_get_dwz_file (dwarf2_per_bfd
*per_bfd
)
2170 const char *filename
;
2171 bfd_size_type buildid_len_arg
;
2175 if (per_bfd
->dwz_file
!= NULL
)
2176 return per_bfd
->dwz_file
.get ();
2178 bfd_set_error (bfd_error_no_error
);
2179 gdb::unique_xmalloc_ptr
<char> data
2180 (bfd_get_alt_debug_link_info (per_bfd
->obfd
,
2181 &buildid_len_arg
, &buildid
));
2184 if (bfd_get_error () == bfd_error_no_error
)
2186 error (_("could not read '.gnu_debugaltlink' section: %s"),
2187 bfd_errmsg (bfd_get_error ()));
2190 gdb::unique_xmalloc_ptr
<bfd_byte
> buildid_holder (buildid
);
2192 buildid_len
= (size_t) buildid_len_arg
;
2194 filename
= data
.get ();
2196 std::string abs_storage
;
2197 if (!IS_ABSOLUTE_PATH (filename
))
2199 gdb::unique_xmalloc_ptr
<char> abs
2200 = gdb_realpath (bfd_get_filename (per_bfd
->obfd
));
2202 abs_storage
= ldirname (abs
.get ()) + SLASH_STRING
+ filename
;
2203 filename
= abs_storage
.c_str ();
2206 /* First try the file name given in the section. If that doesn't
2207 work, try to use the build-id instead. */
2208 gdb_bfd_ref_ptr
dwz_bfd (gdb_bfd_open (filename
, gnutarget
));
2209 if (dwz_bfd
!= NULL
)
2211 if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2212 dwz_bfd
.reset (nullptr);
2215 if (dwz_bfd
== NULL
)
2216 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2218 if (dwz_bfd
== nullptr)
2220 gdb::unique_xmalloc_ptr
<char> alt_filename
;
2221 const char *origname
= bfd_get_filename (per_bfd
->obfd
);
2223 scoped_fd
fd (debuginfod_debuginfo_query (buildid
,
2230 /* File successfully retrieved from server. */
2231 dwz_bfd
= gdb_bfd_open (alt_filename
.get (), gnutarget
);
2233 if (dwz_bfd
== nullptr)
2234 warning (_("File \"%s\" from debuginfod cannot be opened as bfd"),
2235 alt_filename
.get ());
2236 else if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2237 dwz_bfd
.reset (nullptr);
2241 if (dwz_bfd
== NULL
)
2242 error (_("could not find '.gnu_debugaltlink' file for %s"),
2243 bfd_get_filename (per_bfd
->obfd
));
2245 std::unique_ptr
<struct dwz_file
> result
2246 (new struct dwz_file (std::move (dwz_bfd
)));
2248 for (asection
*sec
: gdb_bfd_sections (result
->dwz_bfd
))
2249 locate_dwz_sections (result
->dwz_bfd
.get (), sec
, result
.get ());
2251 gdb_bfd_record_inclusion (per_bfd
->obfd
, result
->dwz_bfd
.get ());
2252 per_bfd
->dwz_file
= std::move (result
);
2253 return per_bfd
->dwz_file
.get ();
2256 /* DWARF quick_symbols_functions support. */
2258 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2259 unique line tables, so we maintain a separate table of all .debug_line
2260 derived entries to support the sharing.
2261 All the quick functions need is the list of file names. We discard the
2262 line_header when we're done and don't need to record it here. */
2263 struct quick_file_names
2265 /* The data used to construct the hash key. */
2266 struct stmt_list_hash hash
;
2268 /* The number of entries in file_names, real_names. */
2269 unsigned int num_file_names
;
2271 /* The file names from the line table, after being run through
2273 const char **file_names
;
2275 /* The file names from the line table after being run through
2276 gdb_realpath. These are computed lazily. */
2277 const char **real_names
;
2280 /* When using the index (and thus not using psymtabs), each CU has an
2281 object of this type. This is used to hold information needed by
2282 the various "quick" methods. */
2283 struct dwarf2_per_cu_quick_data
2285 /* The file table. This can be NULL if there was no file table
2286 or it's currently not read in.
2287 NOTE: This points into dwarf2_per_objfile->per_bfd->quick_file_names_table. */
2288 struct quick_file_names
*file_names
;
2290 /* A temporary mark bit used when iterating over all CUs in
2291 expand_symtabs_matching. */
2292 unsigned int mark
: 1;
2294 /* True if we've tried to read the file table and found there isn't one.
2295 There will be no point in trying to read it again next time. */
2296 unsigned int no_file_data
: 1;
2299 /* Utility hash function for a stmt_list_hash. */
2302 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2306 if (stmt_list_hash
->dwo_unit
!= NULL
)
2307 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2308 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2312 /* Utility equality function for a stmt_list_hash. */
2315 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2316 const struct stmt_list_hash
*rhs
)
2318 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2320 if (lhs
->dwo_unit
!= NULL
2321 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2324 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2327 /* Hash function for a quick_file_names. */
2330 hash_file_name_entry (const void *e
)
2332 const struct quick_file_names
*file_data
2333 = (const struct quick_file_names
*) e
;
2335 return hash_stmt_list_entry (&file_data
->hash
);
2338 /* Equality function for a quick_file_names. */
2341 eq_file_name_entry (const void *a
, const void *b
)
2343 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2344 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2346 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2349 /* Delete function for a quick_file_names. */
2352 delete_file_name_entry (void *e
)
2354 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2357 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2359 xfree ((void*) file_data
->file_names
[i
]);
2360 if (file_data
->real_names
)
2361 xfree ((void*) file_data
->real_names
[i
]);
2364 /* The space for the struct itself lives on the obstack, so we don't
2368 /* Create a quick_file_names hash table. */
2371 create_quick_file_names_table (unsigned int nr_initial_entries
)
2373 return htab_up (htab_create_alloc (nr_initial_entries
,
2374 hash_file_name_entry
, eq_file_name_entry
,
2375 delete_file_name_entry
, xcalloc
, xfree
));
2378 /* Read in CU (dwarf2_cu object) for PER_CU in the context of PER_OBJFILE. This
2379 function is unrelated to symtabs, symtab would have to be created afterwards.
2380 You should call age_cached_comp_units after processing the CU. */
2383 load_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
2386 if (per_cu
->is_debug_types
)
2387 load_full_type_unit (per_cu
, per_objfile
);
2389 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
2390 skip_partial
, language_minimal
);
2392 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
2394 return nullptr; /* Dummy CU. */
2396 dwarf2_find_base_address (cu
->dies
, cu
);
2401 /* Read in the symbols for PER_CU in the context of DWARF"_PER_OBJFILE. */
2404 dw2_do_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2405 dwarf2_per_objfile
*per_objfile
, bool skip_partial
)
2407 /* Skip type_unit_groups, reading the type units they contain
2408 is handled elsewhere. */
2409 if (per_cu
->type_unit_group_p ())
2412 /* The destructor of dwarf2_queue_guard frees any entries left on
2413 the queue. After this point we're guaranteed to leave this function
2414 with the dwarf queue empty. */
2415 dwarf2_queue_guard
q_guard (dwarf2_per_objfile
);
2417 if (!per_objfile
->symtab_set_p (per_cu
))
2419 queue_comp_unit (per_cu
, per_objfile
, language_minimal
);
2420 dwarf2_cu
*cu
= load_cu (per_cu
, per_objfile
, skip_partial
);
2422 /* If we just loaded a CU from a DWO, and we're working with an index
2423 that may badly handle TUs, load all the TUs in that DWO as well.
2424 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2425 if (!per_cu
->is_debug_types
2427 && cu
->dwo_unit
!= NULL
2428 && per_objfile
->per_bfd
->index_table
!= NULL
2429 && per_objfile
->per_bfd
->index_table
->version
<= 7
2430 /* DWP files aren't supported yet. */
2431 && get_dwp_file (per_objfile
) == NULL
)
2432 queue_and_load_all_dwo_tus (cu
);
2435 process_queue (per_objfile
);
2437 /* Age the cache, releasing compilation units that have not
2438 been used recently. */
2439 per_objfile
->age_comp_units ();
2442 /* Ensure that the symbols for PER_CU have been read in. DWARF2_PER_OBJFILE is
2443 the per-objfile for which this symtab is instantiated.
2445 Returns the resulting symbol table. */
2447 static struct compunit_symtab
*
2448 dw2_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2449 dwarf2_per_objfile
*per_objfile
,
2452 gdb_assert (per_objfile
->per_bfd
->using_index
);
2454 if (!per_objfile
->symtab_set_p (per_cu
))
2456 free_cached_comp_units
freer (per_objfile
);
2457 scoped_restore decrementer
= increment_reading_symtab ();
2458 dw2_do_instantiate_symtab (per_cu
, per_objfile
, skip_partial
);
2459 process_cu_includes (per_objfile
);
2462 return per_objfile
->get_symtab (per_cu
);
2465 /* See declaration. */
2467 dwarf2_per_cu_data
*
2468 dwarf2_per_bfd::get_cutu (int index
)
2470 if (index
>= this->all_comp_units
.size ())
2472 index
-= this->all_comp_units
.size ();
2473 gdb_assert (index
< this->all_type_units
.size ());
2474 return &this->all_type_units
[index
]->per_cu
;
2477 return this->all_comp_units
[index
];
2480 /* See declaration. */
2482 dwarf2_per_cu_data
*
2483 dwarf2_per_bfd::get_cu (int index
)
2485 gdb_assert (index
>= 0 && index
< this->all_comp_units
.size ());
2487 return this->all_comp_units
[index
];
2490 /* See declaration. */
2493 dwarf2_per_bfd::get_tu (int index
)
2495 gdb_assert (index
>= 0 && index
< this->all_type_units
.size ());
2497 return this->all_type_units
[index
];
2502 dwarf2_per_cu_data
*
2503 dwarf2_per_bfd::allocate_per_cu ()
2505 dwarf2_per_cu_data
*result
= OBSTACK_ZALLOC (&obstack
, dwarf2_per_cu_data
);
2506 result
->per_bfd
= this;
2507 result
->index
= m_num_psymtabs
++;
2514 dwarf2_per_bfd::allocate_signatured_type ()
2516 signatured_type
*result
= OBSTACK_ZALLOC (&obstack
, signatured_type
);
2517 result
->per_cu
.per_bfd
= this;
2518 result
->per_cu
.index
= m_num_psymtabs
++;
2522 /* Return a new dwarf2_per_cu_data allocated on the per-bfd
2523 obstack, and constructed with the specified field values. */
2525 static dwarf2_per_cu_data
*
2526 create_cu_from_index_list (dwarf2_per_bfd
*per_bfd
,
2527 struct dwarf2_section_info
*section
,
2529 sect_offset sect_off
, ULONGEST length
)
2531 dwarf2_per_cu_data
*the_cu
= per_bfd
->allocate_per_cu ();
2532 the_cu
->sect_off
= sect_off
;
2533 the_cu
->length
= length
;
2534 the_cu
->section
= section
;
2535 the_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
2536 struct dwarf2_per_cu_quick_data
);
2537 the_cu
->is_dwz
= is_dwz
;
2541 /* A helper for create_cus_from_index that handles a given list of
2545 create_cus_from_index_list (dwarf2_per_bfd
*per_bfd
,
2546 const gdb_byte
*cu_list
, offset_type n_elements
,
2547 struct dwarf2_section_info
*section
,
2550 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
2552 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2554 sect_offset sect_off
2555 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2556 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2559 dwarf2_per_cu_data
*per_cu
2560 = create_cu_from_index_list (per_bfd
, section
, is_dwz
, sect_off
,
2562 per_bfd
->all_comp_units
.push_back (per_cu
);
2566 /* Read the CU list from the mapped index, and use it to create all
2567 the CU objects for PER_BFD. */
2570 create_cus_from_index (dwarf2_per_bfd
*per_bfd
,
2571 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2572 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2574 gdb_assert (per_bfd
->all_comp_units
.empty ());
2575 per_bfd
->all_comp_units
.reserve ((cu_list_elements
+ dwz_elements
) / 2);
2577 create_cus_from_index_list (per_bfd
, cu_list
, cu_list_elements
,
2580 if (dwz_elements
== 0)
2583 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
2584 create_cus_from_index_list (per_bfd
, dwz_list
, dwz_elements
,
2588 /* Create the signatured type hash table from the index. */
2591 create_signatured_type_table_from_index
2592 (dwarf2_per_bfd
*per_bfd
, struct dwarf2_section_info
*section
,
2593 const gdb_byte
*bytes
, offset_type elements
)
2595 gdb_assert (per_bfd
->all_type_units
.empty ());
2596 per_bfd
->all_type_units
.reserve (elements
/ 3);
2598 htab_up sig_types_hash
= allocate_signatured_type_table ();
2600 for (offset_type i
= 0; i
< elements
; i
+= 3)
2602 struct signatured_type
*sig_type
;
2605 cu_offset type_offset_in_tu
;
2607 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2608 sect_offset sect_off
2609 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2611 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
2613 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2616 sig_type
= per_bfd
->allocate_signatured_type ();
2617 sig_type
->signature
= signature
;
2618 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
2619 sig_type
->per_cu
.is_debug_types
= 1;
2620 sig_type
->per_cu
.section
= section
;
2621 sig_type
->per_cu
.sect_off
= sect_off
;
2622 sig_type
->per_cu
.v
.quick
2623 = OBSTACK_ZALLOC (&per_bfd
->obstack
,
2624 struct dwarf2_per_cu_quick_data
);
2626 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2629 per_bfd
->all_type_units
.push_back (sig_type
);
2632 per_bfd
->signatured_types
= std::move (sig_types_hash
);
2635 /* Create the signatured type hash table from .debug_names. */
2638 create_signatured_type_table_from_debug_names
2639 (dwarf2_per_objfile
*per_objfile
,
2640 const mapped_debug_names
&map
,
2641 struct dwarf2_section_info
*section
,
2642 struct dwarf2_section_info
*abbrev_section
)
2644 struct objfile
*objfile
= per_objfile
->objfile
;
2646 section
->read (objfile
);
2647 abbrev_section
->read (objfile
);
2649 gdb_assert (per_objfile
->per_bfd
->all_type_units
.empty ());
2650 per_objfile
->per_bfd
->all_type_units
.reserve (map
.tu_count
);
2652 htab_up sig_types_hash
= allocate_signatured_type_table ();
2654 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
2656 struct signatured_type
*sig_type
;
2659 sect_offset sect_off
2660 = (sect_offset
) (extract_unsigned_integer
2661 (map
.tu_table_reordered
+ i
* map
.offset_size
,
2663 map
.dwarf5_byte_order
));
2665 comp_unit_head cu_header
;
2666 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
2668 section
->buffer
+ to_underlying (sect_off
),
2671 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
2672 sig_type
->signature
= cu_header
.signature
;
2673 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
2674 sig_type
->per_cu
.is_debug_types
= 1;
2675 sig_type
->per_cu
.section
= section
;
2676 sig_type
->per_cu
.sect_off
= sect_off
;
2677 sig_type
->per_cu
.v
.quick
2678 = OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
2679 struct dwarf2_per_cu_quick_data
);
2681 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2684 per_objfile
->per_bfd
->all_type_units
.push_back (sig_type
);
2687 per_objfile
->per_bfd
->signatured_types
= std::move (sig_types_hash
);
2690 /* Read the address map data from the mapped index, and use it to
2691 populate the objfile's psymtabs_addrmap. */
2694 create_addrmap_from_index (dwarf2_per_objfile
*per_objfile
,
2695 struct mapped_index
*index
)
2697 struct objfile
*objfile
= per_objfile
->objfile
;
2698 struct gdbarch
*gdbarch
= objfile
->arch ();
2699 const gdb_byte
*iter
, *end
;
2700 struct addrmap
*mutable_map
;
2703 auto_obstack temp_obstack
;
2705 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2707 iter
= index
->address_table
.data ();
2708 end
= iter
+ index
->address_table
.size ();
2710 baseaddr
= objfile
->text_section_offset ();
2714 ULONGEST hi
, lo
, cu_index
;
2715 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2717 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2719 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2724 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
2725 hex_string (lo
), hex_string (hi
));
2729 if (cu_index
>= per_objfile
->per_bfd
->all_comp_units
.size ())
2731 complaint (_(".gdb_index address table has invalid CU number %u"),
2732 (unsigned) cu_index
);
2736 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
2737 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
2738 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
2739 per_objfile
->per_bfd
->get_cu (cu_index
));
2742 objfile
->partial_symtabs
->psymtabs_addrmap
2743 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
2746 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
2747 populate the objfile's psymtabs_addrmap. */
2750 create_addrmap_from_aranges (dwarf2_per_objfile
*per_objfile
,
2751 struct dwarf2_section_info
*section
)
2753 struct objfile
*objfile
= per_objfile
->objfile
;
2754 bfd
*abfd
= objfile
->obfd
;
2755 struct gdbarch
*gdbarch
= objfile
->arch ();
2756 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
2758 auto_obstack temp_obstack
;
2759 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
2761 std::unordered_map
<sect_offset
,
2762 dwarf2_per_cu_data
*,
2763 gdb::hash_enum
<sect_offset
>>
2764 debug_info_offset_to_per_cu
;
2765 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
2767 const auto insertpair
2768 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
, per_cu
);
2769 if (!insertpair
.second
)
2771 warning (_("Section .debug_aranges in %s has duplicate "
2772 "debug_info_offset %s, ignoring .debug_aranges."),
2773 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
2778 section
->read (objfile
);
2780 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
2782 const gdb_byte
*addr
= section
->buffer
;
2784 while (addr
< section
->buffer
+ section
->size
)
2786 const gdb_byte
*const entry_addr
= addr
;
2787 unsigned int bytes_read
;
2789 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
2793 const gdb_byte
*const entry_end
= addr
+ entry_length
;
2794 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
2795 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
2796 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
2798 warning (_("Section .debug_aranges in %s entry at offset %s "
2799 "length %s exceeds section length %s, "
2800 "ignoring .debug_aranges."),
2801 objfile_name (objfile
),
2802 plongest (entry_addr
- section
->buffer
),
2803 plongest (bytes_read
+ entry_length
),
2804 pulongest (section
->size
));
2808 /* The version number. */
2809 const uint16_t version
= read_2_bytes (abfd
, addr
);
2813 warning (_("Section .debug_aranges in %s entry at offset %s "
2814 "has unsupported version %d, ignoring .debug_aranges."),
2815 objfile_name (objfile
),
2816 plongest (entry_addr
- section
->buffer
), version
);
2820 const uint64_t debug_info_offset
2821 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
2822 addr
+= offset_size
;
2823 const auto per_cu_it
2824 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
2825 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
2827 warning (_("Section .debug_aranges in %s entry at offset %s "
2828 "debug_info_offset %s does not exists, "
2829 "ignoring .debug_aranges."),
2830 objfile_name (objfile
),
2831 plongest (entry_addr
- section
->buffer
),
2832 pulongest (debug_info_offset
));
2835 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
2837 const uint8_t address_size
= *addr
++;
2838 if (address_size
< 1 || address_size
> 8)
2840 warning (_("Section .debug_aranges in %s entry at offset %s "
2841 "address_size %u is invalid, ignoring .debug_aranges."),
2842 objfile_name (objfile
),
2843 plongest (entry_addr
- section
->buffer
), address_size
);
2847 const uint8_t segment_selector_size
= *addr
++;
2848 if (segment_selector_size
!= 0)
2850 warning (_("Section .debug_aranges in %s entry at offset %s "
2851 "segment_selector_size %u is not supported, "
2852 "ignoring .debug_aranges."),
2853 objfile_name (objfile
),
2854 plongest (entry_addr
- section
->buffer
),
2855 segment_selector_size
);
2859 /* Must pad to an alignment boundary that is twice the address
2860 size. It is undocumented by the DWARF standard but GCC does
2862 for (size_t padding
= ((-(addr
- section
->buffer
))
2863 & (2 * address_size
- 1));
2864 padding
> 0; padding
--)
2867 warning (_("Section .debug_aranges in %s entry at offset %s "
2868 "padding is not zero, ignoring .debug_aranges."),
2869 objfile_name (objfile
),
2870 plongest (entry_addr
- section
->buffer
));
2876 if (addr
+ 2 * address_size
> entry_end
)
2878 warning (_("Section .debug_aranges in %s entry at offset %s "
2879 "address list is not properly terminated, "
2880 "ignoring .debug_aranges."),
2881 objfile_name (objfile
),
2882 plongest (entry_addr
- section
->buffer
));
2885 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
2887 addr
+= address_size
;
2888 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
2890 addr
+= address_size
;
2891 if (start
== 0 && length
== 0)
2893 if (start
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
2895 /* Symbol was eliminated due to a COMDAT group. */
2898 ULONGEST end
= start
+ length
;
2899 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
2901 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
2903 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
2907 objfile
->partial_symtabs
->psymtabs_addrmap
2908 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
2911 /* Find a slot in the mapped index INDEX for the object named NAME.
2912 If NAME is found, set *VEC_OUT to point to the CU vector in the
2913 constant pool and return true. If NAME cannot be found, return
2917 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2918 offset_type
**vec_out
)
2921 offset_type slot
, step
;
2922 int (*cmp
) (const char *, const char *);
2924 gdb::unique_xmalloc_ptr
<char> without_params
;
2925 if (current_language
->la_language
== language_cplus
2926 || current_language
->la_language
== language_fortran
2927 || current_language
->la_language
== language_d
)
2929 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2932 if (strchr (name
, '(') != NULL
)
2934 without_params
= cp_remove_params (name
);
2936 if (without_params
!= NULL
)
2937 name
= without_params
.get ();
2941 /* Index version 4 did not support case insensitive searches. But the
2942 indices for case insensitive languages are built in lowercase, therefore
2943 simulate our NAME being searched is also lowercased. */
2944 hash
= mapped_index_string_hash ((index
->version
== 4
2945 && case_sensitivity
== case_sensitive_off
2946 ? 5 : index
->version
),
2949 slot
= hash
& (index
->symbol_table
.size () - 1);
2950 step
= ((hash
* 17) & (index
->symbol_table
.size () - 1)) | 1;
2951 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2957 const auto &bucket
= index
->symbol_table
[slot
];
2958 if (bucket
.name
== 0 && bucket
.vec
== 0)
2961 str
= index
->constant_pool
+ MAYBE_SWAP (bucket
.name
);
2962 if (!cmp (name
, str
))
2964 *vec_out
= (offset_type
*) (index
->constant_pool
2965 + MAYBE_SWAP (bucket
.vec
));
2969 slot
= (slot
+ step
) & (index
->symbol_table
.size () - 1);
2973 /* A helper function that reads the .gdb_index from BUFFER and fills
2974 in MAP. FILENAME is the name of the file containing the data;
2975 it is used for error reporting. DEPRECATED_OK is true if it is
2976 ok to use deprecated sections.
2978 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2979 out parameters that are filled in with information about the CU and
2980 TU lists in the section.
2982 Returns true if all went well, false otherwise. */
2985 read_gdb_index_from_buffer (const char *filename
,
2987 gdb::array_view
<const gdb_byte
> buffer
,
2988 struct mapped_index
*map
,
2989 const gdb_byte
**cu_list
,
2990 offset_type
*cu_list_elements
,
2991 const gdb_byte
**types_list
,
2992 offset_type
*types_list_elements
)
2994 const gdb_byte
*addr
= &buffer
[0];
2996 /* Version check. */
2997 offset_type version
= MAYBE_SWAP (*(offset_type
*) addr
);
2998 /* Versions earlier than 3 emitted every copy of a psymbol. This
2999 causes the index to behave very poorly for certain requests. Version 3
3000 contained incomplete addrmap. So, it seems better to just ignore such
3004 static int warning_printed
= 0;
3005 if (!warning_printed
)
3007 warning (_("Skipping obsolete .gdb_index section in %s."),
3009 warning_printed
= 1;
3013 /* Index version 4 uses a different hash function than index version
3016 Versions earlier than 6 did not emit psymbols for inlined
3017 functions. Using these files will cause GDB not to be able to
3018 set breakpoints on inlined functions by name, so we ignore these
3019 indices unless the user has done
3020 "set use-deprecated-index-sections on". */
3021 if (version
< 6 && !deprecated_ok
)
3023 static int warning_printed
= 0;
3024 if (!warning_printed
)
3027 Skipping deprecated .gdb_index section in %s.\n\
3028 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3029 to use the section anyway."),
3031 warning_printed
= 1;
3035 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3036 of the TU (for symbols coming from TUs),
3037 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3038 Plus gold-generated indices can have duplicate entries for global symbols,
3039 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3040 These are just performance bugs, and we can't distinguish gdb-generated
3041 indices from gold-generated ones, so issue no warning here. */
3043 /* Indexes with higher version than the one supported by GDB may be no
3044 longer backward compatible. */
3048 map
->version
= version
;
3050 offset_type
*metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3053 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3054 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3058 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3059 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3060 - MAYBE_SWAP (metadata
[i
]))
3064 const gdb_byte
*address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3065 const gdb_byte
*address_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3067 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
3070 const gdb_byte
*symbol_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3071 const gdb_byte
*symbol_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3073 = gdb::array_view
<mapped_index::symbol_table_slot
>
3074 ((mapped_index::symbol_table_slot
*) symbol_table
,
3075 (mapped_index::symbol_table_slot
*) symbol_table_end
);
3078 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3083 /* Callback types for dwarf2_read_gdb_index. */
3085 typedef gdb::function_view
3086 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_bfd
*)>
3087 get_gdb_index_contents_ftype
;
3088 typedef gdb::function_view
3089 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
3090 get_gdb_index_contents_dwz_ftype
;
3092 /* Read .gdb_index. If everything went ok, initialize the "quick"
3093 elements of all the CUs and return 1. Otherwise, return 0. */
3096 dwarf2_read_gdb_index
3097 (dwarf2_per_objfile
*per_objfile
,
3098 get_gdb_index_contents_ftype get_gdb_index_contents
,
3099 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
3101 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3102 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3103 struct dwz_file
*dwz
;
3104 struct objfile
*objfile
= per_objfile
->objfile
;
3105 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
3107 gdb::array_view
<const gdb_byte
> main_index_contents
3108 = get_gdb_index_contents (objfile
, per_bfd
);
3110 if (main_index_contents
.empty ())
3113 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
3114 if (!read_gdb_index_from_buffer (objfile_name (objfile
),
3115 use_deprecated_index_sections
,
3116 main_index_contents
, map
.get (), &cu_list
,
3117 &cu_list_elements
, &types_list
,
3118 &types_list_elements
))
3121 /* Don't use the index if it's empty. */
3122 if (map
->symbol_table
.empty ())
3125 /* If there is a .dwz file, read it so we can get its CU list as
3127 dwz
= dwarf2_get_dwz_file (per_bfd
);
3130 struct mapped_index dwz_map
;
3131 const gdb_byte
*dwz_types_ignore
;
3132 offset_type dwz_types_elements_ignore
;
3134 gdb::array_view
<const gdb_byte
> dwz_index_content
3135 = get_gdb_index_contents_dwz (objfile
, dwz
);
3137 if (dwz_index_content
.empty ())
3140 if (!read_gdb_index_from_buffer (bfd_get_filename (dwz
->dwz_bfd
.get ()),
3141 1, dwz_index_content
, &dwz_map
,
3142 &dwz_list
, &dwz_list_elements
,
3144 &dwz_types_elements_ignore
))
3146 warning (_("could not read '.gdb_index' section from %s; skipping"),
3147 bfd_get_filename (dwz
->dwz_bfd
.get ()));
3152 create_cus_from_index (per_bfd
, cu_list
, cu_list_elements
, dwz_list
,
3155 if (types_list_elements
)
3157 /* We can only handle a single .debug_types when we have an
3159 if (per_bfd
->types
.size () != 1)
3162 dwarf2_section_info
*section
= &per_bfd
->types
[0];
3164 create_signatured_type_table_from_index (per_bfd
, section
, types_list
,
3165 types_list_elements
);
3168 create_addrmap_from_index (per_objfile
, map
.get ());
3170 per_bfd
->index_table
= std::move (map
);
3171 per_bfd
->using_index
= 1;
3172 per_bfd
->quick_file_names_table
=
3173 create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
3175 /* Save partial symtabs in the per_bfd object, for the benefit of subsequent
3176 objfiles using the same BFD. */
3177 gdb_assert (per_bfd
->partial_symtabs
== nullptr);
3178 per_bfd
->partial_symtabs
= objfile
->partial_symtabs
;
3183 /* die_reader_func for dw2_get_file_names. */
3186 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3187 const gdb_byte
*info_ptr
,
3188 struct die_info
*comp_unit_die
)
3190 struct dwarf2_cu
*cu
= reader
->cu
;
3191 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3192 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
3193 struct dwarf2_per_cu_data
*lh_cu
;
3194 struct attribute
*attr
;
3196 struct quick_file_names
*qfn
;
3198 gdb_assert (! this_cu
->is_debug_types
);
3200 /* Our callers never want to match partial units -- instead they
3201 will match the enclosing full CU. */
3202 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3204 this_cu
->v
.quick
->no_file_data
= 1;
3212 sect_offset line_offset
{};
3214 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3215 if (attr
!= nullptr && attr
->form_is_unsigned ())
3217 struct quick_file_names find_entry
;
3219 line_offset
= (sect_offset
) attr
->as_unsigned ();
3221 /* We may have already read in this line header (TU line header sharing).
3222 If we have we're done. */
3223 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3224 find_entry
.hash
.line_sect_off
= line_offset
;
3225 slot
= htab_find_slot (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3226 &find_entry
, INSERT
);
3229 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3233 lh
= dwarf_decode_line_header (line_offset
, cu
);
3237 lh_cu
->v
.quick
->no_file_data
= 1;
3241 qfn
= XOBNEW (&per_objfile
->per_bfd
->obstack
, struct quick_file_names
);
3242 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3243 qfn
->hash
.line_sect_off
= line_offset
;
3244 gdb_assert (slot
!= NULL
);
3247 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3250 if (strcmp (fnd
.name
, "<unknown>") != 0)
3253 qfn
->num_file_names
= offset
+ lh
->file_names_size ();
3255 XOBNEWVEC (&per_objfile
->per_bfd
->obstack
, const char *,
3256 qfn
->num_file_names
);
3258 qfn
->file_names
[0] = xstrdup (fnd
.name
);
3259 for (int i
= 0; i
< lh
->file_names_size (); ++i
)
3260 qfn
->file_names
[i
+ offset
] = lh
->file_full_name (i
+ 1,
3261 fnd
.comp_dir
).release ();
3262 qfn
->real_names
= NULL
;
3264 lh_cu
->v
.quick
->file_names
= qfn
;
3267 /* A helper for the "quick" functions which attempts to read the line
3268 table for THIS_CU. */
3270 static struct quick_file_names
*
3271 dw2_get_file_names (dwarf2_per_cu_data
*this_cu
,
3272 dwarf2_per_objfile
*per_objfile
)
3274 /* This should never be called for TUs. */
3275 gdb_assert (! this_cu
->is_debug_types
);
3276 /* Nor type unit groups. */
3277 gdb_assert (! this_cu
->type_unit_group_p ());
3279 if (this_cu
->v
.quick
->file_names
!= NULL
)
3280 return this_cu
->v
.quick
->file_names
;
3281 /* If we know there is no line data, no point in looking again. */
3282 if (this_cu
->v
.quick
->no_file_data
)
3285 cutu_reader
reader (this_cu
, per_objfile
);
3286 if (!reader
.dummy_p
)
3287 dw2_get_file_names_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
);
3289 if (this_cu
->v
.quick
->no_file_data
)
3291 return this_cu
->v
.quick
->file_names
;
3294 /* A helper for the "quick" functions which computes and caches the
3295 real path for a given file name from the line table. */
3298 dw2_get_real_path (dwarf2_per_objfile
*per_objfile
,
3299 struct quick_file_names
*qfn
, int index
)
3301 if (qfn
->real_names
== NULL
)
3302 qfn
->real_names
= OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
3303 qfn
->num_file_names
, const char *);
3305 if (qfn
->real_names
[index
] == NULL
)
3306 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3308 return qfn
->real_names
[index
];
3311 static struct symtab
*
3312 dw2_find_last_source_symtab (struct objfile
*objfile
)
3314 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3315 dwarf2_per_cu_data
*dwarf_cu
= per_objfile
->per_bfd
->all_comp_units
.back ();
3316 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, per_objfile
, false);
3321 return compunit_primary_filetab (cust
);
3324 /* Traversal function for dw2_forget_cached_source_info. */
3327 dw2_free_cached_file_names (void **slot
, void *info
)
3329 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3331 if (file_data
->real_names
)
3335 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3337 xfree ((void*) file_data
->real_names
[i
]);
3338 file_data
->real_names
[i
] = NULL
;
3346 dw2_forget_cached_source_info (struct objfile
*objfile
)
3348 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3350 htab_traverse_noresize (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3351 dw2_free_cached_file_names
, NULL
);
3354 /* Helper function for dw2_map_symtabs_matching_filename that expands
3355 the symtabs and calls the iterator. */
3358 dw2_map_expand_apply (struct objfile
*objfile
,
3359 struct dwarf2_per_cu_data
*per_cu
,
3360 const char *name
, const char *real_path
,
3361 gdb::function_view
<bool (symtab
*)> callback
)
3363 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3365 /* Don't visit already-expanded CUs. */
3366 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3367 if (per_objfile
->symtab_set_p (per_cu
))
3370 /* This may expand more than one symtab, and we want to iterate over
3372 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3374 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
3375 last_made
, callback
);
3378 /* Implementation of the map_symtabs_matching_filename method. */
3381 dw2_map_symtabs_matching_filename
3382 (struct objfile
*objfile
, const char *name
, const char *real_path
,
3383 gdb::function_view
<bool (symtab
*)> callback
)
3385 const char *name_basename
= lbasename (name
);
3386 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3388 /* The rule is CUs specify all the files, including those used by
3389 any TU, so there's no need to scan TUs here. */
3391 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
3393 /* We only need to look at symtabs not already expanded. */
3394 if (per_objfile
->symtab_set_p (per_cu
))
3397 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
3398 if (file_data
== NULL
)
3401 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3403 const char *this_name
= file_data
->file_names
[j
];
3404 const char *this_real_name
;
3406 if (compare_filenames_for_search (this_name
, name
))
3408 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3414 /* Before we invoke realpath, which can get expensive when many
3415 files are involved, do a quick comparison of the basenames. */
3416 if (! basenames_may_differ
3417 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3420 this_real_name
= dw2_get_real_path (per_objfile
, file_data
, j
);
3421 if (compare_filenames_for_search (this_real_name
, name
))
3423 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3429 if (real_path
!= NULL
)
3431 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3432 gdb_assert (IS_ABSOLUTE_PATH (name
));
3433 if (this_real_name
!= NULL
3434 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3436 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3448 /* Struct used to manage iterating over all CUs looking for a symbol. */
3450 struct dw2_symtab_iterator
3452 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3453 dwarf2_per_objfile
*per_objfile
;
3454 /* If set, only look for symbols that match that block. Valid values are
3455 GLOBAL_BLOCK and STATIC_BLOCK. */
3456 gdb::optional
<block_enum
> block_index
;
3457 /* The kind of symbol we're looking for. */
3459 /* The list of CUs from the index entry of the symbol,
3460 or NULL if not found. */
3462 /* The next element in VEC to look at. */
3464 /* The number of elements in VEC, or zero if there is no match. */
3466 /* Have we seen a global version of the symbol?
3467 If so we can ignore all further global instances.
3468 This is to work around gold/15646, inefficient gold-generated
3473 /* Initialize the index symtab iterator ITER, common part. */
3476 dw2_symtab_iter_init_common (struct dw2_symtab_iterator
*iter
,
3477 dwarf2_per_objfile
*per_objfile
,
3478 gdb::optional
<block_enum
> block_index
,
3481 iter
->per_objfile
= per_objfile
;
3482 iter
->block_index
= block_index
;
3483 iter
->domain
= domain
;
3485 iter
->global_seen
= 0;
3490 /* Initialize the index symtab iterator ITER, const char *NAME variant. */
3493 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3494 dwarf2_per_objfile
*per_objfile
,
3495 gdb::optional
<block_enum
> block_index
,
3499 dw2_symtab_iter_init_common (iter
, per_objfile
, block_index
, domain
);
3501 mapped_index
*index
= per_objfile
->per_bfd
->index_table
.get ();
3502 /* index is NULL if OBJF_READNOW. */
3506 if (find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3507 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3510 /* Initialize the index symtab iterator ITER, offset_type NAMEI variant. */
3513 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3514 dwarf2_per_objfile
*per_objfile
,
3515 gdb::optional
<block_enum
> block_index
,
3516 domain_enum domain
, offset_type namei
)
3518 dw2_symtab_iter_init_common (iter
, per_objfile
, block_index
, domain
);
3520 mapped_index
*index
= per_objfile
->per_bfd
->index_table
.get ();
3521 /* index is NULL if OBJF_READNOW. */
3525 gdb_assert (!index
->symbol_name_slot_invalid (namei
));
3526 const auto &bucket
= index
->symbol_table
[namei
];
3528 iter
->vec
= (offset_type
*) (index
->constant_pool
3529 + MAYBE_SWAP (bucket
.vec
));
3530 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3533 /* Return the next matching CU or NULL if there are no more. */
3535 static struct dwarf2_per_cu_data
*
3536 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3538 dwarf2_per_objfile
*per_objfile
= iter
->per_objfile
;
3540 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3542 offset_type cu_index_and_attrs
=
3543 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3544 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3545 gdb_index_symbol_kind symbol_kind
=
3546 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3547 /* Only check the symbol attributes if they're present.
3548 Indices prior to version 7 don't record them,
3549 and indices >= 7 may elide them for certain symbols
3550 (gold does this). */
3552 (per_objfile
->per_bfd
->index_table
->version
>= 7
3553 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3555 /* Don't crash on bad data. */
3556 if (cu_index
>= (per_objfile
->per_bfd
->all_comp_units
.size ()
3557 + per_objfile
->per_bfd
->all_type_units
.size ()))
3559 complaint (_(".gdb_index entry has bad CU index"
3560 " [in module %s]"), objfile_name (per_objfile
->objfile
));
3564 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (cu_index
);
3566 /* Skip if already read in. */
3567 if (per_objfile
->symtab_set_p (per_cu
))
3570 /* Check static vs global. */
3573 bool is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3575 if (iter
->block_index
.has_value ())
3577 bool want_static
= *iter
->block_index
== STATIC_BLOCK
;
3579 if (is_static
!= want_static
)
3583 /* Work around gold/15646. */
3585 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
3587 if (iter
->global_seen
)
3590 iter
->global_seen
= 1;
3594 /* Only check the symbol's kind if it has one. */
3597 switch (iter
->domain
)
3600 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3601 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3602 /* Some types are also in VAR_DOMAIN. */
3603 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3607 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3611 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3615 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3630 static struct compunit_symtab
*
3631 dw2_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
3632 const char *name
, domain_enum domain
)
3634 struct compunit_symtab
*stab_best
= NULL
;
3635 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3637 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
3639 struct dw2_symtab_iterator iter
;
3640 struct dwarf2_per_cu_data
*per_cu
;
3642 dw2_symtab_iter_init (&iter
, per_objfile
, block_index
, domain
, name
);
3644 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3646 struct symbol
*sym
, *with_opaque
= NULL
;
3647 struct compunit_symtab
*stab
3648 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3649 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
3650 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3652 sym
= block_find_symbol (block
, name
, domain
,
3653 block_find_non_opaque_type_preferred
,
3656 /* Some caution must be observed with overloaded functions
3657 and methods, since the index will not contain any overload
3658 information (but NAME might contain it). */
3661 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
3663 if (with_opaque
!= NULL
3664 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
3667 /* Keep looking through other CUs. */
3674 dw2_print_stats (struct objfile
*objfile
)
3676 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3677 int total
= (per_objfile
->per_bfd
->all_comp_units
.size ()
3678 + per_objfile
->per_bfd
->all_type_units
.size ());
3681 for (int i
= 0; i
< total
; ++i
)
3683 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (i
);
3685 if (!per_objfile
->symtab_set_p (per_cu
))
3688 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3689 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3692 /* This dumps minimal information about the index.
3693 It is called via "mt print objfiles".
3694 One use is to verify .gdb_index has been loaded by the
3695 gdb.dwarf2/gdb-index.exp testcase. */
3698 dw2_dump (struct objfile
*objfile
)
3700 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3702 gdb_assert (per_objfile
->per_bfd
->using_index
);
3703 printf_filtered (".gdb_index:");
3704 if (per_objfile
->per_bfd
->index_table
!= NULL
)
3706 printf_filtered (" version %d\n",
3707 per_objfile
->per_bfd
->index_table
->version
);
3710 printf_filtered (" faked for \"readnow\"\n");
3711 printf_filtered ("\n");
3715 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
3716 const char *func_name
)
3718 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3720 struct dw2_symtab_iterator iter
;
3721 struct dwarf2_per_cu_data
*per_cu
;
3723 dw2_symtab_iter_init (&iter
, per_objfile
, {}, VAR_DOMAIN
, func_name
);
3725 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3726 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3731 dw2_expand_all_symtabs (struct objfile
*objfile
)
3733 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3734 int total_units
= (per_objfile
->per_bfd
->all_comp_units
.size ()
3735 + per_objfile
->per_bfd
->all_type_units
.size ());
3737 for (int i
= 0; i
< total_units
; ++i
)
3739 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (i
);
3741 /* We don't want to directly expand a partial CU, because if we
3742 read it with the wrong language, then assertion failures can
3743 be triggered later on. See PR symtab/23010. So, tell
3744 dw2_instantiate_symtab to skip partial CUs -- any important
3745 partial CU will be read via DW_TAG_imported_unit anyway. */
3746 dw2_instantiate_symtab (per_cu
, per_objfile
, true);
3751 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
3752 const char *fullname
)
3754 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3756 /* We don't need to consider type units here.
3757 This is only called for examining code, e.g. expand_line_sal.
3758 There can be an order of magnitude (or more) more type units
3759 than comp units, and we avoid them if we can. */
3761 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
3763 /* We only need to look at symtabs not already expanded. */
3764 if (per_objfile
->symtab_set_p (per_cu
))
3767 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
3768 if (file_data
== NULL
)
3771 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3773 const char *this_fullname
= file_data
->file_names
[j
];
3775 if (filename_cmp (this_fullname
, fullname
) == 0)
3777 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3785 dw2_expand_symtabs_matching_symbol
3786 (mapped_index_base
&index
,
3787 const lookup_name_info
&lookup_name_in
,
3788 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3789 enum search_domain kind
,
3790 gdb::function_view
<bool (offset_type
)> match_callback
,
3791 dwarf2_per_objfile
*per_objfile
);
3794 dw2_expand_symtabs_matching_one
3795 (dwarf2_per_cu_data
*per_cu
,
3796 dwarf2_per_objfile
*per_objfile
,
3797 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3798 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
);
3801 dw2_map_matching_symbols
3802 (struct objfile
*objfile
,
3803 const lookup_name_info
&name
, domain_enum domain
,
3805 gdb::function_view
<symbol_found_callback_ftype
> callback
,
3806 symbol_compare_ftype
*ordered_compare
)
3809 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3811 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
3813 if (per_objfile
->per_bfd
->index_table
!= nullptr)
3815 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
3817 const char *match_name
= name
.ada ().lookup_name ().c_str ();
3818 auto matcher
= [&] (const char *symname
)
3820 if (ordered_compare
== nullptr)
3822 return ordered_compare (symname
, match_name
) == 0;
3825 dw2_expand_symtabs_matching_symbol (index
, name
, matcher
, ALL_DOMAIN
,
3826 [&] (offset_type namei
)
3828 struct dw2_symtab_iterator iter
;
3829 struct dwarf2_per_cu_data
*per_cu
;
3831 dw2_symtab_iter_init (&iter
, per_objfile
, block_kind
, domain
,
3833 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3834 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
3841 /* We have -readnow: no .gdb_index, but no partial symtabs either. So,
3842 proceed assuming all symtabs have been read in. */
3845 for (compunit_symtab
*cust
: objfile
->compunits ())
3847 const struct block
*block
;
3851 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
3852 if (!iterate_over_symbols_terminated (block
, name
,
3858 /* Starting from a search name, return the string that finds the upper
3859 bound of all strings that start with SEARCH_NAME in a sorted name
3860 list. Returns the empty string to indicate that the upper bound is
3861 the end of the list. */
3864 make_sort_after_prefix_name (const char *search_name
)
3866 /* When looking to complete "func", we find the upper bound of all
3867 symbols that start with "func" by looking for where we'd insert
3868 the closest string that would follow "func" in lexicographical
3869 order. Usually, that's "func"-with-last-character-incremented,
3870 i.e. "fund". Mind non-ASCII characters, though. Usually those
3871 will be UTF-8 multi-byte sequences, but we can't be certain.
3872 Especially mind the 0xff character, which is a valid character in
3873 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
3874 rule out compilers allowing it in identifiers. Note that
3875 conveniently, strcmp/strcasecmp are specified to compare
3876 characters interpreted as unsigned char. So what we do is treat
3877 the whole string as a base 256 number composed of a sequence of
3878 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
3879 to 0, and carries 1 to the following more-significant position.
3880 If the very first character in SEARCH_NAME ends up incremented
3881 and carries/overflows, then the upper bound is the end of the
3882 list. The string after the empty string is also the empty
3885 Some examples of this operation:
3887 SEARCH_NAME => "+1" RESULT
3891 "\xff" "a" "\xff" => "\xff" "b"
3896 Then, with these symbols for example:
3902 completing "func" looks for symbols between "func" and
3903 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
3904 which finds "func" and "func1", but not "fund".
3908 funcÿ (Latin1 'ÿ' [0xff])
3912 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
3913 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
3917 ÿÿ (Latin1 'ÿ' [0xff])
3920 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
3921 the end of the list.
3923 std::string after
= search_name
;
3924 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
3926 if (!after
.empty ())
3927 after
.back () = (unsigned char) after
.back () + 1;
3931 /* See declaration. */
3933 std::pair
<std::vector
<name_component
>::const_iterator
,
3934 std::vector
<name_component
>::const_iterator
>
3935 mapped_index_base::find_name_components_bounds
3936 (const lookup_name_info
&lookup_name_without_params
, language lang
,
3937 dwarf2_per_objfile
*per_objfile
) const
3940 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
3942 const char *lang_name
3943 = lookup_name_without_params
.language_lookup_name (lang
);
3945 /* Comparison function object for lower_bound that matches against a
3946 given symbol name. */
3947 auto lookup_compare_lower
= [&] (const name_component
&elem
,
3950 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3951 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3952 return name_cmp (elem_name
, name
) < 0;
3955 /* Comparison function object for upper_bound that matches against a
3956 given symbol name. */
3957 auto lookup_compare_upper
= [&] (const char *name
,
3958 const name_component
&elem
)
3960 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3961 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3962 return name_cmp (name
, elem_name
) < 0;
3965 auto begin
= this->name_components
.begin ();
3966 auto end
= this->name_components
.end ();
3968 /* Find the lower bound. */
3971 if (lookup_name_without_params
.completion_mode () && lang_name
[0] == '\0')
3974 return std::lower_bound (begin
, end
, lang_name
, lookup_compare_lower
);
3977 /* Find the upper bound. */
3980 if (lookup_name_without_params
.completion_mode ())
3982 /* In completion mode, we want UPPER to point past all
3983 symbols names that have the same prefix. I.e., with
3984 these symbols, and completing "func":
3986 function << lower bound
3988 other_function << upper bound
3990 We find the upper bound by looking for the insertion
3991 point of "func"-with-last-character-incremented,
3993 std::string after
= make_sort_after_prefix_name (lang_name
);
3996 return std::lower_bound (lower
, end
, after
.c_str (),
3997 lookup_compare_lower
);
4000 return std::upper_bound (lower
, end
, lang_name
, lookup_compare_upper
);
4003 return {lower
, upper
};
4006 /* See declaration. */
4009 mapped_index_base::build_name_components (dwarf2_per_objfile
*per_objfile
)
4011 if (!this->name_components
.empty ())
4014 this->name_components_casing
= case_sensitivity
;
4016 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4018 /* The code below only knows how to break apart components of C++
4019 symbol names (and other languages that use '::' as
4020 namespace/module separator) and Ada symbol names. */
4021 auto count
= this->symbol_name_count ();
4022 for (offset_type idx
= 0; idx
< count
; idx
++)
4024 if (this->symbol_name_slot_invalid (idx
))
4027 const char *name
= this->symbol_name_at (idx
, per_objfile
);
4029 /* Add each name component to the name component table. */
4030 unsigned int previous_len
= 0;
4032 if (strstr (name
, "::") != nullptr)
4034 for (unsigned int current_len
= cp_find_first_component (name
);
4035 name
[current_len
] != '\0';
4036 current_len
+= cp_find_first_component (name
+ current_len
))
4038 gdb_assert (name
[current_len
] == ':');
4039 this->name_components
.push_back ({previous_len
, idx
});
4040 /* Skip the '::'. */
4042 previous_len
= current_len
;
4047 /* Handle the Ada encoded (aka mangled) form here. */
4048 for (const char *iter
= strstr (name
, "__");
4050 iter
= strstr (iter
, "__"))
4052 this->name_components
.push_back ({previous_len
, idx
});
4054 previous_len
= iter
- name
;
4058 this->name_components
.push_back ({previous_len
, idx
});
4061 /* Sort name_components elements by name. */
4062 auto name_comp_compare
= [&] (const name_component
&left
,
4063 const name_component
&right
)
4065 const char *left_qualified
4066 = this->symbol_name_at (left
.idx
, per_objfile
);
4067 const char *right_qualified
4068 = this->symbol_name_at (right
.idx
, per_objfile
);
4070 const char *left_name
= left_qualified
+ left
.name_offset
;
4071 const char *right_name
= right_qualified
+ right
.name_offset
;
4073 return name_cmp (left_name
, right_name
) < 0;
4076 std::sort (this->name_components
.begin (),
4077 this->name_components
.end (),
4081 /* Helper for dw2_expand_symtabs_matching that works with a
4082 mapped_index_base instead of the containing objfile. This is split
4083 to a separate function in order to be able to unit test the
4084 name_components matching using a mock mapped_index_base. For each
4085 symbol name that matches, calls MATCH_CALLBACK, passing it the
4086 symbol's index in the mapped_index_base symbol table. */
4089 dw2_expand_symtabs_matching_symbol
4090 (mapped_index_base
&index
,
4091 const lookup_name_info
&lookup_name_in
,
4092 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4093 enum search_domain kind
,
4094 gdb::function_view
<bool (offset_type
)> match_callback
,
4095 dwarf2_per_objfile
*per_objfile
)
4097 lookup_name_info lookup_name_without_params
4098 = lookup_name_in
.make_ignore_params ();
4100 /* Build the symbol name component sorted vector, if we haven't
4102 index
.build_name_components (per_objfile
);
4104 /* The same symbol may appear more than once in the range though.
4105 E.g., if we're looking for symbols that complete "w", and we have
4106 a symbol named "w1::w2", we'll find the two name components for
4107 that same symbol in the range. To be sure we only call the
4108 callback once per symbol, we first collect the symbol name
4109 indexes that matched in a temporary vector and ignore
4111 std::vector
<offset_type
> matches
;
4113 struct name_and_matcher
4115 symbol_name_matcher_ftype
*matcher
;
4118 bool operator== (const name_and_matcher
&other
) const
4120 return matcher
== other
.matcher
&& strcmp (name
, other
.name
) == 0;
4124 /* A vector holding all the different symbol name matchers, for all
4126 std::vector
<name_and_matcher
> matchers
;
4128 for (int i
= 0; i
< nr_languages
; i
++)
4130 enum language lang_e
= (enum language
) i
;
4132 const language_defn
*lang
= language_def (lang_e
);
4133 symbol_name_matcher_ftype
*name_matcher
4134 = lang
->get_symbol_name_matcher (lookup_name_without_params
);
4136 name_and_matcher key
{
4138 lookup_name_without_params
.language_lookup_name (lang_e
)
4141 /* Don't insert the same comparison routine more than once.
4142 Note that we do this linear walk. This is not a problem in
4143 practice because the number of supported languages is
4145 if (std::find (matchers
.begin (), matchers
.end (), key
)
4148 matchers
.push_back (std::move (key
));
4151 = index
.find_name_components_bounds (lookup_name_without_params
,
4152 lang_e
, per_objfile
);
4154 /* Now for each symbol name in range, check to see if we have a name
4155 match, and if so, call the MATCH_CALLBACK callback. */
4157 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
4159 const char *qualified
4160 = index
.symbol_name_at (bounds
.first
->idx
, per_objfile
);
4162 if (!name_matcher (qualified
, lookup_name_without_params
, NULL
)
4163 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
4166 matches
.push_back (bounds
.first
->idx
);
4170 std::sort (matches
.begin (), matches
.end ());
4172 /* Finally call the callback, once per match. */
4174 for (offset_type idx
: matches
)
4178 if (!match_callback (idx
))
4184 /* Above we use a type wider than idx's for 'prev', since 0 and
4185 (offset_type)-1 are both possible values. */
4186 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
4191 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
4193 /* A mock .gdb_index/.debug_names-like name index table, enough to
4194 exercise dw2_expand_symtabs_matching_symbol, which works with the
4195 mapped_index_base interface. Builds an index from the symbol list
4196 passed as parameter to the constructor. */
4197 class mock_mapped_index
: public mapped_index_base
4200 mock_mapped_index (gdb::array_view
<const char *> symbols
)
4201 : m_symbol_table (symbols
)
4204 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
4206 /* Return the number of names in the symbol table. */
4207 size_t symbol_name_count () const override
4209 return m_symbol_table
.size ();
4212 /* Get the name of the symbol at IDX in the symbol table. */
4213 const char *symbol_name_at
4214 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
4216 return m_symbol_table
[idx
];
4220 gdb::array_view
<const char *> m_symbol_table
;
4223 /* Convenience function that converts a NULL pointer to a "<null>"
4224 string, to pass to print routines. */
4227 string_or_null (const char *str
)
4229 return str
!= NULL
? str
: "<null>";
4232 /* Check if a lookup_name_info built from
4233 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4234 index. EXPECTED_LIST is the list of expected matches, in expected
4235 matching order. If no match expected, then an empty list is
4236 specified. Returns true on success. On failure prints a warning
4237 indicating the file:line that failed, and returns false. */
4240 check_match (const char *file
, int line
,
4241 mock_mapped_index
&mock_index
,
4242 const char *name
, symbol_name_match_type match_type
,
4243 bool completion_mode
,
4244 std::initializer_list
<const char *> expected_list
,
4245 dwarf2_per_objfile
*per_objfile
)
4247 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4249 bool matched
= true;
4251 auto mismatch
= [&] (const char *expected_str
,
4254 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4255 "expected=\"%s\", got=\"%s\"\n"),
4257 (match_type
== symbol_name_match_type::FULL
4259 name
, string_or_null (expected_str
), string_or_null (got
));
4263 auto expected_it
= expected_list
.begin ();
4264 auto expected_end
= expected_list
.end ();
4266 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
4268 [&] (offset_type idx
)
4270 const char *matched_name
= mock_index
.symbol_name_at (idx
, per_objfile
);
4271 const char *expected_str
4272 = expected_it
== expected_end
? NULL
: *expected_it
++;
4274 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4275 mismatch (expected_str
, matched_name
);
4279 const char *expected_str
4280 = expected_it
== expected_end
? NULL
: *expected_it
++;
4281 if (expected_str
!= NULL
)
4282 mismatch (expected_str
, NULL
);
4287 /* The symbols added to the mock mapped_index for testing (in
4289 static const char *test_symbols
[] = {
4298 "ns2::tmpl<int>::foo2",
4299 "(anonymous namespace)::A::B::C",
4301 /* These are used to check that the increment-last-char in the
4302 matching algorithm for completion doesn't match "t1_fund" when
4303 completing "t1_func". */
4309 /* A UTF-8 name with multi-byte sequences to make sure that
4310 cp-name-parser understands this as a single identifier ("função"
4311 is "function" in PT). */
4314 /* \377 (0xff) is Latin1 'ÿ'. */
4317 /* \377 (0xff) is Latin1 'ÿ'. */
4321 /* A name with all sorts of complications. Starts with "z" to make
4322 it easier for the completion tests below. */
4323 #define Z_SYM_NAME \
4324 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4325 "::tuple<(anonymous namespace)::ui*, " \
4326 "std::default_delete<(anonymous namespace)::ui>, void>"
4331 /* Returns true if the mapped_index_base::find_name_component_bounds
4332 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4333 in completion mode. */
4336 check_find_bounds_finds (mapped_index_base
&index
,
4337 const char *search_name
,
4338 gdb::array_view
<const char *> expected_syms
,
4339 dwarf2_per_objfile
*per_objfile
)
4341 lookup_name_info
lookup_name (search_name
,
4342 symbol_name_match_type::FULL
, true);
4344 auto bounds
= index
.find_name_components_bounds (lookup_name
,
4348 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
4349 if (distance
!= expected_syms
.size ())
4352 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
4354 auto nc_elem
= bounds
.first
+ exp_elem
;
4355 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
, per_objfile
);
4356 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
4363 /* Test the lower-level mapped_index::find_name_component_bounds
4367 test_mapped_index_find_name_component_bounds ()
4369 mock_mapped_index
mock_index (test_symbols
);
4371 mock_index
.build_name_components (NULL
/* per_objfile */);
4373 /* Test the lower-level mapped_index::find_name_component_bounds
4374 method in completion mode. */
4376 static const char *expected_syms
[] = {
4381 SELF_CHECK (check_find_bounds_finds
4382 (mock_index
, "t1_func", expected_syms
,
4383 NULL
/* per_objfile */));
4386 /* Check that the increment-last-char in the name matching algorithm
4387 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4389 static const char *expected_syms1
[] = {
4393 SELF_CHECK (check_find_bounds_finds
4394 (mock_index
, "\377", expected_syms1
, NULL
/* per_objfile */));
4396 static const char *expected_syms2
[] = {
4399 SELF_CHECK (check_find_bounds_finds
4400 (mock_index
, "\377\377", expected_syms2
,
4401 NULL
/* per_objfile */));
4405 /* Test dw2_expand_symtabs_matching_symbol. */
4408 test_dw2_expand_symtabs_matching_symbol ()
4410 mock_mapped_index
mock_index (test_symbols
);
4412 /* We let all tests run until the end even if some fails, for debug
4414 bool any_mismatch
= false;
4416 /* Create the expected symbols list (an initializer_list). Needed
4417 because lists have commas, and we need to pass them to CHECK,
4418 which is a macro. */
4419 #define EXPECT(...) { __VA_ARGS__ }
4421 /* Wrapper for check_match that passes down the current
4422 __FILE__/__LINE__. */
4423 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4424 any_mismatch |= !check_match (__FILE__, __LINE__, \
4426 NAME, MATCH_TYPE, COMPLETION_MODE, \
4427 EXPECTED_LIST, NULL)
4429 /* Identity checks. */
4430 for (const char *sym
: test_symbols
)
4432 /* Should be able to match all existing symbols. */
4433 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4436 /* Should be able to match all existing symbols with
4438 std::string with_params
= std::string (sym
) + "(int)";
4439 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4442 /* Should be able to match all existing symbols with
4443 parameters and qualifiers. */
4444 with_params
= std::string (sym
) + " ( int ) const";
4445 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4448 /* This should really find sym, but cp-name-parser.y doesn't
4449 know about lvalue/rvalue qualifiers yet. */
4450 with_params
= std::string (sym
) + " ( int ) &&";
4451 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4455 /* Check that the name matching algorithm for completion doesn't get
4456 confused with Latin1 'ÿ' / 0xff. */
4458 static const char str
[] = "\377";
4459 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4460 EXPECT ("\377", "\377\377123"));
4463 /* Check that the increment-last-char in the matching algorithm for
4464 completion doesn't match "t1_fund" when completing "t1_func". */
4466 static const char str
[] = "t1_func";
4467 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4468 EXPECT ("t1_func", "t1_func1"));
4471 /* Check that completion mode works at each prefix of the expected
4474 static const char str
[] = "function(int)";
4475 size_t len
= strlen (str
);
4478 for (size_t i
= 1; i
< len
; i
++)
4480 lookup
.assign (str
, i
);
4481 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4482 EXPECT ("function"));
4486 /* While "w" is a prefix of both components, the match function
4487 should still only be called once. */
4489 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4491 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4495 /* Same, with a "complicated" symbol. */
4497 static const char str
[] = Z_SYM_NAME
;
4498 size_t len
= strlen (str
);
4501 for (size_t i
= 1; i
< len
; i
++)
4503 lookup
.assign (str
, i
);
4504 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4505 EXPECT (Z_SYM_NAME
));
4509 /* In FULL mode, an incomplete symbol doesn't match. */
4511 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4515 /* A complete symbol with parameters matches any overload, since the
4516 index has no overload info. */
4518 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4519 EXPECT ("std::zfunction", "std::zfunction2"));
4520 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4521 EXPECT ("std::zfunction", "std::zfunction2"));
4522 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4523 EXPECT ("std::zfunction", "std::zfunction2"));
4526 /* Check that whitespace is ignored appropriately. A symbol with a
4527 template argument list. */
4529 static const char expected
[] = "ns::foo<int>";
4530 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4532 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4536 /* Check that whitespace is ignored appropriately. A symbol with a
4537 template argument list that includes a pointer. */
4539 static const char expected
[] = "ns::foo<char*>";
4540 /* Try both completion and non-completion modes. */
4541 static const bool completion_mode
[2] = {false, true};
4542 for (size_t i
= 0; i
< 2; i
++)
4544 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4545 completion_mode
[i
], EXPECT (expected
));
4546 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4547 completion_mode
[i
], EXPECT (expected
));
4549 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4550 completion_mode
[i
], EXPECT (expected
));
4551 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4552 completion_mode
[i
], EXPECT (expected
));
4557 /* Check method qualifiers are ignored. */
4558 static const char expected
[] = "ns::foo<char*>";
4559 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4560 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4561 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4562 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4563 CHECK_MATCH ("foo < char * > ( int ) const",
4564 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4565 CHECK_MATCH ("foo < char * > ( int ) &&",
4566 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4569 /* Test lookup names that don't match anything. */
4571 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4574 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4578 /* Some wild matching tests, exercising "(anonymous namespace)",
4579 which should not be confused with a parameter list. */
4581 static const char *syms
[] = {
4585 "A :: B :: C ( int )",
4590 for (const char *s
: syms
)
4592 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4593 EXPECT ("(anonymous namespace)::A::B::C"));
4598 static const char expected
[] = "ns2::tmpl<int>::foo2";
4599 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4601 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4605 SELF_CHECK (!any_mismatch
);
4614 test_mapped_index_find_name_component_bounds ();
4615 test_dw2_expand_symtabs_matching_symbol ();
4618 }} // namespace selftests::dw2_expand_symtabs_matching
4620 #endif /* GDB_SELF_TEST */
4622 /* If FILE_MATCHER is NULL or if PER_CU has
4623 dwarf2_per_cu_quick_data::MARK set (see
4624 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4625 EXPANSION_NOTIFY on it. */
4628 dw2_expand_symtabs_matching_one
4629 (dwarf2_per_cu_data
*per_cu
,
4630 dwarf2_per_objfile
*per_objfile
,
4631 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4632 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4634 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4636 bool symtab_was_null
= !per_objfile
->symtab_set_p (per_cu
);
4638 compunit_symtab
*symtab
4639 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
4640 gdb_assert (symtab
!= nullptr);
4642 if (expansion_notify
!= NULL
&& symtab_was_null
)
4643 expansion_notify (symtab
);
4647 /* Helper for dw2_expand_matching symtabs. Called on each symbol
4648 matched, to expand corresponding CUs that were marked. IDX is the
4649 index of the symbol name that matched. */
4652 dw2_expand_marked_cus
4653 (dwarf2_per_objfile
*per_objfile
, offset_type idx
,
4654 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4655 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4658 offset_type
*vec
, vec_len
, vec_idx
;
4659 bool global_seen
= false;
4660 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4662 vec
= (offset_type
*) (index
.constant_pool
4663 + MAYBE_SWAP (index
.symbol_table
[idx
].vec
));
4664 vec_len
= MAYBE_SWAP (vec
[0]);
4665 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
4667 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
4668 /* This value is only valid for index versions >= 7. */
4669 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4670 gdb_index_symbol_kind symbol_kind
=
4671 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
4672 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
4673 /* Only check the symbol attributes if they're present.
4674 Indices prior to version 7 don't record them,
4675 and indices >= 7 may elide them for certain symbols
4676 (gold does this). */
4679 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
4681 /* Work around gold/15646. */
4684 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
4692 /* Only check the symbol's kind if it has one. */
4697 case VARIABLES_DOMAIN
:
4698 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
4701 case FUNCTIONS_DOMAIN
:
4702 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4706 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4709 case MODULES_DOMAIN
:
4710 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4718 /* Don't crash on bad data. */
4719 if (cu_index
>= (per_objfile
->per_bfd
->all_comp_units
.size ()
4720 + per_objfile
->per_bfd
->all_type_units
.size ()))
4722 complaint (_(".gdb_index entry has bad CU index"
4723 " [in module %s]"), objfile_name (per_objfile
->objfile
));
4727 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (cu_index
);
4728 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
4733 /* If FILE_MATCHER is non-NULL, set all the
4734 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
4735 that match FILE_MATCHER. */
4738 dw_expand_symtabs_matching_file_matcher
4739 (dwarf2_per_objfile
*per_objfile
,
4740 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
4742 if (file_matcher
== NULL
)
4745 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
4747 NULL
, xcalloc
, xfree
));
4748 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
4750 NULL
, xcalloc
, xfree
));
4752 /* The rule is CUs specify all the files, including those used by
4753 any TU, so there's no need to scan TUs here. */
4755 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4759 per_cu
->v
.quick
->mark
= 0;
4761 /* We only need to look at symtabs not already expanded. */
4762 if (per_objfile
->symtab_set_p (per_cu
))
4765 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
4766 if (file_data
== NULL
)
4769 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
4771 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
4773 per_cu
->v
.quick
->mark
= 1;
4777 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4779 const char *this_real_name
;
4781 if (file_matcher (file_data
->file_names
[j
], false))
4783 per_cu
->v
.quick
->mark
= 1;
4787 /* Before we invoke realpath, which can get expensive when many
4788 files are involved, do a quick comparison of the basenames. */
4789 if (!basenames_may_differ
4790 && !file_matcher (lbasename (file_data
->file_names
[j
]),
4794 this_real_name
= dw2_get_real_path (per_objfile
, file_data
, j
);
4795 if (file_matcher (this_real_name
, false))
4797 per_cu
->v
.quick
->mark
= 1;
4802 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
4803 ? visited_found
.get ()
4804 : visited_not_found
.get (),
4811 dw2_expand_symtabs_matching
4812 (struct objfile
*objfile
,
4813 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4814 const lookup_name_info
*lookup_name
,
4815 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4816 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4817 enum search_domain kind
)
4819 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4821 /* index_table is NULL if OBJF_READNOW. */
4822 if (!per_objfile
->per_bfd
->index_table
)
4825 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
4827 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
4829 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4833 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
,
4834 file_matcher
, expansion_notify
);
4839 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4841 dw2_expand_symtabs_matching_symbol (index
, *lookup_name
,
4843 kind
, [&] (offset_type idx
)
4845 dw2_expand_marked_cus (per_objfile
, idx
, file_matcher
, expansion_notify
,
4851 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4854 static struct compunit_symtab
*
4855 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4860 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4861 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4864 if (cust
->includes
== NULL
)
4867 for (i
= 0; cust
->includes
[i
]; ++i
)
4869 struct compunit_symtab
*s
= cust
->includes
[i
];
4871 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
4879 static struct compunit_symtab
*
4880 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
4881 struct bound_minimal_symbol msymbol
,
4883 struct obj_section
*section
,
4886 struct dwarf2_per_cu_data
*data
;
4887 struct compunit_symtab
*result
;
4889 if (!objfile
->partial_symtabs
->psymtabs_addrmap
)
4892 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
4893 data
= (struct dwarf2_per_cu_data
*) addrmap_find
4894 (objfile
->partial_symtabs
->psymtabs_addrmap
, pc
- baseaddr
);
4898 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4899 if (warn_if_readin
&& per_objfile
->symtab_set_p (data
))
4900 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4901 paddress (objfile
->arch (), pc
));
4903 result
= recursively_find_pc_sect_compunit_symtab
4904 (dw2_instantiate_symtab (data
, per_objfile
, false), pc
);
4906 gdb_assert (result
!= NULL
);
4911 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
4912 void *data
, int need_fullname
)
4914 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4916 if (!per_objfile
->per_bfd
->filenames_cache
)
4918 per_objfile
->per_bfd
->filenames_cache
.emplace ();
4920 htab_up
visited (htab_create_alloc (10,
4921 htab_hash_pointer
, htab_eq_pointer
,
4922 NULL
, xcalloc
, xfree
));
4924 /* The rule is CUs specify all the files, including those used
4925 by any TU, so there's no need to scan TUs here. We can
4926 ignore file names coming from already-expanded CUs. */
4928 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4930 if (per_objfile
->symtab_set_p (per_cu
))
4932 void **slot
= htab_find_slot (visited
.get (),
4933 per_cu
->v
.quick
->file_names
,
4936 *slot
= per_cu
->v
.quick
->file_names
;
4940 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4942 /* We only need to look at symtabs not already expanded. */
4943 if (per_objfile
->symtab_set_p (per_cu
))
4946 quick_file_names
*file_data
4947 = dw2_get_file_names (per_cu
, per_objfile
);
4948 if (file_data
== NULL
)
4951 void **slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
4954 /* Already visited. */
4959 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4961 const char *filename
= file_data
->file_names
[j
];
4962 per_objfile
->per_bfd
->filenames_cache
->seen (filename
);
4967 per_objfile
->per_bfd
->filenames_cache
->traverse ([&] (const char *filename
)
4969 gdb::unique_xmalloc_ptr
<char> this_real_name
;
4972 this_real_name
= gdb_realpath (filename
);
4973 (*fun
) (filename
, this_real_name
.get (), data
);
4978 dw2_has_symbols (struct objfile
*objfile
)
4983 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
4986 dw2_find_last_source_symtab
,
4987 dw2_forget_cached_source_info
,
4988 dw2_map_symtabs_matching_filename
,
4993 dw2_expand_symtabs_for_function
,
4994 dw2_expand_all_symtabs
,
4995 dw2_expand_symtabs_with_fullname
,
4996 dw2_map_matching_symbols
,
4997 dw2_expand_symtabs_matching
,
4998 dw2_find_pc_sect_compunit_symtab
,
5000 dw2_map_symbol_filenames
5003 /* DWARF-5 debug_names reader. */
5005 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5006 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
5008 /* A helper function that reads the .debug_names section in SECTION
5009 and fills in MAP. FILENAME is the name of the file containing the
5010 section; it is used for error reporting.
5012 Returns true if all went well, false otherwise. */
5015 read_debug_names_from_section (struct objfile
*objfile
,
5016 const char *filename
,
5017 struct dwarf2_section_info
*section
,
5018 mapped_debug_names
&map
)
5020 if (section
->empty ())
5023 /* Older elfutils strip versions could keep the section in the main
5024 executable while splitting it for the separate debug info file. */
5025 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
5028 section
->read (objfile
);
5030 map
.dwarf5_byte_order
= gdbarch_byte_order (objfile
->arch ());
5032 const gdb_byte
*addr
= section
->buffer
;
5034 bfd
*const abfd
= section
->get_bfd_owner ();
5036 unsigned int bytes_read
;
5037 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
5040 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
5041 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
5042 if (bytes_read
+ length
!= section
->size
)
5044 /* There may be multiple per-CU indices. */
5045 warning (_("Section .debug_names in %s length %s does not match "
5046 "section length %s, ignoring .debug_names."),
5047 filename
, plongest (bytes_read
+ length
),
5048 pulongest (section
->size
));
5052 /* The version number. */
5053 uint16_t version
= read_2_bytes (abfd
, addr
);
5057 warning (_("Section .debug_names in %s has unsupported version %d, "
5058 "ignoring .debug_names."),
5064 uint16_t padding
= read_2_bytes (abfd
, addr
);
5068 warning (_("Section .debug_names in %s has unsupported padding %d, "
5069 "ignoring .debug_names."),
5074 /* comp_unit_count - The number of CUs in the CU list. */
5075 map
.cu_count
= read_4_bytes (abfd
, addr
);
5078 /* local_type_unit_count - The number of TUs in the local TU
5080 map
.tu_count
= read_4_bytes (abfd
, addr
);
5083 /* foreign_type_unit_count - The number of TUs in the foreign TU
5085 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
5087 if (foreign_tu_count
!= 0)
5089 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5090 "ignoring .debug_names."),
5091 filename
, static_cast<unsigned long> (foreign_tu_count
));
5095 /* bucket_count - The number of hash buckets in the hash lookup
5097 map
.bucket_count
= read_4_bytes (abfd
, addr
);
5100 /* name_count - The number of unique names in the index. */
5101 map
.name_count
= read_4_bytes (abfd
, addr
);
5104 /* abbrev_table_size - The size in bytes of the abbreviations
5106 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
5109 /* augmentation_string_size - The size in bytes of the augmentation
5110 string. This value is rounded up to a multiple of 4. */
5111 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
5113 map
.augmentation_is_gdb
= ((augmentation_string_size
5114 == sizeof (dwarf5_augmentation
))
5115 && memcmp (addr
, dwarf5_augmentation
,
5116 sizeof (dwarf5_augmentation
)) == 0);
5117 augmentation_string_size
+= (-augmentation_string_size
) & 3;
5118 addr
+= augmentation_string_size
;
5121 map
.cu_table_reordered
= addr
;
5122 addr
+= map
.cu_count
* map
.offset_size
;
5124 /* List of Local TUs */
5125 map
.tu_table_reordered
= addr
;
5126 addr
+= map
.tu_count
* map
.offset_size
;
5128 /* Hash Lookup Table */
5129 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5130 addr
+= map
.bucket_count
* 4;
5131 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5132 addr
+= map
.name_count
* 4;
5135 map
.name_table_string_offs_reordered
= addr
;
5136 addr
+= map
.name_count
* map
.offset_size
;
5137 map
.name_table_entry_offs_reordered
= addr
;
5138 addr
+= map
.name_count
* map
.offset_size
;
5140 const gdb_byte
*abbrev_table_start
= addr
;
5143 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5148 const auto insertpair
5149 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
5150 if (!insertpair
.second
)
5152 warning (_("Section .debug_names in %s has duplicate index %s, "
5153 "ignoring .debug_names."),
5154 filename
, pulongest (index_num
));
5157 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
5158 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5163 mapped_debug_names::index_val::attr attr
;
5164 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5166 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5168 if (attr
.form
== DW_FORM_implicit_const
)
5170 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
5174 if (attr
.dw_idx
== 0 && attr
.form
== 0)
5176 indexval
.attr_vec
.push_back (std::move (attr
));
5179 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
5181 warning (_("Section .debug_names in %s has abbreviation_table "
5182 "of size %s vs. written as %u, ignoring .debug_names."),
5183 filename
, plongest (addr
- abbrev_table_start
),
5187 map
.entry_pool
= addr
;
5192 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5196 create_cus_from_debug_names_list (dwarf2_per_bfd
*per_bfd
,
5197 const mapped_debug_names
&map
,
5198 dwarf2_section_info
§ion
,
5201 if (!map
.augmentation_is_gdb
)
5203 for (uint32_t i
= 0; i
< map
.cu_count
; ++i
)
5205 sect_offset sect_off
5206 = (sect_offset
) (extract_unsigned_integer
5207 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5209 map
.dwarf5_byte_order
));
5210 /* We don't know the length of the CU, because the CU list in a
5211 .debug_names index can be incomplete, so we can't use the start of
5212 the next CU as end of this CU. We create the CUs here with length 0,
5213 and in cutu_reader::cutu_reader we'll fill in the actual length. */
5214 dwarf2_per_cu_data
*per_cu
5215 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
, sect_off
, 0);
5216 per_bfd
->all_comp_units
.push_back (per_cu
);
5220 sect_offset sect_off_prev
;
5221 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
5223 sect_offset sect_off_next
;
5224 if (i
< map
.cu_count
)
5227 = (sect_offset
) (extract_unsigned_integer
5228 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5230 map
.dwarf5_byte_order
));
5233 sect_off_next
= (sect_offset
) section
.size
;
5236 const ULONGEST length
= sect_off_next
- sect_off_prev
;
5237 dwarf2_per_cu_data
*per_cu
5238 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
,
5239 sect_off_prev
, length
);
5240 per_bfd
->all_comp_units
.push_back (per_cu
);
5242 sect_off_prev
= sect_off_next
;
5246 /* Read the CU list from the mapped index, and use it to create all
5247 the CU objects for this dwarf2_per_objfile. */
5250 create_cus_from_debug_names (dwarf2_per_bfd
*per_bfd
,
5251 const mapped_debug_names
&map
,
5252 const mapped_debug_names
&dwz_map
)
5254 gdb_assert (per_bfd
->all_comp_units
.empty ());
5255 per_bfd
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
5257 create_cus_from_debug_names_list (per_bfd
, map
, per_bfd
->info
,
5258 false /* is_dwz */);
5260 if (dwz_map
.cu_count
== 0)
5263 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
5264 create_cus_from_debug_names_list (per_bfd
, dwz_map
, dwz
->info
,
5268 /* Read .debug_names. If everything went ok, initialize the "quick"
5269 elements of all the CUs and return true. Otherwise, return false. */
5272 dwarf2_read_debug_names (dwarf2_per_objfile
*per_objfile
)
5274 std::unique_ptr
<mapped_debug_names
> map (new mapped_debug_names
);
5275 mapped_debug_names dwz_map
;
5276 struct objfile
*objfile
= per_objfile
->objfile
;
5277 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5279 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
5280 &per_objfile
->per_bfd
->debug_names
, *map
))
5283 /* Don't use the index if it's empty. */
5284 if (map
->name_count
== 0)
5287 /* If there is a .dwz file, read it so we can get its CU list as
5289 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
5292 if (!read_debug_names_from_section (objfile
,
5293 bfd_get_filename (dwz
->dwz_bfd
.get ()),
5294 &dwz
->debug_names
, dwz_map
))
5296 warning (_("could not read '.debug_names' section from %s; skipping"),
5297 bfd_get_filename (dwz
->dwz_bfd
.get ()));
5302 create_cus_from_debug_names (per_bfd
, *map
, dwz_map
);
5304 if (map
->tu_count
!= 0)
5306 /* We can only handle a single .debug_types when we have an
5308 if (per_bfd
->types
.size () != 1)
5311 dwarf2_section_info
*section
= &per_bfd
->types
[0];
5313 create_signatured_type_table_from_debug_names
5314 (per_objfile
, *map
, section
, &per_bfd
->abbrev
);
5317 create_addrmap_from_aranges (per_objfile
, &per_bfd
->debug_aranges
);
5319 per_bfd
->debug_names_table
= std::move (map
);
5320 per_bfd
->using_index
= 1;
5321 per_bfd
->quick_file_names_table
=
5322 create_quick_file_names_table (per_objfile
->per_bfd
->all_comp_units
.size ());
5324 /* Save partial symtabs in the per_bfd object, for the benefit of subsequent
5325 objfiles using the same BFD. */
5326 gdb_assert (per_bfd
->partial_symtabs
== nullptr);
5327 per_bfd
->partial_symtabs
= objfile
->partial_symtabs
;
5332 /* Type used to manage iterating over all CUs looking for a symbol for
5335 class dw2_debug_names_iterator
5338 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5339 gdb::optional
<block_enum
> block_index
,
5341 const char *name
, dwarf2_per_objfile
*per_objfile
)
5342 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5343 m_addr (find_vec_in_debug_names (map
, name
, per_objfile
)),
5344 m_per_objfile (per_objfile
)
5347 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5348 search_domain search
, uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5351 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
5352 m_per_objfile (per_objfile
)
5355 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5356 block_enum block_index
, domain_enum domain
,
5357 uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5358 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5359 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
5360 m_per_objfile (per_objfile
)
5363 /* Return the next matching CU or NULL if there are no more. */
5364 dwarf2_per_cu_data
*next ();
5367 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5369 dwarf2_per_objfile
*per_objfile
);
5370 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5372 dwarf2_per_objfile
*per_objfile
);
5374 /* The internalized form of .debug_names. */
5375 const mapped_debug_names
&m_map
;
5377 /* If set, only look for symbols that match that block. Valid values are
5378 GLOBAL_BLOCK and STATIC_BLOCK. */
5379 const gdb::optional
<block_enum
> m_block_index
;
5381 /* The kind of symbol we're looking for. */
5382 const domain_enum m_domain
= UNDEF_DOMAIN
;
5383 const search_domain m_search
= ALL_DOMAIN
;
5385 /* The list of CUs from the index entry of the symbol, or NULL if
5387 const gdb_byte
*m_addr
;
5389 dwarf2_per_objfile
*m_per_objfile
;
5393 mapped_debug_names::namei_to_name
5394 (uint32_t namei
, dwarf2_per_objfile
*per_objfile
) const
5396 const ULONGEST namei_string_offs
5397 = extract_unsigned_integer ((name_table_string_offs_reordered
5398 + namei
* offset_size
),
5401 return read_indirect_string_at_offset (per_objfile
, namei_string_offs
);
5404 /* Find a slot in .debug_names for the object named NAME. If NAME is
5405 found, return pointer to its pool data. If NAME cannot be found,
5409 dw2_debug_names_iterator::find_vec_in_debug_names
5410 (const mapped_debug_names
&map
, const char *name
,
5411 dwarf2_per_objfile
*per_objfile
)
5413 int (*cmp
) (const char *, const char *);
5415 gdb::unique_xmalloc_ptr
<char> without_params
;
5416 if (current_language
->la_language
== language_cplus
5417 || current_language
->la_language
== language_fortran
5418 || current_language
->la_language
== language_d
)
5420 /* NAME is already canonical. Drop any qualifiers as
5421 .debug_names does not contain any. */
5423 if (strchr (name
, '(') != NULL
)
5425 without_params
= cp_remove_params (name
);
5426 if (without_params
!= NULL
)
5427 name
= without_params
.get ();
5431 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
5433 const uint32_t full_hash
= dwarf5_djb_hash (name
);
5435 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5436 (map
.bucket_table_reordered
5437 + (full_hash
% map
.bucket_count
)), 4,
5438 map
.dwarf5_byte_order
);
5442 if (namei
>= map
.name_count
)
5444 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5446 namei
, map
.name_count
,
5447 objfile_name (per_objfile
->objfile
));
5453 const uint32_t namei_full_hash
5454 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5455 (map
.hash_table_reordered
+ namei
), 4,
5456 map
.dwarf5_byte_order
);
5457 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
5460 if (full_hash
== namei_full_hash
)
5462 const char *const namei_string
= map
.namei_to_name (namei
, per_objfile
);
5464 #if 0 /* An expensive sanity check. */
5465 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
5467 complaint (_("Wrong .debug_names hash for string at index %u "
5469 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
5474 if (cmp (namei_string
, name
) == 0)
5476 const ULONGEST namei_entry_offs
5477 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5478 + namei
* map
.offset_size
),
5479 map
.offset_size
, map
.dwarf5_byte_order
);
5480 return map
.entry_pool
+ namei_entry_offs
;
5485 if (namei
>= map
.name_count
)
5491 dw2_debug_names_iterator::find_vec_in_debug_names
5492 (const mapped_debug_names
&map
, uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5494 if (namei
>= map
.name_count
)
5496 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5498 namei
, map
.name_count
,
5499 objfile_name (per_objfile
->objfile
));
5503 const ULONGEST namei_entry_offs
5504 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5505 + namei
* map
.offset_size
),
5506 map
.offset_size
, map
.dwarf5_byte_order
);
5507 return map
.entry_pool
+ namei_entry_offs
;
5510 /* See dw2_debug_names_iterator. */
5512 dwarf2_per_cu_data
*
5513 dw2_debug_names_iterator::next ()
5518 dwarf2_per_bfd
*per_bfd
= m_per_objfile
->per_bfd
;
5519 struct objfile
*objfile
= m_per_objfile
->objfile
;
5520 bfd
*const abfd
= objfile
->obfd
;
5524 unsigned int bytes_read
;
5525 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5526 m_addr
+= bytes_read
;
5530 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5531 if (indexval_it
== m_map
.abbrev_map
.cend ())
5533 complaint (_("Wrong .debug_names undefined abbrev code %s "
5535 pulongest (abbrev
), objfile_name (objfile
));
5538 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5539 enum class symbol_linkage
{
5543 } symbol_linkage_
= symbol_linkage::unknown
;
5544 dwarf2_per_cu_data
*per_cu
= NULL
;
5545 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5550 case DW_FORM_implicit_const
:
5551 ull
= attr
.implicit_const
;
5553 case DW_FORM_flag_present
:
5557 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5558 m_addr
+= bytes_read
;
5561 ull
= read_4_bytes (abfd
, m_addr
);
5565 ull
= read_8_bytes (abfd
, m_addr
);
5568 case DW_FORM_ref_sig8
:
5569 ull
= read_8_bytes (abfd
, m_addr
);
5573 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5574 dwarf_form_name (attr
.form
),
5575 objfile_name (objfile
));
5578 switch (attr
.dw_idx
)
5580 case DW_IDX_compile_unit
:
5581 /* Don't crash on bad data. */
5582 if (ull
>= m_per_objfile
->per_bfd
->all_comp_units
.size ())
5584 complaint (_(".debug_names entry has bad CU index %s"
5587 objfile_name (objfile
));
5590 per_cu
= per_bfd
->get_cutu (ull
);
5592 case DW_IDX_type_unit
:
5593 /* Don't crash on bad data. */
5594 if (ull
>= per_bfd
->all_type_units
.size ())
5596 complaint (_(".debug_names entry has bad TU index %s"
5599 objfile_name (objfile
));
5602 per_cu
= &per_bfd
->get_tu (ull
)->per_cu
;
5604 case DW_IDX_die_offset
:
5605 /* In a per-CU index (as opposed to a per-module index), index
5606 entries without CU attribute implicitly refer to the single CU. */
5608 per_cu
= per_bfd
->get_cu (0);
5610 case DW_IDX_GNU_internal
:
5611 if (!m_map
.augmentation_is_gdb
)
5613 symbol_linkage_
= symbol_linkage::static_
;
5615 case DW_IDX_GNU_external
:
5616 if (!m_map
.augmentation_is_gdb
)
5618 symbol_linkage_
= symbol_linkage::extern_
;
5623 /* Skip if already read in. */
5624 if (m_per_objfile
->symtab_set_p (per_cu
))
5627 /* Check static vs global. */
5628 if (symbol_linkage_
!= symbol_linkage::unknown
&& m_block_index
.has_value ())
5630 const bool want_static
= *m_block_index
== STATIC_BLOCK
;
5631 const bool symbol_is_static
=
5632 symbol_linkage_
== symbol_linkage::static_
;
5633 if (want_static
!= symbol_is_static
)
5637 /* Match dw2_symtab_iter_next, symbol_kind
5638 and debug_names::psymbol_tag. */
5642 switch (indexval
.dwarf_tag
)
5644 case DW_TAG_variable
:
5645 case DW_TAG_subprogram
:
5646 /* Some types are also in VAR_DOMAIN. */
5647 case DW_TAG_typedef
:
5648 case DW_TAG_structure_type
:
5655 switch (indexval
.dwarf_tag
)
5657 case DW_TAG_typedef
:
5658 case DW_TAG_structure_type
:
5665 switch (indexval
.dwarf_tag
)
5668 case DW_TAG_variable
:
5675 switch (indexval
.dwarf_tag
)
5687 /* Match dw2_expand_symtabs_matching, symbol_kind and
5688 debug_names::psymbol_tag. */
5691 case VARIABLES_DOMAIN
:
5692 switch (indexval
.dwarf_tag
)
5694 case DW_TAG_variable
:
5700 case FUNCTIONS_DOMAIN
:
5701 switch (indexval
.dwarf_tag
)
5703 case DW_TAG_subprogram
:
5710 switch (indexval
.dwarf_tag
)
5712 case DW_TAG_typedef
:
5713 case DW_TAG_structure_type
:
5719 case MODULES_DOMAIN
:
5720 switch (indexval
.dwarf_tag
)
5734 static struct compunit_symtab
*
5735 dw2_debug_names_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
5736 const char *name
, domain_enum domain
)
5738 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5740 const auto &mapp
= per_objfile
->per_bfd
->debug_names_table
;
5743 /* index is NULL if OBJF_READNOW. */
5746 const auto &map
= *mapp
;
5748 dw2_debug_names_iterator
iter (map
, block_index
, domain
, name
, per_objfile
);
5750 struct compunit_symtab
*stab_best
= NULL
;
5751 struct dwarf2_per_cu_data
*per_cu
;
5752 while ((per_cu
= iter
.next ()) != NULL
)
5754 struct symbol
*sym
, *with_opaque
= NULL
;
5755 compunit_symtab
*stab
5756 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
5757 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
5758 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
5760 sym
= block_find_symbol (block
, name
, domain
,
5761 block_find_non_opaque_type_preferred
,
5764 /* Some caution must be observed with overloaded functions and
5765 methods, since the index will not contain any overload
5766 information (but NAME might contain it). */
5769 && strcmp_iw (sym
->search_name (), name
) == 0)
5771 if (with_opaque
!= NULL
5772 && strcmp_iw (with_opaque
->search_name (), name
) == 0)
5775 /* Keep looking through other CUs. */
5781 /* This dumps minimal information about .debug_names. It is called
5782 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
5783 uses this to verify that .debug_names has been loaded. */
5786 dw2_debug_names_dump (struct objfile
*objfile
)
5788 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5790 gdb_assert (per_objfile
->per_bfd
->using_index
);
5791 printf_filtered (".debug_names:");
5792 if (per_objfile
->per_bfd
->debug_names_table
)
5793 printf_filtered (" exists\n");
5795 printf_filtered (" faked for \"readnow\"\n");
5796 printf_filtered ("\n");
5800 dw2_debug_names_expand_symtabs_for_function (struct objfile
*objfile
,
5801 const char *func_name
)
5803 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5805 /* per_objfile->per_bfd->debug_names_table is NULL if OBJF_READNOW. */
5806 if (per_objfile
->per_bfd
->debug_names_table
)
5808 const mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5810 dw2_debug_names_iterator
iter (map
, {}, VAR_DOMAIN
, func_name
,
5813 struct dwarf2_per_cu_data
*per_cu
;
5814 while ((per_cu
= iter
.next ()) != NULL
)
5815 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
5820 dw2_debug_names_map_matching_symbols
5821 (struct objfile
*objfile
,
5822 const lookup_name_info
&name
, domain_enum domain
,
5824 gdb::function_view
<symbol_found_callback_ftype
> callback
,
5825 symbol_compare_ftype
*ordered_compare
)
5827 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5829 /* debug_names_table is NULL if OBJF_READNOW. */
5830 if (!per_objfile
->per_bfd
->debug_names_table
)
5833 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5834 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
5836 const char *match_name
= name
.ada ().lookup_name ().c_str ();
5837 auto matcher
= [&] (const char *symname
)
5839 if (ordered_compare
== nullptr)
5841 return ordered_compare (symname
, match_name
) == 0;
5844 dw2_expand_symtabs_matching_symbol (map
, name
, matcher
, ALL_DOMAIN
,
5845 [&] (offset_type namei
)
5847 /* The name was matched, now expand corresponding CUs that were
5849 dw2_debug_names_iterator
iter (map
, block_kind
, domain
, namei
,
5852 struct dwarf2_per_cu_data
*per_cu
;
5853 while ((per_cu
= iter
.next ()) != NULL
)
5854 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
5859 /* It's a shame we couldn't do this inside the
5860 dw2_expand_symtabs_matching_symbol callback, but that skips CUs
5861 that have already been expanded. Instead, this loop matches what
5862 the psymtab code does. */
5863 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5865 compunit_symtab
*symtab
= per_objfile
->get_symtab (per_cu
);
5866 if (symtab
!= nullptr)
5868 const struct block
*block
5869 = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (symtab
), block_kind
);
5870 if (!iterate_over_symbols_terminated (block
, name
,
5878 dw2_debug_names_expand_symtabs_matching
5879 (struct objfile
*objfile
,
5880 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5881 const lookup_name_info
*lookup_name
,
5882 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5883 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5884 enum search_domain kind
)
5886 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5888 /* debug_names_table is NULL if OBJF_READNOW. */
5889 if (!per_objfile
->per_bfd
->debug_names_table
)
5892 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
5894 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
5896 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5900 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
5906 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5908 dw2_expand_symtabs_matching_symbol (map
, *lookup_name
,
5910 kind
, [&] (offset_type namei
)
5912 /* The name was matched, now expand corresponding CUs that were
5914 dw2_debug_names_iterator
iter (map
, kind
, namei
, per_objfile
);
5916 struct dwarf2_per_cu_data
*per_cu
;
5917 while ((per_cu
= iter
.next ()) != NULL
)
5918 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
5924 const struct quick_symbol_functions dwarf2_debug_names_functions
=
5927 dw2_find_last_source_symtab
,
5928 dw2_forget_cached_source_info
,
5929 dw2_map_symtabs_matching_filename
,
5930 dw2_debug_names_lookup_symbol
,
5933 dw2_debug_names_dump
,
5934 dw2_debug_names_expand_symtabs_for_function
,
5935 dw2_expand_all_symtabs
,
5936 dw2_expand_symtabs_with_fullname
,
5937 dw2_debug_names_map_matching_symbols
,
5938 dw2_debug_names_expand_symtabs_matching
,
5939 dw2_find_pc_sect_compunit_symtab
,
5941 dw2_map_symbol_filenames
5944 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
5945 to either a dwarf2_per_bfd or dwz_file object. */
5947 template <typename T
>
5948 static gdb::array_view
<const gdb_byte
>
5949 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
5951 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
5953 if (section
->empty ())
5956 /* Older elfutils strip versions could keep the section in the main
5957 executable while splitting it for the separate debug info file. */
5958 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
5961 section
->read (obj
);
5963 /* dwarf2_section_info::size is a bfd_size_type, while
5964 gdb::array_view works with size_t. On 32-bit hosts, with
5965 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
5966 is 32-bit. So we need an explicit narrowing conversion here.
5967 This is fine, because it's impossible to allocate or mmap an
5968 array/buffer larger than what size_t can represent. */
5969 return gdb::make_array_view (section
->buffer
, section
->size
);
5972 /* Lookup the index cache for the contents of the index associated to
5975 static gdb::array_view
<const gdb_byte
>
5976 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_bfd
*dwarf2_per_bfd
)
5978 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
5979 if (build_id
== nullptr)
5982 return global_index_cache
.lookup_gdb_index (build_id
,
5983 &dwarf2_per_bfd
->index_cache_res
);
5986 /* Same as the above, but for DWZ. */
5988 static gdb::array_view
<const gdb_byte
>
5989 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
5991 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
5992 if (build_id
== nullptr)
5995 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
5998 /* See symfile.h. */
6001 dwarf2_initialize_objfile (struct objfile
*objfile
, dw_index_kind
*index_kind
)
6003 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
6004 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6006 /* If we're about to read full symbols, don't bother with the
6007 indices. In this case we also don't care if some other debug
6008 format is making psymtabs, because they are all about to be
6010 if ((objfile
->flags
& OBJF_READNOW
))
6012 /* When using READNOW, the using_index flag (set below) indicates that
6013 PER_BFD was already initialized, when we loaded some other objfile. */
6014 if (per_bfd
->using_index
)
6016 *index_kind
= dw_index_kind::GDB_INDEX
;
6017 per_objfile
->resize_symtabs ();
6021 per_bfd
->using_index
= 1;
6022 create_all_comp_units (per_objfile
);
6023 create_all_type_units (per_objfile
);
6024 per_bfd
->quick_file_names_table
6025 = create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
6026 per_objfile
->resize_symtabs ();
6028 for (int i
= 0; i
< (per_bfd
->all_comp_units
.size ()
6029 + per_bfd
->all_type_units
.size ()); ++i
)
6031 dwarf2_per_cu_data
*per_cu
= per_bfd
->get_cutu (i
);
6033 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
6034 struct dwarf2_per_cu_quick_data
);
6037 /* Return 1 so that gdb sees the "quick" functions. However,
6038 these functions will be no-ops because we will have expanded
6040 *index_kind
= dw_index_kind::GDB_INDEX
;
6044 /* Was a debug names index already read when we processed an objfile sharing
6046 if (per_bfd
->debug_names_table
!= nullptr)
6048 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6049 per_objfile
->objfile
->partial_symtabs
= per_bfd
->partial_symtabs
;
6050 per_objfile
->resize_symtabs ();
6054 /* Was a GDB index already read when we processed an objfile sharing
6056 if (per_bfd
->index_table
!= nullptr)
6058 *index_kind
= dw_index_kind::GDB_INDEX
;
6059 per_objfile
->objfile
->partial_symtabs
= per_bfd
->partial_symtabs
;
6060 per_objfile
->resize_symtabs ();
6064 /* There might already be partial symtabs built for this BFD. This happens
6065 when loading the same binary twice with the index-cache enabled. If so,
6066 don't try to read an index. The objfile / per_objfile initialization will
6067 be completed in dwarf2_build_psymtabs, in the standard partial symtabs
6069 if (per_bfd
->partial_symtabs
!= nullptr)
6072 if (dwarf2_read_debug_names (per_objfile
))
6074 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6075 per_objfile
->resize_symtabs ();
6079 if (dwarf2_read_gdb_index (per_objfile
,
6080 get_gdb_index_contents_from_section
<struct dwarf2_per_bfd
>,
6081 get_gdb_index_contents_from_section
<dwz_file
>))
6083 *index_kind
= dw_index_kind::GDB_INDEX
;
6084 per_objfile
->resize_symtabs ();
6088 /* ... otherwise, try to find the index in the index cache. */
6089 if (dwarf2_read_gdb_index (per_objfile
,
6090 get_gdb_index_contents_from_cache
,
6091 get_gdb_index_contents_from_cache_dwz
))
6093 global_index_cache
.hit ();
6094 *index_kind
= dw_index_kind::GDB_INDEX
;
6095 per_objfile
->resize_symtabs ();
6099 global_index_cache
.miss ();
6105 /* Build a partial symbol table. */
6108 dwarf2_build_psymtabs (struct objfile
*objfile
)
6110 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
6111 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6113 if (per_bfd
->partial_symtabs
!= nullptr)
6115 /* Partial symbols were already read, so now we can simply
6117 objfile
->partial_symtabs
= per_bfd
->partial_symtabs
;
6118 per_objfile
->resize_symtabs ();
6122 init_psymbol_list (objfile
, 1024);
6126 /* This isn't really ideal: all the data we allocate on the
6127 objfile's obstack is still uselessly kept around. However,
6128 freeing it seems unsafe. */
6129 psymtab_discarder
psymtabs (objfile
);
6130 dwarf2_build_psymtabs_hard (per_objfile
);
6133 per_objfile
->resize_symtabs ();
6135 /* (maybe) store an index in the cache. */
6136 global_index_cache
.store (per_objfile
);
6138 catch (const gdb_exception_error
&except
)
6140 exception_print (gdb_stderr
, except
);
6143 /* Finish by setting the local reference to partial symtabs, so that
6144 we don't try to read them again if reading another objfile with the same
6145 BFD. If we can't in fact share, this won't make a difference anyway as
6146 the dwarf2_per_bfd object won't be shared. */
6147 per_bfd
->partial_symtabs
= objfile
->partial_symtabs
;
6150 /* Find the base address of the compilation unit for range lists and
6151 location lists. It will normally be specified by DW_AT_low_pc.
6152 In DWARF-3 draft 4, the base address could be overridden by
6153 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6154 compilation units with discontinuous ranges. */
6157 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
6159 struct attribute
*attr
;
6161 cu
->base_address
.reset ();
6163 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
6164 if (attr
!= nullptr)
6165 cu
->base_address
= attr
->as_address ();
6168 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6169 if (attr
!= nullptr)
6170 cu
->base_address
= attr
->as_address ();
6174 /* Helper function that returns the proper abbrev section for
6177 static struct dwarf2_section_info
*
6178 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
6180 struct dwarf2_section_info
*abbrev
;
6181 dwarf2_per_bfd
*per_bfd
= this_cu
->per_bfd
;
6183 if (this_cu
->is_dwz
)
6184 abbrev
= &dwarf2_get_dwz_file (per_bfd
)->abbrev
;
6186 abbrev
= &per_bfd
->abbrev
;
6191 /* Fetch the abbreviation table offset from a comp or type unit header. */
6194 read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
6195 struct dwarf2_section_info
*section
,
6196 sect_offset sect_off
)
6198 bfd
*abfd
= section
->get_bfd_owner ();
6199 const gdb_byte
*info_ptr
;
6200 unsigned int initial_length_size
, offset_size
;
6203 section
->read (per_objfile
->objfile
);
6204 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
6205 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6206 offset_size
= initial_length_size
== 4 ? 4 : 8;
6207 info_ptr
+= initial_length_size
;
6209 version
= read_2_bytes (abfd
, info_ptr
);
6213 /* Skip unit type and address size. */
6217 return (sect_offset
) read_offset (abfd
, info_ptr
, offset_size
);
6220 /* A partial symtab that is used only for include files. */
6221 struct dwarf2_include_psymtab
: public partial_symtab
6223 dwarf2_include_psymtab (const char *filename
, struct objfile
*objfile
)
6224 : partial_symtab (filename
, objfile
)
6228 void read_symtab (struct objfile
*objfile
) override
6230 /* It's an include file, no symbols to read for it.
6231 Everything is in the includer symtab. */
6233 /* The expansion of a dwarf2_include_psymtab is just a trigger for
6234 expansion of the includer psymtab. We use the dependencies[0] field to
6235 model the includer. But if we go the regular route of calling
6236 expand_psymtab here, and having expand_psymtab call expand_dependencies
6237 to expand the includer, we'll only use expand_psymtab on the includer
6238 (making it a non-toplevel psymtab), while if we expand the includer via
6239 another path, we'll use read_symtab (making it a toplevel psymtab).
6240 So, don't pretend a dwarf2_include_psymtab is an actual toplevel
6241 psymtab, and trigger read_symtab on the includer here directly. */
6242 includer ()->read_symtab (objfile
);
6245 void expand_psymtab (struct objfile
*objfile
) override
6247 /* This is not called by read_symtab, and should not be called by any
6248 expand_dependencies. */
6252 bool readin_p (struct objfile
*objfile
) const override
6254 return includer ()->readin_p (objfile
);
6257 compunit_symtab
*get_compunit_symtab (struct objfile
*objfile
) const override
6263 partial_symtab
*includer () const
6265 /* An include psymtab has exactly one dependency: the psymtab that
6267 gdb_assert (this->number_of_dependencies
== 1);
6268 return this->dependencies
[0];
6272 /* Allocate a new partial symtab for file named NAME and mark this new
6273 partial symtab as being an include of PST. */
6276 dwarf2_create_include_psymtab (const char *name
, dwarf2_psymtab
*pst
,
6277 struct objfile
*objfile
)
6279 dwarf2_include_psymtab
*subpst
= new dwarf2_include_psymtab (name
, objfile
);
6281 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
6282 subpst
->dirname
= pst
->dirname
;
6284 subpst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (1);
6285 subpst
->dependencies
[0] = pst
;
6286 subpst
->number_of_dependencies
= 1;
6289 /* Read the Line Number Program data and extract the list of files
6290 included by the source file represented by PST. Build an include
6291 partial symtab for each of these included files. */
6294 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
6295 struct die_info
*die
,
6296 dwarf2_psymtab
*pst
)
6299 struct attribute
*attr
;
6301 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6302 if (attr
!= nullptr && attr
->form_is_unsigned ())
6303 lh
= dwarf_decode_line_header ((sect_offset
) attr
->as_unsigned (), cu
);
6305 return; /* No linetable, so no includes. */
6307 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6308 that we pass in the raw text_low here; that is ok because we're
6309 only decoding the line table to make include partial symtabs, and
6310 so the addresses aren't really used. */
6311 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
6312 pst
->raw_text_low (), 1);
6316 hash_signatured_type (const void *item
)
6318 const struct signatured_type
*sig_type
6319 = (const struct signatured_type
*) item
;
6321 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6322 return sig_type
->signature
;
6326 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6328 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6329 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6331 return lhs
->signature
== rhs
->signature
;
6334 /* Allocate a hash table for signatured types. */
6337 allocate_signatured_type_table ()
6339 return htab_up (htab_create_alloc (41,
6340 hash_signatured_type
,
6342 NULL
, xcalloc
, xfree
));
6345 /* A helper function to add a signatured type CU to a table. */
6348 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6350 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6351 std::vector
<signatured_type
*> *all_type_units
6352 = (std::vector
<signatured_type
*> *) datum
;
6354 all_type_units
->push_back (sigt
);
6359 /* A helper for create_debug_types_hash_table. Read types from SECTION
6360 and fill them into TYPES_HTAB. It will process only type units,
6361 therefore DW_UT_type. */
6364 create_debug_type_hash_table (dwarf2_per_objfile
*per_objfile
,
6365 struct dwo_file
*dwo_file
,
6366 dwarf2_section_info
*section
, htab_up
&types_htab
,
6367 rcuh_kind section_kind
)
6369 struct objfile
*objfile
= per_objfile
->objfile
;
6370 struct dwarf2_section_info
*abbrev_section
;
6372 const gdb_byte
*info_ptr
, *end_ptr
;
6374 abbrev_section
= (dwo_file
!= NULL
6375 ? &dwo_file
->sections
.abbrev
6376 : &per_objfile
->per_bfd
->abbrev
);
6378 if (dwarf_read_debug
)
6379 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
6380 section
->get_name (),
6381 abbrev_section
->get_file_name ());
6383 section
->read (objfile
);
6384 info_ptr
= section
->buffer
;
6386 if (info_ptr
== NULL
)
6389 /* We can't set abfd until now because the section may be empty or
6390 not present, in which case the bfd is unknown. */
6391 abfd
= section
->get_bfd_owner ();
6393 /* We don't use cutu_reader here because we don't need to read
6394 any dies: the signature is in the header. */
6396 end_ptr
= info_ptr
+ section
->size
;
6397 while (info_ptr
< end_ptr
)
6399 struct signatured_type
*sig_type
;
6400 struct dwo_unit
*dwo_tu
;
6402 const gdb_byte
*ptr
= info_ptr
;
6403 struct comp_unit_head header
;
6404 unsigned int length
;
6406 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
6408 /* Initialize it due to a false compiler warning. */
6409 header
.signature
= -1;
6410 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
6412 /* We need to read the type's signature in order to build the hash
6413 table, but we don't need anything else just yet. */
6415 ptr
= read_and_check_comp_unit_head (per_objfile
, &header
, section
,
6416 abbrev_section
, ptr
, section_kind
);
6418 length
= header
.get_length ();
6420 /* Skip dummy type units. */
6421 if (ptr
>= info_ptr
+ length
6422 || peek_abbrev_code (abfd
, ptr
) == 0
6423 || (header
.unit_type
!= DW_UT_type
6424 && header
.unit_type
!= DW_UT_split_type
))
6430 if (types_htab
== NULL
)
6433 types_htab
= allocate_dwo_unit_table ();
6435 types_htab
= allocate_signatured_type_table ();
6441 dwo_tu
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, dwo_unit
);
6442 dwo_tu
->dwo_file
= dwo_file
;
6443 dwo_tu
->signature
= header
.signature
;
6444 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6445 dwo_tu
->section
= section
;
6446 dwo_tu
->sect_off
= sect_off
;
6447 dwo_tu
->length
= length
;
6451 /* N.B.: type_offset is not usable if this type uses a DWO file.
6452 The real type_offset is in the DWO file. */
6454 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6455 sig_type
->signature
= header
.signature
;
6456 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6457 sig_type
->per_cu
.is_debug_types
= 1;
6458 sig_type
->per_cu
.section
= section
;
6459 sig_type
->per_cu
.sect_off
= sect_off
;
6460 sig_type
->per_cu
.length
= length
;
6463 slot
= htab_find_slot (types_htab
.get (),
6464 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
6466 gdb_assert (slot
!= NULL
);
6469 sect_offset dup_sect_off
;
6473 const struct dwo_unit
*dup_tu
6474 = (const struct dwo_unit
*) *slot
;
6476 dup_sect_off
= dup_tu
->sect_off
;
6480 const struct signatured_type
*dup_tu
6481 = (const struct signatured_type
*) *slot
;
6483 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
6486 complaint (_("debug type entry at offset %s is duplicate to"
6487 " the entry at offset %s, signature %s"),
6488 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
6489 hex_string (header
.signature
));
6491 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
6493 if (dwarf_read_debug
> 1)
6494 fprintf_unfiltered (gdb_stdlog
, " offset %s, signature %s\n",
6495 sect_offset_str (sect_off
),
6496 hex_string (header
.signature
));
6502 /* Create the hash table of all entries in the .debug_types
6503 (or .debug_types.dwo) section(s).
6504 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6505 otherwise it is NULL.
6507 The result is a pointer to the hash table or NULL if there are no types.
6509 Note: This function processes DWO files only, not DWP files. */
6512 create_debug_types_hash_table (dwarf2_per_objfile
*per_objfile
,
6513 struct dwo_file
*dwo_file
,
6514 gdb::array_view
<dwarf2_section_info
> type_sections
,
6515 htab_up
&types_htab
)
6517 for (dwarf2_section_info
§ion
: type_sections
)
6518 create_debug_type_hash_table (per_objfile
, dwo_file
, §ion
, types_htab
,
6522 /* Create the hash table of all entries in the .debug_types section,
6523 and initialize all_type_units.
6524 The result is zero if there is an error (e.g. missing .debug_types section),
6525 otherwise non-zero. */
6528 create_all_type_units (dwarf2_per_objfile
*per_objfile
)
6532 create_debug_type_hash_table (per_objfile
, NULL
, &per_objfile
->per_bfd
->info
,
6533 types_htab
, rcuh_kind::COMPILE
);
6534 create_debug_types_hash_table (per_objfile
, NULL
, per_objfile
->per_bfd
->types
,
6536 if (types_htab
== NULL
)
6538 per_objfile
->per_bfd
->signatured_types
= NULL
;
6542 per_objfile
->per_bfd
->signatured_types
= std::move (types_htab
);
6544 gdb_assert (per_objfile
->per_bfd
->all_type_units
.empty ());
6545 per_objfile
->per_bfd
->all_type_units
.reserve
6546 (htab_elements (per_objfile
->per_bfd
->signatured_types
.get ()));
6548 htab_traverse_noresize (per_objfile
->per_bfd
->signatured_types
.get (),
6549 add_signatured_type_cu_to_table
,
6550 &per_objfile
->per_bfd
->all_type_units
);
6555 /* Add an entry for signature SIG to dwarf2_per_objfile->per_bfd->signatured_types.
6556 If SLOT is non-NULL, it is the entry to use in the hash table.
6557 Otherwise we find one. */
6559 static struct signatured_type
*
6560 add_type_unit (dwarf2_per_objfile
*per_objfile
, ULONGEST sig
, void **slot
)
6562 if (per_objfile
->per_bfd
->all_type_units
.size ()
6563 == per_objfile
->per_bfd
->all_type_units
.capacity ())
6564 ++per_objfile
->per_bfd
->tu_stats
.nr_all_type_units_reallocs
;
6566 signatured_type
*sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6568 per_objfile
->resize_symtabs ();
6570 per_objfile
->per_bfd
->all_type_units
.push_back (sig_type
);
6571 sig_type
->signature
= sig
;
6572 sig_type
->per_cu
.is_debug_types
= 1;
6573 if (per_objfile
->per_bfd
->using_index
)
6575 sig_type
->per_cu
.v
.quick
=
6576 OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
6577 struct dwarf2_per_cu_quick_data
);
6582 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6585 gdb_assert (*slot
== NULL
);
6587 /* The rest of sig_type must be filled in by the caller. */
6591 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6592 Fill in SIG_ENTRY with DWO_ENTRY. */
6595 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
*per_objfile
,
6596 struct signatured_type
*sig_entry
,
6597 struct dwo_unit
*dwo_entry
)
6599 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6601 /* Make sure we're not clobbering something we don't expect to. */
6602 gdb_assert (! sig_entry
->per_cu
.queued
);
6603 gdb_assert (per_objfile
->get_cu (&sig_entry
->per_cu
) == NULL
);
6604 if (per_bfd
->using_index
)
6606 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
6607 gdb_assert (!per_objfile
->symtab_set_p (&sig_entry
->per_cu
));
6610 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
6611 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
6612 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
6613 gdb_assert (sig_entry
->type_unit_group
== NULL
);
6614 gdb_assert (sig_entry
->dwo_unit
== NULL
);
6616 sig_entry
->per_cu
.section
= dwo_entry
->section
;
6617 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
6618 sig_entry
->per_cu
.length
= dwo_entry
->length
;
6619 sig_entry
->per_cu
.reading_dwo_directly
= 1;
6620 sig_entry
->per_cu
.per_bfd
= per_bfd
;
6621 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
6622 sig_entry
->dwo_unit
= dwo_entry
;
6625 /* Subroutine of lookup_signatured_type.
6626 If we haven't read the TU yet, create the signatured_type data structure
6627 for a TU to be read in directly from a DWO file, bypassing the stub.
6628 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6629 using .gdb_index, then when reading a CU we want to stay in the DWO file
6630 containing that CU. Otherwise we could end up reading several other DWO
6631 files (due to comdat folding) to process the transitive closure of all the
6632 mentioned TUs, and that can be slow. The current DWO file will have every
6633 type signature that it needs.
6634 We only do this for .gdb_index because in the psymtab case we already have
6635 to read all the DWOs to build the type unit groups. */
6637 static struct signatured_type
*
6638 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6640 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6641 struct dwo_file
*dwo_file
;
6642 struct dwo_unit find_dwo_entry
, *dwo_entry
;
6643 struct signatured_type find_sig_entry
, *sig_entry
;
6646 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6648 /* If TU skeletons have been removed then we may not have read in any
6650 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6651 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6653 /* We only ever need to read in one copy of a signatured type.
6654 Use the global signatured_types array to do our own comdat-folding
6655 of types. If this is the first time we're reading this TU, and
6656 the TU has an entry in .gdb_index, replace the recorded data from
6657 .gdb_index with this TU. */
6659 find_sig_entry
.signature
= sig
;
6660 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6661 &find_sig_entry
, INSERT
);
6662 sig_entry
= (struct signatured_type
*) *slot
;
6664 /* We can get here with the TU already read, *or* in the process of being
6665 read. Don't reassign the global entry to point to this DWO if that's
6666 the case. Also note that if the TU is already being read, it may not
6667 have come from a DWO, the program may be a mix of Fission-compiled
6668 code and non-Fission-compiled code. */
6670 /* Have we already tried to read this TU?
6671 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6672 needn't exist in the global table yet). */
6673 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
6676 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6677 dwo_unit of the TU itself. */
6678 dwo_file
= cu
->dwo_unit
->dwo_file
;
6680 /* Ok, this is the first time we're reading this TU. */
6681 if (dwo_file
->tus
== NULL
)
6683 find_dwo_entry
.signature
= sig
;
6684 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
6686 if (dwo_entry
== NULL
)
6689 /* If the global table doesn't have an entry for this TU, add one. */
6690 if (sig_entry
== NULL
)
6691 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6693 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6694 sig_entry
->per_cu
.tu_read
= 1;
6698 /* Subroutine of lookup_signatured_type.
6699 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6700 then try the DWP file. If the TU stub (skeleton) has been removed then
6701 it won't be in .gdb_index. */
6703 static struct signatured_type
*
6704 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6706 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6707 struct dwp_file
*dwp_file
= get_dwp_file (per_objfile
);
6708 struct dwo_unit
*dwo_entry
;
6709 struct signatured_type find_sig_entry
, *sig_entry
;
6712 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6713 gdb_assert (dwp_file
!= NULL
);
6715 /* If TU skeletons have been removed then we may not have read in any
6717 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6718 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6720 find_sig_entry
.signature
= sig
;
6721 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6722 &find_sig_entry
, INSERT
);
6723 sig_entry
= (struct signatured_type
*) *slot
;
6725 /* Have we already tried to read this TU?
6726 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6727 needn't exist in the global table yet). */
6728 if (sig_entry
!= NULL
)
6731 if (dwp_file
->tus
== NULL
)
6733 dwo_entry
= lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, NULL
, sig
,
6734 1 /* is_debug_types */);
6735 if (dwo_entry
== NULL
)
6738 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6739 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6744 /* Lookup a signature based type for DW_FORM_ref_sig8.
6745 Returns NULL if signature SIG is not present in the table.
6746 It is up to the caller to complain about this. */
6748 static struct signatured_type
*
6749 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6751 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6753 if (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
)
6755 /* We're in a DWO/DWP file, and we're using .gdb_index.
6756 These cases require special processing. */
6757 if (get_dwp_file (per_objfile
) == NULL
)
6758 return lookup_dwo_signatured_type (cu
, sig
);
6760 return lookup_dwp_signatured_type (cu
, sig
);
6764 struct signatured_type find_entry
, *entry
;
6766 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6768 find_entry
.signature
= sig
;
6769 entry
= ((struct signatured_type
*)
6770 htab_find (per_objfile
->per_bfd
->signatured_types
.get (),
6776 /* Low level DIE reading support. */
6778 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
6781 init_cu_die_reader (struct die_reader_specs
*reader
,
6782 struct dwarf2_cu
*cu
,
6783 struct dwarf2_section_info
*section
,
6784 struct dwo_file
*dwo_file
,
6785 struct abbrev_table
*abbrev_table
)
6787 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
6788 reader
->abfd
= section
->get_bfd_owner ();
6790 reader
->dwo_file
= dwo_file
;
6791 reader
->die_section
= section
;
6792 reader
->buffer
= section
->buffer
;
6793 reader
->buffer_end
= section
->buffer
+ section
->size
;
6794 reader
->abbrev_table
= abbrev_table
;
6797 /* Subroutine of cutu_reader to simplify it.
6798 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
6799 There's just a lot of work to do, and cutu_reader is big enough
6802 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
6803 from it to the DIE in the DWO. If NULL we are skipping the stub.
6804 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
6805 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
6806 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
6807 STUB_COMP_DIR may be non-NULL.
6808 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE
6809 are filled in with the info of the DIE from the DWO file.
6810 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
6811 from the dwo. Since *RESULT_READER references this abbrev table, it must be
6812 kept around for at least as long as *RESULT_READER.
6814 The result is non-zero if a valid (non-dummy) DIE was found. */
6817 read_cutu_die_from_dwo (dwarf2_cu
*cu
,
6818 struct dwo_unit
*dwo_unit
,
6819 struct die_info
*stub_comp_unit_die
,
6820 const char *stub_comp_dir
,
6821 struct die_reader_specs
*result_reader
,
6822 const gdb_byte
**result_info_ptr
,
6823 struct die_info
**result_comp_unit_die
,
6824 abbrev_table_up
*result_dwo_abbrev_table
)
6826 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6827 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6828 struct objfile
*objfile
= per_objfile
->objfile
;
6830 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6831 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
6832 int i
,num_extra_attrs
;
6833 struct dwarf2_section_info
*dwo_abbrev_section
;
6834 struct die_info
*comp_unit_die
;
6836 /* At most one of these may be provided. */
6837 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
6839 /* These attributes aren't processed until later:
6840 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
6841 DW_AT_comp_dir is used now, to find the DWO file, but it is also
6842 referenced later. However, these attributes are found in the stub
6843 which we won't have later. In order to not impose this complication
6844 on the rest of the code, we read them here and copy them to the
6853 if (stub_comp_unit_die
!= NULL
)
6855 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
6857 if (!per_cu
->is_debug_types
)
6858 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
6859 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
6860 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
6861 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
6862 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
6864 cu
->addr_base
= stub_comp_unit_die
->addr_base ();
6866 /* There should be a DW_AT_rnglists_base (DW_AT_GNU_ranges_base) attribute
6867 here (if needed). We need the value before we can process
6869 cu
->ranges_base
= stub_comp_unit_die
->ranges_base ();
6871 else if (stub_comp_dir
!= NULL
)
6873 /* Reconstruct the comp_dir attribute to simplify the code below. */
6874 comp_dir
= OBSTACK_ZALLOC (&cu
->comp_unit_obstack
, struct attribute
);
6875 comp_dir
->name
= DW_AT_comp_dir
;
6876 comp_dir
->form
= DW_FORM_string
;
6877 comp_dir
->set_string_noncanonical (stub_comp_dir
);
6880 /* Set up for reading the DWO CU/TU. */
6881 cu
->dwo_unit
= dwo_unit
;
6882 dwarf2_section_info
*section
= dwo_unit
->section
;
6883 section
->read (objfile
);
6884 abfd
= section
->get_bfd_owner ();
6885 begin_info_ptr
= info_ptr
= (section
->buffer
6886 + to_underlying (dwo_unit
->sect_off
));
6887 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
6889 if (per_cu
->is_debug_types
)
6891 signatured_type
*sig_type
= (struct signatured_type
*) per_cu
;
6893 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6894 section
, dwo_abbrev_section
,
6895 info_ptr
, rcuh_kind::TYPE
);
6896 /* This is not an assert because it can be caused by bad debug info. */
6897 if (sig_type
->signature
!= cu
->header
.signature
)
6899 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
6900 " TU at offset %s [in module %s]"),
6901 hex_string (sig_type
->signature
),
6902 hex_string (cu
->header
.signature
),
6903 sect_offset_str (dwo_unit
->sect_off
),
6904 bfd_get_filename (abfd
));
6906 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6907 /* For DWOs coming from DWP files, we don't know the CU length
6908 nor the type's offset in the TU until now. */
6909 dwo_unit
->length
= cu
->header
.get_length ();
6910 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
6912 /* Establish the type offset that can be used to lookup the type.
6913 For DWO files, we don't know it until now. */
6914 sig_type
->type_offset_in_section
6915 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
6919 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6920 section
, dwo_abbrev_section
,
6921 info_ptr
, rcuh_kind::COMPILE
);
6922 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6923 /* For DWOs coming from DWP files, we don't know the CU length
6925 dwo_unit
->length
= cu
->header
.get_length ();
6928 *result_dwo_abbrev_table
6929 = abbrev_table::read (objfile
, dwo_abbrev_section
,
6930 cu
->header
.abbrev_sect_off
);
6931 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
6932 result_dwo_abbrev_table
->get ());
6934 /* Read in the die, but leave space to copy over the attributes
6935 from the stub. This has the benefit of simplifying the rest of
6936 the code - all the work to maintain the illusion of a single
6937 DW_TAG_{compile,type}_unit DIE is done here. */
6938 num_extra_attrs
= ((stmt_list
!= NULL
)
6942 + (comp_dir
!= NULL
));
6943 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
6946 /* Copy over the attributes from the stub to the DIE we just read in. */
6947 comp_unit_die
= *result_comp_unit_die
;
6948 i
= comp_unit_die
->num_attrs
;
6949 if (stmt_list
!= NULL
)
6950 comp_unit_die
->attrs
[i
++] = *stmt_list
;
6952 comp_unit_die
->attrs
[i
++] = *low_pc
;
6953 if (high_pc
!= NULL
)
6954 comp_unit_die
->attrs
[i
++] = *high_pc
;
6956 comp_unit_die
->attrs
[i
++] = *ranges
;
6957 if (comp_dir
!= NULL
)
6958 comp_unit_die
->attrs
[i
++] = *comp_dir
;
6959 comp_unit_die
->num_attrs
+= num_extra_attrs
;
6961 if (dwarf_die_debug
)
6963 fprintf_unfiltered (gdb_stdlog
,
6964 "Read die from %s@0x%x of %s:\n",
6965 section
->get_name (),
6966 (unsigned) (begin_info_ptr
- section
->buffer
),
6967 bfd_get_filename (abfd
));
6968 dump_die (comp_unit_die
, dwarf_die_debug
);
6971 /* Skip dummy compilation units. */
6972 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
6973 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6976 *result_info_ptr
= info_ptr
;
6980 /* Return the signature of the compile unit, if found. In DWARF 4 and before,
6981 the signature is in the DW_AT_GNU_dwo_id attribute. In DWARF 5 and later, the
6982 signature is part of the header. */
6983 static gdb::optional
<ULONGEST
>
6984 lookup_dwo_id (struct dwarf2_cu
*cu
, struct die_info
* comp_unit_die
)
6986 if (cu
->header
.version
>= 5)
6987 return cu
->header
.signature
;
6988 struct attribute
*attr
;
6989 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
6990 if (attr
== nullptr || !attr
->form_is_unsigned ())
6991 return gdb::optional
<ULONGEST
> ();
6992 return attr
->as_unsigned ();
6995 /* Subroutine of cutu_reader to simplify it.
6996 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
6997 Returns NULL if the specified DWO unit cannot be found. */
6999 static struct dwo_unit
*
7000 lookup_dwo_unit (dwarf2_cu
*cu
, die_info
*comp_unit_die
, const char *dwo_name
)
7002 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7003 struct dwo_unit
*dwo_unit
;
7004 const char *comp_dir
;
7006 gdb_assert (cu
!= NULL
);
7008 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7009 dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7010 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7012 if (per_cu
->is_debug_types
)
7013 dwo_unit
= lookup_dwo_type_unit (cu
, dwo_name
, comp_dir
);
7016 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
7018 if (!signature
.has_value ())
7019 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7021 dwo_name
, bfd_get_filename (per_cu
->per_bfd
->obfd
));
7023 dwo_unit
= lookup_dwo_comp_unit (cu
, dwo_name
, comp_dir
, *signature
);
7029 /* Subroutine of cutu_reader to simplify it.
7030 See it for a description of the parameters.
7031 Read a TU directly from a DWO file, bypassing the stub. */
7034 cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
7035 dwarf2_per_objfile
*per_objfile
,
7036 dwarf2_cu
*existing_cu
)
7038 struct signatured_type
*sig_type
;
7040 /* Verify we can do the following downcast, and that we have the
7042 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
7043 sig_type
= (struct signatured_type
*) this_cu
;
7044 gdb_assert (sig_type
->dwo_unit
!= NULL
);
7048 if (existing_cu
!= nullptr)
7051 gdb_assert (cu
->dwo_unit
== sig_type
->dwo_unit
);
7052 /* There's no need to do the rereading_dwo_cu handling that
7053 cutu_reader does since we don't read the stub. */
7057 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
7058 in per_objfile yet. */
7059 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7060 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7061 cu
= m_new_cu
.get ();
7064 /* A future optimization, if needed, would be to use an existing
7065 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7066 could share abbrev tables. */
7068 if (read_cutu_die_from_dwo (cu
, sig_type
->dwo_unit
,
7069 NULL
/* stub_comp_unit_die */,
7070 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
7073 &m_dwo_abbrev_table
) == 0)
7080 /* Initialize a CU (or TU) and read its DIEs.
7081 If the CU defers to a DWO file, read the DWO file as well.
7083 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7084 Otherwise the table specified in the comp unit header is read in and used.
7085 This is an optimization for when we already have the abbrev table.
7087 If EXISTING_CU is non-NULL, then use it. Otherwise, a new CU is
7090 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
7091 dwarf2_per_objfile
*per_objfile
,
7092 struct abbrev_table
*abbrev_table
,
7093 dwarf2_cu
*existing_cu
,
7095 : die_reader_specs
{},
7098 struct objfile
*objfile
= per_objfile
->objfile
;
7099 struct dwarf2_section_info
*section
= this_cu
->section
;
7100 bfd
*abfd
= section
->get_bfd_owner ();
7101 const gdb_byte
*begin_info_ptr
;
7102 struct signatured_type
*sig_type
= NULL
;
7103 struct dwarf2_section_info
*abbrev_section
;
7104 /* Non-zero if CU currently points to a DWO file and we need to
7105 reread it. When this happens we need to reread the skeleton die
7106 before we can reread the DWO file (this only applies to CUs, not TUs). */
7107 int rereading_dwo_cu
= 0;
7109 if (dwarf_die_debug
)
7110 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7111 this_cu
->is_debug_types
? "type" : "comp",
7112 sect_offset_str (this_cu
->sect_off
));
7114 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7115 file (instead of going through the stub), short-circuit all of this. */
7116 if (this_cu
->reading_dwo_directly
)
7118 /* Narrow down the scope of possibilities to have to understand. */
7119 gdb_assert (this_cu
->is_debug_types
);
7120 gdb_assert (abbrev_table
== NULL
);
7121 init_tu_and_read_dwo_dies (this_cu
, per_objfile
, existing_cu
);
7125 /* This is cheap if the section is already read in. */
7126 section
->read (objfile
);
7128 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7130 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
7134 if (existing_cu
!= nullptr)
7137 /* If this CU is from a DWO file we need to start over, we need to
7138 refetch the attributes from the skeleton CU.
7139 This could be optimized by retrieving those attributes from when we
7140 were here the first time: the previous comp_unit_die was stored in
7141 comp_unit_obstack. But there's no data yet that we need this
7143 if (cu
->dwo_unit
!= NULL
)
7144 rereading_dwo_cu
= 1;
7148 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
7149 in per_objfile yet. */
7150 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7151 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7152 cu
= m_new_cu
.get ();
7155 /* Get the header. */
7156 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
7158 /* We already have the header, there's no need to read it in again. */
7159 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
7163 if (this_cu
->is_debug_types
)
7165 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7166 section
, abbrev_section
,
7167 info_ptr
, rcuh_kind::TYPE
);
7169 /* Since per_cu is the first member of struct signatured_type,
7170 we can go from a pointer to one to a pointer to the other. */
7171 sig_type
= (struct signatured_type
*) this_cu
;
7172 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
7173 gdb_assert (sig_type
->type_offset_in_tu
7174 == cu
->header
.type_cu_offset_in_tu
);
7175 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7177 /* LENGTH has not been set yet for type units if we're
7178 using .gdb_index. */
7179 this_cu
->length
= cu
->header
.get_length ();
7181 /* Establish the type offset that can be used to lookup the type. */
7182 sig_type
->type_offset_in_section
=
7183 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
7185 this_cu
->dwarf_version
= cu
->header
.version
;
7189 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7190 section
, abbrev_section
,
7192 rcuh_kind::COMPILE
);
7194 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7195 if (this_cu
->length
== 0)
7196 this_cu
->length
= cu
->header
.get_length ();
7198 gdb_assert (this_cu
->length
== cu
->header
.get_length ());
7199 this_cu
->dwarf_version
= cu
->header
.version
;
7203 /* Skip dummy compilation units. */
7204 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7205 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7211 /* If we don't have them yet, read the abbrevs for this compilation unit.
7212 And if we need to read them now, make sure they're freed when we're
7214 if (abbrev_table
!= NULL
)
7215 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
7218 m_abbrev_table_holder
7219 = abbrev_table::read (objfile
, abbrev_section
,
7220 cu
->header
.abbrev_sect_off
);
7221 abbrev_table
= m_abbrev_table_holder
.get ();
7224 /* Read the top level CU/TU die. */
7225 init_cu_die_reader (this, cu
, section
, NULL
, abbrev_table
);
7226 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7228 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
7234 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7235 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7236 table from the DWO file and pass the ownership over to us. It will be
7237 referenced from READER, so we must make sure to free it after we're done
7240 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7241 DWO CU, that this test will fail (the attribute will not be present). */
7242 const char *dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7243 if (dwo_name
!= nullptr)
7245 struct dwo_unit
*dwo_unit
;
7246 struct die_info
*dwo_comp_unit_die
;
7248 if (comp_unit_die
->has_children
)
7250 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7251 " has children (offset %s) [in module %s]"),
7252 sect_offset_str (this_cu
->sect_off
),
7253 bfd_get_filename (abfd
));
7255 dwo_unit
= lookup_dwo_unit (cu
, comp_unit_die
, dwo_name
);
7256 if (dwo_unit
!= NULL
)
7258 if (read_cutu_die_from_dwo (cu
, dwo_unit
,
7259 comp_unit_die
, NULL
,
7262 &m_dwo_abbrev_table
) == 0)
7268 comp_unit_die
= dwo_comp_unit_die
;
7272 /* Yikes, we couldn't find the rest of the DIE, we only have
7273 the stub. A complaint has already been logged. There's
7274 not much more we can do except pass on the stub DIE to
7275 die_reader_func. We don't want to throw an error on bad
7282 cutu_reader::keep ()
7284 /* Done, clean up. */
7285 gdb_assert (!dummy_p
);
7286 if (m_new_cu
!= NULL
)
7288 /* Save this dwarf2_cu in the per_objfile. The per_objfile owns it
7290 dwarf2_per_objfile
*per_objfile
= m_new_cu
->per_objfile
;
7291 per_objfile
->set_cu (m_this_cu
, m_new_cu
.release ());
7295 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name (DW_AT_dwo_name)
7296 if present. DWO_FILE, if non-NULL, is the DWO file to read (the caller is
7297 assumed to have already done the lookup to find the DWO file).
7299 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7300 THIS_CU->is_debug_types, but nothing else.
7302 We fill in THIS_CU->length.
7304 THIS_CU->cu is always freed when done.
7305 This is done in order to not leave THIS_CU->cu in a state where we have
7306 to care whether it refers to the "main" CU or the DWO CU.
7308 When parent_cu is passed, it is used to provide a default value for
7309 str_offsets_base and addr_base from the parent. */
7311 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
7312 dwarf2_per_objfile
*per_objfile
,
7313 struct dwarf2_cu
*parent_cu
,
7314 struct dwo_file
*dwo_file
)
7315 : die_reader_specs
{},
7318 struct objfile
*objfile
= per_objfile
->objfile
;
7319 struct dwarf2_section_info
*section
= this_cu
->section
;
7320 bfd
*abfd
= section
->get_bfd_owner ();
7321 struct dwarf2_section_info
*abbrev_section
;
7322 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7324 if (dwarf_die_debug
)
7325 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7326 this_cu
->is_debug_types
? "type" : "comp",
7327 sect_offset_str (this_cu
->sect_off
));
7329 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7331 abbrev_section
= (dwo_file
!= NULL
7332 ? &dwo_file
->sections
.abbrev
7333 : get_abbrev_section_for_cu (this_cu
));
7335 /* This is cheap if the section is already read in. */
7336 section
->read (objfile
);
7338 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7340 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7341 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &m_new_cu
->header
,
7342 section
, abbrev_section
, info_ptr
,
7343 (this_cu
->is_debug_types
7345 : rcuh_kind::COMPILE
));
7347 if (parent_cu
!= nullptr)
7349 m_new_cu
->str_offsets_base
= parent_cu
->str_offsets_base
;
7350 m_new_cu
->addr_base
= parent_cu
->addr_base
;
7352 this_cu
->length
= m_new_cu
->header
.get_length ();
7354 /* Skip dummy compilation units. */
7355 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7356 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7362 m_abbrev_table_holder
7363 = abbrev_table::read (objfile
, abbrev_section
,
7364 m_new_cu
->header
.abbrev_sect_off
);
7366 init_cu_die_reader (this, m_new_cu
.get (), section
, dwo_file
,
7367 m_abbrev_table_holder
.get ());
7368 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7372 /* Type Unit Groups.
7374 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7375 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7376 so that all types coming from the same compilation (.o file) are grouped
7377 together. A future step could be to put the types in the same symtab as
7378 the CU the types ultimately came from. */
7381 hash_type_unit_group (const void *item
)
7383 const struct type_unit_group
*tu_group
7384 = (const struct type_unit_group
*) item
;
7386 return hash_stmt_list_entry (&tu_group
->hash
);
7390 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
7392 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
7393 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
7395 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
7398 /* Allocate a hash table for type unit groups. */
7401 allocate_type_unit_groups_table ()
7403 return htab_up (htab_create_alloc (3,
7404 hash_type_unit_group
,
7406 NULL
, xcalloc
, xfree
));
7409 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7410 partial symtabs. We combine several TUs per psymtab to not let the size
7411 of any one psymtab grow too big. */
7412 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7413 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7415 /* Helper routine for get_type_unit_group.
7416 Create the type_unit_group object used to hold one or more TUs. */
7418 static struct type_unit_group
*
7419 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
7421 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7422 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7423 struct dwarf2_per_cu_data
*per_cu
;
7424 struct type_unit_group
*tu_group
;
7426 tu_group
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, type_unit_group
);
7427 per_cu
= &tu_group
->per_cu
;
7428 per_cu
->per_bfd
= per_bfd
;
7430 if (per_bfd
->using_index
)
7432 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
7433 struct dwarf2_per_cu_quick_data
);
7437 unsigned int line_offset
= to_underlying (line_offset_struct
);
7438 dwarf2_psymtab
*pst
;
7441 /* Give the symtab a useful name for debug purposes. */
7442 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
7443 name
= string_printf ("<type_units_%d>",
7444 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
7446 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
7448 pst
= create_partial_symtab (per_cu
, per_objfile
, name
.c_str ());
7449 pst
->anonymous
= true;
7452 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
7453 tu_group
->hash
.line_sect_off
= line_offset_struct
;
7458 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7459 STMT_LIST is a DW_AT_stmt_list attribute. */
7461 static struct type_unit_group
*
7462 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
7464 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7465 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7466 struct type_unit_group
*tu_group
;
7468 unsigned int line_offset
;
7469 struct type_unit_group type_unit_group_for_lookup
;
7471 if (per_objfile
->per_bfd
->type_unit_groups
== NULL
)
7472 per_objfile
->per_bfd
->type_unit_groups
= allocate_type_unit_groups_table ();
7474 /* Do we need to create a new group, or can we use an existing one? */
7476 if (stmt_list
!= nullptr && stmt_list
->form_is_unsigned ())
7478 line_offset
= stmt_list
->as_unsigned ();
7479 ++tu_stats
->nr_symtab_sharers
;
7483 /* Ugh, no stmt_list. Rare, but we have to handle it.
7484 We can do various things here like create one group per TU or
7485 spread them over multiple groups to split up the expansion work.
7486 To avoid worst case scenarios (too many groups or too large groups)
7487 we, umm, group them in bunches. */
7488 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7489 | (tu_stats
->nr_stmt_less_type_units
7490 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
7491 ++tu_stats
->nr_stmt_less_type_units
;
7494 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
7495 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
7496 slot
= htab_find_slot (per_objfile
->per_bfd
->type_unit_groups
.get (),
7497 &type_unit_group_for_lookup
, INSERT
);
7500 tu_group
= (struct type_unit_group
*) *slot
;
7501 gdb_assert (tu_group
!= NULL
);
7505 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
7506 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
7508 ++tu_stats
->nr_symtabs
;
7514 /* Partial symbol tables. */
7516 /* Create a psymtab named NAME and assign it to PER_CU.
7518 The caller must fill in the following details:
7519 dirname, textlow, texthigh. */
7521 static dwarf2_psymtab
*
7522 create_partial_symtab (dwarf2_per_cu_data
*per_cu
,
7523 dwarf2_per_objfile
*per_objfile
,
7526 struct objfile
*objfile
= per_objfile
->objfile
;
7527 dwarf2_psymtab
*pst
;
7529 pst
= new dwarf2_psymtab (name
, objfile
, per_cu
);
7531 pst
->psymtabs_addrmap_supported
= true;
7533 /* This is the glue that links PST into GDB's symbol API. */
7534 per_cu
->v
.psymtab
= pst
;
7539 /* DIE reader function for process_psymtab_comp_unit. */
7542 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
7543 const gdb_byte
*info_ptr
,
7544 struct die_info
*comp_unit_die
,
7545 enum language pretend_language
)
7547 struct dwarf2_cu
*cu
= reader
->cu
;
7548 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7549 struct objfile
*objfile
= per_objfile
->objfile
;
7550 struct gdbarch
*gdbarch
= objfile
->arch ();
7551 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7553 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
7554 dwarf2_psymtab
*pst
;
7555 enum pc_bounds_kind cu_bounds_kind
;
7556 const char *filename
;
7558 gdb_assert (! per_cu
->is_debug_types
);
7560 prepare_one_comp_unit (cu
, comp_unit_die
, pretend_language
);
7562 /* Allocate a new partial symbol table structure. */
7563 gdb::unique_xmalloc_ptr
<char> debug_filename
;
7564 static const char artificial
[] = "<artificial>";
7565 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
7566 if (filename
== NULL
)
7568 else if (strcmp (filename
, artificial
) == 0)
7570 debug_filename
.reset (concat (artificial
, "@",
7571 sect_offset_str (per_cu
->sect_off
),
7573 filename
= debug_filename
.get ();
7576 pst
= create_partial_symtab (per_cu
, per_objfile
, filename
);
7578 /* This must be done before calling dwarf2_build_include_psymtabs. */
7579 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7581 baseaddr
= objfile
->text_section_offset ();
7583 dwarf2_find_base_address (comp_unit_die
, cu
);
7585 /* Possibly set the default values of LOWPC and HIGHPC from
7587 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
7588 &best_highpc
, cu
, pst
);
7589 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
7592 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
7595 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
7597 /* Store the contiguous range if it is not empty; it can be
7598 empty for CUs with no code. */
7599 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
7603 /* Check if comp unit has_children.
7604 If so, read the rest of the partial symbols from this comp unit.
7605 If not, there's no more debug_info for this comp unit. */
7606 if (comp_unit_die
->has_children
)
7608 struct partial_die_info
*first_die
;
7609 CORE_ADDR lowpc
, highpc
;
7611 lowpc
= ((CORE_ADDR
) -1);
7612 highpc
= ((CORE_ADDR
) 0);
7614 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7616 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
7617 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
7619 /* If we didn't find a lowpc, set it to highpc to avoid
7620 complaints from `maint check'. */
7621 if (lowpc
== ((CORE_ADDR
) -1))
7624 /* If the compilation unit didn't have an explicit address range,
7625 then use the information extracted from its child dies. */
7626 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
7629 best_highpc
= highpc
;
7632 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
7633 best_lowpc
+ baseaddr
)
7635 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
7636 best_highpc
+ baseaddr
)
7639 end_psymtab_common (objfile
, pst
);
7641 if (!cu
->per_cu
->imported_symtabs_empty ())
7644 int len
= cu
->per_cu
->imported_symtabs_size ();
7646 /* Fill in 'dependencies' here; we fill in 'users' in a
7648 pst
->number_of_dependencies
= len
;
7650 = objfile
->partial_symtabs
->allocate_dependencies (len
);
7651 for (i
= 0; i
< len
; ++i
)
7653 pst
->dependencies
[i
]
7654 = cu
->per_cu
->imported_symtabs
->at (i
)->v
.psymtab
;
7657 cu
->per_cu
->imported_symtabs_free ();
7660 /* Get the list of files included in the current compilation unit,
7661 and build a psymtab for each of them. */
7662 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
7664 if (dwarf_read_debug
)
7665 fprintf_unfiltered (gdb_stdlog
,
7666 "Psymtab for %s unit @%s: %s - %s"
7667 ", %d global, %d static syms\n",
7668 per_cu
->is_debug_types
? "type" : "comp",
7669 sect_offset_str (per_cu
->sect_off
),
7670 paddress (gdbarch
, pst
->text_low (objfile
)),
7671 paddress (gdbarch
, pst
->text_high (objfile
)),
7672 (int) pst
->global_psymbols
.size (),
7673 (int) pst
->static_psymbols
.size ());
7676 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7677 Process compilation unit THIS_CU for a psymtab. */
7680 process_psymtab_comp_unit (dwarf2_per_cu_data
*this_cu
,
7681 dwarf2_per_objfile
*per_objfile
,
7682 bool want_partial_unit
,
7683 enum language pretend_language
)
7685 /* If this compilation unit was already read in, free the
7686 cached copy in order to read it in again. This is
7687 necessary because we skipped some symbols when we first
7688 read in the compilation unit (see load_partial_dies).
7689 This problem could be avoided, but the benefit is unclear. */
7690 per_objfile
->remove_cu (this_cu
);
7692 cutu_reader
reader (this_cu
, per_objfile
, nullptr, nullptr, false);
7694 switch (reader
.comp_unit_die
->tag
)
7696 case DW_TAG_compile_unit
:
7697 this_cu
->unit_type
= DW_UT_compile
;
7699 case DW_TAG_partial_unit
:
7700 this_cu
->unit_type
= DW_UT_partial
;
7710 else if (this_cu
->is_debug_types
)
7711 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7712 reader
.comp_unit_die
);
7713 else if (want_partial_unit
7714 || reader
.comp_unit_die
->tag
!= DW_TAG_partial_unit
)
7715 process_psymtab_comp_unit_reader (&reader
, reader
.info_ptr
,
7716 reader
.comp_unit_die
,
7719 this_cu
->lang
= reader
.cu
->language
;
7721 /* Age out any secondary CUs. */
7722 per_objfile
->age_comp_units ();
7725 /* Reader function for build_type_psymtabs. */
7728 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
7729 const gdb_byte
*info_ptr
,
7730 struct die_info
*type_unit_die
)
7732 dwarf2_per_objfile
*per_objfile
= reader
->cu
->per_objfile
;
7733 struct objfile
*objfile
= per_objfile
->objfile
;
7734 struct dwarf2_cu
*cu
= reader
->cu
;
7735 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7736 struct signatured_type
*sig_type
;
7737 struct type_unit_group
*tu_group
;
7738 struct attribute
*attr
;
7739 struct partial_die_info
*first_die
;
7740 CORE_ADDR lowpc
, highpc
;
7741 dwarf2_psymtab
*pst
;
7743 gdb_assert (per_cu
->is_debug_types
);
7744 sig_type
= (struct signatured_type
*) per_cu
;
7746 if (! type_unit_die
->has_children
)
7749 attr
= type_unit_die
->attr (DW_AT_stmt_list
);
7750 tu_group
= get_type_unit_group (cu
, attr
);
7752 if (tu_group
->tus
== nullptr)
7753 tu_group
->tus
= new std::vector
<signatured_type
*>;
7754 tu_group
->tus
->push_back (sig_type
);
7756 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
7757 pst
= create_partial_symtab (per_cu
, per_objfile
, "");
7758 pst
->anonymous
= true;
7760 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7762 lowpc
= (CORE_ADDR
) -1;
7763 highpc
= (CORE_ADDR
) 0;
7764 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
7766 end_psymtab_common (objfile
, pst
);
7769 /* Struct used to sort TUs by their abbreviation table offset. */
7771 struct tu_abbrev_offset
7773 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
7774 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
7777 signatured_type
*sig_type
;
7778 sect_offset abbrev_offset
;
7781 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
7784 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset
&a
,
7785 const struct tu_abbrev_offset
&b
)
7787 return a
.abbrev_offset
< b
.abbrev_offset
;
7790 /* Efficiently read all the type units.
7791 This does the bulk of the work for build_type_psymtabs.
7793 The efficiency is because we sort TUs by the abbrev table they use and
7794 only read each abbrev table once. In one program there are 200K TUs
7795 sharing 8K abbrev tables.
7797 The main purpose of this function is to support building the
7798 dwarf2_per_objfile->per_bfd->type_unit_groups table.
7799 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
7800 can collapse the search space by grouping them by stmt_list.
7801 The savings can be significant, in the same program from above the 200K TUs
7802 share 8K stmt_list tables.
7804 FUNC is expected to call get_type_unit_group, which will create the
7805 struct type_unit_group if necessary and add it to
7806 dwarf2_per_objfile->per_bfd->type_unit_groups. */
7809 build_type_psymtabs_1 (dwarf2_per_objfile
*per_objfile
)
7811 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7812 abbrev_table_up abbrev_table
;
7813 sect_offset abbrev_offset
;
7815 /* It's up to the caller to not call us multiple times. */
7816 gdb_assert (per_objfile
->per_bfd
->type_unit_groups
== NULL
);
7818 if (per_objfile
->per_bfd
->all_type_units
.empty ())
7821 /* TUs typically share abbrev tables, and there can be way more TUs than
7822 abbrev tables. Sort by abbrev table to reduce the number of times we
7823 read each abbrev table in.
7824 Alternatives are to punt or to maintain a cache of abbrev tables.
7825 This is simpler and efficient enough for now.
7827 Later we group TUs by their DW_AT_stmt_list value (as this defines the
7828 symtab to use). Typically TUs with the same abbrev offset have the same
7829 stmt_list value too so in practice this should work well.
7831 The basic algorithm here is:
7833 sort TUs by abbrev table
7834 for each TU with same abbrev table:
7835 read abbrev table if first user
7836 read TU top level DIE
7837 [IWBN if DWO skeletons had DW_AT_stmt_list]
7840 if (dwarf_read_debug
)
7841 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
7843 /* Sort in a separate table to maintain the order of all_type_units
7844 for .gdb_index: TU indices directly index all_type_units. */
7845 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
7846 sorted_by_abbrev
.reserve (per_objfile
->per_bfd
->all_type_units
.size ());
7848 for (signatured_type
*sig_type
: per_objfile
->per_bfd
->all_type_units
)
7849 sorted_by_abbrev
.emplace_back
7850 (sig_type
, read_abbrev_offset (per_objfile
, sig_type
->per_cu
.section
,
7851 sig_type
->per_cu
.sect_off
));
7853 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end (),
7854 sort_tu_by_abbrev_offset
);
7856 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
7858 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
7860 /* Switch to the next abbrev table if necessary. */
7861 if (abbrev_table
== NULL
7862 || tu
.abbrev_offset
!= abbrev_offset
)
7864 abbrev_offset
= tu
.abbrev_offset
;
7866 abbrev_table::read (per_objfile
->objfile
,
7867 &per_objfile
->per_bfd
->abbrev
, abbrev_offset
);
7868 ++tu_stats
->nr_uniq_abbrev_tables
;
7871 cutu_reader
reader (&tu
.sig_type
->per_cu
, per_objfile
,
7872 abbrev_table
.get (), nullptr, false);
7873 if (!reader
.dummy_p
)
7874 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7875 reader
.comp_unit_die
);
7879 /* Print collected type unit statistics. */
7882 print_tu_stats (dwarf2_per_objfile
*per_objfile
)
7884 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7886 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
7887 fprintf_unfiltered (gdb_stdlog
, " %zu TUs\n",
7888 per_objfile
->per_bfd
->all_type_units
.size ());
7889 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
7890 tu_stats
->nr_uniq_abbrev_tables
);
7891 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
7892 tu_stats
->nr_symtabs
);
7893 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
7894 tu_stats
->nr_symtab_sharers
);
7895 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
7896 tu_stats
->nr_stmt_less_type_units
);
7897 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
7898 tu_stats
->nr_all_type_units_reallocs
);
7901 /* Traversal function for build_type_psymtabs. */
7904 build_type_psymtab_dependencies (void **slot
, void *info
)
7906 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7907 struct objfile
*objfile
= per_objfile
->objfile
;
7908 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
7909 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
7910 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
7911 int len
= (tu_group
->tus
== nullptr) ? 0 : tu_group
->tus
->size ();
7914 gdb_assert (len
> 0);
7915 gdb_assert (per_cu
->type_unit_group_p ());
7917 pst
->number_of_dependencies
= len
;
7918 pst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (len
);
7919 for (i
= 0; i
< len
; ++i
)
7921 struct signatured_type
*iter
= tu_group
->tus
->at (i
);
7922 gdb_assert (iter
->per_cu
.is_debug_types
);
7923 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
7924 iter
->type_unit_group
= tu_group
;
7927 delete tu_group
->tus
;
7928 tu_group
->tus
= nullptr;
7933 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7934 Build partial symbol tables for the .debug_types comp-units. */
7937 build_type_psymtabs (dwarf2_per_objfile
*per_objfile
)
7939 if (! create_all_type_units (per_objfile
))
7942 build_type_psymtabs_1 (per_objfile
);
7945 /* Traversal function for process_skeletonless_type_unit.
7946 Read a TU in a DWO file and build partial symbols for it. */
7949 process_skeletonless_type_unit (void **slot
, void *info
)
7951 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
7952 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7953 struct signatured_type find_entry
, *entry
;
7955 /* If this TU doesn't exist in the global table, add it and read it in. */
7957 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
7958 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
7960 find_entry
.signature
= dwo_unit
->signature
;
7961 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
7962 &find_entry
, INSERT
);
7963 /* If we've already seen this type there's nothing to do. What's happening
7964 is we're doing our own version of comdat-folding here. */
7968 /* This does the job that create_all_type_units would have done for
7970 entry
= add_type_unit (per_objfile
, dwo_unit
->signature
, slot
);
7971 fill_in_sig_entry_from_dwo_entry (per_objfile
, entry
, dwo_unit
);
7974 /* This does the job that build_type_psymtabs_1 would have done. */
7975 cutu_reader
reader (&entry
->per_cu
, per_objfile
, nullptr, nullptr, false);
7976 if (!reader
.dummy_p
)
7977 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7978 reader
.comp_unit_die
);
7983 /* Traversal function for process_skeletonless_type_units. */
7986 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
7988 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
7990 if (dwo_file
->tus
!= NULL
)
7991 htab_traverse_noresize (dwo_file
->tus
.get (),
7992 process_skeletonless_type_unit
, info
);
7997 /* Scan all TUs of DWO files, verifying we've processed them.
7998 This is needed in case a TU was emitted without its skeleton.
7999 Note: This can't be done until we know what all the DWO files are. */
8002 process_skeletonless_type_units (dwarf2_per_objfile
*per_objfile
)
8004 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8005 if (get_dwp_file (per_objfile
) == NULL
8006 && per_objfile
->per_bfd
->dwo_files
!= NULL
)
8008 htab_traverse_noresize (per_objfile
->per_bfd
->dwo_files
.get (),
8009 process_dwo_file_for_skeletonless_type_units
,
8014 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8017 set_partial_user (dwarf2_per_objfile
*per_objfile
)
8019 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
8021 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
8026 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
8028 /* Set the 'user' field only if it is not already set. */
8029 if (pst
->dependencies
[j
]->user
== NULL
)
8030 pst
->dependencies
[j
]->user
= pst
;
8035 /* Build the partial symbol table by doing a quick pass through the
8036 .debug_info and .debug_abbrev sections. */
8039 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
)
8041 struct objfile
*objfile
= per_objfile
->objfile
;
8043 if (dwarf_read_debug
)
8045 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
8046 objfile_name (objfile
));
8049 scoped_restore restore_reading_psyms
8050 = make_scoped_restore (&per_objfile
->per_bfd
->reading_partial_symbols
,
8053 per_objfile
->per_bfd
->info
.read (objfile
);
8055 /* Any cached compilation units will be linked by the per-objfile
8056 read_in_chain. Make sure to free them when we're done. */
8057 free_cached_comp_units
freer (per_objfile
);
8059 build_type_psymtabs (per_objfile
);
8061 create_all_comp_units (per_objfile
);
8063 /* Create a temporary address map on a temporary obstack. We later
8064 copy this to the final obstack. */
8065 auto_obstack temp_obstack
;
8067 scoped_restore save_psymtabs_addrmap
8068 = make_scoped_restore (&objfile
->partial_symtabs
->psymtabs_addrmap
,
8069 addrmap_create_mutable (&temp_obstack
));
8071 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
8073 if (per_cu
->v
.psymtab
!= NULL
)
8074 /* In case a forward DW_TAG_imported_unit has read the CU already. */
8076 process_psymtab_comp_unit (per_cu
, per_objfile
, false,
8080 /* This has to wait until we read the CUs, we need the list of DWOs. */
8081 process_skeletonless_type_units (per_objfile
);
8083 /* Now that all TUs have been processed we can fill in the dependencies. */
8084 if (per_objfile
->per_bfd
->type_unit_groups
!= NULL
)
8086 htab_traverse_noresize (per_objfile
->per_bfd
->type_unit_groups
.get (),
8087 build_type_psymtab_dependencies
, per_objfile
);
8090 if (dwarf_read_debug
)
8091 print_tu_stats (per_objfile
);
8093 set_partial_user (per_objfile
);
8095 objfile
->partial_symtabs
->psymtabs_addrmap
8096 = addrmap_create_fixed (objfile
->partial_symtabs
->psymtabs_addrmap
,
8097 objfile
->partial_symtabs
->obstack ());
8098 /* At this point we want to keep the address map. */
8099 save_psymtabs_addrmap
.release ();
8101 if (dwarf_read_debug
)
8102 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
8103 objfile_name (objfile
));
8106 /* Load the partial DIEs for a secondary CU into memory.
8107 This is also used when rereading a primary CU with load_all_dies. */
8110 load_partial_comp_unit (dwarf2_per_cu_data
*this_cu
,
8111 dwarf2_per_objfile
*per_objfile
,
8112 dwarf2_cu
*existing_cu
)
8114 cutu_reader
reader (this_cu
, per_objfile
, nullptr, existing_cu
, false);
8116 if (!reader
.dummy_p
)
8118 prepare_one_comp_unit (reader
.cu
, reader
.comp_unit_die
,
8121 /* Check if comp unit has_children.
8122 If so, read the rest of the partial symbols from this comp unit.
8123 If not, there's no more debug_info for this comp unit. */
8124 if (reader
.comp_unit_die
->has_children
)
8125 load_partial_dies (&reader
, reader
.info_ptr
, 0);
8132 read_comp_units_from_section (dwarf2_per_objfile
*per_objfile
,
8133 struct dwarf2_section_info
*section
,
8134 struct dwarf2_section_info
*abbrev_section
,
8135 unsigned int is_dwz
)
8137 const gdb_byte
*info_ptr
;
8138 struct objfile
*objfile
= per_objfile
->objfile
;
8140 if (dwarf_read_debug
)
8141 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
8142 section
->get_name (),
8143 section
->get_file_name ());
8145 section
->read (objfile
);
8147 info_ptr
= section
->buffer
;
8149 while (info_ptr
< section
->buffer
+ section
->size
)
8151 struct dwarf2_per_cu_data
*this_cu
;
8153 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
8155 comp_unit_head cu_header
;
8156 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
8157 abbrev_section
, info_ptr
,
8158 rcuh_kind::COMPILE
);
8160 /* Save the compilation unit for later lookup. */
8161 if (cu_header
.unit_type
!= DW_UT_type
)
8162 this_cu
= per_objfile
->per_bfd
->allocate_per_cu ();
8165 auto sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
8166 sig_type
->signature
= cu_header
.signature
;
8167 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
8168 this_cu
= &sig_type
->per_cu
;
8170 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
8171 this_cu
->sect_off
= sect_off
;
8172 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
8173 this_cu
->is_dwz
= is_dwz
;
8174 this_cu
->section
= section
;
8176 per_objfile
->per_bfd
->all_comp_units
.push_back (this_cu
);
8178 info_ptr
= info_ptr
+ this_cu
->length
;
8182 /* Create a list of all compilation units in OBJFILE.
8183 This is only done for -readnow and building partial symtabs. */
8186 create_all_comp_units (dwarf2_per_objfile
*per_objfile
)
8188 gdb_assert (per_objfile
->per_bfd
->all_comp_units
.empty ());
8189 read_comp_units_from_section (per_objfile
, &per_objfile
->per_bfd
->info
,
8190 &per_objfile
->per_bfd
->abbrev
, 0);
8192 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
8194 read_comp_units_from_section (per_objfile
, &dwz
->info
, &dwz
->abbrev
, 1);
8197 /* Process all loaded DIEs for compilation unit CU, starting at
8198 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8199 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8200 DW_AT_ranges). See the comments of add_partial_subprogram on how
8201 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8204 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
8205 CORE_ADDR
*highpc
, int set_addrmap
,
8206 struct dwarf2_cu
*cu
)
8208 struct partial_die_info
*pdi
;
8210 /* Now, march along the PDI's, descending into ones which have
8211 interesting children but skipping the children of the other ones,
8212 until we reach the end of the compilation unit. */
8220 /* Anonymous namespaces or modules have no name but have interesting
8221 children, so we need to look at them. Ditto for anonymous
8224 if (pdi
->raw_name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
8225 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
8226 || pdi
->tag
== DW_TAG_imported_unit
8227 || pdi
->tag
== DW_TAG_inlined_subroutine
)
8231 case DW_TAG_subprogram
:
8232 case DW_TAG_inlined_subroutine
:
8233 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8234 if (cu
->language
== language_cplus
)
8235 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8238 case DW_TAG_constant
:
8239 case DW_TAG_variable
:
8240 case DW_TAG_typedef
:
8241 case DW_TAG_union_type
:
8242 if (!pdi
->is_declaration
8243 || (pdi
->tag
== DW_TAG_variable
&& pdi
->is_external
))
8245 add_partial_symbol (pdi
, cu
);
8248 case DW_TAG_class_type
:
8249 case DW_TAG_interface_type
:
8250 case DW_TAG_structure_type
:
8251 if (!pdi
->is_declaration
)
8253 add_partial_symbol (pdi
, cu
);
8255 if ((cu
->language
== language_rust
8256 || cu
->language
== language_cplus
) && pdi
->has_children
)
8257 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8260 case DW_TAG_enumeration_type
:
8261 if (!pdi
->is_declaration
)
8262 add_partial_enumeration (pdi
, cu
);
8264 case DW_TAG_base_type
:
8265 case DW_TAG_subrange_type
:
8266 /* File scope base type definitions are added to the partial
8268 add_partial_symbol (pdi
, cu
);
8270 case DW_TAG_namespace
:
8271 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8274 if (!pdi
->is_declaration
)
8275 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8277 case DW_TAG_imported_unit
:
8279 struct dwarf2_per_cu_data
*per_cu
;
8281 /* For now we don't handle imported units in type units. */
8282 if (cu
->per_cu
->is_debug_types
)
8284 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8285 " supported in type units [in module %s]"),
8286 objfile_name (cu
->per_objfile
->objfile
));
8289 per_cu
= dwarf2_find_containing_comp_unit
8290 (pdi
->d
.sect_off
, pdi
->is_dwz
, cu
->per_objfile
);
8292 /* Go read the partial unit, if needed. */
8293 if (per_cu
->v
.psymtab
== NULL
)
8294 process_psymtab_comp_unit (per_cu
, cu
->per_objfile
, true,
8297 cu
->per_cu
->imported_symtabs_push (per_cu
);
8300 case DW_TAG_imported_declaration
:
8301 add_partial_symbol (pdi
, cu
);
8308 /* If the die has a sibling, skip to the sibling. */
8310 pdi
= pdi
->die_sibling
;
8314 /* Functions used to compute the fully scoped name of a partial DIE.
8316 Normally, this is simple. For C++, the parent DIE's fully scoped
8317 name is concatenated with "::" and the partial DIE's name.
8318 Enumerators are an exception; they use the scope of their parent
8319 enumeration type, i.e. the name of the enumeration type is not
8320 prepended to the enumerator.
8322 There are two complexities. One is DW_AT_specification; in this
8323 case "parent" means the parent of the target of the specification,
8324 instead of the direct parent of the DIE. The other is compilers
8325 which do not emit DW_TAG_namespace; in this case we try to guess
8326 the fully qualified name of structure types from their members'
8327 linkage names. This must be done using the DIE's children rather
8328 than the children of any DW_AT_specification target. We only need
8329 to do this for structures at the top level, i.e. if the target of
8330 any DW_AT_specification (if any; otherwise the DIE itself) does not
8333 /* Compute the scope prefix associated with PDI's parent, in
8334 compilation unit CU. The result will be allocated on CU's
8335 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8336 field. NULL is returned if no prefix is necessary. */
8338 partial_die_parent_scope (struct partial_die_info
*pdi
,
8339 struct dwarf2_cu
*cu
)
8341 const char *grandparent_scope
;
8342 struct partial_die_info
*parent
, *real_pdi
;
8344 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8345 then this means the parent of the specification DIE. */
8348 while (real_pdi
->has_specification
)
8350 auto res
= find_partial_die (real_pdi
->spec_offset
,
8351 real_pdi
->spec_is_dwz
, cu
);
8356 parent
= real_pdi
->die_parent
;
8360 if (parent
->scope_set
)
8361 return parent
->scope
;
8365 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
8367 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8368 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8369 Work around this problem here. */
8370 if (cu
->language
== language_cplus
8371 && parent
->tag
== DW_TAG_namespace
8372 && strcmp (parent
->name (cu
), "::") == 0
8373 && grandparent_scope
== NULL
)
8375 parent
->scope
= NULL
;
8376 parent
->scope_set
= 1;
8380 /* Nested subroutines in Fortran get a prefix. */
8381 if (pdi
->tag
== DW_TAG_enumerator
)
8382 /* Enumerators should not get the name of the enumeration as a prefix. */
8383 parent
->scope
= grandparent_scope
;
8384 else if (parent
->tag
== DW_TAG_namespace
8385 || parent
->tag
== DW_TAG_module
8386 || parent
->tag
== DW_TAG_structure_type
8387 || parent
->tag
== DW_TAG_class_type
8388 || parent
->tag
== DW_TAG_interface_type
8389 || parent
->tag
== DW_TAG_union_type
8390 || parent
->tag
== DW_TAG_enumeration_type
8391 || (cu
->language
== language_fortran
8392 && parent
->tag
== DW_TAG_subprogram
8393 && pdi
->tag
== DW_TAG_subprogram
))
8395 if (grandparent_scope
== NULL
)
8396 parent
->scope
= parent
->name (cu
);
8398 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
8400 parent
->name (cu
), 0, cu
);
8404 /* FIXME drow/2004-04-01: What should we be doing with
8405 function-local names? For partial symbols, we should probably be
8407 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8408 dwarf_tag_name (parent
->tag
),
8409 sect_offset_str (pdi
->sect_off
));
8410 parent
->scope
= grandparent_scope
;
8413 parent
->scope_set
= 1;
8414 return parent
->scope
;
8417 /* Return the fully scoped name associated with PDI, from compilation unit
8418 CU. The result will be allocated with malloc. */
8420 static gdb::unique_xmalloc_ptr
<char>
8421 partial_die_full_name (struct partial_die_info
*pdi
,
8422 struct dwarf2_cu
*cu
)
8424 const char *parent_scope
;
8426 /* If this is a template instantiation, we can not work out the
8427 template arguments from partial DIEs. So, unfortunately, we have
8428 to go through the full DIEs. At least any work we do building
8429 types here will be reused if full symbols are loaded later. */
8430 if (pdi
->has_template_arguments
)
8434 if (pdi
->name (cu
) != NULL
&& strchr (pdi
->name (cu
), '<') == NULL
)
8436 struct die_info
*die
;
8437 struct attribute attr
;
8438 struct dwarf2_cu
*ref_cu
= cu
;
8440 /* DW_FORM_ref_addr is using section offset. */
8441 attr
.name
= (enum dwarf_attribute
) 0;
8442 attr
.form
= DW_FORM_ref_addr
;
8443 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
8444 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
8446 return make_unique_xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
8450 parent_scope
= partial_die_parent_scope (pdi
, cu
);
8451 if (parent_scope
== NULL
)
8454 return gdb::unique_xmalloc_ptr
<char> (typename_concat (NULL
, parent_scope
,
8460 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
8462 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
8463 struct objfile
*objfile
= per_objfile
->objfile
;
8464 struct gdbarch
*gdbarch
= objfile
->arch ();
8466 const char *actual_name
= NULL
;
8469 baseaddr
= objfile
->text_section_offset ();
8471 gdb::unique_xmalloc_ptr
<char> built_actual_name
8472 = partial_die_full_name (pdi
, cu
);
8473 if (built_actual_name
!= NULL
)
8474 actual_name
= built_actual_name
.get ();
8476 if (actual_name
== NULL
)
8477 actual_name
= pdi
->name (cu
);
8479 partial_symbol psymbol
;
8480 memset (&psymbol
, 0, sizeof (psymbol
));
8481 psymbol
.ginfo
.set_language (cu
->language
, &objfile
->objfile_obstack
);
8482 psymbol
.ginfo
.section
= -1;
8484 /* The code below indicates that the psymbol should be installed by
8486 gdb::optional
<psymbol_placement
> where
;
8490 case DW_TAG_inlined_subroutine
:
8491 case DW_TAG_subprogram
:
8492 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
8494 if (pdi
->is_external
8495 || cu
->language
== language_ada
8496 || (cu
->language
== language_fortran
8497 && pdi
->die_parent
!= NULL
8498 && pdi
->die_parent
->tag
== DW_TAG_subprogram
))
8500 /* Normally, only "external" DIEs are part of the global scope.
8501 But in Ada and Fortran, we want to be able to access nested
8502 procedures globally. So all Ada and Fortran subprograms are
8503 stored in the global scope. */
8504 where
= psymbol_placement::GLOBAL
;
8507 where
= psymbol_placement::STATIC
;
8509 psymbol
.domain
= VAR_DOMAIN
;
8510 psymbol
.aclass
= LOC_BLOCK
;
8511 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8512 psymbol
.ginfo
.value
.address
= addr
;
8514 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8515 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
8517 case DW_TAG_constant
:
8518 psymbol
.domain
= VAR_DOMAIN
;
8519 psymbol
.aclass
= LOC_STATIC
;
8520 where
= (pdi
->is_external
8521 ? psymbol_placement::GLOBAL
8522 : psymbol_placement::STATIC
);
8524 case DW_TAG_variable
:
8526 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
8530 && !per_objfile
->per_bfd
->has_section_at_zero
)
8532 /* A global or static variable may also have been stripped
8533 out by the linker if unused, in which case its address
8534 will be nullified; do not add such variables into partial
8535 symbol table then. */
8537 else if (pdi
->is_external
)
8540 Don't enter into the minimal symbol tables as there is
8541 a minimal symbol table entry from the ELF symbols already.
8542 Enter into partial symbol table if it has a location
8543 descriptor or a type.
8544 If the location descriptor is missing, new_symbol will create
8545 a LOC_UNRESOLVED symbol, the address of the variable will then
8546 be determined from the minimal symbol table whenever the variable
8548 The address for the partial symbol table entry is not
8549 used by GDB, but it comes in handy for debugging partial symbol
8552 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8554 psymbol
.domain
= VAR_DOMAIN
;
8555 psymbol
.aclass
= LOC_STATIC
;
8556 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8557 psymbol
.ginfo
.value
.address
= addr
;
8558 where
= psymbol_placement::GLOBAL
;
8563 int has_loc
= pdi
->d
.locdesc
!= NULL
;
8565 /* Static Variable. Skip symbols whose value we cannot know (those
8566 without location descriptors or constant values). */
8567 if (!has_loc
&& !pdi
->has_const_value
)
8570 psymbol
.domain
= VAR_DOMAIN
;
8571 psymbol
.aclass
= LOC_STATIC
;
8572 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8574 psymbol
.ginfo
.value
.address
= addr
;
8575 where
= psymbol_placement::STATIC
;
8578 case DW_TAG_typedef
:
8579 case DW_TAG_base_type
:
8580 case DW_TAG_subrange_type
:
8581 psymbol
.domain
= VAR_DOMAIN
;
8582 psymbol
.aclass
= LOC_TYPEDEF
;
8583 where
= psymbol_placement::STATIC
;
8585 case DW_TAG_imported_declaration
:
8586 case DW_TAG_namespace
:
8587 psymbol
.domain
= VAR_DOMAIN
;
8588 psymbol
.aclass
= LOC_TYPEDEF
;
8589 where
= psymbol_placement::GLOBAL
;
8592 /* With Fortran 77 there might be a "BLOCK DATA" module
8593 available without any name. If so, we skip the module as it
8594 doesn't bring any value. */
8595 if (actual_name
!= nullptr)
8597 psymbol
.domain
= MODULE_DOMAIN
;
8598 psymbol
.aclass
= LOC_TYPEDEF
;
8599 where
= psymbol_placement::GLOBAL
;
8602 case DW_TAG_class_type
:
8603 case DW_TAG_interface_type
:
8604 case DW_TAG_structure_type
:
8605 case DW_TAG_union_type
:
8606 case DW_TAG_enumeration_type
:
8607 /* Skip external references. The DWARF standard says in the section
8608 about "Structure, Union, and Class Type Entries": "An incomplete
8609 structure, union or class type is represented by a structure,
8610 union or class entry that does not have a byte size attribute
8611 and that has a DW_AT_declaration attribute." */
8612 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
8615 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8616 static vs. global. */
8617 psymbol
.domain
= STRUCT_DOMAIN
;
8618 psymbol
.aclass
= LOC_TYPEDEF
;
8619 where
= (cu
->language
== language_cplus
8620 ? psymbol_placement::GLOBAL
8621 : psymbol_placement::STATIC
);
8623 case DW_TAG_enumerator
:
8624 psymbol
.domain
= VAR_DOMAIN
;
8625 psymbol
.aclass
= LOC_CONST
;
8626 where
= (cu
->language
== language_cplus
8627 ? psymbol_placement::GLOBAL
8628 : psymbol_placement::STATIC
);
8634 if (where
.has_value ())
8636 if (built_actual_name
!= nullptr)
8637 actual_name
= objfile
->intern (actual_name
);
8638 if (pdi
->linkage_name
== nullptr || cu
->language
== language_ada
)
8639 psymbol
.ginfo
.set_linkage_name (actual_name
);
8642 psymbol
.ginfo
.set_demangled_name (actual_name
,
8643 &objfile
->objfile_obstack
);
8644 psymbol
.ginfo
.set_linkage_name (pdi
->linkage_name
);
8646 cu
->per_cu
->v
.psymtab
->add_psymbol (psymbol
, *where
, objfile
);
8650 /* Read a partial die corresponding to a namespace; also, add a symbol
8651 corresponding to that namespace to the symbol table. NAMESPACE is
8652 the name of the enclosing namespace. */
8655 add_partial_namespace (struct partial_die_info
*pdi
,
8656 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8657 int set_addrmap
, struct dwarf2_cu
*cu
)
8659 /* Add a symbol for the namespace. */
8661 add_partial_symbol (pdi
, cu
);
8663 /* Now scan partial symbols in that namespace. */
8665 if (pdi
->has_children
)
8666 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8669 /* Read a partial die corresponding to a Fortran module. */
8672 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
8673 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
8675 /* Add a symbol for the namespace. */
8677 add_partial_symbol (pdi
, cu
);
8679 /* Now scan partial symbols in that module. */
8681 if (pdi
->has_children
)
8682 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8685 /* Read a partial die corresponding to a subprogram or an inlined
8686 subprogram and create a partial symbol for that subprogram.
8687 When the CU language allows it, this routine also defines a partial
8688 symbol for each nested subprogram that this subprogram contains.
8689 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
8690 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
8692 PDI may also be a lexical block, in which case we simply search
8693 recursively for subprograms defined inside that lexical block.
8694 Again, this is only performed when the CU language allows this
8695 type of definitions. */
8698 add_partial_subprogram (struct partial_die_info
*pdi
,
8699 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8700 int set_addrmap
, struct dwarf2_cu
*cu
)
8702 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
8704 if (pdi
->has_pc_info
)
8706 if (pdi
->lowpc
< *lowpc
)
8707 *lowpc
= pdi
->lowpc
;
8708 if (pdi
->highpc
> *highpc
)
8709 *highpc
= pdi
->highpc
;
8712 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8713 struct gdbarch
*gdbarch
= objfile
->arch ();
8715 CORE_ADDR this_highpc
;
8716 CORE_ADDR this_lowpc
;
8718 baseaddr
= objfile
->text_section_offset ();
8720 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8721 pdi
->lowpc
+ baseaddr
)
8724 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8725 pdi
->highpc
+ baseaddr
)
8727 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
8728 this_lowpc
, this_highpc
- 1,
8729 cu
->per_cu
->v
.psymtab
);
8733 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
8735 if (!pdi
->is_declaration
)
8736 /* Ignore subprogram DIEs that do not have a name, they are
8737 illegal. Do not emit a complaint at this point, we will
8738 do so when we convert this psymtab into a symtab. */
8740 add_partial_symbol (pdi
, cu
);
8744 if (! pdi
->has_children
)
8747 if (cu
->language
== language_ada
|| cu
->language
== language_fortran
)
8749 pdi
= pdi
->die_child
;
8753 if (pdi
->tag
== DW_TAG_subprogram
8754 || pdi
->tag
== DW_TAG_inlined_subroutine
8755 || pdi
->tag
== DW_TAG_lexical_block
)
8756 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8757 pdi
= pdi
->die_sibling
;
8762 /* Read a partial die corresponding to an enumeration type. */
8765 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
8766 struct dwarf2_cu
*cu
)
8768 struct partial_die_info
*pdi
;
8770 if (enum_pdi
->name (cu
) != NULL
)
8771 add_partial_symbol (enum_pdi
, cu
);
8773 pdi
= enum_pdi
->die_child
;
8776 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->raw_name
== NULL
)
8777 complaint (_("malformed enumerator DIE ignored"));
8779 add_partial_symbol (pdi
, cu
);
8780 pdi
= pdi
->die_sibling
;
8784 /* Return the initial uleb128 in the die at INFO_PTR. */
8787 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
8789 unsigned int bytes_read
;
8791 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8794 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
8795 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
8797 Return the corresponding abbrev, or NULL if the number is zero (indicating
8798 an empty DIE). In either case *BYTES_READ will be set to the length of
8799 the initial number. */
8801 static struct abbrev_info
*
8802 peek_die_abbrev (const die_reader_specs
&reader
,
8803 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
8805 dwarf2_cu
*cu
= reader
.cu
;
8806 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
8807 unsigned int abbrev_number
8808 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
8810 if (abbrev_number
== 0)
8813 abbrev_info
*abbrev
= reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
8816 error (_("Dwarf Error: Could not find abbrev number %d in %s"
8817 " at offset %s [in module %s]"),
8818 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
8819 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
8825 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8826 Returns a pointer to the end of a series of DIEs, terminated by an empty
8827 DIE. Any children of the skipped DIEs will also be skipped. */
8829 static const gdb_byte
*
8830 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
8834 unsigned int bytes_read
;
8835 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
8838 return info_ptr
+ bytes_read
;
8840 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
8844 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8845 INFO_PTR should point just after the initial uleb128 of a DIE, and the
8846 abbrev corresponding to that skipped uleb128 should be passed in
8847 ABBREV. Returns a pointer to this DIE's sibling, skipping any
8850 static const gdb_byte
*
8851 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
8852 struct abbrev_info
*abbrev
)
8854 unsigned int bytes_read
;
8855 struct attribute attr
;
8856 bfd
*abfd
= reader
->abfd
;
8857 struct dwarf2_cu
*cu
= reader
->cu
;
8858 const gdb_byte
*buffer
= reader
->buffer
;
8859 const gdb_byte
*buffer_end
= reader
->buffer_end
;
8860 unsigned int form
, i
;
8862 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
8864 /* The only abbrev we care about is DW_AT_sibling. */
8865 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
8867 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
8868 if (attr
.form
== DW_FORM_ref_addr
)
8869 complaint (_("ignoring absolute DW_AT_sibling"));
8872 sect_offset off
= attr
.get_ref_die_offset ();
8873 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
8875 if (sibling_ptr
< info_ptr
)
8876 complaint (_("DW_AT_sibling points backwards"));
8877 else if (sibling_ptr
> reader
->buffer_end
)
8878 reader
->die_section
->overflow_complaint ();
8884 /* If it isn't DW_AT_sibling, skip this attribute. */
8885 form
= abbrev
->attrs
[i
].form
;
8889 case DW_FORM_ref_addr
:
8890 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
8891 and later it is offset sized. */
8892 if (cu
->header
.version
== 2)
8893 info_ptr
+= cu
->header
.addr_size
;
8895 info_ptr
+= cu
->header
.offset_size
;
8897 case DW_FORM_GNU_ref_alt
:
8898 info_ptr
+= cu
->header
.offset_size
;
8901 info_ptr
+= cu
->header
.addr_size
;
8909 case DW_FORM_flag_present
:
8910 case DW_FORM_implicit_const
:
8927 case DW_FORM_ref_sig8
:
8930 case DW_FORM_data16
:
8933 case DW_FORM_string
:
8934 read_direct_string (abfd
, info_ptr
, &bytes_read
);
8935 info_ptr
+= bytes_read
;
8937 case DW_FORM_sec_offset
:
8939 case DW_FORM_GNU_strp_alt
:
8940 info_ptr
+= cu
->header
.offset_size
;
8942 case DW_FORM_exprloc
:
8944 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8945 info_ptr
+= bytes_read
;
8947 case DW_FORM_block1
:
8948 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
8950 case DW_FORM_block2
:
8951 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
8953 case DW_FORM_block4
:
8954 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
8960 case DW_FORM_ref_udata
:
8961 case DW_FORM_GNU_addr_index
:
8962 case DW_FORM_GNU_str_index
:
8963 case DW_FORM_rnglistx
:
8964 case DW_FORM_loclistx
:
8965 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
8967 case DW_FORM_indirect
:
8968 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8969 info_ptr
+= bytes_read
;
8970 /* We need to continue parsing from here, so just go back to
8972 goto skip_attribute
;
8975 error (_("Dwarf Error: Cannot handle %s "
8976 "in DWARF reader [in module %s]"),
8977 dwarf_form_name (form
),
8978 bfd_get_filename (abfd
));
8982 if (abbrev
->has_children
)
8983 return skip_children (reader
, info_ptr
);
8988 /* Locate ORIG_PDI's sibling.
8989 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
8991 static const gdb_byte
*
8992 locate_pdi_sibling (const struct die_reader_specs
*reader
,
8993 struct partial_die_info
*orig_pdi
,
8994 const gdb_byte
*info_ptr
)
8996 /* Do we know the sibling already? */
8998 if (orig_pdi
->sibling
)
8999 return orig_pdi
->sibling
;
9001 /* Are there any children to deal with? */
9003 if (!orig_pdi
->has_children
)
9006 /* Skip the children the long way. */
9008 return skip_children (reader
, info_ptr
);
9011 /* Expand this partial symbol table into a full symbol table. SELF is
9015 dwarf2_psymtab::read_symtab (struct objfile
*objfile
)
9017 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9019 gdb_assert (!per_objfile
->symtab_set_p (per_cu_data
));
9021 /* If this psymtab is constructed from a debug-only objfile, the
9022 has_section_at_zero flag will not necessarily be correct. We
9023 can get the correct value for this flag by looking at the data
9024 associated with the (presumably stripped) associated objfile. */
9025 if (objfile
->separate_debug_objfile_backlink
)
9027 dwarf2_per_objfile
*per_objfile_backlink
9028 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
9030 per_objfile
->per_bfd
->has_section_at_zero
9031 = per_objfile_backlink
->per_bfd
->has_section_at_zero
;
9034 expand_psymtab (objfile
);
9036 process_cu_includes (per_objfile
);
9039 /* Reading in full CUs. */
9041 /* Add PER_CU to the queue. */
9044 queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
9045 dwarf2_per_objfile
*per_objfile
,
9046 enum language pretend_language
)
9049 per_cu
->per_bfd
->queue
.emplace (per_cu
, per_objfile
, pretend_language
);
9052 /* If PER_CU is not yet queued, add it to the queue.
9053 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9055 The result is non-zero if PER_CU was queued, otherwise the result is zero
9056 meaning either PER_CU is already queued or it is already loaded.
9058 N.B. There is an invariant here that if a CU is queued then it is loaded.
9059 The caller is required to load PER_CU if we return non-zero. */
9062 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
9063 dwarf2_per_cu_data
*per_cu
,
9064 dwarf2_per_objfile
*per_objfile
,
9065 enum language pretend_language
)
9067 /* We may arrive here during partial symbol reading, if we need full
9068 DIEs to process an unusual case (e.g. template arguments). Do
9069 not queue PER_CU, just tell our caller to load its DIEs. */
9070 if (per_cu
->per_bfd
->reading_partial_symbols
)
9072 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9074 if (cu
== NULL
|| cu
->dies
== NULL
)
9079 /* Mark the dependence relation so that we don't flush PER_CU
9081 if (dependent_cu
!= NULL
)
9082 dwarf2_add_dependence (dependent_cu
, per_cu
);
9084 /* If it's already on the queue, we have nothing to do. */
9088 /* If the compilation unit is already loaded, just mark it as
9090 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9097 /* Add it to the queue. */
9098 queue_comp_unit (per_cu
, per_objfile
, pretend_language
);
9103 /* Process the queue. */
9106 process_queue (dwarf2_per_objfile
*per_objfile
)
9108 if (dwarf_read_debug
)
9110 fprintf_unfiltered (gdb_stdlog
,
9111 "Expanding one or more symtabs of objfile %s ...\n",
9112 objfile_name (per_objfile
->objfile
));
9115 /* The queue starts out with one item, but following a DIE reference
9116 may load a new CU, adding it to the end of the queue. */
9117 while (!per_objfile
->per_bfd
->queue
.empty ())
9119 dwarf2_queue_item
&item
= per_objfile
->per_bfd
->queue
.front ();
9120 dwarf2_per_cu_data
*per_cu
= item
.per_cu
;
9122 if (!per_objfile
->symtab_set_p (per_cu
))
9124 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9126 /* Skip dummy CUs. */
9129 unsigned int debug_print_threshold
;
9132 if (per_cu
->is_debug_types
)
9134 struct signatured_type
*sig_type
=
9135 (struct signatured_type
*) per_cu
;
9137 sprintf (buf
, "TU %s at offset %s",
9138 hex_string (sig_type
->signature
),
9139 sect_offset_str (per_cu
->sect_off
));
9140 /* There can be 100s of TUs.
9141 Only print them in verbose mode. */
9142 debug_print_threshold
= 2;
9146 sprintf (buf
, "CU at offset %s",
9147 sect_offset_str (per_cu
->sect_off
));
9148 debug_print_threshold
= 1;
9151 if (dwarf_read_debug
>= debug_print_threshold
)
9152 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
9154 if (per_cu
->is_debug_types
)
9155 process_full_type_unit (cu
, item
.pretend_language
);
9157 process_full_comp_unit (cu
, item
.pretend_language
);
9159 if (dwarf_read_debug
>= debug_print_threshold
)
9160 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
9165 per_objfile
->per_bfd
->queue
.pop ();
9168 if (dwarf_read_debug
)
9170 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
9171 objfile_name (per_objfile
->objfile
));
9175 /* Read in full symbols for PST, and anything it depends on. */
9178 dwarf2_psymtab::expand_psymtab (struct objfile
*objfile
)
9180 gdb_assert (!readin_p (objfile
));
9182 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9183 free_cached_comp_units
freer (per_objfile
);
9184 expand_dependencies (objfile
);
9186 dw2_do_instantiate_symtab (per_cu_data
, per_objfile
, false);
9187 gdb_assert (get_compunit_symtab (objfile
) != nullptr);
9190 /* See psympriv.h. */
9193 dwarf2_psymtab::readin_p (struct objfile
*objfile
) const
9195 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9196 return per_objfile
->symtab_set_p (per_cu_data
);
9199 /* See psympriv.h. */
9202 dwarf2_psymtab::get_compunit_symtab (struct objfile
*objfile
) const
9204 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9205 return per_objfile
->get_symtab (per_cu_data
);
9208 /* Trivial hash function for die_info: the hash value of a DIE
9209 is its offset in .debug_info for this objfile. */
9212 die_hash (const void *item
)
9214 const struct die_info
*die
= (const struct die_info
*) item
;
9216 return to_underlying (die
->sect_off
);
9219 /* Trivial comparison function for die_info structures: two DIEs
9220 are equal if they have the same offset. */
9223 die_eq (const void *item_lhs
, const void *item_rhs
)
9225 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
9226 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
9228 return die_lhs
->sect_off
== die_rhs
->sect_off
;
9231 /* Load the DIEs associated with PER_CU into memory.
9233 In some cases, the caller, while reading partial symbols, will need to load
9234 the full symbols for the CU for some reason. It will already have a
9235 dwarf2_cu object for THIS_CU and pass it as EXISTING_CU, so it can be re-used
9236 rather than creating a new one. */
9239 load_full_comp_unit (dwarf2_per_cu_data
*this_cu
,
9240 dwarf2_per_objfile
*per_objfile
,
9241 dwarf2_cu
*existing_cu
,
9243 enum language pretend_language
)
9245 gdb_assert (! this_cu
->is_debug_types
);
9247 cutu_reader
reader (this_cu
, per_objfile
, NULL
, existing_cu
, skip_partial
);
9251 struct dwarf2_cu
*cu
= reader
.cu
;
9252 const gdb_byte
*info_ptr
= reader
.info_ptr
;
9254 gdb_assert (cu
->die_hash
== NULL
);
9256 htab_create_alloc_ex (cu
->header
.length
/ 12,
9260 &cu
->comp_unit_obstack
,
9261 hashtab_obstack_allocate
,
9262 dummy_obstack_deallocate
);
9264 if (reader
.comp_unit_die
->has_children
)
9265 reader
.comp_unit_die
->child
9266 = read_die_and_siblings (&reader
, reader
.info_ptr
,
9267 &info_ptr
, reader
.comp_unit_die
);
9268 cu
->dies
= reader
.comp_unit_die
;
9269 /* comp_unit_die is not stored in die_hash, no need. */
9271 /* We try not to read any attributes in this function, because not
9272 all CUs needed for references have been loaded yet, and symbol
9273 table processing isn't initialized. But we have to set the CU language,
9274 or we won't be able to build types correctly.
9275 Similarly, if we do not read the producer, we can not apply
9276 producer-specific interpretation. */
9277 prepare_one_comp_unit (cu
, cu
->dies
, pretend_language
);
9282 /* Add a DIE to the delayed physname list. */
9285 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
9286 const char *name
, struct die_info
*die
,
9287 struct dwarf2_cu
*cu
)
9289 struct delayed_method_info mi
;
9291 mi
.fnfield_index
= fnfield_index
;
9295 cu
->method_list
.push_back (mi
);
9298 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9299 "const" / "volatile". If so, decrements LEN by the length of the
9300 modifier and return true. Otherwise return false. */
9304 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
9306 size_t mod_len
= sizeof (mod
) - 1;
9307 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
9315 /* Compute the physnames of any methods on the CU's method list.
9317 The computation of method physnames is delayed in order to avoid the
9318 (bad) condition that one of the method's formal parameters is of an as yet
9322 compute_delayed_physnames (struct dwarf2_cu
*cu
)
9324 /* Only C++ delays computing physnames. */
9325 if (cu
->method_list
.empty ())
9327 gdb_assert (cu
->language
== language_cplus
);
9329 for (const delayed_method_info
&mi
: cu
->method_list
)
9331 const char *physname
;
9332 struct fn_fieldlist
*fn_flp
9333 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
9334 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
9335 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
9336 = physname
? physname
: "";
9338 /* Since there's no tag to indicate whether a method is a
9339 const/volatile overload, extract that information out of the
9341 if (physname
!= NULL
)
9343 size_t len
= strlen (physname
);
9347 if (physname
[len
] == ')') /* shortcut */
9349 else if (check_modifier (physname
, len
, " const"))
9350 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
9351 else if (check_modifier (physname
, len
, " volatile"))
9352 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
9359 /* The list is no longer needed. */
9360 cu
->method_list
.clear ();
9363 /* Go objects should be embedded in a DW_TAG_module DIE,
9364 and it's not clear if/how imported objects will appear.
9365 To keep Go support simple until that's worked out,
9366 go back through what we've read and create something usable.
9367 We could do this while processing each DIE, and feels kinda cleaner,
9368 but that way is more invasive.
9369 This is to, for example, allow the user to type "p var" or "b main"
9370 without having to specify the package name, and allow lookups
9371 of module.object to work in contexts that use the expression
9375 fixup_go_packaging (struct dwarf2_cu
*cu
)
9377 gdb::unique_xmalloc_ptr
<char> package_name
;
9378 struct pending
*list
;
9381 for (list
= *cu
->get_builder ()->get_global_symbols ();
9385 for (i
= 0; i
< list
->nsyms
; ++i
)
9387 struct symbol
*sym
= list
->symbol
[i
];
9389 if (sym
->language () == language_go
9390 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
9392 gdb::unique_xmalloc_ptr
<char> this_package_name
9393 (go_symbol_package_name (sym
));
9395 if (this_package_name
== NULL
)
9397 if (package_name
== NULL
)
9398 package_name
= std::move (this_package_name
);
9401 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9402 if (strcmp (package_name
.get (), this_package_name
.get ()) != 0)
9403 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9404 (symbol_symtab (sym
) != NULL
9405 ? symtab_to_filename_for_display
9406 (symbol_symtab (sym
))
9407 : objfile_name (objfile
)),
9408 this_package_name
.get (), package_name
.get ());
9414 if (package_name
!= NULL
)
9416 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9417 const char *saved_package_name
= objfile
->intern (package_name
.get ());
9418 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9419 saved_package_name
);
9422 sym
= new (&objfile
->objfile_obstack
) symbol
;
9423 sym
->set_language (language_go
, &objfile
->objfile_obstack
);
9424 sym
->compute_and_set_names (saved_package_name
, false, objfile
->per_bfd
);
9425 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9426 e.g., "main" finds the "main" module and not C's main(). */
9427 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9428 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9429 SYMBOL_TYPE (sym
) = type
;
9431 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
9435 /* Allocate a fully-qualified name consisting of the two parts on the
9439 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
9441 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
9444 /* A helper that allocates a variant part to attach to a Rust enum
9445 type. OBSTACK is where the results should be allocated. TYPE is
9446 the type we're processing. DISCRIMINANT_INDEX is the index of the
9447 discriminant. It must be the index of one of the fields of TYPE,
9448 or -1 to mean there is no discriminant (univariant enum).
9449 DEFAULT_INDEX is the index of the default field; or -1 if there is
9450 no default. RANGES is indexed by "effective" field number (the
9451 field index, but omitting the discriminant and default fields) and
9452 must hold the discriminant values used by the variants. Note that
9453 RANGES must have a lifetime at least as long as OBSTACK -- either
9454 already allocated on it, or static. */
9457 alloc_rust_variant (struct obstack
*obstack
, struct type
*type
,
9458 int discriminant_index
, int default_index
,
9459 gdb::array_view
<discriminant_range
> ranges
)
9461 /* When DISCRIMINANT_INDEX == -1, we have a univariant enum. */
9462 gdb_assert (discriminant_index
== -1
9463 || (discriminant_index
>= 0
9464 && discriminant_index
< type
->num_fields ()));
9465 gdb_assert (default_index
== -1
9466 || (default_index
>= 0 && default_index
< type
->num_fields ()));
9468 /* We have one variant for each non-discriminant field. */
9469 int n_variants
= type
->num_fields ();
9470 if (discriminant_index
!= -1)
9473 variant
*variants
= new (obstack
) variant
[n_variants
];
9476 for (int i
= 0; i
< type
->num_fields (); ++i
)
9478 if (i
== discriminant_index
)
9481 variants
[var_idx
].first_field
= i
;
9482 variants
[var_idx
].last_field
= i
+ 1;
9484 /* The default field does not need a range, but other fields do.
9485 We skipped the discriminant above. */
9486 if (i
!= default_index
)
9488 variants
[var_idx
].discriminants
= ranges
.slice (range_idx
, 1);
9495 gdb_assert (range_idx
== ranges
.size ());
9496 gdb_assert (var_idx
== n_variants
);
9498 variant_part
*part
= new (obstack
) variant_part
;
9499 part
->discriminant_index
= discriminant_index
;
9500 /* If there is no discriminant, then whether it is signed is of no
9503 = (discriminant_index
== -1
9505 : type
->field (discriminant_index
).type ()->is_unsigned ());
9506 part
->variants
= gdb::array_view
<variant
> (variants
, n_variants
);
9508 void *storage
= obstack_alloc (obstack
, sizeof (gdb::array_view
<variant_part
>));
9509 gdb::array_view
<variant_part
> *prop_value
9510 = new (storage
) gdb::array_view
<variant_part
> (part
, 1);
9512 struct dynamic_prop prop
;
9513 prop
.set_variant_parts (prop_value
);
9515 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
9518 /* Some versions of rustc emitted enums in an unusual way.
9520 Ordinary enums were emitted as unions. The first element of each
9521 structure in the union was named "RUST$ENUM$DISR". This element
9522 held the discriminant.
9524 These versions of Rust also implemented the "non-zero"
9525 optimization. When the enum had two values, and one is empty and
9526 the other holds a pointer that cannot be zero, the pointer is used
9527 as the discriminant, with a zero value meaning the empty variant.
9528 Here, the union's first member is of the form
9529 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9530 where the fieldnos are the indices of the fields that should be
9531 traversed in order to find the field (which may be several fields deep)
9532 and the variantname is the name of the variant of the case when the
9535 This function recognizes whether TYPE is of one of these forms,
9536 and, if so, smashes it to be a variant type. */
9539 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
9541 gdb_assert (type
->code () == TYPE_CODE_UNION
);
9543 /* We don't need to deal with empty enums. */
9544 if (type
->num_fields () == 0)
9547 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9548 if (type
->num_fields () == 1
9549 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
9551 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
9553 /* Decode the field name to find the offset of the
9555 ULONGEST bit_offset
= 0;
9556 struct type
*field_type
= type
->field (0).type ();
9557 while (name
[0] >= '0' && name
[0] <= '9')
9560 unsigned long index
= strtoul (name
, &tail
, 10);
9563 || index
>= field_type
->num_fields ()
9564 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
9565 != FIELD_LOC_KIND_BITPOS
))
9567 complaint (_("Could not parse Rust enum encoding string \"%s\""
9569 TYPE_FIELD_NAME (type
, 0),
9570 objfile_name (objfile
));
9575 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
9576 field_type
= field_type
->field (index
).type ();
9579 /* Smash this type to be a structure type. We have to do this
9580 because the type has already been recorded. */
9581 type
->set_code (TYPE_CODE_STRUCT
);
9582 type
->set_num_fields (3);
9583 /* Save the field we care about. */
9584 struct field saved_field
= type
->field (0);
9586 ((struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
)));
9588 /* Put the discriminant at index 0. */
9589 type
->field (0).set_type (field_type
);
9590 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9591 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9592 SET_FIELD_BITPOS (type
->field (0), bit_offset
);
9594 /* The order of fields doesn't really matter, so put the real
9595 field at index 1 and the data-less field at index 2. */
9596 type
->field (1) = saved_field
;
9597 TYPE_FIELD_NAME (type
, 1)
9598 = rust_last_path_segment (type
->field (1).type ()->name ());
9599 type
->field (1).type ()->set_name
9600 (rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9601 TYPE_FIELD_NAME (type
, 1)));
9603 const char *dataless_name
9604 = rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9606 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
9608 type
->field (2).set_type (dataless_type
);
9609 /* NAME points into the original discriminant name, which
9610 already has the correct lifetime. */
9611 TYPE_FIELD_NAME (type
, 2) = name
;
9612 SET_FIELD_BITPOS (type
->field (2), 0);
9614 /* Indicate that this is a variant type. */
9615 static discriminant_range ranges
[1] = { { 0, 0 } };
9616 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, 1, ranges
);
9618 /* A union with a single anonymous field is probably an old-style
9620 else if (type
->num_fields () == 1 && streq (TYPE_FIELD_NAME (type
, 0), ""))
9622 /* Smash this type to be a structure type. We have to do this
9623 because the type has already been recorded. */
9624 type
->set_code (TYPE_CODE_STRUCT
);
9626 struct type
*field_type
= type
->field (0).type ();
9627 const char *variant_name
9628 = rust_last_path_segment (field_type
->name ());
9629 TYPE_FIELD_NAME (type
, 0) = variant_name
;
9630 field_type
->set_name
9631 (rust_fully_qualify (&objfile
->objfile_obstack
,
9632 type
->name (), variant_name
));
9634 alloc_rust_variant (&objfile
->objfile_obstack
, type
, -1, 0, {});
9638 struct type
*disr_type
= nullptr;
9639 for (int i
= 0; i
< type
->num_fields (); ++i
)
9641 disr_type
= type
->field (i
).type ();
9643 if (disr_type
->code () != TYPE_CODE_STRUCT
)
9645 /* All fields of a true enum will be structs. */
9648 else if (disr_type
->num_fields () == 0)
9650 /* Could be data-less variant, so keep going. */
9651 disr_type
= nullptr;
9653 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
9654 "RUST$ENUM$DISR") != 0)
9656 /* Not a Rust enum. */
9666 /* If we got here without a discriminant, then it's probably
9668 if (disr_type
== nullptr)
9671 /* Smash this type to be a structure type. We have to do this
9672 because the type has already been recorded. */
9673 type
->set_code (TYPE_CODE_STRUCT
);
9675 /* Make space for the discriminant field. */
9676 struct field
*disr_field
= &disr_type
->field (0);
9678 = (struct field
*) TYPE_ZALLOC (type
, ((type
->num_fields () + 1)
9679 * sizeof (struct field
)));
9680 memcpy (new_fields
+ 1, type
->fields (),
9681 type
->num_fields () * sizeof (struct field
));
9682 type
->set_fields (new_fields
);
9683 type
->set_num_fields (type
->num_fields () + 1);
9685 /* Install the discriminant at index 0 in the union. */
9686 type
->field (0) = *disr_field
;
9687 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9688 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9690 /* We need a way to find the correct discriminant given a
9691 variant name. For convenience we build a map here. */
9692 struct type
*enum_type
= disr_field
->type ();
9693 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
9694 for (int i
= 0; i
< enum_type
->num_fields (); ++i
)
9696 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
9699 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
9700 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
9704 int n_fields
= type
->num_fields ();
9705 /* We don't need a range entry for the discriminant, but we do
9706 need one for every other field, as there is no default
9708 discriminant_range
*ranges
= XOBNEWVEC (&objfile
->objfile_obstack
,
9711 /* Skip the discriminant here. */
9712 for (int i
= 1; i
< n_fields
; ++i
)
9714 /* Find the final word in the name of this variant's type.
9715 That name can be used to look up the correct
9717 const char *variant_name
9718 = rust_last_path_segment (type
->field (i
).type ()->name ());
9720 auto iter
= discriminant_map
.find (variant_name
);
9721 if (iter
!= discriminant_map
.end ())
9723 ranges
[i
- 1].low
= iter
->second
;
9724 ranges
[i
- 1].high
= iter
->second
;
9727 /* In Rust, each element should have the size of the
9729 TYPE_LENGTH (type
->field (i
).type ()) = TYPE_LENGTH (type
);
9731 /* Remove the discriminant field, if it exists. */
9732 struct type
*sub_type
= type
->field (i
).type ();
9733 if (sub_type
->num_fields () > 0)
9735 sub_type
->set_num_fields (sub_type
->num_fields () - 1);
9736 sub_type
->set_fields (sub_type
->fields () + 1);
9738 TYPE_FIELD_NAME (type
, i
) = variant_name
;
9740 (rust_fully_qualify (&objfile
->objfile_obstack
,
9741 type
->name (), variant_name
));
9744 /* Indicate that this is a variant type. */
9745 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, -1,
9746 gdb::array_view
<discriminant_range
> (ranges
,
9751 /* Rewrite some Rust unions to be structures with variants parts. */
9754 rust_union_quirks (struct dwarf2_cu
*cu
)
9756 gdb_assert (cu
->language
== language_rust
);
9757 for (type
*type_
: cu
->rust_unions
)
9758 quirk_rust_enum (type_
, cu
->per_objfile
->objfile
);
9759 /* We don't need this any more. */
9760 cu
->rust_unions
.clear ();
9765 type_unit_group_unshareable
*
9766 dwarf2_per_objfile::get_type_unit_group_unshareable (type_unit_group
*tu_group
)
9768 auto iter
= this->m_type_units
.find (tu_group
);
9769 if (iter
!= this->m_type_units
.end ())
9770 return iter
->second
.get ();
9772 type_unit_group_unshareable_up
uniq (new type_unit_group_unshareable
);
9773 type_unit_group_unshareable
*result
= uniq
.get ();
9774 this->m_type_units
[tu_group
] = std::move (uniq
);
9779 dwarf2_per_objfile::get_type_for_signatured_type
9780 (signatured_type
*sig_type
) const
9782 auto iter
= this->m_type_map
.find (sig_type
);
9783 if (iter
== this->m_type_map
.end ())
9786 return iter
->second
;
9789 void dwarf2_per_objfile::set_type_for_signatured_type
9790 (signatured_type
*sig_type
, struct type
*type
)
9792 gdb_assert (this->m_type_map
.find (sig_type
) == this->m_type_map
.end ());
9794 this->m_type_map
[sig_type
] = type
;
9797 /* A helper function for computing the list of all symbol tables
9798 included by PER_CU. */
9801 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
9802 htab_t all_children
, htab_t all_type_symtabs
,
9803 dwarf2_per_cu_data
*per_cu
,
9804 dwarf2_per_objfile
*per_objfile
,
9805 struct compunit_symtab
*immediate_parent
)
9807 void **slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
9810 /* This inclusion and its children have been processed. */
9816 /* Only add a CU if it has a symbol table. */
9817 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9820 /* If this is a type unit only add its symbol table if we haven't
9821 seen it yet (type unit per_cu's can share symtabs). */
9822 if (per_cu
->is_debug_types
)
9824 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
9828 result
->push_back (cust
);
9829 if (cust
->user
== NULL
)
9830 cust
->user
= immediate_parent
;
9835 result
->push_back (cust
);
9836 if (cust
->user
== NULL
)
9837 cust
->user
= immediate_parent
;
9841 if (!per_cu
->imported_symtabs_empty ())
9842 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9844 recursively_compute_inclusions (result
, all_children
,
9845 all_type_symtabs
, ptr
, per_objfile
,
9850 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
9854 compute_compunit_symtab_includes (dwarf2_per_cu_data
*per_cu
,
9855 dwarf2_per_objfile
*per_objfile
)
9857 gdb_assert (! per_cu
->is_debug_types
);
9859 if (!per_cu
->imported_symtabs_empty ())
9862 std::vector
<compunit_symtab
*> result_symtabs
;
9863 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9865 /* If we don't have a symtab, we can just skip this case. */
9869 htab_up
all_children (htab_create_alloc (1, htab_hash_pointer
,
9871 NULL
, xcalloc
, xfree
));
9872 htab_up
all_type_symtabs (htab_create_alloc (1, htab_hash_pointer
,
9874 NULL
, xcalloc
, xfree
));
9876 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9878 recursively_compute_inclusions (&result_symtabs
, all_children
.get (),
9879 all_type_symtabs
.get (), ptr
,
9883 /* Now we have a transitive closure of all the included symtabs. */
9884 len
= result_symtabs
.size ();
9886 = XOBNEWVEC (&per_objfile
->objfile
->objfile_obstack
,
9887 struct compunit_symtab
*, len
+ 1);
9888 memcpy (cust
->includes
, result_symtabs
.data (),
9889 len
* sizeof (compunit_symtab
*));
9890 cust
->includes
[len
] = NULL
;
9894 /* Compute the 'includes' field for the symtabs of all the CUs we just
9898 process_cu_includes (dwarf2_per_objfile
*per_objfile
)
9900 for (dwarf2_per_cu_data
*iter
: per_objfile
->per_bfd
->just_read_cus
)
9902 if (! iter
->is_debug_types
)
9903 compute_compunit_symtab_includes (iter
, per_objfile
);
9906 per_objfile
->per_bfd
->just_read_cus
.clear ();
9909 /* Generate full symbol information for CU, whose DIEs have
9910 already been loaded into memory. */
9913 process_full_comp_unit (dwarf2_cu
*cu
, enum language pretend_language
)
9915 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9916 struct objfile
*objfile
= per_objfile
->objfile
;
9917 struct gdbarch
*gdbarch
= objfile
->arch ();
9918 CORE_ADDR lowpc
, highpc
;
9919 struct compunit_symtab
*cust
;
9921 struct block
*static_block
;
9924 baseaddr
= objfile
->text_section_offset ();
9926 /* Clear the list here in case something was left over. */
9927 cu
->method_list
.clear ();
9929 cu
->language
= pretend_language
;
9930 cu
->language_defn
= language_def (cu
->language
);
9932 dwarf2_find_base_address (cu
->dies
, cu
);
9934 /* Do line number decoding in read_file_scope () */
9935 process_die (cu
->dies
, cu
);
9937 /* For now fudge the Go package. */
9938 if (cu
->language
== language_go
)
9939 fixup_go_packaging (cu
);
9941 /* Now that we have processed all the DIEs in the CU, all the types
9942 should be complete, and it should now be safe to compute all of the
9944 compute_delayed_physnames (cu
);
9946 if (cu
->language
== language_rust
)
9947 rust_union_quirks (cu
);
9949 /* Some compilers don't define a DW_AT_high_pc attribute for the
9950 compilation unit. If the DW_AT_high_pc is missing, synthesize
9951 it, by scanning the DIE's below the compilation unit. */
9952 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
9954 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
9955 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
9957 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
9958 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
9959 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
9960 addrmap to help ensure it has an accurate map of pc values belonging to
9962 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
9964 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
9965 SECT_OFF_TEXT (objfile
),
9970 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
9972 /* Set symtab language to language from DW_AT_language. If the
9973 compilation is from a C file generated by language preprocessors, do
9974 not set the language if it was already deduced by start_subfile. */
9975 if (!(cu
->language
== language_c
9976 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
9977 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
9979 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
9980 produce DW_AT_location with location lists but it can be possibly
9981 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
9982 there were bugs in prologue debug info, fixed later in GCC-4.5
9983 by "unwind info for epilogues" patch (which is not directly related).
9985 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
9986 needed, it would be wrong due to missing DW_AT_producer there.
9988 Still one can confuse GDB by using non-standard GCC compilation
9989 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
9991 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
9992 cust
->locations_valid
= 1;
9994 if (gcc_4_minor
>= 5)
9995 cust
->epilogue_unwind_valid
= 1;
9997 cust
->call_site_htab
= cu
->call_site_htab
;
10000 per_objfile
->set_symtab (cu
->per_cu
, cust
);
10002 /* Push it for inclusion processing later. */
10003 per_objfile
->per_bfd
->just_read_cus
.push_back (cu
->per_cu
);
10005 /* Not needed any more. */
10006 cu
->reset_builder ();
10009 /* Generate full symbol information for type unit CU, whose DIEs have
10010 already been loaded into memory. */
10013 process_full_type_unit (dwarf2_cu
*cu
,
10014 enum language pretend_language
)
10016 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10017 struct objfile
*objfile
= per_objfile
->objfile
;
10018 struct compunit_symtab
*cust
;
10019 struct signatured_type
*sig_type
;
10021 gdb_assert (cu
->per_cu
->is_debug_types
);
10022 sig_type
= (struct signatured_type
*) cu
->per_cu
;
10024 /* Clear the list here in case something was left over. */
10025 cu
->method_list
.clear ();
10027 cu
->language
= pretend_language
;
10028 cu
->language_defn
= language_def (cu
->language
);
10030 /* The symbol tables are set up in read_type_unit_scope. */
10031 process_die (cu
->dies
, cu
);
10033 /* For now fudge the Go package. */
10034 if (cu
->language
== language_go
)
10035 fixup_go_packaging (cu
);
10037 /* Now that we have processed all the DIEs in the CU, all the types
10038 should be complete, and it should now be safe to compute all of the
10040 compute_delayed_physnames (cu
);
10042 if (cu
->language
== language_rust
)
10043 rust_union_quirks (cu
);
10045 /* TUs share symbol tables.
10046 If this is the first TU to use this symtab, complete the construction
10047 of it with end_expandable_symtab. Otherwise, complete the addition of
10048 this TU's symbols to the existing symtab. */
10049 type_unit_group_unshareable
*tug_unshare
=
10050 per_objfile
->get_type_unit_group_unshareable (sig_type
->type_unit_group
);
10051 if (tug_unshare
->compunit_symtab
== NULL
)
10053 buildsym_compunit
*builder
= cu
->get_builder ();
10054 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
10055 tug_unshare
->compunit_symtab
= cust
;
10059 /* Set symtab language to language from DW_AT_language. If the
10060 compilation is from a C file generated by language preprocessors,
10061 do not set the language if it was already deduced by
10063 if (!(cu
->language
== language_c
10064 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
10065 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10070 cu
->get_builder ()->augment_type_symtab ();
10071 cust
= tug_unshare
->compunit_symtab
;
10074 per_objfile
->set_symtab (cu
->per_cu
, cust
);
10076 /* Not needed any more. */
10077 cu
->reset_builder ();
10080 /* Process an imported unit DIE. */
10083 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10085 struct attribute
*attr
;
10087 /* For now we don't handle imported units in type units. */
10088 if (cu
->per_cu
->is_debug_types
)
10090 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10091 " supported in type units [in module %s]"),
10092 objfile_name (cu
->per_objfile
->objfile
));
10095 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10098 sect_offset sect_off
= attr
->get_ref_die_offset ();
10099 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
10100 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10101 dwarf2_per_cu_data
*per_cu
10102 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
, per_objfile
);
10104 /* We're importing a C++ compilation unit with tag DW_TAG_compile_unit
10105 into another compilation unit, at root level. Regard this as a hint,
10107 if (die
->parent
&& die
->parent
->parent
== NULL
10108 && per_cu
->unit_type
== DW_UT_compile
10109 && per_cu
->lang
== language_cplus
)
10112 /* If necessary, add it to the queue and load its DIEs. */
10113 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
))
10114 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
10115 false, cu
->language
);
10117 cu
->per_cu
->imported_symtabs_push (per_cu
);
10121 /* RAII object that represents a process_die scope: i.e.,
10122 starts/finishes processing a DIE. */
10123 class process_die_scope
10126 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
10127 : m_die (die
), m_cu (cu
)
10129 /* We should only be processing DIEs not already in process. */
10130 gdb_assert (!m_die
->in_process
);
10131 m_die
->in_process
= true;
10134 ~process_die_scope ()
10136 m_die
->in_process
= false;
10138 /* If we're done processing the DIE for the CU that owns the line
10139 header, we don't need the line header anymore. */
10140 if (m_cu
->line_header_die_owner
== m_die
)
10142 delete m_cu
->line_header
;
10143 m_cu
->line_header
= NULL
;
10144 m_cu
->line_header_die_owner
= NULL
;
10153 /* Process a die and its children. */
10156 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10158 process_die_scope
scope (die
, cu
);
10162 case DW_TAG_padding
:
10164 case DW_TAG_compile_unit
:
10165 case DW_TAG_partial_unit
:
10166 read_file_scope (die
, cu
);
10168 case DW_TAG_type_unit
:
10169 read_type_unit_scope (die
, cu
);
10171 case DW_TAG_subprogram
:
10172 /* Nested subprograms in Fortran get a prefix. */
10173 if (cu
->language
== language_fortran
10174 && die
->parent
!= NULL
10175 && die
->parent
->tag
== DW_TAG_subprogram
)
10176 cu
->processing_has_namespace_info
= true;
10177 /* Fall through. */
10178 case DW_TAG_inlined_subroutine
:
10179 read_func_scope (die
, cu
);
10181 case DW_TAG_lexical_block
:
10182 case DW_TAG_try_block
:
10183 case DW_TAG_catch_block
:
10184 read_lexical_block_scope (die
, cu
);
10186 case DW_TAG_call_site
:
10187 case DW_TAG_GNU_call_site
:
10188 read_call_site_scope (die
, cu
);
10190 case DW_TAG_class_type
:
10191 case DW_TAG_interface_type
:
10192 case DW_TAG_structure_type
:
10193 case DW_TAG_union_type
:
10194 process_structure_scope (die
, cu
);
10196 case DW_TAG_enumeration_type
:
10197 process_enumeration_scope (die
, cu
);
10200 /* These dies have a type, but processing them does not create
10201 a symbol or recurse to process the children. Therefore we can
10202 read them on-demand through read_type_die. */
10203 case DW_TAG_subroutine_type
:
10204 case DW_TAG_set_type
:
10205 case DW_TAG_array_type
:
10206 case DW_TAG_pointer_type
:
10207 case DW_TAG_ptr_to_member_type
:
10208 case DW_TAG_reference_type
:
10209 case DW_TAG_rvalue_reference_type
:
10210 case DW_TAG_string_type
:
10213 case DW_TAG_base_type
:
10214 case DW_TAG_subrange_type
:
10215 case DW_TAG_typedef
:
10216 /* Add a typedef symbol for the type definition, if it has a
10218 new_symbol (die
, read_type_die (die
, cu
), cu
);
10220 case DW_TAG_common_block
:
10221 read_common_block (die
, cu
);
10223 case DW_TAG_common_inclusion
:
10225 case DW_TAG_namespace
:
10226 cu
->processing_has_namespace_info
= true;
10227 read_namespace (die
, cu
);
10229 case DW_TAG_module
:
10230 cu
->processing_has_namespace_info
= true;
10231 read_module (die
, cu
);
10233 case DW_TAG_imported_declaration
:
10234 cu
->processing_has_namespace_info
= true;
10235 if (read_namespace_alias (die
, cu
))
10237 /* The declaration is not a global namespace alias. */
10238 /* Fall through. */
10239 case DW_TAG_imported_module
:
10240 cu
->processing_has_namespace_info
= true;
10241 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
10242 || cu
->language
!= language_fortran
))
10243 complaint (_("Tag '%s' has unexpected children"),
10244 dwarf_tag_name (die
->tag
));
10245 read_import_statement (die
, cu
);
10248 case DW_TAG_imported_unit
:
10249 process_imported_unit_die (die
, cu
);
10252 case DW_TAG_variable
:
10253 read_variable (die
, cu
);
10257 new_symbol (die
, NULL
, cu
);
10262 /* DWARF name computation. */
10264 /* A helper function for dwarf2_compute_name which determines whether DIE
10265 needs to have the name of the scope prepended to the name listed in the
10269 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
10271 struct attribute
*attr
;
10275 case DW_TAG_namespace
:
10276 case DW_TAG_typedef
:
10277 case DW_TAG_class_type
:
10278 case DW_TAG_interface_type
:
10279 case DW_TAG_structure_type
:
10280 case DW_TAG_union_type
:
10281 case DW_TAG_enumeration_type
:
10282 case DW_TAG_enumerator
:
10283 case DW_TAG_subprogram
:
10284 case DW_TAG_inlined_subroutine
:
10285 case DW_TAG_member
:
10286 case DW_TAG_imported_declaration
:
10289 case DW_TAG_variable
:
10290 case DW_TAG_constant
:
10291 /* We only need to prefix "globally" visible variables. These include
10292 any variable marked with DW_AT_external or any variable that
10293 lives in a namespace. [Variables in anonymous namespaces
10294 require prefixing, but they are not DW_AT_external.] */
10296 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
10298 struct dwarf2_cu
*spec_cu
= cu
;
10300 return die_needs_namespace (die_specification (die
, &spec_cu
),
10304 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
10305 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
10306 && die
->parent
->tag
!= DW_TAG_module
)
10308 /* A variable in a lexical block of some kind does not need a
10309 namespace, even though in C++ such variables may be external
10310 and have a mangled name. */
10311 if (die
->parent
->tag
== DW_TAG_lexical_block
10312 || die
->parent
->tag
== DW_TAG_try_block
10313 || die
->parent
->tag
== DW_TAG_catch_block
10314 || die
->parent
->tag
== DW_TAG_subprogram
)
10323 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10324 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10325 defined for the given DIE. */
10327 static struct attribute
*
10328 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
10330 struct attribute
*attr
;
10332 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
10334 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10339 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10340 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10341 defined for the given DIE. */
10343 static const char *
10344 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10346 const char *linkage_name
;
10348 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
10349 if (linkage_name
== NULL
)
10350 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10352 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
10353 See https://github.com/rust-lang/rust/issues/32925. */
10354 if (cu
->language
== language_rust
&& linkage_name
!= NULL
10355 && strchr (linkage_name
, '{') != NULL
)
10356 linkage_name
= NULL
;
10358 return linkage_name
;
10361 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10362 compute the physname for the object, which include a method's:
10363 - formal parameters (C++),
10364 - receiver type (Go),
10366 The term "physname" is a bit confusing.
10367 For C++, for example, it is the demangled name.
10368 For Go, for example, it's the mangled name.
10370 For Ada, return the DIE's linkage name rather than the fully qualified
10371 name. PHYSNAME is ignored..
10373 The result is allocated on the objfile->per_bfd's obstack and
10376 static const char *
10377 dwarf2_compute_name (const char *name
,
10378 struct die_info
*die
, struct dwarf2_cu
*cu
,
10381 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10384 name
= dwarf2_name (die
, cu
);
10386 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10387 but otherwise compute it by typename_concat inside GDB.
10388 FIXME: Actually this is not really true, or at least not always true.
10389 It's all very confusing. compute_and_set_names doesn't try to demangle
10390 Fortran names because there is no mangling standard. So new_symbol
10391 will set the demangled name to the result of dwarf2_full_name, and it is
10392 the demangled name that GDB uses if it exists. */
10393 if (cu
->language
== language_ada
10394 || (cu
->language
== language_fortran
&& physname
))
10396 /* For Ada unit, we prefer the linkage name over the name, as
10397 the former contains the exported name, which the user expects
10398 to be able to reference. Ideally, we want the user to be able
10399 to reference this entity using either natural or linkage name,
10400 but we haven't started looking at this enhancement yet. */
10401 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10403 if (linkage_name
!= NULL
)
10404 return linkage_name
;
10407 /* These are the only languages we know how to qualify names in. */
10409 && (cu
->language
== language_cplus
10410 || cu
->language
== language_fortran
|| cu
->language
== language_d
10411 || cu
->language
== language_rust
))
10413 if (die_needs_namespace (die
, cu
))
10415 const char *prefix
;
10416 const char *canonical_name
= NULL
;
10420 prefix
= determine_prefix (die
, cu
);
10421 if (*prefix
!= '\0')
10423 gdb::unique_xmalloc_ptr
<char> prefixed_name
10424 (typename_concat (NULL
, prefix
, name
, physname
, cu
));
10426 buf
.puts (prefixed_name
.get ());
10431 /* Template parameters may be specified in the DIE's DW_AT_name, or
10432 as children with DW_TAG_template_type_param or
10433 DW_TAG_value_type_param. If the latter, add them to the name
10434 here. If the name already has template parameters, then
10435 skip this step; some versions of GCC emit both, and
10436 it is more efficient to use the pre-computed name.
10438 Something to keep in mind about this process: it is very
10439 unlikely, or in some cases downright impossible, to produce
10440 something that will match the mangled name of a function.
10441 If the definition of the function has the same debug info,
10442 we should be able to match up with it anyway. But fallbacks
10443 using the minimal symbol, for instance to find a method
10444 implemented in a stripped copy of libstdc++, will not work.
10445 If we do not have debug info for the definition, we will have to
10446 match them up some other way.
10448 When we do name matching there is a related problem with function
10449 templates; two instantiated function templates are allowed to
10450 differ only by their return types, which we do not add here. */
10452 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
10454 struct attribute
*attr
;
10455 struct die_info
*child
;
10458 die
->building_fullname
= 1;
10460 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
10464 const gdb_byte
*bytes
;
10465 struct dwarf2_locexpr_baton
*baton
;
10468 if (child
->tag
!= DW_TAG_template_type_param
10469 && child
->tag
!= DW_TAG_template_value_param
)
10480 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10483 complaint (_("template parameter missing DW_AT_type"));
10484 buf
.puts ("UNKNOWN_TYPE");
10487 type
= die_type (child
, cu
);
10489 if (child
->tag
== DW_TAG_template_type_param
)
10491 c_print_type (type
, "", &buf
, -1, 0, cu
->language
,
10492 &type_print_raw_options
);
10496 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10499 complaint (_("template parameter missing "
10500 "DW_AT_const_value"));
10501 buf
.puts ("UNKNOWN_VALUE");
10505 dwarf2_const_value_attr (attr
, type
, name
,
10506 &cu
->comp_unit_obstack
, cu
,
10507 &value
, &bytes
, &baton
);
10509 if (type
->has_no_signedness ())
10510 /* GDB prints characters as NUMBER 'CHAR'. If that's
10511 changed, this can use value_print instead. */
10512 c_printchar (value
, type
, &buf
);
10515 struct value_print_options opts
;
10518 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
10522 baton
->per_objfile
);
10523 else if (bytes
!= NULL
)
10525 v
= allocate_value (type
);
10526 memcpy (value_contents_writeable (v
), bytes
,
10527 TYPE_LENGTH (type
));
10530 v
= value_from_longest (type
, value
);
10532 /* Specify decimal so that we do not depend on
10534 get_formatted_print_options (&opts
, 'd');
10536 value_print (v
, &buf
, &opts
);
10541 die
->building_fullname
= 0;
10545 /* Close the argument list, with a space if necessary
10546 (nested templates). */
10547 if (!buf
.empty () && buf
.string ().back () == '>')
10554 /* For C++ methods, append formal parameter type
10555 information, if PHYSNAME. */
10557 if (physname
&& die
->tag
== DW_TAG_subprogram
10558 && cu
->language
== language_cplus
)
10560 struct type
*type
= read_type_die (die
, cu
);
10562 c_type_print_args (type
, &buf
, 1, cu
->language
,
10563 &type_print_raw_options
);
10565 if (cu
->language
== language_cplus
)
10567 /* Assume that an artificial first parameter is
10568 "this", but do not crash if it is not. RealView
10569 marks unnamed (and thus unused) parameters as
10570 artificial; there is no way to differentiate
10572 if (type
->num_fields () > 0
10573 && TYPE_FIELD_ARTIFICIAL (type
, 0)
10574 && type
->field (0).type ()->code () == TYPE_CODE_PTR
10575 && TYPE_CONST (TYPE_TARGET_TYPE (type
->field (0).type ())))
10576 buf
.puts (" const");
10580 const std::string
&intermediate_name
= buf
.string ();
10582 if (cu
->language
== language_cplus
)
10584 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
10587 /* If we only computed INTERMEDIATE_NAME, or if
10588 INTERMEDIATE_NAME is already canonical, then we need to
10590 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
10591 name
= objfile
->intern (intermediate_name
);
10593 name
= canonical_name
;
10600 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10601 If scope qualifiers are appropriate they will be added. The result
10602 will be allocated on the storage_obstack, or NULL if the DIE does
10603 not have a name. NAME may either be from a previous call to
10604 dwarf2_name or NULL.
10606 The output string will be canonicalized (if C++). */
10608 static const char *
10609 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10611 return dwarf2_compute_name (name
, die
, cu
, 0);
10614 /* Construct a physname for the given DIE in CU. NAME may either be
10615 from a previous call to dwarf2_name or NULL. The result will be
10616 allocated on the objfile_objstack or NULL if the DIE does not have a
10619 The output string will be canonicalized (if C++). */
10621 static const char *
10622 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10624 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10625 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
10628 /* In this case dwarf2_compute_name is just a shortcut not building anything
10630 if (!die_needs_namespace (die
, cu
))
10631 return dwarf2_compute_name (name
, die
, cu
, 1);
10633 if (cu
->language
!= language_rust
)
10634 mangled
= dw2_linkage_name (die
, cu
);
10636 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
10638 gdb::unique_xmalloc_ptr
<char> demangled
;
10639 if (mangled
!= NULL
)
10642 if (language_def (cu
->language
)->store_sym_names_in_linkage_form_p ())
10644 /* Do nothing (do not demangle the symbol name). */
10648 /* Use DMGL_RET_DROP for C++ template functions to suppress
10649 their return type. It is easier for GDB users to search
10650 for such functions as `name(params)' than `long name(params)'.
10651 In such case the minimal symbol names do not match the full
10652 symbol names but for template functions there is never a need
10653 to look up their definition from their declaration so
10654 the only disadvantage remains the minimal symbol variant
10655 `long name(params)' does not have the proper inferior type. */
10656 demangled
.reset (gdb_demangle (mangled
,
10657 (DMGL_PARAMS
| DMGL_ANSI
10658 | DMGL_RET_DROP
)));
10661 canon
= demangled
.get ();
10669 if (canon
== NULL
|| check_physname
)
10671 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
10673 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
10675 /* It may not mean a bug in GDB. The compiler could also
10676 compute DW_AT_linkage_name incorrectly. But in such case
10677 GDB would need to be bug-to-bug compatible. */
10679 complaint (_("Computed physname <%s> does not match demangled <%s> "
10680 "(from linkage <%s>) - DIE at %s [in module %s]"),
10681 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
10682 objfile_name (objfile
));
10684 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
10685 is available here - over computed PHYSNAME. It is safer
10686 against both buggy GDB and buggy compilers. */
10700 retval
= objfile
->intern (retval
);
10705 /* Inspect DIE in CU for a namespace alias. If one exists, record
10706 a new symbol for it.
10708 Returns 1 if a namespace alias was recorded, 0 otherwise. */
10711 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
10713 struct attribute
*attr
;
10715 /* If the die does not have a name, this is not a namespace
10717 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
10721 struct die_info
*d
= die
;
10722 struct dwarf2_cu
*imported_cu
= cu
;
10724 /* If the compiler has nested DW_AT_imported_declaration DIEs,
10725 keep inspecting DIEs until we hit the underlying import. */
10726 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
10727 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
10729 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
10733 d
= follow_die_ref (d
, attr
, &imported_cu
);
10734 if (d
->tag
!= DW_TAG_imported_declaration
)
10738 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
10740 complaint (_("DIE at %s has too many recursively imported "
10741 "declarations"), sect_offset_str (d
->sect_off
));
10748 sect_offset sect_off
= attr
->get_ref_die_offset ();
10750 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, cu
->per_objfile
);
10751 if (type
!= NULL
&& type
->code () == TYPE_CODE_NAMESPACE
)
10753 /* This declaration is a global namespace alias. Add
10754 a symbol for it whose type is the aliased namespace. */
10755 new_symbol (die
, type
, cu
);
10764 /* Return the using directives repository (global or local?) to use in the
10765 current context for CU.
10767 For Ada, imported declarations can materialize renamings, which *may* be
10768 global. However it is impossible (for now?) in DWARF to distinguish
10769 "external" imported declarations and "static" ones. As all imported
10770 declarations seem to be static in all other languages, make them all CU-wide
10771 global only in Ada. */
10773 static struct using_direct
**
10774 using_directives (struct dwarf2_cu
*cu
)
10776 if (cu
->language
== language_ada
10777 && cu
->get_builder ()->outermost_context_p ())
10778 return cu
->get_builder ()->get_global_using_directives ();
10780 return cu
->get_builder ()->get_local_using_directives ();
10783 /* Read the import statement specified by the given die and record it. */
10786 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
10788 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10789 struct attribute
*import_attr
;
10790 struct die_info
*imported_die
, *child_die
;
10791 struct dwarf2_cu
*imported_cu
;
10792 const char *imported_name
;
10793 const char *imported_name_prefix
;
10794 const char *canonical_name
;
10795 const char *import_alias
;
10796 const char *imported_declaration
= NULL
;
10797 const char *import_prefix
;
10798 std::vector
<const char *> excludes
;
10800 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10801 if (import_attr
== NULL
)
10803 complaint (_("Tag '%s' has no DW_AT_import"),
10804 dwarf_tag_name (die
->tag
));
10809 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
10810 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10811 if (imported_name
== NULL
)
10813 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
10815 The import in the following code:
10829 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
10830 <52> DW_AT_decl_file : 1
10831 <53> DW_AT_decl_line : 6
10832 <54> DW_AT_import : <0x75>
10833 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
10834 <59> DW_AT_name : B
10835 <5b> DW_AT_decl_file : 1
10836 <5c> DW_AT_decl_line : 2
10837 <5d> DW_AT_type : <0x6e>
10839 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
10840 <76> DW_AT_byte_size : 4
10841 <77> DW_AT_encoding : 5 (signed)
10843 imports the wrong die ( 0x75 instead of 0x58 ).
10844 This case will be ignored until the gcc bug is fixed. */
10848 /* Figure out the local name after import. */
10849 import_alias
= dwarf2_name (die
, cu
);
10851 /* Figure out where the statement is being imported to. */
10852 import_prefix
= determine_prefix (die
, cu
);
10854 /* Figure out what the scope of the imported die is and prepend it
10855 to the name of the imported die. */
10856 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
10858 if (imported_die
->tag
!= DW_TAG_namespace
10859 && imported_die
->tag
!= DW_TAG_module
)
10861 imported_declaration
= imported_name
;
10862 canonical_name
= imported_name_prefix
;
10864 else if (strlen (imported_name_prefix
) > 0)
10865 canonical_name
= obconcat (&objfile
->objfile_obstack
,
10866 imported_name_prefix
,
10867 (cu
->language
== language_d
? "." : "::"),
10868 imported_name
, (char *) NULL
);
10870 canonical_name
= imported_name
;
10872 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
10873 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
10874 child_die
= child_die
->sibling
)
10876 /* DWARF-4: A Fortran use statement with a “rename list” may be
10877 represented by an imported module entry with an import attribute
10878 referring to the module and owned entries corresponding to those
10879 entities that are renamed as part of being imported. */
10881 if (child_die
->tag
!= DW_TAG_imported_declaration
)
10883 complaint (_("child DW_TAG_imported_declaration expected "
10884 "- DIE at %s [in module %s]"),
10885 sect_offset_str (child_die
->sect_off
),
10886 objfile_name (objfile
));
10890 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
10891 if (import_attr
== NULL
)
10893 complaint (_("Tag '%s' has no DW_AT_import"),
10894 dwarf_tag_name (child_die
->tag
));
10899 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
10901 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10902 if (imported_name
== NULL
)
10904 complaint (_("child DW_TAG_imported_declaration has unknown "
10905 "imported name - DIE at %s [in module %s]"),
10906 sect_offset_str (child_die
->sect_off
),
10907 objfile_name (objfile
));
10911 excludes
.push_back (imported_name
);
10913 process_die (child_die
, cu
);
10916 add_using_directive (using_directives (cu
),
10920 imported_declaration
,
10923 &objfile
->objfile_obstack
);
10926 /* ICC<14 does not output the required DW_AT_declaration on incomplete
10927 types, but gives them a size of zero. Starting with version 14,
10928 ICC is compatible with GCC. */
10931 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
10933 if (!cu
->checked_producer
)
10934 check_producer (cu
);
10936 return cu
->producer_is_icc_lt_14
;
10939 /* ICC generates a DW_AT_type for C void functions. This was observed on
10940 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
10941 which says that void functions should not have a DW_AT_type. */
10944 producer_is_icc (struct dwarf2_cu
*cu
)
10946 if (!cu
->checked_producer
)
10947 check_producer (cu
);
10949 return cu
->producer_is_icc
;
10952 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
10953 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
10954 this, it was first present in GCC release 4.3.0. */
10957 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
10959 if (!cu
->checked_producer
)
10960 check_producer (cu
);
10962 return cu
->producer_is_gcc_lt_4_3
;
10965 static file_and_directory
10966 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
10968 file_and_directory res
;
10970 /* Find the filename. Do not use dwarf2_name here, since the filename
10971 is not a source language identifier. */
10972 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
10973 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
10975 if (res
.comp_dir
== NULL
10976 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
10977 && IS_ABSOLUTE_PATH (res
.name
))
10979 res
.comp_dir_storage
= ldirname (res
.name
);
10980 if (!res
.comp_dir_storage
.empty ())
10981 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
10983 if (res
.comp_dir
!= NULL
)
10985 /* Irix 6.2 native cc prepends <machine>.: to the compilation
10986 directory, get rid of it. */
10987 const char *cp
= strchr (res
.comp_dir
, ':');
10989 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
10990 res
.comp_dir
= cp
+ 1;
10993 if (res
.name
== NULL
)
10994 res
.name
= "<unknown>";
10999 /* Handle DW_AT_stmt_list for a compilation unit.
11000 DIE is the DW_TAG_compile_unit die for CU.
11001 COMP_DIR is the compilation directory. LOWPC is passed to
11002 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11005 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
11006 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
11008 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
11009 struct attribute
*attr
;
11010 struct line_header line_header_local
;
11011 hashval_t line_header_local_hash
;
11013 int decode_mapping
;
11015 gdb_assert (! cu
->per_cu
->is_debug_types
);
11017 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
11018 if (attr
== NULL
|| !attr
->form_is_unsigned ())
11021 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
11023 /* The line header hash table is only created if needed (it exists to
11024 prevent redundant reading of the line table for partial_units).
11025 If we're given a partial_unit, we'll need it. If we're given a
11026 compile_unit, then use the line header hash table if it's already
11027 created, but don't create one just yet. */
11029 if (per_objfile
->line_header_hash
== NULL
11030 && die
->tag
== DW_TAG_partial_unit
)
11032 per_objfile
->line_header_hash
11033 .reset (htab_create_alloc (127, line_header_hash_voidp
,
11034 line_header_eq_voidp
,
11035 free_line_header_voidp
,
11039 line_header_local
.sect_off
= line_offset
;
11040 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
11041 line_header_local_hash
= line_header_hash (&line_header_local
);
11042 if (per_objfile
->line_header_hash
!= NULL
)
11044 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
11045 &line_header_local
,
11046 line_header_local_hash
, NO_INSERT
);
11048 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11049 is not present in *SLOT (since if there is something in *SLOT then
11050 it will be for a partial_unit). */
11051 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
11053 gdb_assert (*slot
!= NULL
);
11054 cu
->line_header
= (struct line_header
*) *slot
;
11059 /* dwarf_decode_line_header does not yet provide sufficient information.
11060 We always have to call also dwarf_decode_lines for it. */
11061 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
11065 cu
->line_header
= lh
.release ();
11066 cu
->line_header_die_owner
= die
;
11068 if (per_objfile
->line_header_hash
== NULL
)
11072 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
11073 &line_header_local
,
11074 line_header_local_hash
, INSERT
);
11075 gdb_assert (slot
!= NULL
);
11077 if (slot
!= NULL
&& *slot
== NULL
)
11079 /* This newly decoded line number information unit will be owned
11080 by line_header_hash hash table. */
11081 *slot
= cu
->line_header
;
11082 cu
->line_header_die_owner
= NULL
;
11086 /* We cannot free any current entry in (*slot) as that struct line_header
11087 may be already used by multiple CUs. Create only temporary decoded
11088 line_header for this CU - it may happen at most once for each line
11089 number information unit. And if we're not using line_header_hash
11090 then this is what we want as well. */
11091 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
11093 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
11094 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
11099 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11102 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11104 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
11105 struct objfile
*objfile
= per_objfile
->objfile
;
11106 struct gdbarch
*gdbarch
= objfile
->arch ();
11107 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
11108 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
11109 struct attribute
*attr
;
11110 struct die_info
*child_die
;
11111 CORE_ADDR baseaddr
;
11113 prepare_one_comp_unit (cu
, die
, cu
->language
);
11114 baseaddr
= objfile
->text_section_offset ();
11116 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
11118 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11119 from finish_block. */
11120 if (lowpc
== ((CORE_ADDR
) -1))
11122 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11124 file_and_directory fnd
= find_file_and_directory (die
, cu
);
11126 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11127 standardised yet. As a workaround for the language detection we fall
11128 back to the DW_AT_producer string. */
11129 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
11130 cu
->language
= language_opencl
;
11132 /* Similar hack for Go. */
11133 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
11134 set_cu_language (DW_LANG_Go
, cu
);
11136 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
11138 /* Decode line number information if present. We do this before
11139 processing child DIEs, so that the line header table is available
11140 for DW_AT_decl_file. */
11141 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
11143 /* Process all dies in compilation unit. */
11144 if (die
->child
!= NULL
)
11146 child_die
= die
->child
;
11147 while (child_die
&& child_die
->tag
)
11149 process_die (child_die
, cu
);
11150 child_die
= child_die
->sibling
;
11154 /* Decode macro information, if present. Dwarf 2 macro information
11155 refers to information in the line number info statement program
11156 header, so we can only read it if we've read the header
11158 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
11160 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
11161 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
11163 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
11164 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11166 dwarf_decode_macros (cu
, attr
->as_unsigned (), 1);
11170 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
11171 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
11173 unsigned int macro_offset
= attr
->as_unsigned ();
11175 dwarf_decode_macros (cu
, macro_offset
, 0);
11181 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
11183 struct type_unit_group
*tu_group
;
11185 struct attribute
*attr
;
11187 struct signatured_type
*sig_type
;
11189 gdb_assert (per_cu
->is_debug_types
);
11190 sig_type
= (struct signatured_type
*) per_cu
;
11192 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
11194 /* If we're using .gdb_index (includes -readnow) then
11195 per_cu->type_unit_group may not have been set up yet. */
11196 if (sig_type
->type_unit_group
== NULL
)
11197 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
11198 tu_group
= sig_type
->type_unit_group
;
11200 /* If we've already processed this stmt_list there's no real need to
11201 do it again, we could fake it and just recreate the part we need
11202 (file name,index -> symtab mapping). If data shows this optimization
11203 is useful we can do it then. */
11204 type_unit_group_unshareable
*tug_unshare
11205 = per_objfile
->get_type_unit_group_unshareable (tu_group
);
11206 first_time
= tug_unshare
->compunit_symtab
== NULL
;
11208 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11211 if (attr
!= NULL
&& attr
->form_is_unsigned ())
11213 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
11214 lh
= dwarf_decode_line_header (line_offset
, this);
11219 start_symtab ("", NULL
, 0);
11222 gdb_assert (tug_unshare
->symtabs
== NULL
);
11223 gdb_assert (m_builder
== nullptr);
11224 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11225 m_builder
.reset (new struct buildsym_compunit
11226 (COMPUNIT_OBJFILE (cust
), "",
11227 COMPUNIT_DIRNAME (cust
),
11228 compunit_language (cust
),
11230 list_in_scope
= get_builder ()->get_file_symbols ();
11235 line_header
= lh
.release ();
11236 line_header_die_owner
= die
;
11240 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
11242 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11243 still initializing it, and our caller (a few levels up)
11244 process_full_type_unit still needs to know if this is the first
11247 tug_unshare
->symtabs
11248 = XOBNEWVEC (&COMPUNIT_OBJFILE (cust
)->objfile_obstack
,
11249 struct symtab
*, line_header
->file_names_size ());
11251 auto &file_names
= line_header
->file_names ();
11252 for (i
= 0; i
< file_names
.size (); ++i
)
11254 file_entry
&fe
= file_names
[i
];
11255 dwarf2_start_subfile (this, fe
.name
,
11256 fe
.include_dir (line_header
));
11257 buildsym_compunit
*b
= get_builder ();
11258 if (b
->get_current_subfile ()->symtab
== NULL
)
11260 /* NOTE: start_subfile will recognize when it's been
11261 passed a file it has already seen. So we can't
11262 assume there's a simple mapping from
11263 cu->line_header->file_names to subfiles, plus
11264 cu->line_header->file_names may contain dups. */
11265 b
->get_current_subfile ()->symtab
11266 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
11269 fe
.symtab
= b
->get_current_subfile ()->symtab
;
11270 tug_unshare
->symtabs
[i
] = fe
.symtab
;
11275 gdb_assert (m_builder
== nullptr);
11276 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11277 m_builder
.reset (new struct buildsym_compunit
11278 (COMPUNIT_OBJFILE (cust
), "",
11279 COMPUNIT_DIRNAME (cust
),
11280 compunit_language (cust
),
11282 list_in_scope
= get_builder ()->get_file_symbols ();
11284 auto &file_names
= line_header
->file_names ();
11285 for (i
= 0; i
< file_names
.size (); ++i
)
11287 file_entry
&fe
= file_names
[i
];
11288 fe
.symtab
= tug_unshare
->symtabs
[i
];
11292 /* The main symtab is allocated last. Type units don't have DW_AT_name
11293 so they don't have a "real" (so to speak) symtab anyway.
11294 There is later code that will assign the main symtab to all symbols
11295 that don't have one. We need to handle the case of a symbol with a
11296 missing symtab (DW_AT_decl_file) anyway. */
11299 /* Process DW_TAG_type_unit.
11300 For TUs we want to skip the first top level sibling if it's not the
11301 actual type being defined by this TU. In this case the first top
11302 level sibling is there to provide context only. */
11305 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11307 struct die_info
*child_die
;
11309 prepare_one_comp_unit (cu
, die
, language_minimal
);
11311 /* Initialize (or reinitialize) the machinery for building symtabs.
11312 We do this before processing child DIEs, so that the line header table
11313 is available for DW_AT_decl_file. */
11314 cu
->setup_type_unit_groups (die
);
11316 if (die
->child
!= NULL
)
11318 child_die
= die
->child
;
11319 while (child_die
&& child_die
->tag
)
11321 process_die (child_die
, cu
);
11322 child_die
= child_die
->sibling
;
11329 http://gcc.gnu.org/wiki/DebugFission
11330 http://gcc.gnu.org/wiki/DebugFissionDWP
11332 To simplify handling of both DWO files ("object" files with the DWARF info)
11333 and DWP files (a file with the DWOs packaged up into one file), we treat
11334 DWP files as having a collection of virtual DWO files. */
11337 hash_dwo_file (const void *item
)
11339 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
11342 hash
= htab_hash_string (dwo_file
->dwo_name
);
11343 if (dwo_file
->comp_dir
!= NULL
)
11344 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11349 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11351 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11352 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11354 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11356 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11357 return lhs
->comp_dir
== rhs
->comp_dir
;
11358 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11361 /* Allocate a hash table for DWO files. */
11364 allocate_dwo_file_hash_table ()
11366 auto delete_dwo_file
= [] (void *item
)
11368 struct dwo_file
*dwo_file
= (struct dwo_file
*) item
;
11373 return htab_up (htab_create_alloc (41,
11380 /* Lookup DWO file DWO_NAME. */
11383 lookup_dwo_file_slot (dwarf2_per_objfile
*per_objfile
,
11384 const char *dwo_name
,
11385 const char *comp_dir
)
11387 struct dwo_file find_entry
;
11390 if (per_objfile
->per_bfd
->dwo_files
== NULL
)
11391 per_objfile
->per_bfd
->dwo_files
= allocate_dwo_file_hash_table ();
11393 find_entry
.dwo_name
= dwo_name
;
11394 find_entry
.comp_dir
= comp_dir
;
11395 slot
= htab_find_slot (per_objfile
->per_bfd
->dwo_files
.get (), &find_entry
,
11402 hash_dwo_unit (const void *item
)
11404 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11406 /* This drops the top 32 bits of the id, but is ok for a hash. */
11407 return dwo_unit
->signature
;
11411 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11413 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11414 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11416 /* The signature is assumed to be unique within the DWO file.
11417 So while object file CU dwo_id's always have the value zero,
11418 that's OK, assuming each object file DWO file has only one CU,
11419 and that's the rule for now. */
11420 return lhs
->signature
== rhs
->signature
;
11423 /* Allocate a hash table for DWO CUs,TUs.
11424 There is one of these tables for each of CUs,TUs for each DWO file. */
11427 allocate_dwo_unit_table ()
11429 /* Start out with a pretty small number.
11430 Generally DWO files contain only one CU and maybe some TUs. */
11431 return htab_up (htab_create_alloc (3,
11434 NULL
, xcalloc
, xfree
));
11437 /* die_reader_func for create_dwo_cu. */
11440 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
11441 const gdb_byte
*info_ptr
,
11442 struct die_info
*comp_unit_die
,
11443 struct dwo_file
*dwo_file
,
11444 struct dwo_unit
*dwo_unit
)
11446 struct dwarf2_cu
*cu
= reader
->cu
;
11447 sect_offset sect_off
= cu
->per_cu
->sect_off
;
11448 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
11450 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
11451 if (!signature
.has_value ())
11453 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11454 " its dwo_id [in module %s]"),
11455 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
11459 dwo_unit
->dwo_file
= dwo_file
;
11460 dwo_unit
->signature
= *signature
;
11461 dwo_unit
->section
= section
;
11462 dwo_unit
->sect_off
= sect_off
;
11463 dwo_unit
->length
= cu
->per_cu
->length
;
11465 if (dwarf_read_debug
)
11466 fprintf_unfiltered (gdb_stdlog
, " offset %s, dwo_id %s\n",
11467 sect_offset_str (sect_off
),
11468 hex_string (dwo_unit
->signature
));
11471 /* Create the dwo_units for the CUs in a DWO_FILE.
11472 Note: This function processes DWO files only, not DWP files. */
11475 create_cus_hash_table (dwarf2_per_objfile
*per_objfile
,
11476 dwarf2_cu
*cu
, struct dwo_file
&dwo_file
,
11477 dwarf2_section_info
§ion
, htab_up
&cus_htab
)
11479 struct objfile
*objfile
= per_objfile
->objfile
;
11480 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
11481 const gdb_byte
*info_ptr
, *end_ptr
;
11483 section
.read (objfile
);
11484 info_ptr
= section
.buffer
;
11486 if (info_ptr
== NULL
)
11489 if (dwarf_read_debug
)
11491 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
11492 section
.get_name (),
11493 section
.get_file_name ());
11496 end_ptr
= info_ptr
+ section
.size
;
11497 while (info_ptr
< end_ptr
)
11499 struct dwarf2_per_cu_data per_cu
;
11500 struct dwo_unit read_unit
{};
11501 struct dwo_unit
*dwo_unit
;
11503 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
11505 memset (&per_cu
, 0, sizeof (per_cu
));
11506 per_cu
.per_bfd
= per_bfd
;
11507 per_cu
.is_debug_types
= 0;
11508 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
11509 per_cu
.section
= §ion
;
11511 cutu_reader
reader (&per_cu
, per_objfile
, cu
, &dwo_file
);
11512 if (!reader
.dummy_p
)
11513 create_dwo_cu_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
,
11514 &dwo_file
, &read_unit
);
11515 info_ptr
+= per_cu
.length
;
11517 // If the unit could not be parsed, skip it.
11518 if (read_unit
.dwo_file
== NULL
)
11521 if (cus_htab
== NULL
)
11522 cus_htab
= allocate_dwo_unit_table ();
11524 dwo_unit
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
11526 *dwo_unit
= read_unit
;
11527 slot
= htab_find_slot (cus_htab
.get (), dwo_unit
, INSERT
);
11528 gdb_assert (slot
!= NULL
);
11531 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
11532 sect_offset dup_sect_off
= dup_cu
->sect_off
;
11534 complaint (_("debug cu entry at offset %s is duplicate to"
11535 " the entry at offset %s, signature %s"),
11536 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
11537 hex_string (dwo_unit
->signature
));
11539 *slot
= (void *)dwo_unit
;
11543 /* DWP file .debug_{cu,tu}_index section format:
11544 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11545 [ref: http://dwarfstd.org/doc/DWARF5.pdf, sect 7.3.5 "DWARF Package Files"]
11547 DWP Versions 1 & 2 are older, pre-standard format versions. The first
11548 officially standard DWP format was published with DWARF v5 and is called
11549 Version 5. There are no versions 3 or 4.
11553 Both index sections have the same format, and serve to map a 64-bit
11554 signature to a set of section numbers. Each section begins with a header,
11555 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11556 indexes, and a pool of 32-bit section numbers. The index sections will be
11557 aligned at 8-byte boundaries in the file.
11559 The index section header consists of:
11561 V, 32 bit version number
11563 N, 32 bit number of compilation units or type units in the index
11564 M, 32 bit number of slots in the hash table
11566 Numbers are recorded using the byte order of the application binary.
11568 The hash table begins at offset 16 in the section, and consists of an array
11569 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11570 order of the application binary). Unused slots in the hash table are 0.
11571 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11573 The parallel table begins immediately after the hash table
11574 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11575 array of 32-bit indexes (using the byte order of the application binary),
11576 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11577 table contains a 32-bit index into the pool of section numbers. For unused
11578 hash table slots, the corresponding entry in the parallel table will be 0.
11580 The pool of section numbers begins immediately following the hash table
11581 (at offset 16 + 12 * M from the beginning of the section). The pool of
11582 section numbers consists of an array of 32-bit words (using the byte order
11583 of the application binary). Each item in the array is indexed starting
11584 from 0. The hash table entry provides the index of the first section
11585 number in the set. Additional section numbers in the set follow, and the
11586 set is terminated by a 0 entry (section number 0 is not used in ELF).
11588 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
11589 section must be the first entry in the set, and the .debug_abbrev.dwo must
11590 be the second entry. Other members of the set may follow in any order.
11594 DWP Versions 2 and 5:
11596 DWP Versions 2 and 5 combine all the .debug_info, etc. sections into one,
11597 and the entries in the index tables are now offsets into these sections.
11598 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
11601 Index Section Contents:
11603 Hash Table of Signatures dwp_hash_table.hash_table
11604 Parallel Table of Indices dwp_hash_table.unit_table
11605 Table of Section Offsets dwp_hash_table.{v2|v5}.{section_ids,offsets}
11606 Table of Section Sizes dwp_hash_table.{v2|v5}.sizes
11608 The index section header consists of:
11610 V, 32 bit version number
11611 L, 32 bit number of columns in the table of section offsets
11612 N, 32 bit number of compilation units or type units in the index
11613 M, 32 bit number of slots in the hash table
11615 Numbers are recorded using the byte order of the application binary.
11617 The hash table has the same format as version 1.
11618 The parallel table of indices has the same format as version 1,
11619 except that the entries are origin-1 indices into the table of sections
11620 offsets and the table of section sizes.
11622 The table of offsets begins immediately following the parallel table
11623 (at offset 16 + 12 * M from the beginning of the section). The table is
11624 a two-dimensional array of 32-bit words (using the byte order of the
11625 application binary), with L columns and N+1 rows, in row-major order.
11626 Each row in the array is indexed starting from 0. The first row provides
11627 a key to the remaining rows: each column in this row provides an identifier
11628 for a debug section, and the offsets in the same column of subsequent rows
11629 refer to that section. The section identifiers for Version 2 are:
11631 DW_SECT_INFO 1 .debug_info.dwo
11632 DW_SECT_TYPES 2 .debug_types.dwo
11633 DW_SECT_ABBREV 3 .debug_abbrev.dwo
11634 DW_SECT_LINE 4 .debug_line.dwo
11635 DW_SECT_LOC 5 .debug_loc.dwo
11636 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
11637 DW_SECT_MACINFO 7 .debug_macinfo.dwo
11638 DW_SECT_MACRO 8 .debug_macro.dwo
11640 The section identifiers for Version 5 are:
11642 DW_SECT_INFO_V5 1 .debug_info.dwo
11643 DW_SECT_RESERVED_V5 2 --
11644 DW_SECT_ABBREV_V5 3 .debug_abbrev.dwo
11645 DW_SECT_LINE_V5 4 .debug_line.dwo
11646 DW_SECT_LOCLISTS_V5 5 .debug_loclists.dwo
11647 DW_SECT_STR_OFFSETS_V5 6 .debug_str_offsets.dwo
11648 DW_SECT_MACRO_V5 7 .debug_macro.dwo
11649 DW_SECT_RNGLISTS_V5 8 .debug_rnglists.dwo
11651 The offsets provided by the CU and TU index sections are the base offsets
11652 for the contributions made by each CU or TU to the corresponding section
11653 in the package file. Each CU and TU header contains an abbrev_offset
11654 field, used to find the abbreviations table for that CU or TU within the
11655 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
11656 be interpreted as relative to the base offset given in the index section.
11657 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
11658 should be interpreted as relative to the base offset for .debug_line.dwo,
11659 and offsets into other debug sections obtained from DWARF attributes should
11660 also be interpreted as relative to the corresponding base offset.
11662 The table of sizes begins immediately following the table of offsets.
11663 Like the table of offsets, it is a two-dimensional array of 32-bit words,
11664 with L columns and N rows, in row-major order. Each row in the array is
11665 indexed starting from 1 (row 0 is shared by the two tables).
11669 Hash table lookup is handled the same in version 1 and 2:
11671 We assume that N and M will not exceed 2^32 - 1.
11672 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
11674 Given a 64-bit compilation unit signature or a type signature S, an entry
11675 in the hash table is located as follows:
11677 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
11678 the low-order k bits all set to 1.
11680 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
11682 3) If the hash table entry at index H matches the signature, use that
11683 entry. If the hash table entry at index H is unused (all zeroes),
11684 terminate the search: the signature is not present in the table.
11686 4) Let H = (H + H') modulo M. Repeat at Step 3.
11688 Because M > N and H' and M are relatively prime, the search is guaranteed
11689 to stop at an unused slot or find the match. */
11691 /* Create a hash table to map DWO IDs to their CU/TU entry in
11692 .debug_{info,types}.dwo in DWP_FILE.
11693 Returns NULL if there isn't one.
11694 Note: This function processes DWP files only, not DWO files. */
11696 static struct dwp_hash_table
*
11697 create_dwp_hash_table (dwarf2_per_objfile
*per_objfile
,
11698 struct dwp_file
*dwp_file
, int is_debug_types
)
11700 struct objfile
*objfile
= per_objfile
->objfile
;
11701 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11702 const gdb_byte
*index_ptr
, *index_end
;
11703 struct dwarf2_section_info
*index
;
11704 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
11705 struct dwp_hash_table
*htab
;
11707 if (is_debug_types
)
11708 index
= &dwp_file
->sections
.tu_index
;
11710 index
= &dwp_file
->sections
.cu_index
;
11712 if (index
->empty ())
11714 index
->read (objfile
);
11716 index_ptr
= index
->buffer
;
11717 index_end
= index_ptr
+ index
->size
;
11719 /* For Version 5, the version is really 2 bytes of data & 2 bytes of padding.
11720 For now it's safe to just read 4 bytes (particularly as it's difficult to
11721 tell if you're dealing with Version 5 before you've read the version). */
11722 version
= read_4_bytes (dbfd
, index_ptr
);
11724 if (version
== 2 || version
== 5)
11725 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
11729 nr_units
= read_4_bytes (dbfd
, index_ptr
);
11731 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
11734 if (version
!= 1 && version
!= 2 && version
!= 5)
11736 error (_("Dwarf Error: unsupported DWP file version (%s)"
11737 " [in module %s]"),
11738 pulongest (version
), dwp_file
->name
);
11740 if (nr_slots
!= (nr_slots
& -nr_slots
))
11742 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
11743 " is not power of 2 [in module %s]"),
11744 pulongest (nr_slots
), dwp_file
->name
);
11747 htab
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwp_hash_table
);
11748 htab
->version
= version
;
11749 htab
->nr_columns
= nr_columns
;
11750 htab
->nr_units
= nr_units
;
11751 htab
->nr_slots
= nr_slots
;
11752 htab
->hash_table
= index_ptr
;
11753 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
11755 /* Exit early if the table is empty. */
11756 if (nr_slots
== 0 || nr_units
== 0
11757 || (version
== 2 && nr_columns
== 0)
11758 || (version
== 5 && nr_columns
== 0))
11760 /* All must be zero. */
11761 if (nr_slots
!= 0 || nr_units
!= 0
11762 || (version
== 2 && nr_columns
!= 0)
11763 || (version
== 5 && nr_columns
!= 0))
11765 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
11766 " all zero [in modules %s]"),
11774 htab
->section_pool
.v1
.indices
=
11775 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11776 /* It's harder to decide whether the section is too small in v1.
11777 V1 is deprecated anyway so we punt. */
11779 else if (version
== 2)
11781 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11782 int *ids
= htab
->section_pool
.v2
.section_ids
;
11783 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
11784 /* Reverse map for error checking. */
11785 int ids_seen
[DW_SECT_MAX
+ 1];
11788 if (nr_columns
< 2)
11790 error (_("Dwarf Error: bad DWP hash table, too few columns"
11791 " in section table [in module %s]"),
11794 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
11796 error (_("Dwarf Error: bad DWP hash table, too many columns"
11797 " in section table [in module %s]"),
11800 memset (ids
, 255, sizeof_ids
);
11801 memset (ids_seen
, 255, sizeof (ids_seen
));
11802 for (i
= 0; i
< nr_columns
; ++i
)
11804 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11806 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
11808 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11809 " in section table [in module %s]"),
11810 id
, dwp_file
->name
);
11812 if (ids_seen
[id
] != -1)
11814 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11815 " id %d in section table [in module %s]"),
11816 id
, dwp_file
->name
);
11821 /* Must have exactly one info or types section. */
11822 if (((ids_seen
[DW_SECT_INFO
] != -1)
11823 + (ids_seen
[DW_SECT_TYPES
] != -1))
11826 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11827 " DWO info/types section [in module %s]"),
11830 /* Must have an abbrev section. */
11831 if (ids_seen
[DW_SECT_ABBREV
] == -1)
11833 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11834 " section [in module %s]"),
11837 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11838 htab
->section_pool
.v2
.sizes
=
11839 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
11840 * nr_units
* nr_columns
);
11841 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
11842 * nr_units
* nr_columns
))
11845 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11846 " [in module %s]"),
11850 else /* version == 5 */
11852 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11853 int *ids
= htab
->section_pool
.v5
.section_ids
;
11854 size_t sizeof_ids
= sizeof (htab
->section_pool
.v5
.section_ids
);
11855 /* Reverse map for error checking. */
11856 int ids_seen
[DW_SECT_MAX_V5
+ 1];
11858 if (nr_columns
< 2)
11860 error (_("Dwarf Error: bad DWP hash table, too few columns"
11861 " in section table [in module %s]"),
11864 if (nr_columns
> MAX_NR_V5_DWO_SECTIONS
)
11866 error (_("Dwarf Error: bad DWP hash table, too many columns"
11867 " in section table [in module %s]"),
11870 memset (ids
, 255, sizeof_ids
);
11871 memset (ids_seen
, 255, sizeof (ids_seen
));
11872 for (int i
= 0; i
< nr_columns
; ++i
)
11874 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11876 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX_V5
)
11878 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11879 " in section table [in module %s]"),
11880 id
, dwp_file
->name
);
11882 if (ids_seen
[id
] != -1)
11884 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11885 " id %d in section table [in module %s]"),
11886 id
, dwp_file
->name
);
11891 /* Must have seen an info section. */
11892 if (ids_seen
[DW_SECT_INFO_V5
] == -1)
11894 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11895 " DWO info/types section [in module %s]"),
11898 /* Must have an abbrev section. */
11899 if (ids_seen
[DW_SECT_ABBREV_V5
] == -1)
11901 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11902 " section [in module %s]"),
11905 htab
->section_pool
.v5
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11906 htab
->section_pool
.v5
.sizes
11907 = htab
->section_pool
.v5
.offsets
+ (sizeof (uint32_t)
11908 * nr_units
* nr_columns
);
11909 if ((htab
->section_pool
.v5
.sizes
+ (sizeof (uint32_t)
11910 * nr_units
* nr_columns
))
11913 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11914 " [in module %s]"),
11922 /* Update SECTIONS with the data from SECTP.
11924 This function is like the other "locate" section routines, but in
11925 this context the sections to read comes from the DWP V1 hash table,
11926 not the full ELF section table.
11928 The result is non-zero for success, or zero if an error was found. */
11931 locate_v1_virtual_dwo_sections (asection
*sectp
,
11932 struct virtual_v1_dwo_sections
*sections
)
11934 const struct dwop_section_names
*names
= &dwop_section_names
;
11936 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
11938 /* There can be only one. */
11939 if (sections
->abbrev
.s
.section
!= NULL
)
11941 sections
->abbrev
.s
.section
= sectp
;
11942 sections
->abbrev
.size
= bfd_section_size (sectp
);
11944 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
11945 || section_is_p (sectp
->name
, &names
->types_dwo
))
11947 /* There can be only one. */
11948 if (sections
->info_or_types
.s
.section
!= NULL
)
11950 sections
->info_or_types
.s
.section
= sectp
;
11951 sections
->info_or_types
.size
= bfd_section_size (sectp
);
11953 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
11955 /* There can be only one. */
11956 if (sections
->line
.s
.section
!= NULL
)
11958 sections
->line
.s
.section
= sectp
;
11959 sections
->line
.size
= bfd_section_size (sectp
);
11961 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
11963 /* There can be only one. */
11964 if (sections
->loc
.s
.section
!= NULL
)
11966 sections
->loc
.s
.section
= sectp
;
11967 sections
->loc
.size
= bfd_section_size (sectp
);
11969 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
11971 /* There can be only one. */
11972 if (sections
->macinfo
.s
.section
!= NULL
)
11974 sections
->macinfo
.s
.section
= sectp
;
11975 sections
->macinfo
.size
= bfd_section_size (sectp
);
11977 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
11979 /* There can be only one. */
11980 if (sections
->macro
.s
.section
!= NULL
)
11982 sections
->macro
.s
.section
= sectp
;
11983 sections
->macro
.size
= bfd_section_size (sectp
);
11985 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
11987 /* There can be only one. */
11988 if (sections
->str_offsets
.s
.section
!= NULL
)
11990 sections
->str_offsets
.s
.section
= sectp
;
11991 sections
->str_offsets
.size
= bfd_section_size (sectp
);
11995 /* No other kind of section is valid. */
12002 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12003 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12004 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12005 This is for DWP version 1 files. */
12007 static struct dwo_unit
*
12008 create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
*per_objfile
,
12009 struct dwp_file
*dwp_file
,
12010 uint32_t unit_index
,
12011 const char *comp_dir
,
12012 ULONGEST signature
, int is_debug_types
)
12014 const struct dwp_hash_table
*dwp_htab
=
12015 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12016 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12017 const char *kind
= is_debug_types
? "TU" : "CU";
12018 struct dwo_file
*dwo_file
;
12019 struct dwo_unit
*dwo_unit
;
12020 struct virtual_v1_dwo_sections sections
;
12021 void **dwo_file_slot
;
12024 gdb_assert (dwp_file
->version
== 1);
12026 if (dwarf_read_debug
)
12028 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
12030 pulongest (unit_index
), hex_string (signature
),
12034 /* Fetch the sections of this DWO unit.
12035 Put a limit on the number of sections we look for so that bad data
12036 doesn't cause us to loop forever. */
12038 #define MAX_NR_V1_DWO_SECTIONS \
12039 (1 /* .debug_info or .debug_types */ \
12040 + 1 /* .debug_abbrev */ \
12041 + 1 /* .debug_line */ \
12042 + 1 /* .debug_loc */ \
12043 + 1 /* .debug_str_offsets */ \
12044 + 1 /* .debug_macro or .debug_macinfo */ \
12045 + 1 /* trailing zero */)
12047 memset (§ions
, 0, sizeof (sections
));
12049 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
12052 uint32_t section_nr
=
12053 read_4_bytes (dbfd
,
12054 dwp_htab
->section_pool
.v1
.indices
12055 + (unit_index
+ i
) * sizeof (uint32_t));
12057 if (section_nr
== 0)
12059 if (section_nr
>= dwp_file
->num_sections
)
12061 error (_("Dwarf Error: bad DWP hash table, section number too large"
12062 " [in module %s]"),
12066 sectp
= dwp_file
->elf_sections
[section_nr
];
12067 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
12069 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12070 " [in module %s]"),
12076 || sections
.info_or_types
.empty ()
12077 || sections
.abbrev
.empty ())
12079 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12080 " [in module %s]"),
12083 if (i
== MAX_NR_V1_DWO_SECTIONS
)
12085 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12086 " [in module %s]"),
12090 /* It's easier for the rest of the code if we fake a struct dwo_file and
12091 have dwo_unit "live" in that. At least for now.
12093 The DWP file can be made up of a random collection of CUs and TUs.
12094 However, for each CU + set of TUs that came from the same original DWO
12095 file, we can combine them back into a virtual DWO file to save space
12096 (fewer struct dwo_file objects to allocate). Remember that for really
12097 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12099 std::string virtual_dwo_name
=
12100 string_printf ("virtual-dwo/%d-%d-%d-%d",
12101 sections
.abbrev
.get_id (),
12102 sections
.line
.get_id (),
12103 sections
.loc
.get_id (),
12104 sections
.str_offsets
.get_id ());
12105 /* Can we use an existing virtual DWO file? */
12106 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
12108 /* Create one if necessary. */
12109 if (*dwo_file_slot
== NULL
)
12111 if (dwarf_read_debug
)
12113 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12114 virtual_dwo_name
.c_str ());
12116 dwo_file
= new struct dwo_file
;
12117 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12118 dwo_file
->comp_dir
= comp_dir
;
12119 dwo_file
->sections
.abbrev
= sections
.abbrev
;
12120 dwo_file
->sections
.line
= sections
.line
;
12121 dwo_file
->sections
.loc
= sections
.loc
;
12122 dwo_file
->sections
.macinfo
= sections
.macinfo
;
12123 dwo_file
->sections
.macro
= sections
.macro
;
12124 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
12125 /* The "str" section is global to the entire DWP file. */
12126 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12127 /* The info or types section is assigned below to dwo_unit,
12128 there's no need to record it in dwo_file.
12129 Also, we can't simply record type sections in dwo_file because
12130 we record a pointer into the vector in dwo_unit. As we collect more
12131 types we'll grow the vector and eventually have to reallocate space
12132 for it, invalidating all copies of pointers into the previous
12134 *dwo_file_slot
= dwo_file
;
12138 if (dwarf_read_debug
)
12140 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12141 virtual_dwo_name
.c_str ());
12143 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12146 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12147 dwo_unit
->dwo_file
= dwo_file
;
12148 dwo_unit
->signature
= signature
;
12149 dwo_unit
->section
=
12150 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12151 *dwo_unit
->section
= sections
.info_or_types
;
12152 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12157 /* Subroutine of create_dwo_unit_in_dwp_v2 and create_dwo_unit_in_dwp_v5 to
12158 simplify them. Given a pointer to the containing section SECTION, and
12159 OFFSET,SIZE of the piece within that section used by a TU/CU, return a
12160 virtual section of just that piece. */
12162 static struct dwarf2_section_info
12163 create_dwp_v2_or_v5_section (dwarf2_per_objfile
*per_objfile
,
12164 struct dwarf2_section_info
*section
,
12165 bfd_size_type offset
, bfd_size_type size
)
12167 struct dwarf2_section_info result
;
12170 gdb_assert (section
!= NULL
);
12171 gdb_assert (!section
->is_virtual
);
12173 memset (&result
, 0, sizeof (result
));
12174 result
.s
.containing_section
= section
;
12175 result
.is_virtual
= true;
12180 sectp
= section
->get_bfd_section ();
12182 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12183 bounds of the real section. This is a pretty-rare event, so just
12184 flag an error (easier) instead of a warning and trying to cope. */
12186 || offset
+ size
> bfd_section_size (sectp
))
12188 error (_("Dwarf Error: Bad DWP V2 or V5 section info, doesn't fit"
12189 " in section %s [in module %s]"),
12190 sectp
? bfd_section_name (sectp
) : "<unknown>",
12191 objfile_name (per_objfile
->objfile
));
12194 result
.virtual_offset
= offset
;
12195 result
.size
= size
;
12199 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12200 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12201 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12202 This is for DWP version 2 files. */
12204 static struct dwo_unit
*
12205 create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
*per_objfile
,
12206 struct dwp_file
*dwp_file
,
12207 uint32_t unit_index
,
12208 const char *comp_dir
,
12209 ULONGEST signature
, int is_debug_types
)
12211 const struct dwp_hash_table
*dwp_htab
=
12212 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12213 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12214 const char *kind
= is_debug_types
? "TU" : "CU";
12215 struct dwo_file
*dwo_file
;
12216 struct dwo_unit
*dwo_unit
;
12217 struct virtual_v2_or_v5_dwo_sections sections
;
12218 void **dwo_file_slot
;
12221 gdb_assert (dwp_file
->version
== 2);
12223 if (dwarf_read_debug
)
12225 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
12227 pulongest (unit_index
), hex_string (signature
),
12231 /* Fetch the section offsets of this DWO unit. */
12233 memset (§ions
, 0, sizeof (sections
));
12235 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12237 uint32_t offset
= read_4_bytes (dbfd
,
12238 dwp_htab
->section_pool
.v2
.offsets
12239 + (((unit_index
- 1) * dwp_htab
->nr_columns
12241 * sizeof (uint32_t)));
12242 uint32_t size
= read_4_bytes (dbfd
,
12243 dwp_htab
->section_pool
.v2
.sizes
12244 + (((unit_index
- 1) * dwp_htab
->nr_columns
12246 * sizeof (uint32_t)));
12248 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
12251 case DW_SECT_TYPES
:
12252 sections
.info_or_types_offset
= offset
;
12253 sections
.info_or_types_size
= size
;
12255 case DW_SECT_ABBREV
:
12256 sections
.abbrev_offset
= offset
;
12257 sections
.abbrev_size
= size
;
12260 sections
.line_offset
= offset
;
12261 sections
.line_size
= size
;
12264 sections
.loc_offset
= offset
;
12265 sections
.loc_size
= size
;
12267 case DW_SECT_STR_OFFSETS
:
12268 sections
.str_offsets_offset
= offset
;
12269 sections
.str_offsets_size
= size
;
12271 case DW_SECT_MACINFO
:
12272 sections
.macinfo_offset
= offset
;
12273 sections
.macinfo_size
= size
;
12275 case DW_SECT_MACRO
:
12276 sections
.macro_offset
= offset
;
12277 sections
.macro_size
= size
;
12282 /* It's easier for the rest of the code if we fake a struct dwo_file and
12283 have dwo_unit "live" in that. At least for now.
12285 The DWP file can be made up of a random collection of CUs and TUs.
12286 However, for each CU + set of TUs that came from the same original DWO
12287 file, we can combine them back into a virtual DWO file to save space
12288 (fewer struct dwo_file objects to allocate). Remember that for really
12289 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12291 std::string virtual_dwo_name
=
12292 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12293 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12294 (long) (sections
.line_size
? sections
.line_offset
: 0),
12295 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
12296 (long) (sections
.str_offsets_size
12297 ? sections
.str_offsets_offset
: 0));
12298 /* Can we use an existing virtual DWO file? */
12299 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
12301 /* Create one if necessary. */
12302 if (*dwo_file_slot
== NULL
)
12304 if (dwarf_read_debug
)
12306 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12307 virtual_dwo_name
.c_str ());
12309 dwo_file
= new struct dwo_file
;
12310 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12311 dwo_file
->comp_dir
= comp_dir
;
12312 dwo_file
->sections
.abbrev
=
12313 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.abbrev
,
12314 sections
.abbrev_offset
,
12315 sections
.abbrev_size
);
12316 dwo_file
->sections
.line
=
12317 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.line
,
12318 sections
.line_offset
,
12319 sections
.line_size
);
12320 dwo_file
->sections
.loc
=
12321 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.loc
,
12322 sections
.loc_offset
, sections
.loc_size
);
12323 dwo_file
->sections
.macinfo
=
12324 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macinfo
,
12325 sections
.macinfo_offset
,
12326 sections
.macinfo_size
);
12327 dwo_file
->sections
.macro
=
12328 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macro
,
12329 sections
.macro_offset
,
12330 sections
.macro_size
);
12331 dwo_file
->sections
.str_offsets
=
12332 create_dwp_v2_or_v5_section (per_objfile
,
12333 &dwp_file
->sections
.str_offsets
,
12334 sections
.str_offsets_offset
,
12335 sections
.str_offsets_size
);
12336 /* The "str" section is global to the entire DWP file. */
12337 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12338 /* The info or types section is assigned below to dwo_unit,
12339 there's no need to record it in dwo_file.
12340 Also, we can't simply record type sections in dwo_file because
12341 we record a pointer into the vector in dwo_unit. As we collect more
12342 types we'll grow the vector and eventually have to reallocate space
12343 for it, invalidating all copies of pointers into the previous
12345 *dwo_file_slot
= dwo_file
;
12349 if (dwarf_read_debug
)
12351 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12352 virtual_dwo_name
.c_str ());
12354 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12357 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12358 dwo_unit
->dwo_file
= dwo_file
;
12359 dwo_unit
->signature
= signature
;
12360 dwo_unit
->section
=
12361 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12362 *dwo_unit
->section
= create_dwp_v2_or_v5_section
12365 ? &dwp_file
->sections
.types
12366 : &dwp_file
->sections
.info
,
12367 sections
.info_or_types_offset
,
12368 sections
.info_or_types_size
);
12369 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12374 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12375 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12376 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12377 This is for DWP version 5 files. */
12379 static struct dwo_unit
*
12380 create_dwo_unit_in_dwp_v5 (dwarf2_per_objfile
*per_objfile
,
12381 struct dwp_file
*dwp_file
,
12382 uint32_t unit_index
,
12383 const char *comp_dir
,
12384 ULONGEST signature
, int is_debug_types
)
12386 const struct dwp_hash_table
*dwp_htab
12387 = is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12388 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12389 const char *kind
= is_debug_types
? "TU" : "CU";
12390 struct dwo_file
*dwo_file
;
12391 struct dwo_unit
*dwo_unit
;
12392 struct virtual_v2_or_v5_dwo_sections sections
{};
12393 void **dwo_file_slot
;
12395 gdb_assert (dwp_file
->version
== 5);
12397 if (dwarf_read_debug
)
12399 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V5 file: %s\n",
12401 pulongest (unit_index
), hex_string (signature
),
12405 /* Fetch the section offsets of this DWO unit. */
12407 /* memset (§ions, 0, sizeof (sections)); */
12409 for (int i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12411 uint32_t offset
= read_4_bytes (dbfd
,
12412 dwp_htab
->section_pool
.v5
.offsets
12413 + (((unit_index
- 1)
12414 * dwp_htab
->nr_columns
12416 * sizeof (uint32_t)));
12417 uint32_t size
= read_4_bytes (dbfd
,
12418 dwp_htab
->section_pool
.v5
.sizes
12419 + (((unit_index
- 1) * dwp_htab
->nr_columns
12421 * sizeof (uint32_t)));
12423 switch (dwp_htab
->section_pool
.v5
.section_ids
[i
])
12425 case DW_SECT_ABBREV_V5
:
12426 sections
.abbrev_offset
= offset
;
12427 sections
.abbrev_size
= size
;
12429 case DW_SECT_INFO_V5
:
12430 sections
.info_or_types_offset
= offset
;
12431 sections
.info_or_types_size
= size
;
12433 case DW_SECT_LINE_V5
:
12434 sections
.line_offset
= offset
;
12435 sections
.line_size
= size
;
12437 case DW_SECT_LOCLISTS_V5
:
12438 sections
.loclists_offset
= offset
;
12439 sections
.loclists_size
= size
;
12441 case DW_SECT_MACRO_V5
:
12442 sections
.macro_offset
= offset
;
12443 sections
.macro_size
= size
;
12445 case DW_SECT_RNGLISTS_V5
:
12446 sections
.rnglists_offset
= offset
;
12447 sections
.rnglists_size
= size
;
12449 case DW_SECT_STR_OFFSETS_V5
:
12450 sections
.str_offsets_offset
= offset
;
12451 sections
.str_offsets_size
= size
;
12453 case DW_SECT_RESERVED_V5
:
12459 /* It's easier for the rest of the code if we fake a struct dwo_file and
12460 have dwo_unit "live" in that. At least for now.
12462 The DWP file can be made up of a random collection of CUs and TUs.
12463 However, for each CU + set of TUs that came from the same original DWO
12464 file, we can combine them back into a virtual DWO file to save space
12465 (fewer struct dwo_file objects to allocate). Remember that for really
12466 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12468 std::string virtual_dwo_name
=
12469 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld-%ld-%ld",
12470 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12471 (long) (sections
.line_size
? sections
.line_offset
: 0),
12472 (long) (sections
.loclists_size
? sections
.loclists_offset
: 0),
12473 (long) (sections
.str_offsets_size
12474 ? sections
.str_offsets_offset
: 0),
12475 (long) (sections
.macro_size
? sections
.macro_offset
: 0),
12476 (long) (sections
.rnglists_size
? sections
.rnglists_offset
: 0));
12477 /* Can we use an existing virtual DWO file? */
12478 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
,
12479 virtual_dwo_name
.c_str (),
12481 /* Create one if necessary. */
12482 if (*dwo_file_slot
== NULL
)
12484 if (dwarf_read_debug
)
12486 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12487 virtual_dwo_name
.c_str ());
12489 dwo_file
= new struct dwo_file
;
12490 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12491 dwo_file
->comp_dir
= comp_dir
;
12492 dwo_file
->sections
.abbrev
=
12493 create_dwp_v2_or_v5_section (per_objfile
,
12494 &dwp_file
->sections
.abbrev
,
12495 sections
.abbrev_offset
,
12496 sections
.abbrev_size
);
12497 dwo_file
->sections
.line
=
12498 create_dwp_v2_or_v5_section (per_objfile
,
12499 &dwp_file
->sections
.line
,
12500 sections
.line_offset
, sections
.line_size
);
12501 dwo_file
->sections
.macro
=
12502 create_dwp_v2_or_v5_section (per_objfile
,
12503 &dwp_file
->sections
.macro
,
12504 sections
.macro_offset
,
12505 sections
.macro_size
);
12506 dwo_file
->sections
.loclists
=
12507 create_dwp_v2_or_v5_section (per_objfile
,
12508 &dwp_file
->sections
.loclists
,
12509 sections
.loclists_offset
,
12510 sections
.loclists_size
);
12511 dwo_file
->sections
.rnglists
=
12512 create_dwp_v2_or_v5_section (per_objfile
,
12513 &dwp_file
->sections
.rnglists
,
12514 sections
.rnglists_offset
,
12515 sections
.rnglists_size
);
12516 dwo_file
->sections
.str_offsets
=
12517 create_dwp_v2_or_v5_section (per_objfile
,
12518 &dwp_file
->sections
.str_offsets
,
12519 sections
.str_offsets_offset
,
12520 sections
.str_offsets_size
);
12521 /* The "str" section is global to the entire DWP file. */
12522 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12523 /* The info or types section is assigned below to dwo_unit,
12524 there's no need to record it in dwo_file.
12525 Also, we can't simply record type sections in dwo_file because
12526 we record a pointer into the vector in dwo_unit. As we collect more
12527 types we'll grow the vector and eventually have to reallocate space
12528 for it, invalidating all copies of pointers into the previous
12530 *dwo_file_slot
= dwo_file
;
12534 if (dwarf_read_debug
)
12536 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12537 virtual_dwo_name
.c_str ());
12539 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12542 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12543 dwo_unit
->dwo_file
= dwo_file
;
12544 dwo_unit
->signature
= signature
;
12546 = XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12547 *dwo_unit
->section
= create_dwp_v2_or_v5_section (per_objfile
,
12548 &dwp_file
->sections
.info
,
12549 sections
.info_or_types_offset
,
12550 sections
.info_or_types_size
);
12551 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12556 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12557 Returns NULL if the signature isn't found. */
12559 static struct dwo_unit
*
12560 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
*per_objfile
,
12561 struct dwp_file
*dwp_file
, const char *comp_dir
,
12562 ULONGEST signature
, int is_debug_types
)
12564 const struct dwp_hash_table
*dwp_htab
=
12565 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12566 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12567 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12568 uint32_t hash
= signature
& mask
;
12569 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12572 struct dwo_unit find_dwo_cu
;
12574 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12575 find_dwo_cu
.signature
= signature
;
12576 slot
= htab_find_slot (is_debug_types
12577 ? dwp_file
->loaded_tus
.get ()
12578 : dwp_file
->loaded_cus
.get (),
12579 &find_dwo_cu
, INSERT
);
12582 return (struct dwo_unit
*) *slot
;
12584 /* Use a for loop so that we don't loop forever on bad debug info. */
12585 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12587 ULONGEST signature_in_table
;
12589 signature_in_table
=
12590 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12591 if (signature_in_table
== signature
)
12593 uint32_t unit_index
=
12594 read_4_bytes (dbfd
,
12595 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12597 if (dwp_file
->version
== 1)
12599 *slot
= create_dwo_unit_in_dwp_v1 (per_objfile
, dwp_file
,
12600 unit_index
, comp_dir
,
12601 signature
, is_debug_types
);
12603 else if (dwp_file
->version
== 2)
12605 *slot
= create_dwo_unit_in_dwp_v2 (per_objfile
, dwp_file
,
12606 unit_index
, comp_dir
,
12607 signature
, is_debug_types
);
12609 else /* version == 5 */
12611 *slot
= create_dwo_unit_in_dwp_v5 (per_objfile
, dwp_file
,
12612 unit_index
, comp_dir
,
12613 signature
, is_debug_types
);
12615 return (struct dwo_unit
*) *slot
;
12617 if (signature_in_table
== 0)
12619 hash
= (hash
+ hash2
) & mask
;
12622 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12623 " [in module %s]"),
12627 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12628 Open the file specified by FILE_NAME and hand it off to BFD for
12629 preliminary analysis. Return a newly initialized bfd *, which
12630 includes a canonicalized copy of FILE_NAME.
12631 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12632 SEARCH_CWD is true if the current directory is to be searched.
12633 It will be searched before debug-file-directory.
12634 If successful, the file is added to the bfd include table of the
12635 objfile's bfd (see gdb_bfd_record_inclusion).
12636 If unable to find/open the file, return NULL.
12637 NOTE: This function is derived from symfile_bfd_open. */
12639 static gdb_bfd_ref_ptr
12640 try_open_dwop_file (dwarf2_per_objfile
*per_objfile
,
12641 const char *file_name
, int is_dwp
, int search_cwd
)
12644 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12645 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12646 to debug_file_directory. */
12647 const char *search_path
;
12648 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12650 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12653 if (*debug_file_directory
!= '\0')
12655 search_path_holder
.reset (concat (".", dirname_separator_string
,
12656 debug_file_directory
,
12658 search_path
= search_path_holder
.get ();
12664 search_path
= debug_file_directory
;
12666 openp_flags flags
= OPF_RETURN_REALPATH
;
12668 flags
|= OPF_SEARCH_IN_PATH
;
12670 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12671 desc
= openp (search_path
, flags
, file_name
,
12672 O_RDONLY
| O_BINARY
, &absolute_name
);
12676 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12678 if (sym_bfd
== NULL
)
12680 bfd_set_cacheable (sym_bfd
.get (), 1);
12682 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12685 /* Success. Record the bfd as having been included by the objfile's bfd.
12686 This is important because things like demangled_names_hash lives in the
12687 objfile's per_bfd space and may have references to things like symbol
12688 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12689 gdb_bfd_record_inclusion (per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12694 /* Try to open DWO file FILE_NAME.
12695 COMP_DIR is the DW_AT_comp_dir attribute.
12696 The result is the bfd handle of the file.
12697 If there is a problem finding or opening the file, return NULL.
12698 Upon success, the canonicalized path of the file is stored in the bfd,
12699 same as symfile_bfd_open. */
12701 static gdb_bfd_ref_ptr
12702 open_dwo_file (dwarf2_per_objfile
*per_objfile
,
12703 const char *file_name
, const char *comp_dir
)
12705 if (IS_ABSOLUTE_PATH (file_name
))
12706 return try_open_dwop_file (per_objfile
, file_name
,
12707 0 /*is_dwp*/, 0 /*search_cwd*/);
12709 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12711 if (comp_dir
!= NULL
)
12713 gdb::unique_xmalloc_ptr
<char> path_to_try
12714 (concat (comp_dir
, SLASH_STRING
, file_name
, (char *) NULL
));
12716 /* NOTE: If comp_dir is a relative path, this will also try the
12717 search path, which seems useful. */
12718 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, path_to_try
.get (),
12720 1 /*search_cwd*/));
12725 /* That didn't work, try debug-file-directory, which, despite its name,
12726 is a list of paths. */
12728 if (*debug_file_directory
== '\0')
12731 return try_open_dwop_file (per_objfile
, file_name
,
12732 0 /*is_dwp*/, 1 /*search_cwd*/);
12735 /* This function is mapped across the sections and remembers the offset and
12736 size of each of the DWO debugging sections we are interested in. */
12739 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
,
12740 dwo_sections
*dwo_sections
)
12742 const struct dwop_section_names
*names
= &dwop_section_names
;
12744 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12746 dwo_sections
->abbrev
.s
.section
= sectp
;
12747 dwo_sections
->abbrev
.size
= bfd_section_size (sectp
);
12749 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12751 dwo_sections
->info
.s
.section
= sectp
;
12752 dwo_sections
->info
.size
= bfd_section_size (sectp
);
12754 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12756 dwo_sections
->line
.s
.section
= sectp
;
12757 dwo_sections
->line
.size
= bfd_section_size (sectp
);
12759 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12761 dwo_sections
->loc
.s
.section
= sectp
;
12762 dwo_sections
->loc
.size
= bfd_section_size (sectp
);
12764 else if (section_is_p (sectp
->name
, &names
->loclists_dwo
))
12766 dwo_sections
->loclists
.s
.section
= sectp
;
12767 dwo_sections
->loclists
.size
= bfd_section_size (sectp
);
12769 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12771 dwo_sections
->macinfo
.s
.section
= sectp
;
12772 dwo_sections
->macinfo
.size
= bfd_section_size (sectp
);
12774 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12776 dwo_sections
->macro
.s
.section
= sectp
;
12777 dwo_sections
->macro
.size
= bfd_section_size (sectp
);
12779 else if (section_is_p (sectp
->name
, &names
->rnglists_dwo
))
12781 dwo_sections
->rnglists
.s
.section
= sectp
;
12782 dwo_sections
->rnglists
.size
= bfd_section_size (sectp
);
12784 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
12786 dwo_sections
->str
.s
.section
= sectp
;
12787 dwo_sections
->str
.size
= bfd_section_size (sectp
);
12789 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12791 dwo_sections
->str_offsets
.s
.section
= sectp
;
12792 dwo_sections
->str_offsets
.size
= bfd_section_size (sectp
);
12794 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
12796 struct dwarf2_section_info type_section
;
12798 memset (&type_section
, 0, sizeof (type_section
));
12799 type_section
.s
.section
= sectp
;
12800 type_section
.size
= bfd_section_size (sectp
);
12801 dwo_sections
->types
.push_back (type_section
);
12805 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12806 by PER_CU. This is for the non-DWP case.
12807 The result is NULL if DWO_NAME can't be found. */
12809 static struct dwo_file
*
12810 open_and_init_dwo_file (dwarf2_cu
*cu
, const char *dwo_name
,
12811 const char *comp_dir
)
12813 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
12815 gdb_bfd_ref_ptr dbfd
= open_dwo_file (per_objfile
, dwo_name
, comp_dir
);
12818 if (dwarf_read_debug
)
12819 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
12823 dwo_file_up
dwo_file (new struct dwo_file
);
12824 dwo_file
->dwo_name
= dwo_name
;
12825 dwo_file
->comp_dir
= comp_dir
;
12826 dwo_file
->dbfd
= std::move (dbfd
);
12828 for (asection
*sec
: gdb_bfd_sections (dwo_file
->dbfd
))
12829 dwarf2_locate_dwo_sections (dwo_file
->dbfd
.get (), sec
,
12830 &dwo_file
->sections
);
12832 create_cus_hash_table (per_objfile
, cu
, *dwo_file
, dwo_file
->sections
.info
,
12835 if (cu
->per_cu
->dwarf_version
< 5)
12837 create_debug_types_hash_table (per_objfile
, dwo_file
.get (),
12838 dwo_file
->sections
.types
, dwo_file
->tus
);
12842 create_debug_type_hash_table (per_objfile
, dwo_file
.get (),
12843 &dwo_file
->sections
.info
, dwo_file
->tus
,
12847 if (dwarf_read_debug
)
12848 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
12850 return dwo_file
.release ();
12853 /* This function is mapped across the sections and remembers the offset and
12854 size of each of the DWP debugging sections common to version 1 and 2 that
12855 we are interested in. */
12858 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
12859 dwp_file
*dwp_file
)
12861 const struct dwop_section_names
*names
= &dwop_section_names
;
12862 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12864 /* Record the ELF section number for later lookup: this is what the
12865 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12866 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12867 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12869 /* Look for specific sections that we need. */
12870 if (section_is_p (sectp
->name
, &names
->str_dwo
))
12872 dwp_file
->sections
.str
.s
.section
= sectp
;
12873 dwp_file
->sections
.str
.size
= bfd_section_size (sectp
);
12875 else if (section_is_p (sectp
->name
, &names
->cu_index
))
12877 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
12878 dwp_file
->sections
.cu_index
.size
= bfd_section_size (sectp
);
12880 else if (section_is_p (sectp
->name
, &names
->tu_index
))
12882 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
12883 dwp_file
->sections
.tu_index
.size
= bfd_section_size (sectp
);
12887 /* This function is mapped across the sections and remembers the offset and
12888 size of each of the DWP version 2 debugging sections that we are interested
12889 in. This is split into a separate function because we don't know if we
12890 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12893 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12895 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12896 const struct dwop_section_names
*names
= &dwop_section_names
;
12897 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12899 /* Record the ELF section number for later lookup: this is what the
12900 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12901 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12902 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12904 /* Look for specific sections that we need. */
12905 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12907 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12908 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12910 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12912 dwp_file
->sections
.info
.s
.section
= sectp
;
12913 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12915 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12917 dwp_file
->sections
.line
.s
.section
= sectp
;
12918 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12920 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12922 dwp_file
->sections
.loc
.s
.section
= sectp
;
12923 dwp_file
->sections
.loc
.size
= bfd_section_size (sectp
);
12925 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12927 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
12928 dwp_file
->sections
.macinfo
.size
= bfd_section_size (sectp
);
12930 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12932 dwp_file
->sections
.macro
.s
.section
= sectp
;
12933 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12935 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12937 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12938 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12940 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
12942 dwp_file
->sections
.types
.s
.section
= sectp
;
12943 dwp_file
->sections
.types
.size
= bfd_section_size (sectp
);
12947 /* This function is mapped across the sections and remembers the offset and
12948 size of each of the DWP version 5 debugging sections that we are interested
12949 in. This is split into a separate function because we don't know if we
12950 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12953 dwarf2_locate_v5_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12955 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12956 const struct dwop_section_names
*names
= &dwop_section_names
;
12957 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12959 /* Record the ELF section number for later lookup: this is what the
12960 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12961 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12962 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12964 /* Look for specific sections that we need. */
12965 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12967 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12968 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12970 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12972 dwp_file
->sections
.info
.s
.section
= sectp
;
12973 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12975 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12977 dwp_file
->sections
.line
.s
.section
= sectp
;
12978 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12980 else if (section_is_p (sectp
->name
, &names
->loclists_dwo
))
12982 dwp_file
->sections
.loclists
.s
.section
= sectp
;
12983 dwp_file
->sections
.loclists
.size
= bfd_section_size (sectp
);
12985 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12987 dwp_file
->sections
.macro
.s
.section
= sectp
;
12988 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12990 else if (section_is_p (sectp
->name
, &names
->rnglists_dwo
))
12992 dwp_file
->sections
.rnglists
.s
.section
= sectp
;
12993 dwp_file
->sections
.rnglists
.size
= bfd_section_size (sectp
);
12995 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12997 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12998 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
13002 /* Hash function for dwp_file loaded CUs/TUs. */
13005 hash_dwp_loaded_cutus (const void *item
)
13007 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
13009 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13010 return dwo_unit
->signature
;
13013 /* Equality function for dwp_file loaded CUs/TUs. */
13016 eq_dwp_loaded_cutus (const void *a
, const void *b
)
13018 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
13019 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
13021 return dua
->signature
== dub
->signature
;
13024 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13027 allocate_dwp_loaded_cutus_table ()
13029 return htab_up (htab_create_alloc (3,
13030 hash_dwp_loaded_cutus
,
13031 eq_dwp_loaded_cutus
,
13032 NULL
, xcalloc
, xfree
));
13035 /* Try to open DWP file FILE_NAME.
13036 The result is the bfd handle of the file.
13037 If there is a problem finding or opening the file, return NULL.
13038 Upon success, the canonicalized path of the file is stored in the bfd,
13039 same as symfile_bfd_open. */
13041 static gdb_bfd_ref_ptr
13042 open_dwp_file (dwarf2_per_objfile
*per_objfile
, const char *file_name
)
13044 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, file_name
,
13046 1 /*search_cwd*/));
13050 /* Work around upstream bug 15652.
13051 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13052 [Whether that's a "bug" is debatable, but it is getting in our way.]
13053 We have no real idea where the dwp file is, because gdb's realpath-ing
13054 of the executable's path may have discarded the needed info.
13055 [IWBN if the dwp file name was recorded in the executable, akin to
13056 .gnu_debuglink, but that doesn't exist yet.]
13057 Strip the directory from FILE_NAME and search again. */
13058 if (*debug_file_directory
!= '\0')
13060 /* Don't implicitly search the current directory here.
13061 If the user wants to search "." to handle this case,
13062 it must be added to debug-file-directory. */
13063 return try_open_dwop_file (per_objfile
, lbasename (file_name
),
13071 /* Initialize the use of the DWP file for the current objfile.
13072 By convention the name of the DWP file is ${objfile}.dwp.
13073 The result is NULL if it can't be found. */
13075 static std::unique_ptr
<struct dwp_file
>
13076 open_and_init_dwp_file (dwarf2_per_objfile
*per_objfile
)
13078 struct objfile
*objfile
= per_objfile
->objfile
;
13080 /* Try to find first .dwp for the binary file before any symbolic links
13083 /* If the objfile is a debug file, find the name of the real binary
13084 file and get the name of dwp file from there. */
13085 std::string dwp_name
;
13086 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
13088 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
13089 const char *backlink_basename
= lbasename (backlink
->original_name
);
13091 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
13094 dwp_name
= objfile
->original_name
;
13096 dwp_name
+= ".dwp";
13098 gdb_bfd_ref_ptr
dbfd (open_dwp_file (per_objfile
, dwp_name
.c_str ()));
13100 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
13102 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13103 dwp_name
= objfile_name (objfile
);
13104 dwp_name
+= ".dwp";
13105 dbfd
= open_dwp_file (per_objfile
, dwp_name
.c_str ());
13110 if (dwarf_read_debug
)
13111 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
.c_str ());
13112 return std::unique_ptr
<dwp_file
> ();
13115 const char *name
= bfd_get_filename (dbfd
.get ());
13116 std::unique_ptr
<struct dwp_file
> dwp_file
13117 (new struct dwp_file (name
, std::move (dbfd
)));
13119 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
13120 dwp_file
->elf_sections
=
13121 OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
13122 dwp_file
->num_sections
, asection
*);
13124 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
13125 dwarf2_locate_common_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13128 dwp_file
->cus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 0);
13130 dwp_file
->tus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 1);
13132 /* The DWP file version is stored in the hash table. Oh well. */
13133 if (dwp_file
->cus
&& dwp_file
->tus
13134 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
13136 /* Technically speaking, we should try to limp along, but this is
13137 pretty bizarre. We use pulongest here because that's the established
13138 portability solution (e.g, we cannot use %u for uint32_t). */
13139 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13140 " TU version %s [in DWP file %s]"),
13141 pulongest (dwp_file
->cus
->version
),
13142 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
13146 dwp_file
->version
= dwp_file
->cus
->version
;
13147 else if (dwp_file
->tus
)
13148 dwp_file
->version
= dwp_file
->tus
->version
;
13150 dwp_file
->version
= 2;
13152 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
13154 if (dwp_file
->version
== 2)
13155 dwarf2_locate_v2_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13158 dwarf2_locate_v5_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13162 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table ();
13163 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table ();
13165 if (dwarf_read_debug
)
13167 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
13168 fprintf_unfiltered (gdb_stdlog
,
13169 " %s CUs, %s TUs\n",
13170 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
13171 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
13177 /* Wrapper around open_and_init_dwp_file, only open it once. */
13179 static struct dwp_file
*
13180 get_dwp_file (dwarf2_per_objfile
*per_objfile
)
13182 if (!per_objfile
->per_bfd
->dwp_checked
)
13184 per_objfile
->per_bfd
->dwp_file
= open_and_init_dwp_file (per_objfile
);
13185 per_objfile
->per_bfd
->dwp_checked
= 1;
13187 return per_objfile
->per_bfd
->dwp_file
.get ();
13190 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13191 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13192 or in the DWP file for the objfile, referenced by THIS_UNIT.
13193 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13194 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13196 This is called, for example, when wanting to read a variable with a
13197 complex location. Therefore we don't want to do file i/o for every call.
13198 Therefore we don't want to look for a DWO file on every call.
13199 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13200 then we check if we've already seen DWO_NAME, and only THEN do we check
13203 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13204 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13206 static struct dwo_unit
*
13207 lookup_dwo_cutu (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
13208 ULONGEST signature
, int is_debug_types
)
13210 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13211 struct objfile
*objfile
= per_objfile
->objfile
;
13212 const char *kind
= is_debug_types
? "TU" : "CU";
13213 void **dwo_file_slot
;
13214 struct dwo_file
*dwo_file
;
13215 struct dwp_file
*dwp_file
;
13217 /* First see if there's a DWP file.
13218 If we have a DWP file but didn't find the DWO inside it, don't
13219 look for the original DWO file. It makes gdb behave differently
13220 depending on whether one is debugging in the build tree. */
13222 dwp_file
= get_dwp_file (per_objfile
);
13223 if (dwp_file
!= NULL
)
13225 const struct dwp_hash_table
*dwp_htab
=
13226 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
13228 if (dwp_htab
!= NULL
)
13230 struct dwo_unit
*dwo_cutu
=
13231 lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, comp_dir
, signature
,
13234 if (dwo_cutu
!= NULL
)
13236 if (dwarf_read_debug
)
13238 fprintf_unfiltered (gdb_stdlog
,
13239 "Virtual DWO %s %s found: @%s\n",
13240 kind
, hex_string (signature
),
13241 host_address_to_string (dwo_cutu
));
13249 /* No DWP file, look for the DWO file. */
13251 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, dwo_name
, comp_dir
);
13252 if (*dwo_file_slot
== NULL
)
13254 /* Read in the file and build a table of the CUs/TUs it contains. */
13255 *dwo_file_slot
= open_and_init_dwo_file (cu
, dwo_name
, comp_dir
);
13257 /* NOTE: This will be NULL if unable to open the file. */
13258 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
13260 if (dwo_file
!= NULL
)
13262 struct dwo_unit
*dwo_cutu
= NULL
;
13264 if (is_debug_types
&& dwo_file
->tus
)
13266 struct dwo_unit find_dwo_cutu
;
13268 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13269 find_dwo_cutu
.signature
= signature
;
13271 = (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
13274 else if (!is_debug_types
&& dwo_file
->cus
)
13276 struct dwo_unit find_dwo_cutu
;
13278 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13279 find_dwo_cutu
.signature
= signature
;
13280 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
.get (),
13284 if (dwo_cutu
!= NULL
)
13286 if (dwarf_read_debug
)
13288 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
13289 kind
, dwo_name
, hex_string (signature
),
13290 host_address_to_string (dwo_cutu
));
13297 /* We didn't find it. This could mean a dwo_id mismatch, or
13298 someone deleted the DWO/DWP file, or the search path isn't set up
13299 correctly to find the file. */
13301 if (dwarf_read_debug
)
13303 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
13304 kind
, dwo_name
, hex_string (signature
));
13307 /* This is a warning and not a complaint because it can be caused by
13308 pilot error (e.g., user accidentally deleting the DWO). */
13310 /* Print the name of the DWP file if we looked there, helps the user
13311 better diagnose the problem. */
13312 std::string dwp_text
;
13314 if (dwp_file
!= NULL
)
13315 dwp_text
= string_printf (" [in DWP file %s]",
13316 lbasename (dwp_file
->name
));
13318 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13319 " [in module %s]"),
13320 kind
, dwo_name
, hex_string (signature
), dwp_text
.c_str (), kind
,
13321 sect_offset_str (cu
->per_cu
->sect_off
), objfile_name (objfile
));
13326 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13327 See lookup_dwo_cutu_unit for details. */
13329 static struct dwo_unit
*
13330 lookup_dwo_comp_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
13331 ULONGEST signature
)
13333 gdb_assert (!cu
->per_cu
->is_debug_types
);
13335 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, signature
, 0);
13338 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13339 See lookup_dwo_cutu_unit for details. */
13341 static struct dwo_unit
*
13342 lookup_dwo_type_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
)
13344 gdb_assert (cu
->per_cu
->is_debug_types
);
13346 signatured_type
*sig_type
= (signatured_type
*) cu
->per_cu
;
13348 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, sig_type
->signature
, 1);
13351 /* Traversal function for queue_and_load_all_dwo_tus. */
13354 queue_and_load_dwo_tu (void **slot
, void *info
)
13356 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
13357 dwarf2_cu
*cu
= (dwarf2_cu
*) info
;
13358 ULONGEST signature
= dwo_unit
->signature
;
13359 signatured_type
*sig_type
= lookup_dwo_signatured_type (cu
, signature
);
13361 if (sig_type
!= NULL
)
13363 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
13365 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13366 a real dependency of PER_CU on SIG_TYPE. That is detected later
13367 while processing PER_CU. */
13368 if (maybe_queue_comp_unit (NULL
, sig_cu
, cu
->per_objfile
, cu
->language
))
13369 load_full_type_unit (sig_cu
, cu
->per_objfile
);
13370 cu
->per_cu
->imported_symtabs_push (sig_cu
);
13376 /* Queue all TUs contained in the DWO of CU to be read in.
13377 The DWO may have the only definition of the type, though it may not be
13378 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13379 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13382 queue_and_load_all_dwo_tus (dwarf2_cu
*cu
)
13384 struct dwo_unit
*dwo_unit
;
13385 struct dwo_file
*dwo_file
;
13387 gdb_assert (cu
!= nullptr);
13388 gdb_assert (!cu
->per_cu
->is_debug_types
);
13389 gdb_assert (get_dwp_file (cu
->per_objfile
) == nullptr);
13391 dwo_unit
= cu
->dwo_unit
;
13392 gdb_assert (dwo_unit
!= NULL
);
13394 dwo_file
= dwo_unit
->dwo_file
;
13395 if (dwo_file
->tus
!= NULL
)
13396 htab_traverse_noresize (dwo_file
->tus
.get (), queue_and_load_dwo_tu
, cu
);
13399 /* Read in various DIEs. */
13401 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13402 Inherit only the children of the DW_AT_abstract_origin DIE not being
13403 already referenced by DW_AT_abstract_origin from the children of the
13407 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
13409 struct die_info
*child_die
;
13410 sect_offset
*offsetp
;
13411 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13412 struct die_info
*origin_die
;
13413 /* Iterator of the ORIGIN_DIE children. */
13414 struct die_info
*origin_child_die
;
13415 struct attribute
*attr
;
13416 struct dwarf2_cu
*origin_cu
;
13417 struct pending
**origin_previous_list_in_scope
;
13419 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13423 /* Note that following die references may follow to a die in a
13427 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
13429 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13431 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
13432 origin_cu
->list_in_scope
= cu
->list_in_scope
;
13434 if (die
->tag
!= origin_die
->tag
13435 && !(die
->tag
== DW_TAG_inlined_subroutine
13436 && origin_die
->tag
== DW_TAG_subprogram
))
13437 complaint (_("DIE %s and its abstract origin %s have different tags"),
13438 sect_offset_str (die
->sect_off
),
13439 sect_offset_str (origin_die
->sect_off
));
13441 std::vector
<sect_offset
> offsets
;
13443 for (child_die
= die
->child
;
13444 child_die
&& child_die
->tag
;
13445 child_die
= child_die
->sibling
)
13447 struct die_info
*child_origin_die
;
13448 struct dwarf2_cu
*child_origin_cu
;
13450 /* We are trying to process concrete instance entries:
13451 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13452 it's not relevant to our analysis here. i.e. detecting DIEs that are
13453 present in the abstract instance but not referenced in the concrete
13455 if (child_die
->tag
== DW_TAG_call_site
13456 || child_die
->tag
== DW_TAG_GNU_call_site
)
13459 /* For each CHILD_DIE, find the corresponding child of
13460 ORIGIN_DIE. If there is more than one layer of
13461 DW_AT_abstract_origin, follow them all; there shouldn't be,
13462 but GCC versions at least through 4.4 generate this (GCC PR
13464 child_origin_die
= child_die
;
13465 child_origin_cu
= cu
;
13468 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
13472 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
13476 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13477 counterpart may exist. */
13478 if (child_origin_die
!= child_die
)
13480 if (child_die
->tag
!= child_origin_die
->tag
13481 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13482 && child_origin_die
->tag
== DW_TAG_subprogram
))
13483 complaint (_("Child DIE %s and its abstract origin %s have "
13485 sect_offset_str (child_die
->sect_off
),
13486 sect_offset_str (child_origin_die
->sect_off
));
13487 if (child_origin_die
->parent
!= origin_die
)
13488 complaint (_("Child DIE %s and its abstract origin %s have "
13489 "different parents"),
13490 sect_offset_str (child_die
->sect_off
),
13491 sect_offset_str (child_origin_die
->sect_off
));
13493 offsets
.push_back (child_origin_die
->sect_off
);
13496 std::sort (offsets
.begin (), offsets
.end ());
13497 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13498 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13499 if (offsetp
[-1] == *offsetp
)
13500 complaint (_("Multiple children of DIE %s refer "
13501 "to DIE %s as their abstract origin"),
13502 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
13504 offsetp
= offsets
.data ();
13505 origin_child_die
= origin_die
->child
;
13506 while (origin_child_die
&& origin_child_die
->tag
)
13508 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13509 while (offsetp
< offsets_end
13510 && *offsetp
< origin_child_die
->sect_off
)
13512 if (offsetp
>= offsets_end
13513 || *offsetp
> origin_child_die
->sect_off
)
13515 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13516 Check whether we're already processing ORIGIN_CHILD_DIE.
13517 This can happen with mutually referenced abstract_origins.
13519 if (!origin_child_die
->in_process
)
13520 process_die (origin_child_die
, origin_cu
);
13522 origin_child_die
= origin_child_die
->sibling
;
13524 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13526 if (cu
!= origin_cu
)
13527 compute_delayed_physnames (origin_cu
);
13531 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13533 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13534 struct gdbarch
*gdbarch
= objfile
->arch ();
13535 struct context_stack
*newobj
;
13538 struct die_info
*child_die
;
13539 struct attribute
*attr
, *call_line
, *call_file
;
13541 CORE_ADDR baseaddr
;
13542 struct block
*block
;
13543 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13544 std::vector
<struct symbol
*> template_args
;
13545 struct template_symbol
*templ_func
= NULL
;
13549 /* If we do not have call site information, we can't show the
13550 caller of this inlined function. That's too confusing, so
13551 only use the scope for local variables. */
13552 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13553 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13554 if (call_line
== NULL
|| call_file
== NULL
)
13556 read_lexical_block_scope (die
, cu
);
13561 baseaddr
= objfile
->text_section_offset ();
13563 name
= dwarf2_name (die
, cu
);
13565 /* Ignore functions with missing or empty names. These are actually
13566 illegal according to the DWARF standard. */
13569 complaint (_("missing name for subprogram DIE at %s"),
13570 sect_offset_str (die
->sect_off
));
13574 /* Ignore functions with missing or invalid low and high pc attributes. */
13575 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13576 <= PC_BOUNDS_INVALID
)
13578 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13579 if (attr
== nullptr || !attr
->as_boolean ())
13580 complaint (_("cannot get low and high bounds "
13581 "for subprogram DIE at %s"),
13582 sect_offset_str (die
->sect_off
));
13586 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13587 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13589 /* If we have any template arguments, then we must allocate a
13590 different sort of symbol. */
13591 for (child_die
= die
->child
; child_die
; child_die
= child_die
->sibling
)
13593 if (child_die
->tag
== DW_TAG_template_type_param
13594 || child_die
->tag
== DW_TAG_template_value_param
)
13596 templ_func
= new (&objfile
->objfile_obstack
) template_symbol
;
13597 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13602 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13603 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13604 (struct symbol
*) templ_func
);
13606 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13607 set_objfile_main_name (objfile
, newobj
->name
->linkage_name (),
13610 /* If there is a location expression for DW_AT_frame_base, record
13612 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13613 if (attr
!= nullptr)
13614 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13616 /* If there is a location for the static link, record it. */
13617 newobj
->static_link
= NULL
;
13618 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13619 if (attr
!= nullptr)
13621 newobj
->static_link
13622 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13623 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
13627 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13629 if (die
->child
!= NULL
)
13631 child_die
= die
->child
;
13632 while (child_die
&& child_die
->tag
)
13634 if (child_die
->tag
== DW_TAG_template_type_param
13635 || child_die
->tag
== DW_TAG_template_value_param
)
13637 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13640 template_args
.push_back (arg
);
13643 process_die (child_die
, cu
);
13644 child_die
= child_die
->sibling
;
13648 inherit_abstract_dies (die
, cu
);
13650 /* If we have a DW_AT_specification, we might need to import using
13651 directives from the context of the specification DIE. See the
13652 comment in determine_prefix. */
13653 if (cu
->language
== language_cplus
13654 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13656 struct dwarf2_cu
*spec_cu
= cu
;
13657 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13661 child_die
= spec_die
->child
;
13662 while (child_die
&& child_die
->tag
)
13664 if (child_die
->tag
== DW_TAG_imported_module
)
13665 process_die (child_die
, spec_cu
);
13666 child_die
= child_die
->sibling
;
13669 /* In some cases, GCC generates specification DIEs that
13670 themselves contain DW_AT_specification attributes. */
13671 spec_die
= die_specification (spec_die
, &spec_cu
);
13675 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13676 /* Make a block for the local symbols within. */
13677 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13678 cstk
.static_link
, lowpc
, highpc
);
13680 /* For C++, set the block's scope. */
13681 if ((cu
->language
== language_cplus
13682 || cu
->language
== language_fortran
13683 || cu
->language
== language_d
13684 || cu
->language
== language_rust
)
13685 && cu
->processing_has_namespace_info
)
13686 block_set_scope (block
, determine_prefix (die
, cu
),
13687 &objfile
->objfile_obstack
);
13689 /* If we have address ranges, record them. */
13690 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13692 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13694 /* Attach template arguments to function. */
13695 if (!template_args
.empty ())
13697 gdb_assert (templ_func
!= NULL
);
13699 templ_func
->n_template_arguments
= template_args
.size ();
13700 templ_func
->template_arguments
13701 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13702 templ_func
->n_template_arguments
);
13703 memcpy (templ_func
->template_arguments
,
13704 template_args
.data (),
13705 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13707 /* Make sure that the symtab is set on the new symbols. Even
13708 though they don't appear in this symtab directly, other parts
13709 of gdb assume that symbols do, and this is reasonably
13711 for (symbol
*sym
: template_args
)
13712 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13715 /* In C++, we can have functions nested inside functions (e.g., when
13716 a function declares a class that has methods). This means that
13717 when we finish processing a function scope, we may need to go
13718 back to building a containing block's symbol lists. */
13719 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13720 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13722 /* If we've finished processing a top-level function, subsequent
13723 symbols go in the file symbol list. */
13724 if (cu
->get_builder ()->outermost_context_p ())
13725 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13728 /* Process all the DIES contained within a lexical block scope. Start
13729 a new scope, process the dies, and then close the scope. */
13732 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13734 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13735 struct gdbarch
*gdbarch
= objfile
->arch ();
13736 CORE_ADDR lowpc
, highpc
;
13737 struct die_info
*child_die
;
13738 CORE_ADDR baseaddr
;
13740 baseaddr
= objfile
->text_section_offset ();
13742 /* Ignore blocks with missing or invalid low and high pc attributes. */
13743 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13744 as multiple lexical blocks? Handling children in a sane way would
13745 be nasty. Might be easier to properly extend generic blocks to
13746 describe ranges. */
13747 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13749 case PC_BOUNDS_NOT_PRESENT
:
13750 /* DW_TAG_lexical_block has no attributes, process its children as if
13751 there was no wrapping by that DW_TAG_lexical_block.
13752 GCC does no longer produces such DWARF since GCC r224161. */
13753 for (child_die
= die
->child
;
13754 child_die
!= NULL
&& child_die
->tag
;
13755 child_die
= child_die
->sibling
)
13757 /* We might already be processing this DIE. This can happen
13758 in an unusual circumstance -- where a subroutine A
13759 appears lexically in another subroutine B, but A actually
13760 inlines B. The recursion is broken here, rather than in
13761 inherit_abstract_dies, because it seems better to simply
13762 drop concrete children here. */
13763 if (!child_die
->in_process
)
13764 process_die (child_die
, cu
);
13767 case PC_BOUNDS_INVALID
:
13770 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13771 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13773 cu
->get_builder ()->push_context (0, lowpc
);
13774 if (die
->child
!= NULL
)
13776 child_die
= die
->child
;
13777 while (child_die
&& child_die
->tag
)
13779 process_die (child_die
, cu
);
13780 child_die
= child_die
->sibling
;
13783 inherit_abstract_dies (die
, cu
);
13784 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13786 if (*cu
->get_builder ()->get_local_symbols () != NULL
13787 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13789 struct block
*block
13790 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13791 cstk
.start_addr
, highpc
);
13793 /* Note that recording ranges after traversing children, as we
13794 do here, means that recording a parent's ranges entails
13795 walking across all its children's ranges as they appear in
13796 the address map, which is quadratic behavior.
13798 It would be nicer to record the parent's ranges before
13799 traversing its children, simply overriding whatever you find
13800 there. But since we don't even decide whether to create a
13801 block until after we've traversed its children, that's hard
13803 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13805 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13806 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13809 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13812 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13814 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13815 struct objfile
*objfile
= per_objfile
->objfile
;
13816 struct gdbarch
*gdbarch
= objfile
->arch ();
13817 CORE_ADDR pc
, baseaddr
;
13818 struct attribute
*attr
;
13819 struct call_site
*call_site
, call_site_local
;
13822 struct die_info
*child_die
;
13824 baseaddr
= objfile
->text_section_offset ();
13826 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13829 /* This was a pre-DWARF-5 GNU extension alias
13830 for DW_AT_call_return_pc. */
13831 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13835 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13836 "DIE %s [in module %s]"),
13837 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13840 pc
= attr
->as_address () + baseaddr
;
13841 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13843 if (cu
->call_site_htab
== NULL
)
13844 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13845 NULL
, &objfile
->objfile_obstack
,
13846 hashtab_obstack_allocate
, NULL
);
13847 call_site_local
.pc
= pc
;
13848 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13851 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13852 "DIE %s [in module %s]"),
13853 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13854 objfile_name (objfile
));
13858 /* Count parameters at the caller. */
13861 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13862 child_die
= child_die
->sibling
)
13864 if (child_die
->tag
!= DW_TAG_call_site_parameter
13865 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13867 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13868 "DW_TAG_call_site child DIE %s [in module %s]"),
13869 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
13870 objfile_name (objfile
));
13878 = ((struct call_site
*)
13879 obstack_alloc (&objfile
->objfile_obstack
,
13880 sizeof (*call_site
)
13881 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
13883 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
13884 call_site
->pc
= pc
;
13886 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
13887 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
13889 struct die_info
*func_die
;
13891 /* Skip also over DW_TAG_inlined_subroutine. */
13892 for (func_die
= die
->parent
;
13893 func_die
&& func_die
->tag
!= DW_TAG_subprogram
13894 && func_die
->tag
!= DW_TAG_subroutine_type
;
13895 func_die
= func_die
->parent
);
13897 /* DW_AT_call_all_calls is a superset
13898 of DW_AT_call_all_tail_calls. */
13900 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
13901 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
13902 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
13903 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
13905 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13906 not complete. But keep CALL_SITE for look ups via call_site_htab,
13907 both the initial caller containing the real return address PC and
13908 the final callee containing the current PC of a chain of tail
13909 calls do not need to have the tail call list complete. But any
13910 function candidate for a virtual tail call frame searched via
13911 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13912 determined unambiguously. */
13916 struct type
*func_type
= NULL
;
13919 func_type
= get_die_type (func_die
, cu
);
13920 if (func_type
!= NULL
)
13922 gdb_assert (func_type
->code () == TYPE_CODE_FUNC
);
13924 /* Enlist this call site to the function. */
13925 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
13926 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
13929 complaint (_("Cannot find function owning DW_TAG_call_site "
13930 "DIE %s [in module %s]"),
13931 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13935 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
13937 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
13939 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
13942 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
13943 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13945 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
13946 if (!attr
|| (attr
->form_is_block () && attr
->as_block ()->size
== 0))
13947 /* Keep NULL DWARF_BLOCK. */;
13948 else if (attr
->form_is_block ())
13950 struct dwarf2_locexpr_baton
*dlbaton
;
13951 struct dwarf_block
*block
= attr
->as_block ();
13953 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
13954 dlbaton
->data
= block
->data
;
13955 dlbaton
->size
= block
->size
;
13956 dlbaton
->per_objfile
= per_objfile
;
13957 dlbaton
->per_cu
= cu
->per_cu
;
13959 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
13961 else if (attr
->form_is_ref ())
13963 struct dwarf2_cu
*target_cu
= cu
;
13964 struct die_info
*target_die
;
13966 target_die
= follow_die_ref (die
, attr
, &target_cu
);
13967 gdb_assert (target_cu
->per_objfile
->objfile
== objfile
);
13968 if (die_is_declaration (target_die
, target_cu
))
13970 const char *target_physname
;
13972 /* Prefer the mangled name; otherwise compute the demangled one. */
13973 target_physname
= dw2_linkage_name (target_die
, target_cu
);
13974 if (target_physname
== NULL
)
13975 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
13976 if (target_physname
== NULL
)
13977 complaint (_("DW_AT_call_target target DIE has invalid "
13978 "physname, for referencing DIE %s [in module %s]"),
13979 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13981 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
13987 /* DW_AT_entry_pc should be preferred. */
13988 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
13989 <= PC_BOUNDS_INVALID
)
13990 complaint (_("DW_AT_call_target target DIE has invalid "
13991 "low pc, for referencing DIE %s [in module %s]"),
13992 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13995 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13996 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
14001 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14002 "block nor reference, for DIE %s [in module %s]"),
14003 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14005 call_site
->per_cu
= cu
->per_cu
;
14006 call_site
->per_objfile
= per_objfile
;
14008 for (child_die
= die
->child
;
14009 child_die
&& child_die
->tag
;
14010 child_die
= child_die
->sibling
)
14012 struct call_site_parameter
*parameter
;
14013 struct attribute
*loc
, *origin
;
14015 if (child_die
->tag
!= DW_TAG_call_site_parameter
14016 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14018 /* Already printed the complaint above. */
14022 gdb_assert (call_site
->parameter_count
< nparams
);
14023 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
14025 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14026 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14027 register is contained in DW_AT_call_value. */
14029 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
14030 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
14031 if (origin
== NULL
)
14033 /* This was a pre-DWARF-5 GNU extension alias
14034 for DW_AT_call_parameter. */
14035 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
14037 if (loc
== NULL
&& origin
!= NULL
&& origin
->form_is_ref ())
14039 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
14041 sect_offset sect_off
= origin
->get_ref_die_offset ();
14042 if (!cu
->header
.offset_in_cu_p (sect_off
))
14044 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14045 binding can be done only inside one CU. Such referenced DIE
14046 therefore cannot be even moved to DW_TAG_partial_unit. */
14047 complaint (_("DW_AT_call_parameter offset is not in CU for "
14048 "DW_TAG_call_site child DIE %s [in module %s]"),
14049 sect_offset_str (child_die
->sect_off
),
14050 objfile_name (objfile
));
14053 parameter
->u
.param_cu_off
14054 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
14056 else if (loc
== NULL
|| origin
!= NULL
|| !loc
->form_is_block ())
14058 complaint (_("No DW_FORM_block* DW_AT_location for "
14059 "DW_TAG_call_site child DIE %s [in module %s]"),
14060 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
14065 struct dwarf_block
*block
= loc
->as_block ();
14067 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
14068 (block
->data
, &block
->data
[block
->size
]);
14069 if (parameter
->u
.dwarf_reg
!= -1)
14070 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
14071 else if (dwarf_block_to_sp_offset (gdbarch
, block
->data
,
14072 &block
->data
[block
->size
],
14073 ¶meter
->u
.fb_offset
))
14074 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
14077 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14078 "for DW_FORM_block* DW_AT_location is supported for "
14079 "DW_TAG_call_site child DIE %s "
14081 sect_offset_str (child_die
->sect_off
),
14082 objfile_name (objfile
));
14087 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
14089 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
14090 if (attr
== NULL
|| !attr
->form_is_block ())
14092 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14093 "DW_TAG_call_site child DIE %s [in module %s]"),
14094 sect_offset_str (child_die
->sect_off
),
14095 objfile_name (objfile
));
14099 struct dwarf_block
*block
= attr
->as_block ();
14100 parameter
->value
= block
->data
;
14101 parameter
->value_size
= block
->size
;
14103 /* Parameters are not pre-cleared by memset above. */
14104 parameter
->data_value
= NULL
;
14105 parameter
->data_value_size
= 0;
14106 call_site
->parameter_count
++;
14108 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
14110 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
14111 if (attr
!= nullptr)
14113 if (!attr
->form_is_block ())
14114 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14115 "DW_TAG_call_site child DIE %s [in module %s]"),
14116 sect_offset_str (child_die
->sect_off
),
14117 objfile_name (objfile
));
14120 block
= attr
->as_block ();
14121 parameter
->data_value
= block
->data
;
14122 parameter
->data_value_size
= block
->size
;
14128 /* Helper function for read_variable. If DIE represents a virtual
14129 table, then return the type of the concrete object that is
14130 associated with the virtual table. Otherwise, return NULL. */
14132 static struct type
*
14133 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14135 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
14139 /* Find the type DIE. */
14140 struct die_info
*type_die
= NULL
;
14141 struct dwarf2_cu
*type_cu
= cu
;
14143 if (attr
->form_is_ref ())
14144 type_die
= follow_die_ref (die
, attr
, &type_cu
);
14145 if (type_die
== NULL
)
14148 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
14150 return die_containing_type (type_die
, type_cu
);
14153 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14156 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
14158 struct rust_vtable_symbol
*storage
= NULL
;
14160 if (cu
->language
== language_rust
)
14162 struct type
*containing_type
= rust_containing_type (die
, cu
);
14164 if (containing_type
!= NULL
)
14166 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14168 storage
= new (&objfile
->objfile_obstack
) rust_vtable_symbol
;
14169 storage
->concrete_type
= containing_type
;
14170 storage
->subclass
= SYMBOL_RUST_VTABLE
;
14174 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
14175 struct attribute
*abstract_origin
14176 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14177 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
14178 if (res
== NULL
&& loc
&& abstract_origin
)
14180 /* We have a variable without a name, but with a location and an abstract
14181 origin. This may be a concrete instance of an abstract variable
14182 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14184 struct dwarf2_cu
*origin_cu
= cu
;
14185 struct die_info
*origin_die
14186 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
14187 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14188 per_objfile
->per_bfd
->abstract_to_concrete
14189 [origin_die
->sect_off
].push_back (die
->sect_off
);
14193 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14194 reading .debug_rnglists.
14195 Callback's type should be:
14196 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14197 Return true if the attributes are present and valid, otherwise,
14200 template <typename Callback
>
14202 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
14203 dwarf_tag tag
, Callback
&&callback
)
14205 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14206 struct objfile
*objfile
= per_objfile
->objfile
;
14207 bfd
*obfd
= objfile
->obfd
;
14208 /* Base address selection entry. */
14209 gdb::optional
<CORE_ADDR
> base
;
14210 const gdb_byte
*buffer
;
14211 CORE_ADDR baseaddr
;
14212 bool overflow
= false;
14213 ULONGEST addr_index
;
14214 struct dwarf2_section_info
*rnglists_section
;
14216 base
= cu
->base_address
;
14217 rnglists_section
= cu_debug_rnglists_section (cu
, tag
);
14218 rnglists_section
->read (objfile
);
14220 if (offset
>= rnglists_section
->size
)
14222 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14226 buffer
= rnglists_section
->buffer
+ offset
;
14228 baseaddr
= objfile
->text_section_offset ();
14232 /* Initialize it due to a false compiler warning. */
14233 CORE_ADDR range_beginning
= 0, range_end
= 0;
14234 const gdb_byte
*buf_end
= (rnglists_section
->buffer
14235 + rnglists_section
->size
);
14236 unsigned int bytes_read
;
14238 if (buffer
== buf_end
)
14243 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
14246 case DW_RLE_end_of_list
:
14248 case DW_RLE_base_address
:
14249 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14254 base
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14255 buffer
+= bytes_read
;
14257 case DW_RLE_base_addressx
:
14258 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14259 buffer
+= bytes_read
;
14260 base
= read_addr_index (cu
, addr_index
);
14262 case DW_RLE_start_length
:
14263 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14268 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14270 buffer
+= bytes_read
;
14271 range_end
= (range_beginning
14272 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14273 buffer
+= bytes_read
;
14274 if (buffer
> buf_end
)
14280 case DW_RLE_startx_length
:
14281 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14282 buffer
+= bytes_read
;
14283 range_beginning
= read_addr_index (cu
, addr_index
);
14284 if (buffer
> buf_end
)
14289 range_end
= (range_beginning
14290 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14291 buffer
+= bytes_read
;
14293 case DW_RLE_offset_pair
:
14294 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14295 buffer
+= bytes_read
;
14296 if (buffer
> buf_end
)
14301 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14302 buffer
+= bytes_read
;
14303 if (buffer
> buf_end
)
14309 case DW_RLE_start_end
:
14310 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
14315 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14317 buffer
+= bytes_read
;
14318 range_end
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14319 buffer
+= bytes_read
;
14321 case DW_RLE_startx_endx
:
14322 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14323 buffer
+= bytes_read
;
14324 range_beginning
= read_addr_index (cu
, addr_index
);
14325 if (buffer
> buf_end
)
14330 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14331 buffer
+= bytes_read
;
14332 range_end
= read_addr_index (cu
, addr_index
);
14335 complaint (_("Invalid .debug_rnglists data (no base address)"));
14338 if (rlet
== DW_RLE_end_of_list
|| overflow
)
14340 if (rlet
== DW_RLE_base_address
)
14343 if (range_beginning
> range_end
)
14345 /* Inverted range entries are invalid. */
14346 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14350 /* Empty range entries have no effect. */
14351 if (range_beginning
== range_end
)
14354 /* Only DW_RLE_offset_pair needs the base address added. */
14355 if (rlet
== DW_RLE_offset_pair
)
14357 if (!base
.has_value ())
14359 /* We have no valid base address for the DW_RLE_offset_pair. */
14360 complaint (_("Invalid .debug_rnglists data (no base address for "
14361 "DW_RLE_offset_pair)"));
14365 range_beginning
+= *base
;
14366 range_end
+= *base
;
14369 /* A not-uncommon case of bad debug info.
14370 Don't pollute the addrmap with bad data. */
14371 if (range_beginning
+ baseaddr
== 0
14372 && !per_objfile
->per_bfd
->has_section_at_zero
)
14374 complaint (_(".debug_rnglists entry has start address of zero"
14375 " [in module %s]"), objfile_name (objfile
));
14379 callback (range_beginning
, range_end
);
14384 complaint (_("Offset %d is not terminated "
14385 "for DW_AT_ranges attribute"),
14393 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14394 Callback's type should be:
14395 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14396 Return 1 if the attributes are present and valid, otherwise, return 0. */
14398 template <typename Callback
>
14400 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
, dwarf_tag tag
,
14401 Callback
&&callback
)
14403 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14404 struct objfile
*objfile
= per_objfile
->objfile
;
14405 struct comp_unit_head
*cu_header
= &cu
->header
;
14406 bfd
*obfd
= objfile
->obfd
;
14407 unsigned int addr_size
= cu_header
->addr_size
;
14408 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
14409 /* Base address selection entry. */
14410 gdb::optional
<CORE_ADDR
> base
;
14411 unsigned int dummy
;
14412 const gdb_byte
*buffer
;
14413 CORE_ADDR baseaddr
;
14415 if (cu_header
->version
>= 5)
14416 return dwarf2_rnglists_process (offset
, cu
, tag
, callback
);
14418 base
= cu
->base_address
;
14420 per_objfile
->per_bfd
->ranges
.read (objfile
);
14421 if (offset
>= per_objfile
->per_bfd
->ranges
.size
)
14423 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14427 buffer
= per_objfile
->per_bfd
->ranges
.buffer
+ offset
;
14429 baseaddr
= objfile
->text_section_offset ();
14433 CORE_ADDR range_beginning
, range_end
;
14435 range_beginning
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14436 buffer
+= addr_size
;
14437 range_end
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14438 buffer
+= addr_size
;
14439 offset
+= 2 * addr_size
;
14441 /* An end of list marker is a pair of zero addresses. */
14442 if (range_beginning
== 0 && range_end
== 0)
14443 /* Found the end of list entry. */
14446 /* Each base address selection entry is a pair of 2 values.
14447 The first is the largest possible address, the second is
14448 the base address. Check for a base address here. */
14449 if ((range_beginning
& mask
) == mask
)
14451 /* If we found the largest possible address, then we already
14452 have the base address in range_end. */
14457 if (!base
.has_value ())
14459 /* We have no valid base address for the ranges
14461 complaint (_("Invalid .debug_ranges data (no base address)"));
14465 if (range_beginning
> range_end
)
14467 /* Inverted range entries are invalid. */
14468 complaint (_("Invalid .debug_ranges data (inverted range)"));
14472 /* Empty range entries have no effect. */
14473 if (range_beginning
== range_end
)
14476 range_beginning
+= *base
;
14477 range_end
+= *base
;
14479 /* A not-uncommon case of bad debug info.
14480 Don't pollute the addrmap with bad data. */
14481 if (range_beginning
+ baseaddr
== 0
14482 && !per_objfile
->per_bfd
->has_section_at_zero
)
14484 complaint (_(".debug_ranges entry has start address of zero"
14485 " [in module %s]"), objfile_name (objfile
));
14489 callback (range_beginning
, range_end
);
14495 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14496 Return 1 if the attributes are present and valid, otherwise, return 0.
14497 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14500 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14501 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14502 dwarf2_psymtab
*ranges_pst
, dwarf_tag tag
)
14504 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14505 struct gdbarch
*gdbarch
= objfile
->arch ();
14506 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
14509 CORE_ADDR high
= 0;
14512 retval
= dwarf2_ranges_process (offset
, cu
, tag
,
14513 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14515 if (ranges_pst
!= NULL
)
14520 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14521 range_beginning
+ baseaddr
)
14523 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14524 range_end
+ baseaddr
)
14526 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
14527 lowpc
, highpc
- 1, ranges_pst
);
14530 /* FIXME: This is recording everything as a low-high
14531 segment of consecutive addresses. We should have a
14532 data structure for discontiguous block ranges
14536 low
= range_beginning
;
14542 if (range_beginning
< low
)
14543 low
= range_beginning
;
14544 if (range_end
> high
)
14552 /* If the first entry is an end-of-list marker, the range
14553 describes an empty scope, i.e. no instructions. */
14559 *high_return
= high
;
14563 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14564 definition for the return value. *LOWPC and *HIGHPC are set iff
14565 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14567 static enum pc_bounds_kind
14568 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14569 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14570 dwarf2_psymtab
*pst
)
14572 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14573 struct attribute
*attr
;
14574 struct attribute
*attr_high
;
14576 CORE_ADDR high
= 0;
14577 enum pc_bounds_kind ret
;
14579 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14582 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14583 if (attr
!= nullptr)
14585 low
= attr
->as_address ();
14586 high
= attr_high
->as_address ();
14587 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14591 /* Found high w/o low attribute. */
14592 return PC_BOUNDS_INVALID
;
14594 /* Found consecutive range of addresses. */
14595 ret
= PC_BOUNDS_HIGH_LOW
;
14599 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14600 if (attr
!= nullptr && attr
->form_is_unsigned ())
14602 /* DW_AT_rnglists_base does not apply to DIEs from the DWO skeleton.
14603 We take advantage of the fact that DW_AT_ranges does not appear
14604 in DW_TAG_compile_unit of DWO files.
14606 Attributes of the form DW_FORM_rnglistx have already had their
14607 value changed by read_rnglist_index and already include
14608 DW_AT_rnglists_base, so don't need to add the ranges base,
14610 int need_ranges_base
= (die
->tag
!= DW_TAG_compile_unit
14611 && attr
->form
!= DW_FORM_rnglistx
);
14612 unsigned int ranges_offset
= (attr
->as_unsigned ()
14613 + (need_ranges_base
14617 /* Value of the DW_AT_ranges attribute is the offset in the
14618 .debug_ranges section. */
14619 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
,
14621 return PC_BOUNDS_INVALID
;
14622 /* Found discontinuous range of addresses. */
14623 ret
= PC_BOUNDS_RANGES
;
14626 return PC_BOUNDS_NOT_PRESENT
;
14629 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14631 return PC_BOUNDS_INVALID
;
14633 /* When using the GNU linker, .gnu.linkonce. sections are used to
14634 eliminate duplicate copies of functions and vtables and such.
14635 The linker will arbitrarily choose one and discard the others.
14636 The AT_*_pc values for such functions refer to local labels in
14637 these sections. If the section from that file was discarded, the
14638 labels are not in the output, so the relocs get a value of 0.
14639 If this is a discarded function, mark the pc bounds as invalid,
14640 so that GDB will ignore it. */
14641 if (low
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
14642 return PC_BOUNDS_INVALID
;
14650 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14651 its low and high PC addresses. Do nothing if these addresses could not
14652 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14653 and HIGHPC to the high address if greater than HIGHPC. */
14656 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14657 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14658 struct dwarf2_cu
*cu
)
14660 CORE_ADDR low
, high
;
14661 struct die_info
*child
= die
->child
;
14663 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14665 *lowpc
= std::min (*lowpc
, low
);
14666 *highpc
= std::max (*highpc
, high
);
14669 /* If the language does not allow nested subprograms (either inside
14670 subprograms or lexical blocks), we're done. */
14671 if (cu
->language
!= language_ada
)
14674 /* Check all the children of the given DIE. If it contains nested
14675 subprograms, then check their pc bounds. Likewise, we need to
14676 check lexical blocks as well, as they may also contain subprogram
14678 while (child
&& child
->tag
)
14680 if (child
->tag
== DW_TAG_subprogram
14681 || child
->tag
== DW_TAG_lexical_block
)
14682 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14683 child
= child
->sibling
;
14687 /* Get the low and high pc's represented by the scope DIE, and store
14688 them in *LOWPC and *HIGHPC. If the correct values can't be
14689 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14692 get_scope_pc_bounds (struct die_info
*die
,
14693 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14694 struct dwarf2_cu
*cu
)
14696 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14697 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14698 CORE_ADDR current_low
, current_high
;
14700 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14701 >= PC_BOUNDS_RANGES
)
14703 best_low
= current_low
;
14704 best_high
= current_high
;
14708 struct die_info
*child
= die
->child
;
14710 while (child
&& child
->tag
)
14712 switch (child
->tag
) {
14713 case DW_TAG_subprogram
:
14714 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14716 case DW_TAG_namespace
:
14717 case DW_TAG_module
:
14718 /* FIXME: carlton/2004-01-16: Should we do this for
14719 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14720 that current GCC's always emit the DIEs corresponding
14721 to definitions of methods of classes as children of a
14722 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14723 the DIEs giving the declarations, which could be
14724 anywhere). But I don't see any reason why the
14725 standards says that they have to be there. */
14726 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14728 if (current_low
!= ((CORE_ADDR
) -1))
14730 best_low
= std::min (best_low
, current_low
);
14731 best_high
= std::max (best_high
, current_high
);
14739 child
= child
->sibling
;
14744 *highpc
= best_high
;
14747 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14751 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14752 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14754 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14755 struct gdbarch
*gdbarch
= objfile
->arch ();
14756 struct attribute
*attr
;
14757 struct attribute
*attr_high
;
14759 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14762 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14763 if (attr
!= nullptr)
14765 CORE_ADDR low
= attr
->as_address ();
14766 CORE_ADDR high
= attr_high
->as_address ();
14768 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14771 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14772 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14773 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14777 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14778 if (attr
!= nullptr && attr
->form_is_unsigned ())
14780 /* DW_AT_rnglists_base does not apply to DIEs from the DWO skeleton.
14781 We take advantage of the fact that DW_AT_ranges does not appear
14782 in DW_TAG_compile_unit of DWO files.
14784 Attributes of the form DW_FORM_rnglistx have already had their
14785 value changed by read_rnglist_index and already include
14786 DW_AT_rnglists_base, so don't need to add the ranges base,
14788 int need_ranges_base
= (die
->tag
!= DW_TAG_compile_unit
14789 && attr
->form
!= DW_FORM_rnglistx
);
14791 /* The value of the DW_AT_ranges attribute is the offset of the
14792 address range list in the .debug_ranges section. */
14793 unsigned long offset
= (attr
->as_unsigned ()
14794 + (need_ranges_base
? cu
->ranges_base
: 0));
14796 std::vector
<blockrange
> blockvec
;
14797 dwarf2_ranges_process (offset
, cu
, die
->tag
,
14798 [&] (CORE_ADDR start
, CORE_ADDR end
)
14802 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14803 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14804 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14805 blockvec
.emplace_back (start
, end
);
14808 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14812 /* Check whether the producer field indicates either of GCC < 4.6, or the
14813 Intel C/C++ compiler, and cache the result in CU. */
14816 check_producer (struct dwarf2_cu
*cu
)
14820 if (cu
->producer
== NULL
)
14822 /* For unknown compilers expect their behavior is DWARF version
14825 GCC started to support .debug_types sections by -gdwarf-4 since
14826 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14827 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14828 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14829 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14831 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14833 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14834 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14836 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14838 cu
->producer_is_icc
= true;
14839 cu
->producer_is_icc_lt_14
= major
< 14;
14841 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14842 cu
->producer_is_codewarrior
= true;
14845 /* For other non-GCC compilers, expect their behavior is DWARF version
14849 cu
->checked_producer
= true;
14852 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14853 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14854 during 4.6.0 experimental. */
14857 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14859 if (!cu
->checked_producer
)
14860 check_producer (cu
);
14862 return cu
->producer_is_gxx_lt_4_6
;
14866 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14867 with incorrect is_stmt attributes. */
14870 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14872 if (!cu
->checked_producer
)
14873 check_producer (cu
);
14875 return cu
->producer_is_codewarrior
;
14878 /* Return the accessibility of DIE, as given by DW_AT_accessibility.
14879 If that attribute is not available, return the appropriate
14882 static enum dwarf_access_attribute
14883 dwarf2_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14885 attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14886 if (attr
!= nullptr)
14888 LONGEST value
= attr
->constant_value (-1);
14889 if (value
== DW_ACCESS_public
14890 || value
== DW_ACCESS_protected
14891 || value
== DW_ACCESS_private
)
14892 return (dwarf_access_attribute
) value
;
14893 complaint (_("Unhandled DW_AT_accessibility value (%s)"),
14897 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14899 /* The default DWARF 2 accessibility for members is public, the default
14900 accessibility for inheritance is private. */
14902 if (die
->tag
!= DW_TAG_inheritance
)
14903 return DW_ACCESS_public
;
14905 return DW_ACCESS_private
;
14909 /* DWARF 3+ defines the default accessibility a different way. The same
14910 rules apply now for DW_TAG_inheritance as for the members and it only
14911 depends on the container kind. */
14913 if (die
->parent
->tag
== DW_TAG_class_type
)
14914 return DW_ACCESS_private
;
14916 return DW_ACCESS_public
;
14920 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14921 offset. If the attribute was not found return 0, otherwise return
14922 1. If it was found but could not properly be handled, set *OFFSET
14926 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14929 struct attribute
*attr
;
14931 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14936 /* Note that we do not check for a section offset first here.
14937 This is because DW_AT_data_member_location is new in DWARF 4,
14938 so if we see it, we can assume that a constant form is really
14939 a constant and not a section offset. */
14940 if (attr
->form_is_constant ())
14941 *offset
= attr
->constant_value (0);
14942 else if (attr
->form_is_section_offset ())
14943 dwarf2_complex_location_expr_complaint ();
14944 else if (attr
->form_is_block ())
14945 *offset
= decode_locdesc (attr
->as_block (), cu
);
14947 dwarf2_complex_location_expr_complaint ();
14955 /* Look for DW_AT_data_member_location and store the results in FIELD. */
14958 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14959 struct field
*field
)
14961 struct attribute
*attr
;
14963 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14966 if (attr
->form_is_constant ())
14968 LONGEST offset
= attr
->constant_value (0);
14969 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14971 else if (attr
->form_is_section_offset ())
14972 dwarf2_complex_location_expr_complaint ();
14973 else if (attr
->form_is_block ())
14976 CORE_ADDR offset
= decode_locdesc (attr
->as_block (), cu
, &handled
);
14978 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14981 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14982 struct objfile
*objfile
= per_objfile
->objfile
;
14983 struct dwarf2_locexpr_baton
*dlbaton
14984 = XOBNEW (&objfile
->objfile_obstack
,
14985 struct dwarf2_locexpr_baton
);
14986 dlbaton
->data
= attr
->as_block ()->data
;
14987 dlbaton
->size
= attr
->as_block ()->size
;
14988 /* When using this baton, we want to compute the address
14989 of the field, not the value. This is why
14990 is_reference is set to false here. */
14991 dlbaton
->is_reference
= false;
14992 dlbaton
->per_objfile
= per_objfile
;
14993 dlbaton
->per_cu
= cu
->per_cu
;
14995 SET_FIELD_DWARF_BLOCK (*field
, dlbaton
);
14999 dwarf2_complex_location_expr_complaint ();
15003 /* Add an aggregate field to the field list. */
15006 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
15007 struct dwarf2_cu
*cu
)
15009 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15010 struct gdbarch
*gdbarch
= objfile
->arch ();
15011 struct nextfield
*new_field
;
15012 struct attribute
*attr
;
15014 const char *fieldname
= "";
15016 if (die
->tag
== DW_TAG_inheritance
)
15018 fip
->baseclasses
.emplace_back ();
15019 new_field
= &fip
->baseclasses
.back ();
15023 fip
->fields
.emplace_back ();
15024 new_field
= &fip
->fields
.back ();
15027 new_field
->offset
= die
->sect_off
;
15029 new_field
->accessibility
= dwarf2_access_attribute (die
, cu
);
15030 if (new_field
->accessibility
!= DW_ACCESS_public
)
15031 fip
->non_public_fields
= true;
15033 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15034 if (attr
!= nullptr)
15035 new_field
->virtuality
= attr
->as_virtuality ();
15037 new_field
->virtuality
= DW_VIRTUALITY_none
;
15039 fp
= &new_field
->field
;
15041 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
15043 /* Data member other than a C++ static data member. */
15045 /* Get type of field. */
15046 fp
->set_type (die_type (die
, cu
));
15048 SET_FIELD_BITPOS (*fp
, 0);
15050 /* Get bit size of field (zero if none). */
15051 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
15052 if (attr
!= nullptr)
15054 FIELD_BITSIZE (*fp
) = attr
->constant_value (0);
15058 FIELD_BITSIZE (*fp
) = 0;
15061 /* Get bit offset of field. */
15062 handle_data_member_location (die
, cu
, fp
);
15063 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
15064 if (attr
!= nullptr && attr
->form_is_constant ())
15066 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
15068 /* For big endian bits, the DW_AT_bit_offset gives the
15069 additional bit offset from the MSB of the containing
15070 anonymous object to the MSB of the field. We don't
15071 have to do anything special since we don't need to
15072 know the size of the anonymous object. */
15073 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15074 + attr
->constant_value (0)));
15078 /* For little endian bits, compute the bit offset to the
15079 MSB of the anonymous object, subtract off the number of
15080 bits from the MSB of the field to the MSB of the
15081 object, and then subtract off the number of bits of
15082 the field itself. The result is the bit offset of
15083 the LSB of the field. */
15084 int anonymous_size
;
15085 int bit_offset
= attr
->constant_value (0);
15087 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15088 if (attr
!= nullptr && attr
->form_is_constant ())
15090 /* The size of the anonymous object containing
15091 the bit field is explicit, so use the
15092 indicated size (in bytes). */
15093 anonymous_size
= attr
->constant_value (0);
15097 /* The size of the anonymous object containing
15098 the bit field must be inferred from the type
15099 attribute of the data member containing the
15101 anonymous_size
= TYPE_LENGTH (fp
->type ());
15103 SET_FIELD_BITPOS (*fp
,
15104 (FIELD_BITPOS (*fp
)
15105 + anonymous_size
* bits_per_byte
15106 - bit_offset
- FIELD_BITSIZE (*fp
)));
15109 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
15111 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15112 + attr
->constant_value (0)));
15114 /* Get name of field. */
15115 fieldname
= dwarf2_name (die
, cu
);
15116 if (fieldname
== NULL
)
15119 /* The name is already allocated along with this objfile, so we don't
15120 need to duplicate it for the type. */
15121 fp
->name
= fieldname
;
15123 /* Change accessibility for artificial fields (e.g. virtual table
15124 pointer or virtual base class pointer) to private. */
15125 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
15127 FIELD_ARTIFICIAL (*fp
) = 1;
15128 new_field
->accessibility
= DW_ACCESS_private
;
15129 fip
->non_public_fields
= true;
15132 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
15134 /* C++ static member. */
15136 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15137 is a declaration, but all versions of G++ as of this writing
15138 (so through at least 3.2.1) incorrectly generate
15139 DW_TAG_variable tags. */
15141 const char *physname
;
15143 /* Get name of field. */
15144 fieldname
= dwarf2_name (die
, cu
);
15145 if (fieldname
== NULL
)
15148 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15150 /* Only create a symbol if this is an external value.
15151 new_symbol checks this and puts the value in the global symbol
15152 table, which we want. If it is not external, new_symbol
15153 will try to put the value in cu->list_in_scope which is wrong. */
15154 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
15156 /* A static const member, not much different than an enum as far as
15157 we're concerned, except that we can support more types. */
15158 new_symbol (die
, NULL
, cu
);
15161 /* Get physical name. */
15162 physname
= dwarf2_physname (fieldname
, die
, cu
);
15164 /* The name is already allocated along with this objfile, so we don't
15165 need to duplicate it for the type. */
15166 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
15167 fp
->set_type (die_type (die
, cu
));
15168 FIELD_NAME (*fp
) = fieldname
;
15170 else if (die
->tag
== DW_TAG_inheritance
)
15172 /* C++ base class field. */
15173 handle_data_member_location (die
, cu
, fp
);
15174 FIELD_BITSIZE (*fp
) = 0;
15175 fp
->set_type (die_type (die
, cu
));
15176 FIELD_NAME (*fp
) = fp
->type ()->name ();
15179 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15182 /* Can the type given by DIE define another type? */
15185 type_can_define_types (const struct die_info
*die
)
15189 case DW_TAG_typedef
:
15190 case DW_TAG_class_type
:
15191 case DW_TAG_structure_type
:
15192 case DW_TAG_union_type
:
15193 case DW_TAG_enumeration_type
:
15201 /* Add a type definition defined in the scope of the FIP's class. */
15204 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
15205 struct dwarf2_cu
*cu
)
15207 struct decl_field fp
;
15208 memset (&fp
, 0, sizeof (fp
));
15210 gdb_assert (type_can_define_types (die
));
15212 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15213 fp
.name
= dwarf2_name (die
, cu
);
15214 fp
.type
= read_type_die (die
, cu
);
15216 /* Save accessibility. */
15217 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15218 switch (accessibility
)
15220 case DW_ACCESS_public
:
15221 /* The assumed value if neither private nor protected. */
15223 case DW_ACCESS_private
:
15226 case DW_ACCESS_protected
:
15227 fp
.is_protected
= 1;
15231 if (die
->tag
== DW_TAG_typedef
)
15232 fip
->typedef_field_list
.push_back (fp
);
15234 fip
->nested_types_list
.push_back (fp
);
15237 /* A convenience typedef that's used when finding the discriminant
15238 field for a variant part. */
15239 typedef std::unordered_map
<sect_offset
, int, gdb::hash_enum
<sect_offset
>>
15242 /* Compute the discriminant range for a given variant. OBSTACK is
15243 where the results will be stored. VARIANT is the variant to
15244 process. IS_UNSIGNED indicates whether the discriminant is signed
15247 static const gdb::array_view
<discriminant_range
>
15248 convert_variant_range (struct obstack
*obstack
, const variant_field
&variant
,
15251 std::vector
<discriminant_range
> ranges
;
15253 if (variant
.default_branch
)
15256 if (variant
.discr_list_data
== nullptr)
15258 discriminant_range r
15259 = {variant
.discriminant_value
, variant
.discriminant_value
};
15260 ranges
.push_back (r
);
15264 gdb::array_view
<const gdb_byte
> data (variant
.discr_list_data
->data
,
15265 variant
.discr_list_data
->size
);
15266 while (!data
.empty ())
15268 if (data
[0] != DW_DSC_range
&& data
[0] != DW_DSC_label
)
15270 complaint (_("invalid discriminant marker: %d"), data
[0]);
15273 bool is_range
= data
[0] == DW_DSC_range
;
15274 data
= data
.slice (1);
15276 ULONGEST low
, high
;
15277 unsigned int bytes_read
;
15281 complaint (_("DW_AT_discr_list missing low value"));
15285 low
= read_unsigned_leb128 (nullptr, data
.data (), &bytes_read
);
15287 low
= (ULONGEST
) read_signed_leb128 (nullptr, data
.data (),
15289 data
= data
.slice (bytes_read
);
15295 complaint (_("DW_AT_discr_list missing high value"));
15299 high
= read_unsigned_leb128 (nullptr, data
.data (),
15302 high
= (LONGEST
) read_signed_leb128 (nullptr, data
.data (),
15304 data
= data
.slice (bytes_read
);
15309 ranges
.push_back ({ low
, high
});
15313 discriminant_range
*result
= XOBNEWVEC (obstack
, discriminant_range
,
15315 std::copy (ranges
.begin (), ranges
.end (), result
);
15316 return gdb::array_view
<discriminant_range
> (result
, ranges
.size ());
15319 static const gdb::array_view
<variant_part
> create_variant_parts
15320 (struct obstack
*obstack
,
15321 const offset_map_type
&offset_map
,
15322 struct field_info
*fi
,
15323 const std::vector
<variant_part_builder
> &variant_parts
);
15325 /* Fill in a "struct variant" for a given variant field. RESULT is
15326 the variant to fill in. OBSTACK is where any needed allocations
15327 will be done. OFFSET_MAP holds the mapping from section offsets to
15328 fields for the type. FI describes the fields of the type we're
15329 processing. FIELD is the variant field we're converting. */
15332 create_one_variant (variant
&result
, struct obstack
*obstack
,
15333 const offset_map_type
&offset_map
,
15334 struct field_info
*fi
, const variant_field
&field
)
15336 result
.discriminants
= convert_variant_range (obstack
, field
, false);
15337 result
.first_field
= field
.first_field
+ fi
->baseclasses
.size ();
15338 result
.last_field
= field
.last_field
+ fi
->baseclasses
.size ();
15339 result
.parts
= create_variant_parts (obstack
, offset_map
, fi
,
15340 field
.variant_parts
);
15343 /* Fill in a "struct variant_part" for a given variant part. RESULT
15344 is the variant part to fill in. OBSTACK is where any needed
15345 allocations will be done. OFFSET_MAP holds the mapping from
15346 section offsets to fields for the type. FI describes the fields of
15347 the type we're processing. BUILDER is the variant part to be
15351 create_one_variant_part (variant_part
&result
,
15352 struct obstack
*obstack
,
15353 const offset_map_type
&offset_map
,
15354 struct field_info
*fi
,
15355 const variant_part_builder
&builder
)
15357 auto iter
= offset_map
.find (builder
.discriminant_offset
);
15358 if (iter
== offset_map
.end ())
15360 result
.discriminant_index
= -1;
15361 /* Doesn't matter. */
15362 result
.is_unsigned
= false;
15366 result
.discriminant_index
= iter
->second
;
15368 = fi
->fields
[result
.discriminant_index
].field
.type ()->is_unsigned ();
15371 size_t n
= builder
.variants
.size ();
15372 variant
*output
= new (obstack
) variant
[n
];
15373 for (size_t i
= 0; i
< n
; ++i
)
15374 create_one_variant (output
[i
], obstack
, offset_map
, fi
,
15375 builder
.variants
[i
]);
15377 result
.variants
= gdb::array_view
<variant
> (output
, n
);
15380 /* Create a vector of variant parts that can be attached to a type.
15381 OBSTACK is where any needed allocations will be done. OFFSET_MAP
15382 holds the mapping from section offsets to fields for the type. FI
15383 describes the fields of the type we're processing. VARIANT_PARTS
15384 is the vector to convert. */
15386 static const gdb::array_view
<variant_part
>
15387 create_variant_parts (struct obstack
*obstack
,
15388 const offset_map_type
&offset_map
,
15389 struct field_info
*fi
,
15390 const std::vector
<variant_part_builder
> &variant_parts
)
15392 if (variant_parts
.empty ())
15395 size_t n
= variant_parts
.size ();
15396 variant_part
*result
= new (obstack
) variant_part
[n
];
15397 for (size_t i
= 0; i
< n
; ++i
)
15398 create_one_variant_part (result
[i
], obstack
, offset_map
, fi
,
15401 return gdb::array_view
<variant_part
> (result
, n
);
15404 /* Compute the variant part vector for FIP, attaching it to TYPE when
15408 add_variant_property (struct field_info
*fip
, struct type
*type
,
15409 struct dwarf2_cu
*cu
)
15411 /* Map section offsets of fields to their field index. Note the
15412 field index here does not take the number of baseclasses into
15414 offset_map_type offset_map
;
15415 for (int i
= 0; i
< fip
->fields
.size (); ++i
)
15416 offset_map
[fip
->fields
[i
].offset
] = i
;
15418 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15419 gdb::array_view
<variant_part
> parts
15420 = create_variant_parts (&objfile
->objfile_obstack
, offset_map
, fip
,
15421 fip
->variant_parts
);
15423 struct dynamic_prop prop
;
15424 prop
.set_variant_parts ((gdb::array_view
<variant_part
> *)
15425 obstack_copy (&objfile
->objfile_obstack
, &parts
,
15428 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
15431 /* Create the vector of fields, and attach it to the type. */
15434 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
15435 struct dwarf2_cu
*cu
)
15437 int nfields
= fip
->nfields ();
15439 /* Record the field count, allocate space for the array of fields,
15440 and create blank accessibility bitfields if necessary. */
15441 type
->set_num_fields (nfields
);
15443 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
));
15445 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
15447 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15449 TYPE_FIELD_PRIVATE_BITS (type
) =
15450 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15451 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
15453 TYPE_FIELD_PROTECTED_BITS (type
) =
15454 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15455 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
15457 TYPE_FIELD_IGNORE_BITS (type
) =
15458 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15459 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
15462 /* If the type has baseclasses, allocate and clear a bit vector for
15463 TYPE_FIELD_VIRTUAL_BITS. */
15464 if (!fip
->baseclasses
.empty () && cu
->language
!= language_ada
)
15466 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
15467 unsigned char *pointer
;
15469 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15470 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
15471 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
15472 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
15473 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
15476 if (!fip
->variant_parts
.empty ())
15477 add_variant_property (fip
, type
, cu
);
15479 /* Copy the saved-up fields into the field vector. */
15480 for (int i
= 0; i
< nfields
; ++i
)
15482 struct nextfield
&field
15483 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
15484 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
15486 type
->field (i
) = field
.field
;
15487 switch (field
.accessibility
)
15489 case DW_ACCESS_private
:
15490 if (cu
->language
!= language_ada
)
15491 SET_TYPE_FIELD_PRIVATE (type
, i
);
15494 case DW_ACCESS_protected
:
15495 if (cu
->language
!= language_ada
)
15496 SET_TYPE_FIELD_PROTECTED (type
, i
);
15499 case DW_ACCESS_public
:
15503 /* Unknown accessibility. Complain and treat it as public. */
15505 complaint (_("unsupported accessibility %d"),
15506 field
.accessibility
);
15510 if (i
< fip
->baseclasses
.size ())
15512 switch (field
.virtuality
)
15514 case DW_VIRTUALITY_virtual
:
15515 case DW_VIRTUALITY_pure_virtual
:
15516 if (cu
->language
== language_ada
)
15517 error (_("unexpected virtuality in component of Ada type"));
15518 SET_TYPE_FIELD_VIRTUAL (type
, i
);
15525 /* Return true if this member function is a constructor, false
15529 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15531 const char *fieldname
;
15532 const char *type_name
;
15535 if (die
->parent
== NULL
)
15538 if (die
->parent
->tag
!= DW_TAG_structure_type
15539 && die
->parent
->tag
!= DW_TAG_union_type
15540 && die
->parent
->tag
!= DW_TAG_class_type
)
15543 fieldname
= dwarf2_name (die
, cu
);
15544 type_name
= dwarf2_name (die
->parent
, cu
);
15545 if (fieldname
== NULL
|| type_name
== NULL
)
15548 len
= strlen (fieldname
);
15549 return (strncmp (fieldname
, type_name
, len
) == 0
15550 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15553 /* Add a member function to the proper fieldlist. */
15556 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15557 struct type
*type
, struct dwarf2_cu
*cu
)
15559 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15560 struct attribute
*attr
;
15562 struct fnfieldlist
*flp
= nullptr;
15563 struct fn_field
*fnp
;
15564 const char *fieldname
;
15565 struct type
*this_type
;
15567 if (cu
->language
== language_ada
)
15568 error (_("unexpected member function in Ada type"));
15570 /* Get name of member function. */
15571 fieldname
= dwarf2_name (die
, cu
);
15572 if (fieldname
== NULL
)
15575 /* Look up member function name in fieldlist. */
15576 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15578 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15580 flp
= &fip
->fnfieldlists
[i
];
15585 /* Create a new fnfieldlist if necessary. */
15586 if (flp
== nullptr)
15588 fip
->fnfieldlists
.emplace_back ();
15589 flp
= &fip
->fnfieldlists
.back ();
15590 flp
->name
= fieldname
;
15591 i
= fip
->fnfieldlists
.size () - 1;
15594 /* Create a new member function field and add it to the vector of
15596 flp
->fnfields
.emplace_back ();
15597 fnp
= &flp
->fnfields
.back ();
15599 /* Delay processing of the physname until later. */
15600 if (cu
->language
== language_cplus
)
15601 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15605 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15606 fnp
->physname
= physname
? physname
: "";
15609 fnp
->type
= alloc_type (objfile
);
15610 this_type
= read_type_die (die
, cu
);
15611 if (this_type
&& this_type
->code () == TYPE_CODE_FUNC
)
15613 int nparams
= this_type
->num_fields ();
15615 /* TYPE is the domain of this method, and THIS_TYPE is the type
15616 of the method itself (TYPE_CODE_METHOD). */
15617 smash_to_method_type (fnp
->type
, type
,
15618 TYPE_TARGET_TYPE (this_type
),
15619 this_type
->fields (),
15620 this_type
->num_fields (),
15621 this_type
->has_varargs ());
15623 /* Handle static member functions.
15624 Dwarf2 has no clean way to discern C++ static and non-static
15625 member functions. G++ helps GDB by marking the first
15626 parameter for non-static member functions (which is the this
15627 pointer) as artificial. We obtain this information from
15628 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15629 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15630 fnp
->voffset
= VOFFSET_STATIC
;
15633 complaint (_("member function type missing for '%s'"),
15634 dwarf2_full_name (fieldname
, die
, cu
));
15636 /* Get fcontext from DW_AT_containing_type if present. */
15637 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15638 fnp
->fcontext
= die_containing_type (die
, cu
);
15640 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15641 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15643 /* Get accessibility. */
15644 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15645 switch (accessibility
)
15647 case DW_ACCESS_private
:
15648 fnp
->is_private
= 1;
15650 case DW_ACCESS_protected
:
15651 fnp
->is_protected
= 1;
15655 /* Check for artificial methods. */
15656 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15657 if (attr
&& attr
->as_boolean ())
15658 fnp
->is_artificial
= 1;
15660 /* Check for defaulted methods. */
15661 attr
= dwarf2_attr (die
, DW_AT_defaulted
, cu
);
15662 if (attr
!= nullptr)
15663 fnp
->defaulted
= attr
->defaulted ();
15665 /* Check for deleted methods. */
15666 attr
= dwarf2_attr (die
, DW_AT_deleted
, cu
);
15667 if (attr
!= nullptr && attr
->as_boolean ())
15668 fnp
->is_deleted
= 1;
15670 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15672 /* Get index in virtual function table if it is a virtual member
15673 function. For older versions of GCC, this is an offset in the
15674 appropriate virtual table, as specified by DW_AT_containing_type.
15675 For everyone else, it is an expression to be evaluated relative
15676 to the object address. */
15678 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15679 if (attr
!= nullptr)
15681 if (attr
->form_is_block () && attr
->as_block ()->size
> 0)
15683 struct dwarf_block
*block
= attr
->as_block ();
15685 if (block
->data
[0] == DW_OP_constu
)
15687 /* Old-style GCC. */
15688 fnp
->voffset
= decode_locdesc (block
, cu
) + 2;
15690 else if (block
->data
[0] == DW_OP_deref
15691 || (block
->size
> 1
15692 && block
->data
[0] == DW_OP_deref_size
15693 && block
->data
[1] == cu
->header
.addr_size
))
15695 fnp
->voffset
= decode_locdesc (block
, cu
);
15696 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15697 dwarf2_complex_location_expr_complaint ();
15699 fnp
->voffset
/= cu
->header
.addr_size
;
15703 dwarf2_complex_location_expr_complaint ();
15705 if (!fnp
->fcontext
)
15707 /* If there is no `this' field and no DW_AT_containing_type,
15708 we cannot actually find a base class context for the
15710 if (this_type
->num_fields () == 0
15711 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15713 complaint (_("cannot determine context for virtual member "
15714 "function \"%s\" (offset %s)"),
15715 fieldname
, sect_offset_str (die
->sect_off
));
15720 = TYPE_TARGET_TYPE (this_type
->field (0).type ());
15724 else if (attr
->form_is_section_offset ())
15726 dwarf2_complex_location_expr_complaint ();
15730 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15736 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15737 if (attr
!= nullptr && attr
->as_virtuality () != DW_VIRTUALITY_none
)
15739 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15740 complaint (_("Member function \"%s\" (offset %s) is virtual "
15741 "but the vtable offset is not specified"),
15742 fieldname
, sect_offset_str (die
->sect_off
));
15743 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15744 TYPE_CPLUS_DYNAMIC (type
) = 1;
15749 /* Create the vector of member function fields, and attach it to the type. */
15752 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15753 struct dwarf2_cu
*cu
)
15755 if (cu
->language
== language_ada
)
15756 error (_("unexpected member functions in Ada type"));
15758 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15759 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15761 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15763 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15765 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15766 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15768 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15769 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15770 fn_flp
->fn_fields
= (struct fn_field
*)
15771 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15773 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15774 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15777 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15780 /* Returns non-zero if NAME is the name of a vtable member in CU's
15781 language, zero otherwise. */
15783 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15785 static const char vptr
[] = "_vptr";
15787 /* Look for the C++ form of the vtable. */
15788 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15794 /* GCC outputs unnamed structures that are really pointers to member
15795 functions, with the ABI-specified layout. If TYPE describes
15796 such a structure, smash it into a member function type.
15798 GCC shouldn't do this; it should just output pointer to member DIEs.
15799 This is GCC PR debug/28767. */
15802 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15804 struct type
*pfn_type
, *self_type
, *new_type
;
15806 /* Check for a structure with no name and two children. */
15807 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15810 /* Check for __pfn and __delta members. */
15811 if (TYPE_FIELD_NAME (type
, 0) == NULL
15812 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15813 || TYPE_FIELD_NAME (type
, 1) == NULL
15814 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15817 /* Find the type of the method. */
15818 pfn_type
= type
->field (0).type ();
15819 if (pfn_type
== NULL
15820 || pfn_type
->code () != TYPE_CODE_PTR
15821 || TYPE_TARGET_TYPE (pfn_type
)->code () != TYPE_CODE_FUNC
)
15824 /* Look for the "this" argument. */
15825 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15826 if (pfn_type
->num_fields () == 0
15827 /* || pfn_type->field (0).type () == NULL */
15828 || pfn_type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15831 self_type
= TYPE_TARGET_TYPE (pfn_type
->field (0).type ());
15832 new_type
= alloc_type (objfile
);
15833 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15834 pfn_type
->fields (), pfn_type
->num_fields (),
15835 pfn_type
->has_varargs ());
15836 smash_to_methodptr_type (type
, new_type
);
15839 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15840 appropriate error checking and issuing complaints if there is a
15844 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
15846 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
15848 if (attr
== nullptr)
15851 if (!attr
->form_is_constant ())
15853 complaint (_("DW_AT_alignment must have constant form"
15854 " - DIE at %s [in module %s]"),
15855 sect_offset_str (die
->sect_off
),
15856 objfile_name (cu
->per_objfile
->objfile
));
15860 LONGEST val
= attr
->constant_value (0);
15863 complaint (_("DW_AT_alignment value must not be negative"
15864 " - DIE at %s [in module %s]"),
15865 sect_offset_str (die
->sect_off
),
15866 objfile_name (cu
->per_objfile
->objfile
));
15869 ULONGEST align
= val
;
15873 complaint (_("DW_AT_alignment value must not be zero"
15874 " - DIE at %s [in module %s]"),
15875 sect_offset_str (die
->sect_off
),
15876 objfile_name (cu
->per_objfile
->objfile
));
15879 if ((align
& (align
- 1)) != 0)
15881 complaint (_("DW_AT_alignment value must be a power of 2"
15882 " - DIE at %s [in module %s]"),
15883 sect_offset_str (die
->sect_off
),
15884 objfile_name (cu
->per_objfile
->objfile
));
15891 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15892 the alignment for TYPE. */
15895 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
15898 if (!set_type_align (type
, get_alignment (cu
, die
)))
15899 complaint (_("DW_AT_alignment value too large"
15900 " - DIE at %s [in module %s]"),
15901 sect_offset_str (die
->sect_off
),
15902 objfile_name (cu
->per_objfile
->objfile
));
15905 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15906 constant for a type, according to DWARF5 spec, Table 5.5. */
15909 is_valid_DW_AT_calling_convention_for_type (ULONGEST value
)
15914 case DW_CC_pass_by_reference
:
15915 case DW_CC_pass_by_value
:
15919 complaint (_("unrecognized DW_AT_calling_convention value "
15920 "(%s) for a type"), pulongest (value
));
15925 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15926 constant for a subroutine, according to DWARF5 spec, Table 3.3, and
15927 also according to GNU-specific values (see include/dwarf2.h). */
15930 is_valid_DW_AT_calling_convention_for_subroutine (ULONGEST value
)
15935 case DW_CC_program
:
15939 case DW_CC_GNU_renesas_sh
:
15940 case DW_CC_GNU_borland_fastcall_i386
:
15941 case DW_CC_GDB_IBM_OpenCL
:
15945 complaint (_("unrecognized DW_AT_calling_convention value "
15946 "(%s) for a subroutine"), pulongest (value
));
15951 /* Called when we find the DIE that starts a structure or union scope
15952 (definition) to create a type for the structure or union. Fill in
15953 the type's name and general properties; the members will not be
15954 processed until process_structure_scope. A symbol table entry for
15955 the type will also not be done until process_structure_scope (assuming
15956 the type has a name).
15958 NOTE: we need to call these functions regardless of whether or not the
15959 DIE has a DW_AT_name attribute, since it might be an anonymous
15960 structure or union. This gets the type entered into our set of
15961 user defined types. */
15963 static struct type
*
15964 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15966 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15968 struct attribute
*attr
;
15971 /* If the definition of this type lives in .debug_types, read that type.
15972 Don't follow DW_AT_specification though, that will take us back up
15973 the chain and we want to go down. */
15974 attr
= die
->attr (DW_AT_signature
);
15975 if (attr
!= nullptr)
15977 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15979 /* The type's CU may not be the same as CU.
15980 Ensure TYPE is recorded with CU in die_type_hash. */
15981 return set_die_type (die
, type
, cu
);
15984 type
= alloc_type (objfile
);
15985 INIT_CPLUS_SPECIFIC (type
);
15987 name
= dwarf2_name (die
, cu
);
15990 if (cu
->language
== language_cplus
15991 || cu
->language
== language_d
15992 || cu
->language
== language_rust
)
15994 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
15996 /* dwarf2_full_name might have already finished building the DIE's
15997 type. If so, there is no need to continue. */
15998 if (get_die_type (die
, cu
) != NULL
)
15999 return get_die_type (die
, cu
);
16001 type
->set_name (full_name
);
16005 /* The name is already allocated along with this objfile, so
16006 we don't need to duplicate it for the type. */
16007 type
->set_name (name
);
16011 if (die
->tag
== DW_TAG_structure_type
)
16013 type
->set_code (TYPE_CODE_STRUCT
);
16015 else if (die
->tag
== DW_TAG_union_type
)
16017 type
->set_code (TYPE_CODE_UNION
);
16021 type
->set_code (TYPE_CODE_STRUCT
);
16024 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
16025 TYPE_DECLARED_CLASS (type
) = 1;
16027 /* Store the calling convention in the type if it's available in
16028 the die. Otherwise the calling convention remains set to
16029 the default value DW_CC_normal. */
16030 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
16031 if (attr
!= nullptr
16032 && is_valid_DW_AT_calling_convention_for_type (attr
->constant_value (0)))
16034 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16035 TYPE_CPLUS_CALLING_CONVENTION (type
)
16036 = (enum dwarf_calling_convention
) (attr
->constant_value (0));
16039 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16040 if (attr
!= nullptr)
16042 if (attr
->form_is_constant ())
16043 TYPE_LENGTH (type
) = attr
->constant_value (0);
16046 struct dynamic_prop prop
;
16047 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
16048 type
->add_dyn_prop (DYN_PROP_BYTE_SIZE
, prop
);
16049 TYPE_LENGTH (type
) = 0;
16054 TYPE_LENGTH (type
) = 0;
16057 maybe_set_alignment (cu
, die
, type
);
16059 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
16061 /* ICC<14 does not output the required DW_AT_declaration on
16062 incomplete types, but gives them a size of zero. */
16063 type
->set_is_stub (true);
16066 type
->set_stub_is_supported (true);
16068 if (die_is_declaration (die
, cu
))
16069 type
->set_is_stub (true);
16070 else if (attr
== NULL
&& die
->child
== NULL
16071 && producer_is_realview (cu
->producer
))
16072 /* RealView does not output the required DW_AT_declaration
16073 on incomplete types. */
16074 type
->set_is_stub (true);
16076 /* We need to add the type field to the die immediately so we don't
16077 infinitely recurse when dealing with pointers to the structure
16078 type within the structure itself. */
16079 set_die_type (die
, type
, cu
);
16081 /* set_die_type should be already done. */
16082 set_descriptive_type (type
, die
, cu
);
16087 static void handle_struct_member_die
16088 (struct die_info
*child_die
,
16090 struct field_info
*fi
,
16091 std::vector
<struct symbol
*> *template_args
,
16092 struct dwarf2_cu
*cu
);
16094 /* A helper for handle_struct_member_die that handles
16095 DW_TAG_variant_part. */
16098 handle_variant_part (struct die_info
*die
, struct type
*type
,
16099 struct field_info
*fi
,
16100 std::vector
<struct symbol
*> *template_args
,
16101 struct dwarf2_cu
*cu
)
16103 variant_part_builder
*new_part
;
16104 if (fi
->current_variant_part
== nullptr)
16106 fi
->variant_parts
.emplace_back ();
16107 new_part
= &fi
->variant_parts
.back ();
16109 else if (!fi
->current_variant_part
->processing_variant
)
16111 complaint (_("nested DW_TAG_variant_part seen "
16112 "- DIE at %s [in module %s]"),
16113 sect_offset_str (die
->sect_off
),
16114 objfile_name (cu
->per_objfile
->objfile
));
16119 variant_field
¤t
= fi
->current_variant_part
->variants
.back ();
16120 current
.variant_parts
.emplace_back ();
16121 new_part
= ¤t
.variant_parts
.back ();
16124 /* When we recurse, we want callees to add to this new variant
16126 scoped_restore save_current_variant_part
16127 = make_scoped_restore (&fi
->current_variant_part
, new_part
);
16129 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
16132 /* It's a univariant form, an extension we support. */
16134 else if (discr
->form_is_ref ())
16136 struct dwarf2_cu
*target_cu
= cu
;
16137 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
16139 new_part
->discriminant_offset
= target_die
->sect_off
;
16143 complaint (_("DW_AT_discr does not have DIE reference form"
16144 " - DIE at %s [in module %s]"),
16145 sect_offset_str (die
->sect_off
),
16146 objfile_name (cu
->per_objfile
->objfile
));
16149 for (die_info
*child_die
= die
->child
;
16151 child_die
= child_die
->sibling
)
16152 handle_struct_member_die (child_die
, type
, fi
, template_args
, cu
);
16155 /* A helper for handle_struct_member_die that handles
16159 handle_variant (struct die_info
*die
, struct type
*type
,
16160 struct field_info
*fi
,
16161 std::vector
<struct symbol
*> *template_args
,
16162 struct dwarf2_cu
*cu
)
16164 if (fi
->current_variant_part
== nullptr)
16166 complaint (_("saw DW_TAG_variant outside DW_TAG_variant_part "
16167 "- DIE at %s [in module %s]"),
16168 sect_offset_str (die
->sect_off
),
16169 objfile_name (cu
->per_objfile
->objfile
));
16172 if (fi
->current_variant_part
->processing_variant
)
16174 complaint (_("nested DW_TAG_variant seen "
16175 "- DIE at %s [in module %s]"),
16176 sect_offset_str (die
->sect_off
),
16177 objfile_name (cu
->per_objfile
->objfile
));
16181 scoped_restore save_processing_variant
16182 = make_scoped_restore (&fi
->current_variant_part
->processing_variant
,
16185 fi
->current_variant_part
->variants
.emplace_back ();
16186 variant_field
&variant
= fi
->current_variant_part
->variants
.back ();
16187 variant
.first_field
= fi
->fields
.size ();
16189 /* In a variant we want to get the discriminant and also add a
16190 field for our sole member child. */
16191 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr_value
, cu
);
16192 if (discr
== nullptr || !discr
->form_is_constant ())
16194 discr
= dwarf2_attr (die
, DW_AT_discr_list
, cu
);
16195 if (discr
== nullptr || discr
->as_block ()->size
== 0)
16196 variant
.default_branch
= true;
16198 variant
.discr_list_data
= discr
->as_block ();
16201 variant
.discriminant_value
= discr
->constant_value (0);
16203 for (die_info
*variant_child
= die
->child
;
16204 variant_child
!= NULL
;
16205 variant_child
= variant_child
->sibling
)
16206 handle_struct_member_die (variant_child
, type
, fi
, template_args
, cu
);
16208 variant
.last_field
= fi
->fields
.size ();
16211 /* A helper for process_structure_scope that handles a single member
16215 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
16216 struct field_info
*fi
,
16217 std::vector
<struct symbol
*> *template_args
,
16218 struct dwarf2_cu
*cu
)
16220 if (child_die
->tag
== DW_TAG_member
16221 || child_die
->tag
== DW_TAG_variable
)
16223 /* NOTE: carlton/2002-11-05: A C++ static data member
16224 should be a DW_TAG_member that is a declaration, but
16225 all versions of G++ as of this writing (so through at
16226 least 3.2.1) incorrectly generate DW_TAG_variable
16227 tags for them instead. */
16228 dwarf2_add_field (fi
, child_die
, cu
);
16230 else if (child_die
->tag
== DW_TAG_subprogram
)
16232 /* Rust doesn't have member functions in the C++ sense.
16233 However, it does emit ordinary functions as children
16234 of a struct DIE. */
16235 if (cu
->language
== language_rust
)
16236 read_func_scope (child_die
, cu
);
16239 /* C++ member function. */
16240 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
16243 else if (child_die
->tag
== DW_TAG_inheritance
)
16245 /* C++ base class field. */
16246 dwarf2_add_field (fi
, child_die
, cu
);
16248 else if (type_can_define_types (child_die
))
16249 dwarf2_add_type_defn (fi
, child_die
, cu
);
16250 else if (child_die
->tag
== DW_TAG_template_type_param
16251 || child_die
->tag
== DW_TAG_template_value_param
)
16253 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
16256 template_args
->push_back (arg
);
16258 else if (child_die
->tag
== DW_TAG_variant_part
)
16259 handle_variant_part (child_die
, type
, fi
, template_args
, cu
);
16260 else if (child_die
->tag
== DW_TAG_variant
)
16261 handle_variant (child_die
, type
, fi
, template_args
, cu
);
16264 /* Finish creating a structure or union type, including filling in
16265 its members and creating a symbol for it. */
16268 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16270 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16271 struct die_info
*child_die
;
16274 type
= get_die_type (die
, cu
);
16276 type
= read_structure_type (die
, cu
);
16278 bool has_template_parameters
= false;
16279 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
16281 struct field_info fi
;
16282 std::vector
<struct symbol
*> template_args
;
16284 child_die
= die
->child
;
16286 while (child_die
&& child_die
->tag
)
16288 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
16289 child_die
= child_die
->sibling
;
16292 /* Attach template arguments to type. */
16293 if (!template_args
.empty ())
16295 has_template_parameters
= true;
16296 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16297 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
16298 TYPE_TEMPLATE_ARGUMENTS (type
)
16299 = XOBNEWVEC (&objfile
->objfile_obstack
,
16301 TYPE_N_TEMPLATE_ARGUMENTS (type
));
16302 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
16303 template_args
.data (),
16304 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
16305 * sizeof (struct symbol
*)));
16308 /* Attach fields and member functions to the type. */
16309 if (fi
.nfields () > 0)
16310 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
16311 if (!fi
.fnfieldlists
.empty ())
16313 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
16315 /* Get the type which refers to the base class (possibly this
16316 class itself) which contains the vtable pointer for the current
16317 class from the DW_AT_containing_type attribute. This use of
16318 DW_AT_containing_type is a GNU extension. */
16320 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
16322 struct type
*t
= die_containing_type (die
, cu
);
16324 set_type_vptr_basetype (type
, t
);
16329 /* Our own class provides vtbl ptr. */
16330 for (i
= t
->num_fields () - 1;
16331 i
>= TYPE_N_BASECLASSES (t
);
16334 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
16336 if (is_vtable_name (fieldname
, cu
))
16338 set_type_vptr_fieldno (type
, i
);
16343 /* Complain if virtual function table field not found. */
16344 if (i
< TYPE_N_BASECLASSES (t
))
16345 complaint (_("virtual function table pointer "
16346 "not found when defining class '%s'"),
16347 type
->name () ? type
->name () : "");
16351 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
16354 else if (cu
->producer
16355 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
16357 /* The IBM XLC compiler does not provide direct indication
16358 of the containing type, but the vtable pointer is
16359 always named __vfp. */
16363 for (i
= type
->num_fields () - 1;
16364 i
>= TYPE_N_BASECLASSES (type
);
16367 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
16369 set_type_vptr_fieldno (type
, i
);
16370 set_type_vptr_basetype (type
, type
);
16377 /* Copy fi.typedef_field_list linked list elements content into the
16378 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16379 if (!fi
.typedef_field_list
.empty ())
16381 int count
= fi
.typedef_field_list
.size ();
16383 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16384 TYPE_TYPEDEF_FIELD_ARRAY (type
)
16385 = ((struct decl_field
*)
16387 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
16388 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
16390 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
16391 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
16394 /* Copy fi.nested_types_list linked list elements content into the
16395 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16396 if (!fi
.nested_types_list
.empty () && cu
->language
!= language_ada
)
16398 int count
= fi
.nested_types_list
.size ();
16400 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16401 TYPE_NESTED_TYPES_ARRAY (type
)
16402 = ((struct decl_field
*)
16403 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
16404 TYPE_NESTED_TYPES_COUNT (type
) = count
;
16406 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
16407 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
16411 quirk_gcc_member_function_pointer (type
, objfile
);
16412 if (cu
->language
== language_rust
&& die
->tag
== DW_TAG_union_type
)
16413 cu
->rust_unions
.push_back (type
);
16415 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16416 snapshots) has been known to create a die giving a declaration
16417 for a class that has, as a child, a die giving a definition for a
16418 nested class. So we have to process our children even if the
16419 current die is a declaration. Normally, of course, a declaration
16420 won't have any children at all. */
16422 child_die
= die
->child
;
16424 while (child_die
!= NULL
&& child_die
->tag
)
16426 if (child_die
->tag
== DW_TAG_member
16427 || child_die
->tag
== DW_TAG_variable
16428 || child_die
->tag
== DW_TAG_inheritance
16429 || child_die
->tag
== DW_TAG_template_value_param
16430 || child_die
->tag
== DW_TAG_template_type_param
)
16435 process_die (child_die
, cu
);
16437 child_die
= child_die
->sibling
;
16440 /* Do not consider external references. According to the DWARF standard,
16441 these DIEs are identified by the fact that they have no byte_size
16442 attribute, and a declaration attribute. */
16443 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16444 || !die_is_declaration (die
, cu
)
16445 || dwarf2_attr (die
, DW_AT_signature
, cu
) != NULL
)
16447 struct symbol
*sym
= new_symbol (die
, type
, cu
);
16449 if (has_template_parameters
)
16451 struct symtab
*symtab
;
16452 if (sym
!= nullptr)
16453 symtab
= symbol_symtab (sym
);
16454 else if (cu
->line_header
!= nullptr)
16456 /* Any related symtab will do. */
16458 = cu
->line_header
->file_names ()[0].symtab
;
16463 complaint (_("could not find suitable "
16464 "symtab for template parameter"
16465 " - DIE at %s [in module %s]"),
16466 sect_offset_str (die
->sect_off
),
16467 objfile_name (objfile
));
16470 if (symtab
!= nullptr)
16472 /* Make sure that the symtab is set on the new symbols.
16473 Even though they don't appear in this symtab directly,
16474 other parts of gdb assume that symbols do, and this is
16475 reasonably true. */
16476 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
16477 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
16483 /* Assuming DIE is an enumeration type, and TYPE is its associated
16484 type, update TYPE using some information only available in DIE's
16485 children. In particular, the fields are computed. */
16488 update_enumeration_type_from_children (struct die_info
*die
,
16490 struct dwarf2_cu
*cu
)
16492 struct die_info
*child_die
;
16493 int unsigned_enum
= 1;
16496 auto_obstack obstack
;
16497 std::vector
<struct field
> fields
;
16499 for (child_die
= die
->child
;
16500 child_die
!= NULL
&& child_die
->tag
;
16501 child_die
= child_die
->sibling
)
16503 struct attribute
*attr
;
16505 const gdb_byte
*bytes
;
16506 struct dwarf2_locexpr_baton
*baton
;
16509 if (child_die
->tag
!= DW_TAG_enumerator
)
16512 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16516 name
= dwarf2_name (child_die
, cu
);
16518 name
= "<anonymous enumerator>";
16520 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16521 &value
, &bytes
, &baton
);
16529 if (count_one_bits_ll (value
) >= 2)
16533 fields
.emplace_back ();
16534 struct field
&field
= fields
.back ();
16535 FIELD_NAME (field
) = dwarf2_physname (name
, child_die
, cu
);
16536 SET_FIELD_ENUMVAL (field
, value
);
16539 if (!fields
.empty ())
16541 type
->set_num_fields (fields
.size ());
16544 TYPE_ALLOC (type
, sizeof (struct field
) * fields
.size ()));
16545 memcpy (type
->fields (), fields
.data (),
16546 sizeof (struct field
) * fields
.size ());
16550 type
->set_is_unsigned (true);
16553 TYPE_FLAG_ENUM (type
) = 1;
16556 /* Given a DW_AT_enumeration_type die, set its type. We do not
16557 complete the type's fields yet, or create any symbols. */
16559 static struct type
*
16560 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16562 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16564 struct attribute
*attr
;
16567 /* If the definition of this type lives in .debug_types, read that type.
16568 Don't follow DW_AT_specification though, that will take us back up
16569 the chain and we want to go down. */
16570 attr
= die
->attr (DW_AT_signature
);
16571 if (attr
!= nullptr)
16573 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16575 /* The type's CU may not be the same as CU.
16576 Ensure TYPE is recorded with CU in die_type_hash. */
16577 return set_die_type (die
, type
, cu
);
16580 type
= alloc_type (objfile
);
16582 type
->set_code (TYPE_CODE_ENUM
);
16583 name
= dwarf2_full_name (NULL
, die
, cu
);
16585 type
->set_name (name
);
16587 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16590 struct type
*underlying_type
= die_type (die
, cu
);
16592 TYPE_TARGET_TYPE (type
) = underlying_type
;
16595 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16596 if (attr
!= nullptr)
16598 TYPE_LENGTH (type
) = attr
->constant_value (0);
16602 TYPE_LENGTH (type
) = 0;
16605 maybe_set_alignment (cu
, die
, type
);
16607 /* The enumeration DIE can be incomplete. In Ada, any type can be
16608 declared as private in the package spec, and then defined only
16609 inside the package body. Such types are known as Taft Amendment
16610 Types. When another package uses such a type, an incomplete DIE
16611 may be generated by the compiler. */
16612 if (die_is_declaration (die
, cu
))
16613 type
->set_is_stub (true);
16615 /* If this type has an underlying type that is not a stub, then we
16616 may use its attributes. We always use the "unsigned" attribute
16617 in this situation, because ordinarily we guess whether the type
16618 is unsigned -- but the guess can be wrong and the underlying type
16619 can tell us the reality. However, we defer to a local size
16620 attribute if one exists, because this lets the compiler override
16621 the underlying type if needed. */
16622 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_TARGET_TYPE (type
)->is_stub ())
16624 struct type
*underlying_type
= TYPE_TARGET_TYPE (type
);
16625 underlying_type
= check_typedef (underlying_type
);
16627 type
->set_is_unsigned (underlying_type
->is_unsigned ());
16629 if (TYPE_LENGTH (type
) == 0)
16630 TYPE_LENGTH (type
) = TYPE_LENGTH (underlying_type
);
16632 if (TYPE_RAW_ALIGN (type
) == 0
16633 && TYPE_RAW_ALIGN (underlying_type
) != 0)
16634 set_type_align (type
, TYPE_RAW_ALIGN (underlying_type
));
16637 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
16639 set_die_type (die
, type
, cu
);
16641 /* Finish the creation of this type by using the enum's children.
16642 Note that, as usual, this must come after set_die_type to avoid
16643 infinite recursion when trying to compute the names of the
16645 update_enumeration_type_from_children (die
, type
, cu
);
16650 /* Given a pointer to a die which begins an enumeration, process all
16651 the dies that define the members of the enumeration, and create the
16652 symbol for the enumeration type.
16654 NOTE: We reverse the order of the element list. */
16657 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16659 struct type
*this_type
;
16661 this_type
= get_die_type (die
, cu
);
16662 if (this_type
== NULL
)
16663 this_type
= read_enumeration_type (die
, cu
);
16665 if (die
->child
!= NULL
)
16667 struct die_info
*child_die
;
16670 child_die
= die
->child
;
16671 while (child_die
&& child_die
->tag
)
16673 if (child_die
->tag
!= DW_TAG_enumerator
)
16675 process_die (child_die
, cu
);
16679 name
= dwarf2_name (child_die
, cu
);
16681 new_symbol (child_die
, this_type
, cu
);
16684 child_die
= child_die
->sibling
;
16688 /* If we are reading an enum from a .debug_types unit, and the enum
16689 is a declaration, and the enum is not the signatured type in the
16690 unit, then we do not want to add a symbol for it. Adding a
16691 symbol would in some cases obscure the true definition of the
16692 enum, giving users an incomplete type when the definition is
16693 actually available. Note that we do not want to do this for all
16694 enums which are just declarations, because C++0x allows forward
16695 enum declarations. */
16696 if (cu
->per_cu
->is_debug_types
16697 && die_is_declaration (die
, cu
))
16699 struct signatured_type
*sig_type
;
16701 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16702 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16703 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16707 new_symbol (die
, this_type
, cu
);
16710 /* Extract all information from a DW_TAG_array_type DIE and put it in
16711 the DIE's type field. For now, this only handles one dimensional
16714 static struct type
*
16715 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16717 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16718 struct die_info
*child_die
;
16720 struct type
*element_type
, *range_type
, *index_type
;
16721 struct attribute
*attr
;
16723 struct dynamic_prop
*byte_stride_prop
= NULL
;
16724 unsigned int bit_stride
= 0;
16726 element_type
= die_type (die
, cu
);
16728 /* The die_type call above may have already set the type for this DIE. */
16729 type
= get_die_type (die
, cu
);
16733 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
16737 struct type
*prop_type
= cu
->addr_sized_int_type (false);
16740 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
16741 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
16745 complaint (_("unable to read array DW_AT_byte_stride "
16746 " - DIE at %s [in module %s]"),
16747 sect_offset_str (die
->sect_off
),
16748 objfile_name (cu
->per_objfile
->objfile
));
16749 /* Ignore this attribute. We will likely not be able to print
16750 arrays of this type correctly, but there is little we can do
16751 to help if we cannot read the attribute's value. */
16752 byte_stride_prop
= NULL
;
16756 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
16758 bit_stride
= attr
->constant_value (0);
16760 /* Irix 6.2 native cc creates array types without children for
16761 arrays with unspecified length. */
16762 if (die
->child
== NULL
)
16764 index_type
= objfile_type (objfile
)->builtin_int
;
16765 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
16766 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
16767 byte_stride_prop
, bit_stride
);
16768 return set_die_type (die
, type
, cu
);
16771 std::vector
<struct type
*> range_types
;
16772 child_die
= die
->child
;
16773 while (child_die
&& child_die
->tag
)
16775 if (child_die
->tag
== DW_TAG_subrange_type
)
16777 struct type
*child_type
= read_type_die (child_die
, cu
);
16779 if (child_type
!= NULL
)
16781 /* The range type was succesfully read. Save it for the
16782 array type creation. */
16783 range_types
.push_back (child_type
);
16786 child_die
= child_die
->sibling
;
16789 /* Dwarf2 dimensions are output from left to right, create the
16790 necessary array types in backwards order. */
16792 type
= element_type
;
16794 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
16798 while (i
< range_types
.size ())
16799 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
16800 byte_stride_prop
, bit_stride
);
16804 size_t ndim
= range_types
.size ();
16806 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
16807 byte_stride_prop
, bit_stride
);
16810 /* Understand Dwarf2 support for vector types (like they occur on
16811 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16812 array type. This is not part of the Dwarf2/3 standard yet, but a
16813 custom vendor extension. The main difference between a regular
16814 array and the vector variant is that vectors are passed by value
16816 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
16817 if (attr
!= nullptr)
16818 make_vector_type (type
);
16820 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16821 implementation may choose to implement triple vectors using this
16823 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16824 if (attr
!= nullptr && attr
->form_is_unsigned ())
16826 if (attr
->as_unsigned () >= TYPE_LENGTH (type
))
16827 TYPE_LENGTH (type
) = attr
->as_unsigned ();
16829 complaint (_("DW_AT_byte_size for array type smaller "
16830 "than the total size of elements"));
16833 name
= dwarf2_name (die
, cu
);
16835 type
->set_name (name
);
16837 maybe_set_alignment (cu
, die
, type
);
16839 /* Install the type in the die. */
16840 set_die_type (die
, type
, cu
);
16842 /* set_die_type should be already done. */
16843 set_descriptive_type (type
, die
, cu
);
16848 static enum dwarf_array_dim_ordering
16849 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
16851 struct attribute
*attr
;
16853 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
16855 if (attr
!= nullptr)
16857 LONGEST val
= attr
->constant_value (-1);
16858 if (val
== DW_ORD_row_major
|| val
== DW_ORD_col_major
)
16859 return (enum dwarf_array_dim_ordering
) val
;
16862 /* GNU F77 is a special case, as at 08/2004 array type info is the
16863 opposite order to the dwarf2 specification, but data is still
16864 laid out as per normal fortran.
16866 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16867 version checking. */
16869 if (cu
->language
== language_fortran
16870 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
16872 return DW_ORD_row_major
;
16875 switch (cu
->language_defn
->array_ordering ())
16877 case array_column_major
:
16878 return DW_ORD_col_major
;
16879 case array_row_major
:
16881 return DW_ORD_row_major
;
16885 /* Extract all information from a DW_TAG_set_type DIE and put it in
16886 the DIE's type field. */
16888 static struct type
*
16889 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16891 struct type
*domain_type
, *set_type
;
16892 struct attribute
*attr
;
16894 domain_type
= die_type (die
, cu
);
16896 /* The die_type call above may have already set the type for this DIE. */
16897 set_type
= get_die_type (die
, cu
);
16901 set_type
= create_set_type (NULL
, domain_type
);
16903 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16904 if (attr
!= nullptr && attr
->form_is_unsigned ())
16905 TYPE_LENGTH (set_type
) = attr
->as_unsigned ();
16907 maybe_set_alignment (cu
, die
, set_type
);
16909 return set_die_type (die
, set_type
, cu
);
16912 /* A helper for read_common_block that creates a locexpr baton.
16913 SYM is the symbol which we are marking as computed.
16914 COMMON_DIE is the DIE for the common block.
16915 COMMON_LOC is the location expression attribute for the common
16917 MEMBER_LOC is the location expression attribute for the particular
16918 member of the common block that we are processing.
16919 CU is the CU from which the above come. */
16922 mark_common_block_symbol_computed (struct symbol
*sym
,
16923 struct die_info
*common_die
,
16924 struct attribute
*common_loc
,
16925 struct attribute
*member_loc
,
16926 struct dwarf2_cu
*cu
)
16928 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
16929 struct objfile
*objfile
= per_objfile
->objfile
;
16930 struct dwarf2_locexpr_baton
*baton
;
16932 unsigned int cu_off
;
16933 enum bfd_endian byte_order
= gdbarch_byte_order (objfile
->arch ());
16934 LONGEST offset
= 0;
16936 gdb_assert (common_loc
&& member_loc
);
16937 gdb_assert (common_loc
->form_is_block ());
16938 gdb_assert (member_loc
->form_is_block ()
16939 || member_loc
->form_is_constant ());
16941 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
16942 baton
->per_objfile
= per_objfile
;
16943 baton
->per_cu
= cu
->per_cu
;
16944 gdb_assert (baton
->per_cu
);
16946 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16948 if (member_loc
->form_is_constant ())
16950 offset
= member_loc
->constant_value (0);
16951 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
16954 baton
->size
+= member_loc
->as_block ()->size
;
16956 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
16959 *ptr
++ = DW_OP_call4
;
16960 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
16961 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
16964 if (member_loc
->form_is_constant ())
16966 *ptr
++ = DW_OP_addr
;
16967 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
16968 ptr
+= cu
->header
.addr_size
;
16972 /* We have to copy the data here, because DW_OP_call4 will only
16973 use a DW_AT_location attribute. */
16974 struct dwarf_block
*block
= member_loc
->as_block ();
16975 memcpy (ptr
, block
->data
, block
->size
);
16976 ptr
+= block
->size
;
16979 *ptr
++ = DW_OP_plus
;
16980 gdb_assert (ptr
- baton
->data
== baton
->size
);
16982 SYMBOL_LOCATION_BATON (sym
) = baton
;
16983 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
16986 /* Create appropriate locally-scoped variables for all the
16987 DW_TAG_common_block entries. Also create a struct common_block
16988 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16989 is used to separate the common blocks name namespace from regular
16993 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
16995 struct attribute
*attr
;
16997 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16998 if (attr
!= nullptr)
17000 /* Support the .debug_loc offsets. */
17001 if (attr
->form_is_block ())
17005 else if (attr
->form_is_section_offset ())
17007 dwarf2_complex_location_expr_complaint ();
17012 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17013 "common block member");
17018 if (die
->child
!= NULL
)
17020 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17021 struct die_info
*child_die
;
17022 size_t n_entries
= 0, size
;
17023 struct common_block
*common_block
;
17024 struct symbol
*sym
;
17026 for (child_die
= die
->child
;
17027 child_die
&& child_die
->tag
;
17028 child_die
= child_die
->sibling
)
17031 size
= (sizeof (struct common_block
)
17032 + (n_entries
- 1) * sizeof (struct symbol
*));
17034 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
17036 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
17037 common_block
->n_entries
= 0;
17039 for (child_die
= die
->child
;
17040 child_die
&& child_die
->tag
;
17041 child_die
= child_die
->sibling
)
17043 /* Create the symbol in the DW_TAG_common_block block in the current
17045 sym
= new_symbol (child_die
, NULL
, cu
);
17048 struct attribute
*member_loc
;
17050 common_block
->contents
[common_block
->n_entries
++] = sym
;
17052 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
17056 /* GDB has handled this for a long time, but it is
17057 not specified by DWARF. It seems to have been
17058 emitted by gfortran at least as recently as:
17059 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
17060 complaint (_("Variable in common block has "
17061 "DW_AT_data_member_location "
17062 "- DIE at %s [in module %s]"),
17063 sect_offset_str (child_die
->sect_off
),
17064 objfile_name (objfile
));
17066 if (member_loc
->form_is_section_offset ())
17067 dwarf2_complex_location_expr_complaint ();
17068 else if (member_loc
->form_is_constant ()
17069 || member_loc
->form_is_block ())
17071 if (attr
!= nullptr)
17072 mark_common_block_symbol_computed (sym
, die
, attr
,
17076 dwarf2_complex_location_expr_complaint ();
17081 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
17082 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
17086 /* Create a type for a C++ namespace. */
17088 static struct type
*
17089 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17091 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17092 const char *previous_prefix
, *name
;
17096 /* For extensions, reuse the type of the original namespace. */
17097 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
17099 struct die_info
*ext_die
;
17100 struct dwarf2_cu
*ext_cu
= cu
;
17102 ext_die
= dwarf2_extension (die
, &ext_cu
);
17103 type
= read_type_die (ext_die
, ext_cu
);
17105 /* EXT_CU may not be the same as CU.
17106 Ensure TYPE is recorded with CU in die_type_hash. */
17107 return set_die_type (die
, type
, cu
);
17110 name
= namespace_name (die
, &is_anonymous
, cu
);
17112 /* Now build the name of the current namespace. */
17114 previous_prefix
= determine_prefix (die
, cu
);
17115 if (previous_prefix
[0] != '\0')
17116 name
= typename_concat (&objfile
->objfile_obstack
,
17117 previous_prefix
, name
, 0, cu
);
17119 /* Create the type. */
17120 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
17122 return set_die_type (die
, type
, cu
);
17125 /* Read a namespace scope. */
17128 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
17130 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17133 /* Add a symbol associated to this if we haven't seen the namespace
17134 before. Also, add a using directive if it's an anonymous
17137 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
17141 type
= read_type_die (die
, cu
);
17142 new_symbol (die
, type
, cu
);
17144 namespace_name (die
, &is_anonymous
, cu
);
17147 const char *previous_prefix
= determine_prefix (die
, cu
);
17149 std::vector
<const char *> excludes
;
17150 add_using_directive (using_directives (cu
),
17151 previous_prefix
, type
->name (), NULL
,
17152 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
17156 if (die
->child
!= NULL
)
17158 struct die_info
*child_die
= die
->child
;
17160 while (child_die
&& child_die
->tag
)
17162 process_die (child_die
, cu
);
17163 child_die
= child_die
->sibling
;
17168 /* Read a Fortran module as type. This DIE can be only a declaration used for
17169 imported module. Still we need that type as local Fortran "use ... only"
17170 declaration imports depend on the created type in determine_prefix. */
17172 static struct type
*
17173 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17175 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17176 const char *module_name
;
17179 module_name
= dwarf2_name (die
, cu
);
17180 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
17182 return set_die_type (die
, type
, cu
);
17185 /* Read a Fortran module. */
17188 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
17190 struct die_info
*child_die
= die
->child
;
17193 type
= read_type_die (die
, cu
);
17194 new_symbol (die
, type
, cu
);
17196 while (child_die
&& child_die
->tag
)
17198 process_die (child_die
, cu
);
17199 child_die
= child_die
->sibling
;
17203 /* Return the name of the namespace represented by DIE. Set
17204 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
17207 static const char *
17208 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
17210 struct die_info
*current_die
;
17211 const char *name
= NULL
;
17213 /* Loop through the extensions until we find a name. */
17215 for (current_die
= die
;
17216 current_die
!= NULL
;
17217 current_die
= dwarf2_extension (die
, &cu
))
17219 /* We don't use dwarf2_name here so that we can detect the absence
17220 of a name -> anonymous namespace. */
17221 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
17227 /* Is it an anonymous namespace? */
17229 *is_anonymous
= (name
== NULL
);
17231 name
= CP_ANONYMOUS_NAMESPACE_STR
;
17236 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17237 the user defined type vector. */
17239 static struct type
*
17240 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17242 struct gdbarch
*gdbarch
= cu
->per_objfile
->objfile
->arch ();
17243 struct comp_unit_head
*cu_header
= &cu
->header
;
17245 struct attribute
*attr_byte_size
;
17246 struct attribute
*attr_address_class
;
17247 int byte_size
, addr_class
;
17248 struct type
*target_type
;
17250 target_type
= die_type (die
, cu
);
17252 /* The die_type call above may have already set the type for this DIE. */
17253 type
= get_die_type (die
, cu
);
17257 type
= lookup_pointer_type (target_type
);
17259 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17260 if (attr_byte_size
)
17261 byte_size
= attr_byte_size
->constant_value (cu_header
->addr_size
);
17263 byte_size
= cu_header
->addr_size
;
17265 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
17266 if (attr_address_class
)
17267 addr_class
= attr_address_class
->constant_value (DW_ADDR_none
);
17269 addr_class
= DW_ADDR_none
;
17271 ULONGEST alignment
= get_alignment (cu
, die
);
17273 /* If the pointer size, alignment, or address class is different
17274 than the default, create a type variant marked as such and set
17275 the length accordingly. */
17276 if (TYPE_LENGTH (type
) != byte_size
17277 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
17278 && alignment
!= TYPE_RAW_ALIGN (type
))
17279 || addr_class
!= DW_ADDR_none
)
17281 if (gdbarch_address_class_type_flags_p (gdbarch
))
17283 type_instance_flags type_flags
17284 = gdbarch_address_class_type_flags (gdbarch
, byte_size
,
17286 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17288 type
= make_type_with_address_space (type
, type_flags
);
17290 else if (TYPE_LENGTH (type
) != byte_size
)
17292 complaint (_("invalid pointer size %d"), byte_size
);
17294 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17296 complaint (_("Invalid DW_AT_alignment"
17297 " - DIE at %s [in module %s]"),
17298 sect_offset_str (die
->sect_off
),
17299 objfile_name (cu
->per_objfile
->objfile
));
17303 /* Should we also complain about unhandled address classes? */
17307 TYPE_LENGTH (type
) = byte_size
;
17308 set_type_align (type
, alignment
);
17309 return set_die_type (die
, type
, cu
);
17312 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17313 the user defined type vector. */
17315 static struct type
*
17316 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17319 struct type
*to_type
;
17320 struct type
*domain
;
17322 to_type
= die_type (die
, cu
);
17323 domain
= die_containing_type (die
, cu
);
17325 /* The calls above may have already set the type for this DIE. */
17326 type
= get_die_type (die
, cu
);
17330 if (check_typedef (to_type
)->code () == TYPE_CODE_METHOD
)
17331 type
= lookup_methodptr_type (to_type
);
17332 else if (check_typedef (to_type
)->code () == TYPE_CODE_FUNC
)
17334 struct type
*new_type
= alloc_type (cu
->per_objfile
->objfile
);
17336 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17337 to_type
->fields (), to_type
->num_fields (),
17338 to_type
->has_varargs ());
17339 type
= lookup_methodptr_type (new_type
);
17342 type
= lookup_memberptr_type (to_type
, domain
);
17344 return set_die_type (die
, type
, cu
);
17347 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17348 the user defined type vector. */
17350 static struct type
*
17351 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17352 enum type_code refcode
)
17354 struct comp_unit_head
*cu_header
= &cu
->header
;
17355 struct type
*type
, *target_type
;
17356 struct attribute
*attr
;
17358 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17360 target_type
= die_type (die
, cu
);
17362 /* The die_type call above may have already set the type for this DIE. */
17363 type
= get_die_type (die
, cu
);
17367 type
= lookup_reference_type (target_type
, refcode
);
17368 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17369 if (attr
!= nullptr)
17371 TYPE_LENGTH (type
) = attr
->constant_value (cu_header
->addr_size
);
17375 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17377 maybe_set_alignment (cu
, die
, type
);
17378 return set_die_type (die
, type
, cu
);
17381 /* Add the given cv-qualifiers to the element type of the array. GCC
17382 outputs DWARF type qualifiers that apply to an array, not the
17383 element type. But GDB relies on the array element type to carry
17384 the cv-qualifiers. This mimics section 6.7.3 of the C99
17387 static struct type
*
17388 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17389 struct type
*base_type
, int cnst
, int voltl
)
17391 struct type
*el_type
, *inner_array
;
17393 base_type
= copy_type (base_type
);
17394 inner_array
= base_type
;
17396 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
17398 TYPE_TARGET_TYPE (inner_array
) =
17399 copy_type (TYPE_TARGET_TYPE (inner_array
));
17400 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17403 el_type
= TYPE_TARGET_TYPE (inner_array
);
17404 cnst
|= TYPE_CONST (el_type
);
17405 voltl
|= TYPE_VOLATILE (el_type
);
17406 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17408 return set_die_type (die
, base_type
, cu
);
17411 static struct type
*
17412 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17414 struct type
*base_type
, *cv_type
;
17416 base_type
= die_type (die
, cu
);
17418 /* The die_type call above may have already set the type for this DIE. */
17419 cv_type
= get_die_type (die
, cu
);
17423 /* In case the const qualifier is applied to an array type, the element type
17424 is so qualified, not the array type (section 6.7.3 of C99). */
17425 if (base_type
->code () == TYPE_CODE_ARRAY
)
17426 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17428 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17429 return set_die_type (die
, cv_type
, cu
);
17432 static struct type
*
17433 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17435 struct type
*base_type
, *cv_type
;
17437 base_type
= die_type (die
, cu
);
17439 /* The die_type call above may have already set the type for this DIE. */
17440 cv_type
= get_die_type (die
, cu
);
17444 /* In case the volatile qualifier is applied to an array type, the
17445 element type is so qualified, not the array type (section 6.7.3
17447 if (base_type
->code () == TYPE_CODE_ARRAY
)
17448 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17450 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17451 return set_die_type (die
, cv_type
, cu
);
17454 /* Handle DW_TAG_restrict_type. */
17456 static struct type
*
17457 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17459 struct type
*base_type
, *cv_type
;
17461 base_type
= die_type (die
, cu
);
17463 /* The die_type call above may have already set the type for this DIE. */
17464 cv_type
= get_die_type (die
, cu
);
17468 cv_type
= make_restrict_type (base_type
);
17469 return set_die_type (die
, cv_type
, cu
);
17472 /* Handle DW_TAG_atomic_type. */
17474 static struct type
*
17475 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17477 struct type
*base_type
, *cv_type
;
17479 base_type
= die_type (die
, cu
);
17481 /* The die_type call above may have already set the type for this DIE. */
17482 cv_type
= get_die_type (die
, cu
);
17486 cv_type
= make_atomic_type (base_type
);
17487 return set_die_type (die
, cv_type
, cu
);
17490 /* Extract all information from a DW_TAG_string_type DIE and add to
17491 the user defined type vector. It isn't really a user defined type,
17492 but it behaves like one, with other DIE's using an AT_user_def_type
17493 attribute to reference it. */
17495 static struct type
*
17496 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17498 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17499 struct gdbarch
*gdbarch
= objfile
->arch ();
17500 struct type
*type
, *range_type
, *index_type
, *char_type
;
17501 struct attribute
*attr
;
17502 struct dynamic_prop prop
;
17503 bool length_is_constant
= true;
17506 /* There are a couple of places where bit sizes might be made use of
17507 when parsing a DW_TAG_string_type, however, no producer that we know
17508 of make use of these. Handling bit sizes that are a multiple of the
17509 byte size is easy enough, but what about other bit sizes? Lets deal
17510 with that problem when we have to. Warn about these attributes being
17511 unsupported, then parse the type and ignore them like we always
17513 if (dwarf2_attr (die
, DW_AT_bit_size
, cu
) != nullptr
17514 || dwarf2_attr (die
, DW_AT_string_length_bit_size
, cu
) != nullptr)
17516 static bool warning_printed
= false;
17517 if (!warning_printed
)
17519 warning (_("DW_AT_bit_size and DW_AT_string_length_bit_size not "
17520 "currently supported on DW_TAG_string_type."));
17521 warning_printed
= true;
17525 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17526 if (attr
!= nullptr && !attr
->form_is_constant ())
17528 /* The string length describes the location at which the length of
17529 the string can be found. The size of the length field can be
17530 specified with one of the attributes below. */
17531 struct type
*prop_type
;
17532 struct attribute
*len
17533 = dwarf2_attr (die
, DW_AT_string_length_byte_size
, cu
);
17534 if (len
== nullptr)
17535 len
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17536 if (len
!= nullptr && len
->form_is_constant ())
17538 /* Pass 0 as the default as we know this attribute is constant
17539 and the default value will not be returned. */
17540 LONGEST sz
= len
->constant_value (0);
17541 prop_type
= cu
->per_objfile
->int_type (sz
, true);
17545 /* If the size is not specified then we assume it is the size of
17546 an address on this target. */
17547 prop_type
= cu
->addr_sized_int_type (true);
17550 /* Convert the attribute into a dynamic property. */
17551 if (!attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
17554 length_is_constant
= false;
17556 else if (attr
!= nullptr)
17558 /* This DW_AT_string_length just contains the length with no
17559 indirection. There's no need to create a dynamic property in this
17560 case. Pass 0 for the default value as we know it will not be
17561 returned in this case. */
17562 length
= attr
->constant_value (0);
17564 else if ((attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
)) != nullptr)
17566 /* We don't currently support non-constant byte sizes for strings. */
17567 length
= attr
->constant_value (1);
17571 /* Use 1 as a fallback length if we have nothing else. */
17575 index_type
= objfile_type (objfile
)->builtin_int
;
17576 if (length_is_constant
)
17577 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17580 struct dynamic_prop low_bound
;
17582 low_bound
.set_const_val (1);
17583 range_type
= create_range_type (NULL
, index_type
, &low_bound
, &prop
, 0);
17585 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17586 type
= create_string_type (NULL
, char_type
, range_type
);
17588 return set_die_type (die
, type
, cu
);
17591 /* Assuming that DIE corresponds to a function, returns nonzero
17592 if the function is prototyped. */
17595 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17597 struct attribute
*attr
;
17599 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17600 if (attr
&& attr
->as_boolean ())
17603 /* The DWARF standard implies that the DW_AT_prototyped attribute
17604 is only meaningful for C, but the concept also extends to other
17605 languages that allow unprototyped functions (Eg: Objective C).
17606 For all other languages, assume that functions are always
17608 if (cu
->language
!= language_c
17609 && cu
->language
!= language_objc
17610 && cu
->language
!= language_opencl
)
17613 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17614 prototyped and unprototyped functions; default to prototyped,
17615 since that is more common in modern code (and RealView warns
17616 about unprototyped functions). */
17617 if (producer_is_realview (cu
->producer
))
17623 /* Handle DIES due to C code like:
17627 int (*funcp)(int a, long l);
17631 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17633 static struct type
*
17634 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17636 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17637 struct type
*type
; /* Type that this function returns. */
17638 struct type
*ftype
; /* Function that returns above type. */
17639 struct attribute
*attr
;
17641 type
= die_type (die
, cu
);
17643 /* The die_type call above may have already set the type for this DIE. */
17644 ftype
= get_die_type (die
, cu
);
17648 ftype
= lookup_function_type (type
);
17650 if (prototyped_function_p (die
, cu
))
17651 ftype
->set_is_prototyped (true);
17653 /* Store the calling convention in the type if it's available in
17654 the subroutine die. Otherwise set the calling convention to
17655 the default value DW_CC_normal. */
17656 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
17657 if (attr
!= nullptr
17658 && is_valid_DW_AT_calling_convention_for_subroutine (attr
->constant_value (0)))
17659 TYPE_CALLING_CONVENTION (ftype
)
17660 = (enum dwarf_calling_convention
) attr
->constant_value (0);
17661 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
17662 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
17664 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
17666 /* Record whether the function returns normally to its caller or not
17667 if the DWARF producer set that information. */
17668 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
17669 if (attr
&& attr
->as_boolean ())
17670 TYPE_NO_RETURN (ftype
) = 1;
17672 /* We need to add the subroutine type to the die immediately so
17673 we don't infinitely recurse when dealing with parameters
17674 declared as the same subroutine type. */
17675 set_die_type (die
, ftype
, cu
);
17677 if (die
->child
!= NULL
)
17679 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
17680 struct die_info
*child_die
;
17681 int nparams
, iparams
;
17683 /* Count the number of parameters.
17684 FIXME: GDB currently ignores vararg functions, but knows about
17685 vararg member functions. */
17687 child_die
= die
->child
;
17688 while (child_die
&& child_die
->tag
)
17690 if (child_die
->tag
== DW_TAG_formal_parameter
)
17692 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
17693 ftype
->set_has_varargs (true);
17695 child_die
= child_die
->sibling
;
17698 /* Allocate storage for parameters and fill them in. */
17699 ftype
->set_num_fields (nparams
);
17701 ((struct field
*) TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
)));
17703 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17704 even if we error out during the parameters reading below. */
17705 for (iparams
= 0; iparams
< nparams
; iparams
++)
17706 ftype
->field (iparams
).set_type (void_type
);
17709 child_die
= die
->child
;
17710 while (child_die
&& child_die
->tag
)
17712 if (child_die
->tag
== DW_TAG_formal_parameter
)
17714 struct type
*arg_type
;
17716 /* DWARF version 2 has no clean way to discern C++
17717 static and non-static member functions. G++ helps
17718 GDB by marking the first parameter for non-static
17719 member functions (which is the this pointer) as
17720 artificial. We pass this information to
17721 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17723 DWARF version 3 added DW_AT_object_pointer, which GCC
17724 4.5 does not yet generate. */
17725 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
17726 if (attr
!= nullptr)
17727 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = attr
->as_boolean ();
17729 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
17730 arg_type
= die_type (child_die
, cu
);
17732 /* RealView does not mark THIS as const, which the testsuite
17733 expects. GCC marks THIS as const in method definitions,
17734 but not in the class specifications (GCC PR 43053). */
17735 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
17736 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
17739 struct dwarf2_cu
*arg_cu
= cu
;
17740 const char *name
= dwarf2_name (child_die
, cu
);
17742 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
17743 if (attr
!= nullptr)
17745 /* If the compiler emits this, use it. */
17746 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
17749 else if (name
&& strcmp (name
, "this") == 0)
17750 /* Function definitions will have the argument names. */
17752 else if (name
== NULL
&& iparams
== 0)
17753 /* Declarations may not have the names, so like
17754 elsewhere in GDB, assume an artificial first
17755 argument is "this". */
17759 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
17763 ftype
->field (iparams
).set_type (arg_type
);
17766 child_die
= child_die
->sibling
;
17773 static struct type
*
17774 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
17776 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17777 const char *name
= NULL
;
17778 struct type
*this_type
, *target_type
;
17780 name
= dwarf2_full_name (NULL
, die
, cu
);
17781 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
17782 this_type
->set_target_is_stub (true);
17783 set_die_type (die
, this_type
, cu
);
17784 target_type
= die_type (die
, cu
);
17785 if (target_type
!= this_type
)
17786 TYPE_TARGET_TYPE (this_type
) = target_type
;
17789 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17790 spec and cause infinite loops in GDB. */
17791 complaint (_("Self-referential DW_TAG_typedef "
17792 "- DIE at %s [in module %s]"),
17793 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
17794 TYPE_TARGET_TYPE (this_type
) = NULL
;
17798 /* Gcc-7 and before supports -feliminate-dwarf2-dups, which generates
17799 anonymous typedefs, which is, strictly speaking, invalid DWARF.
17800 Handle these by just returning the target type, rather than
17801 constructing an anonymous typedef type and trying to handle this
17803 set_die_type (die
, target_type
, cu
);
17804 return target_type
;
17809 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17810 (which may be different from NAME) to the architecture back-end to allow
17811 it to guess the correct format if necessary. */
17813 static struct type
*
17814 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
17815 const char *name_hint
, enum bfd_endian byte_order
)
17817 struct gdbarch
*gdbarch
= objfile
->arch ();
17818 const struct floatformat
**format
;
17821 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
17823 type
= init_float_type (objfile
, bits
, name
, format
, byte_order
);
17825 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17830 /* Allocate an integer type of size BITS and name NAME. */
17832 static struct type
*
17833 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
17834 int bits
, int unsigned_p
, const char *name
)
17838 /* Versions of Intel's C Compiler generate an integer type called "void"
17839 instead of using DW_TAG_unspecified_type. This has been seen on
17840 at least versions 14, 17, and 18. */
17841 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
17842 && strcmp (name
, "void") == 0)
17843 type
= objfile_type (objfile
)->builtin_void
;
17845 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
17850 /* Initialise and return a floating point type of size BITS suitable for
17851 use as a component of a complex number. The NAME_HINT is passed through
17852 when initialising the floating point type and is the name of the complex
17855 As DWARF doesn't currently provide an explicit name for the components
17856 of a complex number, but it can be helpful to have these components
17857 named, we try to select a suitable name based on the size of the
17859 static struct type
*
17860 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
17861 struct objfile
*objfile
,
17862 int bits
, const char *name_hint
,
17863 enum bfd_endian byte_order
)
17865 gdbarch
*gdbarch
= objfile
->arch ();
17866 struct type
*tt
= nullptr;
17868 /* Try to find a suitable floating point builtin type of size BITS.
17869 We're going to use the name of this type as the name for the complex
17870 target type that we are about to create. */
17871 switch (cu
->language
)
17873 case language_fortran
:
17877 tt
= builtin_f_type (gdbarch
)->builtin_real
;
17880 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
17882 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17884 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
17892 tt
= builtin_type (gdbarch
)->builtin_float
;
17895 tt
= builtin_type (gdbarch
)->builtin_double
;
17897 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17899 tt
= builtin_type (gdbarch
)->builtin_long_double
;
17905 /* If the type we found doesn't match the size we were looking for, then
17906 pretend we didn't find a type at all, the complex target type we
17907 create will then be nameless. */
17908 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
17911 const char *name
= (tt
== nullptr) ? nullptr : tt
->name ();
17912 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
, byte_order
);
17915 /* Find a representation of a given base type and install
17916 it in the TYPE field of the die. */
17918 static struct type
*
17919 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17921 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17923 struct attribute
*attr
;
17924 int encoding
= 0, bits
= 0;
17928 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
17929 if (attr
!= nullptr && attr
->form_is_constant ())
17930 encoding
= attr
->constant_value (0);
17931 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17932 if (attr
!= nullptr)
17933 bits
= attr
->constant_value (0) * TARGET_CHAR_BIT
;
17934 name
= dwarf2_name (die
, cu
);
17936 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17938 arch
= objfile
->arch ();
17939 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
17941 attr
= dwarf2_attr (die
, DW_AT_endianity
, cu
);
17942 if (attr
!= nullptr && attr
->form_is_constant ())
17944 int endianity
= attr
->constant_value (0);
17949 byte_order
= BFD_ENDIAN_BIG
;
17951 case DW_END_little
:
17952 byte_order
= BFD_ENDIAN_LITTLE
;
17955 complaint (_("DW_AT_endianity has unrecognized value %d"), endianity
);
17962 case DW_ATE_address
:
17963 /* Turn DW_ATE_address into a void * pointer. */
17964 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
17965 type
= init_pointer_type (objfile
, bits
, name
, type
);
17967 case DW_ATE_boolean
:
17968 type
= init_boolean_type (objfile
, bits
, 1, name
);
17970 case DW_ATE_complex_float
:
17971 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
,
17973 if (type
->code () == TYPE_CODE_ERROR
)
17975 if (name
== nullptr)
17977 struct obstack
*obstack
17978 = &cu
->per_objfile
->objfile
->objfile_obstack
;
17979 name
= obconcat (obstack
, "_Complex ", type
->name (),
17982 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17985 type
= init_complex_type (name
, type
);
17987 case DW_ATE_decimal_float
:
17988 type
= init_decfloat_type (objfile
, bits
, name
);
17991 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
, byte_order
);
17993 case DW_ATE_signed
:
17994 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
17996 case DW_ATE_unsigned
:
17997 if (cu
->language
== language_fortran
17999 && startswith (name
, "character("))
18000 type
= init_character_type (objfile
, bits
, 1, name
);
18002 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18004 case DW_ATE_signed_char
:
18005 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18006 || cu
->language
== language_pascal
18007 || cu
->language
== language_fortran
)
18008 type
= init_character_type (objfile
, bits
, 0, name
);
18010 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18012 case DW_ATE_unsigned_char
:
18013 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18014 || cu
->language
== language_pascal
18015 || cu
->language
== language_fortran
18016 || cu
->language
== language_rust
)
18017 type
= init_character_type (objfile
, bits
, 1, name
);
18019 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18024 type
= builtin_type (arch
)->builtin_char16
;
18025 else if (bits
== 32)
18026 type
= builtin_type (arch
)->builtin_char32
;
18029 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
18031 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18033 return set_die_type (die
, type
, cu
);
18038 complaint (_("unsupported DW_AT_encoding: '%s'"),
18039 dwarf_type_encoding_name (encoding
));
18040 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18044 if (name
&& strcmp (name
, "char") == 0)
18045 type
->set_has_no_signedness (true);
18047 maybe_set_alignment (cu
, die
, type
);
18049 type
->set_endianity_is_not_default (gdbarch_byte_order (arch
) != byte_order
);
18051 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_INT
)
18053 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
18054 if (attr
!= nullptr && attr
->as_unsigned () <= 8 * TYPE_LENGTH (type
))
18056 unsigned real_bit_size
= attr
->as_unsigned ();
18057 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
18058 /* Only use the attributes if they make sense together. */
18059 if (attr
== nullptr
18060 || (attr
->as_unsigned () + real_bit_size
18061 <= 8 * TYPE_LENGTH (type
)))
18063 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_size
18065 if (attr
!= nullptr)
18066 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_offset
18067 = attr
->as_unsigned ();
18072 return set_die_type (die
, type
, cu
);
18075 /* Parse dwarf attribute if it's a block, reference or constant and put the
18076 resulting value of the attribute into struct bound_prop.
18077 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
18080 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
18081 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
18082 struct type
*default_type
)
18084 struct dwarf2_property_baton
*baton
;
18085 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
18086 struct objfile
*objfile
= per_objfile
->objfile
;
18087 struct obstack
*obstack
= &objfile
->objfile_obstack
;
18089 gdb_assert (default_type
!= NULL
);
18091 if (attr
== NULL
|| prop
== NULL
)
18094 if (attr
->form_is_block ())
18096 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18097 baton
->property_type
= default_type
;
18098 baton
->locexpr
.per_cu
= cu
->per_cu
;
18099 baton
->locexpr
.per_objfile
= per_objfile
;
18101 struct dwarf_block
*block
= attr
->as_block ();
18102 baton
->locexpr
.size
= block
->size
;
18103 baton
->locexpr
.data
= block
->data
;
18104 switch (attr
->name
)
18106 case DW_AT_string_length
:
18107 baton
->locexpr
.is_reference
= true;
18110 baton
->locexpr
.is_reference
= false;
18114 prop
->set_locexpr (baton
);
18115 gdb_assert (prop
->baton () != NULL
);
18117 else if (attr
->form_is_ref ())
18119 struct dwarf2_cu
*target_cu
= cu
;
18120 struct die_info
*target_die
;
18121 struct attribute
*target_attr
;
18123 target_die
= follow_die_ref (die
, attr
, &target_cu
);
18124 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
18125 if (target_attr
== NULL
)
18126 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
18128 if (target_attr
== NULL
)
18131 switch (target_attr
->name
)
18133 case DW_AT_location
:
18134 if (target_attr
->form_is_section_offset ())
18136 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18137 baton
->property_type
= die_type (target_die
, target_cu
);
18138 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
18139 prop
->set_loclist (baton
);
18140 gdb_assert (prop
->baton () != NULL
);
18142 else if (target_attr
->form_is_block ())
18144 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18145 baton
->property_type
= die_type (target_die
, target_cu
);
18146 baton
->locexpr
.per_cu
= cu
->per_cu
;
18147 baton
->locexpr
.per_objfile
= per_objfile
;
18148 struct dwarf_block
*block
= target_attr
->as_block ();
18149 baton
->locexpr
.size
= block
->size
;
18150 baton
->locexpr
.data
= block
->data
;
18151 baton
->locexpr
.is_reference
= true;
18152 prop
->set_locexpr (baton
);
18153 gdb_assert (prop
->baton () != NULL
);
18157 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18158 "dynamic property");
18162 case DW_AT_data_member_location
:
18166 if (!handle_data_member_location (target_die
, target_cu
,
18170 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18171 baton
->property_type
= read_type_die (target_die
->parent
,
18173 baton
->offset_info
.offset
= offset
;
18174 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
18175 prop
->set_addr_offset (baton
);
18180 else if (attr
->form_is_constant ())
18181 prop
->set_const_val (attr
->constant_value (0));
18184 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
18185 dwarf2_name (die
, cu
));
18195 dwarf2_per_objfile::int_type (int size_in_bytes
, bool unsigned_p
) const
18197 struct type
*int_type
;
18199 /* Helper macro to examine the various builtin types. */
18200 #define TRY_TYPE(F) \
18201 int_type = (unsigned_p \
18202 ? objfile_type (objfile)->builtin_unsigned_ ## F \
18203 : objfile_type (objfile)->builtin_ ## F); \
18204 if (int_type != NULL && TYPE_LENGTH (int_type) == size_in_bytes) \
18211 TRY_TYPE (long_long
);
18215 gdb_assert_not_reached ("unable to find suitable integer type");
18221 dwarf2_cu::addr_sized_int_type (bool unsigned_p
) const
18223 int addr_size
= this->per_cu
->addr_size ();
18224 return this->per_objfile
->int_type (addr_size
, unsigned_p
);
18227 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
18228 present (which is valid) then compute the default type based on the
18229 compilation units address size. */
18231 static struct type
*
18232 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18234 struct type
*index_type
= die_type (die
, cu
);
18236 /* Dwarf-2 specifications explicitly allows to create subrange types
18237 without specifying a base type.
18238 In that case, the base type must be set to the type of
18239 the lower bound, upper bound or count, in that order, if any of these
18240 three attributes references an object that has a type.
18241 If no base type is found, the Dwarf-2 specifications say that
18242 a signed integer type of size equal to the size of an address should
18244 For the following C code: `extern char gdb_int [];'
18245 GCC produces an empty range DIE.
18246 FIXME: muller/2010-05-28: Possible references to object for low bound,
18247 high bound or count are not yet handled by this code. */
18248 if (index_type
->code () == TYPE_CODE_VOID
)
18249 index_type
= cu
->addr_sized_int_type (false);
18254 /* Read the given DW_AT_subrange DIE. */
18256 static struct type
*
18257 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18259 struct type
*base_type
, *orig_base_type
;
18260 struct type
*range_type
;
18261 struct attribute
*attr
;
18262 struct dynamic_prop low
, high
;
18263 int low_default_is_valid
;
18264 int high_bound_is_count
= 0;
18266 ULONGEST negative_mask
;
18268 orig_base_type
= read_subrange_index_type (die
, cu
);
18270 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
18271 whereas the real type might be. So, we use ORIG_BASE_TYPE when
18272 creating the range type, but we use the result of check_typedef
18273 when examining properties of the type. */
18274 base_type
= check_typedef (orig_base_type
);
18276 /* The die_type call above may have already set the type for this DIE. */
18277 range_type
= get_die_type (die
, cu
);
18281 high
.set_const_val (0);
18283 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
18284 omitting DW_AT_lower_bound. */
18285 switch (cu
->language
)
18288 case language_cplus
:
18289 low
.set_const_val (0);
18290 low_default_is_valid
= 1;
18292 case language_fortran
:
18293 low
.set_const_val (1);
18294 low_default_is_valid
= 1;
18297 case language_objc
:
18298 case language_rust
:
18299 low
.set_const_val (0);
18300 low_default_is_valid
= (cu
->header
.version
>= 4);
18304 case language_pascal
:
18305 low
.set_const_val (1);
18306 low_default_is_valid
= (cu
->header
.version
>= 4);
18309 low
.set_const_val (0);
18310 low_default_is_valid
= 0;
18314 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
18315 if (attr
!= nullptr)
18316 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
18317 else if (!low_default_is_valid
)
18318 complaint (_("Missing DW_AT_lower_bound "
18319 "- DIE at %s [in module %s]"),
18320 sect_offset_str (die
->sect_off
),
18321 objfile_name (cu
->per_objfile
->objfile
));
18323 struct attribute
*attr_ub
, *attr_count
;
18324 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
18325 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18327 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
18328 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18330 /* If bounds are constant do the final calculation here. */
18331 if (low
.kind () == PROP_CONST
&& high
.kind () == PROP_CONST
)
18332 high
.set_const_val (low
.const_val () + high
.const_val () - 1);
18334 high_bound_is_count
= 1;
18338 if (attr_ub
!= NULL
)
18339 complaint (_("Unresolved DW_AT_upper_bound "
18340 "- DIE at %s [in module %s]"),
18341 sect_offset_str (die
->sect_off
),
18342 objfile_name (cu
->per_objfile
->objfile
));
18343 if (attr_count
!= NULL
)
18344 complaint (_("Unresolved DW_AT_count "
18345 "- DIE at %s [in module %s]"),
18346 sect_offset_str (die
->sect_off
),
18347 objfile_name (cu
->per_objfile
->objfile
));
18352 struct attribute
*bias_attr
= dwarf2_attr (die
, DW_AT_GNU_bias
, cu
);
18353 if (bias_attr
!= nullptr && bias_attr
->form_is_constant ())
18354 bias
= bias_attr
->constant_value (0);
18356 /* Normally, the DWARF producers are expected to use a signed
18357 constant form (Eg. DW_FORM_sdata) to express negative bounds.
18358 But this is unfortunately not always the case, as witnessed
18359 with GCC, for instance, where the ambiguous DW_FORM_dataN form
18360 is used instead. To work around that ambiguity, we treat
18361 the bounds as signed, and thus sign-extend their values, when
18362 the base type is signed. */
18364 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
18365 if (low
.kind () == PROP_CONST
18366 && !base_type
->is_unsigned () && (low
.const_val () & negative_mask
))
18367 low
.set_const_val (low
.const_val () | negative_mask
);
18368 if (high
.kind () == PROP_CONST
18369 && !base_type
->is_unsigned () && (high
.const_val () & negative_mask
))
18370 high
.set_const_val (high
.const_val () | negative_mask
);
18372 /* Check for bit and byte strides. */
18373 struct dynamic_prop byte_stride_prop
;
18374 attribute
*attr_byte_stride
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
18375 if (attr_byte_stride
!= nullptr)
18377 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18378 attr_to_dynamic_prop (attr_byte_stride
, die
, cu
, &byte_stride_prop
,
18382 struct dynamic_prop bit_stride_prop
;
18383 attribute
*attr_bit_stride
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
18384 if (attr_bit_stride
!= nullptr)
18386 /* It only makes sense to have either a bit or byte stride. */
18387 if (attr_byte_stride
!= nullptr)
18389 complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
18390 "- DIE at %s [in module %s]"),
18391 sect_offset_str (die
->sect_off
),
18392 objfile_name (cu
->per_objfile
->objfile
));
18393 attr_bit_stride
= nullptr;
18397 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18398 attr_to_dynamic_prop (attr_bit_stride
, die
, cu
, &bit_stride_prop
,
18403 if (attr_byte_stride
!= nullptr
18404 || attr_bit_stride
!= nullptr)
18406 bool byte_stride_p
= (attr_byte_stride
!= nullptr);
18407 struct dynamic_prop
*stride
18408 = byte_stride_p
? &byte_stride_prop
: &bit_stride_prop
;
18411 = create_range_type_with_stride (NULL
, orig_base_type
, &low
,
18412 &high
, bias
, stride
, byte_stride_p
);
18415 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
, bias
);
18417 if (high_bound_is_count
)
18418 range_type
->bounds ()->flag_upper_bound_is_count
= 1;
18420 /* Ada expects an empty array on no boundary attributes. */
18421 if (attr
== NULL
&& cu
->language
!= language_ada
)
18422 range_type
->bounds ()->high
.set_undefined ();
18424 name
= dwarf2_name (die
, cu
);
18426 range_type
->set_name (name
);
18428 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18429 if (attr
!= nullptr)
18430 TYPE_LENGTH (range_type
) = attr
->constant_value (0);
18432 maybe_set_alignment (cu
, die
, range_type
);
18434 set_die_type (die
, range_type
, cu
);
18436 /* set_die_type should be already done. */
18437 set_descriptive_type (range_type
, die
, cu
);
18442 static struct type
*
18443 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18447 type
= init_type (cu
->per_objfile
->objfile
, TYPE_CODE_VOID
, 0, NULL
);
18448 type
->set_name (dwarf2_name (die
, cu
));
18450 /* In Ada, an unspecified type is typically used when the description
18451 of the type is deferred to a different unit. When encountering
18452 such a type, we treat it as a stub, and try to resolve it later on,
18454 if (cu
->language
== language_ada
)
18455 type
->set_is_stub (true);
18457 return set_die_type (die
, type
, cu
);
18460 /* Read a single die and all its descendents. Set the die's sibling
18461 field to NULL; set other fields in the die correctly, and set all
18462 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
18463 location of the info_ptr after reading all of those dies. PARENT
18464 is the parent of the die in question. */
18466 static struct die_info
*
18467 read_die_and_children (const struct die_reader_specs
*reader
,
18468 const gdb_byte
*info_ptr
,
18469 const gdb_byte
**new_info_ptr
,
18470 struct die_info
*parent
)
18472 struct die_info
*die
;
18473 const gdb_byte
*cur_ptr
;
18475 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, 0);
18478 *new_info_ptr
= cur_ptr
;
18481 store_in_ref_table (die
, reader
->cu
);
18483 if (die
->has_children
)
18484 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
18488 *new_info_ptr
= cur_ptr
;
18491 die
->sibling
= NULL
;
18492 die
->parent
= parent
;
18496 /* Read a die, all of its descendents, and all of its siblings; set
18497 all of the fields of all of the dies correctly. Arguments are as
18498 in read_die_and_children. */
18500 static struct die_info
*
18501 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
18502 const gdb_byte
*info_ptr
,
18503 const gdb_byte
**new_info_ptr
,
18504 struct die_info
*parent
)
18506 struct die_info
*first_die
, *last_sibling
;
18507 const gdb_byte
*cur_ptr
;
18509 cur_ptr
= info_ptr
;
18510 first_die
= last_sibling
= NULL
;
18514 struct die_info
*die
18515 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
18519 *new_info_ptr
= cur_ptr
;
18526 last_sibling
->sibling
= die
;
18528 last_sibling
= die
;
18532 /* Read a die, all of its descendents, and all of its siblings; set
18533 all of the fields of all of the dies correctly. Arguments are as
18534 in read_die_and_children.
18535 This the main entry point for reading a DIE and all its children. */
18537 static struct die_info
*
18538 read_die_and_siblings (const struct die_reader_specs
*reader
,
18539 const gdb_byte
*info_ptr
,
18540 const gdb_byte
**new_info_ptr
,
18541 struct die_info
*parent
)
18543 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
18544 new_info_ptr
, parent
);
18546 if (dwarf_die_debug
)
18548 fprintf_unfiltered (gdb_stdlog
,
18549 "Read die from %s@0x%x of %s:\n",
18550 reader
->die_section
->get_name (),
18551 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18552 bfd_get_filename (reader
->abfd
));
18553 dump_die (die
, dwarf_die_debug
);
18559 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18561 The caller is responsible for filling in the extra attributes
18562 and updating (*DIEP)->num_attrs.
18563 Set DIEP to point to a newly allocated die with its information,
18564 except for its child, sibling, and parent fields. */
18566 static const gdb_byte
*
18567 read_full_die_1 (const struct die_reader_specs
*reader
,
18568 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18569 int num_extra_attrs
)
18571 unsigned int abbrev_number
, bytes_read
, i
;
18572 struct abbrev_info
*abbrev
;
18573 struct die_info
*die
;
18574 struct dwarf2_cu
*cu
= reader
->cu
;
18575 bfd
*abfd
= reader
->abfd
;
18577 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
18578 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18579 info_ptr
+= bytes_read
;
18580 if (!abbrev_number
)
18586 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
18588 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18590 bfd_get_filename (abfd
));
18592 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
18593 die
->sect_off
= sect_off
;
18594 die
->tag
= abbrev
->tag
;
18595 die
->abbrev
= abbrev_number
;
18596 die
->has_children
= abbrev
->has_children
;
18598 /* Make the result usable.
18599 The caller needs to update num_attrs after adding the extra
18601 die
->num_attrs
= abbrev
->num_attrs
;
18603 bool any_need_reprocess
= false;
18604 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18606 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
18608 if (die
->attrs
[i
].requires_reprocessing_p ())
18609 any_need_reprocess
= true;
18612 struct attribute
*attr
= die
->attr (DW_AT_str_offsets_base
);
18613 if (attr
!= nullptr && attr
->form_is_unsigned ())
18614 cu
->str_offsets_base
= attr
->as_unsigned ();
18616 attr
= die
->attr (DW_AT_loclists_base
);
18617 if (attr
!= nullptr)
18618 cu
->loclist_base
= attr
->as_unsigned ();
18620 auto maybe_addr_base
= die
->addr_base ();
18621 if (maybe_addr_base
.has_value ())
18622 cu
->addr_base
= *maybe_addr_base
;
18624 attr
= die
->attr (DW_AT_rnglists_base
);
18625 if (attr
!= nullptr)
18626 cu
->ranges_base
= attr
->as_unsigned ();
18628 if (any_need_reprocess
)
18630 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18632 if (die
->attrs
[i
].requires_reprocessing_p ())
18633 read_attribute_reprocess (reader
, &die
->attrs
[i
], die
->tag
);
18640 /* Read a die and all its attributes.
18641 Set DIEP to point to a newly allocated die with its information,
18642 except for its child, sibling, and parent fields. */
18644 static const gdb_byte
*
18645 read_full_die (const struct die_reader_specs
*reader
,
18646 struct die_info
**diep
, const gdb_byte
*info_ptr
)
18648 const gdb_byte
*result
;
18650 result
= read_full_die_1 (reader
, diep
, info_ptr
, 0);
18652 if (dwarf_die_debug
)
18654 fprintf_unfiltered (gdb_stdlog
,
18655 "Read die from %s@0x%x of %s:\n",
18656 reader
->die_section
->get_name (),
18657 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18658 bfd_get_filename (reader
->abfd
));
18659 dump_die (*diep
, dwarf_die_debug
);
18666 /* Returns nonzero if TAG represents a type that we might generate a partial
18670 is_type_tag_for_partial (int tag
)
18675 /* Some types that would be reasonable to generate partial symbols for,
18676 that we don't at present. */
18677 case DW_TAG_array_type
:
18678 case DW_TAG_file_type
:
18679 case DW_TAG_ptr_to_member_type
:
18680 case DW_TAG_set_type
:
18681 case DW_TAG_string_type
:
18682 case DW_TAG_subroutine_type
:
18684 case DW_TAG_base_type
:
18685 case DW_TAG_class_type
:
18686 case DW_TAG_interface_type
:
18687 case DW_TAG_enumeration_type
:
18688 case DW_TAG_structure_type
:
18689 case DW_TAG_subrange_type
:
18690 case DW_TAG_typedef
:
18691 case DW_TAG_union_type
:
18698 /* Load all DIEs that are interesting for partial symbols into memory. */
18700 static struct partial_die_info
*
18701 load_partial_dies (const struct die_reader_specs
*reader
,
18702 const gdb_byte
*info_ptr
, int building_psymtab
)
18704 struct dwarf2_cu
*cu
= reader
->cu
;
18705 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18706 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
18707 unsigned int bytes_read
;
18708 unsigned int load_all
= 0;
18709 int nesting_level
= 1;
18714 gdb_assert (cu
->per_cu
!= NULL
);
18715 if (cu
->per_cu
->load_all_dies
)
18719 = htab_create_alloc_ex (cu
->header
.length
/ 12,
18723 &cu
->comp_unit_obstack
,
18724 hashtab_obstack_allocate
,
18725 dummy_obstack_deallocate
);
18729 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
18731 /* A NULL abbrev means the end of a series of children. */
18732 if (abbrev
== NULL
)
18734 if (--nesting_level
== 0)
18737 info_ptr
+= bytes_read
;
18738 last_die
= parent_die
;
18739 parent_die
= parent_die
->die_parent
;
18743 /* Check for template arguments. We never save these; if
18744 they're seen, we just mark the parent, and go on our way. */
18745 if (parent_die
!= NULL
18746 && cu
->language
== language_cplus
18747 && (abbrev
->tag
== DW_TAG_template_type_param
18748 || abbrev
->tag
== DW_TAG_template_value_param
))
18750 parent_die
->has_template_arguments
= 1;
18754 /* We don't need a partial DIE for the template argument. */
18755 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18760 /* We only recurse into c++ subprograms looking for template arguments.
18761 Skip their other children. */
18763 && cu
->language
== language_cplus
18764 && parent_die
!= NULL
18765 && parent_die
->tag
== DW_TAG_subprogram
18766 && abbrev
->tag
!= DW_TAG_inlined_subroutine
)
18768 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18772 /* Check whether this DIE is interesting enough to save. Normally
18773 we would not be interested in members here, but there may be
18774 later variables referencing them via DW_AT_specification (for
18775 static members). */
18777 && !is_type_tag_for_partial (abbrev
->tag
)
18778 && abbrev
->tag
!= DW_TAG_constant
18779 && abbrev
->tag
!= DW_TAG_enumerator
18780 && abbrev
->tag
!= DW_TAG_subprogram
18781 && abbrev
->tag
!= DW_TAG_inlined_subroutine
18782 && abbrev
->tag
!= DW_TAG_lexical_block
18783 && abbrev
->tag
!= DW_TAG_variable
18784 && abbrev
->tag
!= DW_TAG_namespace
18785 && abbrev
->tag
!= DW_TAG_module
18786 && abbrev
->tag
!= DW_TAG_member
18787 && abbrev
->tag
!= DW_TAG_imported_unit
18788 && abbrev
->tag
!= DW_TAG_imported_declaration
)
18790 /* Otherwise we skip to the next sibling, if any. */
18791 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18795 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
18798 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
18800 /* This two-pass algorithm for processing partial symbols has a
18801 high cost in cache pressure. Thus, handle some simple cases
18802 here which cover the majority of C partial symbols. DIEs
18803 which neither have specification tags in them, nor could have
18804 specification tags elsewhere pointing at them, can simply be
18805 processed and discarded.
18807 This segment is also optional; scan_partial_symbols and
18808 add_partial_symbol will handle these DIEs if we chain
18809 them in normally. When compilers which do not emit large
18810 quantities of duplicate debug information are more common,
18811 this code can probably be removed. */
18813 /* Any complete simple types at the top level (pretty much all
18814 of them, for a language without namespaces), can be processed
18816 if (parent_die
== NULL
18817 && pdi
.has_specification
== 0
18818 && pdi
.is_declaration
== 0
18819 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
18820 || pdi
.tag
== DW_TAG_base_type
18821 || pdi
.tag
== DW_TAG_subrange_type
))
18823 if (building_psymtab
&& pdi
.raw_name
!= NULL
)
18824 add_partial_symbol (&pdi
, cu
);
18826 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18830 /* The exception for DW_TAG_typedef with has_children above is
18831 a workaround of GCC PR debug/47510. In the case of this complaint
18832 type_name_or_error will error on such types later.
18834 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18835 it could not find the child DIEs referenced later, this is checked
18836 above. In correct DWARF DW_TAG_typedef should have no children. */
18838 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
18839 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18840 "- DIE at %s [in module %s]"),
18841 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
18843 /* If we're at the second level, and we're an enumerator, and
18844 our parent has no specification (meaning possibly lives in a
18845 namespace elsewhere), then we can add the partial symbol now
18846 instead of queueing it. */
18847 if (pdi
.tag
== DW_TAG_enumerator
18848 && parent_die
!= NULL
18849 && parent_die
->die_parent
== NULL
18850 && parent_die
->tag
== DW_TAG_enumeration_type
18851 && parent_die
->has_specification
== 0)
18853 if (pdi
.raw_name
== NULL
)
18854 complaint (_("malformed enumerator DIE ignored"));
18855 else if (building_psymtab
)
18856 add_partial_symbol (&pdi
, cu
);
18858 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18862 struct partial_die_info
*part_die
18863 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
18865 /* We'll save this DIE so link it in. */
18866 part_die
->die_parent
= parent_die
;
18867 part_die
->die_sibling
= NULL
;
18868 part_die
->die_child
= NULL
;
18870 if (last_die
&& last_die
== parent_die
)
18871 last_die
->die_child
= part_die
;
18873 last_die
->die_sibling
= part_die
;
18875 last_die
= part_die
;
18877 if (first_die
== NULL
)
18878 first_die
= part_die
;
18880 /* Maybe add the DIE to the hash table. Not all DIEs that we
18881 find interesting need to be in the hash table, because we
18882 also have the parent/sibling/child chains; only those that we
18883 might refer to by offset later during partial symbol reading.
18885 For now this means things that might have be the target of a
18886 DW_AT_specification, DW_AT_abstract_origin, or
18887 DW_AT_extension. DW_AT_extension will refer only to
18888 namespaces; DW_AT_abstract_origin refers to functions (and
18889 many things under the function DIE, but we do not recurse
18890 into function DIEs during partial symbol reading) and
18891 possibly variables as well; DW_AT_specification refers to
18892 declarations. Declarations ought to have the DW_AT_declaration
18893 flag. It happens that GCC forgets to put it in sometimes, but
18894 only for functions, not for types.
18896 Adding more things than necessary to the hash table is harmless
18897 except for the performance cost. Adding too few will result in
18898 wasted time in find_partial_die, when we reread the compilation
18899 unit with load_all_dies set. */
18902 || abbrev
->tag
== DW_TAG_constant
18903 || abbrev
->tag
== DW_TAG_subprogram
18904 || abbrev
->tag
== DW_TAG_variable
18905 || abbrev
->tag
== DW_TAG_namespace
18906 || part_die
->is_declaration
)
18910 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
18911 to_underlying (part_die
->sect_off
),
18916 /* For some DIEs we want to follow their children (if any). For C
18917 we have no reason to follow the children of structures; for other
18918 languages we have to, so that we can get at method physnames
18919 to infer fully qualified class names, for DW_AT_specification,
18920 and for C++ template arguments. For C++, we also look one level
18921 inside functions to find template arguments (if the name of the
18922 function does not already contain the template arguments).
18924 For Ada and Fortran, we need to scan the children of subprograms
18925 and lexical blocks as well because these languages allow the
18926 definition of nested entities that could be interesting for the
18927 debugger, such as nested subprograms for instance. */
18928 if (last_die
->has_children
18930 || last_die
->tag
== DW_TAG_namespace
18931 || last_die
->tag
== DW_TAG_module
18932 || last_die
->tag
== DW_TAG_enumeration_type
18933 || (cu
->language
== language_cplus
18934 && last_die
->tag
== DW_TAG_subprogram
18935 && (last_die
->raw_name
== NULL
18936 || strchr (last_die
->raw_name
, '<') == NULL
))
18937 || (cu
->language
!= language_c
18938 && (last_die
->tag
== DW_TAG_class_type
18939 || last_die
->tag
== DW_TAG_interface_type
18940 || last_die
->tag
== DW_TAG_structure_type
18941 || last_die
->tag
== DW_TAG_union_type
))
18942 || ((cu
->language
== language_ada
18943 || cu
->language
== language_fortran
)
18944 && (last_die
->tag
== DW_TAG_subprogram
18945 || last_die
->tag
== DW_TAG_lexical_block
))))
18948 parent_die
= last_die
;
18952 /* Otherwise we skip to the next sibling, if any. */
18953 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
18955 /* Back to the top, do it again. */
18959 partial_die_info::partial_die_info (sect_offset sect_off_
,
18960 struct abbrev_info
*abbrev
)
18961 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
18965 /* See class definition. */
18968 partial_die_info::name (dwarf2_cu
*cu
)
18970 if (!canonical_name
&& raw_name
!= nullptr)
18972 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18973 raw_name
= dwarf2_canonicalize_name (raw_name
, cu
, objfile
);
18974 canonical_name
= 1;
18980 /* Read a minimal amount of information into the minimal die structure.
18981 INFO_PTR should point just after the initial uleb128 of a DIE. */
18984 partial_die_info::read (const struct die_reader_specs
*reader
,
18985 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
18987 struct dwarf2_cu
*cu
= reader
->cu
;
18988 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
18990 int has_low_pc_attr
= 0;
18991 int has_high_pc_attr
= 0;
18992 int high_pc_relative
= 0;
18994 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
18997 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
18998 /* String and address offsets that need to do the reprocessing have
18999 already been read at this point, so there is no need to wait until
19000 the loop terminates to do the reprocessing. */
19001 if (attr
.requires_reprocessing_p ())
19002 read_attribute_reprocess (reader
, &attr
, tag
);
19003 /* Store the data if it is of an attribute we want to keep in a
19004 partial symbol table. */
19010 case DW_TAG_compile_unit
:
19011 case DW_TAG_partial_unit
:
19012 case DW_TAG_type_unit
:
19013 /* Compilation units have a DW_AT_name that is a filename, not
19014 a source language identifier. */
19015 case DW_TAG_enumeration_type
:
19016 case DW_TAG_enumerator
:
19017 /* These tags always have simple identifiers already; no need
19018 to canonicalize them. */
19019 canonical_name
= 1;
19020 raw_name
= attr
.as_string ();
19023 canonical_name
= 0;
19024 raw_name
= attr
.as_string ();
19028 case DW_AT_linkage_name
:
19029 case DW_AT_MIPS_linkage_name
:
19030 /* Note that both forms of linkage name might appear. We
19031 assume they will be the same, and we only store the last
19033 linkage_name
= attr
.as_string ();
19036 has_low_pc_attr
= 1;
19037 lowpc
= attr
.as_address ();
19039 case DW_AT_high_pc
:
19040 has_high_pc_attr
= 1;
19041 highpc
= attr
.as_address ();
19042 if (cu
->header
.version
>= 4 && attr
.form_is_constant ())
19043 high_pc_relative
= 1;
19045 case DW_AT_location
:
19046 /* Support the .debug_loc offsets. */
19047 if (attr
.form_is_block ())
19049 d
.locdesc
= attr
.as_block ();
19051 else if (attr
.form_is_section_offset ())
19053 dwarf2_complex_location_expr_complaint ();
19057 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
19058 "partial symbol information");
19061 case DW_AT_external
:
19062 is_external
= attr
.as_boolean ();
19064 case DW_AT_declaration
:
19065 is_declaration
= attr
.as_boolean ();
19070 case DW_AT_abstract_origin
:
19071 case DW_AT_specification
:
19072 case DW_AT_extension
:
19073 has_specification
= 1;
19074 spec_offset
= attr
.get_ref_die_offset ();
19075 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19076 || cu
->per_cu
->is_dwz
);
19078 case DW_AT_sibling
:
19079 /* Ignore absolute siblings, they might point outside of
19080 the current compile unit. */
19081 if (attr
.form
== DW_FORM_ref_addr
)
19082 complaint (_("ignoring absolute DW_AT_sibling"));
19085 const gdb_byte
*buffer
= reader
->buffer
;
19086 sect_offset off
= attr
.get_ref_die_offset ();
19087 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
19089 if (sibling_ptr
< info_ptr
)
19090 complaint (_("DW_AT_sibling points backwards"));
19091 else if (sibling_ptr
> reader
->buffer_end
)
19092 reader
->die_section
->overflow_complaint ();
19094 sibling
= sibling_ptr
;
19097 case DW_AT_byte_size
:
19100 case DW_AT_const_value
:
19101 has_const_value
= 1;
19103 case DW_AT_calling_convention
:
19104 /* DWARF doesn't provide a way to identify a program's source-level
19105 entry point. DW_AT_calling_convention attributes are only meant
19106 to describe functions' calling conventions.
19108 However, because it's a necessary piece of information in
19109 Fortran, and before DWARF 4 DW_CC_program was the only
19110 piece of debugging information whose definition refers to
19111 a 'main program' at all, several compilers marked Fortran
19112 main programs with DW_CC_program --- even when those
19113 functions use the standard calling conventions.
19115 Although DWARF now specifies a way to provide this
19116 information, we support this practice for backward
19118 if (attr
.constant_value (0) == DW_CC_program
19119 && cu
->language
== language_fortran
)
19120 main_subprogram
= 1;
19124 LONGEST value
= attr
.constant_value (-1);
19125 if (value
== DW_INL_inlined
19126 || value
== DW_INL_declared_inlined
)
19127 may_be_inlined
= 1;
19132 if (tag
== DW_TAG_imported_unit
)
19134 d
.sect_off
= attr
.get_ref_die_offset ();
19135 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19136 || cu
->per_cu
->is_dwz
);
19140 case DW_AT_main_subprogram
:
19141 main_subprogram
= attr
.as_boolean ();
19146 /* DW_AT_rnglists_base does not apply to DIEs from the DWO
19147 skeleton. We take advantage of the fact the DW_AT_ranges
19148 does not appear in DW_TAG_compile_unit of DWO files.
19150 Attributes of the form DW_FORM_rnglistx have already had
19151 their value changed by read_rnglist_index and already
19152 include DW_AT_rnglists_base, so don't need to add the ranges
19154 int need_ranges_base
= (tag
!= DW_TAG_compile_unit
19155 && attr
.form
!= DW_FORM_rnglistx
);
19156 /* It would be nice to reuse dwarf2_get_pc_bounds here,
19157 but that requires a full DIE, so instead we just
19159 unsigned int ranges_offset
= (attr
.constant_value (0)
19160 + (need_ranges_base
19164 /* Value of the DW_AT_ranges attribute is the offset in the
19165 .debug_ranges section. */
19166 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
19177 /* For Ada, if both the name and the linkage name appear, we prefer
19178 the latter. This lets "catch exception" work better, regardless
19179 of the order in which the name and linkage name were emitted.
19180 Really, though, this is just a workaround for the fact that gdb
19181 doesn't store both the name and the linkage name. */
19182 if (cu
->language
== language_ada
&& linkage_name
!= nullptr)
19183 raw_name
= linkage_name
;
19185 if (high_pc_relative
)
19188 if (has_low_pc_attr
&& has_high_pc_attr
)
19190 /* When using the GNU linker, .gnu.linkonce. sections are used to
19191 eliminate duplicate copies of functions and vtables and such.
19192 The linker will arbitrarily choose one and discard the others.
19193 The AT_*_pc values for such functions refer to local labels in
19194 these sections. If the section from that file was discarded, the
19195 labels are not in the output, so the relocs get a value of 0.
19196 If this is a discarded function, mark the pc bounds as invalid,
19197 so that GDB will ignore it. */
19198 if (lowpc
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
19200 struct objfile
*objfile
= per_objfile
->objfile
;
19201 struct gdbarch
*gdbarch
= objfile
->arch ();
19203 complaint (_("DW_AT_low_pc %s is zero "
19204 "for DIE at %s [in module %s]"),
19205 paddress (gdbarch
, lowpc
),
19206 sect_offset_str (sect_off
),
19207 objfile_name (objfile
));
19209 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
19210 else if (lowpc
>= highpc
)
19212 struct objfile
*objfile
= per_objfile
->objfile
;
19213 struct gdbarch
*gdbarch
= objfile
->arch ();
19215 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
19216 "for DIE at %s [in module %s]"),
19217 paddress (gdbarch
, lowpc
),
19218 paddress (gdbarch
, highpc
),
19219 sect_offset_str (sect_off
),
19220 objfile_name (objfile
));
19229 /* Find a cached partial DIE at OFFSET in CU. */
19231 struct partial_die_info
*
19232 dwarf2_cu::find_partial_die (sect_offset sect_off
)
19234 struct partial_die_info
*lookup_die
= NULL
;
19235 struct partial_die_info
part_die (sect_off
);
19237 lookup_die
= ((struct partial_die_info
*)
19238 htab_find_with_hash (partial_dies
, &part_die
,
19239 to_underlying (sect_off
)));
19244 /* Find a partial DIE at OFFSET, which may or may not be in CU,
19245 except in the case of .debug_types DIEs which do not reference
19246 outside their CU (they do however referencing other types via
19247 DW_FORM_ref_sig8). */
19249 static const struct cu_partial_die_info
19250 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
19252 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19253 struct objfile
*objfile
= per_objfile
->objfile
;
19254 struct partial_die_info
*pd
= NULL
;
19256 if (offset_in_dwz
== cu
->per_cu
->is_dwz
19257 && cu
->header
.offset_in_cu_p (sect_off
))
19259 pd
= cu
->find_partial_die (sect_off
);
19262 /* We missed recording what we needed.
19263 Load all dies and try again. */
19267 /* TUs don't reference other CUs/TUs (except via type signatures). */
19268 if (cu
->per_cu
->is_debug_types
)
19270 error (_("Dwarf Error: Type Unit at offset %s contains"
19271 " external reference to offset %s [in module %s].\n"),
19272 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
19273 bfd_get_filename (objfile
->obfd
));
19275 dwarf2_per_cu_data
*per_cu
19276 = dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
19279 cu
= per_objfile
->get_cu (per_cu
);
19280 if (cu
== NULL
|| cu
->partial_dies
== NULL
)
19281 load_partial_comp_unit (per_cu
, per_objfile
, nullptr);
19283 cu
= per_objfile
->get_cu (per_cu
);
19286 pd
= cu
->find_partial_die (sect_off
);
19289 /* If we didn't find it, and not all dies have been loaded,
19290 load them all and try again. */
19292 if (pd
== NULL
&& cu
->per_cu
->load_all_dies
== 0)
19294 cu
->per_cu
->load_all_dies
= 1;
19296 /* This is nasty. When we reread the DIEs, somewhere up the call chain
19297 THIS_CU->cu may already be in use. So we can't just free it and
19298 replace its DIEs with the ones we read in. Instead, we leave those
19299 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
19300 and clobber THIS_CU->cu->partial_dies with the hash table for the new
19302 load_partial_comp_unit (cu
->per_cu
, per_objfile
, cu
);
19304 pd
= cu
->find_partial_die (sect_off
);
19308 error (_("Dwarf Error: Cannot not find DIE at %s [from module %s]\n"),
19309 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
19313 /* See if we can figure out if the class lives in a namespace. We do
19314 this by looking for a member function; its demangled name will
19315 contain namespace info, if there is any. */
19318 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
19319 struct dwarf2_cu
*cu
)
19321 /* NOTE: carlton/2003-10-07: Getting the info this way changes
19322 what template types look like, because the demangler
19323 frequently doesn't give the same name as the debug info. We
19324 could fix this by only using the demangled name to get the
19325 prefix (but see comment in read_structure_type). */
19327 struct partial_die_info
*real_pdi
;
19328 struct partial_die_info
*child_pdi
;
19330 /* If this DIE (this DIE's specification, if any) has a parent, then
19331 we should not do this. We'll prepend the parent's fully qualified
19332 name when we create the partial symbol. */
19334 real_pdi
= struct_pdi
;
19335 while (real_pdi
->has_specification
)
19337 auto res
= find_partial_die (real_pdi
->spec_offset
,
19338 real_pdi
->spec_is_dwz
, cu
);
19339 real_pdi
= res
.pdi
;
19343 if (real_pdi
->die_parent
!= NULL
)
19346 for (child_pdi
= struct_pdi
->die_child
;
19348 child_pdi
= child_pdi
->die_sibling
)
19350 if (child_pdi
->tag
== DW_TAG_subprogram
19351 && child_pdi
->linkage_name
!= NULL
)
19353 gdb::unique_xmalloc_ptr
<char> actual_class_name
19354 (cu
->language_defn
->class_name_from_physname
19355 (child_pdi
->linkage_name
));
19356 if (actual_class_name
!= NULL
)
19358 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19359 struct_pdi
->raw_name
= objfile
->intern (actual_class_name
.get ());
19360 struct_pdi
->canonical_name
= 1;
19367 /* Return true if a DIE with TAG may have the DW_AT_const_value
19371 can_have_DW_AT_const_value_p (enum dwarf_tag tag
)
19375 case DW_TAG_constant
:
19376 case DW_TAG_enumerator
:
19377 case DW_TAG_formal_parameter
:
19378 case DW_TAG_template_value_param
:
19379 case DW_TAG_variable
:
19387 partial_die_info::fixup (struct dwarf2_cu
*cu
)
19389 /* Once we've fixed up a die, there's no point in doing so again.
19390 This also avoids a memory leak if we were to call
19391 guess_partial_die_structure_name multiple times. */
19395 /* If we found a reference attribute and the DIE has no name, try
19396 to find a name in the referred to DIE. */
19398 if (raw_name
== NULL
&& has_specification
)
19400 struct partial_die_info
*spec_die
;
19402 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19403 spec_die
= res
.pdi
;
19406 spec_die
->fixup (cu
);
19408 if (spec_die
->raw_name
)
19410 raw_name
= spec_die
->raw_name
;
19411 canonical_name
= spec_die
->canonical_name
;
19413 /* Copy DW_AT_external attribute if it is set. */
19414 if (spec_die
->is_external
)
19415 is_external
= spec_die
->is_external
;
19419 if (!has_const_value
&& has_specification
19420 && can_have_DW_AT_const_value_p (tag
))
19422 struct partial_die_info
*spec_die
;
19424 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19425 spec_die
= res
.pdi
;
19428 spec_die
->fixup (cu
);
19430 if (spec_die
->has_const_value
)
19432 /* Copy DW_AT_const_value attribute if it is set. */
19433 has_const_value
= spec_die
->has_const_value
;
19437 /* Set default names for some unnamed DIEs. */
19439 if (raw_name
== NULL
&& tag
== DW_TAG_namespace
)
19441 raw_name
= CP_ANONYMOUS_NAMESPACE_STR
;
19442 canonical_name
= 1;
19445 /* If there is no parent die to provide a namespace, and there are
19446 children, see if we can determine the namespace from their linkage
19448 if (cu
->language
== language_cplus
19449 && !cu
->per_objfile
->per_bfd
->types
.empty ()
19450 && die_parent
== NULL
19452 && (tag
== DW_TAG_class_type
19453 || tag
== DW_TAG_structure_type
19454 || tag
== DW_TAG_union_type
))
19455 guess_partial_die_structure_name (this, cu
);
19457 /* GCC might emit a nameless struct or union that has a linkage
19458 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19459 if (raw_name
== NULL
19460 && (tag
== DW_TAG_class_type
19461 || tag
== DW_TAG_interface_type
19462 || tag
== DW_TAG_structure_type
19463 || tag
== DW_TAG_union_type
)
19464 && linkage_name
!= NULL
)
19466 gdb::unique_xmalloc_ptr
<char> demangled
19467 (gdb_demangle (linkage_name
, DMGL_TYPES
));
19468 if (demangled
!= nullptr)
19472 /* Strip any leading namespaces/classes, keep only the base name.
19473 DW_AT_name for named DIEs does not contain the prefixes. */
19474 base
= strrchr (demangled
.get (), ':');
19475 if (base
&& base
> demangled
.get () && base
[-1] == ':')
19478 base
= demangled
.get ();
19480 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19481 raw_name
= objfile
->intern (base
);
19482 canonical_name
= 1;
19489 /* Read the .debug_loclists or .debug_rnglists header (they are the same format)
19490 contents from the given SECTION in the HEADER. */
19492 read_loclists_rnglists_header (struct loclists_rnglists_header
*header
,
19493 struct dwarf2_section_info
*section
)
19495 unsigned int bytes_read
;
19496 bfd
*abfd
= section
->get_bfd_owner ();
19497 const gdb_byte
*info_ptr
= section
->buffer
;
19498 header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
19499 info_ptr
+= bytes_read
;
19500 header
->version
= read_2_bytes (abfd
, info_ptr
);
19502 header
->addr_size
= read_1_byte (abfd
, info_ptr
);
19504 header
->segment_collector_size
= read_1_byte (abfd
, info_ptr
);
19506 header
->offset_entry_count
= read_4_bytes (abfd
, info_ptr
);
19509 /* Return the DW_AT_loclists_base value for the CU. */
19511 lookup_loclist_base (struct dwarf2_cu
*cu
)
19513 /* For the .dwo unit, the loclist_base points to the first offset following
19514 the header. The header consists of the following entities-
19515 1. Unit Length (4 bytes for 32 bit DWARF format, and 12 bytes for the 64
19517 2. version (2 bytes)
19518 3. address size (1 byte)
19519 4. segment selector size (1 byte)
19520 5. offset entry count (4 bytes)
19521 These sizes are derived as per the DWARFv5 standard. */
19522 if (cu
->dwo_unit
!= nullptr)
19524 if (cu
->header
.initial_length_size
== 4)
19525 return LOCLIST_HEADER_SIZE32
;
19526 return LOCLIST_HEADER_SIZE64
;
19528 return cu
->loclist_base
;
19531 /* Given a DW_FORM_loclistx value LOCLIST_INDEX, fetch the offset from the
19532 array of offsets in the .debug_loclists section. */
19534 read_loclist_index (struct dwarf2_cu
*cu
, ULONGEST loclist_index
)
19536 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19537 struct objfile
*objfile
= per_objfile
->objfile
;
19538 bfd
*abfd
= objfile
->obfd
;
19539 ULONGEST loclist_base
= lookup_loclist_base (cu
);
19540 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
19542 section
->read (objfile
);
19543 if (section
->buffer
== NULL
)
19544 complaint (_("DW_FORM_loclistx used without .debug_loclists "
19545 "section [in module %s]"), objfile_name (objfile
));
19546 struct loclists_rnglists_header header
;
19547 read_loclists_rnglists_header (&header
, section
);
19548 if (loclist_index
>= header
.offset_entry_count
)
19549 complaint (_("DW_FORM_loclistx pointing outside of "
19550 ".debug_loclists offset array [in module %s]"),
19551 objfile_name (objfile
));
19552 if (loclist_base
+ loclist_index
* cu
->header
.offset_size
19554 complaint (_("DW_FORM_loclistx pointing outside of "
19555 ".debug_loclists section [in module %s]"),
19556 objfile_name (objfile
));
19557 const gdb_byte
*info_ptr
19558 = section
->buffer
+ loclist_base
+ loclist_index
* cu
->header
.offset_size
;
19560 if (cu
->header
.offset_size
== 4)
19561 return bfd_get_32 (abfd
, info_ptr
) + loclist_base
;
19563 return bfd_get_64 (abfd
, info_ptr
) + loclist_base
;
19566 /* Given a DW_FORM_rnglistx value RNGLIST_INDEX, fetch the offset from the
19567 array of offsets in the .debug_rnglists section. */
19569 read_rnglist_index (struct dwarf2_cu
*cu
, ULONGEST rnglist_index
,
19572 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
19573 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19574 bfd
*abfd
= objfile
->obfd
;
19575 ULONGEST rnglist_header_size
=
19576 (cu
->header
.initial_length_size
== 4 ? RNGLIST_HEADER_SIZE32
19577 : RNGLIST_HEADER_SIZE64
);
19578 ULONGEST rnglist_base
=
19579 (cu
->dwo_unit
!= nullptr) ? rnglist_header_size
: cu
->ranges_base
;
19580 ULONGEST start_offset
=
19581 rnglist_base
+ rnglist_index
* cu
->header
.offset_size
;
19583 /* Get rnglists section. */
19584 struct dwarf2_section_info
*section
= cu_debug_rnglists_section (cu
, tag
);
19586 /* Read the rnglists section content. */
19587 section
->read (objfile
);
19588 if (section
->buffer
== nullptr)
19589 error (_("DW_FORM_rnglistx used without .debug_rnglists section "
19591 objfile_name (objfile
));
19593 /* Verify the rnglist index is valid. */
19594 struct loclists_rnglists_header header
;
19595 read_loclists_rnglists_header (&header
, section
);
19596 if (rnglist_index
>= header
.offset_entry_count
)
19597 error (_("DW_FORM_rnglistx index pointing outside of "
19598 ".debug_rnglists offset array [in module %s]"),
19599 objfile_name (objfile
));
19601 /* Validate that the offset is within the section's range. */
19602 if (start_offset
>= section
->size
)
19603 error (_("DW_FORM_rnglistx pointing outside of "
19604 ".debug_rnglists section [in module %s]"),
19605 objfile_name (objfile
));
19607 /* Validate that reading won't go beyond the end of the section. */
19608 if (start_offset
+ cu
->header
.offset_size
> rnglist_base
+ section
->size
)
19609 error (_("Reading DW_FORM_rnglistx index beyond end of"
19610 ".debug_rnglists section [in module %s]"),
19611 objfile_name (objfile
));
19613 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
19615 if (cu
->header
.offset_size
== 4)
19616 return read_4_bytes (abfd
, info_ptr
) + rnglist_base
;
19618 return read_8_bytes (abfd
, info_ptr
) + rnglist_base
;
19621 /* Process the attributes that had to be skipped in the first round. These
19622 attributes are the ones that need str_offsets_base or addr_base attributes.
19623 They could not have been processed in the first round, because at the time
19624 the values of str_offsets_base or addr_base may not have been known. */
19626 read_attribute_reprocess (const struct die_reader_specs
*reader
,
19627 struct attribute
*attr
, dwarf_tag tag
)
19629 struct dwarf2_cu
*cu
= reader
->cu
;
19630 switch (attr
->form
)
19632 case DW_FORM_addrx
:
19633 case DW_FORM_GNU_addr_index
:
19634 attr
->set_address (read_addr_index (cu
,
19635 attr
->as_unsigned_reprocess ()));
19637 case DW_FORM_loclistx
:
19638 attr
->set_address (read_loclist_index (cu
, attr
->as_unsigned ()));
19640 case DW_FORM_rnglistx
:
19641 attr
->set_address (read_rnglist_index (cu
, attr
->as_unsigned (), tag
));
19644 case DW_FORM_strx1
:
19645 case DW_FORM_strx2
:
19646 case DW_FORM_strx3
:
19647 case DW_FORM_strx4
:
19648 case DW_FORM_GNU_str_index
:
19650 unsigned int str_index
= attr
->as_unsigned_reprocess ();
19651 gdb_assert (!attr
->canonical_string_p ());
19652 if (reader
->dwo_file
!= NULL
)
19653 attr
->set_string_noncanonical (read_dwo_str_index (reader
,
19656 attr
->set_string_noncanonical (read_stub_str_index (cu
,
19661 gdb_assert_not_reached (_("Unexpected DWARF form."));
19665 /* Read an attribute value described by an attribute form. */
19667 static const gdb_byte
*
19668 read_attribute_value (const struct die_reader_specs
*reader
,
19669 struct attribute
*attr
, unsigned form
,
19670 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
19672 struct dwarf2_cu
*cu
= reader
->cu
;
19673 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19674 struct objfile
*objfile
= per_objfile
->objfile
;
19675 bfd
*abfd
= reader
->abfd
;
19676 struct comp_unit_head
*cu_header
= &cu
->header
;
19677 unsigned int bytes_read
;
19678 struct dwarf_block
*blk
;
19680 attr
->form
= (enum dwarf_form
) form
;
19683 case DW_FORM_ref_addr
:
19684 if (cu
->header
.version
== 2)
19685 attr
->set_unsigned (cu
->header
.read_address (abfd
, info_ptr
,
19688 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
19690 info_ptr
+= bytes_read
;
19692 case DW_FORM_GNU_ref_alt
:
19693 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
19695 info_ptr
+= bytes_read
;
19699 struct gdbarch
*gdbarch
= objfile
->arch ();
19700 CORE_ADDR addr
= cu
->header
.read_address (abfd
, info_ptr
, &bytes_read
);
19701 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
19702 attr
->set_address (addr
);
19703 info_ptr
+= bytes_read
;
19706 case DW_FORM_block2
:
19707 blk
= dwarf_alloc_block (cu
);
19708 blk
->size
= read_2_bytes (abfd
, info_ptr
);
19710 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19711 info_ptr
+= blk
->size
;
19712 attr
->set_block (blk
);
19714 case DW_FORM_block4
:
19715 blk
= dwarf_alloc_block (cu
);
19716 blk
->size
= read_4_bytes (abfd
, info_ptr
);
19718 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19719 info_ptr
+= blk
->size
;
19720 attr
->set_block (blk
);
19722 case DW_FORM_data2
:
19723 attr
->set_unsigned (read_2_bytes (abfd
, info_ptr
));
19726 case DW_FORM_data4
:
19727 attr
->set_unsigned (read_4_bytes (abfd
, info_ptr
));
19730 case DW_FORM_data8
:
19731 attr
->set_unsigned (read_8_bytes (abfd
, info_ptr
));
19734 case DW_FORM_data16
:
19735 blk
= dwarf_alloc_block (cu
);
19737 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
19739 attr
->set_block (blk
);
19741 case DW_FORM_sec_offset
:
19742 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
19744 info_ptr
+= bytes_read
;
19746 case DW_FORM_loclistx
:
19748 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
19750 info_ptr
+= bytes_read
;
19753 case DW_FORM_string
:
19754 attr
->set_string_noncanonical (read_direct_string (abfd
, info_ptr
,
19756 info_ptr
+= bytes_read
;
19759 if (!cu
->per_cu
->is_dwz
)
19761 attr
->set_string_noncanonical
19762 (read_indirect_string (per_objfile
,
19763 abfd
, info_ptr
, cu_header
,
19765 info_ptr
+= bytes_read
;
19769 case DW_FORM_line_strp
:
19770 if (!cu
->per_cu
->is_dwz
)
19772 attr
->set_string_noncanonical
19773 (per_objfile
->read_line_string (info_ptr
, cu_header
,
19775 info_ptr
+= bytes_read
;
19779 case DW_FORM_GNU_strp_alt
:
19781 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
19782 LONGEST str_offset
= cu_header
->read_offset (abfd
, info_ptr
,
19785 attr
->set_string_noncanonical
19786 (dwz
->read_string (objfile
, str_offset
));
19787 info_ptr
+= bytes_read
;
19790 case DW_FORM_exprloc
:
19791 case DW_FORM_block
:
19792 blk
= dwarf_alloc_block (cu
);
19793 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19794 info_ptr
+= bytes_read
;
19795 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19796 info_ptr
+= blk
->size
;
19797 attr
->set_block (blk
);
19799 case DW_FORM_block1
:
19800 blk
= dwarf_alloc_block (cu
);
19801 blk
->size
= read_1_byte (abfd
, info_ptr
);
19803 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19804 info_ptr
+= blk
->size
;
19805 attr
->set_block (blk
);
19807 case DW_FORM_data1
:
19809 attr
->set_unsigned (read_1_byte (abfd
, info_ptr
));
19812 case DW_FORM_flag_present
:
19813 attr
->set_unsigned (1);
19815 case DW_FORM_sdata
:
19816 attr
->set_signed (read_signed_leb128 (abfd
, info_ptr
, &bytes_read
));
19817 info_ptr
+= bytes_read
;
19819 case DW_FORM_rnglistx
:
19821 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
19823 info_ptr
+= bytes_read
;
19826 case DW_FORM_udata
:
19827 attr
->set_unsigned (read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
19828 info_ptr
+= bytes_read
;
19831 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
19832 + read_1_byte (abfd
, info_ptr
)));
19836 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
19837 + read_2_bytes (abfd
, info_ptr
)));
19841 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
19842 + read_4_bytes (abfd
, info_ptr
)));
19846 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
19847 + read_8_bytes (abfd
, info_ptr
)));
19850 case DW_FORM_ref_sig8
:
19851 attr
->set_signature (read_8_bytes (abfd
, info_ptr
));
19854 case DW_FORM_ref_udata
:
19855 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
19856 + read_unsigned_leb128 (abfd
, info_ptr
,
19858 info_ptr
+= bytes_read
;
19860 case DW_FORM_indirect
:
19861 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19862 info_ptr
+= bytes_read
;
19863 if (form
== DW_FORM_implicit_const
)
19865 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19866 info_ptr
+= bytes_read
;
19868 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
19871 case DW_FORM_implicit_const
:
19872 attr
->set_signed (implicit_const
);
19874 case DW_FORM_addrx
:
19875 case DW_FORM_GNU_addr_index
:
19876 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
19878 info_ptr
+= bytes_read
;
19881 case DW_FORM_strx1
:
19882 case DW_FORM_strx2
:
19883 case DW_FORM_strx3
:
19884 case DW_FORM_strx4
:
19885 case DW_FORM_GNU_str_index
:
19887 ULONGEST str_index
;
19888 if (form
== DW_FORM_strx1
)
19890 str_index
= read_1_byte (abfd
, info_ptr
);
19893 else if (form
== DW_FORM_strx2
)
19895 str_index
= read_2_bytes (abfd
, info_ptr
);
19898 else if (form
== DW_FORM_strx3
)
19900 str_index
= read_3_bytes (abfd
, info_ptr
);
19903 else if (form
== DW_FORM_strx4
)
19905 str_index
= read_4_bytes (abfd
, info_ptr
);
19910 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19911 info_ptr
+= bytes_read
;
19913 attr
->set_unsigned_reprocess (str_index
);
19917 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19918 dwarf_form_name (form
),
19919 bfd_get_filename (abfd
));
19923 if (cu
->per_cu
->is_dwz
&& attr
->form_is_ref ())
19924 attr
->form
= DW_FORM_GNU_ref_alt
;
19926 /* We have seen instances where the compiler tried to emit a byte
19927 size attribute of -1 which ended up being encoded as an unsigned
19928 0xffffffff. Although 0xffffffff is technically a valid size value,
19929 an object of this size seems pretty unlikely so we can relatively
19930 safely treat these cases as if the size attribute was invalid and
19931 treat them as zero by default. */
19932 if (attr
->name
== DW_AT_byte_size
19933 && form
== DW_FORM_data4
19934 && attr
->as_unsigned () >= 0xffffffff)
19937 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19938 hex_string (attr
->as_unsigned ()));
19939 attr
->set_unsigned (0);
19945 /* Read an attribute described by an abbreviated attribute. */
19947 static const gdb_byte
*
19948 read_attribute (const struct die_reader_specs
*reader
,
19949 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
19950 const gdb_byte
*info_ptr
)
19952 attr
->name
= abbrev
->name
;
19953 attr
->string_is_canonical
= 0;
19954 attr
->requires_reprocessing
= 0;
19955 return read_attribute_value (reader
, attr
, abbrev
->form
,
19956 abbrev
->implicit_const
, info_ptr
);
19959 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19961 static const char *
19962 read_indirect_string_at_offset (dwarf2_per_objfile
*per_objfile
,
19963 LONGEST str_offset
)
19965 return per_objfile
->per_bfd
->str
.read_string (per_objfile
->objfile
,
19966 str_offset
, "DW_FORM_strp");
19969 /* Return pointer to string at .debug_str offset as read from BUF.
19970 BUF is assumed to be in a compilation unit described by CU_HEADER.
19971 Return *BYTES_READ_PTR count of bytes read from BUF. */
19973 static const char *
19974 read_indirect_string (dwarf2_per_objfile
*per_objfile
, bfd
*abfd
,
19975 const gdb_byte
*buf
,
19976 const struct comp_unit_head
*cu_header
,
19977 unsigned int *bytes_read_ptr
)
19979 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
19981 return read_indirect_string_at_offset (per_objfile
, str_offset
);
19987 dwarf2_per_objfile::read_line_string (const gdb_byte
*buf
,
19988 const struct comp_unit_head
*cu_header
,
19989 unsigned int *bytes_read_ptr
)
19991 bfd
*abfd
= objfile
->obfd
;
19992 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
19994 return per_bfd
->line_str
.read_string (objfile
, str_offset
, "DW_FORM_line_strp");
19997 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19998 ADDR_BASE is the DW_AT_addr_base (DW_AT_GNU_addr_base) attribute or zero.
19999 ADDR_SIZE is the size of addresses from the CU header. */
20002 read_addr_index_1 (dwarf2_per_objfile
*per_objfile
, unsigned int addr_index
,
20003 gdb::optional
<ULONGEST
> addr_base
, int addr_size
)
20005 struct objfile
*objfile
= per_objfile
->objfile
;
20006 bfd
*abfd
= objfile
->obfd
;
20007 const gdb_byte
*info_ptr
;
20008 ULONGEST addr_base_or_zero
= addr_base
.has_value () ? *addr_base
: 0;
20010 per_objfile
->per_bfd
->addr
.read (objfile
);
20011 if (per_objfile
->per_bfd
->addr
.buffer
== NULL
)
20012 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
20013 objfile_name (objfile
));
20014 if (addr_base_or_zero
+ addr_index
* addr_size
20015 >= per_objfile
->per_bfd
->addr
.size
)
20016 error (_("DW_FORM_addr_index pointing outside of "
20017 ".debug_addr section [in module %s]"),
20018 objfile_name (objfile
));
20019 info_ptr
= (per_objfile
->per_bfd
->addr
.buffer
+ addr_base_or_zero
20020 + addr_index
* addr_size
);
20021 if (addr_size
== 4)
20022 return bfd_get_32 (abfd
, info_ptr
);
20024 return bfd_get_64 (abfd
, info_ptr
);
20027 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
20030 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
20032 return read_addr_index_1 (cu
->per_objfile
, addr_index
,
20033 cu
->addr_base
, cu
->header
.addr_size
);
20036 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
20039 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
20040 unsigned int *bytes_read
)
20042 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
20043 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
20045 return read_addr_index (cu
, addr_index
);
20051 dwarf2_read_addr_index (dwarf2_per_cu_data
*per_cu
,
20052 dwarf2_per_objfile
*per_objfile
,
20053 unsigned int addr_index
)
20055 struct dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
20056 gdb::optional
<ULONGEST
> addr_base
;
20059 /* We need addr_base and addr_size.
20060 If we don't have PER_CU->cu, we have to get it.
20061 Nasty, but the alternative is storing the needed info in PER_CU,
20062 which at this point doesn't seem justified: it's not clear how frequently
20063 it would get used and it would increase the size of every PER_CU.
20064 Entry points like dwarf2_per_cu_addr_size do a similar thing
20065 so we're not in uncharted territory here.
20066 Alas we need to be a bit more complicated as addr_base is contained
20069 We don't need to read the entire CU(/TU).
20070 We just need the header and top level die.
20072 IWBN to use the aging mechanism to let us lazily later discard the CU.
20073 For now we skip this optimization. */
20077 addr_base
= cu
->addr_base
;
20078 addr_size
= cu
->header
.addr_size
;
20082 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
20083 addr_base
= reader
.cu
->addr_base
;
20084 addr_size
= reader
.cu
->header
.addr_size
;
20087 return read_addr_index_1 (per_objfile
, addr_index
, addr_base
, addr_size
);
20090 /* Given a DW_FORM_GNU_str_index value STR_INDEX, fetch the string.
20091 STR_SECTION, STR_OFFSETS_SECTION can be from a Fission stub or a
20094 static const char *
20095 read_str_index (struct dwarf2_cu
*cu
,
20096 struct dwarf2_section_info
*str_section
,
20097 struct dwarf2_section_info
*str_offsets_section
,
20098 ULONGEST str_offsets_base
, ULONGEST str_index
)
20100 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20101 struct objfile
*objfile
= per_objfile
->objfile
;
20102 const char *objf_name
= objfile_name (objfile
);
20103 bfd
*abfd
= objfile
->obfd
;
20104 const gdb_byte
*info_ptr
;
20105 ULONGEST str_offset
;
20106 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
20108 str_section
->read (objfile
);
20109 str_offsets_section
->read (objfile
);
20110 if (str_section
->buffer
== NULL
)
20111 error (_("%s used without %s section"
20112 " in CU at offset %s [in module %s]"),
20113 form_name
, str_section
->get_name (),
20114 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20115 if (str_offsets_section
->buffer
== NULL
)
20116 error (_("%s used without %s section"
20117 " in CU at offset %s [in module %s]"),
20118 form_name
, str_section
->get_name (),
20119 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20120 info_ptr
= (str_offsets_section
->buffer
20122 + str_index
* cu
->header
.offset_size
);
20123 if (cu
->header
.offset_size
== 4)
20124 str_offset
= bfd_get_32 (abfd
, info_ptr
);
20126 str_offset
= bfd_get_64 (abfd
, info_ptr
);
20127 if (str_offset
>= str_section
->size
)
20128 error (_("Offset from %s pointing outside of"
20129 " .debug_str.dwo section in CU at offset %s [in module %s]"),
20130 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20131 return (const char *) (str_section
->buffer
+ str_offset
);
20134 /* Given a DW_FORM_GNU_str_index from a DWO file, fetch the string. */
20136 static const char *
20137 read_dwo_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
20139 ULONGEST str_offsets_base
= reader
->cu
->header
.version
>= 5
20140 ? reader
->cu
->header
.addr_size
: 0;
20141 return read_str_index (reader
->cu
,
20142 &reader
->dwo_file
->sections
.str
,
20143 &reader
->dwo_file
->sections
.str_offsets
,
20144 str_offsets_base
, str_index
);
20147 /* Given a DW_FORM_GNU_str_index from a Fission stub, fetch the string. */
20149 static const char *
20150 read_stub_str_index (struct dwarf2_cu
*cu
, ULONGEST str_index
)
20152 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20153 const char *objf_name
= objfile_name (objfile
);
20154 static const char form_name
[] = "DW_FORM_GNU_str_index";
20155 static const char str_offsets_attr_name
[] = "DW_AT_str_offsets";
20157 if (!cu
->str_offsets_base
.has_value ())
20158 error (_("%s used in Fission stub without %s"
20159 " in CU at offset 0x%lx [in module %s]"),
20160 form_name
, str_offsets_attr_name
,
20161 (long) cu
->header
.offset_size
, objf_name
);
20163 return read_str_index (cu
,
20164 &cu
->per_objfile
->per_bfd
->str
,
20165 &cu
->per_objfile
->per_bfd
->str_offsets
,
20166 *cu
->str_offsets_base
, str_index
);
20169 /* Return the length of an LEB128 number in BUF. */
20172 leb128_size (const gdb_byte
*buf
)
20174 const gdb_byte
*begin
= buf
;
20180 if ((byte
& 128) == 0)
20181 return buf
- begin
;
20186 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
20195 cu
->language
= language_c
;
20198 case DW_LANG_C_plus_plus
:
20199 case DW_LANG_C_plus_plus_11
:
20200 case DW_LANG_C_plus_plus_14
:
20201 cu
->language
= language_cplus
;
20204 cu
->language
= language_d
;
20206 case DW_LANG_Fortran77
:
20207 case DW_LANG_Fortran90
:
20208 case DW_LANG_Fortran95
:
20209 case DW_LANG_Fortran03
:
20210 case DW_LANG_Fortran08
:
20211 cu
->language
= language_fortran
;
20214 cu
->language
= language_go
;
20216 case DW_LANG_Mips_Assembler
:
20217 cu
->language
= language_asm
;
20219 case DW_LANG_Ada83
:
20220 case DW_LANG_Ada95
:
20221 cu
->language
= language_ada
;
20223 case DW_LANG_Modula2
:
20224 cu
->language
= language_m2
;
20226 case DW_LANG_Pascal83
:
20227 cu
->language
= language_pascal
;
20230 cu
->language
= language_objc
;
20233 case DW_LANG_Rust_old
:
20234 cu
->language
= language_rust
;
20236 case DW_LANG_Cobol74
:
20237 case DW_LANG_Cobol85
:
20239 cu
->language
= language_minimal
;
20242 cu
->language_defn
= language_def (cu
->language
);
20245 /* Return the named attribute or NULL if not there. */
20247 static struct attribute
*
20248 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20253 struct attribute
*spec
= NULL
;
20255 for (i
= 0; i
< die
->num_attrs
; ++i
)
20257 if (die
->attrs
[i
].name
== name
)
20258 return &die
->attrs
[i
];
20259 if (die
->attrs
[i
].name
== DW_AT_specification
20260 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
20261 spec
= &die
->attrs
[i
];
20267 die
= follow_die_ref (die
, spec
, &cu
);
20273 /* Return the string associated with a string-typed attribute, or NULL if it
20274 is either not found or is of an incorrect type. */
20276 static const char *
20277 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20279 struct attribute
*attr
;
20280 const char *str
= NULL
;
20282 attr
= dwarf2_attr (die
, name
, cu
);
20286 str
= attr
->as_string ();
20287 if (str
== nullptr)
20288 complaint (_("string type expected for attribute %s for "
20289 "DIE at %s in module %s"),
20290 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
20291 objfile_name (cu
->per_objfile
->objfile
));
20297 /* Return the dwo name or NULL if not present. If present, it is in either
20298 DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute. */
20299 static const char *
20300 dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
20302 const char *dwo_name
= dwarf2_string_attr (die
, DW_AT_GNU_dwo_name
, cu
);
20303 if (dwo_name
== nullptr)
20304 dwo_name
= dwarf2_string_attr (die
, DW_AT_dwo_name
, cu
);
20308 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20309 and holds a non-zero value. This function should only be used for
20310 DW_FORM_flag or DW_FORM_flag_present attributes. */
20313 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
20315 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
20317 return attr
!= nullptr && attr
->as_boolean ();
20321 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
20323 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20324 which value is non-zero. However, we have to be careful with
20325 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20326 (via dwarf2_flag_true_p) follows this attribute. So we may
20327 end up accidently finding a declaration attribute that belongs
20328 to a different DIE referenced by the specification attribute,
20329 even though the given DIE does not have a declaration attribute. */
20330 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
20331 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
20334 /* Return the die giving the specification for DIE, if there is
20335 one. *SPEC_CU is the CU containing DIE on input, and the CU
20336 containing the return value on output. If there is no
20337 specification, but there is an abstract origin, that is
20340 static struct die_info
*
20341 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
20343 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
20346 if (spec_attr
== NULL
)
20347 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
20349 if (spec_attr
== NULL
)
20352 return follow_die_ref (die
, spec_attr
, spec_cu
);
20355 /* Stub for free_line_header to match void * callback types. */
20358 free_line_header_voidp (void *arg
)
20360 struct line_header
*lh
= (struct line_header
*) arg
;
20365 /* A convenience function to find the proper .debug_line section for a CU. */
20367 static struct dwarf2_section_info
*
20368 get_debug_line_section (struct dwarf2_cu
*cu
)
20370 struct dwarf2_section_info
*section
;
20371 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20373 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20375 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20376 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
20377 else if (cu
->per_cu
->is_dwz
)
20379 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
20381 section
= &dwz
->line
;
20384 section
= &per_objfile
->per_bfd
->line
;
20389 /* Read the statement program header starting at OFFSET in
20390 .debug_line, or .debug_line.dwo. Return a pointer
20391 to a struct line_header, allocated using xmalloc.
20392 Returns NULL if there is a problem reading the header, e.g., if it
20393 has a version we don't understand.
20395 NOTE: the strings in the include directory and file name tables of
20396 the returned object point into the dwarf line section buffer,
20397 and must not be freed. */
20399 static line_header_up
20400 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
20402 struct dwarf2_section_info
*section
;
20403 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20405 section
= get_debug_line_section (cu
);
20406 section
->read (per_objfile
->objfile
);
20407 if (section
->buffer
== NULL
)
20409 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20410 complaint (_("missing .debug_line.dwo section"));
20412 complaint (_("missing .debug_line section"));
20416 return dwarf_decode_line_header (sect_off
, cu
->per_cu
->is_dwz
,
20417 per_objfile
, section
, &cu
->header
);
20420 /* Subroutine of dwarf_decode_lines to simplify it.
20421 Return the file name of the psymtab for the given file_entry.
20422 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20423 If space for the result is malloc'd, *NAME_HOLDER will be set.
20424 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20426 static const char *
20427 psymtab_include_file_name (const struct line_header
*lh
, const file_entry
&fe
,
20428 const dwarf2_psymtab
*pst
,
20429 const char *comp_dir
,
20430 gdb::unique_xmalloc_ptr
<char> *name_holder
)
20432 const char *include_name
= fe
.name
;
20433 const char *include_name_to_compare
= include_name
;
20434 const char *pst_filename
;
20437 const char *dir_name
= fe
.include_dir (lh
);
20439 gdb::unique_xmalloc_ptr
<char> hold_compare
;
20440 if (!IS_ABSOLUTE_PATH (include_name
)
20441 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
20443 /* Avoid creating a duplicate psymtab for PST.
20444 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20445 Before we do the comparison, however, we need to account
20446 for DIR_NAME and COMP_DIR.
20447 First prepend dir_name (if non-NULL). If we still don't
20448 have an absolute path prepend comp_dir (if non-NULL).
20449 However, the directory we record in the include-file's
20450 psymtab does not contain COMP_DIR (to match the
20451 corresponding symtab(s)).
20456 bash$ gcc -g ./hello.c
20457 include_name = "hello.c"
20459 DW_AT_comp_dir = comp_dir = "/tmp"
20460 DW_AT_name = "./hello.c"
20464 if (dir_name
!= NULL
)
20466 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
20467 include_name
, (char *) NULL
));
20468 include_name
= name_holder
->get ();
20469 include_name_to_compare
= include_name
;
20471 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
20473 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
20474 include_name
, (char *) NULL
));
20475 include_name_to_compare
= hold_compare
.get ();
20479 pst_filename
= pst
->filename
;
20480 gdb::unique_xmalloc_ptr
<char> copied_name
;
20481 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
20483 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
20484 pst_filename
, (char *) NULL
));
20485 pst_filename
= copied_name
.get ();
20488 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
20492 return include_name
;
20495 /* State machine to track the state of the line number program. */
20497 class lnp_state_machine
20500 /* Initialize a machine state for the start of a line number
20502 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
20503 bool record_lines_p
);
20505 file_entry
*current_file ()
20507 /* lh->file_names is 0-based, but the file name numbers in the
20508 statement program are 1-based. */
20509 return m_line_header
->file_name_at (m_file
);
20512 /* Record the line in the state machine. END_SEQUENCE is true if
20513 we're processing the end of a sequence. */
20514 void record_line (bool end_sequence
);
20516 /* Check ADDRESS is -1, or zero and less than UNRELOCATED_LOWPC, and if true
20517 nop-out rest of the lines in this sequence. */
20518 void check_line_address (struct dwarf2_cu
*cu
,
20519 const gdb_byte
*line_ptr
,
20520 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
20522 void handle_set_discriminator (unsigned int discriminator
)
20524 m_discriminator
= discriminator
;
20525 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
20528 /* Handle DW_LNE_set_address. */
20529 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
20532 address
+= baseaddr
;
20533 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
20536 /* Handle DW_LNS_advance_pc. */
20537 void handle_advance_pc (CORE_ADDR adjust
);
20539 /* Handle a special opcode. */
20540 void handle_special_opcode (unsigned char op_code
);
20542 /* Handle DW_LNS_advance_line. */
20543 void handle_advance_line (int line_delta
)
20545 advance_line (line_delta
);
20548 /* Handle DW_LNS_set_file. */
20549 void handle_set_file (file_name_index file
);
20551 /* Handle DW_LNS_negate_stmt. */
20552 void handle_negate_stmt ()
20554 m_is_stmt
= !m_is_stmt
;
20557 /* Handle DW_LNS_const_add_pc. */
20558 void handle_const_add_pc ();
20560 /* Handle DW_LNS_fixed_advance_pc. */
20561 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
20563 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20567 /* Handle DW_LNS_copy. */
20568 void handle_copy ()
20570 record_line (false);
20571 m_discriminator
= 0;
20574 /* Handle DW_LNE_end_sequence. */
20575 void handle_end_sequence ()
20577 m_currently_recording_lines
= true;
20581 /* Advance the line by LINE_DELTA. */
20582 void advance_line (int line_delta
)
20584 m_line
+= line_delta
;
20586 if (line_delta
!= 0)
20587 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20590 struct dwarf2_cu
*m_cu
;
20592 gdbarch
*m_gdbarch
;
20594 /* True if we're recording lines.
20595 Otherwise we're building partial symtabs and are just interested in
20596 finding include files mentioned by the line number program. */
20597 bool m_record_lines_p
;
20599 /* The line number header. */
20600 line_header
*m_line_header
;
20602 /* These are part of the standard DWARF line number state machine,
20603 and initialized according to the DWARF spec. */
20605 unsigned char m_op_index
= 0;
20606 /* The line table index of the current file. */
20607 file_name_index m_file
= 1;
20608 unsigned int m_line
= 1;
20610 /* These are initialized in the constructor. */
20612 CORE_ADDR m_address
;
20614 unsigned int m_discriminator
;
20616 /* Additional bits of state we need to track. */
20618 /* The last file that we called dwarf2_start_subfile for.
20619 This is only used for TLLs. */
20620 unsigned int m_last_file
= 0;
20621 /* The last file a line number was recorded for. */
20622 struct subfile
*m_last_subfile
= NULL
;
20624 /* The address of the last line entry. */
20625 CORE_ADDR m_last_address
;
20627 /* Set to true when a previous line at the same address (using
20628 m_last_address) had m_is_stmt true. This is reset to false when a
20629 line entry at a new address (m_address different to m_last_address) is
20631 bool m_stmt_at_address
= false;
20633 /* When true, record the lines we decode. */
20634 bool m_currently_recording_lines
= false;
20636 /* The last line number that was recorded, used to coalesce
20637 consecutive entries for the same line. This can happen, for
20638 example, when discriminators are present. PR 17276. */
20639 unsigned int m_last_line
= 0;
20640 bool m_line_has_non_zero_discriminator
= false;
20644 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
20646 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
20647 / m_line_header
->maximum_ops_per_instruction
)
20648 * m_line_header
->minimum_instruction_length
);
20649 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20650 m_op_index
= ((m_op_index
+ adjust
)
20651 % m_line_header
->maximum_ops_per_instruction
);
20655 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
20657 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
20658 unsigned char adj_opcode_d
= adj_opcode
/ m_line_header
->line_range
;
20659 unsigned char adj_opcode_r
= adj_opcode
% m_line_header
->line_range
;
20660 CORE_ADDR addr_adj
= (((m_op_index
+ adj_opcode_d
)
20661 / m_line_header
->maximum_ops_per_instruction
)
20662 * m_line_header
->minimum_instruction_length
);
20663 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20664 m_op_index
= ((m_op_index
+ adj_opcode_d
)
20665 % m_line_header
->maximum_ops_per_instruction
);
20667 int line_delta
= m_line_header
->line_base
+ adj_opcode_r
;
20668 advance_line (line_delta
);
20669 record_line (false);
20670 m_discriminator
= 0;
20674 lnp_state_machine::handle_set_file (file_name_index file
)
20678 const file_entry
*fe
= current_file ();
20680 dwarf2_debug_line_missing_file_complaint ();
20681 else if (m_record_lines_p
)
20683 const char *dir
= fe
->include_dir (m_line_header
);
20685 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20686 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20687 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
20692 lnp_state_machine::handle_const_add_pc ()
20695 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
20698 = (((m_op_index
+ adjust
)
20699 / m_line_header
->maximum_ops_per_instruction
)
20700 * m_line_header
->minimum_instruction_length
);
20702 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20703 m_op_index
= ((m_op_index
+ adjust
)
20704 % m_line_header
->maximum_ops_per_instruction
);
20707 /* Return non-zero if we should add LINE to the line number table.
20708 LINE is the line to add, LAST_LINE is the last line that was added,
20709 LAST_SUBFILE is the subfile for LAST_LINE.
20710 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20711 had a non-zero discriminator.
20713 We have to be careful in the presence of discriminators.
20714 E.g., for this line:
20716 for (i = 0; i < 100000; i++);
20718 clang can emit four line number entries for that one line,
20719 each with a different discriminator.
20720 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20722 However, we want gdb to coalesce all four entries into one.
20723 Otherwise the user could stepi into the middle of the line and
20724 gdb would get confused about whether the pc really was in the
20725 middle of the line.
20727 Things are further complicated by the fact that two consecutive
20728 line number entries for the same line is a heuristic used by gcc
20729 to denote the end of the prologue. So we can't just discard duplicate
20730 entries, we have to be selective about it. The heuristic we use is
20731 that we only collapse consecutive entries for the same line if at least
20732 one of those entries has a non-zero discriminator. PR 17276.
20734 Note: Addresses in the line number state machine can never go backwards
20735 within one sequence, thus this coalescing is ok. */
20738 dwarf_record_line_p (struct dwarf2_cu
*cu
,
20739 unsigned int line
, unsigned int last_line
,
20740 int line_has_non_zero_discriminator
,
20741 struct subfile
*last_subfile
)
20743 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
20745 if (line
!= last_line
)
20747 /* Same line for the same file that we've seen already.
20748 As a last check, for pr 17276, only record the line if the line
20749 has never had a non-zero discriminator. */
20750 if (!line_has_non_zero_discriminator
)
20755 /* Use the CU's builder to record line number LINE beginning at
20756 address ADDRESS in the line table of subfile SUBFILE. */
20759 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20760 unsigned int line
, CORE_ADDR address
, bool is_stmt
,
20761 struct dwarf2_cu
*cu
)
20763 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
20765 if (dwarf_line_debug
)
20767 fprintf_unfiltered (gdb_stdlog
,
20768 "Recording line %u, file %s, address %s\n",
20769 line
, lbasename (subfile
->name
),
20770 paddress (gdbarch
, address
));
20774 cu
->get_builder ()->record_line (subfile
, line
, addr
, is_stmt
);
20777 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20778 Mark the end of a set of line number records.
20779 The arguments are the same as for dwarf_record_line_1.
20780 If SUBFILE is NULL the request is ignored. */
20783 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20784 CORE_ADDR address
, struct dwarf2_cu
*cu
)
20786 if (subfile
== NULL
)
20789 if (dwarf_line_debug
)
20791 fprintf_unfiltered (gdb_stdlog
,
20792 "Finishing current line, file %s, address %s\n",
20793 lbasename (subfile
->name
),
20794 paddress (gdbarch
, address
));
20797 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, true, cu
);
20801 lnp_state_machine::record_line (bool end_sequence
)
20803 if (dwarf_line_debug
)
20805 fprintf_unfiltered (gdb_stdlog
,
20806 "Processing actual line %u: file %u,"
20807 " address %s, is_stmt %u, discrim %u%s\n",
20809 paddress (m_gdbarch
, m_address
),
20810 m_is_stmt
, m_discriminator
,
20811 (end_sequence
? "\t(end sequence)" : ""));
20814 file_entry
*fe
= current_file ();
20817 dwarf2_debug_line_missing_file_complaint ();
20818 /* For now we ignore lines not starting on an instruction boundary.
20819 But not when processing end_sequence for compatibility with the
20820 previous version of the code. */
20821 else if (m_op_index
== 0 || end_sequence
)
20823 fe
->included_p
= 1;
20824 if (m_record_lines_p
)
20826 /* When we switch files we insert an end maker in the first file,
20827 switch to the second file and add a new line entry. The
20828 problem is that the end marker inserted in the first file will
20829 discard any previous line entries at the same address. If the
20830 line entries in the first file are marked as is-stmt, while
20831 the new line in the second file is non-stmt, then this means
20832 the end marker will discard is-stmt lines so we can have a
20833 non-stmt line. This means that there are less addresses at
20834 which the user can insert a breakpoint.
20836 To improve this we track the last address in m_last_address,
20837 and whether we have seen an is-stmt at this address. Then
20838 when switching files, if we have seen a stmt at the current
20839 address, and we are switching to create a non-stmt line, then
20840 discard the new line. */
20842 = m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ();
20843 bool ignore_this_line
20844 = ((file_changed
&& !end_sequence
&& m_last_address
== m_address
20845 && !m_is_stmt
&& m_stmt_at_address
)
20846 || (!end_sequence
&& m_line
== 0));
20848 if ((file_changed
&& !ignore_this_line
) || end_sequence
)
20850 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
20851 m_currently_recording_lines
? m_cu
: nullptr);
20854 if (!end_sequence
&& !ignore_this_line
)
20856 bool is_stmt
= producer_is_codewarrior (m_cu
) || m_is_stmt
;
20858 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
20859 m_line_has_non_zero_discriminator
,
20862 buildsym_compunit
*builder
= m_cu
->get_builder ();
20863 dwarf_record_line_1 (m_gdbarch
,
20864 builder
->get_current_subfile (),
20865 m_line
, m_address
, is_stmt
,
20866 m_currently_recording_lines
? m_cu
: nullptr);
20868 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20869 m_last_line
= m_line
;
20874 /* Track whether we have seen any m_is_stmt true at m_address in case we
20875 have multiple line table entries all at m_address. */
20876 if (m_last_address
!= m_address
)
20878 m_stmt_at_address
= false;
20879 m_last_address
= m_address
;
20881 m_stmt_at_address
|= m_is_stmt
;
20884 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
20885 line_header
*lh
, bool record_lines_p
)
20889 m_record_lines_p
= record_lines_p
;
20890 m_line_header
= lh
;
20892 m_currently_recording_lines
= true;
20894 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20895 was a line entry for it so that the backend has a chance to adjust it
20896 and also record it in case it needs it. This is currently used by MIPS
20897 code, cf. `mips_adjust_dwarf2_line'. */
20898 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
20899 m_is_stmt
= lh
->default_is_stmt
;
20900 m_discriminator
= 0;
20902 m_last_address
= m_address
;
20903 m_stmt_at_address
= false;
20907 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
20908 const gdb_byte
*line_ptr
,
20909 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
20911 /* Linkers resolve a symbolic relocation referencing a GC'd function to 0 or
20912 -1. If ADDRESS is 0, ignoring the opcode will err if the text section is
20913 located at 0x0. In this case, additionally check that if
20914 ADDRESS < UNRELOCATED_LOWPC. */
20916 if ((address
== 0 && address
< unrelocated_lowpc
)
20917 || address
== (CORE_ADDR
) -1)
20919 /* This line table is for a function which has been
20920 GCd by the linker. Ignore it. PR gdb/12528 */
20922 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20923 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
20925 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20926 line_offset
, objfile_name (objfile
));
20927 m_currently_recording_lines
= false;
20928 /* Note: m_currently_recording_lines is left as false until we see
20929 DW_LNE_end_sequence. */
20933 /* Subroutine of dwarf_decode_lines to simplify it.
20934 Process the line number information in LH.
20935 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20936 program in order to set included_p for every referenced header. */
20939 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
20940 const int decode_for_pst_p
, CORE_ADDR lowpc
)
20942 const gdb_byte
*line_ptr
, *extended_end
;
20943 const gdb_byte
*line_end
;
20944 unsigned int bytes_read
, extended_len
;
20945 unsigned char op_code
, extended_op
;
20946 CORE_ADDR baseaddr
;
20947 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20948 bfd
*abfd
= objfile
->obfd
;
20949 struct gdbarch
*gdbarch
= objfile
->arch ();
20950 /* True if we're recording line info (as opposed to building partial
20951 symtabs and just interested in finding include files mentioned by
20952 the line number program). */
20953 bool record_lines_p
= !decode_for_pst_p
;
20955 baseaddr
= objfile
->text_section_offset ();
20957 line_ptr
= lh
->statement_program_start
;
20958 line_end
= lh
->statement_program_end
;
20960 /* Read the statement sequences until there's nothing left. */
20961 while (line_ptr
< line_end
)
20963 /* The DWARF line number program state machine. Reset the state
20964 machine at the start of each sequence. */
20965 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
20966 bool end_sequence
= false;
20968 if (record_lines_p
)
20970 /* Start a subfile for the current file of the state
20972 const file_entry
*fe
= state_machine
.current_file ();
20975 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
20978 /* Decode the table. */
20979 while (line_ptr
< line_end
&& !end_sequence
)
20981 op_code
= read_1_byte (abfd
, line_ptr
);
20984 if (op_code
>= lh
->opcode_base
)
20986 /* Special opcode. */
20987 state_machine
.handle_special_opcode (op_code
);
20989 else switch (op_code
)
20991 case DW_LNS_extended_op
:
20992 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
20994 line_ptr
+= bytes_read
;
20995 extended_end
= line_ptr
+ extended_len
;
20996 extended_op
= read_1_byte (abfd
, line_ptr
);
20998 if (DW_LNE_lo_user
<= extended_op
20999 && extended_op
<= DW_LNE_hi_user
)
21001 /* Vendor extension, ignore. */
21002 line_ptr
= extended_end
;
21005 switch (extended_op
)
21007 case DW_LNE_end_sequence
:
21008 state_machine
.handle_end_sequence ();
21009 end_sequence
= true;
21011 case DW_LNE_set_address
:
21014 = cu
->header
.read_address (abfd
, line_ptr
, &bytes_read
);
21015 line_ptr
+= bytes_read
;
21017 state_machine
.check_line_address (cu
, line_ptr
,
21018 lowpc
- baseaddr
, address
);
21019 state_machine
.handle_set_address (baseaddr
, address
);
21022 case DW_LNE_define_file
:
21024 const char *cur_file
;
21025 unsigned int mod_time
, length
;
21028 cur_file
= read_direct_string (abfd
, line_ptr
,
21030 line_ptr
+= bytes_read
;
21031 dindex
= (dir_index
)
21032 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21033 line_ptr
+= bytes_read
;
21035 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21036 line_ptr
+= bytes_read
;
21038 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21039 line_ptr
+= bytes_read
;
21040 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21043 case DW_LNE_set_discriminator
:
21045 /* The discriminator is not interesting to the
21046 debugger; just ignore it. We still need to
21047 check its value though:
21048 if there are consecutive entries for the same
21049 (non-prologue) line we want to coalesce them.
21052 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21053 line_ptr
+= bytes_read
;
21055 state_machine
.handle_set_discriminator (discr
);
21059 complaint (_("mangled .debug_line section"));
21062 /* Make sure that we parsed the extended op correctly. If e.g.
21063 we expected a different address size than the producer used,
21064 we may have read the wrong number of bytes. */
21065 if (line_ptr
!= extended_end
)
21067 complaint (_("mangled .debug_line section"));
21072 state_machine
.handle_copy ();
21074 case DW_LNS_advance_pc
:
21077 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21078 line_ptr
+= bytes_read
;
21080 state_machine
.handle_advance_pc (adjust
);
21083 case DW_LNS_advance_line
:
21086 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21087 line_ptr
+= bytes_read
;
21089 state_machine
.handle_advance_line (line_delta
);
21092 case DW_LNS_set_file
:
21094 file_name_index file
21095 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21097 line_ptr
+= bytes_read
;
21099 state_machine
.handle_set_file (file
);
21102 case DW_LNS_set_column
:
21103 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21104 line_ptr
+= bytes_read
;
21106 case DW_LNS_negate_stmt
:
21107 state_machine
.handle_negate_stmt ();
21109 case DW_LNS_set_basic_block
:
21111 /* Add to the address register of the state machine the
21112 address increment value corresponding to special opcode
21113 255. I.e., this value is scaled by the minimum
21114 instruction length since special opcode 255 would have
21115 scaled the increment. */
21116 case DW_LNS_const_add_pc
:
21117 state_machine
.handle_const_add_pc ();
21119 case DW_LNS_fixed_advance_pc
:
21121 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21124 state_machine
.handle_fixed_advance_pc (addr_adj
);
21129 /* Unknown standard opcode, ignore it. */
21132 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21134 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21135 line_ptr
+= bytes_read
;
21142 dwarf2_debug_line_missing_end_sequence_complaint ();
21144 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21145 in which case we still finish recording the last line). */
21146 state_machine
.record_line (true);
21150 /* Decode the Line Number Program (LNP) for the given line_header
21151 structure and CU. The actual information extracted and the type
21152 of structures created from the LNP depends on the value of PST.
21154 1. If PST is NULL, then this procedure uses the data from the program
21155 to create all necessary symbol tables, and their linetables.
21157 2. If PST is not NULL, this procedure reads the program to determine
21158 the list of files included by the unit represented by PST, and
21159 builds all the associated partial symbol tables.
21161 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21162 It is used for relative paths in the line table.
21163 NOTE: When processing partial symtabs (pst != NULL),
21164 comp_dir == pst->dirname.
21166 NOTE: It is important that psymtabs have the same file name (via strcmp)
21167 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21168 symtab we don't use it in the name of the psymtabs we create.
21169 E.g. expand_line_sal requires this when finding psymtabs to expand.
21170 A good testcase for this is mb-inline.exp.
21172 LOWPC is the lowest address in CU (or 0 if not known).
21174 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21175 for its PC<->lines mapping information. Otherwise only the filename
21176 table is read in. */
21179 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21180 struct dwarf2_cu
*cu
, dwarf2_psymtab
*pst
,
21181 CORE_ADDR lowpc
, int decode_mapping
)
21183 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21184 const int decode_for_pst_p
= (pst
!= NULL
);
21186 if (decode_mapping
)
21187 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21189 if (decode_for_pst_p
)
21191 /* Now that we're done scanning the Line Header Program, we can
21192 create the psymtab of each included file. */
21193 for (auto &file_entry
: lh
->file_names ())
21194 if (file_entry
.included_p
== 1)
21196 gdb::unique_xmalloc_ptr
<char> name_holder
;
21197 const char *include_name
=
21198 psymtab_include_file_name (lh
, file_entry
, pst
,
21199 comp_dir
, &name_holder
);
21200 if (include_name
!= NULL
)
21201 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
21206 /* Make sure a symtab is created for every file, even files
21207 which contain only variables (i.e. no code with associated
21209 buildsym_compunit
*builder
= cu
->get_builder ();
21210 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21212 for (auto &fe
: lh
->file_names ())
21214 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21215 if (builder
->get_current_subfile ()->symtab
== NULL
)
21217 builder
->get_current_subfile ()->symtab
21218 = allocate_symtab (cust
,
21219 builder
->get_current_subfile ()->name
);
21221 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21226 /* Start a subfile for DWARF. FILENAME is the name of the file and
21227 DIRNAME the name of the source directory which contains FILENAME
21228 or NULL if not known.
21229 This routine tries to keep line numbers from identical absolute and
21230 relative file names in a common subfile.
21232 Using the `list' example from the GDB testsuite, which resides in
21233 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21234 of /srcdir/list0.c yields the following debugging information for list0.c:
21236 DW_AT_name: /srcdir/list0.c
21237 DW_AT_comp_dir: /compdir
21238 files.files[0].name: list0.h
21239 files.files[0].dir: /srcdir
21240 files.files[1].name: list0.c
21241 files.files[1].dir: /srcdir
21243 The line number information for list0.c has to end up in a single
21244 subfile, so that `break /srcdir/list0.c:1' works as expected.
21245 start_subfile will ensure that this happens provided that we pass the
21246 concatenation of files.files[1].dir and files.files[1].name as the
21250 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
21251 const char *dirname
)
21253 gdb::unique_xmalloc_ptr
<char> copy
;
21255 /* In order not to lose the line information directory,
21256 we concatenate it to the filename when it makes sense.
21257 Note that the Dwarf3 standard says (speaking of filenames in line
21258 information): ``The directory index is ignored for file names
21259 that represent full path names''. Thus ignoring dirname in the
21260 `else' branch below isn't an issue. */
21262 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
21264 copy
.reset (concat (dirname
, SLASH_STRING
, filename
, (char *) NULL
));
21265 filename
= copy
.get ();
21268 cu
->get_builder ()->start_subfile (filename
);
21271 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21272 buildsym_compunit constructor. */
21274 struct compunit_symtab
*
21275 dwarf2_cu::start_symtab (const char *name
, const char *comp_dir
,
21278 gdb_assert (m_builder
== nullptr);
21280 m_builder
.reset (new struct buildsym_compunit
21281 (this->per_objfile
->objfile
,
21282 name
, comp_dir
, language
, low_pc
));
21284 list_in_scope
= get_builder ()->get_file_symbols ();
21286 get_builder ()->record_debugformat ("DWARF 2");
21287 get_builder ()->record_producer (producer
);
21289 processing_has_namespace_info
= false;
21291 return get_builder ()->get_compunit_symtab ();
21295 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
21296 struct dwarf2_cu
*cu
)
21298 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21299 struct comp_unit_head
*cu_header
= &cu
->header
;
21301 /* NOTE drow/2003-01-30: There used to be a comment and some special
21302 code here to turn a symbol with DW_AT_external and a
21303 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21304 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21305 with some versions of binutils) where shared libraries could have
21306 relocations against symbols in their debug information - the
21307 minimal symbol would have the right address, but the debug info
21308 would not. It's no longer necessary, because we will explicitly
21309 apply relocations when we read in the debug information now. */
21311 /* A DW_AT_location attribute with no contents indicates that a
21312 variable has been optimized away. */
21313 if (attr
->form_is_block () && attr
->as_block ()->size
== 0)
21315 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21319 /* Handle one degenerate form of location expression specially, to
21320 preserve GDB's previous behavior when section offsets are
21321 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
21322 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
21324 if (attr
->form_is_block ())
21326 struct dwarf_block
*block
= attr
->as_block ();
21328 if ((block
->data
[0] == DW_OP_addr
21329 && block
->size
== 1 + cu_header
->addr_size
)
21330 || ((block
->data
[0] == DW_OP_GNU_addr_index
21331 || block
->data
[0] == DW_OP_addrx
)
21333 == 1 + leb128_size (&block
->data
[1]))))
21335 unsigned int dummy
;
21337 if (block
->data
[0] == DW_OP_addr
)
21338 SET_SYMBOL_VALUE_ADDRESS
21339 (sym
, cu
->header
.read_address (objfile
->obfd
,
21343 SET_SYMBOL_VALUE_ADDRESS
21344 (sym
, read_addr_index_from_leb128 (cu
, block
->data
+ 1,
21346 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
21347 fixup_symbol_section (sym
, objfile
);
21348 SET_SYMBOL_VALUE_ADDRESS
21350 SYMBOL_VALUE_ADDRESS (sym
)
21351 + objfile
->section_offsets
[SYMBOL_SECTION (sym
)]);
21356 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21357 expression evaluator, and use LOC_COMPUTED only when necessary
21358 (i.e. when the value of a register or memory location is
21359 referenced, or a thread-local block, etc.). Then again, it might
21360 not be worthwhile. I'm assuming that it isn't unless performance
21361 or memory numbers show me otherwise. */
21363 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
21365 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
21366 cu
->has_loclist
= true;
21369 /* Given a pointer to a DWARF information entry, figure out if we need
21370 to make a symbol table entry for it, and if so, create a new entry
21371 and return a pointer to it.
21372 If TYPE is NULL, determine symbol type from the die, otherwise
21373 used the passed type.
21374 If SPACE is not NULL, use it to hold the new symbol. If it is
21375 NULL, allocate a new symbol on the objfile's obstack. */
21377 static struct symbol
*
21378 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
21379 struct symbol
*space
)
21381 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21382 struct objfile
*objfile
= per_objfile
->objfile
;
21383 struct gdbarch
*gdbarch
= objfile
->arch ();
21384 struct symbol
*sym
= NULL
;
21386 struct attribute
*attr
= NULL
;
21387 struct attribute
*attr2
= NULL
;
21388 CORE_ADDR baseaddr
;
21389 struct pending
**list_to_add
= NULL
;
21391 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
21393 baseaddr
= objfile
->text_section_offset ();
21395 name
= dwarf2_name (die
, cu
);
21398 int suppress_add
= 0;
21403 sym
= new (&objfile
->objfile_obstack
) symbol
;
21404 OBJSTAT (objfile
, n_syms
++);
21406 /* Cache this symbol's name and the name's demangled form (if any). */
21407 sym
->set_language (cu
->language
, &objfile
->objfile_obstack
);
21408 /* Fortran does not have mangling standard and the mangling does differ
21409 between gfortran, iFort etc. */
21410 const char *physname
21411 = (cu
->language
== language_fortran
21412 ? dwarf2_full_name (name
, die
, cu
)
21413 : dwarf2_physname (name
, die
, cu
));
21414 const char *linkagename
= dw2_linkage_name (die
, cu
);
21416 if (linkagename
== nullptr || cu
->language
== language_ada
)
21417 sym
->set_linkage_name (physname
);
21420 sym
->set_demangled_name (physname
, &objfile
->objfile_obstack
);
21421 sym
->set_linkage_name (linkagename
);
21424 /* Default assumptions.
21425 Use the passed type or decode it from the die. */
21426 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21427 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21429 SYMBOL_TYPE (sym
) = type
;
21431 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
21432 attr
= dwarf2_attr (die
,
21433 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
21435 if (attr
!= nullptr)
21436 SYMBOL_LINE (sym
) = attr
->constant_value (0);
21438 attr
= dwarf2_attr (die
,
21439 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
21441 if (attr
!= nullptr && attr
->form_is_unsigned ())
21443 file_name_index file_index
21444 = (file_name_index
) attr
->as_unsigned ();
21445 struct file_entry
*fe
;
21447 if (cu
->line_header
!= NULL
)
21448 fe
= cu
->line_header
->file_name_at (file_index
);
21453 complaint (_("file index out of range"));
21455 symbol_set_symtab (sym
, fe
->symtab
);
21461 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
21462 if (attr
!= nullptr)
21466 addr
= attr
->as_address ();
21467 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
21468 SET_SYMBOL_VALUE_ADDRESS (sym
, addr
);
21469 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
21472 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21473 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
21474 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
21475 add_symbol_to_list (sym
, cu
->list_in_scope
);
21477 case DW_TAG_subprogram
:
21478 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21480 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21481 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21482 if ((attr2
!= nullptr && attr2
->as_boolean ())
21483 || cu
->language
== language_ada
21484 || cu
->language
== language_fortran
)
21486 /* Subprograms marked external are stored as a global symbol.
21487 Ada and Fortran subprograms, whether marked external or
21488 not, are always stored as a global symbol, because we want
21489 to be able to access them globally. For instance, we want
21490 to be able to break on a nested subprogram without having
21491 to specify the context. */
21492 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21496 list_to_add
= cu
->list_in_scope
;
21499 case DW_TAG_inlined_subroutine
:
21500 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21502 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21503 SYMBOL_INLINED (sym
) = 1;
21504 list_to_add
= cu
->list_in_scope
;
21506 case DW_TAG_template_value_param
:
21508 /* Fall through. */
21509 case DW_TAG_constant
:
21510 case DW_TAG_variable
:
21511 case DW_TAG_member
:
21512 /* Compilation with minimal debug info may result in
21513 variables with missing type entries. Change the
21514 misleading `void' type to something sensible. */
21515 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
21516 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
21518 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21519 /* In the case of DW_TAG_member, we should only be called for
21520 static const members. */
21521 if (die
->tag
== DW_TAG_member
)
21523 /* dwarf2_add_field uses die_is_declaration,
21524 so we do the same. */
21525 gdb_assert (die_is_declaration (die
, cu
));
21528 if (attr
!= nullptr)
21530 dwarf2_const_value (attr
, sym
, cu
);
21531 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21534 if (attr2
!= nullptr && attr2
->as_boolean ())
21535 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21537 list_to_add
= cu
->list_in_scope
;
21541 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21542 if (attr
!= nullptr)
21544 var_decode_location (attr
, sym
, cu
);
21545 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21547 /* Fortran explicitly imports any global symbols to the local
21548 scope by DW_TAG_common_block. */
21549 if (cu
->language
== language_fortran
&& die
->parent
21550 && die
->parent
->tag
== DW_TAG_common_block
)
21553 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21554 && SYMBOL_VALUE_ADDRESS (sym
) == 0
21555 && !per_objfile
->per_bfd
->has_section_at_zero
)
21557 /* When a static variable is eliminated by the linker,
21558 the corresponding debug information is not stripped
21559 out, but the variable address is set to null;
21560 do not add such variables into symbol table. */
21562 else if (attr2
!= nullptr && attr2
->as_boolean ())
21564 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21565 && (objfile
->flags
& OBJF_MAINLINE
) == 0
21566 && per_objfile
->per_bfd
->can_copy
)
21568 /* A global static variable might be subject to
21569 copy relocation. We first check for a local
21570 minsym, though, because maybe the symbol was
21571 marked hidden, in which case this would not
21573 bound_minimal_symbol found
21574 = (lookup_minimal_symbol_linkage
21575 (sym
->linkage_name (), objfile
));
21576 if (found
.minsym
!= nullptr)
21577 sym
->maybe_copied
= 1;
21580 /* A variable with DW_AT_external is never static,
21581 but it may be block-scoped. */
21583 = ((cu
->list_in_scope
21584 == cu
->get_builder ()->get_file_symbols ())
21585 ? cu
->get_builder ()->get_global_symbols ()
21586 : cu
->list_in_scope
);
21589 list_to_add
= cu
->list_in_scope
;
21593 /* We do not know the address of this symbol.
21594 If it is an external symbol and we have type information
21595 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21596 The address of the variable will then be determined from
21597 the minimal symbol table whenever the variable is
21599 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21601 /* Fortran explicitly imports any global symbols to the local
21602 scope by DW_TAG_common_block. */
21603 if (cu
->language
== language_fortran
&& die
->parent
21604 && die
->parent
->tag
== DW_TAG_common_block
)
21606 /* SYMBOL_CLASS doesn't matter here because
21607 read_common_block is going to reset it. */
21609 list_to_add
= cu
->list_in_scope
;
21611 else if (attr2
!= nullptr && attr2
->as_boolean ()
21612 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
21614 /* A variable with DW_AT_external is never static, but it
21615 may be block-scoped. */
21617 = ((cu
->list_in_scope
21618 == cu
->get_builder ()->get_file_symbols ())
21619 ? cu
->get_builder ()->get_global_symbols ()
21620 : cu
->list_in_scope
);
21622 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21624 else if (!die_is_declaration (die
, cu
))
21626 /* Use the default LOC_OPTIMIZED_OUT class. */
21627 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
21629 list_to_add
= cu
->list_in_scope
;
21633 case DW_TAG_formal_parameter
:
21635 /* If we are inside a function, mark this as an argument. If
21636 not, we might be looking at an argument to an inlined function
21637 when we do not have enough information to show inlined frames;
21638 pretend it's a local variable in that case so that the user can
21640 struct context_stack
*curr
21641 = cu
->get_builder ()->get_current_context_stack ();
21642 if (curr
!= nullptr && curr
->name
!= nullptr)
21643 SYMBOL_IS_ARGUMENT (sym
) = 1;
21644 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21645 if (attr
!= nullptr)
21647 var_decode_location (attr
, sym
, cu
);
21649 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21650 if (attr
!= nullptr)
21652 dwarf2_const_value (attr
, sym
, cu
);
21655 list_to_add
= cu
->list_in_scope
;
21658 case DW_TAG_unspecified_parameters
:
21659 /* From varargs functions; gdb doesn't seem to have any
21660 interest in this information, so just ignore it for now.
21663 case DW_TAG_template_type_param
:
21665 /* Fall through. */
21666 case DW_TAG_class_type
:
21667 case DW_TAG_interface_type
:
21668 case DW_TAG_structure_type
:
21669 case DW_TAG_union_type
:
21670 case DW_TAG_set_type
:
21671 case DW_TAG_enumeration_type
:
21672 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21673 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
21676 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21677 really ever be static objects: otherwise, if you try
21678 to, say, break of a class's method and you're in a file
21679 which doesn't mention that class, it won't work unless
21680 the check for all static symbols in lookup_symbol_aux
21681 saves you. See the OtherFileClass tests in
21682 gdb.c++/namespace.exp. */
21686 buildsym_compunit
*builder
= cu
->get_builder ();
21688 = (cu
->list_in_scope
== builder
->get_file_symbols ()
21689 && cu
->language
== language_cplus
21690 ? builder
->get_global_symbols ()
21691 : cu
->list_in_scope
);
21693 /* The semantics of C++ state that "struct foo {
21694 ... }" also defines a typedef for "foo". */
21695 if (cu
->language
== language_cplus
21696 || cu
->language
== language_ada
21697 || cu
->language
== language_d
21698 || cu
->language
== language_rust
)
21700 /* The symbol's name is already allocated along
21701 with this objfile, so we don't need to
21702 duplicate it for the type. */
21703 if (SYMBOL_TYPE (sym
)->name () == 0)
21704 SYMBOL_TYPE (sym
)->set_name (sym
->search_name ());
21709 case DW_TAG_typedef
:
21710 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21711 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21712 list_to_add
= cu
->list_in_scope
;
21714 case DW_TAG_base_type
:
21715 case DW_TAG_subrange_type
:
21716 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21717 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21718 list_to_add
= cu
->list_in_scope
;
21720 case DW_TAG_enumerator
:
21721 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21722 if (attr
!= nullptr)
21724 dwarf2_const_value (attr
, sym
, cu
);
21727 /* NOTE: carlton/2003-11-10: See comment above in the
21728 DW_TAG_class_type, etc. block. */
21731 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
21732 && cu
->language
== language_cplus
21733 ? cu
->get_builder ()->get_global_symbols ()
21734 : cu
->list_in_scope
);
21737 case DW_TAG_imported_declaration
:
21738 case DW_TAG_namespace
:
21739 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21740 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21742 case DW_TAG_module
:
21743 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21744 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
21745 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21747 case DW_TAG_common_block
:
21748 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
21749 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
21750 add_symbol_to_list (sym
, cu
->list_in_scope
);
21753 /* Not a tag we recognize. Hopefully we aren't processing
21754 trash data, but since we must specifically ignore things
21755 we don't recognize, there is nothing else we should do at
21757 complaint (_("unsupported tag: '%s'"),
21758 dwarf_tag_name (die
->tag
));
21764 sym
->hash_next
= objfile
->template_symbols
;
21765 objfile
->template_symbols
= sym
;
21766 list_to_add
= NULL
;
21769 if (list_to_add
!= NULL
)
21770 add_symbol_to_list (sym
, list_to_add
);
21772 /* For the benefit of old versions of GCC, check for anonymous
21773 namespaces based on the demangled name. */
21774 if (!cu
->processing_has_namespace_info
21775 && cu
->language
== language_cplus
)
21776 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
21781 /* Given an attr with a DW_FORM_dataN value in host byte order,
21782 zero-extend it as appropriate for the symbol's type. The DWARF
21783 standard (v4) is not entirely clear about the meaning of using
21784 DW_FORM_dataN for a constant with a signed type, where the type is
21785 wider than the data. The conclusion of a discussion on the DWARF
21786 list was that this is unspecified. We choose to always zero-extend
21787 because that is the interpretation long in use by GCC. */
21790 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
21791 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
21793 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21794 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
21795 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
21796 LONGEST l
= attr
->constant_value (0);
21798 if (bits
< sizeof (*value
) * 8)
21800 l
&= ((LONGEST
) 1 << bits
) - 1;
21803 else if (bits
== sizeof (*value
) * 8)
21807 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
21808 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
21815 /* Read a constant value from an attribute. Either set *VALUE, or if
21816 the value does not fit in *VALUE, set *BYTES - either already
21817 allocated on the objfile obstack, or newly allocated on OBSTACK,
21818 or, set *BATON, if we translated the constant to a location
21822 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
21823 const char *name
, struct obstack
*obstack
,
21824 struct dwarf2_cu
*cu
,
21825 LONGEST
*value
, const gdb_byte
**bytes
,
21826 struct dwarf2_locexpr_baton
**baton
)
21828 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21829 struct objfile
*objfile
= per_objfile
->objfile
;
21830 struct comp_unit_head
*cu_header
= &cu
->header
;
21831 struct dwarf_block
*blk
;
21832 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
21833 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
21839 switch (attr
->form
)
21842 case DW_FORM_addrx
:
21843 case DW_FORM_GNU_addr_index
:
21847 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
21848 dwarf2_const_value_length_mismatch_complaint (name
,
21849 cu_header
->addr_size
,
21850 TYPE_LENGTH (type
));
21851 /* Symbols of this form are reasonably rare, so we just
21852 piggyback on the existing location code rather than writing
21853 a new implementation of symbol_computed_ops. */
21854 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
21855 (*baton
)->per_objfile
= per_objfile
;
21856 (*baton
)->per_cu
= cu
->per_cu
;
21857 gdb_assert ((*baton
)->per_cu
);
21859 (*baton
)->size
= 2 + cu_header
->addr_size
;
21860 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
21861 (*baton
)->data
= data
;
21863 data
[0] = DW_OP_addr
;
21864 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
21865 byte_order
, attr
->as_address ());
21866 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
21869 case DW_FORM_string
:
21872 case DW_FORM_GNU_str_index
:
21873 case DW_FORM_GNU_strp_alt
:
21874 /* The string is already allocated on the objfile obstack, point
21876 *bytes
= (const gdb_byte
*) attr
->as_string ();
21878 case DW_FORM_block1
:
21879 case DW_FORM_block2
:
21880 case DW_FORM_block4
:
21881 case DW_FORM_block
:
21882 case DW_FORM_exprloc
:
21883 case DW_FORM_data16
:
21884 blk
= attr
->as_block ();
21885 if (TYPE_LENGTH (type
) != blk
->size
)
21886 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
21887 TYPE_LENGTH (type
));
21888 *bytes
= blk
->data
;
21891 /* The DW_AT_const_value attributes are supposed to carry the
21892 symbol's value "represented as it would be on the target
21893 architecture." By the time we get here, it's already been
21894 converted to host endianness, so we just need to sign- or
21895 zero-extend it as appropriate. */
21896 case DW_FORM_data1
:
21897 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
21899 case DW_FORM_data2
:
21900 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
21902 case DW_FORM_data4
:
21903 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
21905 case DW_FORM_data8
:
21906 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
21909 case DW_FORM_sdata
:
21910 case DW_FORM_implicit_const
:
21911 *value
= attr
->as_signed ();
21914 case DW_FORM_udata
:
21915 *value
= attr
->as_unsigned ();
21919 complaint (_("unsupported const value attribute form: '%s'"),
21920 dwarf_form_name (attr
->form
));
21927 /* Copy constant value from an attribute to a symbol. */
21930 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
21931 struct dwarf2_cu
*cu
)
21933 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21935 const gdb_byte
*bytes
;
21936 struct dwarf2_locexpr_baton
*baton
;
21938 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
21939 sym
->print_name (),
21940 &objfile
->objfile_obstack
, cu
,
21941 &value
, &bytes
, &baton
);
21945 SYMBOL_LOCATION_BATON (sym
) = baton
;
21946 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
21948 else if (bytes
!= NULL
)
21950 SYMBOL_VALUE_BYTES (sym
) = bytes
;
21951 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
21955 SYMBOL_VALUE (sym
) = value
;
21956 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
21960 /* Return the type of the die in question using its DW_AT_type attribute. */
21962 static struct type
*
21963 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
21965 struct attribute
*type_attr
;
21967 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
21970 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21971 /* A missing DW_AT_type represents a void type. */
21972 return objfile_type (objfile
)->builtin_void
;
21975 return lookup_die_type (die
, type_attr
, cu
);
21978 /* True iff CU's producer generates GNAT Ada auxiliary information
21979 that allows to find parallel types through that information instead
21980 of having to do expensive parallel lookups by type name. */
21983 need_gnat_info (struct dwarf2_cu
*cu
)
21985 /* Assume that the Ada compiler was GNAT, which always produces
21986 the auxiliary information. */
21987 return (cu
->language
== language_ada
);
21990 /* Return the auxiliary type of the die in question using its
21991 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
21992 attribute is not present. */
21994 static struct type
*
21995 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
21997 struct attribute
*type_attr
;
21999 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22003 return lookup_die_type (die
, type_attr
, cu
);
22006 /* If DIE has a descriptive_type attribute, then set the TYPE's
22007 descriptive type accordingly. */
22010 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22011 struct dwarf2_cu
*cu
)
22013 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22015 if (descriptive_type
)
22017 ALLOCATE_GNAT_AUX_TYPE (type
);
22018 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22022 /* Return the containing type of the die in question using its
22023 DW_AT_containing_type attribute. */
22025 static struct type
*
22026 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22028 struct attribute
*type_attr
;
22029 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22031 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22033 error (_("Dwarf Error: Problem turning containing type into gdb type "
22034 "[in module %s]"), objfile_name (objfile
));
22036 return lookup_die_type (die
, type_attr
, cu
);
22039 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22041 static struct type
*
22042 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22044 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22045 struct objfile
*objfile
= per_objfile
->objfile
;
22048 std::string message
22049 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22050 objfile_name (objfile
),
22051 sect_offset_str (cu
->header
.sect_off
),
22052 sect_offset_str (die
->sect_off
));
22053 saved
= obstack_strdup (&objfile
->objfile_obstack
, message
);
22055 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22058 /* Look up the type of DIE in CU using its type attribute ATTR.
22059 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22060 DW_AT_containing_type.
22061 If there is no type substitute an error marker. */
22063 static struct type
*
22064 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22065 struct dwarf2_cu
*cu
)
22067 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22068 struct objfile
*objfile
= per_objfile
->objfile
;
22069 struct type
*this_type
;
22071 gdb_assert (attr
->name
== DW_AT_type
22072 || attr
->name
== DW_AT_GNAT_descriptive_type
22073 || attr
->name
== DW_AT_containing_type
);
22075 /* First see if we have it cached. */
22077 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22079 struct dwarf2_per_cu_data
*per_cu
;
22080 sect_offset sect_off
= attr
->get_ref_die_offset ();
22082 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1, per_objfile
);
22083 this_type
= get_die_type_at_offset (sect_off
, per_cu
, per_objfile
);
22085 else if (attr
->form_is_ref ())
22087 sect_offset sect_off
= attr
->get_ref_die_offset ();
22089 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, per_objfile
);
22091 else if (attr
->form
== DW_FORM_ref_sig8
)
22093 ULONGEST signature
= attr
->as_signature ();
22095 return get_signatured_type (die
, signature
, cu
);
22099 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22100 " at %s [in module %s]"),
22101 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22102 objfile_name (objfile
));
22103 return build_error_marker_type (cu
, die
);
22106 /* If not cached we need to read it in. */
22108 if (this_type
== NULL
)
22110 struct die_info
*type_die
= NULL
;
22111 struct dwarf2_cu
*type_cu
= cu
;
22113 if (attr
->form_is_ref ())
22114 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22115 if (type_die
== NULL
)
22116 return build_error_marker_type (cu
, die
);
22117 /* If we find the type now, it's probably because the type came
22118 from an inter-CU reference and the type's CU got expanded before
22120 this_type
= read_type_die (type_die
, type_cu
);
22123 /* If we still don't have a type use an error marker. */
22125 if (this_type
== NULL
)
22126 return build_error_marker_type (cu
, die
);
22131 /* Return the type in DIE, CU.
22132 Returns NULL for invalid types.
22134 This first does a lookup in die_type_hash,
22135 and only reads the die in if necessary.
22137 NOTE: This can be called when reading in partial or full symbols. */
22139 static struct type
*
22140 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22142 struct type
*this_type
;
22144 this_type
= get_die_type (die
, cu
);
22148 return read_type_die_1 (die
, cu
);
22151 /* Read the type in DIE, CU.
22152 Returns NULL for invalid types. */
22154 static struct type
*
22155 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22157 struct type
*this_type
= NULL
;
22161 case DW_TAG_class_type
:
22162 case DW_TAG_interface_type
:
22163 case DW_TAG_structure_type
:
22164 case DW_TAG_union_type
:
22165 this_type
= read_structure_type (die
, cu
);
22167 case DW_TAG_enumeration_type
:
22168 this_type
= read_enumeration_type (die
, cu
);
22170 case DW_TAG_subprogram
:
22171 case DW_TAG_subroutine_type
:
22172 case DW_TAG_inlined_subroutine
:
22173 this_type
= read_subroutine_type (die
, cu
);
22175 case DW_TAG_array_type
:
22176 this_type
= read_array_type (die
, cu
);
22178 case DW_TAG_set_type
:
22179 this_type
= read_set_type (die
, cu
);
22181 case DW_TAG_pointer_type
:
22182 this_type
= read_tag_pointer_type (die
, cu
);
22184 case DW_TAG_ptr_to_member_type
:
22185 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22187 case DW_TAG_reference_type
:
22188 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22190 case DW_TAG_rvalue_reference_type
:
22191 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22193 case DW_TAG_const_type
:
22194 this_type
= read_tag_const_type (die
, cu
);
22196 case DW_TAG_volatile_type
:
22197 this_type
= read_tag_volatile_type (die
, cu
);
22199 case DW_TAG_restrict_type
:
22200 this_type
= read_tag_restrict_type (die
, cu
);
22202 case DW_TAG_string_type
:
22203 this_type
= read_tag_string_type (die
, cu
);
22205 case DW_TAG_typedef
:
22206 this_type
= read_typedef (die
, cu
);
22208 case DW_TAG_subrange_type
:
22209 this_type
= read_subrange_type (die
, cu
);
22211 case DW_TAG_base_type
:
22212 this_type
= read_base_type (die
, cu
);
22214 case DW_TAG_unspecified_type
:
22215 this_type
= read_unspecified_type (die
, cu
);
22217 case DW_TAG_namespace
:
22218 this_type
= read_namespace_type (die
, cu
);
22220 case DW_TAG_module
:
22221 this_type
= read_module_type (die
, cu
);
22223 case DW_TAG_atomic_type
:
22224 this_type
= read_tag_atomic_type (die
, cu
);
22227 complaint (_("unexpected tag in read_type_die: '%s'"),
22228 dwarf_tag_name (die
->tag
));
22235 /* See if we can figure out if the class lives in a namespace. We do
22236 this by looking for a member function; its demangled name will
22237 contain namespace info, if there is any.
22238 Return the computed name or NULL.
22239 Space for the result is allocated on the objfile's obstack.
22240 This is the full-die version of guess_partial_die_structure_name.
22241 In this case we know DIE has no useful parent. */
22243 static const char *
22244 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22246 struct die_info
*spec_die
;
22247 struct dwarf2_cu
*spec_cu
;
22248 struct die_info
*child
;
22249 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22252 spec_die
= die_specification (die
, &spec_cu
);
22253 if (spec_die
!= NULL
)
22259 for (child
= die
->child
;
22261 child
= child
->sibling
)
22263 if (child
->tag
== DW_TAG_subprogram
)
22265 const char *linkage_name
= dw2_linkage_name (child
, cu
);
22267 if (linkage_name
!= NULL
)
22269 gdb::unique_xmalloc_ptr
<char> actual_name
22270 (cu
->language_defn
->class_name_from_physname (linkage_name
));
22271 const char *name
= NULL
;
22273 if (actual_name
!= NULL
)
22275 const char *die_name
= dwarf2_name (die
, cu
);
22277 if (die_name
!= NULL
22278 && strcmp (die_name
, actual_name
.get ()) != 0)
22280 /* Strip off the class name from the full name.
22281 We want the prefix. */
22282 int die_name_len
= strlen (die_name
);
22283 int actual_name_len
= strlen (actual_name
.get ());
22284 const char *ptr
= actual_name
.get ();
22286 /* Test for '::' as a sanity check. */
22287 if (actual_name_len
> die_name_len
+ 2
22288 && ptr
[actual_name_len
- die_name_len
- 1] == ':')
22289 name
= obstack_strndup (
22290 &objfile
->per_bfd
->storage_obstack
,
22291 ptr
, actual_name_len
- die_name_len
- 2);
22302 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22303 prefix part in such case. See
22304 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22306 static const char *
22307 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22309 struct attribute
*attr
;
22312 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
22313 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
22316 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
22319 attr
= dw2_linkage_name_attr (die
, cu
);
22320 const char *attr_name
= attr
->as_string ();
22321 if (attr
== NULL
|| attr_name
== NULL
)
22324 /* dwarf2_name had to be already called. */
22325 gdb_assert (attr
->canonical_string_p ());
22327 /* Strip the base name, keep any leading namespaces/classes. */
22328 base
= strrchr (attr_name
, ':');
22329 if (base
== NULL
|| base
== attr_name
|| base
[-1] != ':')
22332 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22333 return obstack_strndup (&objfile
->per_bfd
->storage_obstack
,
22335 &base
[-1] - attr_name
);
22338 /* Return the name of the namespace/class that DIE is defined within,
22339 or "" if we can't tell. The caller should not xfree the result.
22341 For example, if we're within the method foo() in the following
22351 then determine_prefix on foo's die will return "N::C". */
22353 static const char *
22354 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22356 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22357 struct die_info
*parent
, *spec_die
;
22358 struct dwarf2_cu
*spec_cu
;
22359 struct type
*parent_type
;
22360 const char *retval
;
22362 if (cu
->language
!= language_cplus
22363 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
22364 && cu
->language
!= language_rust
)
22367 retval
= anonymous_struct_prefix (die
, cu
);
22371 /* We have to be careful in the presence of DW_AT_specification.
22372 For example, with GCC 3.4, given the code
22376 // Definition of N::foo.
22380 then we'll have a tree of DIEs like this:
22382 1: DW_TAG_compile_unit
22383 2: DW_TAG_namespace // N
22384 3: DW_TAG_subprogram // declaration of N::foo
22385 4: DW_TAG_subprogram // definition of N::foo
22386 DW_AT_specification // refers to die #3
22388 Thus, when processing die #4, we have to pretend that we're in
22389 the context of its DW_AT_specification, namely the contex of die
22392 spec_die
= die_specification (die
, &spec_cu
);
22393 if (spec_die
== NULL
)
22394 parent
= die
->parent
;
22397 parent
= spec_die
->parent
;
22401 if (parent
== NULL
)
22403 else if (parent
->building_fullname
)
22406 const char *parent_name
;
22408 /* It has been seen on RealView 2.2 built binaries,
22409 DW_TAG_template_type_param types actually _defined_ as
22410 children of the parent class:
22413 template class <class Enum> Class{};
22414 Class<enum E> class_e;
22416 1: DW_TAG_class_type (Class)
22417 2: DW_TAG_enumeration_type (E)
22418 3: DW_TAG_enumerator (enum1:0)
22419 3: DW_TAG_enumerator (enum2:1)
22421 2: DW_TAG_template_type_param
22422 DW_AT_type DW_FORM_ref_udata (E)
22424 Besides being broken debug info, it can put GDB into an
22425 infinite loop. Consider:
22427 When we're building the full name for Class<E>, we'll start
22428 at Class, and go look over its template type parameters,
22429 finding E. We'll then try to build the full name of E, and
22430 reach here. We're now trying to build the full name of E,
22431 and look over the parent DIE for containing scope. In the
22432 broken case, if we followed the parent DIE of E, we'd again
22433 find Class, and once again go look at its template type
22434 arguments, etc., etc. Simply don't consider such parent die
22435 as source-level parent of this die (it can't be, the language
22436 doesn't allow it), and break the loop here. */
22437 name
= dwarf2_name (die
, cu
);
22438 parent_name
= dwarf2_name (parent
, cu
);
22439 complaint (_("template param type '%s' defined within parent '%s'"),
22440 name
? name
: "<unknown>",
22441 parent_name
? parent_name
: "<unknown>");
22445 switch (parent
->tag
)
22447 case DW_TAG_namespace
:
22448 parent_type
= read_type_die (parent
, cu
);
22449 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22450 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22451 Work around this problem here. */
22452 if (cu
->language
== language_cplus
22453 && strcmp (parent_type
->name (), "::") == 0)
22455 /* We give a name to even anonymous namespaces. */
22456 return parent_type
->name ();
22457 case DW_TAG_class_type
:
22458 case DW_TAG_interface_type
:
22459 case DW_TAG_structure_type
:
22460 case DW_TAG_union_type
:
22461 case DW_TAG_module
:
22462 parent_type
= read_type_die (parent
, cu
);
22463 if (parent_type
->name () != NULL
)
22464 return parent_type
->name ();
22466 /* An anonymous structure is only allowed non-static data
22467 members; no typedefs, no member functions, et cetera.
22468 So it does not need a prefix. */
22470 case DW_TAG_compile_unit
:
22471 case DW_TAG_partial_unit
:
22472 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22473 if (cu
->language
== language_cplus
22474 && !per_objfile
->per_bfd
->types
.empty ()
22475 && die
->child
!= NULL
22476 && (die
->tag
== DW_TAG_class_type
22477 || die
->tag
== DW_TAG_structure_type
22478 || die
->tag
== DW_TAG_union_type
))
22480 const char *name
= guess_full_die_structure_name (die
, cu
);
22485 case DW_TAG_subprogram
:
22486 /* Nested subroutines in Fortran get a prefix with the name
22487 of the parent's subroutine. */
22488 if (cu
->language
== language_fortran
)
22490 if ((die
->tag
== DW_TAG_subprogram
)
22491 && (dwarf2_name (parent
, cu
) != NULL
))
22492 return dwarf2_name (parent
, cu
);
22494 return determine_prefix (parent
, cu
);
22495 case DW_TAG_enumeration_type
:
22496 parent_type
= read_type_die (parent
, cu
);
22497 if (TYPE_DECLARED_CLASS (parent_type
))
22499 if (parent_type
->name () != NULL
)
22500 return parent_type
->name ();
22503 /* Fall through. */
22505 return determine_prefix (parent
, cu
);
22509 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22510 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22511 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22512 an obconcat, otherwise allocate storage for the result. The CU argument is
22513 used to determine the language and hence, the appropriate separator. */
22515 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22518 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
22519 int physname
, struct dwarf2_cu
*cu
)
22521 const char *lead
= "";
22524 if (suffix
== NULL
|| suffix
[0] == '\0'
22525 || prefix
== NULL
|| prefix
[0] == '\0')
22527 else if (cu
->language
== language_d
)
22529 /* For D, the 'main' function could be defined in any module, but it
22530 should never be prefixed. */
22531 if (strcmp (suffix
, "D main") == 0)
22539 else if (cu
->language
== language_fortran
&& physname
)
22541 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22542 DW_AT_MIPS_linkage_name is preferred and used instead. */
22550 if (prefix
== NULL
)
22552 if (suffix
== NULL
)
22559 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
22561 strcpy (retval
, lead
);
22562 strcat (retval
, prefix
);
22563 strcat (retval
, sep
);
22564 strcat (retval
, suffix
);
22569 /* We have an obstack. */
22570 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
22574 /* Get name of a die, return NULL if not found. */
22576 static const char *
22577 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
22578 struct objfile
*objfile
)
22580 if (name
&& cu
->language
== language_cplus
)
22582 gdb::unique_xmalloc_ptr
<char> canon_name
22583 = cp_canonicalize_string (name
);
22585 if (canon_name
!= nullptr)
22586 name
= objfile
->intern (canon_name
.get ());
22592 /* Get name of a die, return NULL if not found.
22593 Anonymous namespaces are converted to their magic string. */
22595 static const char *
22596 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22598 struct attribute
*attr
;
22599 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22601 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
22602 const char *attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
22603 if (attr_name
== nullptr
22604 && die
->tag
!= DW_TAG_namespace
22605 && die
->tag
!= DW_TAG_class_type
22606 && die
->tag
!= DW_TAG_interface_type
22607 && die
->tag
!= DW_TAG_structure_type
22608 && die
->tag
!= DW_TAG_union_type
)
22613 case DW_TAG_compile_unit
:
22614 case DW_TAG_partial_unit
:
22615 /* Compilation units have a DW_AT_name that is a filename, not
22616 a source language identifier. */
22617 case DW_TAG_enumeration_type
:
22618 case DW_TAG_enumerator
:
22619 /* These tags always have simple identifiers already; no need
22620 to canonicalize them. */
22623 case DW_TAG_namespace
:
22624 if (attr_name
!= nullptr)
22626 return CP_ANONYMOUS_NAMESPACE_STR
;
22628 case DW_TAG_class_type
:
22629 case DW_TAG_interface_type
:
22630 case DW_TAG_structure_type
:
22631 case DW_TAG_union_type
:
22632 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22633 structures or unions. These were of the form "._%d" in GCC 4.1,
22634 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22635 and GCC 4.4. We work around this problem by ignoring these. */
22636 if (attr_name
!= nullptr
22637 && (startswith (attr_name
, "._")
22638 || startswith (attr_name
, "<anonymous")))
22641 /* GCC might emit a nameless typedef that has a linkage name. See
22642 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22643 if (!attr
|| attr_name
== NULL
)
22645 attr
= dw2_linkage_name_attr (die
, cu
);
22646 attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
22647 if (attr
== NULL
|| attr_name
== NULL
)
22650 /* Avoid demangling attr_name the second time on a second
22651 call for the same DIE. */
22652 if (!attr
->canonical_string_p ())
22654 gdb::unique_xmalloc_ptr
<char> demangled
22655 (gdb_demangle (attr_name
, DMGL_TYPES
));
22656 if (demangled
== nullptr)
22659 attr
->set_string_canonical (objfile
->intern (demangled
.get ()));
22660 attr_name
= attr
->as_string ();
22663 /* Strip any leading namespaces/classes, keep only the
22664 base name. DW_AT_name for named DIEs does not
22665 contain the prefixes. */
22666 const char *base
= strrchr (attr_name
, ':');
22667 if (base
&& base
> attr_name
&& base
[-1] == ':')
22678 if (!attr
->canonical_string_p ())
22679 attr
->set_string_canonical (dwarf2_canonicalize_name (attr_name
, cu
,
22681 return attr
->as_string ();
22684 /* Return the die that this die in an extension of, or NULL if there
22685 is none. *EXT_CU is the CU containing DIE on input, and the CU
22686 containing the return value on output. */
22688 static struct die_info
*
22689 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
22691 struct attribute
*attr
;
22693 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
22697 return follow_die_ref (die
, attr
, ext_cu
);
22701 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
22705 print_spaces (indent
, f
);
22706 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
22707 dwarf_tag_name (die
->tag
), die
->abbrev
,
22708 sect_offset_str (die
->sect_off
));
22710 if (die
->parent
!= NULL
)
22712 print_spaces (indent
, f
);
22713 fprintf_unfiltered (f
, " parent at offset: %s\n",
22714 sect_offset_str (die
->parent
->sect_off
));
22717 print_spaces (indent
, f
);
22718 fprintf_unfiltered (f
, " has children: %s\n",
22719 dwarf_bool_name (die
->child
!= NULL
));
22721 print_spaces (indent
, f
);
22722 fprintf_unfiltered (f
, " attributes:\n");
22724 for (i
= 0; i
< die
->num_attrs
; ++i
)
22726 print_spaces (indent
, f
);
22727 fprintf_unfiltered (f
, " %s (%s) ",
22728 dwarf_attr_name (die
->attrs
[i
].name
),
22729 dwarf_form_name (die
->attrs
[i
].form
));
22731 switch (die
->attrs
[i
].form
)
22734 case DW_FORM_addrx
:
22735 case DW_FORM_GNU_addr_index
:
22736 fprintf_unfiltered (f
, "address: ");
22737 fputs_filtered (hex_string (die
->attrs
[i
].as_address ()), f
);
22739 case DW_FORM_block2
:
22740 case DW_FORM_block4
:
22741 case DW_FORM_block
:
22742 case DW_FORM_block1
:
22743 fprintf_unfiltered (f
, "block: size %s",
22744 pulongest (die
->attrs
[i
].as_block ()->size
));
22746 case DW_FORM_exprloc
:
22747 fprintf_unfiltered (f
, "expression: size %s",
22748 pulongest (die
->attrs
[i
].as_block ()->size
));
22750 case DW_FORM_data16
:
22751 fprintf_unfiltered (f
, "constant of 16 bytes");
22753 case DW_FORM_ref_addr
:
22754 fprintf_unfiltered (f
, "ref address: ");
22755 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
22757 case DW_FORM_GNU_ref_alt
:
22758 fprintf_unfiltered (f
, "alt ref address: ");
22759 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
22765 case DW_FORM_ref_udata
:
22766 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
22767 (long) (die
->attrs
[i
].as_unsigned ()));
22769 case DW_FORM_data1
:
22770 case DW_FORM_data2
:
22771 case DW_FORM_data4
:
22772 case DW_FORM_data8
:
22773 case DW_FORM_udata
:
22774 fprintf_unfiltered (f
, "constant: %s",
22775 pulongest (die
->attrs
[i
].as_unsigned ()));
22777 case DW_FORM_sec_offset
:
22778 fprintf_unfiltered (f
, "section offset: %s",
22779 pulongest (die
->attrs
[i
].as_unsigned ()));
22781 case DW_FORM_ref_sig8
:
22782 fprintf_unfiltered (f
, "signature: %s",
22783 hex_string (die
->attrs
[i
].as_signature ()));
22785 case DW_FORM_string
:
22787 case DW_FORM_line_strp
:
22789 case DW_FORM_GNU_str_index
:
22790 case DW_FORM_GNU_strp_alt
:
22791 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
22792 die
->attrs
[i
].as_string ()
22793 ? die
->attrs
[i
].as_string () : "",
22794 die
->attrs
[i
].canonical_string_p () ? "is" : "not");
22797 if (die
->attrs
[i
].as_boolean ())
22798 fprintf_unfiltered (f
, "flag: TRUE");
22800 fprintf_unfiltered (f
, "flag: FALSE");
22802 case DW_FORM_flag_present
:
22803 fprintf_unfiltered (f
, "flag: TRUE");
22805 case DW_FORM_indirect
:
22806 /* The reader will have reduced the indirect form to
22807 the "base form" so this form should not occur. */
22808 fprintf_unfiltered (f
,
22809 "unexpected attribute form: DW_FORM_indirect");
22811 case DW_FORM_sdata
:
22812 case DW_FORM_implicit_const
:
22813 fprintf_unfiltered (f
, "constant: %s",
22814 plongest (die
->attrs
[i
].as_signed ()));
22817 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
22818 die
->attrs
[i
].form
);
22821 fprintf_unfiltered (f
, "\n");
22826 dump_die_for_error (struct die_info
*die
)
22828 dump_die_shallow (gdb_stderr
, 0, die
);
22832 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
22834 int indent
= level
* 4;
22836 gdb_assert (die
!= NULL
);
22838 if (level
>= max_level
)
22841 dump_die_shallow (f
, indent
, die
);
22843 if (die
->child
!= NULL
)
22845 print_spaces (indent
, f
);
22846 fprintf_unfiltered (f
, " Children:");
22847 if (level
+ 1 < max_level
)
22849 fprintf_unfiltered (f
, "\n");
22850 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
22854 fprintf_unfiltered (f
,
22855 " [not printed, max nesting level reached]\n");
22859 if (die
->sibling
!= NULL
&& level
> 0)
22861 dump_die_1 (f
, level
, max_level
, die
->sibling
);
22865 /* This is called from the pdie macro in gdbinit.in.
22866 It's not static so gcc will keep a copy callable from gdb. */
22869 dump_die (struct die_info
*die
, int max_level
)
22871 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
22875 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
22879 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
22880 to_underlying (die
->sect_off
),
22886 /* Follow reference or signature attribute ATTR of SRC_DIE.
22887 On entry *REF_CU is the CU of SRC_DIE.
22888 On exit *REF_CU is the CU of the result. */
22890 static struct die_info
*
22891 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
22892 struct dwarf2_cu
**ref_cu
)
22894 struct die_info
*die
;
22896 if (attr
->form_is_ref ())
22897 die
= follow_die_ref (src_die
, attr
, ref_cu
);
22898 else if (attr
->form
== DW_FORM_ref_sig8
)
22899 die
= follow_die_sig (src_die
, attr
, ref_cu
);
22902 dump_die_for_error (src_die
);
22903 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
22904 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
22910 /* Follow reference OFFSET.
22911 On entry *REF_CU is the CU of the source die referencing OFFSET.
22912 On exit *REF_CU is the CU of the result.
22913 Returns NULL if OFFSET is invalid. */
22915 static struct die_info
*
22916 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
22917 struct dwarf2_cu
**ref_cu
)
22919 struct die_info temp_die
;
22920 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
22921 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22923 gdb_assert (cu
->per_cu
!= NULL
);
22927 if (cu
->per_cu
->is_debug_types
)
22929 /* .debug_types CUs cannot reference anything outside their CU.
22930 If they need to, they have to reference a signatured type via
22931 DW_FORM_ref_sig8. */
22932 if (!cu
->header
.offset_in_cu_p (sect_off
))
22935 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
22936 || !cu
->header
.offset_in_cu_p (sect_off
))
22938 struct dwarf2_per_cu_data
*per_cu
;
22940 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
22943 /* If necessary, add it to the queue and load its DIEs. */
22944 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
))
22945 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
22946 false, cu
->language
);
22948 target_cu
= per_objfile
->get_cu (per_cu
);
22950 else if (cu
->dies
== NULL
)
22952 /* We're loading full DIEs during partial symbol reading. */
22953 gdb_assert (per_objfile
->per_bfd
->reading_partial_symbols
);
22954 load_full_comp_unit (cu
->per_cu
, per_objfile
, cu
, false,
22958 *ref_cu
= target_cu
;
22959 temp_die
.sect_off
= sect_off
;
22961 if (target_cu
!= cu
)
22962 target_cu
->ancestor
= cu
;
22964 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
22966 to_underlying (sect_off
));
22969 /* Follow reference attribute ATTR of SRC_DIE.
22970 On entry *REF_CU is the CU of SRC_DIE.
22971 On exit *REF_CU is the CU of the result. */
22973 static struct die_info
*
22974 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
22975 struct dwarf2_cu
**ref_cu
)
22977 sect_offset sect_off
= attr
->get_ref_die_offset ();
22978 struct dwarf2_cu
*cu
= *ref_cu
;
22979 struct die_info
*die
;
22981 die
= follow_die_offset (sect_off
,
22982 (attr
->form
== DW_FORM_GNU_ref_alt
22983 || cu
->per_cu
->is_dwz
),
22986 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
22987 "at %s [in module %s]"),
22988 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
22989 objfile_name (cu
->per_objfile
->objfile
));
22996 struct dwarf2_locexpr_baton
22997 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
22998 dwarf2_per_cu_data
*per_cu
,
22999 dwarf2_per_objfile
*per_objfile
,
23000 gdb::function_view
<CORE_ADDR ()> get_frame_pc
,
23001 bool resolve_abstract_p
)
23003 struct die_info
*die
;
23004 struct attribute
*attr
;
23005 struct dwarf2_locexpr_baton retval
;
23006 struct objfile
*objfile
= per_objfile
->objfile
;
23008 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23010 cu
= load_cu (per_cu
, per_objfile
, false);
23014 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23015 Instead just throw an error, not much else we can do. */
23016 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23017 sect_offset_str (sect_off
), objfile_name (objfile
));
23020 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23022 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23023 sect_offset_str (sect_off
), objfile_name (objfile
));
23025 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23026 if (!attr
&& resolve_abstract_p
23027 && (per_objfile
->per_bfd
->abstract_to_concrete
.find (die
->sect_off
)
23028 != per_objfile
->per_bfd
->abstract_to_concrete
.end ()))
23030 CORE_ADDR pc
= get_frame_pc ();
23031 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
23032 struct gdbarch
*gdbarch
= objfile
->arch ();
23034 for (const auto &cand_off
23035 : per_objfile
->per_bfd
->abstract_to_concrete
[die
->sect_off
])
23037 struct dwarf2_cu
*cand_cu
= cu
;
23038 struct die_info
*cand
23039 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23042 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23045 CORE_ADDR pc_low
, pc_high
;
23046 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23047 if (pc_low
== ((CORE_ADDR
) -1))
23049 pc_low
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_low
+ baseaddr
);
23050 pc_high
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_high
+ baseaddr
);
23051 if (!(pc_low
<= pc
&& pc
< pc_high
))
23055 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23062 /* DWARF: "If there is no such attribute, then there is no effect.".
23063 DATA is ignored if SIZE is 0. */
23065 retval
.data
= NULL
;
23068 else if (attr
->form_is_section_offset ())
23070 struct dwarf2_loclist_baton loclist_baton
;
23071 CORE_ADDR pc
= get_frame_pc ();
23074 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23076 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23078 retval
.size
= size
;
23082 if (!attr
->form_is_block ())
23083 error (_("Dwarf Error: DIE at %s referenced in module %s "
23084 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23085 sect_offset_str (sect_off
), objfile_name (objfile
));
23087 struct dwarf_block
*block
= attr
->as_block ();
23088 retval
.data
= block
->data
;
23089 retval
.size
= block
->size
;
23091 retval
.per_objfile
= per_objfile
;
23092 retval
.per_cu
= cu
->per_cu
;
23094 per_objfile
->age_comp_units ();
23101 struct dwarf2_locexpr_baton
23102 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23103 dwarf2_per_cu_data
*per_cu
,
23104 dwarf2_per_objfile
*per_objfile
,
23105 gdb::function_view
<CORE_ADDR ()> get_frame_pc
)
23107 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23109 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, per_objfile
,
23113 /* Write a constant of a given type as target-ordered bytes into
23116 static const gdb_byte
*
23117 write_constant_as_bytes (struct obstack
*obstack
,
23118 enum bfd_endian byte_order
,
23125 *len
= TYPE_LENGTH (type
);
23126 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23127 store_unsigned_integer (result
, *len
, byte_order
, value
);
23135 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23136 dwarf2_per_cu_data
*per_cu
,
23137 dwarf2_per_objfile
*per_objfile
,
23141 struct die_info
*die
;
23142 struct attribute
*attr
;
23143 const gdb_byte
*result
= NULL
;
23146 enum bfd_endian byte_order
;
23147 struct objfile
*objfile
= per_objfile
->objfile
;
23149 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23151 cu
= load_cu (per_cu
, per_objfile
, false);
23155 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23156 Instead just throw an error, not much else we can do. */
23157 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23158 sect_offset_str (sect_off
), objfile_name (objfile
));
23161 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23163 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23164 sect_offset_str (sect_off
), objfile_name (objfile
));
23166 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23170 byte_order
= (bfd_big_endian (objfile
->obfd
)
23171 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23173 switch (attr
->form
)
23176 case DW_FORM_addrx
:
23177 case DW_FORM_GNU_addr_index
:
23181 *len
= cu
->header
.addr_size
;
23182 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23183 store_unsigned_integer (tem
, *len
, byte_order
, attr
->as_address ());
23187 case DW_FORM_string
:
23190 case DW_FORM_GNU_str_index
:
23191 case DW_FORM_GNU_strp_alt
:
23192 /* The string is already allocated on the objfile obstack, point
23195 const char *attr_name
= attr
->as_string ();
23196 result
= (const gdb_byte
*) attr_name
;
23197 *len
= strlen (attr_name
);
23200 case DW_FORM_block1
:
23201 case DW_FORM_block2
:
23202 case DW_FORM_block4
:
23203 case DW_FORM_block
:
23204 case DW_FORM_exprloc
:
23205 case DW_FORM_data16
:
23207 struct dwarf_block
*block
= attr
->as_block ();
23208 result
= block
->data
;
23209 *len
= block
->size
;
23213 /* The DW_AT_const_value attributes are supposed to carry the
23214 symbol's value "represented as it would be on the target
23215 architecture." By the time we get here, it's already been
23216 converted to host endianness, so we just need to sign- or
23217 zero-extend it as appropriate. */
23218 case DW_FORM_data1
:
23219 type
= die_type (die
, cu
);
23220 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23221 if (result
== NULL
)
23222 result
= write_constant_as_bytes (obstack
, byte_order
,
23225 case DW_FORM_data2
:
23226 type
= die_type (die
, cu
);
23227 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23228 if (result
== NULL
)
23229 result
= write_constant_as_bytes (obstack
, byte_order
,
23232 case DW_FORM_data4
:
23233 type
= die_type (die
, cu
);
23234 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23235 if (result
== NULL
)
23236 result
= write_constant_as_bytes (obstack
, byte_order
,
23239 case DW_FORM_data8
:
23240 type
= die_type (die
, cu
);
23241 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23242 if (result
== NULL
)
23243 result
= write_constant_as_bytes (obstack
, byte_order
,
23247 case DW_FORM_sdata
:
23248 case DW_FORM_implicit_const
:
23249 type
= die_type (die
, cu
);
23250 result
= write_constant_as_bytes (obstack
, byte_order
,
23251 type
, attr
->as_signed (), len
);
23254 case DW_FORM_udata
:
23255 type
= die_type (die
, cu
);
23256 result
= write_constant_as_bytes (obstack
, byte_order
,
23257 type
, attr
->as_unsigned (), len
);
23261 complaint (_("unsupported const value attribute form: '%s'"),
23262 dwarf_form_name (attr
->form
));
23272 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
23273 dwarf2_per_cu_data
*per_cu
,
23274 dwarf2_per_objfile
*per_objfile
)
23276 struct die_info
*die
;
23278 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23280 cu
= load_cu (per_cu
, per_objfile
, false);
23285 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23289 return die_type (die
, cu
);
23295 dwarf2_get_die_type (cu_offset die_offset
,
23296 dwarf2_per_cu_data
*per_cu
,
23297 dwarf2_per_objfile
*per_objfile
)
23299 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
23300 return get_die_type_at_offset (die_offset_sect
, per_cu
, per_objfile
);
23303 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23304 On entry *REF_CU is the CU of SRC_DIE.
23305 On exit *REF_CU is the CU of the result.
23306 Returns NULL if the referenced DIE isn't found. */
23308 static struct die_info
*
23309 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
23310 struct dwarf2_cu
**ref_cu
)
23312 struct die_info temp_die
;
23313 struct dwarf2_cu
*sig_cu
, *cu
= *ref_cu
;
23314 struct die_info
*die
;
23315 dwarf2_per_objfile
*per_objfile
= (*ref_cu
)->per_objfile
;
23318 /* While it might be nice to assert sig_type->type == NULL here,
23319 we can get here for DW_AT_imported_declaration where we need
23320 the DIE not the type. */
23322 /* If necessary, add it to the queue and load its DIEs. */
23324 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, per_objfile
,
23326 read_signatured_type (sig_type
, per_objfile
);
23328 sig_cu
= per_objfile
->get_cu (&sig_type
->per_cu
);
23329 gdb_assert (sig_cu
!= NULL
);
23330 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
23331 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
23332 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
23333 to_underlying (temp_die
.sect_off
));
23336 /* For .gdb_index version 7 keep track of included TUs.
23337 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23338 if (per_objfile
->per_bfd
->index_table
!= NULL
23339 && per_objfile
->per_bfd
->index_table
->version
<= 7)
23341 (*ref_cu
)->per_cu
->imported_symtabs_push (sig_cu
->per_cu
);
23346 sig_cu
->ancestor
= cu
;
23354 /* Follow signatured type referenced by ATTR in SRC_DIE.
23355 On entry *REF_CU is the CU of SRC_DIE.
23356 On exit *REF_CU is the CU of the result.
23357 The result is the DIE of the type.
23358 If the referenced type cannot be found an error is thrown. */
23360 static struct die_info
*
23361 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23362 struct dwarf2_cu
**ref_cu
)
23364 ULONGEST signature
= attr
->as_signature ();
23365 struct signatured_type
*sig_type
;
23366 struct die_info
*die
;
23368 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
23370 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
23371 /* sig_type will be NULL if the signatured type is missing from
23373 if (sig_type
== NULL
)
23375 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23376 " from DIE at %s [in module %s]"),
23377 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23378 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23381 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
23384 dump_die_for_error (src_die
);
23385 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23386 " from DIE at %s [in module %s]"),
23387 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23388 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23394 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23395 reading in and processing the type unit if necessary. */
23397 static struct type
*
23398 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
23399 struct dwarf2_cu
*cu
)
23401 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23402 struct signatured_type
*sig_type
;
23403 struct dwarf2_cu
*type_cu
;
23404 struct die_info
*type_die
;
23407 sig_type
= lookup_signatured_type (cu
, signature
);
23408 /* sig_type will be NULL if the signatured type is missing from
23410 if (sig_type
== NULL
)
23412 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23413 " from DIE at %s [in module %s]"),
23414 hex_string (signature
), sect_offset_str (die
->sect_off
),
23415 objfile_name (per_objfile
->objfile
));
23416 return build_error_marker_type (cu
, die
);
23419 /* If we already know the type we're done. */
23420 type
= per_objfile
->get_type_for_signatured_type (sig_type
);
23421 if (type
!= nullptr)
23425 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
23426 if (type_die
!= NULL
)
23428 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23429 is created. This is important, for example, because for c++ classes
23430 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23431 type
= read_type_die (type_die
, type_cu
);
23434 complaint (_("Dwarf Error: Cannot build signatured type %s"
23435 " referenced from DIE at %s [in module %s]"),
23436 hex_string (signature
), sect_offset_str (die
->sect_off
),
23437 objfile_name (per_objfile
->objfile
));
23438 type
= build_error_marker_type (cu
, die
);
23443 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23444 " from DIE at %s [in module %s]"),
23445 hex_string (signature
), sect_offset_str (die
->sect_off
),
23446 objfile_name (per_objfile
->objfile
));
23447 type
= build_error_marker_type (cu
, die
);
23450 per_objfile
->set_type_for_signatured_type (sig_type
, type
);
23455 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23456 reading in and processing the type unit if necessary. */
23458 static struct type
*
23459 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
23460 struct dwarf2_cu
*cu
) /* ARI: editCase function */
23462 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23463 if (attr
->form_is_ref ())
23465 struct dwarf2_cu
*type_cu
= cu
;
23466 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
23468 return read_type_die (type_die
, type_cu
);
23470 else if (attr
->form
== DW_FORM_ref_sig8
)
23472 return get_signatured_type (die
, attr
->as_signature (), cu
);
23476 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23478 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23479 " at %s [in module %s]"),
23480 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
23481 objfile_name (per_objfile
->objfile
));
23482 return build_error_marker_type (cu
, die
);
23486 /* Load the DIEs associated with type unit PER_CU into memory. */
23489 load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
23490 dwarf2_per_objfile
*per_objfile
)
23492 struct signatured_type
*sig_type
;
23494 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23495 gdb_assert (! per_cu
->type_unit_group_p ());
23497 /* We have the per_cu, but we need the signatured_type.
23498 Fortunately this is an easy translation. */
23499 gdb_assert (per_cu
->is_debug_types
);
23500 sig_type
= (struct signatured_type
*) per_cu
;
23502 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
23504 read_signatured_type (sig_type
, per_objfile
);
23506 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
23509 /* Read in a signatured type and build its CU and DIEs.
23510 If the type is a stub for the real type in a DWO file,
23511 read in the real type from the DWO file as well. */
23514 read_signatured_type (signatured_type
*sig_type
,
23515 dwarf2_per_objfile
*per_objfile
)
23517 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
23519 gdb_assert (per_cu
->is_debug_types
);
23520 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
23522 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
23524 if (!reader
.dummy_p
)
23526 struct dwarf2_cu
*cu
= reader
.cu
;
23527 const gdb_byte
*info_ptr
= reader
.info_ptr
;
23529 gdb_assert (cu
->die_hash
== NULL
);
23531 htab_create_alloc_ex (cu
->header
.length
/ 12,
23535 &cu
->comp_unit_obstack
,
23536 hashtab_obstack_allocate
,
23537 dummy_obstack_deallocate
);
23539 if (reader
.comp_unit_die
->has_children
)
23540 reader
.comp_unit_die
->child
23541 = read_die_and_siblings (&reader
, info_ptr
, &info_ptr
,
23542 reader
.comp_unit_die
);
23543 cu
->dies
= reader
.comp_unit_die
;
23544 /* comp_unit_die is not stored in die_hash, no need. */
23546 /* We try not to read any attributes in this function, because
23547 not all CUs needed for references have been loaded yet, and
23548 symbol table processing isn't initialized. But we have to
23549 set the CU language, or we won't be able to build types
23550 correctly. Similarly, if we do not read the producer, we can
23551 not apply producer-specific interpretation. */
23552 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
23557 sig_type
->per_cu
.tu_read
= 1;
23560 /* Decode simple location descriptions.
23561 Given a pointer to a dwarf block that defines a location, compute
23562 the location and return the value. If COMPUTED is non-null, it is
23563 set to true to indicate that decoding was successful, and false
23564 otherwise. If COMPUTED is null, then this function may emit a
23568 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
, bool *computed
)
23570 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
23572 size_t size
= blk
->size
;
23573 const gdb_byte
*data
= blk
->data
;
23574 CORE_ADDR stack
[64];
23576 unsigned int bytes_read
, unsnd
;
23579 if (computed
!= nullptr)
23585 stack
[++stacki
] = 0;
23624 stack
[++stacki
] = op
- DW_OP_lit0
;
23659 stack
[++stacki
] = op
- DW_OP_reg0
;
23662 if (computed
== nullptr)
23663 dwarf2_complex_location_expr_complaint ();
23670 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
23672 stack
[++stacki
] = unsnd
;
23675 if (computed
== nullptr)
23676 dwarf2_complex_location_expr_complaint ();
23683 stack
[++stacki
] = cu
->header
.read_address (objfile
->obfd
, &data
[i
],
23688 case DW_OP_const1u
:
23689 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
23693 case DW_OP_const1s
:
23694 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
23698 case DW_OP_const2u
:
23699 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
23703 case DW_OP_const2s
:
23704 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
23708 case DW_OP_const4u
:
23709 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
23713 case DW_OP_const4s
:
23714 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
23718 case DW_OP_const8u
:
23719 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
23724 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
23730 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
23735 stack
[stacki
+ 1] = stack
[stacki
];
23740 stack
[stacki
- 1] += stack
[stacki
];
23744 case DW_OP_plus_uconst
:
23745 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
23751 stack
[stacki
- 1] -= stack
[stacki
];
23756 /* If we're not the last op, then we definitely can't encode
23757 this using GDB's address_class enum. This is valid for partial
23758 global symbols, although the variable's address will be bogus
23762 if (computed
== nullptr)
23763 dwarf2_complex_location_expr_complaint ();
23769 case DW_OP_GNU_push_tls_address
:
23770 case DW_OP_form_tls_address
:
23771 /* The top of the stack has the offset from the beginning
23772 of the thread control block at which the variable is located. */
23773 /* Nothing should follow this operator, so the top of stack would
23775 /* This is valid for partial global symbols, but the variable's
23776 address will be bogus in the psymtab. Make it always at least
23777 non-zero to not look as a variable garbage collected by linker
23778 which have DW_OP_addr 0. */
23781 if (computed
== nullptr)
23782 dwarf2_complex_location_expr_complaint ();
23789 case DW_OP_GNU_uninit
:
23790 if (computed
!= nullptr)
23795 case DW_OP_GNU_addr_index
:
23796 case DW_OP_GNU_const_index
:
23797 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
23803 if (computed
== nullptr)
23805 const char *name
= get_DW_OP_name (op
);
23808 complaint (_("unsupported stack op: '%s'"),
23811 complaint (_("unsupported stack op: '%02x'"),
23815 return (stack
[stacki
]);
23818 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23819 outside of the allocated space. Also enforce minimum>0. */
23820 if (stacki
>= ARRAY_SIZE (stack
) - 1)
23822 if (computed
== nullptr)
23823 complaint (_("location description stack overflow"));
23829 if (computed
== nullptr)
23830 complaint (_("location description stack underflow"));
23835 if (computed
!= nullptr)
23837 return (stack
[stacki
]);
23840 /* memory allocation interface */
23842 static struct dwarf_block
*
23843 dwarf_alloc_block (struct dwarf2_cu
*cu
)
23845 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
23848 static struct die_info
*
23849 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
23851 struct die_info
*die
;
23852 size_t size
= sizeof (struct die_info
);
23855 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
23857 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
23858 memset (die
, 0, sizeof (struct die_info
));
23864 /* Macro support. */
23866 /* An overload of dwarf_decode_macros that finds the correct section
23867 and ensures it is read in before calling the other overload. */
23870 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
23871 int section_is_gnu
)
23873 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23874 struct objfile
*objfile
= per_objfile
->objfile
;
23875 const struct line_header
*lh
= cu
->line_header
;
23876 unsigned int offset_size
= cu
->header
.offset_size
;
23877 struct dwarf2_section_info
*section
;
23878 const char *section_name
;
23880 if (cu
->dwo_unit
!= nullptr)
23882 if (section_is_gnu
)
23884 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
23885 section_name
= ".debug_macro.dwo";
23889 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
23890 section_name
= ".debug_macinfo.dwo";
23895 if (section_is_gnu
)
23897 section
= &per_objfile
->per_bfd
->macro
;
23898 section_name
= ".debug_macro";
23902 section
= &per_objfile
->per_bfd
->macinfo
;
23903 section_name
= ".debug_macinfo";
23907 section
->read (objfile
);
23908 if (section
->buffer
== nullptr)
23910 complaint (_("missing %s section"), section_name
);
23914 buildsym_compunit
*builder
= cu
->get_builder ();
23916 struct dwarf2_section_info
*str_offsets_section
;
23917 struct dwarf2_section_info
*str_section
;
23918 ULONGEST str_offsets_base
;
23920 if (cu
->dwo_unit
!= nullptr)
23922 str_offsets_section
= &cu
->dwo_unit
->dwo_file
23923 ->sections
.str_offsets
;
23924 str_section
= &cu
->dwo_unit
->dwo_file
->sections
.str
;
23925 str_offsets_base
= cu
->header
.addr_size
;
23929 str_offsets_section
= &per_objfile
->per_bfd
->str_offsets
;
23930 str_section
= &per_objfile
->per_bfd
->str
;
23931 str_offsets_base
= *cu
->str_offsets_base
;
23934 dwarf_decode_macros (per_objfile
, builder
, section
, lh
,
23935 offset_size
, offset
, str_section
, str_offsets_section
,
23936 str_offsets_base
, section_is_gnu
);
23939 /* Return the .debug_loc section to use for CU.
23940 For DWO files use .debug_loc.dwo. */
23942 static struct dwarf2_section_info
*
23943 cu_debug_loc_section (struct dwarf2_cu
*cu
)
23945 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23949 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
23951 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
23953 return (cu
->header
.version
>= 5 ? &per_objfile
->per_bfd
->loclists
23954 : &per_objfile
->per_bfd
->loc
);
23957 /* Return the .debug_rnglists section to use for CU. */
23958 static struct dwarf2_section_info
*
23959 cu_debug_rnglists_section (struct dwarf2_cu
*cu
, dwarf_tag tag
)
23961 if (cu
->header
.version
< 5)
23962 error (_(".debug_rnglists section cannot be used in DWARF %d"),
23963 cu
->header
.version
);
23964 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
23966 /* Make sure we read the .debug_rnglists section from the file that
23967 contains the DW_AT_ranges attribute we are reading. Normally that
23968 would be the .dwo file, if there is one. However for DW_TAG_compile_unit
23969 or DW_TAG_skeleton unit, we always want to read from objfile/linked
23971 if (cu
->dwo_unit
!= nullptr
23972 && tag
!= DW_TAG_compile_unit
23973 && tag
!= DW_TAG_skeleton_unit
)
23975 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
23977 if (sections
->rnglists
.size
> 0)
23978 return §ions
->rnglists
;
23980 error (_(".debug_rnglists section is missing from .dwo file."));
23982 return &dwarf2_per_objfile
->per_bfd
->rnglists
;
23985 /* A helper function that fills in a dwarf2_loclist_baton. */
23988 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
23989 struct dwarf2_loclist_baton
*baton
,
23990 const struct attribute
*attr
)
23992 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23993 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
23995 section
->read (per_objfile
->objfile
);
23997 baton
->per_objfile
= per_objfile
;
23998 baton
->per_cu
= cu
->per_cu
;
23999 gdb_assert (baton
->per_cu
);
24000 /* We don't know how long the location list is, but make sure we
24001 don't run off the edge of the section. */
24002 baton
->size
= section
->size
- attr
->as_unsigned ();
24003 baton
->data
= section
->buffer
+ attr
->as_unsigned ();
24004 if (cu
->base_address
.has_value ())
24005 baton
->base_address
= *cu
->base_address
;
24007 baton
->base_address
= 0;
24008 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
24012 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
24013 struct dwarf2_cu
*cu
, int is_block
)
24015 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24016 struct objfile
*objfile
= per_objfile
->objfile
;
24017 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24019 if (attr
->form_is_section_offset ()
24020 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24021 the section. If so, fall through to the complaint in the
24023 && attr
->as_unsigned () < section
->get_size (objfile
))
24025 struct dwarf2_loclist_baton
*baton
;
24027 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
24029 fill_in_loclist_baton (cu
, baton
, attr
);
24031 if (!cu
->base_address
.has_value ())
24032 complaint (_("Location list used without "
24033 "specifying the CU base address."));
24035 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24036 ? dwarf2_loclist_block_index
24037 : dwarf2_loclist_index
);
24038 SYMBOL_LOCATION_BATON (sym
) = baton
;
24042 struct dwarf2_locexpr_baton
*baton
;
24044 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
24045 baton
->per_objfile
= per_objfile
;
24046 baton
->per_cu
= cu
->per_cu
;
24047 gdb_assert (baton
->per_cu
);
24049 if (attr
->form_is_block ())
24051 /* Note that we're just copying the block's data pointer
24052 here, not the actual data. We're still pointing into the
24053 info_buffer for SYM's objfile; right now we never release
24054 that buffer, but when we do clean up properly this may
24056 struct dwarf_block
*block
= attr
->as_block ();
24057 baton
->size
= block
->size
;
24058 baton
->data
= block
->data
;
24062 dwarf2_invalid_attrib_class_complaint ("location description",
24063 sym
->natural_name ());
24067 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24068 ? dwarf2_locexpr_block_index
24069 : dwarf2_locexpr_index
);
24070 SYMBOL_LOCATION_BATON (sym
) = baton
;
24076 const comp_unit_head
*
24077 dwarf2_per_cu_data::get_header () const
24079 if (!m_header_read_in
)
24081 const gdb_byte
*info_ptr
24082 = this->section
->buffer
+ to_underlying (this->sect_off
);
24084 memset (&m_header
, 0, sizeof (m_header
));
24086 read_comp_unit_head (&m_header
, info_ptr
, this->section
,
24087 rcuh_kind::COMPILE
);
24096 dwarf2_per_cu_data::addr_size () const
24098 return this->get_header ()->addr_size
;
24104 dwarf2_per_cu_data::offset_size () const
24106 return this->get_header ()->offset_size
;
24112 dwarf2_per_cu_data::ref_addr_size () const
24114 const comp_unit_head
*header
= this->get_header ();
24116 if (header
->version
== 2)
24117 return header
->addr_size
;
24119 return header
->offset_size
;
24125 dwarf2_cu::addr_type () const
24127 struct objfile
*objfile
= this->per_objfile
->objfile
;
24128 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
24129 struct type
*addr_type
= lookup_pointer_type (void_type
);
24130 int addr_size
= this->per_cu
->addr_size ();
24132 if (TYPE_LENGTH (addr_type
) == addr_size
)
24135 addr_type
= addr_sized_int_type (addr_type
->is_unsigned ());
24139 /* A helper function for dwarf2_find_containing_comp_unit that returns
24140 the index of the result, and that searches a vector. It will
24141 return a result even if the offset in question does not actually
24142 occur in any CU. This is separate so that it can be unit
24146 dwarf2_find_containing_comp_unit
24147 (sect_offset sect_off
,
24148 unsigned int offset_in_dwz
,
24149 const std::vector
<dwarf2_per_cu_data
*> &all_comp_units
)
24154 high
= all_comp_units
.size () - 1;
24157 struct dwarf2_per_cu_data
*mid_cu
;
24158 int mid
= low
+ (high
- low
) / 2;
24160 mid_cu
= all_comp_units
[mid
];
24161 if (mid_cu
->is_dwz
> offset_in_dwz
24162 || (mid_cu
->is_dwz
== offset_in_dwz
24163 && mid_cu
->sect_off
+ mid_cu
->length
> sect_off
))
24168 gdb_assert (low
== high
);
24172 /* Locate the .debug_info compilation unit from CU's objfile which contains
24173 the DIE at OFFSET. Raises an error on failure. */
24175 static struct dwarf2_per_cu_data
*
24176 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
24177 unsigned int offset_in_dwz
,
24178 dwarf2_per_objfile
*per_objfile
)
24180 int low
= dwarf2_find_containing_comp_unit
24181 (sect_off
, offset_in_dwz
, per_objfile
->per_bfd
->all_comp_units
);
24182 dwarf2_per_cu_data
*this_cu
= per_objfile
->per_bfd
->all_comp_units
[low
];
24184 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
24186 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
24187 error (_("Dwarf Error: could not find partial DIE containing "
24188 "offset %s [in module %s]"),
24189 sect_offset_str (sect_off
),
24190 bfd_get_filename (per_objfile
->objfile
->obfd
));
24192 gdb_assert (per_objfile
->per_bfd
->all_comp_units
[low
-1]->sect_off
24194 return per_objfile
->per_bfd
->all_comp_units
[low
-1];
24198 if (low
== per_objfile
->per_bfd
->all_comp_units
.size () - 1
24199 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
24200 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
24201 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
24208 namespace selftests
{
24209 namespace find_containing_comp_unit
{
24214 struct dwarf2_per_cu_data one
{};
24215 struct dwarf2_per_cu_data two
{};
24216 struct dwarf2_per_cu_data three
{};
24217 struct dwarf2_per_cu_data four
{};
24220 two
.sect_off
= sect_offset (one
.length
);
24225 four
.sect_off
= sect_offset (three
.length
);
24229 std::vector
<dwarf2_per_cu_data
*> units
;
24230 units
.push_back (&one
);
24231 units
.push_back (&two
);
24232 units
.push_back (&three
);
24233 units
.push_back (&four
);
24237 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 0, units
);
24238 SELF_CHECK (units
[result
] == &one
);
24239 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 0, units
);
24240 SELF_CHECK (units
[result
] == &one
);
24241 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 0, units
);
24242 SELF_CHECK (units
[result
] == &two
);
24244 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 1, units
);
24245 SELF_CHECK (units
[result
] == &three
);
24246 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 1, units
);
24247 SELF_CHECK (units
[result
] == &three
);
24248 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 1, units
);
24249 SELF_CHECK (units
[result
] == &four
);
24255 #endif /* GDB_SELF_TEST */
24257 /* Initialize dwarf2_cu to read PER_CU, in the context of PER_OBJFILE. */
24259 dwarf2_cu::dwarf2_cu (dwarf2_per_cu_data
*per_cu
,
24260 dwarf2_per_objfile
*per_objfile
)
24262 per_objfile (per_objfile
),
24264 has_loclist (false),
24265 checked_producer (false),
24266 producer_is_gxx_lt_4_6 (false),
24267 producer_is_gcc_lt_4_3 (false),
24268 producer_is_icc (false),
24269 producer_is_icc_lt_14 (false),
24270 producer_is_codewarrior (false),
24271 processing_has_namespace_info (false)
24275 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
24278 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
24279 enum language pretend_language
)
24281 struct attribute
*attr
;
24283 /* Set the language we're debugging. */
24284 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
24285 if (attr
!= nullptr)
24286 set_cu_language (attr
->constant_value (0), cu
);
24289 cu
->language
= pretend_language
;
24290 cu
->language_defn
= language_def (cu
->language
);
24293 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
24299 dwarf2_per_objfile::get_cu (dwarf2_per_cu_data
*per_cu
)
24301 auto it
= m_dwarf2_cus
.find (per_cu
);
24302 if (it
== m_dwarf2_cus
.end ())
24311 dwarf2_per_objfile::set_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_cu
*cu
)
24313 gdb_assert (this->get_cu (per_cu
) == nullptr);
24315 m_dwarf2_cus
[per_cu
] = cu
;
24321 dwarf2_per_objfile::age_comp_units ()
24323 /* Start by clearing all marks. */
24324 for (auto pair
: m_dwarf2_cus
)
24325 pair
.second
->mark
= false;
24327 /* Traverse all CUs, mark them and their dependencies if used recently
24329 for (auto pair
: m_dwarf2_cus
)
24331 dwarf2_cu
*cu
= pair
.second
;
24334 if (cu
->last_used
<= dwarf_max_cache_age
)
24338 /* Delete all CUs still not marked. */
24339 for (auto it
= m_dwarf2_cus
.begin (); it
!= m_dwarf2_cus
.end ();)
24341 dwarf2_cu
*cu
= it
->second
;
24346 it
= m_dwarf2_cus
.erase (it
);
24356 dwarf2_per_objfile::remove_cu (dwarf2_per_cu_data
*per_cu
)
24358 auto it
= m_dwarf2_cus
.find (per_cu
);
24359 if (it
== m_dwarf2_cus
.end ())
24364 m_dwarf2_cus
.erase (it
);
24367 dwarf2_per_objfile::~dwarf2_per_objfile ()
24372 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
24373 We store these in a hash table separate from the DIEs, and preserve them
24374 when the DIEs are flushed out of cache.
24376 The CU "per_cu" pointer is needed because offset alone is not enough to
24377 uniquely identify the type. A file may have multiple .debug_types sections,
24378 or the type may come from a DWO file. Furthermore, while it's more logical
24379 to use per_cu->section+offset, with Fission the section with the data is in
24380 the DWO file but we don't know that section at the point we need it.
24381 We have to use something in dwarf2_per_cu_data (or the pointer to it)
24382 because we can enter the lookup routine, get_die_type_at_offset, from
24383 outside this file, and thus won't necessarily have PER_CU->cu.
24384 Fortunately, PER_CU is stable for the life of the objfile. */
24386 struct dwarf2_per_cu_offset_and_type
24388 const struct dwarf2_per_cu_data
*per_cu
;
24389 sect_offset sect_off
;
24393 /* Hash function for a dwarf2_per_cu_offset_and_type. */
24396 per_cu_offset_and_type_hash (const void *item
)
24398 const struct dwarf2_per_cu_offset_and_type
*ofs
24399 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
24401 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
24404 /* Equality function for a dwarf2_per_cu_offset_and_type. */
24407 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
24409 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
24410 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
24411 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
24412 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
24414 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
24415 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
24418 /* Set the type associated with DIE to TYPE. Save it in CU's hash
24419 table if necessary. For convenience, return TYPE.
24421 The DIEs reading must have careful ordering to:
24422 * Not cause infinite loops trying to read in DIEs as a prerequisite for
24423 reading current DIE.
24424 * Not trying to dereference contents of still incompletely read in types
24425 while reading in other DIEs.
24426 * Enable referencing still incompletely read in types just by a pointer to
24427 the type without accessing its fields.
24429 Therefore caller should follow these rules:
24430 * Try to fetch any prerequisite types we may need to build this DIE type
24431 before building the type and calling set_die_type.
24432 * After building type call set_die_type for current DIE as soon as
24433 possible before fetching more types to complete the current type.
24434 * Make the type as complete as possible before fetching more types. */
24436 static struct type
*
24437 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
24439 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24440 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
24441 struct objfile
*objfile
= per_objfile
->objfile
;
24442 struct attribute
*attr
;
24443 struct dynamic_prop prop
;
24445 /* For Ada types, make sure that the gnat-specific data is always
24446 initialized (if not already set). There are a few types where
24447 we should not be doing so, because the type-specific area is
24448 already used to hold some other piece of info (eg: TYPE_CODE_FLT
24449 where the type-specific area is used to store the floatformat).
24450 But this is not a problem, because the gnat-specific information
24451 is actually not needed for these types. */
24452 if (need_gnat_info (cu
)
24453 && type
->code () != TYPE_CODE_FUNC
24454 && type
->code () != TYPE_CODE_FLT
24455 && type
->code () != TYPE_CODE_METHODPTR
24456 && type
->code () != TYPE_CODE_MEMBERPTR
24457 && type
->code () != TYPE_CODE_METHOD
24458 && !HAVE_GNAT_AUX_INFO (type
))
24459 INIT_GNAT_SPECIFIC (type
);
24461 /* Read DW_AT_allocated and set in type. */
24462 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
24465 struct type
*prop_type
= cu
->addr_sized_int_type (false);
24466 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24467 type
->add_dyn_prop (DYN_PROP_ALLOCATED
, prop
);
24470 /* Read DW_AT_associated and set in type. */
24471 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
24474 struct type
*prop_type
= cu
->addr_sized_int_type (false);
24475 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24476 type
->add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
);
24479 /* Read DW_AT_data_location and set in type. */
24480 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
24481 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
24482 type
->add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
);
24484 if (per_objfile
->die_type_hash
== NULL
)
24485 per_objfile
->die_type_hash
24486 = htab_up (htab_create_alloc (127,
24487 per_cu_offset_and_type_hash
,
24488 per_cu_offset_and_type_eq
,
24489 NULL
, xcalloc
, xfree
));
24491 ofs
.per_cu
= cu
->per_cu
;
24492 ofs
.sect_off
= die
->sect_off
;
24494 slot
= (struct dwarf2_per_cu_offset_and_type
**)
24495 htab_find_slot (per_objfile
->die_type_hash
.get (), &ofs
, INSERT
);
24497 complaint (_("A problem internal to GDB: DIE %s has type already set"),
24498 sect_offset_str (die
->sect_off
));
24499 *slot
= XOBNEW (&objfile
->objfile_obstack
,
24500 struct dwarf2_per_cu_offset_and_type
);
24505 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
24506 or return NULL if the die does not have a saved type. */
24508 static struct type
*
24509 get_die_type_at_offset (sect_offset sect_off
,
24510 dwarf2_per_cu_data
*per_cu
,
24511 dwarf2_per_objfile
*per_objfile
)
24513 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
24515 if (per_objfile
->die_type_hash
== NULL
)
24518 ofs
.per_cu
= per_cu
;
24519 ofs
.sect_off
= sect_off
;
24520 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
24521 htab_find (per_objfile
->die_type_hash
.get (), &ofs
));
24528 /* Look up the type for DIE in CU in die_type_hash,
24529 or return NULL if DIE does not have a saved type. */
24531 static struct type
*
24532 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
24534 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
, cu
->per_objfile
);
24537 /* Add a dependence relationship from CU to REF_PER_CU. */
24540 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
24541 struct dwarf2_per_cu_data
*ref_per_cu
)
24545 if (cu
->dependencies
== NULL
)
24547 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
24548 NULL
, &cu
->comp_unit_obstack
,
24549 hashtab_obstack_allocate
,
24550 dummy_obstack_deallocate
);
24552 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
24554 *slot
= ref_per_cu
;
24557 /* Subroutine of dwarf2_mark to pass to htab_traverse.
24558 Set the mark field in every compilation unit in the
24559 cache that we must keep because we are keeping CU.
24561 DATA is the dwarf2_per_objfile object in which to look up CUs. */
24564 dwarf2_mark_helper (void **slot
, void *data
)
24566 dwarf2_per_cu_data
*per_cu
= (dwarf2_per_cu_data
*) *slot
;
24567 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) data
;
24568 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
24570 /* cu->dependencies references may not yet have been ever read if QUIT aborts
24571 reading of the chain. As such dependencies remain valid it is not much
24572 useful to track and undo them during QUIT cleanups. */
24581 if (cu
->dependencies
!= nullptr)
24582 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, per_objfile
);
24587 /* Set the mark field in CU and in every other compilation unit in the
24588 cache that we must keep because we are keeping CU. */
24591 dwarf2_mark (struct dwarf2_cu
*cu
)
24598 if (cu
->dependencies
!= nullptr)
24599 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, cu
->per_objfile
);
24602 /* Trivial hash function for partial_die_info: the hash value of a DIE
24603 is its offset in .debug_info for this objfile. */
24606 partial_die_hash (const void *item
)
24608 const struct partial_die_info
*part_die
24609 = (const struct partial_die_info
*) item
;
24611 return to_underlying (part_die
->sect_off
);
24614 /* Trivial comparison function for partial_die_info structures: two DIEs
24615 are equal if they have the same offset. */
24618 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
24620 const struct partial_die_info
*part_die_lhs
24621 = (const struct partial_die_info
*) item_lhs
;
24622 const struct partial_die_info
*part_die_rhs
24623 = (const struct partial_die_info
*) item_rhs
;
24625 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
24628 struct cmd_list_element
*set_dwarf_cmdlist
;
24629 struct cmd_list_element
*show_dwarf_cmdlist
;
24632 show_check_physname (struct ui_file
*file
, int from_tty
,
24633 struct cmd_list_element
*c
, const char *value
)
24635 fprintf_filtered (file
,
24636 _("Whether to check \"physname\" is %s.\n"),
24640 void _initialize_dwarf2_read ();
24642 _initialize_dwarf2_read ()
24644 add_basic_prefix_cmd ("dwarf", class_maintenance
, _("\
24645 Set DWARF specific variables.\n\
24646 Configure DWARF variables such as the cache size."),
24647 &set_dwarf_cmdlist
, "maintenance set dwarf ",
24648 0/*allow-unknown*/, &maintenance_set_cmdlist
);
24650 add_show_prefix_cmd ("dwarf", class_maintenance
, _("\
24651 Show DWARF specific variables.\n\
24652 Show DWARF variables such as the cache size."),
24653 &show_dwarf_cmdlist
, "maintenance show dwarf ",
24654 0/*allow-unknown*/, &maintenance_show_cmdlist
);
24656 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
24657 &dwarf_max_cache_age
, _("\
24658 Set the upper bound on the age of cached DWARF compilation units."), _("\
24659 Show the upper bound on the age of cached DWARF compilation units."), _("\
24660 A higher limit means that cached compilation units will be stored\n\
24661 in memory longer, and more total memory will be used. Zero disables\n\
24662 caching, which can slow down startup."),
24664 show_dwarf_max_cache_age
,
24665 &set_dwarf_cmdlist
,
24666 &show_dwarf_cmdlist
);
24668 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
24669 Set debugging of the DWARF reader."), _("\
24670 Show debugging of the DWARF reader."), _("\
24671 When enabled (non-zero), debugging messages are printed during DWARF\n\
24672 reading and symtab expansion. A value of 1 (one) provides basic\n\
24673 information. A value greater than 1 provides more verbose information."),
24676 &setdebuglist
, &showdebuglist
);
24678 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
24679 Set debugging of the DWARF DIE reader."), _("\
24680 Show debugging of the DWARF DIE reader."), _("\
24681 When enabled (non-zero), DIEs are dumped after they are read in.\n\
24682 The value is the maximum depth to print."),
24685 &setdebuglist
, &showdebuglist
);
24687 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
24688 Set debugging of the dwarf line reader."), _("\
24689 Show debugging of the dwarf line reader."), _("\
24690 When enabled (non-zero), line number entries are dumped as they are read in.\n\
24691 A value of 1 (one) provides basic information.\n\
24692 A value greater than 1 provides more verbose information."),
24695 &setdebuglist
, &showdebuglist
);
24697 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
24698 Set cross-checking of \"physname\" code against demangler."), _("\
24699 Show cross-checking of \"physname\" code against demangler."), _("\
24700 When enabled, GDB's internal \"physname\" code is checked against\n\
24702 NULL
, show_check_physname
,
24703 &setdebuglist
, &showdebuglist
);
24705 add_setshow_boolean_cmd ("use-deprecated-index-sections",
24706 no_class
, &use_deprecated_index_sections
, _("\
24707 Set whether to use deprecated gdb_index sections."), _("\
24708 Show whether to use deprecated gdb_index sections."), _("\
24709 When enabled, deprecated .gdb_index sections are used anyway.\n\
24710 Normally they are ignored either because of a missing feature or\n\
24711 performance issue.\n\
24712 Warning: This option must be enabled before gdb reads the file."),
24715 &setlist
, &showlist
);
24717 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
24718 &dwarf2_locexpr_funcs
);
24719 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
24720 &dwarf2_loclist_funcs
);
24722 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
24723 &dwarf2_block_frame_base_locexpr_funcs
);
24724 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
24725 &dwarf2_block_frame_base_loclist_funcs
);
24728 selftests::register_test ("dw2_expand_symtabs_matching",
24729 selftests::dw2_expand_symtabs_matching::run_test
);
24730 selftests::register_test ("dwarf2_find_containing_comp_unit",
24731 selftests::find_containing_comp_unit::run_test
);