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 ();
6124 /* This isn't really ideal: all the data we allocate on the
6125 objfile's obstack is still uselessly kept around. However,
6126 freeing it seems unsafe. */
6127 psymtab_discarder
psymtabs (objfile
);
6128 dwarf2_build_psymtabs_hard (per_objfile
);
6131 per_objfile
->resize_symtabs ();
6133 /* (maybe) store an index in the cache. */
6134 global_index_cache
.store (per_objfile
);
6136 catch (const gdb_exception_error
&except
)
6138 exception_print (gdb_stderr
, except
);
6141 /* Finish by setting the local reference to partial symtabs, so that
6142 we don't try to read them again if reading another objfile with the same
6143 BFD. If we can't in fact share, this won't make a difference anyway as
6144 the dwarf2_per_bfd object won't be shared. */
6145 per_bfd
->partial_symtabs
= objfile
->partial_symtabs
;
6148 /* Find the base address of the compilation unit for range lists and
6149 location lists. It will normally be specified by DW_AT_low_pc.
6150 In DWARF-3 draft 4, the base address could be overridden by
6151 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6152 compilation units with discontinuous ranges. */
6155 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
6157 struct attribute
*attr
;
6159 cu
->base_address
.reset ();
6161 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
6162 if (attr
!= nullptr)
6163 cu
->base_address
= attr
->as_address ();
6166 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6167 if (attr
!= nullptr)
6168 cu
->base_address
= attr
->as_address ();
6172 /* Helper function that returns the proper abbrev section for
6175 static struct dwarf2_section_info
*
6176 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
6178 struct dwarf2_section_info
*abbrev
;
6179 dwarf2_per_bfd
*per_bfd
= this_cu
->per_bfd
;
6181 if (this_cu
->is_dwz
)
6182 abbrev
= &dwarf2_get_dwz_file (per_bfd
)->abbrev
;
6184 abbrev
= &per_bfd
->abbrev
;
6189 /* Fetch the abbreviation table offset from a comp or type unit header. */
6192 read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
6193 struct dwarf2_section_info
*section
,
6194 sect_offset sect_off
)
6196 bfd
*abfd
= section
->get_bfd_owner ();
6197 const gdb_byte
*info_ptr
;
6198 unsigned int initial_length_size
, offset_size
;
6201 section
->read (per_objfile
->objfile
);
6202 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
6203 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6204 offset_size
= initial_length_size
== 4 ? 4 : 8;
6205 info_ptr
+= initial_length_size
;
6207 version
= read_2_bytes (abfd
, info_ptr
);
6211 /* Skip unit type and address size. */
6215 return (sect_offset
) read_offset (abfd
, info_ptr
, offset_size
);
6218 /* A partial symtab that is used only for include files. */
6219 struct dwarf2_include_psymtab
: public partial_symtab
6221 dwarf2_include_psymtab (const char *filename
, struct objfile
*objfile
)
6222 : partial_symtab (filename
, objfile
)
6226 void read_symtab (struct objfile
*objfile
) override
6228 /* It's an include file, no symbols to read for it.
6229 Everything is in the includer symtab. */
6231 /* The expansion of a dwarf2_include_psymtab is just a trigger for
6232 expansion of the includer psymtab. We use the dependencies[0] field to
6233 model the includer. But if we go the regular route of calling
6234 expand_psymtab here, and having expand_psymtab call expand_dependencies
6235 to expand the includer, we'll only use expand_psymtab on the includer
6236 (making it a non-toplevel psymtab), while if we expand the includer via
6237 another path, we'll use read_symtab (making it a toplevel psymtab).
6238 So, don't pretend a dwarf2_include_psymtab is an actual toplevel
6239 psymtab, and trigger read_symtab on the includer here directly. */
6240 includer ()->read_symtab (objfile
);
6243 void expand_psymtab (struct objfile
*objfile
) override
6245 /* This is not called by read_symtab, and should not be called by any
6246 expand_dependencies. */
6250 bool readin_p (struct objfile
*objfile
) const override
6252 return includer ()->readin_p (objfile
);
6255 compunit_symtab
*get_compunit_symtab (struct objfile
*objfile
) const override
6261 partial_symtab
*includer () const
6263 /* An include psymtab has exactly one dependency: the psymtab that
6265 gdb_assert (this->number_of_dependencies
== 1);
6266 return this->dependencies
[0];
6270 /* Allocate a new partial symtab for file named NAME and mark this new
6271 partial symtab as being an include of PST. */
6274 dwarf2_create_include_psymtab (const char *name
, dwarf2_psymtab
*pst
,
6275 struct objfile
*objfile
)
6277 dwarf2_include_psymtab
*subpst
= new dwarf2_include_psymtab (name
, objfile
);
6279 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
6280 subpst
->dirname
= pst
->dirname
;
6282 subpst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (1);
6283 subpst
->dependencies
[0] = pst
;
6284 subpst
->number_of_dependencies
= 1;
6287 /* Read the Line Number Program data and extract the list of files
6288 included by the source file represented by PST. Build an include
6289 partial symtab for each of these included files. */
6292 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
6293 struct die_info
*die
,
6294 dwarf2_psymtab
*pst
)
6297 struct attribute
*attr
;
6299 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6300 if (attr
!= nullptr && attr
->form_is_unsigned ())
6301 lh
= dwarf_decode_line_header ((sect_offset
) attr
->as_unsigned (), cu
);
6303 return; /* No linetable, so no includes. */
6305 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6306 that we pass in the raw text_low here; that is ok because we're
6307 only decoding the line table to make include partial symtabs, and
6308 so the addresses aren't really used. */
6309 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
6310 pst
->raw_text_low (), 1);
6314 hash_signatured_type (const void *item
)
6316 const struct signatured_type
*sig_type
6317 = (const struct signatured_type
*) item
;
6319 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6320 return sig_type
->signature
;
6324 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6326 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6327 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6329 return lhs
->signature
== rhs
->signature
;
6332 /* Allocate a hash table for signatured types. */
6335 allocate_signatured_type_table ()
6337 return htab_up (htab_create_alloc (41,
6338 hash_signatured_type
,
6340 NULL
, xcalloc
, xfree
));
6343 /* A helper function to add a signatured type CU to a table. */
6346 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6348 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6349 std::vector
<signatured_type
*> *all_type_units
6350 = (std::vector
<signatured_type
*> *) datum
;
6352 all_type_units
->push_back (sigt
);
6357 /* A helper for create_debug_types_hash_table. Read types from SECTION
6358 and fill them into TYPES_HTAB. It will process only type units,
6359 therefore DW_UT_type. */
6362 create_debug_type_hash_table (dwarf2_per_objfile
*per_objfile
,
6363 struct dwo_file
*dwo_file
,
6364 dwarf2_section_info
*section
, htab_up
&types_htab
,
6365 rcuh_kind section_kind
)
6367 struct objfile
*objfile
= per_objfile
->objfile
;
6368 struct dwarf2_section_info
*abbrev_section
;
6370 const gdb_byte
*info_ptr
, *end_ptr
;
6372 abbrev_section
= (dwo_file
!= NULL
6373 ? &dwo_file
->sections
.abbrev
6374 : &per_objfile
->per_bfd
->abbrev
);
6376 if (dwarf_read_debug
)
6377 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
6378 section
->get_name (),
6379 abbrev_section
->get_file_name ());
6381 section
->read (objfile
);
6382 info_ptr
= section
->buffer
;
6384 if (info_ptr
== NULL
)
6387 /* We can't set abfd until now because the section may be empty or
6388 not present, in which case the bfd is unknown. */
6389 abfd
= section
->get_bfd_owner ();
6391 /* We don't use cutu_reader here because we don't need to read
6392 any dies: the signature is in the header. */
6394 end_ptr
= info_ptr
+ section
->size
;
6395 while (info_ptr
< end_ptr
)
6397 struct signatured_type
*sig_type
;
6398 struct dwo_unit
*dwo_tu
;
6400 const gdb_byte
*ptr
= info_ptr
;
6401 struct comp_unit_head header
;
6402 unsigned int length
;
6404 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
6406 /* Initialize it due to a false compiler warning. */
6407 header
.signature
= -1;
6408 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
6410 /* We need to read the type's signature in order to build the hash
6411 table, but we don't need anything else just yet. */
6413 ptr
= read_and_check_comp_unit_head (per_objfile
, &header
, section
,
6414 abbrev_section
, ptr
, section_kind
);
6416 length
= header
.get_length ();
6418 /* Skip dummy type units. */
6419 if (ptr
>= info_ptr
+ length
6420 || peek_abbrev_code (abfd
, ptr
) == 0
6421 || (header
.unit_type
!= DW_UT_type
6422 && header
.unit_type
!= DW_UT_split_type
))
6428 if (types_htab
== NULL
)
6431 types_htab
= allocate_dwo_unit_table ();
6433 types_htab
= allocate_signatured_type_table ();
6439 dwo_tu
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, dwo_unit
);
6440 dwo_tu
->dwo_file
= dwo_file
;
6441 dwo_tu
->signature
= header
.signature
;
6442 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6443 dwo_tu
->section
= section
;
6444 dwo_tu
->sect_off
= sect_off
;
6445 dwo_tu
->length
= length
;
6449 /* N.B.: type_offset is not usable if this type uses a DWO file.
6450 The real type_offset is in the DWO file. */
6452 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6453 sig_type
->signature
= header
.signature
;
6454 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6455 sig_type
->per_cu
.is_debug_types
= 1;
6456 sig_type
->per_cu
.section
= section
;
6457 sig_type
->per_cu
.sect_off
= sect_off
;
6458 sig_type
->per_cu
.length
= length
;
6461 slot
= htab_find_slot (types_htab
.get (),
6462 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
6464 gdb_assert (slot
!= NULL
);
6467 sect_offset dup_sect_off
;
6471 const struct dwo_unit
*dup_tu
6472 = (const struct dwo_unit
*) *slot
;
6474 dup_sect_off
= dup_tu
->sect_off
;
6478 const struct signatured_type
*dup_tu
6479 = (const struct signatured_type
*) *slot
;
6481 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
6484 complaint (_("debug type entry at offset %s is duplicate to"
6485 " the entry at offset %s, signature %s"),
6486 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
6487 hex_string (header
.signature
));
6489 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
6491 if (dwarf_read_debug
> 1)
6492 fprintf_unfiltered (gdb_stdlog
, " offset %s, signature %s\n",
6493 sect_offset_str (sect_off
),
6494 hex_string (header
.signature
));
6500 /* Create the hash table of all entries in the .debug_types
6501 (or .debug_types.dwo) section(s).
6502 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6503 otherwise it is NULL.
6505 The result is a pointer to the hash table or NULL if there are no types.
6507 Note: This function processes DWO files only, not DWP files. */
6510 create_debug_types_hash_table (dwarf2_per_objfile
*per_objfile
,
6511 struct dwo_file
*dwo_file
,
6512 gdb::array_view
<dwarf2_section_info
> type_sections
,
6513 htab_up
&types_htab
)
6515 for (dwarf2_section_info
§ion
: type_sections
)
6516 create_debug_type_hash_table (per_objfile
, dwo_file
, §ion
, types_htab
,
6520 /* Create the hash table of all entries in the .debug_types section,
6521 and initialize all_type_units.
6522 The result is zero if there is an error (e.g. missing .debug_types section),
6523 otherwise non-zero. */
6526 create_all_type_units (dwarf2_per_objfile
*per_objfile
)
6530 create_debug_type_hash_table (per_objfile
, NULL
, &per_objfile
->per_bfd
->info
,
6531 types_htab
, rcuh_kind::COMPILE
);
6532 create_debug_types_hash_table (per_objfile
, NULL
, per_objfile
->per_bfd
->types
,
6534 if (types_htab
== NULL
)
6536 per_objfile
->per_bfd
->signatured_types
= NULL
;
6540 per_objfile
->per_bfd
->signatured_types
= std::move (types_htab
);
6542 gdb_assert (per_objfile
->per_bfd
->all_type_units
.empty ());
6543 per_objfile
->per_bfd
->all_type_units
.reserve
6544 (htab_elements (per_objfile
->per_bfd
->signatured_types
.get ()));
6546 htab_traverse_noresize (per_objfile
->per_bfd
->signatured_types
.get (),
6547 add_signatured_type_cu_to_table
,
6548 &per_objfile
->per_bfd
->all_type_units
);
6553 /* Add an entry for signature SIG to dwarf2_per_objfile->per_bfd->signatured_types.
6554 If SLOT is non-NULL, it is the entry to use in the hash table.
6555 Otherwise we find one. */
6557 static struct signatured_type
*
6558 add_type_unit (dwarf2_per_objfile
*per_objfile
, ULONGEST sig
, void **slot
)
6560 if (per_objfile
->per_bfd
->all_type_units
.size ()
6561 == per_objfile
->per_bfd
->all_type_units
.capacity ())
6562 ++per_objfile
->per_bfd
->tu_stats
.nr_all_type_units_reallocs
;
6564 signatured_type
*sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6566 per_objfile
->resize_symtabs ();
6568 per_objfile
->per_bfd
->all_type_units
.push_back (sig_type
);
6569 sig_type
->signature
= sig
;
6570 sig_type
->per_cu
.is_debug_types
= 1;
6571 if (per_objfile
->per_bfd
->using_index
)
6573 sig_type
->per_cu
.v
.quick
=
6574 OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
6575 struct dwarf2_per_cu_quick_data
);
6580 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6583 gdb_assert (*slot
== NULL
);
6585 /* The rest of sig_type must be filled in by the caller. */
6589 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6590 Fill in SIG_ENTRY with DWO_ENTRY. */
6593 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
*per_objfile
,
6594 struct signatured_type
*sig_entry
,
6595 struct dwo_unit
*dwo_entry
)
6597 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6599 /* Make sure we're not clobbering something we don't expect to. */
6600 gdb_assert (! sig_entry
->per_cu
.queued
);
6601 gdb_assert (per_objfile
->get_cu (&sig_entry
->per_cu
) == NULL
);
6602 if (per_bfd
->using_index
)
6604 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
6605 gdb_assert (!per_objfile
->symtab_set_p (&sig_entry
->per_cu
));
6608 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
6609 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
6610 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
6611 gdb_assert (sig_entry
->type_unit_group
== NULL
);
6612 gdb_assert (sig_entry
->dwo_unit
== NULL
);
6614 sig_entry
->per_cu
.section
= dwo_entry
->section
;
6615 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
6616 sig_entry
->per_cu
.length
= dwo_entry
->length
;
6617 sig_entry
->per_cu
.reading_dwo_directly
= 1;
6618 sig_entry
->per_cu
.per_bfd
= per_bfd
;
6619 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
6620 sig_entry
->dwo_unit
= dwo_entry
;
6623 /* Subroutine of lookup_signatured_type.
6624 If we haven't read the TU yet, create the signatured_type data structure
6625 for a TU to be read in directly from a DWO file, bypassing the stub.
6626 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6627 using .gdb_index, then when reading a CU we want to stay in the DWO file
6628 containing that CU. Otherwise we could end up reading several other DWO
6629 files (due to comdat folding) to process the transitive closure of all the
6630 mentioned TUs, and that can be slow. The current DWO file will have every
6631 type signature that it needs.
6632 We only do this for .gdb_index because in the psymtab case we already have
6633 to read all the DWOs to build the type unit groups. */
6635 static struct signatured_type
*
6636 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6638 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6639 struct dwo_file
*dwo_file
;
6640 struct dwo_unit find_dwo_entry
, *dwo_entry
;
6641 struct signatured_type find_sig_entry
, *sig_entry
;
6644 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6646 /* If TU skeletons have been removed then we may not have read in any
6648 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6649 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6651 /* We only ever need to read in one copy of a signatured type.
6652 Use the global signatured_types array to do our own comdat-folding
6653 of types. If this is the first time we're reading this TU, and
6654 the TU has an entry in .gdb_index, replace the recorded data from
6655 .gdb_index with this TU. */
6657 find_sig_entry
.signature
= sig
;
6658 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6659 &find_sig_entry
, INSERT
);
6660 sig_entry
= (struct signatured_type
*) *slot
;
6662 /* We can get here with the TU already read, *or* in the process of being
6663 read. Don't reassign the global entry to point to this DWO if that's
6664 the case. Also note that if the TU is already being read, it may not
6665 have come from a DWO, the program may be a mix of Fission-compiled
6666 code and non-Fission-compiled code. */
6668 /* Have we already tried to read this TU?
6669 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6670 needn't exist in the global table yet). */
6671 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
6674 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6675 dwo_unit of the TU itself. */
6676 dwo_file
= cu
->dwo_unit
->dwo_file
;
6678 /* Ok, this is the first time we're reading this TU. */
6679 if (dwo_file
->tus
== NULL
)
6681 find_dwo_entry
.signature
= sig
;
6682 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
6684 if (dwo_entry
== NULL
)
6687 /* If the global table doesn't have an entry for this TU, add one. */
6688 if (sig_entry
== NULL
)
6689 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6691 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6692 sig_entry
->per_cu
.tu_read
= 1;
6696 /* Subroutine of lookup_signatured_type.
6697 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6698 then try the DWP file. If the TU stub (skeleton) has been removed then
6699 it won't be in .gdb_index. */
6701 static struct signatured_type
*
6702 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6704 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6705 struct dwp_file
*dwp_file
= get_dwp_file (per_objfile
);
6706 struct dwo_unit
*dwo_entry
;
6707 struct signatured_type find_sig_entry
, *sig_entry
;
6710 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6711 gdb_assert (dwp_file
!= NULL
);
6713 /* If TU skeletons have been removed then we may not have read in any
6715 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6716 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6718 find_sig_entry
.signature
= sig
;
6719 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6720 &find_sig_entry
, INSERT
);
6721 sig_entry
= (struct signatured_type
*) *slot
;
6723 /* Have we already tried to read this TU?
6724 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6725 needn't exist in the global table yet). */
6726 if (sig_entry
!= NULL
)
6729 if (dwp_file
->tus
== NULL
)
6731 dwo_entry
= lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, NULL
, sig
,
6732 1 /* is_debug_types */);
6733 if (dwo_entry
== NULL
)
6736 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6737 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6742 /* Lookup a signature based type for DW_FORM_ref_sig8.
6743 Returns NULL if signature SIG is not present in the table.
6744 It is up to the caller to complain about this. */
6746 static struct signatured_type
*
6747 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6749 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6751 if (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
)
6753 /* We're in a DWO/DWP file, and we're using .gdb_index.
6754 These cases require special processing. */
6755 if (get_dwp_file (per_objfile
) == NULL
)
6756 return lookup_dwo_signatured_type (cu
, sig
);
6758 return lookup_dwp_signatured_type (cu
, sig
);
6762 struct signatured_type find_entry
, *entry
;
6764 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6766 find_entry
.signature
= sig
;
6767 entry
= ((struct signatured_type
*)
6768 htab_find (per_objfile
->per_bfd
->signatured_types
.get (),
6774 /* Low level DIE reading support. */
6776 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
6779 init_cu_die_reader (struct die_reader_specs
*reader
,
6780 struct dwarf2_cu
*cu
,
6781 struct dwarf2_section_info
*section
,
6782 struct dwo_file
*dwo_file
,
6783 struct abbrev_table
*abbrev_table
)
6785 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
6786 reader
->abfd
= section
->get_bfd_owner ();
6788 reader
->dwo_file
= dwo_file
;
6789 reader
->die_section
= section
;
6790 reader
->buffer
= section
->buffer
;
6791 reader
->buffer_end
= section
->buffer
+ section
->size
;
6792 reader
->abbrev_table
= abbrev_table
;
6795 /* Subroutine of cutu_reader to simplify it.
6796 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
6797 There's just a lot of work to do, and cutu_reader is big enough
6800 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
6801 from it to the DIE in the DWO. If NULL we are skipping the stub.
6802 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
6803 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
6804 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
6805 STUB_COMP_DIR may be non-NULL.
6806 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE
6807 are filled in with the info of the DIE from the DWO file.
6808 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
6809 from the dwo. Since *RESULT_READER references this abbrev table, it must be
6810 kept around for at least as long as *RESULT_READER.
6812 The result is non-zero if a valid (non-dummy) DIE was found. */
6815 read_cutu_die_from_dwo (dwarf2_cu
*cu
,
6816 struct dwo_unit
*dwo_unit
,
6817 struct die_info
*stub_comp_unit_die
,
6818 const char *stub_comp_dir
,
6819 struct die_reader_specs
*result_reader
,
6820 const gdb_byte
**result_info_ptr
,
6821 struct die_info
**result_comp_unit_die
,
6822 abbrev_table_up
*result_dwo_abbrev_table
)
6824 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6825 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6826 struct objfile
*objfile
= per_objfile
->objfile
;
6828 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6829 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
6830 int i
,num_extra_attrs
;
6831 struct dwarf2_section_info
*dwo_abbrev_section
;
6832 struct die_info
*comp_unit_die
;
6834 /* At most one of these may be provided. */
6835 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
6837 /* These attributes aren't processed until later:
6838 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
6839 DW_AT_comp_dir is used now, to find the DWO file, but it is also
6840 referenced later. However, these attributes are found in the stub
6841 which we won't have later. In order to not impose this complication
6842 on the rest of the code, we read them here and copy them to the
6851 if (stub_comp_unit_die
!= NULL
)
6853 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
6855 if (!per_cu
->is_debug_types
)
6856 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
6857 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
6858 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
6859 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
6860 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
6862 cu
->addr_base
= stub_comp_unit_die
->addr_base ();
6864 /* There should be a DW_AT_rnglists_base (DW_AT_GNU_ranges_base) attribute
6865 here (if needed). We need the value before we can process
6867 cu
->ranges_base
= stub_comp_unit_die
->ranges_base ();
6869 else if (stub_comp_dir
!= NULL
)
6871 /* Reconstruct the comp_dir attribute to simplify the code below. */
6872 comp_dir
= OBSTACK_ZALLOC (&cu
->comp_unit_obstack
, struct attribute
);
6873 comp_dir
->name
= DW_AT_comp_dir
;
6874 comp_dir
->form
= DW_FORM_string
;
6875 comp_dir
->set_string_noncanonical (stub_comp_dir
);
6878 /* Set up for reading the DWO CU/TU. */
6879 cu
->dwo_unit
= dwo_unit
;
6880 dwarf2_section_info
*section
= dwo_unit
->section
;
6881 section
->read (objfile
);
6882 abfd
= section
->get_bfd_owner ();
6883 begin_info_ptr
= info_ptr
= (section
->buffer
6884 + to_underlying (dwo_unit
->sect_off
));
6885 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
6887 if (per_cu
->is_debug_types
)
6889 signatured_type
*sig_type
= (struct signatured_type
*) per_cu
;
6891 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6892 section
, dwo_abbrev_section
,
6893 info_ptr
, rcuh_kind::TYPE
);
6894 /* This is not an assert because it can be caused by bad debug info. */
6895 if (sig_type
->signature
!= cu
->header
.signature
)
6897 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
6898 " TU at offset %s [in module %s]"),
6899 hex_string (sig_type
->signature
),
6900 hex_string (cu
->header
.signature
),
6901 sect_offset_str (dwo_unit
->sect_off
),
6902 bfd_get_filename (abfd
));
6904 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6905 /* For DWOs coming from DWP files, we don't know the CU length
6906 nor the type's offset in the TU until now. */
6907 dwo_unit
->length
= cu
->header
.get_length ();
6908 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
6910 /* Establish the type offset that can be used to lookup the type.
6911 For DWO files, we don't know it until now. */
6912 sig_type
->type_offset_in_section
6913 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
6917 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6918 section
, dwo_abbrev_section
,
6919 info_ptr
, rcuh_kind::COMPILE
);
6920 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6921 /* For DWOs coming from DWP files, we don't know the CU length
6923 dwo_unit
->length
= cu
->header
.get_length ();
6926 *result_dwo_abbrev_table
6927 = abbrev_table::read (objfile
, dwo_abbrev_section
,
6928 cu
->header
.abbrev_sect_off
);
6929 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
6930 result_dwo_abbrev_table
->get ());
6932 /* Read in the die, but leave space to copy over the attributes
6933 from the stub. This has the benefit of simplifying the rest of
6934 the code - all the work to maintain the illusion of a single
6935 DW_TAG_{compile,type}_unit DIE is done here. */
6936 num_extra_attrs
= ((stmt_list
!= NULL
)
6940 + (comp_dir
!= NULL
));
6941 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
6944 /* Copy over the attributes from the stub to the DIE we just read in. */
6945 comp_unit_die
= *result_comp_unit_die
;
6946 i
= comp_unit_die
->num_attrs
;
6947 if (stmt_list
!= NULL
)
6948 comp_unit_die
->attrs
[i
++] = *stmt_list
;
6950 comp_unit_die
->attrs
[i
++] = *low_pc
;
6951 if (high_pc
!= NULL
)
6952 comp_unit_die
->attrs
[i
++] = *high_pc
;
6954 comp_unit_die
->attrs
[i
++] = *ranges
;
6955 if (comp_dir
!= NULL
)
6956 comp_unit_die
->attrs
[i
++] = *comp_dir
;
6957 comp_unit_die
->num_attrs
+= num_extra_attrs
;
6959 if (dwarf_die_debug
)
6961 fprintf_unfiltered (gdb_stdlog
,
6962 "Read die from %s@0x%x of %s:\n",
6963 section
->get_name (),
6964 (unsigned) (begin_info_ptr
- section
->buffer
),
6965 bfd_get_filename (abfd
));
6966 dump_die (comp_unit_die
, dwarf_die_debug
);
6969 /* Skip dummy compilation units. */
6970 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
6971 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6974 *result_info_ptr
= info_ptr
;
6978 /* Return the signature of the compile unit, if found. In DWARF 4 and before,
6979 the signature is in the DW_AT_GNU_dwo_id attribute. In DWARF 5 and later, the
6980 signature is part of the header. */
6981 static gdb::optional
<ULONGEST
>
6982 lookup_dwo_id (struct dwarf2_cu
*cu
, struct die_info
* comp_unit_die
)
6984 if (cu
->header
.version
>= 5)
6985 return cu
->header
.signature
;
6986 struct attribute
*attr
;
6987 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
6988 if (attr
== nullptr || !attr
->form_is_unsigned ())
6989 return gdb::optional
<ULONGEST
> ();
6990 return attr
->as_unsigned ();
6993 /* Subroutine of cutu_reader to simplify it.
6994 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
6995 Returns NULL if the specified DWO unit cannot be found. */
6997 static struct dwo_unit
*
6998 lookup_dwo_unit (dwarf2_cu
*cu
, die_info
*comp_unit_die
, const char *dwo_name
)
7000 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7001 struct dwo_unit
*dwo_unit
;
7002 const char *comp_dir
;
7004 gdb_assert (cu
!= NULL
);
7006 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7007 dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7008 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7010 if (per_cu
->is_debug_types
)
7011 dwo_unit
= lookup_dwo_type_unit (cu
, dwo_name
, comp_dir
);
7014 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
7016 if (!signature
.has_value ())
7017 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7019 dwo_name
, bfd_get_filename (per_cu
->per_bfd
->obfd
));
7021 dwo_unit
= lookup_dwo_comp_unit (cu
, dwo_name
, comp_dir
, *signature
);
7027 /* Subroutine of cutu_reader to simplify it.
7028 See it for a description of the parameters.
7029 Read a TU directly from a DWO file, bypassing the stub. */
7032 cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
7033 dwarf2_per_objfile
*per_objfile
,
7034 dwarf2_cu
*existing_cu
)
7036 struct signatured_type
*sig_type
;
7038 /* Verify we can do the following downcast, and that we have the
7040 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
7041 sig_type
= (struct signatured_type
*) this_cu
;
7042 gdb_assert (sig_type
->dwo_unit
!= NULL
);
7046 if (existing_cu
!= nullptr)
7049 gdb_assert (cu
->dwo_unit
== sig_type
->dwo_unit
);
7050 /* There's no need to do the rereading_dwo_cu handling that
7051 cutu_reader does since we don't read the stub. */
7055 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
7056 in per_objfile yet. */
7057 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7058 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7059 cu
= m_new_cu
.get ();
7062 /* A future optimization, if needed, would be to use an existing
7063 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7064 could share abbrev tables. */
7066 if (read_cutu_die_from_dwo (cu
, sig_type
->dwo_unit
,
7067 NULL
/* stub_comp_unit_die */,
7068 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
7071 &m_dwo_abbrev_table
) == 0)
7078 /* Initialize a CU (or TU) and read its DIEs.
7079 If the CU defers to a DWO file, read the DWO file as well.
7081 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7082 Otherwise the table specified in the comp unit header is read in and used.
7083 This is an optimization for when we already have the abbrev table.
7085 If EXISTING_CU is non-NULL, then use it. Otherwise, a new CU is
7088 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
7089 dwarf2_per_objfile
*per_objfile
,
7090 struct abbrev_table
*abbrev_table
,
7091 dwarf2_cu
*existing_cu
,
7093 : die_reader_specs
{},
7096 struct objfile
*objfile
= per_objfile
->objfile
;
7097 struct dwarf2_section_info
*section
= this_cu
->section
;
7098 bfd
*abfd
= section
->get_bfd_owner ();
7099 const gdb_byte
*begin_info_ptr
;
7100 struct signatured_type
*sig_type
= NULL
;
7101 struct dwarf2_section_info
*abbrev_section
;
7102 /* Non-zero if CU currently points to a DWO file and we need to
7103 reread it. When this happens we need to reread the skeleton die
7104 before we can reread the DWO file (this only applies to CUs, not TUs). */
7105 int rereading_dwo_cu
= 0;
7107 if (dwarf_die_debug
)
7108 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7109 this_cu
->is_debug_types
? "type" : "comp",
7110 sect_offset_str (this_cu
->sect_off
));
7112 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7113 file (instead of going through the stub), short-circuit all of this. */
7114 if (this_cu
->reading_dwo_directly
)
7116 /* Narrow down the scope of possibilities to have to understand. */
7117 gdb_assert (this_cu
->is_debug_types
);
7118 gdb_assert (abbrev_table
== NULL
);
7119 init_tu_and_read_dwo_dies (this_cu
, per_objfile
, existing_cu
);
7123 /* This is cheap if the section is already read in. */
7124 section
->read (objfile
);
7126 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7128 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
7132 if (existing_cu
!= nullptr)
7135 /* If this CU is from a DWO file we need to start over, we need to
7136 refetch the attributes from the skeleton CU.
7137 This could be optimized by retrieving those attributes from when we
7138 were here the first time: the previous comp_unit_die was stored in
7139 comp_unit_obstack. But there's no data yet that we need this
7141 if (cu
->dwo_unit
!= NULL
)
7142 rereading_dwo_cu
= 1;
7146 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
7147 in per_objfile yet. */
7148 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7149 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7150 cu
= m_new_cu
.get ();
7153 /* Get the header. */
7154 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
7156 /* We already have the header, there's no need to read it in again. */
7157 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
7161 if (this_cu
->is_debug_types
)
7163 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7164 section
, abbrev_section
,
7165 info_ptr
, rcuh_kind::TYPE
);
7167 /* Since per_cu is the first member of struct signatured_type,
7168 we can go from a pointer to one to a pointer to the other. */
7169 sig_type
= (struct signatured_type
*) this_cu
;
7170 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
7171 gdb_assert (sig_type
->type_offset_in_tu
7172 == cu
->header
.type_cu_offset_in_tu
);
7173 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7175 /* LENGTH has not been set yet for type units if we're
7176 using .gdb_index. */
7177 this_cu
->length
= cu
->header
.get_length ();
7179 /* Establish the type offset that can be used to lookup the type. */
7180 sig_type
->type_offset_in_section
=
7181 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
7183 this_cu
->dwarf_version
= cu
->header
.version
;
7187 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7188 section
, abbrev_section
,
7190 rcuh_kind::COMPILE
);
7192 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7193 if (this_cu
->length
== 0)
7194 this_cu
->length
= cu
->header
.get_length ();
7196 gdb_assert (this_cu
->length
== cu
->header
.get_length ());
7197 this_cu
->dwarf_version
= cu
->header
.version
;
7201 /* Skip dummy compilation units. */
7202 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7203 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7209 /* If we don't have them yet, read the abbrevs for this compilation unit.
7210 And if we need to read them now, make sure they're freed when we're
7212 if (abbrev_table
!= NULL
)
7213 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
7216 m_abbrev_table_holder
7217 = abbrev_table::read (objfile
, abbrev_section
,
7218 cu
->header
.abbrev_sect_off
);
7219 abbrev_table
= m_abbrev_table_holder
.get ();
7222 /* Read the top level CU/TU die. */
7223 init_cu_die_reader (this, cu
, section
, NULL
, abbrev_table
);
7224 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7226 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
7232 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7233 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7234 table from the DWO file and pass the ownership over to us. It will be
7235 referenced from READER, so we must make sure to free it after we're done
7238 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7239 DWO CU, that this test will fail (the attribute will not be present). */
7240 const char *dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7241 if (dwo_name
!= nullptr)
7243 struct dwo_unit
*dwo_unit
;
7244 struct die_info
*dwo_comp_unit_die
;
7246 if (comp_unit_die
->has_children
)
7248 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7249 " has children (offset %s) [in module %s]"),
7250 sect_offset_str (this_cu
->sect_off
),
7251 bfd_get_filename (abfd
));
7253 dwo_unit
= lookup_dwo_unit (cu
, comp_unit_die
, dwo_name
);
7254 if (dwo_unit
!= NULL
)
7256 if (read_cutu_die_from_dwo (cu
, dwo_unit
,
7257 comp_unit_die
, NULL
,
7260 &m_dwo_abbrev_table
) == 0)
7266 comp_unit_die
= dwo_comp_unit_die
;
7270 /* Yikes, we couldn't find the rest of the DIE, we only have
7271 the stub. A complaint has already been logged. There's
7272 not much more we can do except pass on the stub DIE to
7273 die_reader_func. We don't want to throw an error on bad
7280 cutu_reader::keep ()
7282 /* Done, clean up. */
7283 gdb_assert (!dummy_p
);
7284 if (m_new_cu
!= NULL
)
7286 /* Save this dwarf2_cu in the per_objfile. The per_objfile owns it
7288 dwarf2_per_objfile
*per_objfile
= m_new_cu
->per_objfile
;
7289 per_objfile
->set_cu (m_this_cu
, m_new_cu
.release ());
7293 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name (DW_AT_dwo_name)
7294 if present. DWO_FILE, if non-NULL, is the DWO file to read (the caller is
7295 assumed to have already done the lookup to find the DWO file).
7297 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7298 THIS_CU->is_debug_types, but nothing else.
7300 We fill in THIS_CU->length.
7302 THIS_CU->cu is always freed when done.
7303 This is done in order to not leave THIS_CU->cu in a state where we have
7304 to care whether it refers to the "main" CU or the DWO CU.
7306 When parent_cu is passed, it is used to provide a default value for
7307 str_offsets_base and addr_base from the parent. */
7309 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
7310 dwarf2_per_objfile
*per_objfile
,
7311 struct dwarf2_cu
*parent_cu
,
7312 struct dwo_file
*dwo_file
)
7313 : die_reader_specs
{},
7316 struct objfile
*objfile
= per_objfile
->objfile
;
7317 struct dwarf2_section_info
*section
= this_cu
->section
;
7318 bfd
*abfd
= section
->get_bfd_owner ();
7319 struct dwarf2_section_info
*abbrev_section
;
7320 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7322 if (dwarf_die_debug
)
7323 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7324 this_cu
->is_debug_types
? "type" : "comp",
7325 sect_offset_str (this_cu
->sect_off
));
7327 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7329 abbrev_section
= (dwo_file
!= NULL
7330 ? &dwo_file
->sections
.abbrev
7331 : get_abbrev_section_for_cu (this_cu
));
7333 /* This is cheap if the section is already read in. */
7334 section
->read (objfile
);
7336 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7338 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7339 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &m_new_cu
->header
,
7340 section
, abbrev_section
, info_ptr
,
7341 (this_cu
->is_debug_types
7343 : rcuh_kind::COMPILE
));
7345 if (parent_cu
!= nullptr)
7347 m_new_cu
->str_offsets_base
= parent_cu
->str_offsets_base
;
7348 m_new_cu
->addr_base
= parent_cu
->addr_base
;
7350 this_cu
->length
= m_new_cu
->header
.get_length ();
7352 /* Skip dummy compilation units. */
7353 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7354 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7360 m_abbrev_table_holder
7361 = abbrev_table::read (objfile
, abbrev_section
,
7362 m_new_cu
->header
.abbrev_sect_off
);
7364 init_cu_die_reader (this, m_new_cu
.get (), section
, dwo_file
,
7365 m_abbrev_table_holder
.get ());
7366 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7370 /* Type Unit Groups.
7372 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7373 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7374 so that all types coming from the same compilation (.o file) are grouped
7375 together. A future step could be to put the types in the same symtab as
7376 the CU the types ultimately came from. */
7379 hash_type_unit_group (const void *item
)
7381 const struct type_unit_group
*tu_group
7382 = (const struct type_unit_group
*) item
;
7384 return hash_stmt_list_entry (&tu_group
->hash
);
7388 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
7390 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
7391 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
7393 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
7396 /* Allocate a hash table for type unit groups. */
7399 allocate_type_unit_groups_table ()
7401 return htab_up (htab_create_alloc (3,
7402 hash_type_unit_group
,
7404 NULL
, xcalloc
, xfree
));
7407 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7408 partial symtabs. We combine several TUs per psymtab to not let the size
7409 of any one psymtab grow too big. */
7410 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7411 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7413 /* Helper routine for get_type_unit_group.
7414 Create the type_unit_group object used to hold one or more TUs. */
7416 static struct type_unit_group
*
7417 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
7419 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7420 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7421 struct dwarf2_per_cu_data
*per_cu
;
7422 struct type_unit_group
*tu_group
;
7424 tu_group
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, type_unit_group
);
7425 per_cu
= &tu_group
->per_cu
;
7426 per_cu
->per_bfd
= per_bfd
;
7428 if (per_bfd
->using_index
)
7430 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
7431 struct dwarf2_per_cu_quick_data
);
7435 unsigned int line_offset
= to_underlying (line_offset_struct
);
7436 dwarf2_psymtab
*pst
;
7439 /* Give the symtab a useful name for debug purposes. */
7440 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
7441 name
= string_printf ("<type_units_%d>",
7442 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
7444 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
7446 pst
= create_partial_symtab (per_cu
, per_objfile
, name
.c_str ());
7447 pst
->anonymous
= true;
7450 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
7451 tu_group
->hash
.line_sect_off
= line_offset_struct
;
7456 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7457 STMT_LIST is a DW_AT_stmt_list attribute. */
7459 static struct type_unit_group
*
7460 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
7462 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7463 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7464 struct type_unit_group
*tu_group
;
7466 unsigned int line_offset
;
7467 struct type_unit_group type_unit_group_for_lookup
;
7469 if (per_objfile
->per_bfd
->type_unit_groups
== NULL
)
7470 per_objfile
->per_bfd
->type_unit_groups
= allocate_type_unit_groups_table ();
7472 /* Do we need to create a new group, or can we use an existing one? */
7474 if (stmt_list
!= nullptr && stmt_list
->form_is_unsigned ())
7476 line_offset
= stmt_list
->as_unsigned ();
7477 ++tu_stats
->nr_symtab_sharers
;
7481 /* Ugh, no stmt_list. Rare, but we have to handle it.
7482 We can do various things here like create one group per TU or
7483 spread them over multiple groups to split up the expansion work.
7484 To avoid worst case scenarios (too many groups or too large groups)
7485 we, umm, group them in bunches. */
7486 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7487 | (tu_stats
->nr_stmt_less_type_units
7488 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
7489 ++tu_stats
->nr_stmt_less_type_units
;
7492 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
7493 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
7494 slot
= htab_find_slot (per_objfile
->per_bfd
->type_unit_groups
.get (),
7495 &type_unit_group_for_lookup
, INSERT
);
7498 tu_group
= (struct type_unit_group
*) *slot
;
7499 gdb_assert (tu_group
!= NULL
);
7503 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
7504 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
7506 ++tu_stats
->nr_symtabs
;
7512 /* Partial symbol tables. */
7514 /* Create a psymtab named NAME and assign it to PER_CU.
7516 The caller must fill in the following details:
7517 dirname, textlow, texthigh. */
7519 static dwarf2_psymtab
*
7520 create_partial_symtab (dwarf2_per_cu_data
*per_cu
,
7521 dwarf2_per_objfile
*per_objfile
,
7524 struct objfile
*objfile
= per_objfile
->objfile
;
7525 dwarf2_psymtab
*pst
;
7527 pst
= new dwarf2_psymtab (name
, objfile
, per_cu
);
7529 pst
->psymtabs_addrmap_supported
= true;
7531 /* This is the glue that links PST into GDB's symbol API. */
7532 per_cu
->v
.psymtab
= pst
;
7537 /* DIE reader function for process_psymtab_comp_unit. */
7540 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
7541 const gdb_byte
*info_ptr
,
7542 struct die_info
*comp_unit_die
,
7543 enum language pretend_language
)
7545 struct dwarf2_cu
*cu
= reader
->cu
;
7546 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7547 struct objfile
*objfile
= per_objfile
->objfile
;
7548 struct gdbarch
*gdbarch
= objfile
->arch ();
7549 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7551 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
7552 dwarf2_psymtab
*pst
;
7553 enum pc_bounds_kind cu_bounds_kind
;
7554 const char *filename
;
7556 gdb_assert (! per_cu
->is_debug_types
);
7558 prepare_one_comp_unit (cu
, comp_unit_die
, pretend_language
);
7560 /* Allocate a new partial symbol table structure. */
7561 gdb::unique_xmalloc_ptr
<char> debug_filename
;
7562 static const char artificial
[] = "<artificial>";
7563 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
7564 if (filename
== NULL
)
7566 else if (strcmp (filename
, artificial
) == 0)
7568 debug_filename
.reset (concat (artificial
, "@",
7569 sect_offset_str (per_cu
->sect_off
),
7571 filename
= debug_filename
.get ();
7574 pst
= create_partial_symtab (per_cu
, per_objfile
, filename
);
7576 /* This must be done before calling dwarf2_build_include_psymtabs. */
7577 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7579 baseaddr
= objfile
->text_section_offset ();
7581 dwarf2_find_base_address (comp_unit_die
, cu
);
7583 /* Possibly set the default values of LOWPC and HIGHPC from
7585 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
7586 &best_highpc
, cu
, pst
);
7587 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
7590 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
7593 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
7595 /* Store the contiguous range if it is not empty; it can be
7596 empty for CUs with no code. */
7597 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
7601 /* Check if comp unit has_children.
7602 If so, read the rest of the partial symbols from this comp unit.
7603 If not, there's no more debug_info for this comp unit. */
7604 if (comp_unit_die
->has_children
)
7606 struct partial_die_info
*first_die
;
7607 CORE_ADDR lowpc
, highpc
;
7609 lowpc
= ((CORE_ADDR
) -1);
7610 highpc
= ((CORE_ADDR
) 0);
7612 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7614 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
7615 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
7617 /* If we didn't find a lowpc, set it to highpc to avoid
7618 complaints from `maint check'. */
7619 if (lowpc
== ((CORE_ADDR
) -1))
7622 /* If the compilation unit didn't have an explicit address range,
7623 then use the information extracted from its child dies. */
7624 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
7627 best_highpc
= highpc
;
7630 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
7631 best_lowpc
+ baseaddr
)
7633 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
7634 best_highpc
+ baseaddr
)
7639 if (!cu
->per_cu
->imported_symtabs_empty ())
7642 int len
= cu
->per_cu
->imported_symtabs_size ();
7644 /* Fill in 'dependencies' here; we fill in 'users' in a
7646 pst
->number_of_dependencies
= len
;
7648 = objfile
->partial_symtabs
->allocate_dependencies (len
);
7649 for (i
= 0; i
< len
; ++i
)
7651 pst
->dependencies
[i
]
7652 = cu
->per_cu
->imported_symtabs
->at (i
)->v
.psymtab
;
7655 cu
->per_cu
->imported_symtabs_free ();
7658 /* Get the list of files included in the current compilation unit,
7659 and build a psymtab for each of them. */
7660 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
7662 if (dwarf_read_debug
)
7663 fprintf_unfiltered (gdb_stdlog
,
7664 "Psymtab for %s unit @%s: %s - %s"
7665 ", %d global, %d static syms\n",
7666 per_cu
->is_debug_types
? "type" : "comp",
7667 sect_offset_str (per_cu
->sect_off
),
7668 paddress (gdbarch
, pst
->text_low (objfile
)),
7669 paddress (gdbarch
, pst
->text_high (objfile
)),
7670 (int) pst
->global_psymbols
.size (),
7671 (int) pst
->static_psymbols
.size ());
7674 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7675 Process compilation unit THIS_CU for a psymtab. */
7678 process_psymtab_comp_unit (dwarf2_per_cu_data
*this_cu
,
7679 dwarf2_per_objfile
*per_objfile
,
7680 bool want_partial_unit
,
7681 enum language pretend_language
)
7683 /* If this compilation unit was already read in, free the
7684 cached copy in order to read it in again. This is
7685 necessary because we skipped some symbols when we first
7686 read in the compilation unit (see load_partial_dies).
7687 This problem could be avoided, but the benefit is unclear. */
7688 per_objfile
->remove_cu (this_cu
);
7690 cutu_reader
reader (this_cu
, per_objfile
, nullptr, nullptr, false);
7692 switch (reader
.comp_unit_die
->tag
)
7694 case DW_TAG_compile_unit
:
7695 this_cu
->unit_type
= DW_UT_compile
;
7697 case DW_TAG_partial_unit
:
7698 this_cu
->unit_type
= DW_UT_partial
;
7708 else if (this_cu
->is_debug_types
)
7709 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7710 reader
.comp_unit_die
);
7711 else if (want_partial_unit
7712 || reader
.comp_unit_die
->tag
!= DW_TAG_partial_unit
)
7713 process_psymtab_comp_unit_reader (&reader
, reader
.info_ptr
,
7714 reader
.comp_unit_die
,
7717 this_cu
->lang
= reader
.cu
->language
;
7719 /* Age out any secondary CUs. */
7720 per_objfile
->age_comp_units ();
7723 /* Reader function for build_type_psymtabs. */
7726 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
7727 const gdb_byte
*info_ptr
,
7728 struct die_info
*type_unit_die
)
7730 dwarf2_per_objfile
*per_objfile
= reader
->cu
->per_objfile
;
7731 struct dwarf2_cu
*cu
= reader
->cu
;
7732 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7733 struct signatured_type
*sig_type
;
7734 struct type_unit_group
*tu_group
;
7735 struct attribute
*attr
;
7736 struct partial_die_info
*first_die
;
7737 CORE_ADDR lowpc
, highpc
;
7738 dwarf2_psymtab
*pst
;
7740 gdb_assert (per_cu
->is_debug_types
);
7741 sig_type
= (struct signatured_type
*) per_cu
;
7743 if (! type_unit_die
->has_children
)
7746 attr
= type_unit_die
->attr (DW_AT_stmt_list
);
7747 tu_group
= get_type_unit_group (cu
, attr
);
7749 if (tu_group
->tus
== nullptr)
7750 tu_group
->tus
= new std::vector
<signatured_type
*>;
7751 tu_group
->tus
->push_back (sig_type
);
7753 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
7754 pst
= create_partial_symtab (per_cu
, per_objfile
, "");
7755 pst
->anonymous
= true;
7757 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7759 lowpc
= (CORE_ADDR
) -1;
7760 highpc
= (CORE_ADDR
) 0;
7761 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
7766 /* Struct used to sort TUs by their abbreviation table offset. */
7768 struct tu_abbrev_offset
7770 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
7771 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
7774 signatured_type
*sig_type
;
7775 sect_offset abbrev_offset
;
7778 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
7781 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset
&a
,
7782 const struct tu_abbrev_offset
&b
)
7784 return a
.abbrev_offset
< b
.abbrev_offset
;
7787 /* Efficiently read all the type units.
7788 This does the bulk of the work for build_type_psymtabs.
7790 The efficiency is because we sort TUs by the abbrev table they use and
7791 only read each abbrev table once. In one program there are 200K TUs
7792 sharing 8K abbrev tables.
7794 The main purpose of this function is to support building the
7795 dwarf2_per_objfile->per_bfd->type_unit_groups table.
7796 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
7797 can collapse the search space by grouping them by stmt_list.
7798 The savings can be significant, in the same program from above the 200K TUs
7799 share 8K stmt_list tables.
7801 FUNC is expected to call get_type_unit_group, which will create the
7802 struct type_unit_group if necessary and add it to
7803 dwarf2_per_objfile->per_bfd->type_unit_groups. */
7806 build_type_psymtabs_1 (dwarf2_per_objfile
*per_objfile
)
7808 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7809 abbrev_table_up abbrev_table
;
7810 sect_offset abbrev_offset
;
7812 /* It's up to the caller to not call us multiple times. */
7813 gdb_assert (per_objfile
->per_bfd
->type_unit_groups
== NULL
);
7815 if (per_objfile
->per_bfd
->all_type_units
.empty ())
7818 /* TUs typically share abbrev tables, and there can be way more TUs than
7819 abbrev tables. Sort by abbrev table to reduce the number of times we
7820 read each abbrev table in.
7821 Alternatives are to punt or to maintain a cache of abbrev tables.
7822 This is simpler and efficient enough for now.
7824 Later we group TUs by their DW_AT_stmt_list value (as this defines the
7825 symtab to use). Typically TUs with the same abbrev offset have the same
7826 stmt_list value too so in practice this should work well.
7828 The basic algorithm here is:
7830 sort TUs by abbrev table
7831 for each TU with same abbrev table:
7832 read abbrev table if first user
7833 read TU top level DIE
7834 [IWBN if DWO skeletons had DW_AT_stmt_list]
7837 if (dwarf_read_debug
)
7838 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
7840 /* Sort in a separate table to maintain the order of all_type_units
7841 for .gdb_index: TU indices directly index all_type_units. */
7842 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
7843 sorted_by_abbrev
.reserve (per_objfile
->per_bfd
->all_type_units
.size ());
7845 for (signatured_type
*sig_type
: per_objfile
->per_bfd
->all_type_units
)
7846 sorted_by_abbrev
.emplace_back
7847 (sig_type
, read_abbrev_offset (per_objfile
, sig_type
->per_cu
.section
,
7848 sig_type
->per_cu
.sect_off
));
7850 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end (),
7851 sort_tu_by_abbrev_offset
);
7853 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
7855 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
7857 /* Switch to the next abbrev table if necessary. */
7858 if (abbrev_table
== NULL
7859 || tu
.abbrev_offset
!= abbrev_offset
)
7861 abbrev_offset
= tu
.abbrev_offset
;
7863 abbrev_table::read (per_objfile
->objfile
,
7864 &per_objfile
->per_bfd
->abbrev
, abbrev_offset
);
7865 ++tu_stats
->nr_uniq_abbrev_tables
;
7868 cutu_reader
reader (&tu
.sig_type
->per_cu
, per_objfile
,
7869 abbrev_table
.get (), nullptr, false);
7870 if (!reader
.dummy_p
)
7871 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7872 reader
.comp_unit_die
);
7876 /* Print collected type unit statistics. */
7879 print_tu_stats (dwarf2_per_objfile
*per_objfile
)
7881 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7883 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
7884 fprintf_unfiltered (gdb_stdlog
, " %zu TUs\n",
7885 per_objfile
->per_bfd
->all_type_units
.size ());
7886 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
7887 tu_stats
->nr_uniq_abbrev_tables
);
7888 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
7889 tu_stats
->nr_symtabs
);
7890 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
7891 tu_stats
->nr_symtab_sharers
);
7892 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
7893 tu_stats
->nr_stmt_less_type_units
);
7894 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
7895 tu_stats
->nr_all_type_units_reallocs
);
7898 /* Traversal function for build_type_psymtabs. */
7901 build_type_psymtab_dependencies (void **slot
, void *info
)
7903 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7904 struct objfile
*objfile
= per_objfile
->objfile
;
7905 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
7906 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
7907 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
7908 int len
= (tu_group
->tus
== nullptr) ? 0 : tu_group
->tus
->size ();
7911 gdb_assert (len
> 0);
7912 gdb_assert (per_cu
->type_unit_group_p ());
7914 pst
->number_of_dependencies
= len
;
7915 pst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (len
);
7916 for (i
= 0; i
< len
; ++i
)
7918 struct signatured_type
*iter
= tu_group
->tus
->at (i
);
7919 gdb_assert (iter
->per_cu
.is_debug_types
);
7920 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
7921 iter
->type_unit_group
= tu_group
;
7924 delete tu_group
->tus
;
7925 tu_group
->tus
= nullptr;
7930 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7931 Build partial symbol tables for the .debug_types comp-units. */
7934 build_type_psymtabs (dwarf2_per_objfile
*per_objfile
)
7936 if (! create_all_type_units (per_objfile
))
7939 build_type_psymtabs_1 (per_objfile
);
7942 /* Traversal function for process_skeletonless_type_unit.
7943 Read a TU in a DWO file and build partial symbols for it. */
7946 process_skeletonless_type_unit (void **slot
, void *info
)
7948 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
7949 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7950 struct signatured_type find_entry
, *entry
;
7952 /* If this TU doesn't exist in the global table, add it and read it in. */
7954 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
7955 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
7957 find_entry
.signature
= dwo_unit
->signature
;
7958 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
7959 &find_entry
, INSERT
);
7960 /* If we've already seen this type there's nothing to do. What's happening
7961 is we're doing our own version of comdat-folding here. */
7965 /* This does the job that create_all_type_units would have done for
7967 entry
= add_type_unit (per_objfile
, dwo_unit
->signature
, slot
);
7968 fill_in_sig_entry_from_dwo_entry (per_objfile
, entry
, dwo_unit
);
7971 /* This does the job that build_type_psymtabs_1 would have done. */
7972 cutu_reader
reader (&entry
->per_cu
, per_objfile
, nullptr, nullptr, false);
7973 if (!reader
.dummy_p
)
7974 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7975 reader
.comp_unit_die
);
7980 /* Traversal function for process_skeletonless_type_units. */
7983 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
7985 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
7987 if (dwo_file
->tus
!= NULL
)
7988 htab_traverse_noresize (dwo_file
->tus
.get (),
7989 process_skeletonless_type_unit
, info
);
7994 /* Scan all TUs of DWO files, verifying we've processed them.
7995 This is needed in case a TU was emitted without its skeleton.
7996 Note: This can't be done until we know what all the DWO files are. */
7999 process_skeletonless_type_units (dwarf2_per_objfile
*per_objfile
)
8001 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8002 if (get_dwp_file (per_objfile
) == NULL
8003 && per_objfile
->per_bfd
->dwo_files
!= NULL
)
8005 htab_traverse_noresize (per_objfile
->per_bfd
->dwo_files
.get (),
8006 process_dwo_file_for_skeletonless_type_units
,
8011 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8014 set_partial_user (dwarf2_per_objfile
*per_objfile
)
8016 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
8018 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
8023 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
8025 /* Set the 'user' field only if it is not already set. */
8026 if (pst
->dependencies
[j
]->user
== NULL
)
8027 pst
->dependencies
[j
]->user
= pst
;
8032 /* Build the partial symbol table by doing a quick pass through the
8033 .debug_info and .debug_abbrev sections. */
8036 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
)
8038 struct objfile
*objfile
= per_objfile
->objfile
;
8040 if (dwarf_read_debug
)
8042 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
8043 objfile_name (objfile
));
8046 scoped_restore restore_reading_psyms
8047 = make_scoped_restore (&per_objfile
->per_bfd
->reading_partial_symbols
,
8050 per_objfile
->per_bfd
->info
.read (objfile
);
8052 /* Any cached compilation units will be linked by the per-objfile
8053 read_in_chain. Make sure to free them when we're done. */
8054 free_cached_comp_units
freer (per_objfile
);
8056 build_type_psymtabs (per_objfile
);
8058 create_all_comp_units (per_objfile
);
8060 /* Create a temporary address map on a temporary obstack. We later
8061 copy this to the final obstack. */
8062 auto_obstack temp_obstack
;
8064 scoped_restore save_psymtabs_addrmap
8065 = make_scoped_restore (&objfile
->partial_symtabs
->psymtabs_addrmap
,
8066 addrmap_create_mutable (&temp_obstack
));
8068 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
8070 if (per_cu
->v
.psymtab
!= NULL
)
8071 /* In case a forward DW_TAG_imported_unit has read the CU already. */
8073 process_psymtab_comp_unit (per_cu
, per_objfile
, false,
8077 /* This has to wait until we read the CUs, we need the list of DWOs. */
8078 process_skeletonless_type_units (per_objfile
);
8080 /* Now that all TUs have been processed we can fill in the dependencies. */
8081 if (per_objfile
->per_bfd
->type_unit_groups
!= NULL
)
8083 htab_traverse_noresize (per_objfile
->per_bfd
->type_unit_groups
.get (),
8084 build_type_psymtab_dependencies
, per_objfile
);
8087 if (dwarf_read_debug
)
8088 print_tu_stats (per_objfile
);
8090 set_partial_user (per_objfile
);
8092 objfile
->partial_symtabs
->psymtabs_addrmap
8093 = addrmap_create_fixed (objfile
->partial_symtabs
->psymtabs_addrmap
,
8094 objfile
->partial_symtabs
->obstack ());
8095 /* At this point we want to keep the address map. */
8096 save_psymtabs_addrmap
.release ();
8098 if (dwarf_read_debug
)
8099 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
8100 objfile_name (objfile
));
8103 /* Load the partial DIEs for a secondary CU into memory.
8104 This is also used when rereading a primary CU with load_all_dies. */
8107 load_partial_comp_unit (dwarf2_per_cu_data
*this_cu
,
8108 dwarf2_per_objfile
*per_objfile
,
8109 dwarf2_cu
*existing_cu
)
8111 cutu_reader
reader (this_cu
, per_objfile
, nullptr, existing_cu
, false);
8113 if (!reader
.dummy_p
)
8115 prepare_one_comp_unit (reader
.cu
, reader
.comp_unit_die
,
8118 /* Check if comp unit has_children.
8119 If so, read the rest of the partial symbols from this comp unit.
8120 If not, there's no more debug_info for this comp unit. */
8121 if (reader
.comp_unit_die
->has_children
)
8122 load_partial_dies (&reader
, reader
.info_ptr
, 0);
8129 read_comp_units_from_section (dwarf2_per_objfile
*per_objfile
,
8130 struct dwarf2_section_info
*section
,
8131 struct dwarf2_section_info
*abbrev_section
,
8132 unsigned int is_dwz
)
8134 const gdb_byte
*info_ptr
;
8135 struct objfile
*objfile
= per_objfile
->objfile
;
8137 if (dwarf_read_debug
)
8138 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
8139 section
->get_name (),
8140 section
->get_file_name ());
8142 section
->read (objfile
);
8144 info_ptr
= section
->buffer
;
8146 while (info_ptr
< section
->buffer
+ section
->size
)
8148 struct dwarf2_per_cu_data
*this_cu
;
8150 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
8152 comp_unit_head cu_header
;
8153 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
8154 abbrev_section
, info_ptr
,
8155 rcuh_kind::COMPILE
);
8157 /* Save the compilation unit for later lookup. */
8158 if (cu_header
.unit_type
!= DW_UT_type
)
8159 this_cu
= per_objfile
->per_bfd
->allocate_per_cu ();
8162 auto sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
8163 sig_type
->signature
= cu_header
.signature
;
8164 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
8165 this_cu
= &sig_type
->per_cu
;
8167 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
8168 this_cu
->sect_off
= sect_off
;
8169 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
8170 this_cu
->is_dwz
= is_dwz
;
8171 this_cu
->section
= section
;
8173 per_objfile
->per_bfd
->all_comp_units
.push_back (this_cu
);
8175 info_ptr
= info_ptr
+ this_cu
->length
;
8179 /* Create a list of all compilation units in OBJFILE.
8180 This is only done for -readnow and building partial symtabs. */
8183 create_all_comp_units (dwarf2_per_objfile
*per_objfile
)
8185 gdb_assert (per_objfile
->per_bfd
->all_comp_units
.empty ());
8186 read_comp_units_from_section (per_objfile
, &per_objfile
->per_bfd
->info
,
8187 &per_objfile
->per_bfd
->abbrev
, 0);
8189 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
8191 read_comp_units_from_section (per_objfile
, &dwz
->info
, &dwz
->abbrev
, 1);
8194 /* Process all loaded DIEs for compilation unit CU, starting at
8195 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8196 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8197 DW_AT_ranges). See the comments of add_partial_subprogram on how
8198 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8201 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
8202 CORE_ADDR
*highpc
, int set_addrmap
,
8203 struct dwarf2_cu
*cu
)
8205 struct partial_die_info
*pdi
;
8207 /* Now, march along the PDI's, descending into ones which have
8208 interesting children but skipping the children of the other ones,
8209 until we reach the end of the compilation unit. */
8217 /* Anonymous namespaces or modules have no name but have interesting
8218 children, so we need to look at them. Ditto for anonymous
8221 if (pdi
->raw_name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
8222 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
8223 || pdi
->tag
== DW_TAG_imported_unit
8224 || pdi
->tag
== DW_TAG_inlined_subroutine
)
8228 case DW_TAG_subprogram
:
8229 case DW_TAG_inlined_subroutine
:
8230 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8231 if (cu
->language
== language_cplus
)
8232 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8235 case DW_TAG_constant
:
8236 case DW_TAG_variable
:
8237 case DW_TAG_typedef
:
8238 case DW_TAG_union_type
:
8239 if (!pdi
->is_declaration
8240 || (pdi
->tag
== DW_TAG_variable
&& pdi
->is_external
))
8242 add_partial_symbol (pdi
, cu
);
8245 case DW_TAG_class_type
:
8246 case DW_TAG_interface_type
:
8247 case DW_TAG_structure_type
:
8248 if (!pdi
->is_declaration
)
8250 add_partial_symbol (pdi
, cu
);
8252 if ((cu
->language
== language_rust
8253 || cu
->language
== language_cplus
) && pdi
->has_children
)
8254 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8257 case DW_TAG_enumeration_type
:
8258 if (!pdi
->is_declaration
)
8259 add_partial_enumeration (pdi
, cu
);
8261 case DW_TAG_base_type
:
8262 case DW_TAG_subrange_type
:
8263 /* File scope base type definitions are added to the partial
8265 add_partial_symbol (pdi
, cu
);
8267 case DW_TAG_namespace
:
8268 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8271 if (!pdi
->is_declaration
)
8272 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8274 case DW_TAG_imported_unit
:
8276 struct dwarf2_per_cu_data
*per_cu
;
8278 /* For now we don't handle imported units in type units. */
8279 if (cu
->per_cu
->is_debug_types
)
8281 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8282 " supported in type units [in module %s]"),
8283 objfile_name (cu
->per_objfile
->objfile
));
8286 per_cu
= dwarf2_find_containing_comp_unit
8287 (pdi
->d
.sect_off
, pdi
->is_dwz
, cu
->per_objfile
);
8289 /* Go read the partial unit, if needed. */
8290 if (per_cu
->v
.psymtab
== NULL
)
8291 process_psymtab_comp_unit (per_cu
, cu
->per_objfile
, true,
8294 cu
->per_cu
->imported_symtabs_push (per_cu
);
8297 case DW_TAG_imported_declaration
:
8298 add_partial_symbol (pdi
, cu
);
8305 /* If the die has a sibling, skip to the sibling. */
8307 pdi
= pdi
->die_sibling
;
8311 /* Functions used to compute the fully scoped name of a partial DIE.
8313 Normally, this is simple. For C++, the parent DIE's fully scoped
8314 name is concatenated with "::" and the partial DIE's name.
8315 Enumerators are an exception; they use the scope of their parent
8316 enumeration type, i.e. the name of the enumeration type is not
8317 prepended to the enumerator.
8319 There are two complexities. One is DW_AT_specification; in this
8320 case "parent" means the parent of the target of the specification,
8321 instead of the direct parent of the DIE. The other is compilers
8322 which do not emit DW_TAG_namespace; in this case we try to guess
8323 the fully qualified name of structure types from their members'
8324 linkage names. This must be done using the DIE's children rather
8325 than the children of any DW_AT_specification target. We only need
8326 to do this for structures at the top level, i.e. if the target of
8327 any DW_AT_specification (if any; otherwise the DIE itself) does not
8330 /* Compute the scope prefix associated with PDI's parent, in
8331 compilation unit CU. The result will be allocated on CU's
8332 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8333 field. NULL is returned if no prefix is necessary. */
8335 partial_die_parent_scope (struct partial_die_info
*pdi
,
8336 struct dwarf2_cu
*cu
)
8338 const char *grandparent_scope
;
8339 struct partial_die_info
*parent
, *real_pdi
;
8341 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8342 then this means the parent of the specification DIE. */
8345 while (real_pdi
->has_specification
)
8347 auto res
= find_partial_die (real_pdi
->spec_offset
,
8348 real_pdi
->spec_is_dwz
, cu
);
8353 parent
= real_pdi
->die_parent
;
8357 if (parent
->scope_set
)
8358 return parent
->scope
;
8362 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
8364 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8365 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8366 Work around this problem here. */
8367 if (cu
->language
== language_cplus
8368 && parent
->tag
== DW_TAG_namespace
8369 && strcmp (parent
->name (cu
), "::") == 0
8370 && grandparent_scope
== NULL
)
8372 parent
->scope
= NULL
;
8373 parent
->scope_set
= 1;
8377 /* Nested subroutines in Fortran get a prefix. */
8378 if (pdi
->tag
== DW_TAG_enumerator
)
8379 /* Enumerators should not get the name of the enumeration as a prefix. */
8380 parent
->scope
= grandparent_scope
;
8381 else if (parent
->tag
== DW_TAG_namespace
8382 || parent
->tag
== DW_TAG_module
8383 || parent
->tag
== DW_TAG_structure_type
8384 || parent
->tag
== DW_TAG_class_type
8385 || parent
->tag
== DW_TAG_interface_type
8386 || parent
->tag
== DW_TAG_union_type
8387 || parent
->tag
== DW_TAG_enumeration_type
8388 || (cu
->language
== language_fortran
8389 && parent
->tag
== DW_TAG_subprogram
8390 && pdi
->tag
== DW_TAG_subprogram
))
8392 if (grandparent_scope
== NULL
)
8393 parent
->scope
= parent
->name (cu
);
8395 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
8397 parent
->name (cu
), 0, cu
);
8401 /* FIXME drow/2004-04-01: What should we be doing with
8402 function-local names? For partial symbols, we should probably be
8404 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8405 dwarf_tag_name (parent
->tag
),
8406 sect_offset_str (pdi
->sect_off
));
8407 parent
->scope
= grandparent_scope
;
8410 parent
->scope_set
= 1;
8411 return parent
->scope
;
8414 /* Return the fully scoped name associated with PDI, from compilation unit
8415 CU. The result will be allocated with malloc. */
8417 static gdb::unique_xmalloc_ptr
<char>
8418 partial_die_full_name (struct partial_die_info
*pdi
,
8419 struct dwarf2_cu
*cu
)
8421 const char *parent_scope
;
8423 /* If this is a template instantiation, we can not work out the
8424 template arguments from partial DIEs. So, unfortunately, we have
8425 to go through the full DIEs. At least any work we do building
8426 types here will be reused if full symbols are loaded later. */
8427 if (pdi
->has_template_arguments
)
8431 if (pdi
->name (cu
) != NULL
&& strchr (pdi
->name (cu
), '<') == NULL
)
8433 struct die_info
*die
;
8434 struct attribute attr
;
8435 struct dwarf2_cu
*ref_cu
= cu
;
8437 /* DW_FORM_ref_addr is using section offset. */
8438 attr
.name
= (enum dwarf_attribute
) 0;
8439 attr
.form
= DW_FORM_ref_addr
;
8440 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
8441 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
8443 return make_unique_xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
8447 parent_scope
= partial_die_parent_scope (pdi
, cu
);
8448 if (parent_scope
== NULL
)
8451 return gdb::unique_xmalloc_ptr
<char> (typename_concat (NULL
, parent_scope
,
8457 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
8459 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
8460 struct objfile
*objfile
= per_objfile
->objfile
;
8461 struct gdbarch
*gdbarch
= objfile
->arch ();
8463 const char *actual_name
= NULL
;
8466 baseaddr
= objfile
->text_section_offset ();
8468 gdb::unique_xmalloc_ptr
<char> built_actual_name
8469 = partial_die_full_name (pdi
, cu
);
8470 if (built_actual_name
!= NULL
)
8471 actual_name
= built_actual_name
.get ();
8473 if (actual_name
== NULL
)
8474 actual_name
= pdi
->name (cu
);
8476 partial_symbol psymbol
;
8477 memset (&psymbol
, 0, sizeof (psymbol
));
8478 psymbol
.ginfo
.set_language (cu
->language
, &objfile
->objfile_obstack
);
8479 psymbol
.ginfo
.section
= -1;
8481 /* The code below indicates that the psymbol should be installed by
8483 gdb::optional
<psymbol_placement
> where
;
8487 case DW_TAG_inlined_subroutine
:
8488 case DW_TAG_subprogram
:
8489 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
8491 if (pdi
->is_external
8492 || cu
->language
== language_ada
8493 || (cu
->language
== language_fortran
8494 && pdi
->die_parent
!= NULL
8495 && pdi
->die_parent
->tag
== DW_TAG_subprogram
))
8497 /* Normally, only "external" DIEs are part of the global scope.
8498 But in Ada and Fortran, we want to be able to access nested
8499 procedures globally. So all Ada and Fortran subprograms are
8500 stored in the global scope. */
8501 where
= psymbol_placement::GLOBAL
;
8504 where
= psymbol_placement::STATIC
;
8506 psymbol
.domain
= VAR_DOMAIN
;
8507 psymbol
.aclass
= LOC_BLOCK
;
8508 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8509 psymbol
.ginfo
.value
.address
= addr
;
8511 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8512 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
8514 case DW_TAG_constant
:
8515 psymbol
.domain
= VAR_DOMAIN
;
8516 psymbol
.aclass
= LOC_STATIC
;
8517 where
= (pdi
->is_external
8518 ? psymbol_placement::GLOBAL
8519 : psymbol_placement::STATIC
);
8521 case DW_TAG_variable
:
8523 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
8527 && !per_objfile
->per_bfd
->has_section_at_zero
)
8529 /* A global or static variable may also have been stripped
8530 out by the linker if unused, in which case its address
8531 will be nullified; do not add such variables into partial
8532 symbol table then. */
8534 else if (pdi
->is_external
)
8537 Don't enter into the minimal symbol tables as there is
8538 a minimal symbol table entry from the ELF symbols already.
8539 Enter into partial symbol table if it has a location
8540 descriptor or a type.
8541 If the location descriptor is missing, new_symbol will create
8542 a LOC_UNRESOLVED symbol, the address of the variable will then
8543 be determined from the minimal symbol table whenever the variable
8545 The address for the partial symbol table entry is not
8546 used by GDB, but it comes in handy for debugging partial symbol
8549 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8551 psymbol
.domain
= VAR_DOMAIN
;
8552 psymbol
.aclass
= LOC_STATIC
;
8553 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8554 psymbol
.ginfo
.value
.address
= addr
;
8555 where
= psymbol_placement::GLOBAL
;
8560 int has_loc
= pdi
->d
.locdesc
!= NULL
;
8562 /* Static Variable. Skip symbols whose value we cannot know (those
8563 without location descriptors or constant values). */
8564 if (!has_loc
&& !pdi
->has_const_value
)
8567 psymbol
.domain
= VAR_DOMAIN
;
8568 psymbol
.aclass
= LOC_STATIC
;
8569 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8571 psymbol
.ginfo
.value
.address
= addr
;
8572 where
= psymbol_placement::STATIC
;
8575 case DW_TAG_typedef
:
8576 case DW_TAG_base_type
:
8577 case DW_TAG_subrange_type
:
8578 psymbol
.domain
= VAR_DOMAIN
;
8579 psymbol
.aclass
= LOC_TYPEDEF
;
8580 where
= psymbol_placement::STATIC
;
8582 case DW_TAG_imported_declaration
:
8583 case DW_TAG_namespace
:
8584 psymbol
.domain
= VAR_DOMAIN
;
8585 psymbol
.aclass
= LOC_TYPEDEF
;
8586 where
= psymbol_placement::GLOBAL
;
8589 /* With Fortran 77 there might be a "BLOCK DATA" module
8590 available without any name. If so, we skip the module as it
8591 doesn't bring any value. */
8592 if (actual_name
!= nullptr)
8594 psymbol
.domain
= MODULE_DOMAIN
;
8595 psymbol
.aclass
= LOC_TYPEDEF
;
8596 where
= psymbol_placement::GLOBAL
;
8599 case DW_TAG_class_type
:
8600 case DW_TAG_interface_type
:
8601 case DW_TAG_structure_type
:
8602 case DW_TAG_union_type
:
8603 case DW_TAG_enumeration_type
:
8604 /* Skip external references. The DWARF standard says in the section
8605 about "Structure, Union, and Class Type Entries": "An incomplete
8606 structure, union or class type is represented by a structure,
8607 union or class entry that does not have a byte size attribute
8608 and that has a DW_AT_declaration attribute." */
8609 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
8612 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8613 static vs. global. */
8614 psymbol
.domain
= STRUCT_DOMAIN
;
8615 psymbol
.aclass
= LOC_TYPEDEF
;
8616 where
= (cu
->language
== language_cplus
8617 ? psymbol_placement::GLOBAL
8618 : psymbol_placement::STATIC
);
8620 case DW_TAG_enumerator
:
8621 psymbol
.domain
= VAR_DOMAIN
;
8622 psymbol
.aclass
= LOC_CONST
;
8623 where
= (cu
->language
== language_cplus
8624 ? psymbol_placement::GLOBAL
8625 : psymbol_placement::STATIC
);
8631 if (where
.has_value ())
8633 if (built_actual_name
!= nullptr)
8634 actual_name
= objfile
->intern (actual_name
);
8635 if (pdi
->linkage_name
== nullptr || cu
->language
== language_ada
)
8636 psymbol
.ginfo
.set_linkage_name (actual_name
);
8639 psymbol
.ginfo
.set_demangled_name (actual_name
,
8640 &objfile
->objfile_obstack
);
8641 psymbol
.ginfo
.set_linkage_name (pdi
->linkage_name
);
8643 cu
->per_cu
->v
.psymtab
->add_psymbol (psymbol
, *where
, objfile
);
8647 /* Read a partial die corresponding to a namespace; also, add a symbol
8648 corresponding to that namespace to the symbol table. NAMESPACE is
8649 the name of the enclosing namespace. */
8652 add_partial_namespace (struct partial_die_info
*pdi
,
8653 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8654 int set_addrmap
, struct dwarf2_cu
*cu
)
8656 /* Add a symbol for the namespace. */
8658 add_partial_symbol (pdi
, cu
);
8660 /* Now scan partial symbols in that namespace. */
8662 if (pdi
->has_children
)
8663 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8666 /* Read a partial die corresponding to a Fortran module. */
8669 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
8670 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
8672 /* Add a symbol for the namespace. */
8674 add_partial_symbol (pdi
, cu
);
8676 /* Now scan partial symbols in that module. */
8678 if (pdi
->has_children
)
8679 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8682 /* Read a partial die corresponding to a subprogram or an inlined
8683 subprogram and create a partial symbol for that subprogram.
8684 When the CU language allows it, this routine also defines a partial
8685 symbol for each nested subprogram that this subprogram contains.
8686 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
8687 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
8689 PDI may also be a lexical block, in which case we simply search
8690 recursively for subprograms defined inside that lexical block.
8691 Again, this is only performed when the CU language allows this
8692 type of definitions. */
8695 add_partial_subprogram (struct partial_die_info
*pdi
,
8696 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8697 int set_addrmap
, struct dwarf2_cu
*cu
)
8699 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
8701 if (pdi
->has_pc_info
)
8703 if (pdi
->lowpc
< *lowpc
)
8704 *lowpc
= pdi
->lowpc
;
8705 if (pdi
->highpc
> *highpc
)
8706 *highpc
= pdi
->highpc
;
8709 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8710 struct gdbarch
*gdbarch
= objfile
->arch ();
8712 CORE_ADDR this_highpc
;
8713 CORE_ADDR this_lowpc
;
8715 baseaddr
= objfile
->text_section_offset ();
8717 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8718 pdi
->lowpc
+ baseaddr
)
8721 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8722 pdi
->highpc
+ baseaddr
)
8724 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
8725 this_lowpc
, this_highpc
- 1,
8726 cu
->per_cu
->v
.psymtab
);
8730 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
8732 if (!pdi
->is_declaration
)
8733 /* Ignore subprogram DIEs that do not have a name, they are
8734 illegal. Do not emit a complaint at this point, we will
8735 do so when we convert this psymtab into a symtab. */
8737 add_partial_symbol (pdi
, cu
);
8741 if (! pdi
->has_children
)
8744 if (cu
->language
== language_ada
|| cu
->language
== language_fortran
)
8746 pdi
= pdi
->die_child
;
8750 if (pdi
->tag
== DW_TAG_subprogram
8751 || pdi
->tag
== DW_TAG_inlined_subroutine
8752 || pdi
->tag
== DW_TAG_lexical_block
)
8753 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8754 pdi
= pdi
->die_sibling
;
8759 /* Read a partial die corresponding to an enumeration type. */
8762 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
8763 struct dwarf2_cu
*cu
)
8765 struct partial_die_info
*pdi
;
8767 if (enum_pdi
->name (cu
) != NULL
)
8768 add_partial_symbol (enum_pdi
, cu
);
8770 pdi
= enum_pdi
->die_child
;
8773 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->raw_name
== NULL
)
8774 complaint (_("malformed enumerator DIE ignored"));
8776 add_partial_symbol (pdi
, cu
);
8777 pdi
= pdi
->die_sibling
;
8781 /* Return the initial uleb128 in the die at INFO_PTR. */
8784 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
8786 unsigned int bytes_read
;
8788 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8791 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
8792 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
8794 Return the corresponding abbrev, or NULL if the number is zero (indicating
8795 an empty DIE). In either case *BYTES_READ will be set to the length of
8796 the initial number. */
8798 static struct abbrev_info
*
8799 peek_die_abbrev (const die_reader_specs
&reader
,
8800 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
8802 dwarf2_cu
*cu
= reader
.cu
;
8803 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
8804 unsigned int abbrev_number
8805 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
8807 if (abbrev_number
== 0)
8810 abbrev_info
*abbrev
= reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
8813 error (_("Dwarf Error: Could not find abbrev number %d in %s"
8814 " at offset %s [in module %s]"),
8815 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
8816 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
8822 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8823 Returns a pointer to the end of a series of DIEs, terminated by an empty
8824 DIE. Any children of the skipped DIEs will also be skipped. */
8826 static const gdb_byte
*
8827 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
8831 unsigned int bytes_read
;
8832 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
8835 return info_ptr
+ bytes_read
;
8837 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
8841 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8842 INFO_PTR should point just after the initial uleb128 of a DIE, and the
8843 abbrev corresponding to that skipped uleb128 should be passed in
8844 ABBREV. Returns a pointer to this DIE's sibling, skipping any
8847 static const gdb_byte
*
8848 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
8849 struct abbrev_info
*abbrev
)
8851 unsigned int bytes_read
;
8852 struct attribute attr
;
8853 bfd
*abfd
= reader
->abfd
;
8854 struct dwarf2_cu
*cu
= reader
->cu
;
8855 const gdb_byte
*buffer
= reader
->buffer
;
8856 const gdb_byte
*buffer_end
= reader
->buffer_end
;
8857 unsigned int form
, i
;
8859 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
8861 /* The only abbrev we care about is DW_AT_sibling. */
8862 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
8864 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
8865 if (attr
.form
== DW_FORM_ref_addr
)
8866 complaint (_("ignoring absolute DW_AT_sibling"));
8869 sect_offset off
= attr
.get_ref_die_offset ();
8870 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
8872 if (sibling_ptr
< info_ptr
)
8873 complaint (_("DW_AT_sibling points backwards"));
8874 else if (sibling_ptr
> reader
->buffer_end
)
8875 reader
->die_section
->overflow_complaint ();
8881 /* If it isn't DW_AT_sibling, skip this attribute. */
8882 form
= abbrev
->attrs
[i
].form
;
8886 case DW_FORM_ref_addr
:
8887 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
8888 and later it is offset sized. */
8889 if (cu
->header
.version
== 2)
8890 info_ptr
+= cu
->header
.addr_size
;
8892 info_ptr
+= cu
->header
.offset_size
;
8894 case DW_FORM_GNU_ref_alt
:
8895 info_ptr
+= cu
->header
.offset_size
;
8898 info_ptr
+= cu
->header
.addr_size
;
8906 case DW_FORM_flag_present
:
8907 case DW_FORM_implicit_const
:
8924 case DW_FORM_ref_sig8
:
8927 case DW_FORM_data16
:
8930 case DW_FORM_string
:
8931 read_direct_string (abfd
, info_ptr
, &bytes_read
);
8932 info_ptr
+= bytes_read
;
8934 case DW_FORM_sec_offset
:
8936 case DW_FORM_GNU_strp_alt
:
8937 info_ptr
+= cu
->header
.offset_size
;
8939 case DW_FORM_exprloc
:
8941 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8942 info_ptr
+= bytes_read
;
8944 case DW_FORM_block1
:
8945 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
8947 case DW_FORM_block2
:
8948 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
8950 case DW_FORM_block4
:
8951 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
8957 case DW_FORM_ref_udata
:
8958 case DW_FORM_GNU_addr_index
:
8959 case DW_FORM_GNU_str_index
:
8960 case DW_FORM_rnglistx
:
8961 case DW_FORM_loclistx
:
8962 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
8964 case DW_FORM_indirect
:
8965 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8966 info_ptr
+= bytes_read
;
8967 /* We need to continue parsing from here, so just go back to
8969 goto skip_attribute
;
8972 error (_("Dwarf Error: Cannot handle %s "
8973 "in DWARF reader [in module %s]"),
8974 dwarf_form_name (form
),
8975 bfd_get_filename (abfd
));
8979 if (abbrev
->has_children
)
8980 return skip_children (reader
, info_ptr
);
8985 /* Locate ORIG_PDI's sibling.
8986 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
8988 static const gdb_byte
*
8989 locate_pdi_sibling (const struct die_reader_specs
*reader
,
8990 struct partial_die_info
*orig_pdi
,
8991 const gdb_byte
*info_ptr
)
8993 /* Do we know the sibling already? */
8995 if (orig_pdi
->sibling
)
8996 return orig_pdi
->sibling
;
8998 /* Are there any children to deal with? */
9000 if (!orig_pdi
->has_children
)
9003 /* Skip the children the long way. */
9005 return skip_children (reader
, info_ptr
);
9008 /* Expand this partial symbol table into a full symbol table. SELF is
9012 dwarf2_psymtab::read_symtab (struct objfile
*objfile
)
9014 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9016 gdb_assert (!per_objfile
->symtab_set_p (per_cu_data
));
9018 /* If this psymtab is constructed from a debug-only objfile, the
9019 has_section_at_zero flag will not necessarily be correct. We
9020 can get the correct value for this flag by looking at the data
9021 associated with the (presumably stripped) associated objfile. */
9022 if (objfile
->separate_debug_objfile_backlink
)
9024 dwarf2_per_objfile
*per_objfile_backlink
9025 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
9027 per_objfile
->per_bfd
->has_section_at_zero
9028 = per_objfile_backlink
->per_bfd
->has_section_at_zero
;
9031 expand_psymtab (objfile
);
9033 process_cu_includes (per_objfile
);
9036 /* Reading in full CUs. */
9038 /* Add PER_CU to the queue. */
9041 queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
9042 dwarf2_per_objfile
*per_objfile
,
9043 enum language pretend_language
)
9046 per_cu
->per_bfd
->queue
.emplace (per_cu
, per_objfile
, pretend_language
);
9049 /* If PER_CU is not yet queued, add it to the queue.
9050 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9052 The result is non-zero if PER_CU was queued, otherwise the result is zero
9053 meaning either PER_CU is already queued or it is already loaded.
9055 N.B. There is an invariant here that if a CU is queued then it is loaded.
9056 The caller is required to load PER_CU if we return non-zero. */
9059 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
9060 dwarf2_per_cu_data
*per_cu
,
9061 dwarf2_per_objfile
*per_objfile
,
9062 enum language pretend_language
)
9064 /* We may arrive here during partial symbol reading, if we need full
9065 DIEs to process an unusual case (e.g. template arguments). Do
9066 not queue PER_CU, just tell our caller to load its DIEs. */
9067 if (per_cu
->per_bfd
->reading_partial_symbols
)
9069 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9071 if (cu
== NULL
|| cu
->dies
== NULL
)
9076 /* Mark the dependence relation so that we don't flush PER_CU
9078 if (dependent_cu
!= NULL
)
9079 dwarf2_add_dependence (dependent_cu
, per_cu
);
9081 /* If it's already on the queue, we have nothing to do. */
9085 /* If the compilation unit is already loaded, just mark it as
9087 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9094 /* Add it to the queue. */
9095 queue_comp_unit (per_cu
, per_objfile
, pretend_language
);
9100 /* Process the queue. */
9103 process_queue (dwarf2_per_objfile
*per_objfile
)
9105 if (dwarf_read_debug
)
9107 fprintf_unfiltered (gdb_stdlog
,
9108 "Expanding one or more symtabs of objfile %s ...\n",
9109 objfile_name (per_objfile
->objfile
));
9112 /* The queue starts out with one item, but following a DIE reference
9113 may load a new CU, adding it to the end of the queue. */
9114 while (!per_objfile
->per_bfd
->queue
.empty ())
9116 dwarf2_queue_item
&item
= per_objfile
->per_bfd
->queue
.front ();
9117 dwarf2_per_cu_data
*per_cu
= item
.per_cu
;
9119 if (!per_objfile
->symtab_set_p (per_cu
))
9121 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9123 /* Skip dummy CUs. */
9126 unsigned int debug_print_threshold
;
9129 if (per_cu
->is_debug_types
)
9131 struct signatured_type
*sig_type
=
9132 (struct signatured_type
*) per_cu
;
9134 sprintf (buf
, "TU %s at offset %s",
9135 hex_string (sig_type
->signature
),
9136 sect_offset_str (per_cu
->sect_off
));
9137 /* There can be 100s of TUs.
9138 Only print them in verbose mode. */
9139 debug_print_threshold
= 2;
9143 sprintf (buf
, "CU at offset %s",
9144 sect_offset_str (per_cu
->sect_off
));
9145 debug_print_threshold
= 1;
9148 if (dwarf_read_debug
>= debug_print_threshold
)
9149 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
9151 if (per_cu
->is_debug_types
)
9152 process_full_type_unit (cu
, item
.pretend_language
);
9154 process_full_comp_unit (cu
, item
.pretend_language
);
9156 if (dwarf_read_debug
>= debug_print_threshold
)
9157 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
9162 per_objfile
->per_bfd
->queue
.pop ();
9165 if (dwarf_read_debug
)
9167 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
9168 objfile_name (per_objfile
->objfile
));
9172 /* Read in full symbols for PST, and anything it depends on. */
9175 dwarf2_psymtab::expand_psymtab (struct objfile
*objfile
)
9177 gdb_assert (!readin_p (objfile
));
9179 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9180 free_cached_comp_units
freer (per_objfile
);
9181 expand_dependencies (objfile
);
9183 dw2_do_instantiate_symtab (per_cu_data
, per_objfile
, false);
9184 gdb_assert (get_compunit_symtab (objfile
) != nullptr);
9187 /* See psympriv.h. */
9190 dwarf2_psymtab::readin_p (struct objfile
*objfile
) const
9192 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9193 return per_objfile
->symtab_set_p (per_cu_data
);
9196 /* See psympriv.h. */
9199 dwarf2_psymtab::get_compunit_symtab (struct objfile
*objfile
) const
9201 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9202 return per_objfile
->get_symtab (per_cu_data
);
9205 /* Trivial hash function for die_info: the hash value of a DIE
9206 is its offset in .debug_info for this objfile. */
9209 die_hash (const void *item
)
9211 const struct die_info
*die
= (const struct die_info
*) item
;
9213 return to_underlying (die
->sect_off
);
9216 /* Trivial comparison function for die_info structures: two DIEs
9217 are equal if they have the same offset. */
9220 die_eq (const void *item_lhs
, const void *item_rhs
)
9222 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
9223 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
9225 return die_lhs
->sect_off
== die_rhs
->sect_off
;
9228 /* Load the DIEs associated with PER_CU into memory.
9230 In some cases, the caller, while reading partial symbols, will need to load
9231 the full symbols for the CU for some reason. It will already have a
9232 dwarf2_cu object for THIS_CU and pass it as EXISTING_CU, so it can be re-used
9233 rather than creating a new one. */
9236 load_full_comp_unit (dwarf2_per_cu_data
*this_cu
,
9237 dwarf2_per_objfile
*per_objfile
,
9238 dwarf2_cu
*existing_cu
,
9240 enum language pretend_language
)
9242 gdb_assert (! this_cu
->is_debug_types
);
9244 cutu_reader
reader (this_cu
, per_objfile
, NULL
, existing_cu
, skip_partial
);
9248 struct dwarf2_cu
*cu
= reader
.cu
;
9249 const gdb_byte
*info_ptr
= reader
.info_ptr
;
9251 gdb_assert (cu
->die_hash
== NULL
);
9253 htab_create_alloc_ex (cu
->header
.length
/ 12,
9257 &cu
->comp_unit_obstack
,
9258 hashtab_obstack_allocate
,
9259 dummy_obstack_deallocate
);
9261 if (reader
.comp_unit_die
->has_children
)
9262 reader
.comp_unit_die
->child
9263 = read_die_and_siblings (&reader
, reader
.info_ptr
,
9264 &info_ptr
, reader
.comp_unit_die
);
9265 cu
->dies
= reader
.comp_unit_die
;
9266 /* comp_unit_die is not stored in die_hash, no need. */
9268 /* We try not to read any attributes in this function, because not
9269 all CUs needed for references have been loaded yet, and symbol
9270 table processing isn't initialized. But we have to set the CU language,
9271 or we won't be able to build types correctly.
9272 Similarly, if we do not read the producer, we can not apply
9273 producer-specific interpretation. */
9274 prepare_one_comp_unit (cu
, cu
->dies
, pretend_language
);
9279 /* Add a DIE to the delayed physname list. */
9282 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
9283 const char *name
, struct die_info
*die
,
9284 struct dwarf2_cu
*cu
)
9286 struct delayed_method_info mi
;
9288 mi
.fnfield_index
= fnfield_index
;
9292 cu
->method_list
.push_back (mi
);
9295 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9296 "const" / "volatile". If so, decrements LEN by the length of the
9297 modifier and return true. Otherwise return false. */
9301 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
9303 size_t mod_len
= sizeof (mod
) - 1;
9304 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
9312 /* Compute the physnames of any methods on the CU's method list.
9314 The computation of method physnames is delayed in order to avoid the
9315 (bad) condition that one of the method's formal parameters is of an as yet
9319 compute_delayed_physnames (struct dwarf2_cu
*cu
)
9321 /* Only C++ delays computing physnames. */
9322 if (cu
->method_list
.empty ())
9324 gdb_assert (cu
->language
== language_cplus
);
9326 for (const delayed_method_info
&mi
: cu
->method_list
)
9328 const char *physname
;
9329 struct fn_fieldlist
*fn_flp
9330 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
9331 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
9332 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
9333 = physname
? physname
: "";
9335 /* Since there's no tag to indicate whether a method is a
9336 const/volatile overload, extract that information out of the
9338 if (physname
!= NULL
)
9340 size_t len
= strlen (physname
);
9344 if (physname
[len
] == ')') /* shortcut */
9346 else if (check_modifier (physname
, len
, " const"))
9347 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
9348 else if (check_modifier (physname
, len
, " volatile"))
9349 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
9356 /* The list is no longer needed. */
9357 cu
->method_list
.clear ();
9360 /* Go objects should be embedded in a DW_TAG_module DIE,
9361 and it's not clear if/how imported objects will appear.
9362 To keep Go support simple until that's worked out,
9363 go back through what we've read and create something usable.
9364 We could do this while processing each DIE, and feels kinda cleaner,
9365 but that way is more invasive.
9366 This is to, for example, allow the user to type "p var" or "b main"
9367 without having to specify the package name, and allow lookups
9368 of module.object to work in contexts that use the expression
9372 fixup_go_packaging (struct dwarf2_cu
*cu
)
9374 gdb::unique_xmalloc_ptr
<char> package_name
;
9375 struct pending
*list
;
9378 for (list
= *cu
->get_builder ()->get_global_symbols ();
9382 for (i
= 0; i
< list
->nsyms
; ++i
)
9384 struct symbol
*sym
= list
->symbol
[i
];
9386 if (sym
->language () == language_go
9387 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
9389 gdb::unique_xmalloc_ptr
<char> this_package_name
9390 (go_symbol_package_name (sym
));
9392 if (this_package_name
== NULL
)
9394 if (package_name
== NULL
)
9395 package_name
= std::move (this_package_name
);
9398 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9399 if (strcmp (package_name
.get (), this_package_name
.get ()) != 0)
9400 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9401 (symbol_symtab (sym
) != NULL
9402 ? symtab_to_filename_for_display
9403 (symbol_symtab (sym
))
9404 : objfile_name (objfile
)),
9405 this_package_name
.get (), package_name
.get ());
9411 if (package_name
!= NULL
)
9413 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9414 const char *saved_package_name
= objfile
->intern (package_name
.get ());
9415 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9416 saved_package_name
);
9419 sym
= new (&objfile
->objfile_obstack
) symbol
;
9420 sym
->set_language (language_go
, &objfile
->objfile_obstack
);
9421 sym
->compute_and_set_names (saved_package_name
, false, objfile
->per_bfd
);
9422 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9423 e.g., "main" finds the "main" module and not C's main(). */
9424 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9425 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9426 SYMBOL_TYPE (sym
) = type
;
9428 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
9432 /* Allocate a fully-qualified name consisting of the two parts on the
9436 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
9438 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
9441 /* A helper that allocates a variant part to attach to a Rust enum
9442 type. OBSTACK is where the results should be allocated. TYPE is
9443 the type we're processing. DISCRIMINANT_INDEX is the index of the
9444 discriminant. It must be the index of one of the fields of TYPE,
9445 or -1 to mean there is no discriminant (univariant enum).
9446 DEFAULT_INDEX is the index of the default field; or -1 if there is
9447 no default. RANGES is indexed by "effective" field number (the
9448 field index, but omitting the discriminant and default fields) and
9449 must hold the discriminant values used by the variants. Note that
9450 RANGES must have a lifetime at least as long as OBSTACK -- either
9451 already allocated on it, or static. */
9454 alloc_rust_variant (struct obstack
*obstack
, struct type
*type
,
9455 int discriminant_index
, int default_index
,
9456 gdb::array_view
<discriminant_range
> ranges
)
9458 /* When DISCRIMINANT_INDEX == -1, we have a univariant enum. */
9459 gdb_assert (discriminant_index
== -1
9460 || (discriminant_index
>= 0
9461 && discriminant_index
< type
->num_fields ()));
9462 gdb_assert (default_index
== -1
9463 || (default_index
>= 0 && default_index
< type
->num_fields ()));
9465 /* We have one variant for each non-discriminant field. */
9466 int n_variants
= type
->num_fields ();
9467 if (discriminant_index
!= -1)
9470 variant
*variants
= new (obstack
) variant
[n_variants
];
9473 for (int i
= 0; i
< type
->num_fields (); ++i
)
9475 if (i
== discriminant_index
)
9478 variants
[var_idx
].first_field
= i
;
9479 variants
[var_idx
].last_field
= i
+ 1;
9481 /* The default field does not need a range, but other fields do.
9482 We skipped the discriminant above. */
9483 if (i
!= default_index
)
9485 variants
[var_idx
].discriminants
= ranges
.slice (range_idx
, 1);
9492 gdb_assert (range_idx
== ranges
.size ());
9493 gdb_assert (var_idx
== n_variants
);
9495 variant_part
*part
= new (obstack
) variant_part
;
9496 part
->discriminant_index
= discriminant_index
;
9497 /* If there is no discriminant, then whether it is signed is of no
9500 = (discriminant_index
== -1
9502 : type
->field (discriminant_index
).type ()->is_unsigned ());
9503 part
->variants
= gdb::array_view
<variant
> (variants
, n_variants
);
9505 void *storage
= obstack_alloc (obstack
, sizeof (gdb::array_view
<variant_part
>));
9506 gdb::array_view
<variant_part
> *prop_value
9507 = new (storage
) gdb::array_view
<variant_part
> (part
, 1);
9509 struct dynamic_prop prop
;
9510 prop
.set_variant_parts (prop_value
);
9512 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
9515 /* Some versions of rustc emitted enums in an unusual way.
9517 Ordinary enums were emitted as unions. The first element of each
9518 structure in the union was named "RUST$ENUM$DISR". This element
9519 held the discriminant.
9521 These versions of Rust also implemented the "non-zero"
9522 optimization. When the enum had two values, and one is empty and
9523 the other holds a pointer that cannot be zero, the pointer is used
9524 as the discriminant, with a zero value meaning the empty variant.
9525 Here, the union's first member is of the form
9526 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9527 where the fieldnos are the indices of the fields that should be
9528 traversed in order to find the field (which may be several fields deep)
9529 and the variantname is the name of the variant of the case when the
9532 This function recognizes whether TYPE is of one of these forms,
9533 and, if so, smashes it to be a variant type. */
9536 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
9538 gdb_assert (type
->code () == TYPE_CODE_UNION
);
9540 /* We don't need to deal with empty enums. */
9541 if (type
->num_fields () == 0)
9544 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9545 if (type
->num_fields () == 1
9546 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
9548 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
9550 /* Decode the field name to find the offset of the
9552 ULONGEST bit_offset
= 0;
9553 struct type
*field_type
= type
->field (0).type ();
9554 while (name
[0] >= '0' && name
[0] <= '9')
9557 unsigned long index
= strtoul (name
, &tail
, 10);
9560 || index
>= field_type
->num_fields ()
9561 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
9562 != FIELD_LOC_KIND_BITPOS
))
9564 complaint (_("Could not parse Rust enum encoding string \"%s\""
9566 TYPE_FIELD_NAME (type
, 0),
9567 objfile_name (objfile
));
9572 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
9573 field_type
= field_type
->field (index
).type ();
9576 /* Smash this type to be a structure type. We have to do this
9577 because the type has already been recorded. */
9578 type
->set_code (TYPE_CODE_STRUCT
);
9579 type
->set_num_fields (3);
9580 /* Save the field we care about. */
9581 struct field saved_field
= type
->field (0);
9583 ((struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
)));
9585 /* Put the discriminant at index 0. */
9586 type
->field (0).set_type (field_type
);
9587 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9588 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9589 SET_FIELD_BITPOS (type
->field (0), bit_offset
);
9591 /* The order of fields doesn't really matter, so put the real
9592 field at index 1 and the data-less field at index 2. */
9593 type
->field (1) = saved_field
;
9594 TYPE_FIELD_NAME (type
, 1)
9595 = rust_last_path_segment (type
->field (1).type ()->name ());
9596 type
->field (1).type ()->set_name
9597 (rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9598 TYPE_FIELD_NAME (type
, 1)));
9600 const char *dataless_name
9601 = rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9603 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
9605 type
->field (2).set_type (dataless_type
);
9606 /* NAME points into the original discriminant name, which
9607 already has the correct lifetime. */
9608 TYPE_FIELD_NAME (type
, 2) = name
;
9609 SET_FIELD_BITPOS (type
->field (2), 0);
9611 /* Indicate that this is a variant type. */
9612 static discriminant_range ranges
[1] = { { 0, 0 } };
9613 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, 1, ranges
);
9615 /* A union with a single anonymous field is probably an old-style
9617 else if (type
->num_fields () == 1 && streq (TYPE_FIELD_NAME (type
, 0), ""))
9619 /* Smash this type to be a structure type. We have to do this
9620 because the type has already been recorded. */
9621 type
->set_code (TYPE_CODE_STRUCT
);
9623 struct type
*field_type
= type
->field (0).type ();
9624 const char *variant_name
9625 = rust_last_path_segment (field_type
->name ());
9626 TYPE_FIELD_NAME (type
, 0) = variant_name
;
9627 field_type
->set_name
9628 (rust_fully_qualify (&objfile
->objfile_obstack
,
9629 type
->name (), variant_name
));
9631 alloc_rust_variant (&objfile
->objfile_obstack
, type
, -1, 0, {});
9635 struct type
*disr_type
= nullptr;
9636 for (int i
= 0; i
< type
->num_fields (); ++i
)
9638 disr_type
= type
->field (i
).type ();
9640 if (disr_type
->code () != TYPE_CODE_STRUCT
)
9642 /* All fields of a true enum will be structs. */
9645 else if (disr_type
->num_fields () == 0)
9647 /* Could be data-less variant, so keep going. */
9648 disr_type
= nullptr;
9650 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
9651 "RUST$ENUM$DISR") != 0)
9653 /* Not a Rust enum. */
9663 /* If we got here without a discriminant, then it's probably
9665 if (disr_type
== nullptr)
9668 /* Smash this type to be a structure type. We have to do this
9669 because the type has already been recorded. */
9670 type
->set_code (TYPE_CODE_STRUCT
);
9672 /* Make space for the discriminant field. */
9673 struct field
*disr_field
= &disr_type
->field (0);
9675 = (struct field
*) TYPE_ZALLOC (type
, ((type
->num_fields () + 1)
9676 * sizeof (struct field
)));
9677 memcpy (new_fields
+ 1, type
->fields (),
9678 type
->num_fields () * sizeof (struct field
));
9679 type
->set_fields (new_fields
);
9680 type
->set_num_fields (type
->num_fields () + 1);
9682 /* Install the discriminant at index 0 in the union. */
9683 type
->field (0) = *disr_field
;
9684 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9685 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9687 /* We need a way to find the correct discriminant given a
9688 variant name. For convenience we build a map here. */
9689 struct type
*enum_type
= disr_field
->type ();
9690 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
9691 for (int i
= 0; i
< enum_type
->num_fields (); ++i
)
9693 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
9696 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
9697 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
9701 int n_fields
= type
->num_fields ();
9702 /* We don't need a range entry for the discriminant, but we do
9703 need one for every other field, as there is no default
9705 discriminant_range
*ranges
= XOBNEWVEC (&objfile
->objfile_obstack
,
9708 /* Skip the discriminant here. */
9709 for (int i
= 1; i
< n_fields
; ++i
)
9711 /* Find the final word in the name of this variant's type.
9712 That name can be used to look up the correct
9714 const char *variant_name
9715 = rust_last_path_segment (type
->field (i
).type ()->name ());
9717 auto iter
= discriminant_map
.find (variant_name
);
9718 if (iter
!= discriminant_map
.end ())
9720 ranges
[i
- 1].low
= iter
->second
;
9721 ranges
[i
- 1].high
= iter
->second
;
9724 /* In Rust, each element should have the size of the
9726 TYPE_LENGTH (type
->field (i
).type ()) = TYPE_LENGTH (type
);
9728 /* Remove the discriminant field, if it exists. */
9729 struct type
*sub_type
= type
->field (i
).type ();
9730 if (sub_type
->num_fields () > 0)
9732 sub_type
->set_num_fields (sub_type
->num_fields () - 1);
9733 sub_type
->set_fields (sub_type
->fields () + 1);
9735 TYPE_FIELD_NAME (type
, i
) = variant_name
;
9737 (rust_fully_qualify (&objfile
->objfile_obstack
,
9738 type
->name (), variant_name
));
9741 /* Indicate that this is a variant type. */
9742 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, -1,
9743 gdb::array_view
<discriminant_range
> (ranges
,
9748 /* Rewrite some Rust unions to be structures with variants parts. */
9751 rust_union_quirks (struct dwarf2_cu
*cu
)
9753 gdb_assert (cu
->language
== language_rust
);
9754 for (type
*type_
: cu
->rust_unions
)
9755 quirk_rust_enum (type_
, cu
->per_objfile
->objfile
);
9756 /* We don't need this any more. */
9757 cu
->rust_unions
.clear ();
9762 type_unit_group_unshareable
*
9763 dwarf2_per_objfile::get_type_unit_group_unshareable (type_unit_group
*tu_group
)
9765 auto iter
= this->m_type_units
.find (tu_group
);
9766 if (iter
!= this->m_type_units
.end ())
9767 return iter
->second
.get ();
9769 type_unit_group_unshareable_up
uniq (new type_unit_group_unshareable
);
9770 type_unit_group_unshareable
*result
= uniq
.get ();
9771 this->m_type_units
[tu_group
] = std::move (uniq
);
9776 dwarf2_per_objfile::get_type_for_signatured_type
9777 (signatured_type
*sig_type
) const
9779 auto iter
= this->m_type_map
.find (sig_type
);
9780 if (iter
== this->m_type_map
.end ())
9783 return iter
->second
;
9786 void dwarf2_per_objfile::set_type_for_signatured_type
9787 (signatured_type
*sig_type
, struct type
*type
)
9789 gdb_assert (this->m_type_map
.find (sig_type
) == this->m_type_map
.end ());
9791 this->m_type_map
[sig_type
] = type
;
9794 /* A helper function for computing the list of all symbol tables
9795 included by PER_CU. */
9798 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
9799 htab_t all_children
, htab_t all_type_symtabs
,
9800 dwarf2_per_cu_data
*per_cu
,
9801 dwarf2_per_objfile
*per_objfile
,
9802 struct compunit_symtab
*immediate_parent
)
9804 void **slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
9807 /* This inclusion and its children have been processed. */
9813 /* Only add a CU if it has a symbol table. */
9814 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9817 /* If this is a type unit only add its symbol table if we haven't
9818 seen it yet (type unit per_cu's can share symtabs). */
9819 if (per_cu
->is_debug_types
)
9821 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
9825 result
->push_back (cust
);
9826 if (cust
->user
== NULL
)
9827 cust
->user
= immediate_parent
;
9832 result
->push_back (cust
);
9833 if (cust
->user
== NULL
)
9834 cust
->user
= immediate_parent
;
9838 if (!per_cu
->imported_symtabs_empty ())
9839 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9841 recursively_compute_inclusions (result
, all_children
,
9842 all_type_symtabs
, ptr
, per_objfile
,
9847 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
9851 compute_compunit_symtab_includes (dwarf2_per_cu_data
*per_cu
,
9852 dwarf2_per_objfile
*per_objfile
)
9854 gdb_assert (! per_cu
->is_debug_types
);
9856 if (!per_cu
->imported_symtabs_empty ())
9859 std::vector
<compunit_symtab
*> result_symtabs
;
9860 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9862 /* If we don't have a symtab, we can just skip this case. */
9866 htab_up
all_children (htab_create_alloc (1, htab_hash_pointer
,
9868 NULL
, xcalloc
, xfree
));
9869 htab_up
all_type_symtabs (htab_create_alloc (1, htab_hash_pointer
,
9871 NULL
, xcalloc
, xfree
));
9873 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9875 recursively_compute_inclusions (&result_symtabs
, all_children
.get (),
9876 all_type_symtabs
.get (), ptr
,
9880 /* Now we have a transitive closure of all the included symtabs. */
9881 len
= result_symtabs
.size ();
9883 = XOBNEWVEC (&per_objfile
->objfile
->objfile_obstack
,
9884 struct compunit_symtab
*, len
+ 1);
9885 memcpy (cust
->includes
, result_symtabs
.data (),
9886 len
* sizeof (compunit_symtab
*));
9887 cust
->includes
[len
] = NULL
;
9891 /* Compute the 'includes' field for the symtabs of all the CUs we just
9895 process_cu_includes (dwarf2_per_objfile
*per_objfile
)
9897 for (dwarf2_per_cu_data
*iter
: per_objfile
->per_bfd
->just_read_cus
)
9899 if (! iter
->is_debug_types
)
9900 compute_compunit_symtab_includes (iter
, per_objfile
);
9903 per_objfile
->per_bfd
->just_read_cus
.clear ();
9906 /* Generate full symbol information for CU, whose DIEs have
9907 already been loaded into memory. */
9910 process_full_comp_unit (dwarf2_cu
*cu
, enum language pretend_language
)
9912 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9913 struct objfile
*objfile
= per_objfile
->objfile
;
9914 struct gdbarch
*gdbarch
= objfile
->arch ();
9915 CORE_ADDR lowpc
, highpc
;
9916 struct compunit_symtab
*cust
;
9918 struct block
*static_block
;
9921 baseaddr
= objfile
->text_section_offset ();
9923 /* Clear the list here in case something was left over. */
9924 cu
->method_list
.clear ();
9926 cu
->language
= pretend_language
;
9927 cu
->language_defn
= language_def (cu
->language
);
9929 dwarf2_find_base_address (cu
->dies
, cu
);
9931 /* Do line number decoding in read_file_scope () */
9932 process_die (cu
->dies
, cu
);
9934 /* For now fudge the Go package. */
9935 if (cu
->language
== language_go
)
9936 fixup_go_packaging (cu
);
9938 /* Now that we have processed all the DIEs in the CU, all the types
9939 should be complete, and it should now be safe to compute all of the
9941 compute_delayed_physnames (cu
);
9943 if (cu
->language
== language_rust
)
9944 rust_union_quirks (cu
);
9946 /* Some compilers don't define a DW_AT_high_pc attribute for the
9947 compilation unit. If the DW_AT_high_pc is missing, synthesize
9948 it, by scanning the DIE's below the compilation unit. */
9949 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
9951 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
9952 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
9954 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
9955 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
9956 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
9957 addrmap to help ensure it has an accurate map of pc values belonging to
9959 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
9961 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
9962 SECT_OFF_TEXT (objfile
),
9967 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
9969 /* Set symtab language to language from DW_AT_language. If the
9970 compilation is from a C file generated by language preprocessors, do
9971 not set the language if it was already deduced by start_subfile. */
9972 if (!(cu
->language
== language_c
9973 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
9974 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
9976 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
9977 produce DW_AT_location with location lists but it can be possibly
9978 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
9979 there were bugs in prologue debug info, fixed later in GCC-4.5
9980 by "unwind info for epilogues" patch (which is not directly related).
9982 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
9983 needed, it would be wrong due to missing DW_AT_producer there.
9985 Still one can confuse GDB by using non-standard GCC compilation
9986 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
9988 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
9989 cust
->locations_valid
= 1;
9991 if (gcc_4_minor
>= 5)
9992 cust
->epilogue_unwind_valid
= 1;
9994 cust
->call_site_htab
= cu
->call_site_htab
;
9997 per_objfile
->set_symtab (cu
->per_cu
, cust
);
9999 /* Push it for inclusion processing later. */
10000 per_objfile
->per_bfd
->just_read_cus
.push_back (cu
->per_cu
);
10002 /* Not needed any more. */
10003 cu
->reset_builder ();
10006 /* Generate full symbol information for type unit CU, whose DIEs have
10007 already been loaded into memory. */
10010 process_full_type_unit (dwarf2_cu
*cu
,
10011 enum language pretend_language
)
10013 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10014 struct objfile
*objfile
= per_objfile
->objfile
;
10015 struct compunit_symtab
*cust
;
10016 struct signatured_type
*sig_type
;
10018 gdb_assert (cu
->per_cu
->is_debug_types
);
10019 sig_type
= (struct signatured_type
*) cu
->per_cu
;
10021 /* Clear the list here in case something was left over. */
10022 cu
->method_list
.clear ();
10024 cu
->language
= pretend_language
;
10025 cu
->language_defn
= language_def (cu
->language
);
10027 /* The symbol tables are set up in read_type_unit_scope. */
10028 process_die (cu
->dies
, cu
);
10030 /* For now fudge the Go package. */
10031 if (cu
->language
== language_go
)
10032 fixup_go_packaging (cu
);
10034 /* Now that we have processed all the DIEs in the CU, all the types
10035 should be complete, and it should now be safe to compute all of the
10037 compute_delayed_physnames (cu
);
10039 if (cu
->language
== language_rust
)
10040 rust_union_quirks (cu
);
10042 /* TUs share symbol tables.
10043 If this is the first TU to use this symtab, complete the construction
10044 of it with end_expandable_symtab. Otherwise, complete the addition of
10045 this TU's symbols to the existing symtab. */
10046 type_unit_group_unshareable
*tug_unshare
=
10047 per_objfile
->get_type_unit_group_unshareable (sig_type
->type_unit_group
);
10048 if (tug_unshare
->compunit_symtab
== NULL
)
10050 buildsym_compunit
*builder
= cu
->get_builder ();
10051 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
10052 tug_unshare
->compunit_symtab
= cust
;
10056 /* Set symtab language to language from DW_AT_language. If the
10057 compilation is from a C file generated by language preprocessors,
10058 do not set the language if it was already deduced by
10060 if (!(cu
->language
== language_c
10061 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
10062 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10067 cu
->get_builder ()->augment_type_symtab ();
10068 cust
= tug_unshare
->compunit_symtab
;
10071 per_objfile
->set_symtab (cu
->per_cu
, cust
);
10073 /* Not needed any more. */
10074 cu
->reset_builder ();
10077 /* Process an imported unit DIE. */
10080 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10082 struct attribute
*attr
;
10084 /* For now we don't handle imported units in type units. */
10085 if (cu
->per_cu
->is_debug_types
)
10087 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10088 " supported in type units [in module %s]"),
10089 objfile_name (cu
->per_objfile
->objfile
));
10092 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10095 sect_offset sect_off
= attr
->get_ref_die_offset ();
10096 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
10097 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10098 dwarf2_per_cu_data
*per_cu
10099 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
, per_objfile
);
10101 /* We're importing a C++ compilation unit with tag DW_TAG_compile_unit
10102 into another compilation unit, at root level. Regard this as a hint,
10104 if (die
->parent
&& die
->parent
->parent
== NULL
10105 && per_cu
->unit_type
== DW_UT_compile
10106 && per_cu
->lang
== language_cplus
)
10109 /* If necessary, add it to the queue and load its DIEs. */
10110 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
))
10111 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
10112 false, cu
->language
);
10114 cu
->per_cu
->imported_symtabs_push (per_cu
);
10118 /* RAII object that represents a process_die scope: i.e.,
10119 starts/finishes processing a DIE. */
10120 class process_die_scope
10123 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
10124 : m_die (die
), m_cu (cu
)
10126 /* We should only be processing DIEs not already in process. */
10127 gdb_assert (!m_die
->in_process
);
10128 m_die
->in_process
= true;
10131 ~process_die_scope ()
10133 m_die
->in_process
= false;
10135 /* If we're done processing the DIE for the CU that owns the line
10136 header, we don't need the line header anymore. */
10137 if (m_cu
->line_header_die_owner
== m_die
)
10139 delete m_cu
->line_header
;
10140 m_cu
->line_header
= NULL
;
10141 m_cu
->line_header_die_owner
= NULL
;
10150 /* Process a die and its children. */
10153 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10155 process_die_scope
scope (die
, cu
);
10159 case DW_TAG_padding
:
10161 case DW_TAG_compile_unit
:
10162 case DW_TAG_partial_unit
:
10163 read_file_scope (die
, cu
);
10165 case DW_TAG_type_unit
:
10166 read_type_unit_scope (die
, cu
);
10168 case DW_TAG_subprogram
:
10169 /* Nested subprograms in Fortran get a prefix. */
10170 if (cu
->language
== language_fortran
10171 && die
->parent
!= NULL
10172 && die
->parent
->tag
== DW_TAG_subprogram
)
10173 cu
->processing_has_namespace_info
= true;
10174 /* Fall through. */
10175 case DW_TAG_inlined_subroutine
:
10176 read_func_scope (die
, cu
);
10178 case DW_TAG_lexical_block
:
10179 case DW_TAG_try_block
:
10180 case DW_TAG_catch_block
:
10181 read_lexical_block_scope (die
, cu
);
10183 case DW_TAG_call_site
:
10184 case DW_TAG_GNU_call_site
:
10185 read_call_site_scope (die
, cu
);
10187 case DW_TAG_class_type
:
10188 case DW_TAG_interface_type
:
10189 case DW_TAG_structure_type
:
10190 case DW_TAG_union_type
:
10191 process_structure_scope (die
, cu
);
10193 case DW_TAG_enumeration_type
:
10194 process_enumeration_scope (die
, cu
);
10197 /* These dies have a type, but processing them does not create
10198 a symbol or recurse to process the children. Therefore we can
10199 read them on-demand through read_type_die. */
10200 case DW_TAG_subroutine_type
:
10201 case DW_TAG_set_type
:
10202 case DW_TAG_array_type
:
10203 case DW_TAG_pointer_type
:
10204 case DW_TAG_ptr_to_member_type
:
10205 case DW_TAG_reference_type
:
10206 case DW_TAG_rvalue_reference_type
:
10207 case DW_TAG_string_type
:
10210 case DW_TAG_base_type
:
10211 case DW_TAG_subrange_type
:
10212 case DW_TAG_typedef
:
10213 /* Add a typedef symbol for the type definition, if it has a
10215 new_symbol (die
, read_type_die (die
, cu
), cu
);
10217 case DW_TAG_common_block
:
10218 read_common_block (die
, cu
);
10220 case DW_TAG_common_inclusion
:
10222 case DW_TAG_namespace
:
10223 cu
->processing_has_namespace_info
= true;
10224 read_namespace (die
, cu
);
10226 case DW_TAG_module
:
10227 cu
->processing_has_namespace_info
= true;
10228 read_module (die
, cu
);
10230 case DW_TAG_imported_declaration
:
10231 cu
->processing_has_namespace_info
= true;
10232 if (read_namespace_alias (die
, cu
))
10234 /* The declaration is not a global namespace alias. */
10235 /* Fall through. */
10236 case DW_TAG_imported_module
:
10237 cu
->processing_has_namespace_info
= true;
10238 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
10239 || cu
->language
!= language_fortran
))
10240 complaint (_("Tag '%s' has unexpected children"),
10241 dwarf_tag_name (die
->tag
));
10242 read_import_statement (die
, cu
);
10245 case DW_TAG_imported_unit
:
10246 process_imported_unit_die (die
, cu
);
10249 case DW_TAG_variable
:
10250 read_variable (die
, cu
);
10254 new_symbol (die
, NULL
, cu
);
10259 /* DWARF name computation. */
10261 /* A helper function for dwarf2_compute_name which determines whether DIE
10262 needs to have the name of the scope prepended to the name listed in the
10266 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
10268 struct attribute
*attr
;
10272 case DW_TAG_namespace
:
10273 case DW_TAG_typedef
:
10274 case DW_TAG_class_type
:
10275 case DW_TAG_interface_type
:
10276 case DW_TAG_structure_type
:
10277 case DW_TAG_union_type
:
10278 case DW_TAG_enumeration_type
:
10279 case DW_TAG_enumerator
:
10280 case DW_TAG_subprogram
:
10281 case DW_TAG_inlined_subroutine
:
10282 case DW_TAG_member
:
10283 case DW_TAG_imported_declaration
:
10286 case DW_TAG_variable
:
10287 case DW_TAG_constant
:
10288 /* We only need to prefix "globally" visible variables. These include
10289 any variable marked with DW_AT_external or any variable that
10290 lives in a namespace. [Variables in anonymous namespaces
10291 require prefixing, but they are not DW_AT_external.] */
10293 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
10295 struct dwarf2_cu
*spec_cu
= cu
;
10297 return die_needs_namespace (die_specification (die
, &spec_cu
),
10301 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
10302 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
10303 && die
->parent
->tag
!= DW_TAG_module
)
10305 /* A variable in a lexical block of some kind does not need a
10306 namespace, even though in C++ such variables may be external
10307 and have a mangled name. */
10308 if (die
->parent
->tag
== DW_TAG_lexical_block
10309 || die
->parent
->tag
== DW_TAG_try_block
10310 || die
->parent
->tag
== DW_TAG_catch_block
10311 || die
->parent
->tag
== DW_TAG_subprogram
)
10320 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10321 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10322 defined for the given DIE. */
10324 static struct attribute
*
10325 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
10327 struct attribute
*attr
;
10329 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
10331 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10336 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10337 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10338 defined for the given DIE. */
10340 static const char *
10341 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10343 const char *linkage_name
;
10345 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
10346 if (linkage_name
== NULL
)
10347 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10349 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
10350 See https://github.com/rust-lang/rust/issues/32925. */
10351 if (cu
->language
== language_rust
&& linkage_name
!= NULL
10352 && strchr (linkage_name
, '{') != NULL
)
10353 linkage_name
= NULL
;
10355 return linkage_name
;
10358 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10359 compute the physname for the object, which include a method's:
10360 - formal parameters (C++),
10361 - receiver type (Go),
10363 The term "physname" is a bit confusing.
10364 For C++, for example, it is the demangled name.
10365 For Go, for example, it's the mangled name.
10367 For Ada, return the DIE's linkage name rather than the fully qualified
10368 name. PHYSNAME is ignored..
10370 The result is allocated on the objfile->per_bfd's obstack and
10373 static const char *
10374 dwarf2_compute_name (const char *name
,
10375 struct die_info
*die
, struct dwarf2_cu
*cu
,
10378 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10381 name
= dwarf2_name (die
, cu
);
10383 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10384 but otherwise compute it by typename_concat inside GDB.
10385 FIXME: Actually this is not really true, or at least not always true.
10386 It's all very confusing. compute_and_set_names doesn't try to demangle
10387 Fortran names because there is no mangling standard. So new_symbol
10388 will set the demangled name to the result of dwarf2_full_name, and it is
10389 the demangled name that GDB uses if it exists. */
10390 if (cu
->language
== language_ada
10391 || (cu
->language
== language_fortran
&& physname
))
10393 /* For Ada unit, we prefer the linkage name over the name, as
10394 the former contains the exported name, which the user expects
10395 to be able to reference. Ideally, we want the user to be able
10396 to reference this entity using either natural or linkage name,
10397 but we haven't started looking at this enhancement yet. */
10398 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10400 if (linkage_name
!= NULL
)
10401 return linkage_name
;
10404 /* These are the only languages we know how to qualify names in. */
10406 && (cu
->language
== language_cplus
10407 || cu
->language
== language_fortran
|| cu
->language
== language_d
10408 || cu
->language
== language_rust
))
10410 if (die_needs_namespace (die
, cu
))
10412 const char *prefix
;
10413 const char *canonical_name
= NULL
;
10417 prefix
= determine_prefix (die
, cu
);
10418 if (*prefix
!= '\0')
10420 gdb::unique_xmalloc_ptr
<char> prefixed_name
10421 (typename_concat (NULL
, prefix
, name
, physname
, cu
));
10423 buf
.puts (prefixed_name
.get ());
10428 /* Template parameters may be specified in the DIE's DW_AT_name, or
10429 as children with DW_TAG_template_type_param or
10430 DW_TAG_value_type_param. If the latter, add them to the name
10431 here. If the name already has template parameters, then
10432 skip this step; some versions of GCC emit both, and
10433 it is more efficient to use the pre-computed name.
10435 Something to keep in mind about this process: it is very
10436 unlikely, or in some cases downright impossible, to produce
10437 something that will match the mangled name of a function.
10438 If the definition of the function has the same debug info,
10439 we should be able to match up with it anyway. But fallbacks
10440 using the minimal symbol, for instance to find a method
10441 implemented in a stripped copy of libstdc++, will not work.
10442 If we do not have debug info for the definition, we will have to
10443 match them up some other way.
10445 When we do name matching there is a related problem with function
10446 templates; two instantiated function templates are allowed to
10447 differ only by their return types, which we do not add here. */
10449 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
10451 struct attribute
*attr
;
10452 struct die_info
*child
;
10455 die
->building_fullname
= 1;
10457 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
10461 const gdb_byte
*bytes
;
10462 struct dwarf2_locexpr_baton
*baton
;
10465 if (child
->tag
!= DW_TAG_template_type_param
10466 && child
->tag
!= DW_TAG_template_value_param
)
10477 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10480 complaint (_("template parameter missing DW_AT_type"));
10481 buf
.puts ("UNKNOWN_TYPE");
10484 type
= die_type (child
, cu
);
10486 if (child
->tag
== DW_TAG_template_type_param
)
10488 c_print_type (type
, "", &buf
, -1, 0, cu
->language
,
10489 &type_print_raw_options
);
10493 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10496 complaint (_("template parameter missing "
10497 "DW_AT_const_value"));
10498 buf
.puts ("UNKNOWN_VALUE");
10502 dwarf2_const_value_attr (attr
, type
, name
,
10503 &cu
->comp_unit_obstack
, cu
,
10504 &value
, &bytes
, &baton
);
10506 if (type
->has_no_signedness ())
10507 /* GDB prints characters as NUMBER 'CHAR'. If that's
10508 changed, this can use value_print instead. */
10509 c_printchar (value
, type
, &buf
);
10512 struct value_print_options opts
;
10515 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
10519 baton
->per_objfile
);
10520 else if (bytes
!= NULL
)
10522 v
= allocate_value (type
);
10523 memcpy (value_contents_writeable (v
), bytes
,
10524 TYPE_LENGTH (type
));
10527 v
= value_from_longest (type
, value
);
10529 /* Specify decimal so that we do not depend on
10531 get_formatted_print_options (&opts
, 'd');
10533 value_print (v
, &buf
, &opts
);
10538 die
->building_fullname
= 0;
10542 /* Close the argument list, with a space if necessary
10543 (nested templates). */
10544 if (!buf
.empty () && buf
.string ().back () == '>')
10551 /* For C++ methods, append formal parameter type
10552 information, if PHYSNAME. */
10554 if (physname
&& die
->tag
== DW_TAG_subprogram
10555 && cu
->language
== language_cplus
)
10557 struct type
*type
= read_type_die (die
, cu
);
10559 c_type_print_args (type
, &buf
, 1, cu
->language
,
10560 &type_print_raw_options
);
10562 if (cu
->language
== language_cplus
)
10564 /* Assume that an artificial first parameter is
10565 "this", but do not crash if it is not. RealView
10566 marks unnamed (and thus unused) parameters as
10567 artificial; there is no way to differentiate
10569 if (type
->num_fields () > 0
10570 && TYPE_FIELD_ARTIFICIAL (type
, 0)
10571 && type
->field (0).type ()->code () == TYPE_CODE_PTR
10572 && TYPE_CONST (TYPE_TARGET_TYPE (type
->field (0).type ())))
10573 buf
.puts (" const");
10577 const std::string
&intermediate_name
= buf
.string ();
10579 if (cu
->language
== language_cplus
)
10581 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
10584 /* If we only computed INTERMEDIATE_NAME, or if
10585 INTERMEDIATE_NAME is already canonical, then we need to
10587 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
10588 name
= objfile
->intern (intermediate_name
);
10590 name
= canonical_name
;
10597 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10598 If scope qualifiers are appropriate they will be added. The result
10599 will be allocated on the storage_obstack, or NULL if the DIE does
10600 not have a name. NAME may either be from a previous call to
10601 dwarf2_name or NULL.
10603 The output string will be canonicalized (if C++). */
10605 static const char *
10606 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10608 return dwarf2_compute_name (name
, die
, cu
, 0);
10611 /* Construct a physname for the given DIE in CU. NAME may either be
10612 from a previous call to dwarf2_name or NULL. The result will be
10613 allocated on the objfile_objstack or NULL if the DIE does not have a
10616 The output string will be canonicalized (if C++). */
10618 static const char *
10619 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10621 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10622 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
10625 /* In this case dwarf2_compute_name is just a shortcut not building anything
10627 if (!die_needs_namespace (die
, cu
))
10628 return dwarf2_compute_name (name
, die
, cu
, 1);
10630 if (cu
->language
!= language_rust
)
10631 mangled
= dw2_linkage_name (die
, cu
);
10633 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
10635 gdb::unique_xmalloc_ptr
<char> demangled
;
10636 if (mangled
!= NULL
)
10639 if (language_def (cu
->language
)->store_sym_names_in_linkage_form_p ())
10641 /* Do nothing (do not demangle the symbol name). */
10645 /* Use DMGL_RET_DROP for C++ template functions to suppress
10646 their return type. It is easier for GDB users to search
10647 for such functions as `name(params)' than `long name(params)'.
10648 In such case the minimal symbol names do not match the full
10649 symbol names but for template functions there is never a need
10650 to look up their definition from their declaration so
10651 the only disadvantage remains the minimal symbol variant
10652 `long name(params)' does not have the proper inferior type. */
10653 demangled
.reset (gdb_demangle (mangled
,
10654 (DMGL_PARAMS
| DMGL_ANSI
10655 | DMGL_RET_DROP
)));
10658 canon
= demangled
.get ();
10666 if (canon
== NULL
|| check_physname
)
10668 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
10670 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
10672 /* It may not mean a bug in GDB. The compiler could also
10673 compute DW_AT_linkage_name incorrectly. But in such case
10674 GDB would need to be bug-to-bug compatible. */
10676 complaint (_("Computed physname <%s> does not match demangled <%s> "
10677 "(from linkage <%s>) - DIE at %s [in module %s]"),
10678 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
10679 objfile_name (objfile
));
10681 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
10682 is available here - over computed PHYSNAME. It is safer
10683 against both buggy GDB and buggy compilers. */
10697 retval
= objfile
->intern (retval
);
10702 /* Inspect DIE in CU for a namespace alias. If one exists, record
10703 a new symbol for it.
10705 Returns 1 if a namespace alias was recorded, 0 otherwise. */
10708 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
10710 struct attribute
*attr
;
10712 /* If the die does not have a name, this is not a namespace
10714 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
10718 struct die_info
*d
= die
;
10719 struct dwarf2_cu
*imported_cu
= cu
;
10721 /* If the compiler has nested DW_AT_imported_declaration DIEs,
10722 keep inspecting DIEs until we hit the underlying import. */
10723 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
10724 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
10726 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
10730 d
= follow_die_ref (d
, attr
, &imported_cu
);
10731 if (d
->tag
!= DW_TAG_imported_declaration
)
10735 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
10737 complaint (_("DIE at %s has too many recursively imported "
10738 "declarations"), sect_offset_str (d
->sect_off
));
10745 sect_offset sect_off
= attr
->get_ref_die_offset ();
10747 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, cu
->per_objfile
);
10748 if (type
!= NULL
&& type
->code () == TYPE_CODE_NAMESPACE
)
10750 /* This declaration is a global namespace alias. Add
10751 a symbol for it whose type is the aliased namespace. */
10752 new_symbol (die
, type
, cu
);
10761 /* Return the using directives repository (global or local?) to use in the
10762 current context for CU.
10764 For Ada, imported declarations can materialize renamings, which *may* be
10765 global. However it is impossible (for now?) in DWARF to distinguish
10766 "external" imported declarations and "static" ones. As all imported
10767 declarations seem to be static in all other languages, make them all CU-wide
10768 global only in Ada. */
10770 static struct using_direct
**
10771 using_directives (struct dwarf2_cu
*cu
)
10773 if (cu
->language
== language_ada
10774 && cu
->get_builder ()->outermost_context_p ())
10775 return cu
->get_builder ()->get_global_using_directives ();
10777 return cu
->get_builder ()->get_local_using_directives ();
10780 /* Read the import statement specified by the given die and record it. */
10783 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
10785 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10786 struct attribute
*import_attr
;
10787 struct die_info
*imported_die
, *child_die
;
10788 struct dwarf2_cu
*imported_cu
;
10789 const char *imported_name
;
10790 const char *imported_name_prefix
;
10791 const char *canonical_name
;
10792 const char *import_alias
;
10793 const char *imported_declaration
= NULL
;
10794 const char *import_prefix
;
10795 std::vector
<const char *> excludes
;
10797 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10798 if (import_attr
== NULL
)
10800 complaint (_("Tag '%s' has no DW_AT_import"),
10801 dwarf_tag_name (die
->tag
));
10806 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
10807 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10808 if (imported_name
== NULL
)
10810 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
10812 The import in the following code:
10826 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
10827 <52> DW_AT_decl_file : 1
10828 <53> DW_AT_decl_line : 6
10829 <54> DW_AT_import : <0x75>
10830 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
10831 <59> DW_AT_name : B
10832 <5b> DW_AT_decl_file : 1
10833 <5c> DW_AT_decl_line : 2
10834 <5d> DW_AT_type : <0x6e>
10836 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
10837 <76> DW_AT_byte_size : 4
10838 <77> DW_AT_encoding : 5 (signed)
10840 imports the wrong die ( 0x75 instead of 0x58 ).
10841 This case will be ignored until the gcc bug is fixed. */
10845 /* Figure out the local name after import. */
10846 import_alias
= dwarf2_name (die
, cu
);
10848 /* Figure out where the statement is being imported to. */
10849 import_prefix
= determine_prefix (die
, cu
);
10851 /* Figure out what the scope of the imported die is and prepend it
10852 to the name of the imported die. */
10853 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
10855 if (imported_die
->tag
!= DW_TAG_namespace
10856 && imported_die
->tag
!= DW_TAG_module
)
10858 imported_declaration
= imported_name
;
10859 canonical_name
= imported_name_prefix
;
10861 else if (strlen (imported_name_prefix
) > 0)
10862 canonical_name
= obconcat (&objfile
->objfile_obstack
,
10863 imported_name_prefix
,
10864 (cu
->language
== language_d
? "." : "::"),
10865 imported_name
, (char *) NULL
);
10867 canonical_name
= imported_name
;
10869 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
10870 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
10871 child_die
= child_die
->sibling
)
10873 /* DWARF-4: A Fortran use statement with a “rename list” may be
10874 represented by an imported module entry with an import attribute
10875 referring to the module and owned entries corresponding to those
10876 entities that are renamed as part of being imported. */
10878 if (child_die
->tag
!= DW_TAG_imported_declaration
)
10880 complaint (_("child DW_TAG_imported_declaration expected "
10881 "- DIE at %s [in module %s]"),
10882 sect_offset_str (child_die
->sect_off
),
10883 objfile_name (objfile
));
10887 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
10888 if (import_attr
== NULL
)
10890 complaint (_("Tag '%s' has no DW_AT_import"),
10891 dwarf_tag_name (child_die
->tag
));
10896 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
10898 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10899 if (imported_name
== NULL
)
10901 complaint (_("child DW_TAG_imported_declaration has unknown "
10902 "imported name - DIE at %s [in module %s]"),
10903 sect_offset_str (child_die
->sect_off
),
10904 objfile_name (objfile
));
10908 excludes
.push_back (imported_name
);
10910 process_die (child_die
, cu
);
10913 add_using_directive (using_directives (cu
),
10917 imported_declaration
,
10920 &objfile
->objfile_obstack
);
10923 /* ICC<14 does not output the required DW_AT_declaration on incomplete
10924 types, but gives them a size of zero. Starting with version 14,
10925 ICC is compatible with GCC. */
10928 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
10930 if (!cu
->checked_producer
)
10931 check_producer (cu
);
10933 return cu
->producer_is_icc_lt_14
;
10936 /* ICC generates a DW_AT_type for C void functions. This was observed on
10937 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
10938 which says that void functions should not have a DW_AT_type. */
10941 producer_is_icc (struct dwarf2_cu
*cu
)
10943 if (!cu
->checked_producer
)
10944 check_producer (cu
);
10946 return cu
->producer_is_icc
;
10949 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
10950 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
10951 this, it was first present in GCC release 4.3.0. */
10954 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
10956 if (!cu
->checked_producer
)
10957 check_producer (cu
);
10959 return cu
->producer_is_gcc_lt_4_3
;
10962 static file_and_directory
10963 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
10965 file_and_directory res
;
10967 /* Find the filename. Do not use dwarf2_name here, since the filename
10968 is not a source language identifier. */
10969 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
10970 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
10972 if (res
.comp_dir
== NULL
10973 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
10974 && IS_ABSOLUTE_PATH (res
.name
))
10976 res
.comp_dir_storage
= ldirname (res
.name
);
10977 if (!res
.comp_dir_storage
.empty ())
10978 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
10980 if (res
.comp_dir
!= NULL
)
10982 /* Irix 6.2 native cc prepends <machine>.: to the compilation
10983 directory, get rid of it. */
10984 const char *cp
= strchr (res
.comp_dir
, ':');
10986 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
10987 res
.comp_dir
= cp
+ 1;
10990 if (res
.name
== NULL
)
10991 res
.name
= "<unknown>";
10996 /* Handle DW_AT_stmt_list for a compilation unit.
10997 DIE is the DW_TAG_compile_unit die for CU.
10998 COMP_DIR is the compilation directory. LOWPC is passed to
10999 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11002 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
11003 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
11005 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
11006 struct attribute
*attr
;
11007 struct line_header line_header_local
;
11008 hashval_t line_header_local_hash
;
11010 int decode_mapping
;
11012 gdb_assert (! cu
->per_cu
->is_debug_types
);
11014 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
11015 if (attr
== NULL
|| !attr
->form_is_unsigned ())
11018 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
11020 /* The line header hash table is only created if needed (it exists to
11021 prevent redundant reading of the line table for partial_units).
11022 If we're given a partial_unit, we'll need it. If we're given a
11023 compile_unit, then use the line header hash table if it's already
11024 created, but don't create one just yet. */
11026 if (per_objfile
->line_header_hash
== NULL
11027 && die
->tag
== DW_TAG_partial_unit
)
11029 per_objfile
->line_header_hash
11030 .reset (htab_create_alloc (127, line_header_hash_voidp
,
11031 line_header_eq_voidp
,
11032 free_line_header_voidp
,
11036 line_header_local
.sect_off
= line_offset
;
11037 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
11038 line_header_local_hash
= line_header_hash (&line_header_local
);
11039 if (per_objfile
->line_header_hash
!= NULL
)
11041 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
11042 &line_header_local
,
11043 line_header_local_hash
, NO_INSERT
);
11045 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11046 is not present in *SLOT (since if there is something in *SLOT then
11047 it will be for a partial_unit). */
11048 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
11050 gdb_assert (*slot
!= NULL
);
11051 cu
->line_header
= (struct line_header
*) *slot
;
11056 /* dwarf_decode_line_header does not yet provide sufficient information.
11057 We always have to call also dwarf_decode_lines for it. */
11058 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
11062 cu
->line_header
= lh
.release ();
11063 cu
->line_header_die_owner
= die
;
11065 if (per_objfile
->line_header_hash
== NULL
)
11069 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
11070 &line_header_local
,
11071 line_header_local_hash
, INSERT
);
11072 gdb_assert (slot
!= NULL
);
11074 if (slot
!= NULL
&& *slot
== NULL
)
11076 /* This newly decoded line number information unit will be owned
11077 by line_header_hash hash table. */
11078 *slot
= cu
->line_header
;
11079 cu
->line_header_die_owner
= NULL
;
11083 /* We cannot free any current entry in (*slot) as that struct line_header
11084 may be already used by multiple CUs. Create only temporary decoded
11085 line_header for this CU - it may happen at most once for each line
11086 number information unit. And if we're not using line_header_hash
11087 then this is what we want as well. */
11088 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
11090 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
11091 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
11096 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11099 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11101 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
11102 struct objfile
*objfile
= per_objfile
->objfile
;
11103 struct gdbarch
*gdbarch
= objfile
->arch ();
11104 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
11105 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
11106 struct attribute
*attr
;
11107 struct die_info
*child_die
;
11108 CORE_ADDR baseaddr
;
11110 prepare_one_comp_unit (cu
, die
, cu
->language
);
11111 baseaddr
= objfile
->text_section_offset ();
11113 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
11115 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11116 from finish_block. */
11117 if (lowpc
== ((CORE_ADDR
) -1))
11119 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11121 file_and_directory fnd
= find_file_and_directory (die
, cu
);
11123 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11124 standardised yet. As a workaround for the language detection we fall
11125 back to the DW_AT_producer string. */
11126 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
11127 cu
->language
= language_opencl
;
11129 /* Similar hack for Go. */
11130 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
11131 set_cu_language (DW_LANG_Go
, cu
);
11133 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
11135 /* Decode line number information if present. We do this before
11136 processing child DIEs, so that the line header table is available
11137 for DW_AT_decl_file. */
11138 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
11140 /* Process all dies in compilation unit. */
11141 if (die
->child
!= NULL
)
11143 child_die
= die
->child
;
11144 while (child_die
&& child_die
->tag
)
11146 process_die (child_die
, cu
);
11147 child_die
= child_die
->sibling
;
11151 /* Decode macro information, if present. Dwarf 2 macro information
11152 refers to information in the line number info statement program
11153 header, so we can only read it if we've read the header
11155 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
11157 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
11158 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
11160 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
11161 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11163 dwarf_decode_macros (cu
, attr
->as_unsigned (), 1);
11167 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
11168 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
11170 unsigned int macro_offset
= attr
->as_unsigned ();
11172 dwarf_decode_macros (cu
, macro_offset
, 0);
11178 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
11180 struct type_unit_group
*tu_group
;
11182 struct attribute
*attr
;
11184 struct signatured_type
*sig_type
;
11186 gdb_assert (per_cu
->is_debug_types
);
11187 sig_type
= (struct signatured_type
*) per_cu
;
11189 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
11191 /* If we're using .gdb_index (includes -readnow) then
11192 per_cu->type_unit_group may not have been set up yet. */
11193 if (sig_type
->type_unit_group
== NULL
)
11194 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
11195 tu_group
= sig_type
->type_unit_group
;
11197 /* If we've already processed this stmt_list there's no real need to
11198 do it again, we could fake it and just recreate the part we need
11199 (file name,index -> symtab mapping). If data shows this optimization
11200 is useful we can do it then. */
11201 type_unit_group_unshareable
*tug_unshare
11202 = per_objfile
->get_type_unit_group_unshareable (tu_group
);
11203 first_time
= tug_unshare
->compunit_symtab
== NULL
;
11205 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11208 if (attr
!= NULL
&& attr
->form_is_unsigned ())
11210 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
11211 lh
= dwarf_decode_line_header (line_offset
, this);
11216 start_symtab ("", NULL
, 0);
11219 gdb_assert (tug_unshare
->symtabs
== NULL
);
11220 gdb_assert (m_builder
== nullptr);
11221 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11222 m_builder
.reset (new struct buildsym_compunit
11223 (COMPUNIT_OBJFILE (cust
), "",
11224 COMPUNIT_DIRNAME (cust
),
11225 compunit_language (cust
),
11227 list_in_scope
= get_builder ()->get_file_symbols ();
11232 line_header
= lh
.release ();
11233 line_header_die_owner
= die
;
11237 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
11239 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11240 still initializing it, and our caller (a few levels up)
11241 process_full_type_unit still needs to know if this is the first
11244 tug_unshare
->symtabs
11245 = XOBNEWVEC (&COMPUNIT_OBJFILE (cust
)->objfile_obstack
,
11246 struct symtab
*, line_header
->file_names_size ());
11248 auto &file_names
= line_header
->file_names ();
11249 for (i
= 0; i
< file_names
.size (); ++i
)
11251 file_entry
&fe
= file_names
[i
];
11252 dwarf2_start_subfile (this, fe
.name
,
11253 fe
.include_dir (line_header
));
11254 buildsym_compunit
*b
= get_builder ();
11255 if (b
->get_current_subfile ()->symtab
== NULL
)
11257 /* NOTE: start_subfile will recognize when it's been
11258 passed a file it has already seen. So we can't
11259 assume there's a simple mapping from
11260 cu->line_header->file_names to subfiles, plus
11261 cu->line_header->file_names may contain dups. */
11262 b
->get_current_subfile ()->symtab
11263 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
11266 fe
.symtab
= b
->get_current_subfile ()->symtab
;
11267 tug_unshare
->symtabs
[i
] = fe
.symtab
;
11272 gdb_assert (m_builder
== nullptr);
11273 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11274 m_builder
.reset (new struct buildsym_compunit
11275 (COMPUNIT_OBJFILE (cust
), "",
11276 COMPUNIT_DIRNAME (cust
),
11277 compunit_language (cust
),
11279 list_in_scope
= get_builder ()->get_file_symbols ();
11281 auto &file_names
= line_header
->file_names ();
11282 for (i
= 0; i
< file_names
.size (); ++i
)
11284 file_entry
&fe
= file_names
[i
];
11285 fe
.symtab
= tug_unshare
->symtabs
[i
];
11289 /* The main symtab is allocated last. Type units don't have DW_AT_name
11290 so they don't have a "real" (so to speak) symtab anyway.
11291 There is later code that will assign the main symtab to all symbols
11292 that don't have one. We need to handle the case of a symbol with a
11293 missing symtab (DW_AT_decl_file) anyway. */
11296 /* Process DW_TAG_type_unit.
11297 For TUs we want to skip the first top level sibling if it's not the
11298 actual type being defined by this TU. In this case the first top
11299 level sibling is there to provide context only. */
11302 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11304 struct die_info
*child_die
;
11306 prepare_one_comp_unit (cu
, die
, language_minimal
);
11308 /* Initialize (or reinitialize) the machinery for building symtabs.
11309 We do this before processing child DIEs, so that the line header table
11310 is available for DW_AT_decl_file. */
11311 cu
->setup_type_unit_groups (die
);
11313 if (die
->child
!= NULL
)
11315 child_die
= die
->child
;
11316 while (child_die
&& child_die
->tag
)
11318 process_die (child_die
, cu
);
11319 child_die
= child_die
->sibling
;
11326 http://gcc.gnu.org/wiki/DebugFission
11327 http://gcc.gnu.org/wiki/DebugFissionDWP
11329 To simplify handling of both DWO files ("object" files with the DWARF info)
11330 and DWP files (a file with the DWOs packaged up into one file), we treat
11331 DWP files as having a collection of virtual DWO files. */
11334 hash_dwo_file (const void *item
)
11336 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
11339 hash
= htab_hash_string (dwo_file
->dwo_name
);
11340 if (dwo_file
->comp_dir
!= NULL
)
11341 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11346 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11348 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11349 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11351 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11353 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11354 return lhs
->comp_dir
== rhs
->comp_dir
;
11355 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11358 /* Allocate a hash table for DWO files. */
11361 allocate_dwo_file_hash_table ()
11363 auto delete_dwo_file
= [] (void *item
)
11365 struct dwo_file
*dwo_file
= (struct dwo_file
*) item
;
11370 return htab_up (htab_create_alloc (41,
11377 /* Lookup DWO file DWO_NAME. */
11380 lookup_dwo_file_slot (dwarf2_per_objfile
*per_objfile
,
11381 const char *dwo_name
,
11382 const char *comp_dir
)
11384 struct dwo_file find_entry
;
11387 if (per_objfile
->per_bfd
->dwo_files
== NULL
)
11388 per_objfile
->per_bfd
->dwo_files
= allocate_dwo_file_hash_table ();
11390 find_entry
.dwo_name
= dwo_name
;
11391 find_entry
.comp_dir
= comp_dir
;
11392 slot
= htab_find_slot (per_objfile
->per_bfd
->dwo_files
.get (), &find_entry
,
11399 hash_dwo_unit (const void *item
)
11401 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11403 /* This drops the top 32 bits of the id, but is ok for a hash. */
11404 return dwo_unit
->signature
;
11408 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11410 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11411 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11413 /* The signature is assumed to be unique within the DWO file.
11414 So while object file CU dwo_id's always have the value zero,
11415 that's OK, assuming each object file DWO file has only one CU,
11416 and that's the rule for now. */
11417 return lhs
->signature
== rhs
->signature
;
11420 /* Allocate a hash table for DWO CUs,TUs.
11421 There is one of these tables for each of CUs,TUs for each DWO file. */
11424 allocate_dwo_unit_table ()
11426 /* Start out with a pretty small number.
11427 Generally DWO files contain only one CU and maybe some TUs. */
11428 return htab_up (htab_create_alloc (3,
11431 NULL
, xcalloc
, xfree
));
11434 /* die_reader_func for create_dwo_cu. */
11437 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
11438 const gdb_byte
*info_ptr
,
11439 struct die_info
*comp_unit_die
,
11440 struct dwo_file
*dwo_file
,
11441 struct dwo_unit
*dwo_unit
)
11443 struct dwarf2_cu
*cu
= reader
->cu
;
11444 sect_offset sect_off
= cu
->per_cu
->sect_off
;
11445 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
11447 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
11448 if (!signature
.has_value ())
11450 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11451 " its dwo_id [in module %s]"),
11452 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
11456 dwo_unit
->dwo_file
= dwo_file
;
11457 dwo_unit
->signature
= *signature
;
11458 dwo_unit
->section
= section
;
11459 dwo_unit
->sect_off
= sect_off
;
11460 dwo_unit
->length
= cu
->per_cu
->length
;
11462 if (dwarf_read_debug
)
11463 fprintf_unfiltered (gdb_stdlog
, " offset %s, dwo_id %s\n",
11464 sect_offset_str (sect_off
),
11465 hex_string (dwo_unit
->signature
));
11468 /* Create the dwo_units for the CUs in a DWO_FILE.
11469 Note: This function processes DWO files only, not DWP files. */
11472 create_cus_hash_table (dwarf2_per_objfile
*per_objfile
,
11473 dwarf2_cu
*cu
, struct dwo_file
&dwo_file
,
11474 dwarf2_section_info
§ion
, htab_up
&cus_htab
)
11476 struct objfile
*objfile
= per_objfile
->objfile
;
11477 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
11478 const gdb_byte
*info_ptr
, *end_ptr
;
11480 section
.read (objfile
);
11481 info_ptr
= section
.buffer
;
11483 if (info_ptr
== NULL
)
11486 if (dwarf_read_debug
)
11488 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
11489 section
.get_name (),
11490 section
.get_file_name ());
11493 end_ptr
= info_ptr
+ section
.size
;
11494 while (info_ptr
< end_ptr
)
11496 struct dwarf2_per_cu_data per_cu
;
11497 struct dwo_unit read_unit
{};
11498 struct dwo_unit
*dwo_unit
;
11500 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
11502 memset (&per_cu
, 0, sizeof (per_cu
));
11503 per_cu
.per_bfd
= per_bfd
;
11504 per_cu
.is_debug_types
= 0;
11505 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
11506 per_cu
.section
= §ion
;
11508 cutu_reader
reader (&per_cu
, per_objfile
, cu
, &dwo_file
);
11509 if (!reader
.dummy_p
)
11510 create_dwo_cu_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
,
11511 &dwo_file
, &read_unit
);
11512 info_ptr
+= per_cu
.length
;
11514 // If the unit could not be parsed, skip it.
11515 if (read_unit
.dwo_file
== NULL
)
11518 if (cus_htab
== NULL
)
11519 cus_htab
= allocate_dwo_unit_table ();
11521 dwo_unit
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
11523 *dwo_unit
= read_unit
;
11524 slot
= htab_find_slot (cus_htab
.get (), dwo_unit
, INSERT
);
11525 gdb_assert (slot
!= NULL
);
11528 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
11529 sect_offset dup_sect_off
= dup_cu
->sect_off
;
11531 complaint (_("debug cu entry at offset %s is duplicate to"
11532 " the entry at offset %s, signature %s"),
11533 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
11534 hex_string (dwo_unit
->signature
));
11536 *slot
= (void *)dwo_unit
;
11540 /* DWP file .debug_{cu,tu}_index section format:
11541 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11542 [ref: http://dwarfstd.org/doc/DWARF5.pdf, sect 7.3.5 "DWARF Package Files"]
11544 DWP Versions 1 & 2 are older, pre-standard format versions. The first
11545 officially standard DWP format was published with DWARF v5 and is called
11546 Version 5. There are no versions 3 or 4.
11550 Both index sections have the same format, and serve to map a 64-bit
11551 signature to a set of section numbers. Each section begins with a header,
11552 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11553 indexes, and a pool of 32-bit section numbers. The index sections will be
11554 aligned at 8-byte boundaries in the file.
11556 The index section header consists of:
11558 V, 32 bit version number
11560 N, 32 bit number of compilation units or type units in the index
11561 M, 32 bit number of slots in the hash table
11563 Numbers are recorded using the byte order of the application binary.
11565 The hash table begins at offset 16 in the section, and consists of an array
11566 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11567 order of the application binary). Unused slots in the hash table are 0.
11568 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11570 The parallel table begins immediately after the hash table
11571 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11572 array of 32-bit indexes (using the byte order of the application binary),
11573 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11574 table contains a 32-bit index into the pool of section numbers. For unused
11575 hash table slots, the corresponding entry in the parallel table will be 0.
11577 The pool of section numbers begins immediately following the hash table
11578 (at offset 16 + 12 * M from the beginning of the section). The pool of
11579 section numbers consists of an array of 32-bit words (using the byte order
11580 of the application binary). Each item in the array is indexed starting
11581 from 0. The hash table entry provides the index of the first section
11582 number in the set. Additional section numbers in the set follow, and the
11583 set is terminated by a 0 entry (section number 0 is not used in ELF).
11585 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
11586 section must be the first entry in the set, and the .debug_abbrev.dwo must
11587 be the second entry. Other members of the set may follow in any order.
11591 DWP Versions 2 and 5:
11593 DWP Versions 2 and 5 combine all the .debug_info, etc. sections into one,
11594 and the entries in the index tables are now offsets into these sections.
11595 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
11598 Index Section Contents:
11600 Hash Table of Signatures dwp_hash_table.hash_table
11601 Parallel Table of Indices dwp_hash_table.unit_table
11602 Table of Section Offsets dwp_hash_table.{v2|v5}.{section_ids,offsets}
11603 Table of Section Sizes dwp_hash_table.{v2|v5}.sizes
11605 The index section header consists of:
11607 V, 32 bit version number
11608 L, 32 bit number of columns in the table of section offsets
11609 N, 32 bit number of compilation units or type units in the index
11610 M, 32 bit number of slots in the hash table
11612 Numbers are recorded using the byte order of the application binary.
11614 The hash table has the same format as version 1.
11615 The parallel table of indices has the same format as version 1,
11616 except that the entries are origin-1 indices into the table of sections
11617 offsets and the table of section sizes.
11619 The table of offsets begins immediately following the parallel table
11620 (at offset 16 + 12 * M from the beginning of the section). The table is
11621 a two-dimensional array of 32-bit words (using the byte order of the
11622 application binary), with L columns and N+1 rows, in row-major order.
11623 Each row in the array is indexed starting from 0. The first row provides
11624 a key to the remaining rows: each column in this row provides an identifier
11625 for a debug section, and the offsets in the same column of subsequent rows
11626 refer to that section. The section identifiers for Version 2 are:
11628 DW_SECT_INFO 1 .debug_info.dwo
11629 DW_SECT_TYPES 2 .debug_types.dwo
11630 DW_SECT_ABBREV 3 .debug_abbrev.dwo
11631 DW_SECT_LINE 4 .debug_line.dwo
11632 DW_SECT_LOC 5 .debug_loc.dwo
11633 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
11634 DW_SECT_MACINFO 7 .debug_macinfo.dwo
11635 DW_SECT_MACRO 8 .debug_macro.dwo
11637 The section identifiers for Version 5 are:
11639 DW_SECT_INFO_V5 1 .debug_info.dwo
11640 DW_SECT_RESERVED_V5 2 --
11641 DW_SECT_ABBREV_V5 3 .debug_abbrev.dwo
11642 DW_SECT_LINE_V5 4 .debug_line.dwo
11643 DW_SECT_LOCLISTS_V5 5 .debug_loclists.dwo
11644 DW_SECT_STR_OFFSETS_V5 6 .debug_str_offsets.dwo
11645 DW_SECT_MACRO_V5 7 .debug_macro.dwo
11646 DW_SECT_RNGLISTS_V5 8 .debug_rnglists.dwo
11648 The offsets provided by the CU and TU index sections are the base offsets
11649 for the contributions made by each CU or TU to the corresponding section
11650 in the package file. Each CU and TU header contains an abbrev_offset
11651 field, used to find the abbreviations table for that CU or TU within the
11652 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
11653 be interpreted as relative to the base offset given in the index section.
11654 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
11655 should be interpreted as relative to the base offset for .debug_line.dwo,
11656 and offsets into other debug sections obtained from DWARF attributes should
11657 also be interpreted as relative to the corresponding base offset.
11659 The table of sizes begins immediately following the table of offsets.
11660 Like the table of offsets, it is a two-dimensional array of 32-bit words,
11661 with L columns and N rows, in row-major order. Each row in the array is
11662 indexed starting from 1 (row 0 is shared by the two tables).
11666 Hash table lookup is handled the same in version 1 and 2:
11668 We assume that N and M will not exceed 2^32 - 1.
11669 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
11671 Given a 64-bit compilation unit signature or a type signature S, an entry
11672 in the hash table is located as follows:
11674 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
11675 the low-order k bits all set to 1.
11677 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
11679 3) If the hash table entry at index H matches the signature, use that
11680 entry. If the hash table entry at index H is unused (all zeroes),
11681 terminate the search: the signature is not present in the table.
11683 4) Let H = (H + H') modulo M. Repeat at Step 3.
11685 Because M > N and H' and M are relatively prime, the search is guaranteed
11686 to stop at an unused slot or find the match. */
11688 /* Create a hash table to map DWO IDs to their CU/TU entry in
11689 .debug_{info,types}.dwo in DWP_FILE.
11690 Returns NULL if there isn't one.
11691 Note: This function processes DWP files only, not DWO files. */
11693 static struct dwp_hash_table
*
11694 create_dwp_hash_table (dwarf2_per_objfile
*per_objfile
,
11695 struct dwp_file
*dwp_file
, int is_debug_types
)
11697 struct objfile
*objfile
= per_objfile
->objfile
;
11698 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11699 const gdb_byte
*index_ptr
, *index_end
;
11700 struct dwarf2_section_info
*index
;
11701 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
11702 struct dwp_hash_table
*htab
;
11704 if (is_debug_types
)
11705 index
= &dwp_file
->sections
.tu_index
;
11707 index
= &dwp_file
->sections
.cu_index
;
11709 if (index
->empty ())
11711 index
->read (objfile
);
11713 index_ptr
= index
->buffer
;
11714 index_end
= index_ptr
+ index
->size
;
11716 /* For Version 5, the version is really 2 bytes of data & 2 bytes of padding.
11717 For now it's safe to just read 4 bytes (particularly as it's difficult to
11718 tell if you're dealing with Version 5 before you've read the version). */
11719 version
= read_4_bytes (dbfd
, index_ptr
);
11721 if (version
== 2 || version
== 5)
11722 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
11726 nr_units
= read_4_bytes (dbfd
, index_ptr
);
11728 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
11731 if (version
!= 1 && version
!= 2 && version
!= 5)
11733 error (_("Dwarf Error: unsupported DWP file version (%s)"
11734 " [in module %s]"),
11735 pulongest (version
), dwp_file
->name
);
11737 if (nr_slots
!= (nr_slots
& -nr_slots
))
11739 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
11740 " is not power of 2 [in module %s]"),
11741 pulongest (nr_slots
), dwp_file
->name
);
11744 htab
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwp_hash_table
);
11745 htab
->version
= version
;
11746 htab
->nr_columns
= nr_columns
;
11747 htab
->nr_units
= nr_units
;
11748 htab
->nr_slots
= nr_slots
;
11749 htab
->hash_table
= index_ptr
;
11750 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
11752 /* Exit early if the table is empty. */
11753 if (nr_slots
== 0 || nr_units
== 0
11754 || (version
== 2 && nr_columns
== 0)
11755 || (version
== 5 && nr_columns
== 0))
11757 /* All must be zero. */
11758 if (nr_slots
!= 0 || nr_units
!= 0
11759 || (version
== 2 && nr_columns
!= 0)
11760 || (version
== 5 && nr_columns
!= 0))
11762 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
11763 " all zero [in modules %s]"),
11771 htab
->section_pool
.v1
.indices
=
11772 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11773 /* It's harder to decide whether the section is too small in v1.
11774 V1 is deprecated anyway so we punt. */
11776 else if (version
== 2)
11778 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11779 int *ids
= htab
->section_pool
.v2
.section_ids
;
11780 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
11781 /* Reverse map for error checking. */
11782 int ids_seen
[DW_SECT_MAX
+ 1];
11785 if (nr_columns
< 2)
11787 error (_("Dwarf Error: bad DWP hash table, too few columns"
11788 " in section table [in module %s]"),
11791 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
11793 error (_("Dwarf Error: bad DWP hash table, too many columns"
11794 " in section table [in module %s]"),
11797 memset (ids
, 255, sizeof_ids
);
11798 memset (ids_seen
, 255, sizeof (ids_seen
));
11799 for (i
= 0; i
< nr_columns
; ++i
)
11801 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11803 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
11805 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11806 " in section table [in module %s]"),
11807 id
, dwp_file
->name
);
11809 if (ids_seen
[id
] != -1)
11811 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11812 " id %d in section table [in module %s]"),
11813 id
, dwp_file
->name
);
11818 /* Must have exactly one info or types section. */
11819 if (((ids_seen
[DW_SECT_INFO
] != -1)
11820 + (ids_seen
[DW_SECT_TYPES
] != -1))
11823 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11824 " DWO info/types section [in module %s]"),
11827 /* Must have an abbrev section. */
11828 if (ids_seen
[DW_SECT_ABBREV
] == -1)
11830 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11831 " section [in module %s]"),
11834 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11835 htab
->section_pool
.v2
.sizes
=
11836 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
11837 * nr_units
* nr_columns
);
11838 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
11839 * nr_units
* nr_columns
))
11842 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11843 " [in module %s]"),
11847 else /* version == 5 */
11849 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11850 int *ids
= htab
->section_pool
.v5
.section_ids
;
11851 size_t sizeof_ids
= sizeof (htab
->section_pool
.v5
.section_ids
);
11852 /* Reverse map for error checking. */
11853 int ids_seen
[DW_SECT_MAX_V5
+ 1];
11855 if (nr_columns
< 2)
11857 error (_("Dwarf Error: bad DWP hash table, too few columns"
11858 " in section table [in module %s]"),
11861 if (nr_columns
> MAX_NR_V5_DWO_SECTIONS
)
11863 error (_("Dwarf Error: bad DWP hash table, too many columns"
11864 " in section table [in module %s]"),
11867 memset (ids
, 255, sizeof_ids
);
11868 memset (ids_seen
, 255, sizeof (ids_seen
));
11869 for (int i
= 0; i
< nr_columns
; ++i
)
11871 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11873 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX_V5
)
11875 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11876 " in section table [in module %s]"),
11877 id
, dwp_file
->name
);
11879 if (ids_seen
[id
] != -1)
11881 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11882 " id %d in section table [in module %s]"),
11883 id
, dwp_file
->name
);
11888 /* Must have seen an info section. */
11889 if (ids_seen
[DW_SECT_INFO_V5
] == -1)
11891 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11892 " DWO info/types section [in module %s]"),
11895 /* Must have an abbrev section. */
11896 if (ids_seen
[DW_SECT_ABBREV_V5
] == -1)
11898 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11899 " section [in module %s]"),
11902 htab
->section_pool
.v5
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11903 htab
->section_pool
.v5
.sizes
11904 = htab
->section_pool
.v5
.offsets
+ (sizeof (uint32_t)
11905 * nr_units
* nr_columns
);
11906 if ((htab
->section_pool
.v5
.sizes
+ (sizeof (uint32_t)
11907 * nr_units
* nr_columns
))
11910 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11911 " [in module %s]"),
11919 /* Update SECTIONS with the data from SECTP.
11921 This function is like the other "locate" section routines, but in
11922 this context the sections to read comes from the DWP V1 hash table,
11923 not the full ELF section table.
11925 The result is non-zero for success, or zero if an error was found. */
11928 locate_v1_virtual_dwo_sections (asection
*sectp
,
11929 struct virtual_v1_dwo_sections
*sections
)
11931 const struct dwop_section_names
*names
= &dwop_section_names
;
11933 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
11935 /* There can be only one. */
11936 if (sections
->abbrev
.s
.section
!= NULL
)
11938 sections
->abbrev
.s
.section
= sectp
;
11939 sections
->abbrev
.size
= bfd_section_size (sectp
);
11941 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
11942 || section_is_p (sectp
->name
, &names
->types_dwo
))
11944 /* There can be only one. */
11945 if (sections
->info_or_types
.s
.section
!= NULL
)
11947 sections
->info_or_types
.s
.section
= sectp
;
11948 sections
->info_or_types
.size
= bfd_section_size (sectp
);
11950 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
11952 /* There can be only one. */
11953 if (sections
->line
.s
.section
!= NULL
)
11955 sections
->line
.s
.section
= sectp
;
11956 sections
->line
.size
= bfd_section_size (sectp
);
11958 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
11960 /* There can be only one. */
11961 if (sections
->loc
.s
.section
!= NULL
)
11963 sections
->loc
.s
.section
= sectp
;
11964 sections
->loc
.size
= bfd_section_size (sectp
);
11966 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
11968 /* There can be only one. */
11969 if (sections
->macinfo
.s
.section
!= NULL
)
11971 sections
->macinfo
.s
.section
= sectp
;
11972 sections
->macinfo
.size
= bfd_section_size (sectp
);
11974 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
11976 /* There can be only one. */
11977 if (sections
->macro
.s
.section
!= NULL
)
11979 sections
->macro
.s
.section
= sectp
;
11980 sections
->macro
.size
= bfd_section_size (sectp
);
11982 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
11984 /* There can be only one. */
11985 if (sections
->str_offsets
.s
.section
!= NULL
)
11987 sections
->str_offsets
.s
.section
= sectp
;
11988 sections
->str_offsets
.size
= bfd_section_size (sectp
);
11992 /* No other kind of section is valid. */
11999 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12000 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12001 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12002 This is for DWP version 1 files. */
12004 static struct dwo_unit
*
12005 create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
*per_objfile
,
12006 struct dwp_file
*dwp_file
,
12007 uint32_t unit_index
,
12008 const char *comp_dir
,
12009 ULONGEST signature
, int is_debug_types
)
12011 const struct dwp_hash_table
*dwp_htab
=
12012 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12013 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12014 const char *kind
= is_debug_types
? "TU" : "CU";
12015 struct dwo_file
*dwo_file
;
12016 struct dwo_unit
*dwo_unit
;
12017 struct virtual_v1_dwo_sections sections
;
12018 void **dwo_file_slot
;
12021 gdb_assert (dwp_file
->version
== 1);
12023 if (dwarf_read_debug
)
12025 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
12027 pulongest (unit_index
), hex_string (signature
),
12031 /* Fetch the sections of this DWO unit.
12032 Put a limit on the number of sections we look for so that bad data
12033 doesn't cause us to loop forever. */
12035 #define MAX_NR_V1_DWO_SECTIONS \
12036 (1 /* .debug_info or .debug_types */ \
12037 + 1 /* .debug_abbrev */ \
12038 + 1 /* .debug_line */ \
12039 + 1 /* .debug_loc */ \
12040 + 1 /* .debug_str_offsets */ \
12041 + 1 /* .debug_macro or .debug_macinfo */ \
12042 + 1 /* trailing zero */)
12044 memset (§ions
, 0, sizeof (sections
));
12046 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
12049 uint32_t section_nr
=
12050 read_4_bytes (dbfd
,
12051 dwp_htab
->section_pool
.v1
.indices
12052 + (unit_index
+ i
) * sizeof (uint32_t));
12054 if (section_nr
== 0)
12056 if (section_nr
>= dwp_file
->num_sections
)
12058 error (_("Dwarf Error: bad DWP hash table, section number too large"
12059 " [in module %s]"),
12063 sectp
= dwp_file
->elf_sections
[section_nr
];
12064 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
12066 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12067 " [in module %s]"),
12073 || sections
.info_or_types
.empty ()
12074 || sections
.abbrev
.empty ())
12076 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12077 " [in module %s]"),
12080 if (i
== MAX_NR_V1_DWO_SECTIONS
)
12082 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12083 " [in module %s]"),
12087 /* It's easier for the rest of the code if we fake a struct dwo_file and
12088 have dwo_unit "live" in that. At least for now.
12090 The DWP file can be made up of a random collection of CUs and TUs.
12091 However, for each CU + set of TUs that came from the same original DWO
12092 file, we can combine them back into a virtual DWO file to save space
12093 (fewer struct dwo_file objects to allocate). Remember that for really
12094 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12096 std::string virtual_dwo_name
=
12097 string_printf ("virtual-dwo/%d-%d-%d-%d",
12098 sections
.abbrev
.get_id (),
12099 sections
.line
.get_id (),
12100 sections
.loc
.get_id (),
12101 sections
.str_offsets
.get_id ());
12102 /* Can we use an existing virtual DWO file? */
12103 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
12105 /* Create one if necessary. */
12106 if (*dwo_file_slot
== NULL
)
12108 if (dwarf_read_debug
)
12110 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12111 virtual_dwo_name
.c_str ());
12113 dwo_file
= new struct dwo_file
;
12114 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12115 dwo_file
->comp_dir
= comp_dir
;
12116 dwo_file
->sections
.abbrev
= sections
.abbrev
;
12117 dwo_file
->sections
.line
= sections
.line
;
12118 dwo_file
->sections
.loc
= sections
.loc
;
12119 dwo_file
->sections
.macinfo
= sections
.macinfo
;
12120 dwo_file
->sections
.macro
= sections
.macro
;
12121 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
12122 /* The "str" section is global to the entire DWP file. */
12123 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12124 /* The info or types section is assigned below to dwo_unit,
12125 there's no need to record it in dwo_file.
12126 Also, we can't simply record type sections in dwo_file because
12127 we record a pointer into the vector in dwo_unit. As we collect more
12128 types we'll grow the vector and eventually have to reallocate space
12129 for it, invalidating all copies of pointers into the previous
12131 *dwo_file_slot
= dwo_file
;
12135 if (dwarf_read_debug
)
12137 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12138 virtual_dwo_name
.c_str ());
12140 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12143 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12144 dwo_unit
->dwo_file
= dwo_file
;
12145 dwo_unit
->signature
= signature
;
12146 dwo_unit
->section
=
12147 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12148 *dwo_unit
->section
= sections
.info_or_types
;
12149 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12154 /* Subroutine of create_dwo_unit_in_dwp_v2 and create_dwo_unit_in_dwp_v5 to
12155 simplify them. Given a pointer to the containing section SECTION, and
12156 OFFSET,SIZE of the piece within that section used by a TU/CU, return a
12157 virtual section of just that piece. */
12159 static struct dwarf2_section_info
12160 create_dwp_v2_or_v5_section (dwarf2_per_objfile
*per_objfile
,
12161 struct dwarf2_section_info
*section
,
12162 bfd_size_type offset
, bfd_size_type size
)
12164 struct dwarf2_section_info result
;
12167 gdb_assert (section
!= NULL
);
12168 gdb_assert (!section
->is_virtual
);
12170 memset (&result
, 0, sizeof (result
));
12171 result
.s
.containing_section
= section
;
12172 result
.is_virtual
= true;
12177 sectp
= section
->get_bfd_section ();
12179 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12180 bounds of the real section. This is a pretty-rare event, so just
12181 flag an error (easier) instead of a warning and trying to cope. */
12183 || offset
+ size
> bfd_section_size (sectp
))
12185 error (_("Dwarf Error: Bad DWP V2 or V5 section info, doesn't fit"
12186 " in section %s [in module %s]"),
12187 sectp
? bfd_section_name (sectp
) : "<unknown>",
12188 objfile_name (per_objfile
->objfile
));
12191 result
.virtual_offset
= offset
;
12192 result
.size
= size
;
12196 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12197 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12198 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12199 This is for DWP version 2 files. */
12201 static struct dwo_unit
*
12202 create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
*per_objfile
,
12203 struct dwp_file
*dwp_file
,
12204 uint32_t unit_index
,
12205 const char *comp_dir
,
12206 ULONGEST signature
, int is_debug_types
)
12208 const struct dwp_hash_table
*dwp_htab
=
12209 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12210 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12211 const char *kind
= is_debug_types
? "TU" : "CU";
12212 struct dwo_file
*dwo_file
;
12213 struct dwo_unit
*dwo_unit
;
12214 struct virtual_v2_or_v5_dwo_sections sections
;
12215 void **dwo_file_slot
;
12218 gdb_assert (dwp_file
->version
== 2);
12220 if (dwarf_read_debug
)
12222 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
12224 pulongest (unit_index
), hex_string (signature
),
12228 /* Fetch the section offsets of this DWO unit. */
12230 memset (§ions
, 0, sizeof (sections
));
12232 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12234 uint32_t offset
= read_4_bytes (dbfd
,
12235 dwp_htab
->section_pool
.v2
.offsets
12236 + (((unit_index
- 1) * dwp_htab
->nr_columns
12238 * sizeof (uint32_t)));
12239 uint32_t size
= read_4_bytes (dbfd
,
12240 dwp_htab
->section_pool
.v2
.sizes
12241 + (((unit_index
- 1) * dwp_htab
->nr_columns
12243 * sizeof (uint32_t)));
12245 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
12248 case DW_SECT_TYPES
:
12249 sections
.info_or_types_offset
= offset
;
12250 sections
.info_or_types_size
= size
;
12252 case DW_SECT_ABBREV
:
12253 sections
.abbrev_offset
= offset
;
12254 sections
.abbrev_size
= size
;
12257 sections
.line_offset
= offset
;
12258 sections
.line_size
= size
;
12261 sections
.loc_offset
= offset
;
12262 sections
.loc_size
= size
;
12264 case DW_SECT_STR_OFFSETS
:
12265 sections
.str_offsets_offset
= offset
;
12266 sections
.str_offsets_size
= size
;
12268 case DW_SECT_MACINFO
:
12269 sections
.macinfo_offset
= offset
;
12270 sections
.macinfo_size
= size
;
12272 case DW_SECT_MACRO
:
12273 sections
.macro_offset
= offset
;
12274 sections
.macro_size
= size
;
12279 /* It's easier for the rest of the code if we fake a struct dwo_file and
12280 have dwo_unit "live" in that. At least for now.
12282 The DWP file can be made up of a random collection of CUs and TUs.
12283 However, for each CU + set of TUs that came from the same original DWO
12284 file, we can combine them back into a virtual DWO file to save space
12285 (fewer struct dwo_file objects to allocate). Remember that for really
12286 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12288 std::string virtual_dwo_name
=
12289 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12290 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12291 (long) (sections
.line_size
? sections
.line_offset
: 0),
12292 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
12293 (long) (sections
.str_offsets_size
12294 ? sections
.str_offsets_offset
: 0));
12295 /* Can we use an existing virtual DWO file? */
12296 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
12298 /* Create one if necessary. */
12299 if (*dwo_file_slot
== NULL
)
12301 if (dwarf_read_debug
)
12303 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12304 virtual_dwo_name
.c_str ());
12306 dwo_file
= new struct dwo_file
;
12307 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12308 dwo_file
->comp_dir
= comp_dir
;
12309 dwo_file
->sections
.abbrev
=
12310 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.abbrev
,
12311 sections
.abbrev_offset
,
12312 sections
.abbrev_size
);
12313 dwo_file
->sections
.line
=
12314 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.line
,
12315 sections
.line_offset
,
12316 sections
.line_size
);
12317 dwo_file
->sections
.loc
=
12318 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.loc
,
12319 sections
.loc_offset
, sections
.loc_size
);
12320 dwo_file
->sections
.macinfo
=
12321 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macinfo
,
12322 sections
.macinfo_offset
,
12323 sections
.macinfo_size
);
12324 dwo_file
->sections
.macro
=
12325 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macro
,
12326 sections
.macro_offset
,
12327 sections
.macro_size
);
12328 dwo_file
->sections
.str_offsets
=
12329 create_dwp_v2_or_v5_section (per_objfile
,
12330 &dwp_file
->sections
.str_offsets
,
12331 sections
.str_offsets_offset
,
12332 sections
.str_offsets_size
);
12333 /* The "str" section is global to the entire DWP file. */
12334 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12335 /* The info or types section is assigned below to dwo_unit,
12336 there's no need to record it in dwo_file.
12337 Also, we can't simply record type sections in dwo_file because
12338 we record a pointer into the vector in dwo_unit. As we collect more
12339 types we'll grow the vector and eventually have to reallocate space
12340 for it, invalidating all copies of pointers into the previous
12342 *dwo_file_slot
= dwo_file
;
12346 if (dwarf_read_debug
)
12348 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12349 virtual_dwo_name
.c_str ());
12351 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12354 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12355 dwo_unit
->dwo_file
= dwo_file
;
12356 dwo_unit
->signature
= signature
;
12357 dwo_unit
->section
=
12358 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12359 *dwo_unit
->section
= create_dwp_v2_or_v5_section
12362 ? &dwp_file
->sections
.types
12363 : &dwp_file
->sections
.info
,
12364 sections
.info_or_types_offset
,
12365 sections
.info_or_types_size
);
12366 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12371 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12372 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12373 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12374 This is for DWP version 5 files. */
12376 static struct dwo_unit
*
12377 create_dwo_unit_in_dwp_v5 (dwarf2_per_objfile
*per_objfile
,
12378 struct dwp_file
*dwp_file
,
12379 uint32_t unit_index
,
12380 const char *comp_dir
,
12381 ULONGEST signature
, int is_debug_types
)
12383 const struct dwp_hash_table
*dwp_htab
12384 = is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12385 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12386 const char *kind
= is_debug_types
? "TU" : "CU";
12387 struct dwo_file
*dwo_file
;
12388 struct dwo_unit
*dwo_unit
;
12389 struct virtual_v2_or_v5_dwo_sections sections
{};
12390 void **dwo_file_slot
;
12392 gdb_assert (dwp_file
->version
== 5);
12394 if (dwarf_read_debug
)
12396 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V5 file: %s\n",
12398 pulongest (unit_index
), hex_string (signature
),
12402 /* Fetch the section offsets of this DWO unit. */
12404 /* memset (§ions, 0, sizeof (sections)); */
12406 for (int i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12408 uint32_t offset
= read_4_bytes (dbfd
,
12409 dwp_htab
->section_pool
.v5
.offsets
12410 + (((unit_index
- 1)
12411 * dwp_htab
->nr_columns
12413 * sizeof (uint32_t)));
12414 uint32_t size
= read_4_bytes (dbfd
,
12415 dwp_htab
->section_pool
.v5
.sizes
12416 + (((unit_index
- 1) * dwp_htab
->nr_columns
12418 * sizeof (uint32_t)));
12420 switch (dwp_htab
->section_pool
.v5
.section_ids
[i
])
12422 case DW_SECT_ABBREV_V5
:
12423 sections
.abbrev_offset
= offset
;
12424 sections
.abbrev_size
= size
;
12426 case DW_SECT_INFO_V5
:
12427 sections
.info_or_types_offset
= offset
;
12428 sections
.info_or_types_size
= size
;
12430 case DW_SECT_LINE_V5
:
12431 sections
.line_offset
= offset
;
12432 sections
.line_size
= size
;
12434 case DW_SECT_LOCLISTS_V5
:
12435 sections
.loclists_offset
= offset
;
12436 sections
.loclists_size
= size
;
12438 case DW_SECT_MACRO_V5
:
12439 sections
.macro_offset
= offset
;
12440 sections
.macro_size
= size
;
12442 case DW_SECT_RNGLISTS_V5
:
12443 sections
.rnglists_offset
= offset
;
12444 sections
.rnglists_size
= size
;
12446 case DW_SECT_STR_OFFSETS_V5
:
12447 sections
.str_offsets_offset
= offset
;
12448 sections
.str_offsets_size
= size
;
12450 case DW_SECT_RESERVED_V5
:
12456 /* It's easier for the rest of the code if we fake a struct dwo_file and
12457 have dwo_unit "live" in that. At least for now.
12459 The DWP file can be made up of a random collection of CUs and TUs.
12460 However, for each CU + set of TUs that came from the same original DWO
12461 file, we can combine them back into a virtual DWO file to save space
12462 (fewer struct dwo_file objects to allocate). Remember that for really
12463 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12465 std::string virtual_dwo_name
=
12466 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld-%ld-%ld",
12467 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12468 (long) (sections
.line_size
? sections
.line_offset
: 0),
12469 (long) (sections
.loclists_size
? sections
.loclists_offset
: 0),
12470 (long) (sections
.str_offsets_size
12471 ? sections
.str_offsets_offset
: 0),
12472 (long) (sections
.macro_size
? sections
.macro_offset
: 0),
12473 (long) (sections
.rnglists_size
? sections
.rnglists_offset
: 0));
12474 /* Can we use an existing virtual DWO file? */
12475 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
,
12476 virtual_dwo_name
.c_str (),
12478 /* Create one if necessary. */
12479 if (*dwo_file_slot
== NULL
)
12481 if (dwarf_read_debug
)
12483 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12484 virtual_dwo_name
.c_str ());
12486 dwo_file
= new struct dwo_file
;
12487 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12488 dwo_file
->comp_dir
= comp_dir
;
12489 dwo_file
->sections
.abbrev
=
12490 create_dwp_v2_or_v5_section (per_objfile
,
12491 &dwp_file
->sections
.abbrev
,
12492 sections
.abbrev_offset
,
12493 sections
.abbrev_size
);
12494 dwo_file
->sections
.line
=
12495 create_dwp_v2_or_v5_section (per_objfile
,
12496 &dwp_file
->sections
.line
,
12497 sections
.line_offset
, sections
.line_size
);
12498 dwo_file
->sections
.macro
=
12499 create_dwp_v2_or_v5_section (per_objfile
,
12500 &dwp_file
->sections
.macro
,
12501 sections
.macro_offset
,
12502 sections
.macro_size
);
12503 dwo_file
->sections
.loclists
=
12504 create_dwp_v2_or_v5_section (per_objfile
,
12505 &dwp_file
->sections
.loclists
,
12506 sections
.loclists_offset
,
12507 sections
.loclists_size
);
12508 dwo_file
->sections
.rnglists
=
12509 create_dwp_v2_or_v5_section (per_objfile
,
12510 &dwp_file
->sections
.rnglists
,
12511 sections
.rnglists_offset
,
12512 sections
.rnglists_size
);
12513 dwo_file
->sections
.str_offsets
=
12514 create_dwp_v2_or_v5_section (per_objfile
,
12515 &dwp_file
->sections
.str_offsets
,
12516 sections
.str_offsets_offset
,
12517 sections
.str_offsets_size
);
12518 /* The "str" section is global to the entire DWP file. */
12519 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12520 /* The info or types section is assigned below to dwo_unit,
12521 there's no need to record it in dwo_file.
12522 Also, we can't simply record type sections in dwo_file because
12523 we record a pointer into the vector in dwo_unit. As we collect more
12524 types we'll grow the vector and eventually have to reallocate space
12525 for it, invalidating all copies of pointers into the previous
12527 *dwo_file_slot
= dwo_file
;
12531 if (dwarf_read_debug
)
12533 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12534 virtual_dwo_name
.c_str ());
12536 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12539 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12540 dwo_unit
->dwo_file
= dwo_file
;
12541 dwo_unit
->signature
= signature
;
12543 = XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12544 *dwo_unit
->section
= create_dwp_v2_or_v5_section (per_objfile
,
12545 &dwp_file
->sections
.info
,
12546 sections
.info_or_types_offset
,
12547 sections
.info_or_types_size
);
12548 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12553 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12554 Returns NULL if the signature isn't found. */
12556 static struct dwo_unit
*
12557 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
*per_objfile
,
12558 struct dwp_file
*dwp_file
, const char *comp_dir
,
12559 ULONGEST signature
, int is_debug_types
)
12561 const struct dwp_hash_table
*dwp_htab
=
12562 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12563 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12564 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12565 uint32_t hash
= signature
& mask
;
12566 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12569 struct dwo_unit find_dwo_cu
;
12571 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12572 find_dwo_cu
.signature
= signature
;
12573 slot
= htab_find_slot (is_debug_types
12574 ? dwp_file
->loaded_tus
.get ()
12575 : dwp_file
->loaded_cus
.get (),
12576 &find_dwo_cu
, INSERT
);
12579 return (struct dwo_unit
*) *slot
;
12581 /* Use a for loop so that we don't loop forever on bad debug info. */
12582 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12584 ULONGEST signature_in_table
;
12586 signature_in_table
=
12587 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12588 if (signature_in_table
== signature
)
12590 uint32_t unit_index
=
12591 read_4_bytes (dbfd
,
12592 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12594 if (dwp_file
->version
== 1)
12596 *slot
= create_dwo_unit_in_dwp_v1 (per_objfile
, dwp_file
,
12597 unit_index
, comp_dir
,
12598 signature
, is_debug_types
);
12600 else if (dwp_file
->version
== 2)
12602 *slot
= create_dwo_unit_in_dwp_v2 (per_objfile
, dwp_file
,
12603 unit_index
, comp_dir
,
12604 signature
, is_debug_types
);
12606 else /* version == 5 */
12608 *slot
= create_dwo_unit_in_dwp_v5 (per_objfile
, dwp_file
,
12609 unit_index
, comp_dir
,
12610 signature
, is_debug_types
);
12612 return (struct dwo_unit
*) *slot
;
12614 if (signature_in_table
== 0)
12616 hash
= (hash
+ hash2
) & mask
;
12619 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12620 " [in module %s]"),
12624 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12625 Open the file specified by FILE_NAME and hand it off to BFD for
12626 preliminary analysis. Return a newly initialized bfd *, which
12627 includes a canonicalized copy of FILE_NAME.
12628 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12629 SEARCH_CWD is true if the current directory is to be searched.
12630 It will be searched before debug-file-directory.
12631 If successful, the file is added to the bfd include table of the
12632 objfile's bfd (see gdb_bfd_record_inclusion).
12633 If unable to find/open the file, return NULL.
12634 NOTE: This function is derived from symfile_bfd_open. */
12636 static gdb_bfd_ref_ptr
12637 try_open_dwop_file (dwarf2_per_objfile
*per_objfile
,
12638 const char *file_name
, int is_dwp
, int search_cwd
)
12641 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12642 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12643 to debug_file_directory. */
12644 const char *search_path
;
12645 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12647 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12650 if (*debug_file_directory
!= '\0')
12652 search_path_holder
.reset (concat (".", dirname_separator_string
,
12653 debug_file_directory
,
12655 search_path
= search_path_holder
.get ();
12661 search_path
= debug_file_directory
;
12663 openp_flags flags
= OPF_RETURN_REALPATH
;
12665 flags
|= OPF_SEARCH_IN_PATH
;
12667 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12668 desc
= openp (search_path
, flags
, file_name
,
12669 O_RDONLY
| O_BINARY
, &absolute_name
);
12673 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12675 if (sym_bfd
== NULL
)
12677 bfd_set_cacheable (sym_bfd
.get (), 1);
12679 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12682 /* Success. Record the bfd as having been included by the objfile's bfd.
12683 This is important because things like demangled_names_hash lives in the
12684 objfile's per_bfd space and may have references to things like symbol
12685 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12686 gdb_bfd_record_inclusion (per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12691 /* Try to open DWO file FILE_NAME.
12692 COMP_DIR is the DW_AT_comp_dir attribute.
12693 The result is the bfd handle of the file.
12694 If there is a problem finding or opening the file, return NULL.
12695 Upon success, the canonicalized path of the file is stored in the bfd,
12696 same as symfile_bfd_open. */
12698 static gdb_bfd_ref_ptr
12699 open_dwo_file (dwarf2_per_objfile
*per_objfile
,
12700 const char *file_name
, const char *comp_dir
)
12702 if (IS_ABSOLUTE_PATH (file_name
))
12703 return try_open_dwop_file (per_objfile
, file_name
,
12704 0 /*is_dwp*/, 0 /*search_cwd*/);
12706 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12708 if (comp_dir
!= NULL
)
12710 gdb::unique_xmalloc_ptr
<char> path_to_try
12711 (concat (comp_dir
, SLASH_STRING
, file_name
, (char *) NULL
));
12713 /* NOTE: If comp_dir is a relative path, this will also try the
12714 search path, which seems useful. */
12715 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, path_to_try
.get (),
12717 1 /*search_cwd*/));
12722 /* That didn't work, try debug-file-directory, which, despite its name,
12723 is a list of paths. */
12725 if (*debug_file_directory
== '\0')
12728 return try_open_dwop_file (per_objfile
, file_name
,
12729 0 /*is_dwp*/, 1 /*search_cwd*/);
12732 /* This function is mapped across the sections and remembers the offset and
12733 size of each of the DWO debugging sections we are interested in. */
12736 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
,
12737 dwo_sections
*dwo_sections
)
12739 const struct dwop_section_names
*names
= &dwop_section_names
;
12741 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12743 dwo_sections
->abbrev
.s
.section
= sectp
;
12744 dwo_sections
->abbrev
.size
= bfd_section_size (sectp
);
12746 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12748 dwo_sections
->info
.s
.section
= sectp
;
12749 dwo_sections
->info
.size
= bfd_section_size (sectp
);
12751 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12753 dwo_sections
->line
.s
.section
= sectp
;
12754 dwo_sections
->line
.size
= bfd_section_size (sectp
);
12756 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12758 dwo_sections
->loc
.s
.section
= sectp
;
12759 dwo_sections
->loc
.size
= bfd_section_size (sectp
);
12761 else if (section_is_p (sectp
->name
, &names
->loclists_dwo
))
12763 dwo_sections
->loclists
.s
.section
= sectp
;
12764 dwo_sections
->loclists
.size
= bfd_section_size (sectp
);
12766 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12768 dwo_sections
->macinfo
.s
.section
= sectp
;
12769 dwo_sections
->macinfo
.size
= bfd_section_size (sectp
);
12771 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12773 dwo_sections
->macro
.s
.section
= sectp
;
12774 dwo_sections
->macro
.size
= bfd_section_size (sectp
);
12776 else if (section_is_p (sectp
->name
, &names
->rnglists_dwo
))
12778 dwo_sections
->rnglists
.s
.section
= sectp
;
12779 dwo_sections
->rnglists
.size
= bfd_section_size (sectp
);
12781 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
12783 dwo_sections
->str
.s
.section
= sectp
;
12784 dwo_sections
->str
.size
= bfd_section_size (sectp
);
12786 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12788 dwo_sections
->str_offsets
.s
.section
= sectp
;
12789 dwo_sections
->str_offsets
.size
= bfd_section_size (sectp
);
12791 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
12793 struct dwarf2_section_info type_section
;
12795 memset (&type_section
, 0, sizeof (type_section
));
12796 type_section
.s
.section
= sectp
;
12797 type_section
.size
= bfd_section_size (sectp
);
12798 dwo_sections
->types
.push_back (type_section
);
12802 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12803 by PER_CU. This is for the non-DWP case.
12804 The result is NULL if DWO_NAME can't be found. */
12806 static struct dwo_file
*
12807 open_and_init_dwo_file (dwarf2_cu
*cu
, const char *dwo_name
,
12808 const char *comp_dir
)
12810 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
12812 gdb_bfd_ref_ptr dbfd
= open_dwo_file (per_objfile
, dwo_name
, comp_dir
);
12815 if (dwarf_read_debug
)
12816 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
12820 dwo_file_up
dwo_file (new struct dwo_file
);
12821 dwo_file
->dwo_name
= dwo_name
;
12822 dwo_file
->comp_dir
= comp_dir
;
12823 dwo_file
->dbfd
= std::move (dbfd
);
12825 for (asection
*sec
: gdb_bfd_sections (dwo_file
->dbfd
))
12826 dwarf2_locate_dwo_sections (dwo_file
->dbfd
.get (), sec
,
12827 &dwo_file
->sections
);
12829 create_cus_hash_table (per_objfile
, cu
, *dwo_file
, dwo_file
->sections
.info
,
12832 if (cu
->per_cu
->dwarf_version
< 5)
12834 create_debug_types_hash_table (per_objfile
, dwo_file
.get (),
12835 dwo_file
->sections
.types
, dwo_file
->tus
);
12839 create_debug_type_hash_table (per_objfile
, dwo_file
.get (),
12840 &dwo_file
->sections
.info
, dwo_file
->tus
,
12844 if (dwarf_read_debug
)
12845 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
12847 return dwo_file
.release ();
12850 /* This function is mapped across the sections and remembers the offset and
12851 size of each of the DWP debugging sections common to version 1 and 2 that
12852 we are interested in. */
12855 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
12856 dwp_file
*dwp_file
)
12858 const struct dwop_section_names
*names
= &dwop_section_names
;
12859 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12861 /* Record the ELF section number for later lookup: this is what the
12862 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12863 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12864 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12866 /* Look for specific sections that we need. */
12867 if (section_is_p (sectp
->name
, &names
->str_dwo
))
12869 dwp_file
->sections
.str
.s
.section
= sectp
;
12870 dwp_file
->sections
.str
.size
= bfd_section_size (sectp
);
12872 else if (section_is_p (sectp
->name
, &names
->cu_index
))
12874 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
12875 dwp_file
->sections
.cu_index
.size
= bfd_section_size (sectp
);
12877 else if (section_is_p (sectp
->name
, &names
->tu_index
))
12879 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
12880 dwp_file
->sections
.tu_index
.size
= bfd_section_size (sectp
);
12884 /* This function is mapped across the sections and remembers the offset and
12885 size of each of the DWP version 2 debugging sections that we are interested
12886 in. This is split into a separate function because we don't know if we
12887 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12890 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12892 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12893 const struct dwop_section_names
*names
= &dwop_section_names
;
12894 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12896 /* Record the ELF section number for later lookup: this is what the
12897 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12898 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12899 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12901 /* Look for specific sections that we need. */
12902 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12904 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12905 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12907 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12909 dwp_file
->sections
.info
.s
.section
= sectp
;
12910 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12912 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12914 dwp_file
->sections
.line
.s
.section
= sectp
;
12915 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12917 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12919 dwp_file
->sections
.loc
.s
.section
= sectp
;
12920 dwp_file
->sections
.loc
.size
= bfd_section_size (sectp
);
12922 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12924 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
12925 dwp_file
->sections
.macinfo
.size
= bfd_section_size (sectp
);
12927 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12929 dwp_file
->sections
.macro
.s
.section
= sectp
;
12930 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12932 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12934 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12935 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12937 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
12939 dwp_file
->sections
.types
.s
.section
= sectp
;
12940 dwp_file
->sections
.types
.size
= bfd_section_size (sectp
);
12944 /* This function is mapped across the sections and remembers the offset and
12945 size of each of the DWP version 5 debugging sections that we are interested
12946 in. This is split into a separate function because we don't know if we
12947 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12950 dwarf2_locate_v5_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12952 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12953 const struct dwop_section_names
*names
= &dwop_section_names
;
12954 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12956 /* Record the ELF section number for later lookup: this is what the
12957 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12958 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12959 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12961 /* Look for specific sections that we need. */
12962 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12964 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12965 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12967 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12969 dwp_file
->sections
.info
.s
.section
= sectp
;
12970 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12972 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12974 dwp_file
->sections
.line
.s
.section
= sectp
;
12975 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12977 else if (section_is_p (sectp
->name
, &names
->loclists_dwo
))
12979 dwp_file
->sections
.loclists
.s
.section
= sectp
;
12980 dwp_file
->sections
.loclists
.size
= bfd_section_size (sectp
);
12982 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12984 dwp_file
->sections
.macro
.s
.section
= sectp
;
12985 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12987 else if (section_is_p (sectp
->name
, &names
->rnglists_dwo
))
12989 dwp_file
->sections
.rnglists
.s
.section
= sectp
;
12990 dwp_file
->sections
.rnglists
.size
= bfd_section_size (sectp
);
12992 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12994 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12995 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12999 /* Hash function for dwp_file loaded CUs/TUs. */
13002 hash_dwp_loaded_cutus (const void *item
)
13004 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
13006 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13007 return dwo_unit
->signature
;
13010 /* Equality function for dwp_file loaded CUs/TUs. */
13013 eq_dwp_loaded_cutus (const void *a
, const void *b
)
13015 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
13016 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
13018 return dua
->signature
== dub
->signature
;
13021 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13024 allocate_dwp_loaded_cutus_table ()
13026 return htab_up (htab_create_alloc (3,
13027 hash_dwp_loaded_cutus
,
13028 eq_dwp_loaded_cutus
,
13029 NULL
, xcalloc
, xfree
));
13032 /* Try to open DWP file FILE_NAME.
13033 The result is the bfd handle of the file.
13034 If there is a problem finding or opening the file, return NULL.
13035 Upon success, the canonicalized path of the file is stored in the bfd,
13036 same as symfile_bfd_open. */
13038 static gdb_bfd_ref_ptr
13039 open_dwp_file (dwarf2_per_objfile
*per_objfile
, const char *file_name
)
13041 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, file_name
,
13043 1 /*search_cwd*/));
13047 /* Work around upstream bug 15652.
13048 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13049 [Whether that's a "bug" is debatable, but it is getting in our way.]
13050 We have no real idea where the dwp file is, because gdb's realpath-ing
13051 of the executable's path may have discarded the needed info.
13052 [IWBN if the dwp file name was recorded in the executable, akin to
13053 .gnu_debuglink, but that doesn't exist yet.]
13054 Strip the directory from FILE_NAME and search again. */
13055 if (*debug_file_directory
!= '\0')
13057 /* Don't implicitly search the current directory here.
13058 If the user wants to search "." to handle this case,
13059 it must be added to debug-file-directory. */
13060 return try_open_dwop_file (per_objfile
, lbasename (file_name
),
13068 /* Initialize the use of the DWP file for the current objfile.
13069 By convention the name of the DWP file is ${objfile}.dwp.
13070 The result is NULL if it can't be found. */
13072 static std::unique_ptr
<struct dwp_file
>
13073 open_and_init_dwp_file (dwarf2_per_objfile
*per_objfile
)
13075 struct objfile
*objfile
= per_objfile
->objfile
;
13077 /* Try to find first .dwp for the binary file before any symbolic links
13080 /* If the objfile is a debug file, find the name of the real binary
13081 file and get the name of dwp file from there. */
13082 std::string dwp_name
;
13083 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
13085 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
13086 const char *backlink_basename
= lbasename (backlink
->original_name
);
13088 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
13091 dwp_name
= objfile
->original_name
;
13093 dwp_name
+= ".dwp";
13095 gdb_bfd_ref_ptr
dbfd (open_dwp_file (per_objfile
, dwp_name
.c_str ()));
13097 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
13099 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13100 dwp_name
= objfile_name (objfile
);
13101 dwp_name
+= ".dwp";
13102 dbfd
= open_dwp_file (per_objfile
, dwp_name
.c_str ());
13107 if (dwarf_read_debug
)
13108 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
.c_str ());
13109 return std::unique_ptr
<dwp_file
> ();
13112 const char *name
= bfd_get_filename (dbfd
.get ());
13113 std::unique_ptr
<struct dwp_file
> dwp_file
13114 (new struct dwp_file (name
, std::move (dbfd
)));
13116 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
13117 dwp_file
->elf_sections
=
13118 OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
13119 dwp_file
->num_sections
, asection
*);
13121 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
13122 dwarf2_locate_common_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13125 dwp_file
->cus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 0);
13127 dwp_file
->tus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 1);
13129 /* The DWP file version is stored in the hash table. Oh well. */
13130 if (dwp_file
->cus
&& dwp_file
->tus
13131 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
13133 /* Technically speaking, we should try to limp along, but this is
13134 pretty bizarre. We use pulongest here because that's the established
13135 portability solution (e.g, we cannot use %u for uint32_t). */
13136 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13137 " TU version %s [in DWP file %s]"),
13138 pulongest (dwp_file
->cus
->version
),
13139 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
13143 dwp_file
->version
= dwp_file
->cus
->version
;
13144 else if (dwp_file
->tus
)
13145 dwp_file
->version
= dwp_file
->tus
->version
;
13147 dwp_file
->version
= 2;
13149 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
13151 if (dwp_file
->version
== 2)
13152 dwarf2_locate_v2_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13155 dwarf2_locate_v5_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13159 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table ();
13160 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table ();
13162 if (dwarf_read_debug
)
13164 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
13165 fprintf_unfiltered (gdb_stdlog
,
13166 " %s CUs, %s TUs\n",
13167 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
13168 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
13174 /* Wrapper around open_and_init_dwp_file, only open it once. */
13176 static struct dwp_file
*
13177 get_dwp_file (dwarf2_per_objfile
*per_objfile
)
13179 if (!per_objfile
->per_bfd
->dwp_checked
)
13181 per_objfile
->per_bfd
->dwp_file
= open_and_init_dwp_file (per_objfile
);
13182 per_objfile
->per_bfd
->dwp_checked
= 1;
13184 return per_objfile
->per_bfd
->dwp_file
.get ();
13187 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13188 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13189 or in the DWP file for the objfile, referenced by THIS_UNIT.
13190 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13191 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13193 This is called, for example, when wanting to read a variable with a
13194 complex location. Therefore we don't want to do file i/o for every call.
13195 Therefore we don't want to look for a DWO file on every call.
13196 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13197 then we check if we've already seen DWO_NAME, and only THEN do we check
13200 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13201 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13203 static struct dwo_unit
*
13204 lookup_dwo_cutu (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
13205 ULONGEST signature
, int is_debug_types
)
13207 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13208 struct objfile
*objfile
= per_objfile
->objfile
;
13209 const char *kind
= is_debug_types
? "TU" : "CU";
13210 void **dwo_file_slot
;
13211 struct dwo_file
*dwo_file
;
13212 struct dwp_file
*dwp_file
;
13214 /* First see if there's a DWP file.
13215 If we have a DWP file but didn't find the DWO inside it, don't
13216 look for the original DWO file. It makes gdb behave differently
13217 depending on whether one is debugging in the build tree. */
13219 dwp_file
= get_dwp_file (per_objfile
);
13220 if (dwp_file
!= NULL
)
13222 const struct dwp_hash_table
*dwp_htab
=
13223 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
13225 if (dwp_htab
!= NULL
)
13227 struct dwo_unit
*dwo_cutu
=
13228 lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, comp_dir
, signature
,
13231 if (dwo_cutu
!= NULL
)
13233 if (dwarf_read_debug
)
13235 fprintf_unfiltered (gdb_stdlog
,
13236 "Virtual DWO %s %s found: @%s\n",
13237 kind
, hex_string (signature
),
13238 host_address_to_string (dwo_cutu
));
13246 /* No DWP file, look for the DWO file. */
13248 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, dwo_name
, comp_dir
);
13249 if (*dwo_file_slot
== NULL
)
13251 /* Read in the file and build a table of the CUs/TUs it contains. */
13252 *dwo_file_slot
= open_and_init_dwo_file (cu
, dwo_name
, comp_dir
);
13254 /* NOTE: This will be NULL if unable to open the file. */
13255 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
13257 if (dwo_file
!= NULL
)
13259 struct dwo_unit
*dwo_cutu
= NULL
;
13261 if (is_debug_types
&& dwo_file
->tus
)
13263 struct dwo_unit find_dwo_cutu
;
13265 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13266 find_dwo_cutu
.signature
= signature
;
13268 = (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
13271 else if (!is_debug_types
&& dwo_file
->cus
)
13273 struct dwo_unit find_dwo_cutu
;
13275 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13276 find_dwo_cutu
.signature
= signature
;
13277 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
.get (),
13281 if (dwo_cutu
!= NULL
)
13283 if (dwarf_read_debug
)
13285 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
13286 kind
, dwo_name
, hex_string (signature
),
13287 host_address_to_string (dwo_cutu
));
13294 /* We didn't find it. This could mean a dwo_id mismatch, or
13295 someone deleted the DWO/DWP file, or the search path isn't set up
13296 correctly to find the file. */
13298 if (dwarf_read_debug
)
13300 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
13301 kind
, dwo_name
, hex_string (signature
));
13304 /* This is a warning and not a complaint because it can be caused by
13305 pilot error (e.g., user accidentally deleting the DWO). */
13307 /* Print the name of the DWP file if we looked there, helps the user
13308 better diagnose the problem. */
13309 std::string dwp_text
;
13311 if (dwp_file
!= NULL
)
13312 dwp_text
= string_printf (" [in DWP file %s]",
13313 lbasename (dwp_file
->name
));
13315 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13316 " [in module %s]"),
13317 kind
, dwo_name
, hex_string (signature
), dwp_text
.c_str (), kind
,
13318 sect_offset_str (cu
->per_cu
->sect_off
), objfile_name (objfile
));
13323 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13324 See lookup_dwo_cutu_unit for details. */
13326 static struct dwo_unit
*
13327 lookup_dwo_comp_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
13328 ULONGEST signature
)
13330 gdb_assert (!cu
->per_cu
->is_debug_types
);
13332 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, signature
, 0);
13335 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13336 See lookup_dwo_cutu_unit for details. */
13338 static struct dwo_unit
*
13339 lookup_dwo_type_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
)
13341 gdb_assert (cu
->per_cu
->is_debug_types
);
13343 signatured_type
*sig_type
= (signatured_type
*) cu
->per_cu
;
13345 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, sig_type
->signature
, 1);
13348 /* Traversal function for queue_and_load_all_dwo_tus. */
13351 queue_and_load_dwo_tu (void **slot
, void *info
)
13353 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
13354 dwarf2_cu
*cu
= (dwarf2_cu
*) info
;
13355 ULONGEST signature
= dwo_unit
->signature
;
13356 signatured_type
*sig_type
= lookup_dwo_signatured_type (cu
, signature
);
13358 if (sig_type
!= NULL
)
13360 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
13362 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13363 a real dependency of PER_CU on SIG_TYPE. That is detected later
13364 while processing PER_CU. */
13365 if (maybe_queue_comp_unit (NULL
, sig_cu
, cu
->per_objfile
, cu
->language
))
13366 load_full_type_unit (sig_cu
, cu
->per_objfile
);
13367 cu
->per_cu
->imported_symtabs_push (sig_cu
);
13373 /* Queue all TUs contained in the DWO of CU to be read in.
13374 The DWO may have the only definition of the type, though it may not be
13375 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13376 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13379 queue_and_load_all_dwo_tus (dwarf2_cu
*cu
)
13381 struct dwo_unit
*dwo_unit
;
13382 struct dwo_file
*dwo_file
;
13384 gdb_assert (cu
!= nullptr);
13385 gdb_assert (!cu
->per_cu
->is_debug_types
);
13386 gdb_assert (get_dwp_file (cu
->per_objfile
) == nullptr);
13388 dwo_unit
= cu
->dwo_unit
;
13389 gdb_assert (dwo_unit
!= NULL
);
13391 dwo_file
= dwo_unit
->dwo_file
;
13392 if (dwo_file
->tus
!= NULL
)
13393 htab_traverse_noresize (dwo_file
->tus
.get (), queue_and_load_dwo_tu
, cu
);
13396 /* Read in various DIEs. */
13398 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13399 Inherit only the children of the DW_AT_abstract_origin DIE not being
13400 already referenced by DW_AT_abstract_origin from the children of the
13404 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
13406 struct die_info
*child_die
;
13407 sect_offset
*offsetp
;
13408 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13409 struct die_info
*origin_die
;
13410 /* Iterator of the ORIGIN_DIE children. */
13411 struct die_info
*origin_child_die
;
13412 struct attribute
*attr
;
13413 struct dwarf2_cu
*origin_cu
;
13414 struct pending
**origin_previous_list_in_scope
;
13416 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13420 /* Note that following die references may follow to a die in a
13424 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
13426 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13428 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
13429 origin_cu
->list_in_scope
= cu
->list_in_scope
;
13431 if (die
->tag
!= origin_die
->tag
13432 && !(die
->tag
== DW_TAG_inlined_subroutine
13433 && origin_die
->tag
== DW_TAG_subprogram
))
13434 complaint (_("DIE %s and its abstract origin %s have different tags"),
13435 sect_offset_str (die
->sect_off
),
13436 sect_offset_str (origin_die
->sect_off
));
13438 std::vector
<sect_offset
> offsets
;
13440 for (child_die
= die
->child
;
13441 child_die
&& child_die
->tag
;
13442 child_die
= child_die
->sibling
)
13444 struct die_info
*child_origin_die
;
13445 struct dwarf2_cu
*child_origin_cu
;
13447 /* We are trying to process concrete instance entries:
13448 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13449 it's not relevant to our analysis here. i.e. detecting DIEs that are
13450 present in the abstract instance but not referenced in the concrete
13452 if (child_die
->tag
== DW_TAG_call_site
13453 || child_die
->tag
== DW_TAG_GNU_call_site
)
13456 /* For each CHILD_DIE, find the corresponding child of
13457 ORIGIN_DIE. If there is more than one layer of
13458 DW_AT_abstract_origin, follow them all; there shouldn't be,
13459 but GCC versions at least through 4.4 generate this (GCC PR
13461 child_origin_die
= child_die
;
13462 child_origin_cu
= cu
;
13465 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
13469 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
13473 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13474 counterpart may exist. */
13475 if (child_origin_die
!= child_die
)
13477 if (child_die
->tag
!= child_origin_die
->tag
13478 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13479 && child_origin_die
->tag
== DW_TAG_subprogram
))
13480 complaint (_("Child DIE %s and its abstract origin %s have "
13482 sect_offset_str (child_die
->sect_off
),
13483 sect_offset_str (child_origin_die
->sect_off
));
13484 if (child_origin_die
->parent
!= origin_die
)
13485 complaint (_("Child DIE %s and its abstract origin %s have "
13486 "different parents"),
13487 sect_offset_str (child_die
->sect_off
),
13488 sect_offset_str (child_origin_die
->sect_off
));
13490 offsets
.push_back (child_origin_die
->sect_off
);
13493 std::sort (offsets
.begin (), offsets
.end ());
13494 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13495 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13496 if (offsetp
[-1] == *offsetp
)
13497 complaint (_("Multiple children of DIE %s refer "
13498 "to DIE %s as their abstract origin"),
13499 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
13501 offsetp
= offsets
.data ();
13502 origin_child_die
= origin_die
->child
;
13503 while (origin_child_die
&& origin_child_die
->tag
)
13505 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13506 while (offsetp
< offsets_end
13507 && *offsetp
< origin_child_die
->sect_off
)
13509 if (offsetp
>= offsets_end
13510 || *offsetp
> origin_child_die
->sect_off
)
13512 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13513 Check whether we're already processing ORIGIN_CHILD_DIE.
13514 This can happen with mutually referenced abstract_origins.
13516 if (!origin_child_die
->in_process
)
13517 process_die (origin_child_die
, origin_cu
);
13519 origin_child_die
= origin_child_die
->sibling
;
13521 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13523 if (cu
!= origin_cu
)
13524 compute_delayed_physnames (origin_cu
);
13528 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13530 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13531 struct gdbarch
*gdbarch
= objfile
->arch ();
13532 struct context_stack
*newobj
;
13535 struct die_info
*child_die
;
13536 struct attribute
*attr
, *call_line
, *call_file
;
13538 CORE_ADDR baseaddr
;
13539 struct block
*block
;
13540 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13541 std::vector
<struct symbol
*> template_args
;
13542 struct template_symbol
*templ_func
= NULL
;
13546 /* If we do not have call site information, we can't show the
13547 caller of this inlined function. That's too confusing, so
13548 only use the scope for local variables. */
13549 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13550 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13551 if (call_line
== NULL
|| call_file
== NULL
)
13553 read_lexical_block_scope (die
, cu
);
13558 baseaddr
= objfile
->text_section_offset ();
13560 name
= dwarf2_name (die
, cu
);
13562 /* Ignore functions with missing or empty names. These are actually
13563 illegal according to the DWARF standard. */
13566 complaint (_("missing name for subprogram DIE at %s"),
13567 sect_offset_str (die
->sect_off
));
13571 /* Ignore functions with missing or invalid low and high pc attributes. */
13572 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13573 <= PC_BOUNDS_INVALID
)
13575 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13576 if (attr
== nullptr || !attr
->as_boolean ())
13577 complaint (_("cannot get low and high bounds "
13578 "for subprogram DIE at %s"),
13579 sect_offset_str (die
->sect_off
));
13583 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13584 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13586 /* If we have any template arguments, then we must allocate a
13587 different sort of symbol. */
13588 for (child_die
= die
->child
; child_die
; child_die
= child_die
->sibling
)
13590 if (child_die
->tag
== DW_TAG_template_type_param
13591 || child_die
->tag
== DW_TAG_template_value_param
)
13593 templ_func
= new (&objfile
->objfile_obstack
) template_symbol
;
13594 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13599 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13600 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13601 (struct symbol
*) templ_func
);
13603 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13604 set_objfile_main_name (objfile
, newobj
->name
->linkage_name (),
13607 /* If there is a location expression for DW_AT_frame_base, record
13609 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13610 if (attr
!= nullptr)
13611 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13613 /* If there is a location for the static link, record it. */
13614 newobj
->static_link
= NULL
;
13615 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13616 if (attr
!= nullptr)
13618 newobj
->static_link
13619 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13620 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
13624 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13626 if (die
->child
!= NULL
)
13628 child_die
= die
->child
;
13629 while (child_die
&& child_die
->tag
)
13631 if (child_die
->tag
== DW_TAG_template_type_param
13632 || child_die
->tag
== DW_TAG_template_value_param
)
13634 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13637 template_args
.push_back (arg
);
13640 process_die (child_die
, cu
);
13641 child_die
= child_die
->sibling
;
13645 inherit_abstract_dies (die
, cu
);
13647 /* If we have a DW_AT_specification, we might need to import using
13648 directives from the context of the specification DIE. See the
13649 comment in determine_prefix. */
13650 if (cu
->language
== language_cplus
13651 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13653 struct dwarf2_cu
*spec_cu
= cu
;
13654 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13658 child_die
= spec_die
->child
;
13659 while (child_die
&& child_die
->tag
)
13661 if (child_die
->tag
== DW_TAG_imported_module
)
13662 process_die (child_die
, spec_cu
);
13663 child_die
= child_die
->sibling
;
13666 /* In some cases, GCC generates specification DIEs that
13667 themselves contain DW_AT_specification attributes. */
13668 spec_die
= die_specification (spec_die
, &spec_cu
);
13672 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13673 /* Make a block for the local symbols within. */
13674 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13675 cstk
.static_link
, lowpc
, highpc
);
13677 /* For C++, set the block's scope. */
13678 if ((cu
->language
== language_cplus
13679 || cu
->language
== language_fortran
13680 || cu
->language
== language_d
13681 || cu
->language
== language_rust
)
13682 && cu
->processing_has_namespace_info
)
13683 block_set_scope (block
, determine_prefix (die
, cu
),
13684 &objfile
->objfile_obstack
);
13686 /* If we have address ranges, record them. */
13687 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13689 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13691 /* Attach template arguments to function. */
13692 if (!template_args
.empty ())
13694 gdb_assert (templ_func
!= NULL
);
13696 templ_func
->n_template_arguments
= template_args
.size ();
13697 templ_func
->template_arguments
13698 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13699 templ_func
->n_template_arguments
);
13700 memcpy (templ_func
->template_arguments
,
13701 template_args
.data (),
13702 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13704 /* Make sure that the symtab is set on the new symbols. Even
13705 though they don't appear in this symtab directly, other parts
13706 of gdb assume that symbols do, and this is reasonably
13708 for (symbol
*sym
: template_args
)
13709 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13712 /* In C++, we can have functions nested inside functions (e.g., when
13713 a function declares a class that has methods). This means that
13714 when we finish processing a function scope, we may need to go
13715 back to building a containing block's symbol lists. */
13716 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13717 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13719 /* If we've finished processing a top-level function, subsequent
13720 symbols go in the file symbol list. */
13721 if (cu
->get_builder ()->outermost_context_p ())
13722 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13725 /* Process all the DIES contained within a lexical block scope. Start
13726 a new scope, process the dies, and then close the scope. */
13729 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13731 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13732 struct gdbarch
*gdbarch
= objfile
->arch ();
13733 CORE_ADDR lowpc
, highpc
;
13734 struct die_info
*child_die
;
13735 CORE_ADDR baseaddr
;
13737 baseaddr
= objfile
->text_section_offset ();
13739 /* Ignore blocks with missing or invalid low and high pc attributes. */
13740 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13741 as multiple lexical blocks? Handling children in a sane way would
13742 be nasty. Might be easier to properly extend generic blocks to
13743 describe ranges. */
13744 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13746 case PC_BOUNDS_NOT_PRESENT
:
13747 /* DW_TAG_lexical_block has no attributes, process its children as if
13748 there was no wrapping by that DW_TAG_lexical_block.
13749 GCC does no longer produces such DWARF since GCC r224161. */
13750 for (child_die
= die
->child
;
13751 child_die
!= NULL
&& child_die
->tag
;
13752 child_die
= child_die
->sibling
)
13754 /* We might already be processing this DIE. This can happen
13755 in an unusual circumstance -- where a subroutine A
13756 appears lexically in another subroutine B, but A actually
13757 inlines B. The recursion is broken here, rather than in
13758 inherit_abstract_dies, because it seems better to simply
13759 drop concrete children here. */
13760 if (!child_die
->in_process
)
13761 process_die (child_die
, cu
);
13764 case PC_BOUNDS_INVALID
:
13767 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13768 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13770 cu
->get_builder ()->push_context (0, lowpc
);
13771 if (die
->child
!= NULL
)
13773 child_die
= die
->child
;
13774 while (child_die
&& child_die
->tag
)
13776 process_die (child_die
, cu
);
13777 child_die
= child_die
->sibling
;
13780 inherit_abstract_dies (die
, cu
);
13781 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13783 if (*cu
->get_builder ()->get_local_symbols () != NULL
13784 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13786 struct block
*block
13787 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13788 cstk
.start_addr
, highpc
);
13790 /* Note that recording ranges after traversing children, as we
13791 do here, means that recording a parent's ranges entails
13792 walking across all its children's ranges as they appear in
13793 the address map, which is quadratic behavior.
13795 It would be nicer to record the parent's ranges before
13796 traversing its children, simply overriding whatever you find
13797 there. But since we don't even decide whether to create a
13798 block until after we've traversed its children, that's hard
13800 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13802 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13803 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13806 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13809 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13811 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13812 struct objfile
*objfile
= per_objfile
->objfile
;
13813 struct gdbarch
*gdbarch
= objfile
->arch ();
13814 CORE_ADDR pc
, baseaddr
;
13815 struct attribute
*attr
;
13816 struct call_site
*call_site
, call_site_local
;
13819 struct die_info
*child_die
;
13821 baseaddr
= objfile
->text_section_offset ();
13823 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13826 /* This was a pre-DWARF-5 GNU extension alias
13827 for DW_AT_call_return_pc. */
13828 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13832 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13833 "DIE %s [in module %s]"),
13834 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13837 pc
= attr
->as_address () + baseaddr
;
13838 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13840 if (cu
->call_site_htab
== NULL
)
13841 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13842 NULL
, &objfile
->objfile_obstack
,
13843 hashtab_obstack_allocate
, NULL
);
13844 call_site_local
.pc
= pc
;
13845 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13848 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13849 "DIE %s [in module %s]"),
13850 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13851 objfile_name (objfile
));
13855 /* Count parameters at the caller. */
13858 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13859 child_die
= child_die
->sibling
)
13861 if (child_die
->tag
!= DW_TAG_call_site_parameter
13862 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13864 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13865 "DW_TAG_call_site child DIE %s [in module %s]"),
13866 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
13867 objfile_name (objfile
));
13875 = ((struct call_site
*)
13876 obstack_alloc (&objfile
->objfile_obstack
,
13877 sizeof (*call_site
)
13878 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
13880 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
13881 call_site
->pc
= pc
;
13883 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
13884 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
13886 struct die_info
*func_die
;
13888 /* Skip also over DW_TAG_inlined_subroutine. */
13889 for (func_die
= die
->parent
;
13890 func_die
&& func_die
->tag
!= DW_TAG_subprogram
13891 && func_die
->tag
!= DW_TAG_subroutine_type
;
13892 func_die
= func_die
->parent
);
13894 /* DW_AT_call_all_calls is a superset
13895 of DW_AT_call_all_tail_calls. */
13897 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
13898 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
13899 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
13900 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
13902 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13903 not complete. But keep CALL_SITE for look ups via call_site_htab,
13904 both the initial caller containing the real return address PC and
13905 the final callee containing the current PC of a chain of tail
13906 calls do not need to have the tail call list complete. But any
13907 function candidate for a virtual tail call frame searched via
13908 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13909 determined unambiguously. */
13913 struct type
*func_type
= NULL
;
13916 func_type
= get_die_type (func_die
, cu
);
13917 if (func_type
!= NULL
)
13919 gdb_assert (func_type
->code () == TYPE_CODE_FUNC
);
13921 /* Enlist this call site to the function. */
13922 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
13923 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
13926 complaint (_("Cannot find function owning DW_TAG_call_site "
13927 "DIE %s [in module %s]"),
13928 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13932 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
13934 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
13936 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
13939 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
13940 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13942 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
13943 if (!attr
|| (attr
->form_is_block () && attr
->as_block ()->size
== 0))
13944 /* Keep NULL DWARF_BLOCK. */;
13945 else if (attr
->form_is_block ())
13947 struct dwarf2_locexpr_baton
*dlbaton
;
13948 struct dwarf_block
*block
= attr
->as_block ();
13950 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
13951 dlbaton
->data
= block
->data
;
13952 dlbaton
->size
= block
->size
;
13953 dlbaton
->per_objfile
= per_objfile
;
13954 dlbaton
->per_cu
= cu
->per_cu
;
13956 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
13958 else if (attr
->form_is_ref ())
13960 struct dwarf2_cu
*target_cu
= cu
;
13961 struct die_info
*target_die
;
13963 target_die
= follow_die_ref (die
, attr
, &target_cu
);
13964 gdb_assert (target_cu
->per_objfile
->objfile
== objfile
);
13965 if (die_is_declaration (target_die
, target_cu
))
13967 const char *target_physname
;
13969 /* Prefer the mangled name; otherwise compute the demangled one. */
13970 target_physname
= dw2_linkage_name (target_die
, target_cu
);
13971 if (target_physname
== NULL
)
13972 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
13973 if (target_physname
== NULL
)
13974 complaint (_("DW_AT_call_target target DIE has invalid "
13975 "physname, for referencing DIE %s [in module %s]"),
13976 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13978 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
13984 /* DW_AT_entry_pc should be preferred. */
13985 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
13986 <= PC_BOUNDS_INVALID
)
13987 complaint (_("DW_AT_call_target target DIE has invalid "
13988 "low pc, for referencing DIE %s [in module %s]"),
13989 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13992 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13993 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
13998 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
13999 "block nor reference, for DIE %s [in module %s]"),
14000 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14002 call_site
->per_cu
= cu
->per_cu
;
14003 call_site
->per_objfile
= per_objfile
;
14005 for (child_die
= die
->child
;
14006 child_die
&& child_die
->tag
;
14007 child_die
= child_die
->sibling
)
14009 struct call_site_parameter
*parameter
;
14010 struct attribute
*loc
, *origin
;
14012 if (child_die
->tag
!= DW_TAG_call_site_parameter
14013 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14015 /* Already printed the complaint above. */
14019 gdb_assert (call_site
->parameter_count
< nparams
);
14020 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
14022 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14023 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14024 register is contained in DW_AT_call_value. */
14026 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
14027 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
14028 if (origin
== NULL
)
14030 /* This was a pre-DWARF-5 GNU extension alias
14031 for DW_AT_call_parameter. */
14032 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
14034 if (loc
== NULL
&& origin
!= NULL
&& origin
->form_is_ref ())
14036 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
14038 sect_offset sect_off
= origin
->get_ref_die_offset ();
14039 if (!cu
->header
.offset_in_cu_p (sect_off
))
14041 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14042 binding can be done only inside one CU. Such referenced DIE
14043 therefore cannot be even moved to DW_TAG_partial_unit. */
14044 complaint (_("DW_AT_call_parameter offset is not in CU for "
14045 "DW_TAG_call_site child DIE %s [in module %s]"),
14046 sect_offset_str (child_die
->sect_off
),
14047 objfile_name (objfile
));
14050 parameter
->u
.param_cu_off
14051 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
14053 else if (loc
== NULL
|| origin
!= NULL
|| !loc
->form_is_block ())
14055 complaint (_("No DW_FORM_block* DW_AT_location for "
14056 "DW_TAG_call_site child DIE %s [in module %s]"),
14057 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
14062 struct dwarf_block
*block
= loc
->as_block ();
14064 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
14065 (block
->data
, &block
->data
[block
->size
]);
14066 if (parameter
->u
.dwarf_reg
!= -1)
14067 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
14068 else if (dwarf_block_to_sp_offset (gdbarch
, block
->data
,
14069 &block
->data
[block
->size
],
14070 ¶meter
->u
.fb_offset
))
14071 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
14074 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14075 "for DW_FORM_block* DW_AT_location is supported for "
14076 "DW_TAG_call_site child DIE %s "
14078 sect_offset_str (child_die
->sect_off
),
14079 objfile_name (objfile
));
14084 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
14086 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
14087 if (attr
== NULL
|| !attr
->form_is_block ())
14089 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14090 "DW_TAG_call_site child DIE %s [in module %s]"),
14091 sect_offset_str (child_die
->sect_off
),
14092 objfile_name (objfile
));
14096 struct dwarf_block
*block
= attr
->as_block ();
14097 parameter
->value
= block
->data
;
14098 parameter
->value_size
= block
->size
;
14100 /* Parameters are not pre-cleared by memset above. */
14101 parameter
->data_value
= NULL
;
14102 parameter
->data_value_size
= 0;
14103 call_site
->parameter_count
++;
14105 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
14107 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
14108 if (attr
!= nullptr)
14110 if (!attr
->form_is_block ())
14111 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14112 "DW_TAG_call_site child DIE %s [in module %s]"),
14113 sect_offset_str (child_die
->sect_off
),
14114 objfile_name (objfile
));
14117 block
= attr
->as_block ();
14118 parameter
->data_value
= block
->data
;
14119 parameter
->data_value_size
= block
->size
;
14125 /* Helper function for read_variable. If DIE represents a virtual
14126 table, then return the type of the concrete object that is
14127 associated with the virtual table. Otherwise, return NULL. */
14129 static struct type
*
14130 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14132 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
14136 /* Find the type DIE. */
14137 struct die_info
*type_die
= NULL
;
14138 struct dwarf2_cu
*type_cu
= cu
;
14140 if (attr
->form_is_ref ())
14141 type_die
= follow_die_ref (die
, attr
, &type_cu
);
14142 if (type_die
== NULL
)
14145 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
14147 return die_containing_type (type_die
, type_cu
);
14150 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14153 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
14155 struct rust_vtable_symbol
*storage
= NULL
;
14157 if (cu
->language
== language_rust
)
14159 struct type
*containing_type
= rust_containing_type (die
, cu
);
14161 if (containing_type
!= NULL
)
14163 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14165 storage
= new (&objfile
->objfile_obstack
) rust_vtable_symbol
;
14166 storage
->concrete_type
= containing_type
;
14167 storage
->subclass
= SYMBOL_RUST_VTABLE
;
14171 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
14172 struct attribute
*abstract_origin
14173 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14174 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
14175 if (res
== NULL
&& loc
&& abstract_origin
)
14177 /* We have a variable without a name, but with a location and an abstract
14178 origin. This may be a concrete instance of an abstract variable
14179 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14181 struct dwarf2_cu
*origin_cu
= cu
;
14182 struct die_info
*origin_die
14183 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
14184 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14185 per_objfile
->per_bfd
->abstract_to_concrete
14186 [origin_die
->sect_off
].push_back (die
->sect_off
);
14190 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14191 reading .debug_rnglists.
14192 Callback's type should be:
14193 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14194 Return true if the attributes are present and valid, otherwise,
14197 template <typename Callback
>
14199 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
14200 dwarf_tag tag
, Callback
&&callback
)
14202 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14203 struct objfile
*objfile
= per_objfile
->objfile
;
14204 bfd
*obfd
= objfile
->obfd
;
14205 /* Base address selection entry. */
14206 gdb::optional
<CORE_ADDR
> base
;
14207 const gdb_byte
*buffer
;
14208 CORE_ADDR baseaddr
;
14209 bool overflow
= false;
14210 ULONGEST addr_index
;
14211 struct dwarf2_section_info
*rnglists_section
;
14213 base
= cu
->base_address
;
14214 rnglists_section
= cu_debug_rnglists_section (cu
, tag
);
14215 rnglists_section
->read (objfile
);
14217 if (offset
>= rnglists_section
->size
)
14219 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14223 buffer
= rnglists_section
->buffer
+ offset
;
14225 baseaddr
= objfile
->text_section_offset ();
14229 /* Initialize it due to a false compiler warning. */
14230 CORE_ADDR range_beginning
= 0, range_end
= 0;
14231 const gdb_byte
*buf_end
= (rnglists_section
->buffer
14232 + rnglists_section
->size
);
14233 unsigned int bytes_read
;
14235 if (buffer
== buf_end
)
14240 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
14243 case DW_RLE_end_of_list
:
14245 case DW_RLE_base_address
:
14246 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14251 base
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14252 buffer
+= bytes_read
;
14254 case DW_RLE_base_addressx
:
14255 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14256 buffer
+= bytes_read
;
14257 base
= read_addr_index (cu
, addr_index
);
14259 case DW_RLE_start_length
:
14260 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14265 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14267 buffer
+= bytes_read
;
14268 range_end
= (range_beginning
14269 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14270 buffer
+= bytes_read
;
14271 if (buffer
> buf_end
)
14277 case DW_RLE_startx_length
:
14278 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14279 buffer
+= bytes_read
;
14280 range_beginning
= read_addr_index (cu
, addr_index
);
14281 if (buffer
> buf_end
)
14286 range_end
= (range_beginning
14287 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14288 buffer
+= bytes_read
;
14290 case DW_RLE_offset_pair
:
14291 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14292 buffer
+= bytes_read
;
14293 if (buffer
> buf_end
)
14298 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14299 buffer
+= bytes_read
;
14300 if (buffer
> buf_end
)
14306 case DW_RLE_start_end
:
14307 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
14312 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14314 buffer
+= bytes_read
;
14315 range_end
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14316 buffer
+= bytes_read
;
14318 case DW_RLE_startx_endx
:
14319 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14320 buffer
+= bytes_read
;
14321 range_beginning
= read_addr_index (cu
, addr_index
);
14322 if (buffer
> buf_end
)
14327 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14328 buffer
+= bytes_read
;
14329 range_end
= read_addr_index (cu
, addr_index
);
14332 complaint (_("Invalid .debug_rnglists data (no base address)"));
14335 if (rlet
== DW_RLE_end_of_list
|| overflow
)
14337 if (rlet
== DW_RLE_base_address
)
14340 if (range_beginning
> range_end
)
14342 /* Inverted range entries are invalid. */
14343 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14347 /* Empty range entries have no effect. */
14348 if (range_beginning
== range_end
)
14351 /* Only DW_RLE_offset_pair needs the base address added. */
14352 if (rlet
== DW_RLE_offset_pair
)
14354 if (!base
.has_value ())
14356 /* We have no valid base address for the DW_RLE_offset_pair. */
14357 complaint (_("Invalid .debug_rnglists data (no base address for "
14358 "DW_RLE_offset_pair)"));
14362 range_beginning
+= *base
;
14363 range_end
+= *base
;
14366 /* A not-uncommon case of bad debug info.
14367 Don't pollute the addrmap with bad data. */
14368 if (range_beginning
+ baseaddr
== 0
14369 && !per_objfile
->per_bfd
->has_section_at_zero
)
14371 complaint (_(".debug_rnglists entry has start address of zero"
14372 " [in module %s]"), objfile_name (objfile
));
14376 callback (range_beginning
, range_end
);
14381 complaint (_("Offset %d is not terminated "
14382 "for DW_AT_ranges attribute"),
14390 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14391 Callback's type should be:
14392 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14393 Return 1 if the attributes are present and valid, otherwise, return 0. */
14395 template <typename Callback
>
14397 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
, dwarf_tag tag
,
14398 Callback
&&callback
)
14400 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14401 struct objfile
*objfile
= per_objfile
->objfile
;
14402 struct comp_unit_head
*cu_header
= &cu
->header
;
14403 bfd
*obfd
= objfile
->obfd
;
14404 unsigned int addr_size
= cu_header
->addr_size
;
14405 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
14406 /* Base address selection entry. */
14407 gdb::optional
<CORE_ADDR
> base
;
14408 unsigned int dummy
;
14409 const gdb_byte
*buffer
;
14410 CORE_ADDR baseaddr
;
14412 if (cu_header
->version
>= 5)
14413 return dwarf2_rnglists_process (offset
, cu
, tag
, callback
);
14415 base
= cu
->base_address
;
14417 per_objfile
->per_bfd
->ranges
.read (objfile
);
14418 if (offset
>= per_objfile
->per_bfd
->ranges
.size
)
14420 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14424 buffer
= per_objfile
->per_bfd
->ranges
.buffer
+ offset
;
14426 baseaddr
= objfile
->text_section_offset ();
14430 CORE_ADDR range_beginning
, range_end
;
14432 range_beginning
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14433 buffer
+= addr_size
;
14434 range_end
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14435 buffer
+= addr_size
;
14436 offset
+= 2 * addr_size
;
14438 /* An end of list marker is a pair of zero addresses. */
14439 if (range_beginning
== 0 && range_end
== 0)
14440 /* Found the end of list entry. */
14443 /* Each base address selection entry is a pair of 2 values.
14444 The first is the largest possible address, the second is
14445 the base address. Check for a base address here. */
14446 if ((range_beginning
& mask
) == mask
)
14448 /* If we found the largest possible address, then we already
14449 have the base address in range_end. */
14454 if (!base
.has_value ())
14456 /* We have no valid base address for the ranges
14458 complaint (_("Invalid .debug_ranges data (no base address)"));
14462 if (range_beginning
> range_end
)
14464 /* Inverted range entries are invalid. */
14465 complaint (_("Invalid .debug_ranges data (inverted range)"));
14469 /* Empty range entries have no effect. */
14470 if (range_beginning
== range_end
)
14473 range_beginning
+= *base
;
14474 range_end
+= *base
;
14476 /* A not-uncommon case of bad debug info.
14477 Don't pollute the addrmap with bad data. */
14478 if (range_beginning
+ baseaddr
== 0
14479 && !per_objfile
->per_bfd
->has_section_at_zero
)
14481 complaint (_(".debug_ranges entry has start address of zero"
14482 " [in module %s]"), objfile_name (objfile
));
14486 callback (range_beginning
, range_end
);
14492 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14493 Return 1 if the attributes are present and valid, otherwise, return 0.
14494 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14497 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14498 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14499 dwarf2_psymtab
*ranges_pst
, dwarf_tag tag
)
14501 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14502 struct gdbarch
*gdbarch
= objfile
->arch ();
14503 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
14506 CORE_ADDR high
= 0;
14509 retval
= dwarf2_ranges_process (offset
, cu
, tag
,
14510 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14512 if (ranges_pst
!= NULL
)
14517 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14518 range_beginning
+ baseaddr
)
14520 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14521 range_end
+ baseaddr
)
14523 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
14524 lowpc
, highpc
- 1, ranges_pst
);
14527 /* FIXME: This is recording everything as a low-high
14528 segment of consecutive addresses. We should have a
14529 data structure for discontiguous block ranges
14533 low
= range_beginning
;
14539 if (range_beginning
< low
)
14540 low
= range_beginning
;
14541 if (range_end
> high
)
14549 /* If the first entry is an end-of-list marker, the range
14550 describes an empty scope, i.e. no instructions. */
14556 *high_return
= high
;
14560 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14561 definition for the return value. *LOWPC and *HIGHPC are set iff
14562 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14564 static enum pc_bounds_kind
14565 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14566 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14567 dwarf2_psymtab
*pst
)
14569 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14570 struct attribute
*attr
;
14571 struct attribute
*attr_high
;
14573 CORE_ADDR high
= 0;
14574 enum pc_bounds_kind ret
;
14576 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14579 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14580 if (attr
!= nullptr)
14582 low
= attr
->as_address ();
14583 high
= attr_high
->as_address ();
14584 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14588 /* Found high w/o low attribute. */
14589 return PC_BOUNDS_INVALID
;
14591 /* Found consecutive range of addresses. */
14592 ret
= PC_BOUNDS_HIGH_LOW
;
14596 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14597 if (attr
!= nullptr && attr
->form_is_unsigned ())
14599 /* DW_AT_rnglists_base does not apply to DIEs from the DWO skeleton.
14600 We take advantage of the fact that DW_AT_ranges does not appear
14601 in DW_TAG_compile_unit of DWO files.
14603 Attributes of the form DW_FORM_rnglistx have already had their
14604 value changed by read_rnglist_index and already include
14605 DW_AT_rnglists_base, so don't need to add the ranges base,
14607 int need_ranges_base
= (die
->tag
!= DW_TAG_compile_unit
14608 && attr
->form
!= DW_FORM_rnglistx
);
14609 unsigned int ranges_offset
= (attr
->as_unsigned ()
14610 + (need_ranges_base
14614 /* Value of the DW_AT_ranges attribute is the offset in the
14615 .debug_ranges section. */
14616 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
,
14618 return PC_BOUNDS_INVALID
;
14619 /* Found discontinuous range of addresses. */
14620 ret
= PC_BOUNDS_RANGES
;
14623 return PC_BOUNDS_NOT_PRESENT
;
14626 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14628 return PC_BOUNDS_INVALID
;
14630 /* When using the GNU linker, .gnu.linkonce. sections are used to
14631 eliminate duplicate copies of functions and vtables and such.
14632 The linker will arbitrarily choose one and discard the others.
14633 The AT_*_pc values for such functions refer to local labels in
14634 these sections. If the section from that file was discarded, the
14635 labels are not in the output, so the relocs get a value of 0.
14636 If this is a discarded function, mark the pc bounds as invalid,
14637 so that GDB will ignore it. */
14638 if (low
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
14639 return PC_BOUNDS_INVALID
;
14647 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14648 its low and high PC addresses. Do nothing if these addresses could not
14649 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14650 and HIGHPC to the high address if greater than HIGHPC. */
14653 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14654 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14655 struct dwarf2_cu
*cu
)
14657 CORE_ADDR low
, high
;
14658 struct die_info
*child
= die
->child
;
14660 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14662 *lowpc
= std::min (*lowpc
, low
);
14663 *highpc
= std::max (*highpc
, high
);
14666 /* If the language does not allow nested subprograms (either inside
14667 subprograms or lexical blocks), we're done. */
14668 if (cu
->language
!= language_ada
)
14671 /* Check all the children of the given DIE. If it contains nested
14672 subprograms, then check their pc bounds. Likewise, we need to
14673 check lexical blocks as well, as they may also contain subprogram
14675 while (child
&& child
->tag
)
14677 if (child
->tag
== DW_TAG_subprogram
14678 || child
->tag
== DW_TAG_lexical_block
)
14679 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14680 child
= child
->sibling
;
14684 /* Get the low and high pc's represented by the scope DIE, and store
14685 them in *LOWPC and *HIGHPC. If the correct values can't be
14686 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14689 get_scope_pc_bounds (struct die_info
*die
,
14690 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14691 struct dwarf2_cu
*cu
)
14693 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14694 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14695 CORE_ADDR current_low
, current_high
;
14697 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14698 >= PC_BOUNDS_RANGES
)
14700 best_low
= current_low
;
14701 best_high
= current_high
;
14705 struct die_info
*child
= die
->child
;
14707 while (child
&& child
->tag
)
14709 switch (child
->tag
) {
14710 case DW_TAG_subprogram
:
14711 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14713 case DW_TAG_namespace
:
14714 case DW_TAG_module
:
14715 /* FIXME: carlton/2004-01-16: Should we do this for
14716 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14717 that current GCC's always emit the DIEs corresponding
14718 to definitions of methods of classes as children of a
14719 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14720 the DIEs giving the declarations, which could be
14721 anywhere). But I don't see any reason why the
14722 standards says that they have to be there. */
14723 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14725 if (current_low
!= ((CORE_ADDR
) -1))
14727 best_low
= std::min (best_low
, current_low
);
14728 best_high
= std::max (best_high
, current_high
);
14736 child
= child
->sibling
;
14741 *highpc
= best_high
;
14744 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14748 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14749 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14751 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14752 struct gdbarch
*gdbarch
= objfile
->arch ();
14753 struct attribute
*attr
;
14754 struct attribute
*attr_high
;
14756 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14759 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14760 if (attr
!= nullptr)
14762 CORE_ADDR low
= attr
->as_address ();
14763 CORE_ADDR high
= attr_high
->as_address ();
14765 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14768 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14769 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14770 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14774 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14775 if (attr
!= nullptr && attr
->form_is_unsigned ())
14777 /* DW_AT_rnglists_base does not apply to DIEs from the DWO skeleton.
14778 We take advantage of the fact that DW_AT_ranges does not appear
14779 in DW_TAG_compile_unit of DWO files.
14781 Attributes of the form DW_FORM_rnglistx have already had their
14782 value changed by read_rnglist_index and already include
14783 DW_AT_rnglists_base, so don't need to add the ranges base,
14785 int need_ranges_base
= (die
->tag
!= DW_TAG_compile_unit
14786 && attr
->form
!= DW_FORM_rnglistx
);
14788 /* The value of the DW_AT_ranges attribute is the offset of the
14789 address range list in the .debug_ranges section. */
14790 unsigned long offset
= (attr
->as_unsigned ()
14791 + (need_ranges_base
? cu
->ranges_base
: 0));
14793 std::vector
<blockrange
> blockvec
;
14794 dwarf2_ranges_process (offset
, cu
, die
->tag
,
14795 [&] (CORE_ADDR start
, CORE_ADDR end
)
14799 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14800 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14801 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14802 blockvec
.emplace_back (start
, end
);
14805 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14809 /* Check whether the producer field indicates either of GCC < 4.6, or the
14810 Intel C/C++ compiler, and cache the result in CU. */
14813 check_producer (struct dwarf2_cu
*cu
)
14817 if (cu
->producer
== NULL
)
14819 /* For unknown compilers expect their behavior is DWARF version
14822 GCC started to support .debug_types sections by -gdwarf-4 since
14823 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14824 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14825 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14826 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14828 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14830 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14831 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14833 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14835 cu
->producer_is_icc
= true;
14836 cu
->producer_is_icc_lt_14
= major
< 14;
14838 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14839 cu
->producer_is_codewarrior
= true;
14842 /* For other non-GCC compilers, expect their behavior is DWARF version
14846 cu
->checked_producer
= true;
14849 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14850 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14851 during 4.6.0 experimental. */
14854 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14856 if (!cu
->checked_producer
)
14857 check_producer (cu
);
14859 return cu
->producer_is_gxx_lt_4_6
;
14863 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14864 with incorrect is_stmt attributes. */
14867 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14869 if (!cu
->checked_producer
)
14870 check_producer (cu
);
14872 return cu
->producer_is_codewarrior
;
14875 /* Return the accessibility of DIE, as given by DW_AT_accessibility.
14876 If that attribute is not available, return the appropriate
14879 static enum dwarf_access_attribute
14880 dwarf2_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14882 attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14883 if (attr
!= nullptr)
14885 LONGEST value
= attr
->constant_value (-1);
14886 if (value
== DW_ACCESS_public
14887 || value
== DW_ACCESS_protected
14888 || value
== DW_ACCESS_private
)
14889 return (dwarf_access_attribute
) value
;
14890 complaint (_("Unhandled DW_AT_accessibility value (%s)"),
14894 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14896 /* The default DWARF 2 accessibility for members is public, the default
14897 accessibility for inheritance is private. */
14899 if (die
->tag
!= DW_TAG_inheritance
)
14900 return DW_ACCESS_public
;
14902 return DW_ACCESS_private
;
14906 /* DWARF 3+ defines the default accessibility a different way. The same
14907 rules apply now for DW_TAG_inheritance as for the members and it only
14908 depends on the container kind. */
14910 if (die
->parent
->tag
== DW_TAG_class_type
)
14911 return DW_ACCESS_private
;
14913 return DW_ACCESS_public
;
14917 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14918 offset. If the attribute was not found return 0, otherwise return
14919 1. If it was found but could not properly be handled, set *OFFSET
14923 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14926 struct attribute
*attr
;
14928 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14933 /* Note that we do not check for a section offset first here.
14934 This is because DW_AT_data_member_location is new in DWARF 4,
14935 so if we see it, we can assume that a constant form is really
14936 a constant and not a section offset. */
14937 if (attr
->form_is_constant ())
14938 *offset
= attr
->constant_value (0);
14939 else if (attr
->form_is_section_offset ())
14940 dwarf2_complex_location_expr_complaint ();
14941 else if (attr
->form_is_block ())
14942 *offset
= decode_locdesc (attr
->as_block (), cu
);
14944 dwarf2_complex_location_expr_complaint ();
14952 /* Look for DW_AT_data_member_location and store the results in FIELD. */
14955 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14956 struct field
*field
)
14958 struct attribute
*attr
;
14960 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14963 if (attr
->form_is_constant ())
14965 LONGEST offset
= attr
->constant_value (0);
14966 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14968 else if (attr
->form_is_section_offset ())
14969 dwarf2_complex_location_expr_complaint ();
14970 else if (attr
->form_is_block ())
14973 CORE_ADDR offset
= decode_locdesc (attr
->as_block (), cu
, &handled
);
14975 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14978 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14979 struct objfile
*objfile
= per_objfile
->objfile
;
14980 struct dwarf2_locexpr_baton
*dlbaton
14981 = XOBNEW (&objfile
->objfile_obstack
,
14982 struct dwarf2_locexpr_baton
);
14983 dlbaton
->data
= attr
->as_block ()->data
;
14984 dlbaton
->size
= attr
->as_block ()->size
;
14985 /* When using this baton, we want to compute the address
14986 of the field, not the value. This is why
14987 is_reference is set to false here. */
14988 dlbaton
->is_reference
= false;
14989 dlbaton
->per_objfile
= per_objfile
;
14990 dlbaton
->per_cu
= cu
->per_cu
;
14992 SET_FIELD_DWARF_BLOCK (*field
, dlbaton
);
14996 dwarf2_complex_location_expr_complaint ();
15000 /* Add an aggregate field to the field list. */
15003 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
15004 struct dwarf2_cu
*cu
)
15006 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15007 struct gdbarch
*gdbarch
= objfile
->arch ();
15008 struct nextfield
*new_field
;
15009 struct attribute
*attr
;
15011 const char *fieldname
= "";
15013 if (die
->tag
== DW_TAG_inheritance
)
15015 fip
->baseclasses
.emplace_back ();
15016 new_field
= &fip
->baseclasses
.back ();
15020 fip
->fields
.emplace_back ();
15021 new_field
= &fip
->fields
.back ();
15024 new_field
->offset
= die
->sect_off
;
15026 new_field
->accessibility
= dwarf2_access_attribute (die
, cu
);
15027 if (new_field
->accessibility
!= DW_ACCESS_public
)
15028 fip
->non_public_fields
= true;
15030 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15031 if (attr
!= nullptr)
15032 new_field
->virtuality
= attr
->as_virtuality ();
15034 new_field
->virtuality
= DW_VIRTUALITY_none
;
15036 fp
= &new_field
->field
;
15038 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
15040 /* Data member other than a C++ static data member. */
15042 /* Get type of field. */
15043 fp
->set_type (die_type (die
, cu
));
15045 SET_FIELD_BITPOS (*fp
, 0);
15047 /* Get bit size of field (zero if none). */
15048 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
15049 if (attr
!= nullptr)
15051 FIELD_BITSIZE (*fp
) = attr
->constant_value (0);
15055 FIELD_BITSIZE (*fp
) = 0;
15058 /* Get bit offset of field. */
15059 handle_data_member_location (die
, cu
, fp
);
15060 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
15061 if (attr
!= nullptr && attr
->form_is_constant ())
15063 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
15065 /* For big endian bits, the DW_AT_bit_offset gives the
15066 additional bit offset from the MSB of the containing
15067 anonymous object to the MSB of the field. We don't
15068 have to do anything special since we don't need to
15069 know the size of the anonymous object. */
15070 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15071 + attr
->constant_value (0)));
15075 /* For little endian bits, compute the bit offset to the
15076 MSB of the anonymous object, subtract off the number of
15077 bits from the MSB of the field to the MSB of the
15078 object, and then subtract off the number of bits of
15079 the field itself. The result is the bit offset of
15080 the LSB of the field. */
15081 int anonymous_size
;
15082 int bit_offset
= attr
->constant_value (0);
15084 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15085 if (attr
!= nullptr && attr
->form_is_constant ())
15087 /* The size of the anonymous object containing
15088 the bit field is explicit, so use the
15089 indicated size (in bytes). */
15090 anonymous_size
= attr
->constant_value (0);
15094 /* The size of the anonymous object containing
15095 the bit field must be inferred from the type
15096 attribute of the data member containing the
15098 anonymous_size
= TYPE_LENGTH (fp
->type ());
15100 SET_FIELD_BITPOS (*fp
,
15101 (FIELD_BITPOS (*fp
)
15102 + anonymous_size
* bits_per_byte
15103 - bit_offset
- FIELD_BITSIZE (*fp
)));
15106 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
15108 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15109 + attr
->constant_value (0)));
15111 /* Get name of field. */
15112 fieldname
= dwarf2_name (die
, cu
);
15113 if (fieldname
== NULL
)
15116 /* The name is already allocated along with this objfile, so we don't
15117 need to duplicate it for the type. */
15118 fp
->name
= fieldname
;
15120 /* Change accessibility for artificial fields (e.g. virtual table
15121 pointer or virtual base class pointer) to private. */
15122 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
15124 FIELD_ARTIFICIAL (*fp
) = 1;
15125 new_field
->accessibility
= DW_ACCESS_private
;
15126 fip
->non_public_fields
= true;
15129 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
15131 /* C++ static member. */
15133 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15134 is a declaration, but all versions of G++ as of this writing
15135 (so through at least 3.2.1) incorrectly generate
15136 DW_TAG_variable tags. */
15138 const char *physname
;
15140 /* Get name of field. */
15141 fieldname
= dwarf2_name (die
, cu
);
15142 if (fieldname
== NULL
)
15145 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15147 /* Only create a symbol if this is an external value.
15148 new_symbol checks this and puts the value in the global symbol
15149 table, which we want. If it is not external, new_symbol
15150 will try to put the value in cu->list_in_scope which is wrong. */
15151 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
15153 /* A static const member, not much different than an enum as far as
15154 we're concerned, except that we can support more types. */
15155 new_symbol (die
, NULL
, cu
);
15158 /* Get physical name. */
15159 physname
= dwarf2_physname (fieldname
, die
, cu
);
15161 /* The name is already allocated along with this objfile, so we don't
15162 need to duplicate it for the type. */
15163 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
15164 fp
->set_type (die_type (die
, cu
));
15165 FIELD_NAME (*fp
) = fieldname
;
15167 else if (die
->tag
== DW_TAG_inheritance
)
15169 /* C++ base class field. */
15170 handle_data_member_location (die
, cu
, fp
);
15171 FIELD_BITSIZE (*fp
) = 0;
15172 fp
->set_type (die_type (die
, cu
));
15173 FIELD_NAME (*fp
) = fp
->type ()->name ();
15176 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15179 /* Can the type given by DIE define another type? */
15182 type_can_define_types (const struct die_info
*die
)
15186 case DW_TAG_typedef
:
15187 case DW_TAG_class_type
:
15188 case DW_TAG_structure_type
:
15189 case DW_TAG_union_type
:
15190 case DW_TAG_enumeration_type
:
15198 /* Add a type definition defined in the scope of the FIP's class. */
15201 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
15202 struct dwarf2_cu
*cu
)
15204 struct decl_field fp
;
15205 memset (&fp
, 0, sizeof (fp
));
15207 gdb_assert (type_can_define_types (die
));
15209 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15210 fp
.name
= dwarf2_name (die
, cu
);
15211 fp
.type
= read_type_die (die
, cu
);
15213 /* Save accessibility. */
15214 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15215 switch (accessibility
)
15217 case DW_ACCESS_public
:
15218 /* The assumed value if neither private nor protected. */
15220 case DW_ACCESS_private
:
15223 case DW_ACCESS_protected
:
15224 fp
.is_protected
= 1;
15228 if (die
->tag
== DW_TAG_typedef
)
15229 fip
->typedef_field_list
.push_back (fp
);
15231 fip
->nested_types_list
.push_back (fp
);
15234 /* A convenience typedef that's used when finding the discriminant
15235 field for a variant part. */
15236 typedef std::unordered_map
<sect_offset
, int, gdb::hash_enum
<sect_offset
>>
15239 /* Compute the discriminant range for a given variant. OBSTACK is
15240 where the results will be stored. VARIANT is the variant to
15241 process. IS_UNSIGNED indicates whether the discriminant is signed
15244 static const gdb::array_view
<discriminant_range
>
15245 convert_variant_range (struct obstack
*obstack
, const variant_field
&variant
,
15248 std::vector
<discriminant_range
> ranges
;
15250 if (variant
.default_branch
)
15253 if (variant
.discr_list_data
== nullptr)
15255 discriminant_range r
15256 = {variant
.discriminant_value
, variant
.discriminant_value
};
15257 ranges
.push_back (r
);
15261 gdb::array_view
<const gdb_byte
> data (variant
.discr_list_data
->data
,
15262 variant
.discr_list_data
->size
);
15263 while (!data
.empty ())
15265 if (data
[0] != DW_DSC_range
&& data
[0] != DW_DSC_label
)
15267 complaint (_("invalid discriminant marker: %d"), data
[0]);
15270 bool is_range
= data
[0] == DW_DSC_range
;
15271 data
= data
.slice (1);
15273 ULONGEST low
, high
;
15274 unsigned int bytes_read
;
15278 complaint (_("DW_AT_discr_list missing low value"));
15282 low
= read_unsigned_leb128 (nullptr, data
.data (), &bytes_read
);
15284 low
= (ULONGEST
) read_signed_leb128 (nullptr, data
.data (),
15286 data
= data
.slice (bytes_read
);
15292 complaint (_("DW_AT_discr_list missing high value"));
15296 high
= read_unsigned_leb128 (nullptr, data
.data (),
15299 high
= (LONGEST
) read_signed_leb128 (nullptr, data
.data (),
15301 data
= data
.slice (bytes_read
);
15306 ranges
.push_back ({ low
, high
});
15310 discriminant_range
*result
= XOBNEWVEC (obstack
, discriminant_range
,
15312 std::copy (ranges
.begin (), ranges
.end (), result
);
15313 return gdb::array_view
<discriminant_range
> (result
, ranges
.size ());
15316 static const gdb::array_view
<variant_part
> create_variant_parts
15317 (struct obstack
*obstack
,
15318 const offset_map_type
&offset_map
,
15319 struct field_info
*fi
,
15320 const std::vector
<variant_part_builder
> &variant_parts
);
15322 /* Fill in a "struct variant" for a given variant field. RESULT is
15323 the variant to fill in. OBSTACK is where any needed allocations
15324 will be done. OFFSET_MAP holds the mapping from section offsets to
15325 fields for the type. FI describes the fields of the type we're
15326 processing. FIELD is the variant field we're converting. */
15329 create_one_variant (variant
&result
, struct obstack
*obstack
,
15330 const offset_map_type
&offset_map
,
15331 struct field_info
*fi
, const variant_field
&field
)
15333 result
.discriminants
= convert_variant_range (obstack
, field
, false);
15334 result
.first_field
= field
.first_field
+ fi
->baseclasses
.size ();
15335 result
.last_field
= field
.last_field
+ fi
->baseclasses
.size ();
15336 result
.parts
= create_variant_parts (obstack
, offset_map
, fi
,
15337 field
.variant_parts
);
15340 /* Fill in a "struct variant_part" for a given variant part. RESULT
15341 is the variant part to fill in. OBSTACK is where any needed
15342 allocations will be done. OFFSET_MAP holds the mapping from
15343 section offsets to fields for the type. FI describes the fields of
15344 the type we're processing. BUILDER is the variant part to be
15348 create_one_variant_part (variant_part
&result
,
15349 struct obstack
*obstack
,
15350 const offset_map_type
&offset_map
,
15351 struct field_info
*fi
,
15352 const variant_part_builder
&builder
)
15354 auto iter
= offset_map
.find (builder
.discriminant_offset
);
15355 if (iter
== offset_map
.end ())
15357 result
.discriminant_index
= -1;
15358 /* Doesn't matter. */
15359 result
.is_unsigned
= false;
15363 result
.discriminant_index
= iter
->second
;
15365 = fi
->fields
[result
.discriminant_index
].field
.type ()->is_unsigned ();
15368 size_t n
= builder
.variants
.size ();
15369 variant
*output
= new (obstack
) variant
[n
];
15370 for (size_t i
= 0; i
< n
; ++i
)
15371 create_one_variant (output
[i
], obstack
, offset_map
, fi
,
15372 builder
.variants
[i
]);
15374 result
.variants
= gdb::array_view
<variant
> (output
, n
);
15377 /* Create a vector of variant parts that can be attached to a type.
15378 OBSTACK is where any needed allocations will be done. OFFSET_MAP
15379 holds the mapping from section offsets to fields for the type. FI
15380 describes the fields of the type we're processing. VARIANT_PARTS
15381 is the vector to convert. */
15383 static const gdb::array_view
<variant_part
>
15384 create_variant_parts (struct obstack
*obstack
,
15385 const offset_map_type
&offset_map
,
15386 struct field_info
*fi
,
15387 const std::vector
<variant_part_builder
> &variant_parts
)
15389 if (variant_parts
.empty ())
15392 size_t n
= variant_parts
.size ();
15393 variant_part
*result
= new (obstack
) variant_part
[n
];
15394 for (size_t i
= 0; i
< n
; ++i
)
15395 create_one_variant_part (result
[i
], obstack
, offset_map
, fi
,
15398 return gdb::array_view
<variant_part
> (result
, n
);
15401 /* Compute the variant part vector for FIP, attaching it to TYPE when
15405 add_variant_property (struct field_info
*fip
, struct type
*type
,
15406 struct dwarf2_cu
*cu
)
15408 /* Map section offsets of fields to their field index. Note the
15409 field index here does not take the number of baseclasses into
15411 offset_map_type offset_map
;
15412 for (int i
= 0; i
< fip
->fields
.size (); ++i
)
15413 offset_map
[fip
->fields
[i
].offset
] = i
;
15415 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15416 gdb::array_view
<variant_part
> parts
15417 = create_variant_parts (&objfile
->objfile_obstack
, offset_map
, fip
,
15418 fip
->variant_parts
);
15420 struct dynamic_prop prop
;
15421 prop
.set_variant_parts ((gdb::array_view
<variant_part
> *)
15422 obstack_copy (&objfile
->objfile_obstack
, &parts
,
15425 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
15428 /* Create the vector of fields, and attach it to the type. */
15431 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
15432 struct dwarf2_cu
*cu
)
15434 int nfields
= fip
->nfields ();
15436 /* Record the field count, allocate space for the array of fields,
15437 and create blank accessibility bitfields if necessary. */
15438 type
->set_num_fields (nfields
);
15440 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
));
15442 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
15444 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15446 TYPE_FIELD_PRIVATE_BITS (type
) =
15447 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15448 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
15450 TYPE_FIELD_PROTECTED_BITS (type
) =
15451 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15452 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
15454 TYPE_FIELD_IGNORE_BITS (type
) =
15455 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15456 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
15459 /* If the type has baseclasses, allocate and clear a bit vector for
15460 TYPE_FIELD_VIRTUAL_BITS. */
15461 if (!fip
->baseclasses
.empty () && cu
->language
!= language_ada
)
15463 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
15464 unsigned char *pointer
;
15466 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15467 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
15468 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
15469 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
15470 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
15473 if (!fip
->variant_parts
.empty ())
15474 add_variant_property (fip
, type
, cu
);
15476 /* Copy the saved-up fields into the field vector. */
15477 for (int i
= 0; i
< nfields
; ++i
)
15479 struct nextfield
&field
15480 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
15481 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
15483 type
->field (i
) = field
.field
;
15484 switch (field
.accessibility
)
15486 case DW_ACCESS_private
:
15487 if (cu
->language
!= language_ada
)
15488 SET_TYPE_FIELD_PRIVATE (type
, i
);
15491 case DW_ACCESS_protected
:
15492 if (cu
->language
!= language_ada
)
15493 SET_TYPE_FIELD_PROTECTED (type
, i
);
15496 case DW_ACCESS_public
:
15500 /* Unknown accessibility. Complain and treat it as public. */
15502 complaint (_("unsupported accessibility %d"),
15503 field
.accessibility
);
15507 if (i
< fip
->baseclasses
.size ())
15509 switch (field
.virtuality
)
15511 case DW_VIRTUALITY_virtual
:
15512 case DW_VIRTUALITY_pure_virtual
:
15513 if (cu
->language
== language_ada
)
15514 error (_("unexpected virtuality in component of Ada type"));
15515 SET_TYPE_FIELD_VIRTUAL (type
, i
);
15522 /* Return true if this member function is a constructor, false
15526 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15528 const char *fieldname
;
15529 const char *type_name
;
15532 if (die
->parent
== NULL
)
15535 if (die
->parent
->tag
!= DW_TAG_structure_type
15536 && die
->parent
->tag
!= DW_TAG_union_type
15537 && die
->parent
->tag
!= DW_TAG_class_type
)
15540 fieldname
= dwarf2_name (die
, cu
);
15541 type_name
= dwarf2_name (die
->parent
, cu
);
15542 if (fieldname
== NULL
|| type_name
== NULL
)
15545 len
= strlen (fieldname
);
15546 return (strncmp (fieldname
, type_name
, len
) == 0
15547 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15550 /* Add a member function to the proper fieldlist. */
15553 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15554 struct type
*type
, struct dwarf2_cu
*cu
)
15556 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15557 struct attribute
*attr
;
15559 struct fnfieldlist
*flp
= nullptr;
15560 struct fn_field
*fnp
;
15561 const char *fieldname
;
15562 struct type
*this_type
;
15564 if (cu
->language
== language_ada
)
15565 error (_("unexpected member function in Ada type"));
15567 /* Get name of member function. */
15568 fieldname
= dwarf2_name (die
, cu
);
15569 if (fieldname
== NULL
)
15572 /* Look up member function name in fieldlist. */
15573 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15575 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15577 flp
= &fip
->fnfieldlists
[i
];
15582 /* Create a new fnfieldlist if necessary. */
15583 if (flp
== nullptr)
15585 fip
->fnfieldlists
.emplace_back ();
15586 flp
= &fip
->fnfieldlists
.back ();
15587 flp
->name
= fieldname
;
15588 i
= fip
->fnfieldlists
.size () - 1;
15591 /* Create a new member function field and add it to the vector of
15593 flp
->fnfields
.emplace_back ();
15594 fnp
= &flp
->fnfields
.back ();
15596 /* Delay processing of the physname until later. */
15597 if (cu
->language
== language_cplus
)
15598 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15602 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15603 fnp
->physname
= physname
? physname
: "";
15606 fnp
->type
= alloc_type (objfile
);
15607 this_type
= read_type_die (die
, cu
);
15608 if (this_type
&& this_type
->code () == TYPE_CODE_FUNC
)
15610 int nparams
= this_type
->num_fields ();
15612 /* TYPE is the domain of this method, and THIS_TYPE is the type
15613 of the method itself (TYPE_CODE_METHOD). */
15614 smash_to_method_type (fnp
->type
, type
,
15615 TYPE_TARGET_TYPE (this_type
),
15616 this_type
->fields (),
15617 this_type
->num_fields (),
15618 this_type
->has_varargs ());
15620 /* Handle static member functions.
15621 Dwarf2 has no clean way to discern C++ static and non-static
15622 member functions. G++ helps GDB by marking the first
15623 parameter for non-static member functions (which is the this
15624 pointer) as artificial. We obtain this information from
15625 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15626 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15627 fnp
->voffset
= VOFFSET_STATIC
;
15630 complaint (_("member function type missing for '%s'"),
15631 dwarf2_full_name (fieldname
, die
, cu
));
15633 /* Get fcontext from DW_AT_containing_type if present. */
15634 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15635 fnp
->fcontext
= die_containing_type (die
, cu
);
15637 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15638 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15640 /* Get accessibility. */
15641 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15642 switch (accessibility
)
15644 case DW_ACCESS_private
:
15645 fnp
->is_private
= 1;
15647 case DW_ACCESS_protected
:
15648 fnp
->is_protected
= 1;
15652 /* Check for artificial methods. */
15653 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15654 if (attr
&& attr
->as_boolean ())
15655 fnp
->is_artificial
= 1;
15657 /* Check for defaulted methods. */
15658 attr
= dwarf2_attr (die
, DW_AT_defaulted
, cu
);
15659 if (attr
!= nullptr)
15660 fnp
->defaulted
= attr
->defaulted ();
15662 /* Check for deleted methods. */
15663 attr
= dwarf2_attr (die
, DW_AT_deleted
, cu
);
15664 if (attr
!= nullptr && attr
->as_boolean ())
15665 fnp
->is_deleted
= 1;
15667 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15669 /* Get index in virtual function table if it is a virtual member
15670 function. For older versions of GCC, this is an offset in the
15671 appropriate virtual table, as specified by DW_AT_containing_type.
15672 For everyone else, it is an expression to be evaluated relative
15673 to the object address. */
15675 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15676 if (attr
!= nullptr)
15678 if (attr
->form_is_block () && attr
->as_block ()->size
> 0)
15680 struct dwarf_block
*block
= attr
->as_block ();
15682 if (block
->data
[0] == DW_OP_constu
)
15684 /* Old-style GCC. */
15685 fnp
->voffset
= decode_locdesc (block
, cu
) + 2;
15687 else if (block
->data
[0] == DW_OP_deref
15688 || (block
->size
> 1
15689 && block
->data
[0] == DW_OP_deref_size
15690 && block
->data
[1] == cu
->header
.addr_size
))
15692 fnp
->voffset
= decode_locdesc (block
, cu
);
15693 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15694 dwarf2_complex_location_expr_complaint ();
15696 fnp
->voffset
/= cu
->header
.addr_size
;
15700 dwarf2_complex_location_expr_complaint ();
15702 if (!fnp
->fcontext
)
15704 /* If there is no `this' field and no DW_AT_containing_type,
15705 we cannot actually find a base class context for the
15707 if (this_type
->num_fields () == 0
15708 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15710 complaint (_("cannot determine context for virtual member "
15711 "function \"%s\" (offset %s)"),
15712 fieldname
, sect_offset_str (die
->sect_off
));
15717 = TYPE_TARGET_TYPE (this_type
->field (0).type ());
15721 else if (attr
->form_is_section_offset ())
15723 dwarf2_complex_location_expr_complaint ();
15727 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15733 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15734 if (attr
!= nullptr && attr
->as_virtuality () != DW_VIRTUALITY_none
)
15736 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15737 complaint (_("Member function \"%s\" (offset %s) is virtual "
15738 "but the vtable offset is not specified"),
15739 fieldname
, sect_offset_str (die
->sect_off
));
15740 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15741 TYPE_CPLUS_DYNAMIC (type
) = 1;
15746 /* Create the vector of member function fields, and attach it to the type. */
15749 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15750 struct dwarf2_cu
*cu
)
15752 if (cu
->language
== language_ada
)
15753 error (_("unexpected member functions in Ada type"));
15755 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15756 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15758 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15760 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15762 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15763 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15765 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15766 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15767 fn_flp
->fn_fields
= (struct fn_field
*)
15768 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15770 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15771 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15774 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15777 /* Returns non-zero if NAME is the name of a vtable member in CU's
15778 language, zero otherwise. */
15780 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15782 static const char vptr
[] = "_vptr";
15784 /* Look for the C++ form of the vtable. */
15785 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15791 /* GCC outputs unnamed structures that are really pointers to member
15792 functions, with the ABI-specified layout. If TYPE describes
15793 such a structure, smash it into a member function type.
15795 GCC shouldn't do this; it should just output pointer to member DIEs.
15796 This is GCC PR debug/28767. */
15799 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15801 struct type
*pfn_type
, *self_type
, *new_type
;
15803 /* Check for a structure with no name and two children. */
15804 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15807 /* Check for __pfn and __delta members. */
15808 if (TYPE_FIELD_NAME (type
, 0) == NULL
15809 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15810 || TYPE_FIELD_NAME (type
, 1) == NULL
15811 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15814 /* Find the type of the method. */
15815 pfn_type
= type
->field (0).type ();
15816 if (pfn_type
== NULL
15817 || pfn_type
->code () != TYPE_CODE_PTR
15818 || TYPE_TARGET_TYPE (pfn_type
)->code () != TYPE_CODE_FUNC
)
15821 /* Look for the "this" argument. */
15822 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15823 if (pfn_type
->num_fields () == 0
15824 /* || pfn_type->field (0).type () == NULL */
15825 || pfn_type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15828 self_type
= TYPE_TARGET_TYPE (pfn_type
->field (0).type ());
15829 new_type
= alloc_type (objfile
);
15830 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15831 pfn_type
->fields (), pfn_type
->num_fields (),
15832 pfn_type
->has_varargs ());
15833 smash_to_methodptr_type (type
, new_type
);
15836 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15837 appropriate error checking and issuing complaints if there is a
15841 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
15843 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
15845 if (attr
== nullptr)
15848 if (!attr
->form_is_constant ())
15850 complaint (_("DW_AT_alignment must have constant form"
15851 " - DIE at %s [in module %s]"),
15852 sect_offset_str (die
->sect_off
),
15853 objfile_name (cu
->per_objfile
->objfile
));
15857 LONGEST val
= attr
->constant_value (0);
15860 complaint (_("DW_AT_alignment value must not be negative"
15861 " - DIE at %s [in module %s]"),
15862 sect_offset_str (die
->sect_off
),
15863 objfile_name (cu
->per_objfile
->objfile
));
15866 ULONGEST align
= val
;
15870 complaint (_("DW_AT_alignment value must not be zero"
15871 " - DIE at %s [in module %s]"),
15872 sect_offset_str (die
->sect_off
),
15873 objfile_name (cu
->per_objfile
->objfile
));
15876 if ((align
& (align
- 1)) != 0)
15878 complaint (_("DW_AT_alignment value must be a power of 2"
15879 " - DIE at %s [in module %s]"),
15880 sect_offset_str (die
->sect_off
),
15881 objfile_name (cu
->per_objfile
->objfile
));
15888 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15889 the alignment for TYPE. */
15892 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
15895 if (!set_type_align (type
, get_alignment (cu
, die
)))
15896 complaint (_("DW_AT_alignment value too large"
15897 " - DIE at %s [in module %s]"),
15898 sect_offset_str (die
->sect_off
),
15899 objfile_name (cu
->per_objfile
->objfile
));
15902 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15903 constant for a type, according to DWARF5 spec, Table 5.5. */
15906 is_valid_DW_AT_calling_convention_for_type (ULONGEST value
)
15911 case DW_CC_pass_by_reference
:
15912 case DW_CC_pass_by_value
:
15916 complaint (_("unrecognized DW_AT_calling_convention value "
15917 "(%s) for a type"), pulongest (value
));
15922 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15923 constant for a subroutine, according to DWARF5 spec, Table 3.3, and
15924 also according to GNU-specific values (see include/dwarf2.h). */
15927 is_valid_DW_AT_calling_convention_for_subroutine (ULONGEST value
)
15932 case DW_CC_program
:
15936 case DW_CC_GNU_renesas_sh
:
15937 case DW_CC_GNU_borland_fastcall_i386
:
15938 case DW_CC_GDB_IBM_OpenCL
:
15942 complaint (_("unrecognized DW_AT_calling_convention value "
15943 "(%s) for a subroutine"), pulongest (value
));
15948 /* Called when we find the DIE that starts a structure or union scope
15949 (definition) to create a type for the structure or union. Fill in
15950 the type's name and general properties; the members will not be
15951 processed until process_structure_scope. A symbol table entry for
15952 the type will also not be done until process_structure_scope (assuming
15953 the type has a name).
15955 NOTE: we need to call these functions regardless of whether or not the
15956 DIE has a DW_AT_name attribute, since it might be an anonymous
15957 structure or union. This gets the type entered into our set of
15958 user defined types. */
15960 static struct type
*
15961 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15963 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15965 struct attribute
*attr
;
15968 /* If the definition of this type lives in .debug_types, read that type.
15969 Don't follow DW_AT_specification though, that will take us back up
15970 the chain and we want to go down. */
15971 attr
= die
->attr (DW_AT_signature
);
15972 if (attr
!= nullptr)
15974 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15976 /* The type's CU may not be the same as CU.
15977 Ensure TYPE is recorded with CU in die_type_hash. */
15978 return set_die_type (die
, type
, cu
);
15981 type
= alloc_type (objfile
);
15982 INIT_CPLUS_SPECIFIC (type
);
15984 name
= dwarf2_name (die
, cu
);
15987 if (cu
->language
== language_cplus
15988 || cu
->language
== language_d
15989 || cu
->language
== language_rust
)
15991 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
15993 /* dwarf2_full_name might have already finished building the DIE's
15994 type. If so, there is no need to continue. */
15995 if (get_die_type (die
, cu
) != NULL
)
15996 return get_die_type (die
, cu
);
15998 type
->set_name (full_name
);
16002 /* The name is already allocated along with this objfile, so
16003 we don't need to duplicate it for the type. */
16004 type
->set_name (name
);
16008 if (die
->tag
== DW_TAG_structure_type
)
16010 type
->set_code (TYPE_CODE_STRUCT
);
16012 else if (die
->tag
== DW_TAG_union_type
)
16014 type
->set_code (TYPE_CODE_UNION
);
16018 type
->set_code (TYPE_CODE_STRUCT
);
16021 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
16022 TYPE_DECLARED_CLASS (type
) = 1;
16024 /* Store the calling convention in the type if it's available in
16025 the die. Otherwise the calling convention remains set to
16026 the default value DW_CC_normal. */
16027 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
16028 if (attr
!= nullptr
16029 && is_valid_DW_AT_calling_convention_for_type (attr
->constant_value (0)))
16031 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16032 TYPE_CPLUS_CALLING_CONVENTION (type
)
16033 = (enum dwarf_calling_convention
) (attr
->constant_value (0));
16036 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16037 if (attr
!= nullptr)
16039 if (attr
->form_is_constant ())
16040 TYPE_LENGTH (type
) = attr
->constant_value (0);
16043 struct dynamic_prop prop
;
16044 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
16045 type
->add_dyn_prop (DYN_PROP_BYTE_SIZE
, prop
);
16046 TYPE_LENGTH (type
) = 0;
16051 TYPE_LENGTH (type
) = 0;
16054 maybe_set_alignment (cu
, die
, type
);
16056 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
16058 /* ICC<14 does not output the required DW_AT_declaration on
16059 incomplete types, but gives them a size of zero. */
16060 type
->set_is_stub (true);
16063 type
->set_stub_is_supported (true);
16065 if (die_is_declaration (die
, cu
))
16066 type
->set_is_stub (true);
16067 else if (attr
== NULL
&& die
->child
== NULL
16068 && producer_is_realview (cu
->producer
))
16069 /* RealView does not output the required DW_AT_declaration
16070 on incomplete types. */
16071 type
->set_is_stub (true);
16073 /* We need to add the type field to the die immediately so we don't
16074 infinitely recurse when dealing with pointers to the structure
16075 type within the structure itself. */
16076 set_die_type (die
, type
, cu
);
16078 /* set_die_type should be already done. */
16079 set_descriptive_type (type
, die
, cu
);
16084 static void handle_struct_member_die
16085 (struct die_info
*child_die
,
16087 struct field_info
*fi
,
16088 std::vector
<struct symbol
*> *template_args
,
16089 struct dwarf2_cu
*cu
);
16091 /* A helper for handle_struct_member_die that handles
16092 DW_TAG_variant_part. */
16095 handle_variant_part (struct die_info
*die
, struct type
*type
,
16096 struct field_info
*fi
,
16097 std::vector
<struct symbol
*> *template_args
,
16098 struct dwarf2_cu
*cu
)
16100 variant_part_builder
*new_part
;
16101 if (fi
->current_variant_part
== nullptr)
16103 fi
->variant_parts
.emplace_back ();
16104 new_part
= &fi
->variant_parts
.back ();
16106 else if (!fi
->current_variant_part
->processing_variant
)
16108 complaint (_("nested DW_TAG_variant_part seen "
16109 "- DIE at %s [in module %s]"),
16110 sect_offset_str (die
->sect_off
),
16111 objfile_name (cu
->per_objfile
->objfile
));
16116 variant_field
¤t
= fi
->current_variant_part
->variants
.back ();
16117 current
.variant_parts
.emplace_back ();
16118 new_part
= ¤t
.variant_parts
.back ();
16121 /* When we recurse, we want callees to add to this new variant
16123 scoped_restore save_current_variant_part
16124 = make_scoped_restore (&fi
->current_variant_part
, new_part
);
16126 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
16129 /* It's a univariant form, an extension we support. */
16131 else if (discr
->form_is_ref ())
16133 struct dwarf2_cu
*target_cu
= cu
;
16134 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
16136 new_part
->discriminant_offset
= target_die
->sect_off
;
16140 complaint (_("DW_AT_discr does not have DIE reference form"
16141 " - DIE at %s [in module %s]"),
16142 sect_offset_str (die
->sect_off
),
16143 objfile_name (cu
->per_objfile
->objfile
));
16146 for (die_info
*child_die
= die
->child
;
16148 child_die
= child_die
->sibling
)
16149 handle_struct_member_die (child_die
, type
, fi
, template_args
, cu
);
16152 /* A helper for handle_struct_member_die that handles
16156 handle_variant (struct die_info
*die
, struct type
*type
,
16157 struct field_info
*fi
,
16158 std::vector
<struct symbol
*> *template_args
,
16159 struct dwarf2_cu
*cu
)
16161 if (fi
->current_variant_part
== nullptr)
16163 complaint (_("saw DW_TAG_variant outside DW_TAG_variant_part "
16164 "- DIE at %s [in module %s]"),
16165 sect_offset_str (die
->sect_off
),
16166 objfile_name (cu
->per_objfile
->objfile
));
16169 if (fi
->current_variant_part
->processing_variant
)
16171 complaint (_("nested DW_TAG_variant seen "
16172 "- DIE at %s [in module %s]"),
16173 sect_offset_str (die
->sect_off
),
16174 objfile_name (cu
->per_objfile
->objfile
));
16178 scoped_restore save_processing_variant
16179 = make_scoped_restore (&fi
->current_variant_part
->processing_variant
,
16182 fi
->current_variant_part
->variants
.emplace_back ();
16183 variant_field
&variant
= fi
->current_variant_part
->variants
.back ();
16184 variant
.first_field
= fi
->fields
.size ();
16186 /* In a variant we want to get the discriminant and also add a
16187 field for our sole member child. */
16188 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr_value
, cu
);
16189 if (discr
== nullptr || !discr
->form_is_constant ())
16191 discr
= dwarf2_attr (die
, DW_AT_discr_list
, cu
);
16192 if (discr
== nullptr || discr
->as_block ()->size
== 0)
16193 variant
.default_branch
= true;
16195 variant
.discr_list_data
= discr
->as_block ();
16198 variant
.discriminant_value
= discr
->constant_value (0);
16200 for (die_info
*variant_child
= die
->child
;
16201 variant_child
!= NULL
;
16202 variant_child
= variant_child
->sibling
)
16203 handle_struct_member_die (variant_child
, type
, fi
, template_args
, cu
);
16205 variant
.last_field
= fi
->fields
.size ();
16208 /* A helper for process_structure_scope that handles a single member
16212 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
16213 struct field_info
*fi
,
16214 std::vector
<struct symbol
*> *template_args
,
16215 struct dwarf2_cu
*cu
)
16217 if (child_die
->tag
== DW_TAG_member
16218 || child_die
->tag
== DW_TAG_variable
)
16220 /* NOTE: carlton/2002-11-05: A C++ static data member
16221 should be a DW_TAG_member that is a declaration, but
16222 all versions of G++ as of this writing (so through at
16223 least 3.2.1) incorrectly generate DW_TAG_variable
16224 tags for them instead. */
16225 dwarf2_add_field (fi
, child_die
, cu
);
16227 else if (child_die
->tag
== DW_TAG_subprogram
)
16229 /* Rust doesn't have member functions in the C++ sense.
16230 However, it does emit ordinary functions as children
16231 of a struct DIE. */
16232 if (cu
->language
== language_rust
)
16233 read_func_scope (child_die
, cu
);
16236 /* C++ member function. */
16237 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
16240 else if (child_die
->tag
== DW_TAG_inheritance
)
16242 /* C++ base class field. */
16243 dwarf2_add_field (fi
, child_die
, cu
);
16245 else if (type_can_define_types (child_die
))
16246 dwarf2_add_type_defn (fi
, child_die
, cu
);
16247 else if (child_die
->tag
== DW_TAG_template_type_param
16248 || child_die
->tag
== DW_TAG_template_value_param
)
16250 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
16253 template_args
->push_back (arg
);
16255 else if (child_die
->tag
== DW_TAG_variant_part
)
16256 handle_variant_part (child_die
, type
, fi
, template_args
, cu
);
16257 else if (child_die
->tag
== DW_TAG_variant
)
16258 handle_variant (child_die
, type
, fi
, template_args
, cu
);
16261 /* Finish creating a structure or union type, including filling in
16262 its members and creating a symbol for it. */
16265 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16267 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16268 struct die_info
*child_die
;
16271 type
= get_die_type (die
, cu
);
16273 type
= read_structure_type (die
, cu
);
16275 bool has_template_parameters
= false;
16276 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
16278 struct field_info fi
;
16279 std::vector
<struct symbol
*> template_args
;
16281 child_die
= die
->child
;
16283 while (child_die
&& child_die
->tag
)
16285 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
16286 child_die
= child_die
->sibling
;
16289 /* Attach template arguments to type. */
16290 if (!template_args
.empty ())
16292 has_template_parameters
= true;
16293 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16294 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
16295 TYPE_TEMPLATE_ARGUMENTS (type
)
16296 = XOBNEWVEC (&objfile
->objfile_obstack
,
16298 TYPE_N_TEMPLATE_ARGUMENTS (type
));
16299 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
16300 template_args
.data (),
16301 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
16302 * sizeof (struct symbol
*)));
16305 /* Attach fields and member functions to the type. */
16306 if (fi
.nfields () > 0)
16307 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
16308 if (!fi
.fnfieldlists
.empty ())
16310 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
16312 /* Get the type which refers to the base class (possibly this
16313 class itself) which contains the vtable pointer for the current
16314 class from the DW_AT_containing_type attribute. This use of
16315 DW_AT_containing_type is a GNU extension. */
16317 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
16319 struct type
*t
= die_containing_type (die
, cu
);
16321 set_type_vptr_basetype (type
, t
);
16326 /* Our own class provides vtbl ptr. */
16327 for (i
= t
->num_fields () - 1;
16328 i
>= TYPE_N_BASECLASSES (t
);
16331 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
16333 if (is_vtable_name (fieldname
, cu
))
16335 set_type_vptr_fieldno (type
, i
);
16340 /* Complain if virtual function table field not found. */
16341 if (i
< TYPE_N_BASECLASSES (t
))
16342 complaint (_("virtual function table pointer "
16343 "not found when defining class '%s'"),
16344 type
->name () ? type
->name () : "");
16348 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
16351 else if (cu
->producer
16352 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
16354 /* The IBM XLC compiler does not provide direct indication
16355 of the containing type, but the vtable pointer is
16356 always named __vfp. */
16360 for (i
= type
->num_fields () - 1;
16361 i
>= TYPE_N_BASECLASSES (type
);
16364 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
16366 set_type_vptr_fieldno (type
, i
);
16367 set_type_vptr_basetype (type
, type
);
16374 /* Copy fi.typedef_field_list linked list elements content into the
16375 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16376 if (!fi
.typedef_field_list
.empty ())
16378 int count
= fi
.typedef_field_list
.size ();
16380 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16381 TYPE_TYPEDEF_FIELD_ARRAY (type
)
16382 = ((struct decl_field
*)
16384 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
16385 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
16387 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
16388 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
16391 /* Copy fi.nested_types_list linked list elements content into the
16392 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16393 if (!fi
.nested_types_list
.empty () && cu
->language
!= language_ada
)
16395 int count
= fi
.nested_types_list
.size ();
16397 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16398 TYPE_NESTED_TYPES_ARRAY (type
)
16399 = ((struct decl_field
*)
16400 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
16401 TYPE_NESTED_TYPES_COUNT (type
) = count
;
16403 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
16404 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
16408 quirk_gcc_member_function_pointer (type
, objfile
);
16409 if (cu
->language
== language_rust
&& die
->tag
== DW_TAG_union_type
)
16410 cu
->rust_unions
.push_back (type
);
16412 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16413 snapshots) has been known to create a die giving a declaration
16414 for a class that has, as a child, a die giving a definition for a
16415 nested class. So we have to process our children even if the
16416 current die is a declaration. Normally, of course, a declaration
16417 won't have any children at all. */
16419 child_die
= die
->child
;
16421 while (child_die
!= NULL
&& child_die
->tag
)
16423 if (child_die
->tag
== DW_TAG_member
16424 || child_die
->tag
== DW_TAG_variable
16425 || child_die
->tag
== DW_TAG_inheritance
16426 || child_die
->tag
== DW_TAG_template_value_param
16427 || child_die
->tag
== DW_TAG_template_type_param
)
16432 process_die (child_die
, cu
);
16434 child_die
= child_die
->sibling
;
16437 /* Do not consider external references. According to the DWARF standard,
16438 these DIEs are identified by the fact that they have no byte_size
16439 attribute, and a declaration attribute. */
16440 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16441 || !die_is_declaration (die
, cu
)
16442 || dwarf2_attr (die
, DW_AT_signature
, cu
) != NULL
)
16444 struct symbol
*sym
= new_symbol (die
, type
, cu
);
16446 if (has_template_parameters
)
16448 struct symtab
*symtab
;
16449 if (sym
!= nullptr)
16450 symtab
= symbol_symtab (sym
);
16451 else if (cu
->line_header
!= nullptr)
16453 /* Any related symtab will do. */
16455 = cu
->line_header
->file_names ()[0].symtab
;
16460 complaint (_("could not find suitable "
16461 "symtab for template parameter"
16462 " - DIE at %s [in module %s]"),
16463 sect_offset_str (die
->sect_off
),
16464 objfile_name (objfile
));
16467 if (symtab
!= nullptr)
16469 /* Make sure that the symtab is set on the new symbols.
16470 Even though they don't appear in this symtab directly,
16471 other parts of gdb assume that symbols do, and this is
16472 reasonably true. */
16473 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
16474 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
16480 /* Assuming DIE is an enumeration type, and TYPE is its associated
16481 type, update TYPE using some information only available in DIE's
16482 children. In particular, the fields are computed. */
16485 update_enumeration_type_from_children (struct die_info
*die
,
16487 struct dwarf2_cu
*cu
)
16489 struct die_info
*child_die
;
16490 int unsigned_enum
= 1;
16493 auto_obstack obstack
;
16494 std::vector
<struct field
> fields
;
16496 for (child_die
= die
->child
;
16497 child_die
!= NULL
&& child_die
->tag
;
16498 child_die
= child_die
->sibling
)
16500 struct attribute
*attr
;
16502 const gdb_byte
*bytes
;
16503 struct dwarf2_locexpr_baton
*baton
;
16506 if (child_die
->tag
!= DW_TAG_enumerator
)
16509 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16513 name
= dwarf2_name (child_die
, cu
);
16515 name
= "<anonymous enumerator>";
16517 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16518 &value
, &bytes
, &baton
);
16526 if (count_one_bits_ll (value
) >= 2)
16530 fields
.emplace_back ();
16531 struct field
&field
= fields
.back ();
16532 FIELD_NAME (field
) = dwarf2_physname (name
, child_die
, cu
);
16533 SET_FIELD_ENUMVAL (field
, value
);
16536 if (!fields
.empty ())
16538 type
->set_num_fields (fields
.size ());
16541 TYPE_ALLOC (type
, sizeof (struct field
) * fields
.size ()));
16542 memcpy (type
->fields (), fields
.data (),
16543 sizeof (struct field
) * fields
.size ());
16547 type
->set_is_unsigned (true);
16550 TYPE_FLAG_ENUM (type
) = 1;
16553 /* Given a DW_AT_enumeration_type die, set its type. We do not
16554 complete the type's fields yet, or create any symbols. */
16556 static struct type
*
16557 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16559 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16561 struct attribute
*attr
;
16564 /* If the definition of this type lives in .debug_types, read that type.
16565 Don't follow DW_AT_specification though, that will take us back up
16566 the chain and we want to go down. */
16567 attr
= die
->attr (DW_AT_signature
);
16568 if (attr
!= nullptr)
16570 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16572 /* The type's CU may not be the same as CU.
16573 Ensure TYPE is recorded with CU in die_type_hash. */
16574 return set_die_type (die
, type
, cu
);
16577 type
= alloc_type (objfile
);
16579 type
->set_code (TYPE_CODE_ENUM
);
16580 name
= dwarf2_full_name (NULL
, die
, cu
);
16582 type
->set_name (name
);
16584 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16587 struct type
*underlying_type
= die_type (die
, cu
);
16589 TYPE_TARGET_TYPE (type
) = underlying_type
;
16592 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16593 if (attr
!= nullptr)
16595 TYPE_LENGTH (type
) = attr
->constant_value (0);
16599 TYPE_LENGTH (type
) = 0;
16602 maybe_set_alignment (cu
, die
, type
);
16604 /* The enumeration DIE can be incomplete. In Ada, any type can be
16605 declared as private in the package spec, and then defined only
16606 inside the package body. Such types are known as Taft Amendment
16607 Types. When another package uses such a type, an incomplete DIE
16608 may be generated by the compiler. */
16609 if (die_is_declaration (die
, cu
))
16610 type
->set_is_stub (true);
16612 /* If this type has an underlying type that is not a stub, then we
16613 may use its attributes. We always use the "unsigned" attribute
16614 in this situation, because ordinarily we guess whether the type
16615 is unsigned -- but the guess can be wrong and the underlying type
16616 can tell us the reality. However, we defer to a local size
16617 attribute if one exists, because this lets the compiler override
16618 the underlying type if needed. */
16619 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_TARGET_TYPE (type
)->is_stub ())
16621 struct type
*underlying_type
= TYPE_TARGET_TYPE (type
);
16622 underlying_type
= check_typedef (underlying_type
);
16624 type
->set_is_unsigned (underlying_type
->is_unsigned ());
16626 if (TYPE_LENGTH (type
) == 0)
16627 TYPE_LENGTH (type
) = TYPE_LENGTH (underlying_type
);
16629 if (TYPE_RAW_ALIGN (type
) == 0
16630 && TYPE_RAW_ALIGN (underlying_type
) != 0)
16631 set_type_align (type
, TYPE_RAW_ALIGN (underlying_type
));
16634 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
16636 set_die_type (die
, type
, cu
);
16638 /* Finish the creation of this type by using the enum's children.
16639 Note that, as usual, this must come after set_die_type to avoid
16640 infinite recursion when trying to compute the names of the
16642 update_enumeration_type_from_children (die
, type
, cu
);
16647 /* Given a pointer to a die which begins an enumeration, process all
16648 the dies that define the members of the enumeration, and create the
16649 symbol for the enumeration type.
16651 NOTE: We reverse the order of the element list. */
16654 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16656 struct type
*this_type
;
16658 this_type
= get_die_type (die
, cu
);
16659 if (this_type
== NULL
)
16660 this_type
= read_enumeration_type (die
, cu
);
16662 if (die
->child
!= NULL
)
16664 struct die_info
*child_die
;
16667 child_die
= die
->child
;
16668 while (child_die
&& child_die
->tag
)
16670 if (child_die
->tag
!= DW_TAG_enumerator
)
16672 process_die (child_die
, cu
);
16676 name
= dwarf2_name (child_die
, cu
);
16678 new_symbol (child_die
, this_type
, cu
);
16681 child_die
= child_die
->sibling
;
16685 /* If we are reading an enum from a .debug_types unit, and the enum
16686 is a declaration, and the enum is not the signatured type in the
16687 unit, then we do not want to add a symbol for it. Adding a
16688 symbol would in some cases obscure the true definition of the
16689 enum, giving users an incomplete type when the definition is
16690 actually available. Note that we do not want to do this for all
16691 enums which are just declarations, because C++0x allows forward
16692 enum declarations. */
16693 if (cu
->per_cu
->is_debug_types
16694 && die_is_declaration (die
, cu
))
16696 struct signatured_type
*sig_type
;
16698 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16699 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16700 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16704 new_symbol (die
, this_type
, cu
);
16707 /* Extract all information from a DW_TAG_array_type DIE and put it in
16708 the DIE's type field. For now, this only handles one dimensional
16711 static struct type
*
16712 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16714 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16715 struct die_info
*child_die
;
16717 struct type
*element_type
, *range_type
, *index_type
;
16718 struct attribute
*attr
;
16720 struct dynamic_prop
*byte_stride_prop
= NULL
;
16721 unsigned int bit_stride
= 0;
16723 element_type
= die_type (die
, cu
);
16725 /* The die_type call above may have already set the type for this DIE. */
16726 type
= get_die_type (die
, cu
);
16730 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
16734 struct type
*prop_type
= cu
->addr_sized_int_type (false);
16737 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
16738 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
16742 complaint (_("unable to read array DW_AT_byte_stride "
16743 " - DIE at %s [in module %s]"),
16744 sect_offset_str (die
->sect_off
),
16745 objfile_name (cu
->per_objfile
->objfile
));
16746 /* Ignore this attribute. We will likely not be able to print
16747 arrays of this type correctly, but there is little we can do
16748 to help if we cannot read the attribute's value. */
16749 byte_stride_prop
= NULL
;
16753 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
16755 bit_stride
= attr
->constant_value (0);
16757 /* Irix 6.2 native cc creates array types without children for
16758 arrays with unspecified length. */
16759 if (die
->child
== NULL
)
16761 index_type
= objfile_type (objfile
)->builtin_int
;
16762 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
16763 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
16764 byte_stride_prop
, bit_stride
);
16765 return set_die_type (die
, type
, cu
);
16768 std::vector
<struct type
*> range_types
;
16769 child_die
= die
->child
;
16770 while (child_die
&& child_die
->tag
)
16772 if (child_die
->tag
== DW_TAG_subrange_type
)
16774 struct type
*child_type
= read_type_die (child_die
, cu
);
16776 if (child_type
!= NULL
)
16778 /* The range type was succesfully read. Save it for the
16779 array type creation. */
16780 range_types
.push_back (child_type
);
16783 child_die
= child_die
->sibling
;
16786 /* Dwarf2 dimensions are output from left to right, create the
16787 necessary array types in backwards order. */
16789 type
= element_type
;
16791 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
16795 while (i
< range_types
.size ())
16796 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
16797 byte_stride_prop
, bit_stride
);
16801 size_t ndim
= range_types
.size ();
16803 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
16804 byte_stride_prop
, bit_stride
);
16807 /* Understand Dwarf2 support for vector types (like they occur on
16808 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16809 array type. This is not part of the Dwarf2/3 standard yet, but a
16810 custom vendor extension. The main difference between a regular
16811 array and the vector variant is that vectors are passed by value
16813 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
16814 if (attr
!= nullptr)
16815 make_vector_type (type
);
16817 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16818 implementation may choose to implement triple vectors using this
16820 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16821 if (attr
!= nullptr && attr
->form_is_unsigned ())
16823 if (attr
->as_unsigned () >= TYPE_LENGTH (type
))
16824 TYPE_LENGTH (type
) = attr
->as_unsigned ();
16826 complaint (_("DW_AT_byte_size for array type smaller "
16827 "than the total size of elements"));
16830 name
= dwarf2_name (die
, cu
);
16832 type
->set_name (name
);
16834 maybe_set_alignment (cu
, die
, type
);
16836 /* Install the type in the die. */
16837 set_die_type (die
, type
, cu
);
16839 /* set_die_type should be already done. */
16840 set_descriptive_type (type
, die
, cu
);
16845 static enum dwarf_array_dim_ordering
16846 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
16848 struct attribute
*attr
;
16850 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
16852 if (attr
!= nullptr)
16854 LONGEST val
= attr
->constant_value (-1);
16855 if (val
== DW_ORD_row_major
|| val
== DW_ORD_col_major
)
16856 return (enum dwarf_array_dim_ordering
) val
;
16859 /* GNU F77 is a special case, as at 08/2004 array type info is the
16860 opposite order to the dwarf2 specification, but data is still
16861 laid out as per normal fortran.
16863 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16864 version checking. */
16866 if (cu
->language
== language_fortran
16867 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
16869 return DW_ORD_row_major
;
16872 switch (cu
->language_defn
->array_ordering ())
16874 case array_column_major
:
16875 return DW_ORD_col_major
;
16876 case array_row_major
:
16878 return DW_ORD_row_major
;
16882 /* Extract all information from a DW_TAG_set_type DIE and put it in
16883 the DIE's type field. */
16885 static struct type
*
16886 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16888 struct type
*domain_type
, *set_type
;
16889 struct attribute
*attr
;
16891 domain_type
= die_type (die
, cu
);
16893 /* The die_type call above may have already set the type for this DIE. */
16894 set_type
= get_die_type (die
, cu
);
16898 set_type
= create_set_type (NULL
, domain_type
);
16900 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16901 if (attr
!= nullptr && attr
->form_is_unsigned ())
16902 TYPE_LENGTH (set_type
) = attr
->as_unsigned ();
16904 maybe_set_alignment (cu
, die
, set_type
);
16906 return set_die_type (die
, set_type
, cu
);
16909 /* A helper for read_common_block that creates a locexpr baton.
16910 SYM is the symbol which we are marking as computed.
16911 COMMON_DIE is the DIE for the common block.
16912 COMMON_LOC is the location expression attribute for the common
16914 MEMBER_LOC is the location expression attribute for the particular
16915 member of the common block that we are processing.
16916 CU is the CU from which the above come. */
16919 mark_common_block_symbol_computed (struct symbol
*sym
,
16920 struct die_info
*common_die
,
16921 struct attribute
*common_loc
,
16922 struct attribute
*member_loc
,
16923 struct dwarf2_cu
*cu
)
16925 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
16926 struct objfile
*objfile
= per_objfile
->objfile
;
16927 struct dwarf2_locexpr_baton
*baton
;
16929 unsigned int cu_off
;
16930 enum bfd_endian byte_order
= gdbarch_byte_order (objfile
->arch ());
16931 LONGEST offset
= 0;
16933 gdb_assert (common_loc
&& member_loc
);
16934 gdb_assert (common_loc
->form_is_block ());
16935 gdb_assert (member_loc
->form_is_block ()
16936 || member_loc
->form_is_constant ());
16938 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
16939 baton
->per_objfile
= per_objfile
;
16940 baton
->per_cu
= cu
->per_cu
;
16941 gdb_assert (baton
->per_cu
);
16943 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16945 if (member_loc
->form_is_constant ())
16947 offset
= member_loc
->constant_value (0);
16948 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
16951 baton
->size
+= member_loc
->as_block ()->size
;
16953 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
16956 *ptr
++ = DW_OP_call4
;
16957 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
16958 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
16961 if (member_loc
->form_is_constant ())
16963 *ptr
++ = DW_OP_addr
;
16964 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
16965 ptr
+= cu
->header
.addr_size
;
16969 /* We have to copy the data here, because DW_OP_call4 will only
16970 use a DW_AT_location attribute. */
16971 struct dwarf_block
*block
= member_loc
->as_block ();
16972 memcpy (ptr
, block
->data
, block
->size
);
16973 ptr
+= block
->size
;
16976 *ptr
++ = DW_OP_plus
;
16977 gdb_assert (ptr
- baton
->data
== baton
->size
);
16979 SYMBOL_LOCATION_BATON (sym
) = baton
;
16980 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
16983 /* Create appropriate locally-scoped variables for all the
16984 DW_TAG_common_block entries. Also create a struct common_block
16985 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16986 is used to separate the common blocks name namespace from regular
16990 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
16992 struct attribute
*attr
;
16994 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16995 if (attr
!= nullptr)
16997 /* Support the .debug_loc offsets. */
16998 if (attr
->form_is_block ())
17002 else if (attr
->form_is_section_offset ())
17004 dwarf2_complex_location_expr_complaint ();
17009 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17010 "common block member");
17015 if (die
->child
!= NULL
)
17017 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17018 struct die_info
*child_die
;
17019 size_t n_entries
= 0, size
;
17020 struct common_block
*common_block
;
17021 struct symbol
*sym
;
17023 for (child_die
= die
->child
;
17024 child_die
&& child_die
->tag
;
17025 child_die
= child_die
->sibling
)
17028 size
= (sizeof (struct common_block
)
17029 + (n_entries
- 1) * sizeof (struct symbol
*));
17031 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
17033 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
17034 common_block
->n_entries
= 0;
17036 for (child_die
= die
->child
;
17037 child_die
&& child_die
->tag
;
17038 child_die
= child_die
->sibling
)
17040 /* Create the symbol in the DW_TAG_common_block block in the current
17042 sym
= new_symbol (child_die
, NULL
, cu
);
17045 struct attribute
*member_loc
;
17047 common_block
->contents
[common_block
->n_entries
++] = sym
;
17049 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
17053 /* GDB has handled this for a long time, but it is
17054 not specified by DWARF. It seems to have been
17055 emitted by gfortran at least as recently as:
17056 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
17057 complaint (_("Variable in common block has "
17058 "DW_AT_data_member_location "
17059 "- DIE at %s [in module %s]"),
17060 sect_offset_str (child_die
->sect_off
),
17061 objfile_name (objfile
));
17063 if (member_loc
->form_is_section_offset ())
17064 dwarf2_complex_location_expr_complaint ();
17065 else if (member_loc
->form_is_constant ()
17066 || member_loc
->form_is_block ())
17068 if (attr
!= nullptr)
17069 mark_common_block_symbol_computed (sym
, die
, attr
,
17073 dwarf2_complex_location_expr_complaint ();
17078 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
17079 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
17083 /* Create a type for a C++ namespace. */
17085 static struct type
*
17086 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17088 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17089 const char *previous_prefix
, *name
;
17093 /* For extensions, reuse the type of the original namespace. */
17094 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
17096 struct die_info
*ext_die
;
17097 struct dwarf2_cu
*ext_cu
= cu
;
17099 ext_die
= dwarf2_extension (die
, &ext_cu
);
17100 type
= read_type_die (ext_die
, ext_cu
);
17102 /* EXT_CU may not be the same as CU.
17103 Ensure TYPE is recorded with CU in die_type_hash. */
17104 return set_die_type (die
, type
, cu
);
17107 name
= namespace_name (die
, &is_anonymous
, cu
);
17109 /* Now build the name of the current namespace. */
17111 previous_prefix
= determine_prefix (die
, cu
);
17112 if (previous_prefix
[0] != '\0')
17113 name
= typename_concat (&objfile
->objfile_obstack
,
17114 previous_prefix
, name
, 0, cu
);
17116 /* Create the type. */
17117 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
17119 return set_die_type (die
, type
, cu
);
17122 /* Read a namespace scope. */
17125 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
17127 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17130 /* Add a symbol associated to this if we haven't seen the namespace
17131 before. Also, add a using directive if it's an anonymous
17134 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
17138 type
= read_type_die (die
, cu
);
17139 new_symbol (die
, type
, cu
);
17141 namespace_name (die
, &is_anonymous
, cu
);
17144 const char *previous_prefix
= determine_prefix (die
, cu
);
17146 std::vector
<const char *> excludes
;
17147 add_using_directive (using_directives (cu
),
17148 previous_prefix
, type
->name (), NULL
,
17149 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
17153 if (die
->child
!= NULL
)
17155 struct die_info
*child_die
= die
->child
;
17157 while (child_die
&& child_die
->tag
)
17159 process_die (child_die
, cu
);
17160 child_die
= child_die
->sibling
;
17165 /* Read a Fortran module as type. This DIE can be only a declaration used for
17166 imported module. Still we need that type as local Fortran "use ... only"
17167 declaration imports depend on the created type in determine_prefix. */
17169 static struct type
*
17170 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17172 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17173 const char *module_name
;
17176 module_name
= dwarf2_name (die
, cu
);
17177 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
17179 return set_die_type (die
, type
, cu
);
17182 /* Read a Fortran module. */
17185 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
17187 struct die_info
*child_die
= die
->child
;
17190 type
= read_type_die (die
, cu
);
17191 new_symbol (die
, type
, cu
);
17193 while (child_die
&& child_die
->tag
)
17195 process_die (child_die
, cu
);
17196 child_die
= child_die
->sibling
;
17200 /* Return the name of the namespace represented by DIE. Set
17201 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
17204 static const char *
17205 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
17207 struct die_info
*current_die
;
17208 const char *name
= NULL
;
17210 /* Loop through the extensions until we find a name. */
17212 for (current_die
= die
;
17213 current_die
!= NULL
;
17214 current_die
= dwarf2_extension (die
, &cu
))
17216 /* We don't use dwarf2_name here so that we can detect the absence
17217 of a name -> anonymous namespace. */
17218 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
17224 /* Is it an anonymous namespace? */
17226 *is_anonymous
= (name
== NULL
);
17228 name
= CP_ANONYMOUS_NAMESPACE_STR
;
17233 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17234 the user defined type vector. */
17236 static struct type
*
17237 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17239 struct gdbarch
*gdbarch
= cu
->per_objfile
->objfile
->arch ();
17240 struct comp_unit_head
*cu_header
= &cu
->header
;
17242 struct attribute
*attr_byte_size
;
17243 struct attribute
*attr_address_class
;
17244 int byte_size
, addr_class
;
17245 struct type
*target_type
;
17247 target_type
= die_type (die
, cu
);
17249 /* The die_type call above may have already set the type for this DIE. */
17250 type
= get_die_type (die
, cu
);
17254 type
= lookup_pointer_type (target_type
);
17256 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17257 if (attr_byte_size
)
17258 byte_size
= attr_byte_size
->constant_value (cu_header
->addr_size
);
17260 byte_size
= cu_header
->addr_size
;
17262 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
17263 if (attr_address_class
)
17264 addr_class
= attr_address_class
->constant_value (DW_ADDR_none
);
17266 addr_class
= DW_ADDR_none
;
17268 ULONGEST alignment
= get_alignment (cu
, die
);
17270 /* If the pointer size, alignment, or address class is different
17271 than the default, create a type variant marked as such and set
17272 the length accordingly. */
17273 if (TYPE_LENGTH (type
) != byte_size
17274 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
17275 && alignment
!= TYPE_RAW_ALIGN (type
))
17276 || addr_class
!= DW_ADDR_none
)
17278 if (gdbarch_address_class_type_flags_p (gdbarch
))
17280 type_instance_flags type_flags
17281 = gdbarch_address_class_type_flags (gdbarch
, byte_size
,
17283 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17285 type
= make_type_with_address_space (type
, type_flags
);
17287 else if (TYPE_LENGTH (type
) != byte_size
)
17289 complaint (_("invalid pointer size %d"), byte_size
);
17291 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17293 complaint (_("Invalid DW_AT_alignment"
17294 " - DIE at %s [in module %s]"),
17295 sect_offset_str (die
->sect_off
),
17296 objfile_name (cu
->per_objfile
->objfile
));
17300 /* Should we also complain about unhandled address classes? */
17304 TYPE_LENGTH (type
) = byte_size
;
17305 set_type_align (type
, alignment
);
17306 return set_die_type (die
, type
, cu
);
17309 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17310 the user defined type vector. */
17312 static struct type
*
17313 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17316 struct type
*to_type
;
17317 struct type
*domain
;
17319 to_type
= die_type (die
, cu
);
17320 domain
= die_containing_type (die
, cu
);
17322 /* The calls above may have already set the type for this DIE. */
17323 type
= get_die_type (die
, cu
);
17327 if (check_typedef (to_type
)->code () == TYPE_CODE_METHOD
)
17328 type
= lookup_methodptr_type (to_type
);
17329 else if (check_typedef (to_type
)->code () == TYPE_CODE_FUNC
)
17331 struct type
*new_type
= alloc_type (cu
->per_objfile
->objfile
);
17333 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17334 to_type
->fields (), to_type
->num_fields (),
17335 to_type
->has_varargs ());
17336 type
= lookup_methodptr_type (new_type
);
17339 type
= lookup_memberptr_type (to_type
, domain
);
17341 return set_die_type (die
, type
, cu
);
17344 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17345 the user defined type vector. */
17347 static struct type
*
17348 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17349 enum type_code refcode
)
17351 struct comp_unit_head
*cu_header
= &cu
->header
;
17352 struct type
*type
, *target_type
;
17353 struct attribute
*attr
;
17355 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17357 target_type
= die_type (die
, cu
);
17359 /* The die_type call above may have already set the type for this DIE. */
17360 type
= get_die_type (die
, cu
);
17364 type
= lookup_reference_type (target_type
, refcode
);
17365 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17366 if (attr
!= nullptr)
17368 TYPE_LENGTH (type
) = attr
->constant_value (cu_header
->addr_size
);
17372 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17374 maybe_set_alignment (cu
, die
, type
);
17375 return set_die_type (die
, type
, cu
);
17378 /* Add the given cv-qualifiers to the element type of the array. GCC
17379 outputs DWARF type qualifiers that apply to an array, not the
17380 element type. But GDB relies on the array element type to carry
17381 the cv-qualifiers. This mimics section 6.7.3 of the C99
17384 static struct type
*
17385 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17386 struct type
*base_type
, int cnst
, int voltl
)
17388 struct type
*el_type
, *inner_array
;
17390 base_type
= copy_type (base_type
);
17391 inner_array
= base_type
;
17393 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
17395 TYPE_TARGET_TYPE (inner_array
) =
17396 copy_type (TYPE_TARGET_TYPE (inner_array
));
17397 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17400 el_type
= TYPE_TARGET_TYPE (inner_array
);
17401 cnst
|= TYPE_CONST (el_type
);
17402 voltl
|= TYPE_VOLATILE (el_type
);
17403 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17405 return set_die_type (die
, base_type
, cu
);
17408 static struct type
*
17409 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17411 struct type
*base_type
, *cv_type
;
17413 base_type
= die_type (die
, cu
);
17415 /* The die_type call above may have already set the type for this DIE. */
17416 cv_type
= get_die_type (die
, cu
);
17420 /* In case the const qualifier is applied to an array type, the element type
17421 is so qualified, not the array type (section 6.7.3 of C99). */
17422 if (base_type
->code () == TYPE_CODE_ARRAY
)
17423 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17425 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17426 return set_die_type (die
, cv_type
, cu
);
17429 static struct type
*
17430 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17432 struct type
*base_type
, *cv_type
;
17434 base_type
= die_type (die
, cu
);
17436 /* The die_type call above may have already set the type for this DIE. */
17437 cv_type
= get_die_type (die
, cu
);
17441 /* In case the volatile qualifier is applied to an array type, the
17442 element type is so qualified, not the array type (section 6.7.3
17444 if (base_type
->code () == TYPE_CODE_ARRAY
)
17445 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17447 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17448 return set_die_type (die
, cv_type
, cu
);
17451 /* Handle DW_TAG_restrict_type. */
17453 static struct type
*
17454 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17456 struct type
*base_type
, *cv_type
;
17458 base_type
= die_type (die
, cu
);
17460 /* The die_type call above may have already set the type for this DIE. */
17461 cv_type
= get_die_type (die
, cu
);
17465 cv_type
= make_restrict_type (base_type
);
17466 return set_die_type (die
, cv_type
, cu
);
17469 /* Handle DW_TAG_atomic_type. */
17471 static struct type
*
17472 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17474 struct type
*base_type
, *cv_type
;
17476 base_type
= die_type (die
, cu
);
17478 /* The die_type call above may have already set the type for this DIE. */
17479 cv_type
= get_die_type (die
, cu
);
17483 cv_type
= make_atomic_type (base_type
);
17484 return set_die_type (die
, cv_type
, cu
);
17487 /* Extract all information from a DW_TAG_string_type DIE and add to
17488 the user defined type vector. It isn't really a user defined type,
17489 but it behaves like one, with other DIE's using an AT_user_def_type
17490 attribute to reference it. */
17492 static struct type
*
17493 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17495 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17496 struct gdbarch
*gdbarch
= objfile
->arch ();
17497 struct type
*type
, *range_type
, *index_type
, *char_type
;
17498 struct attribute
*attr
;
17499 struct dynamic_prop prop
;
17500 bool length_is_constant
= true;
17503 /* There are a couple of places where bit sizes might be made use of
17504 when parsing a DW_TAG_string_type, however, no producer that we know
17505 of make use of these. Handling bit sizes that are a multiple of the
17506 byte size is easy enough, but what about other bit sizes? Lets deal
17507 with that problem when we have to. Warn about these attributes being
17508 unsupported, then parse the type and ignore them like we always
17510 if (dwarf2_attr (die
, DW_AT_bit_size
, cu
) != nullptr
17511 || dwarf2_attr (die
, DW_AT_string_length_bit_size
, cu
) != nullptr)
17513 static bool warning_printed
= false;
17514 if (!warning_printed
)
17516 warning (_("DW_AT_bit_size and DW_AT_string_length_bit_size not "
17517 "currently supported on DW_TAG_string_type."));
17518 warning_printed
= true;
17522 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17523 if (attr
!= nullptr && !attr
->form_is_constant ())
17525 /* The string length describes the location at which the length of
17526 the string can be found. The size of the length field can be
17527 specified with one of the attributes below. */
17528 struct type
*prop_type
;
17529 struct attribute
*len
17530 = dwarf2_attr (die
, DW_AT_string_length_byte_size
, cu
);
17531 if (len
== nullptr)
17532 len
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17533 if (len
!= nullptr && len
->form_is_constant ())
17535 /* Pass 0 as the default as we know this attribute is constant
17536 and the default value will not be returned. */
17537 LONGEST sz
= len
->constant_value (0);
17538 prop_type
= cu
->per_objfile
->int_type (sz
, true);
17542 /* If the size is not specified then we assume it is the size of
17543 an address on this target. */
17544 prop_type
= cu
->addr_sized_int_type (true);
17547 /* Convert the attribute into a dynamic property. */
17548 if (!attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
17551 length_is_constant
= false;
17553 else if (attr
!= nullptr)
17555 /* This DW_AT_string_length just contains the length with no
17556 indirection. There's no need to create a dynamic property in this
17557 case. Pass 0 for the default value as we know it will not be
17558 returned in this case. */
17559 length
= attr
->constant_value (0);
17561 else if ((attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
)) != nullptr)
17563 /* We don't currently support non-constant byte sizes for strings. */
17564 length
= attr
->constant_value (1);
17568 /* Use 1 as a fallback length if we have nothing else. */
17572 index_type
= objfile_type (objfile
)->builtin_int
;
17573 if (length_is_constant
)
17574 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17577 struct dynamic_prop low_bound
;
17579 low_bound
.set_const_val (1);
17580 range_type
= create_range_type (NULL
, index_type
, &low_bound
, &prop
, 0);
17582 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17583 type
= create_string_type (NULL
, char_type
, range_type
);
17585 return set_die_type (die
, type
, cu
);
17588 /* Assuming that DIE corresponds to a function, returns nonzero
17589 if the function is prototyped. */
17592 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17594 struct attribute
*attr
;
17596 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17597 if (attr
&& attr
->as_boolean ())
17600 /* The DWARF standard implies that the DW_AT_prototyped attribute
17601 is only meaningful for C, but the concept also extends to other
17602 languages that allow unprototyped functions (Eg: Objective C).
17603 For all other languages, assume that functions are always
17605 if (cu
->language
!= language_c
17606 && cu
->language
!= language_objc
17607 && cu
->language
!= language_opencl
)
17610 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17611 prototyped and unprototyped functions; default to prototyped,
17612 since that is more common in modern code (and RealView warns
17613 about unprototyped functions). */
17614 if (producer_is_realview (cu
->producer
))
17620 /* Handle DIES due to C code like:
17624 int (*funcp)(int a, long l);
17628 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17630 static struct type
*
17631 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17633 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17634 struct type
*type
; /* Type that this function returns. */
17635 struct type
*ftype
; /* Function that returns above type. */
17636 struct attribute
*attr
;
17638 type
= die_type (die
, cu
);
17640 /* The die_type call above may have already set the type for this DIE. */
17641 ftype
= get_die_type (die
, cu
);
17645 ftype
= lookup_function_type (type
);
17647 if (prototyped_function_p (die
, cu
))
17648 ftype
->set_is_prototyped (true);
17650 /* Store the calling convention in the type if it's available in
17651 the subroutine die. Otherwise set the calling convention to
17652 the default value DW_CC_normal. */
17653 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
17654 if (attr
!= nullptr
17655 && is_valid_DW_AT_calling_convention_for_subroutine (attr
->constant_value (0)))
17656 TYPE_CALLING_CONVENTION (ftype
)
17657 = (enum dwarf_calling_convention
) attr
->constant_value (0);
17658 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
17659 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
17661 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
17663 /* Record whether the function returns normally to its caller or not
17664 if the DWARF producer set that information. */
17665 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
17666 if (attr
&& attr
->as_boolean ())
17667 TYPE_NO_RETURN (ftype
) = 1;
17669 /* We need to add the subroutine type to the die immediately so
17670 we don't infinitely recurse when dealing with parameters
17671 declared as the same subroutine type. */
17672 set_die_type (die
, ftype
, cu
);
17674 if (die
->child
!= NULL
)
17676 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
17677 struct die_info
*child_die
;
17678 int nparams
, iparams
;
17680 /* Count the number of parameters.
17681 FIXME: GDB currently ignores vararg functions, but knows about
17682 vararg member functions. */
17684 child_die
= die
->child
;
17685 while (child_die
&& child_die
->tag
)
17687 if (child_die
->tag
== DW_TAG_formal_parameter
)
17689 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
17690 ftype
->set_has_varargs (true);
17692 child_die
= child_die
->sibling
;
17695 /* Allocate storage for parameters and fill them in. */
17696 ftype
->set_num_fields (nparams
);
17698 ((struct field
*) TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
)));
17700 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17701 even if we error out during the parameters reading below. */
17702 for (iparams
= 0; iparams
< nparams
; iparams
++)
17703 ftype
->field (iparams
).set_type (void_type
);
17706 child_die
= die
->child
;
17707 while (child_die
&& child_die
->tag
)
17709 if (child_die
->tag
== DW_TAG_formal_parameter
)
17711 struct type
*arg_type
;
17713 /* DWARF version 2 has no clean way to discern C++
17714 static and non-static member functions. G++ helps
17715 GDB by marking the first parameter for non-static
17716 member functions (which is the this pointer) as
17717 artificial. We pass this information to
17718 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17720 DWARF version 3 added DW_AT_object_pointer, which GCC
17721 4.5 does not yet generate. */
17722 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
17723 if (attr
!= nullptr)
17724 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = attr
->as_boolean ();
17726 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
17727 arg_type
= die_type (child_die
, cu
);
17729 /* RealView does not mark THIS as const, which the testsuite
17730 expects. GCC marks THIS as const in method definitions,
17731 but not in the class specifications (GCC PR 43053). */
17732 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
17733 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
17736 struct dwarf2_cu
*arg_cu
= cu
;
17737 const char *name
= dwarf2_name (child_die
, cu
);
17739 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
17740 if (attr
!= nullptr)
17742 /* If the compiler emits this, use it. */
17743 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
17746 else if (name
&& strcmp (name
, "this") == 0)
17747 /* Function definitions will have the argument names. */
17749 else if (name
== NULL
&& iparams
== 0)
17750 /* Declarations may not have the names, so like
17751 elsewhere in GDB, assume an artificial first
17752 argument is "this". */
17756 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
17760 ftype
->field (iparams
).set_type (arg_type
);
17763 child_die
= child_die
->sibling
;
17770 static struct type
*
17771 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
17773 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17774 const char *name
= NULL
;
17775 struct type
*this_type
, *target_type
;
17777 name
= dwarf2_full_name (NULL
, die
, cu
);
17778 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
17779 this_type
->set_target_is_stub (true);
17780 set_die_type (die
, this_type
, cu
);
17781 target_type
= die_type (die
, cu
);
17782 if (target_type
!= this_type
)
17783 TYPE_TARGET_TYPE (this_type
) = target_type
;
17786 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17787 spec and cause infinite loops in GDB. */
17788 complaint (_("Self-referential DW_TAG_typedef "
17789 "- DIE at %s [in module %s]"),
17790 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
17791 TYPE_TARGET_TYPE (this_type
) = NULL
;
17795 /* Gcc-7 and before supports -feliminate-dwarf2-dups, which generates
17796 anonymous typedefs, which is, strictly speaking, invalid DWARF.
17797 Handle these by just returning the target type, rather than
17798 constructing an anonymous typedef type and trying to handle this
17800 set_die_type (die
, target_type
, cu
);
17801 return target_type
;
17806 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17807 (which may be different from NAME) to the architecture back-end to allow
17808 it to guess the correct format if necessary. */
17810 static struct type
*
17811 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
17812 const char *name_hint
, enum bfd_endian byte_order
)
17814 struct gdbarch
*gdbarch
= objfile
->arch ();
17815 const struct floatformat
**format
;
17818 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
17820 type
= init_float_type (objfile
, bits
, name
, format
, byte_order
);
17822 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17827 /* Allocate an integer type of size BITS and name NAME. */
17829 static struct type
*
17830 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
17831 int bits
, int unsigned_p
, const char *name
)
17835 /* Versions of Intel's C Compiler generate an integer type called "void"
17836 instead of using DW_TAG_unspecified_type. This has been seen on
17837 at least versions 14, 17, and 18. */
17838 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
17839 && strcmp (name
, "void") == 0)
17840 type
= objfile_type (objfile
)->builtin_void
;
17842 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
17847 /* Initialise and return a floating point type of size BITS suitable for
17848 use as a component of a complex number. The NAME_HINT is passed through
17849 when initialising the floating point type and is the name of the complex
17852 As DWARF doesn't currently provide an explicit name for the components
17853 of a complex number, but it can be helpful to have these components
17854 named, we try to select a suitable name based on the size of the
17856 static struct type
*
17857 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
17858 struct objfile
*objfile
,
17859 int bits
, const char *name_hint
,
17860 enum bfd_endian byte_order
)
17862 gdbarch
*gdbarch
= objfile
->arch ();
17863 struct type
*tt
= nullptr;
17865 /* Try to find a suitable floating point builtin type of size BITS.
17866 We're going to use the name of this type as the name for the complex
17867 target type that we are about to create. */
17868 switch (cu
->language
)
17870 case language_fortran
:
17874 tt
= builtin_f_type (gdbarch
)->builtin_real
;
17877 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
17879 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17881 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
17889 tt
= builtin_type (gdbarch
)->builtin_float
;
17892 tt
= builtin_type (gdbarch
)->builtin_double
;
17894 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17896 tt
= builtin_type (gdbarch
)->builtin_long_double
;
17902 /* If the type we found doesn't match the size we were looking for, then
17903 pretend we didn't find a type at all, the complex target type we
17904 create will then be nameless. */
17905 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
17908 const char *name
= (tt
== nullptr) ? nullptr : tt
->name ();
17909 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
, byte_order
);
17912 /* Find a representation of a given base type and install
17913 it in the TYPE field of the die. */
17915 static struct type
*
17916 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17918 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17920 struct attribute
*attr
;
17921 int encoding
= 0, bits
= 0;
17925 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
17926 if (attr
!= nullptr && attr
->form_is_constant ())
17927 encoding
= attr
->constant_value (0);
17928 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17929 if (attr
!= nullptr)
17930 bits
= attr
->constant_value (0) * TARGET_CHAR_BIT
;
17931 name
= dwarf2_name (die
, cu
);
17933 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17935 arch
= objfile
->arch ();
17936 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
17938 attr
= dwarf2_attr (die
, DW_AT_endianity
, cu
);
17939 if (attr
!= nullptr && attr
->form_is_constant ())
17941 int endianity
= attr
->constant_value (0);
17946 byte_order
= BFD_ENDIAN_BIG
;
17948 case DW_END_little
:
17949 byte_order
= BFD_ENDIAN_LITTLE
;
17952 complaint (_("DW_AT_endianity has unrecognized value %d"), endianity
);
17959 case DW_ATE_address
:
17960 /* Turn DW_ATE_address into a void * pointer. */
17961 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
17962 type
= init_pointer_type (objfile
, bits
, name
, type
);
17964 case DW_ATE_boolean
:
17965 type
= init_boolean_type (objfile
, bits
, 1, name
);
17967 case DW_ATE_complex_float
:
17968 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
,
17970 if (type
->code () == TYPE_CODE_ERROR
)
17972 if (name
== nullptr)
17974 struct obstack
*obstack
17975 = &cu
->per_objfile
->objfile
->objfile_obstack
;
17976 name
= obconcat (obstack
, "_Complex ", type
->name (),
17979 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17982 type
= init_complex_type (name
, type
);
17984 case DW_ATE_decimal_float
:
17985 type
= init_decfloat_type (objfile
, bits
, name
);
17988 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
, byte_order
);
17990 case DW_ATE_signed
:
17991 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
17993 case DW_ATE_unsigned
:
17994 if (cu
->language
== language_fortran
17996 && startswith (name
, "character("))
17997 type
= init_character_type (objfile
, bits
, 1, name
);
17999 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18001 case DW_ATE_signed_char
:
18002 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18003 || cu
->language
== language_pascal
18004 || cu
->language
== language_fortran
)
18005 type
= init_character_type (objfile
, bits
, 0, name
);
18007 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18009 case DW_ATE_unsigned_char
:
18010 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18011 || cu
->language
== language_pascal
18012 || cu
->language
== language_fortran
18013 || cu
->language
== language_rust
)
18014 type
= init_character_type (objfile
, bits
, 1, name
);
18016 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18021 type
= builtin_type (arch
)->builtin_char16
;
18022 else if (bits
== 32)
18023 type
= builtin_type (arch
)->builtin_char32
;
18026 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
18028 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18030 return set_die_type (die
, type
, cu
);
18035 complaint (_("unsupported DW_AT_encoding: '%s'"),
18036 dwarf_type_encoding_name (encoding
));
18037 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18041 if (name
&& strcmp (name
, "char") == 0)
18042 type
->set_has_no_signedness (true);
18044 maybe_set_alignment (cu
, die
, type
);
18046 type
->set_endianity_is_not_default (gdbarch_byte_order (arch
) != byte_order
);
18048 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_INT
)
18050 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
18051 if (attr
!= nullptr && attr
->as_unsigned () <= 8 * TYPE_LENGTH (type
))
18053 unsigned real_bit_size
= attr
->as_unsigned ();
18054 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
18055 /* Only use the attributes if they make sense together. */
18056 if (attr
== nullptr
18057 || (attr
->as_unsigned () + real_bit_size
18058 <= 8 * TYPE_LENGTH (type
)))
18060 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_size
18062 if (attr
!= nullptr)
18063 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_offset
18064 = attr
->as_unsigned ();
18069 return set_die_type (die
, type
, cu
);
18072 /* Parse dwarf attribute if it's a block, reference or constant and put the
18073 resulting value of the attribute into struct bound_prop.
18074 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
18077 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
18078 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
18079 struct type
*default_type
)
18081 struct dwarf2_property_baton
*baton
;
18082 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
18083 struct objfile
*objfile
= per_objfile
->objfile
;
18084 struct obstack
*obstack
= &objfile
->objfile_obstack
;
18086 gdb_assert (default_type
!= NULL
);
18088 if (attr
== NULL
|| prop
== NULL
)
18091 if (attr
->form_is_block ())
18093 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18094 baton
->property_type
= default_type
;
18095 baton
->locexpr
.per_cu
= cu
->per_cu
;
18096 baton
->locexpr
.per_objfile
= per_objfile
;
18098 struct dwarf_block
*block
= attr
->as_block ();
18099 baton
->locexpr
.size
= block
->size
;
18100 baton
->locexpr
.data
= block
->data
;
18101 switch (attr
->name
)
18103 case DW_AT_string_length
:
18104 baton
->locexpr
.is_reference
= true;
18107 baton
->locexpr
.is_reference
= false;
18111 prop
->set_locexpr (baton
);
18112 gdb_assert (prop
->baton () != NULL
);
18114 else if (attr
->form_is_ref ())
18116 struct dwarf2_cu
*target_cu
= cu
;
18117 struct die_info
*target_die
;
18118 struct attribute
*target_attr
;
18120 target_die
= follow_die_ref (die
, attr
, &target_cu
);
18121 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
18122 if (target_attr
== NULL
)
18123 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
18125 if (target_attr
== NULL
)
18128 switch (target_attr
->name
)
18130 case DW_AT_location
:
18131 if (target_attr
->form_is_section_offset ())
18133 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18134 baton
->property_type
= die_type (target_die
, target_cu
);
18135 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
18136 prop
->set_loclist (baton
);
18137 gdb_assert (prop
->baton () != NULL
);
18139 else if (target_attr
->form_is_block ())
18141 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18142 baton
->property_type
= die_type (target_die
, target_cu
);
18143 baton
->locexpr
.per_cu
= cu
->per_cu
;
18144 baton
->locexpr
.per_objfile
= per_objfile
;
18145 struct dwarf_block
*block
= target_attr
->as_block ();
18146 baton
->locexpr
.size
= block
->size
;
18147 baton
->locexpr
.data
= block
->data
;
18148 baton
->locexpr
.is_reference
= true;
18149 prop
->set_locexpr (baton
);
18150 gdb_assert (prop
->baton () != NULL
);
18154 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18155 "dynamic property");
18159 case DW_AT_data_member_location
:
18163 if (!handle_data_member_location (target_die
, target_cu
,
18167 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18168 baton
->property_type
= read_type_die (target_die
->parent
,
18170 baton
->offset_info
.offset
= offset
;
18171 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
18172 prop
->set_addr_offset (baton
);
18177 else if (attr
->form_is_constant ())
18178 prop
->set_const_val (attr
->constant_value (0));
18181 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
18182 dwarf2_name (die
, cu
));
18192 dwarf2_per_objfile::int_type (int size_in_bytes
, bool unsigned_p
) const
18194 struct type
*int_type
;
18196 /* Helper macro to examine the various builtin types. */
18197 #define TRY_TYPE(F) \
18198 int_type = (unsigned_p \
18199 ? objfile_type (objfile)->builtin_unsigned_ ## F \
18200 : objfile_type (objfile)->builtin_ ## F); \
18201 if (int_type != NULL && TYPE_LENGTH (int_type) == size_in_bytes) \
18208 TRY_TYPE (long_long
);
18212 gdb_assert_not_reached ("unable to find suitable integer type");
18218 dwarf2_cu::addr_sized_int_type (bool unsigned_p
) const
18220 int addr_size
= this->per_cu
->addr_size ();
18221 return this->per_objfile
->int_type (addr_size
, unsigned_p
);
18224 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
18225 present (which is valid) then compute the default type based on the
18226 compilation units address size. */
18228 static struct type
*
18229 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18231 struct type
*index_type
= die_type (die
, cu
);
18233 /* Dwarf-2 specifications explicitly allows to create subrange types
18234 without specifying a base type.
18235 In that case, the base type must be set to the type of
18236 the lower bound, upper bound or count, in that order, if any of these
18237 three attributes references an object that has a type.
18238 If no base type is found, the Dwarf-2 specifications say that
18239 a signed integer type of size equal to the size of an address should
18241 For the following C code: `extern char gdb_int [];'
18242 GCC produces an empty range DIE.
18243 FIXME: muller/2010-05-28: Possible references to object for low bound,
18244 high bound or count are not yet handled by this code. */
18245 if (index_type
->code () == TYPE_CODE_VOID
)
18246 index_type
= cu
->addr_sized_int_type (false);
18251 /* Read the given DW_AT_subrange DIE. */
18253 static struct type
*
18254 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18256 struct type
*base_type
, *orig_base_type
;
18257 struct type
*range_type
;
18258 struct attribute
*attr
;
18259 struct dynamic_prop low
, high
;
18260 int low_default_is_valid
;
18261 int high_bound_is_count
= 0;
18263 ULONGEST negative_mask
;
18265 orig_base_type
= read_subrange_index_type (die
, cu
);
18267 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
18268 whereas the real type might be. So, we use ORIG_BASE_TYPE when
18269 creating the range type, but we use the result of check_typedef
18270 when examining properties of the type. */
18271 base_type
= check_typedef (orig_base_type
);
18273 /* The die_type call above may have already set the type for this DIE. */
18274 range_type
= get_die_type (die
, cu
);
18278 high
.set_const_val (0);
18280 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
18281 omitting DW_AT_lower_bound. */
18282 switch (cu
->language
)
18285 case language_cplus
:
18286 low
.set_const_val (0);
18287 low_default_is_valid
= 1;
18289 case language_fortran
:
18290 low
.set_const_val (1);
18291 low_default_is_valid
= 1;
18294 case language_objc
:
18295 case language_rust
:
18296 low
.set_const_val (0);
18297 low_default_is_valid
= (cu
->header
.version
>= 4);
18301 case language_pascal
:
18302 low
.set_const_val (1);
18303 low_default_is_valid
= (cu
->header
.version
>= 4);
18306 low
.set_const_val (0);
18307 low_default_is_valid
= 0;
18311 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
18312 if (attr
!= nullptr)
18313 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
18314 else if (!low_default_is_valid
)
18315 complaint (_("Missing DW_AT_lower_bound "
18316 "- DIE at %s [in module %s]"),
18317 sect_offset_str (die
->sect_off
),
18318 objfile_name (cu
->per_objfile
->objfile
));
18320 struct attribute
*attr_ub
, *attr_count
;
18321 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
18322 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18324 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
18325 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18327 /* If bounds are constant do the final calculation here. */
18328 if (low
.kind () == PROP_CONST
&& high
.kind () == PROP_CONST
)
18329 high
.set_const_val (low
.const_val () + high
.const_val () - 1);
18331 high_bound_is_count
= 1;
18335 if (attr_ub
!= NULL
)
18336 complaint (_("Unresolved DW_AT_upper_bound "
18337 "- DIE at %s [in module %s]"),
18338 sect_offset_str (die
->sect_off
),
18339 objfile_name (cu
->per_objfile
->objfile
));
18340 if (attr_count
!= NULL
)
18341 complaint (_("Unresolved DW_AT_count "
18342 "- DIE at %s [in module %s]"),
18343 sect_offset_str (die
->sect_off
),
18344 objfile_name (cu
->per_objfile
->objfile
));
18349 struct attribute
*bias_attr
= dwarf2_attr (die
, DW_AT_GNU_bias
, cu
);
18350 if (bias_attr
!= nullptr && bias_attr
->form_is_constant ())
18351 bias
= bias_attr
->constant_value (0);
18353 /* Normally, the DWARF producers are expected to use a signed
18354 constant form (Eg. DW_FORM_sdata) to express negative bounds.
18355 But this is unfortunately not always the case, as witnessed
18356 with GCC, for instance, where the ambiguous DW_FORM_dataN form
18357 is used instead. To work around that ambiguity, we treat
18358 the bounds as signed, and thus sign-extend their values, when
18359 the base type is signed. */
18361 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
18362 if (low
.kind () == PROP_CONST
18363 && !base_type
->is_unsigned () && (low
.const_val () & negative_mask
))
18364 low
.set_const_val (low
.const_val () | negative_mask
);
18365 if (high
.kind () == PROP_CONST
18366 && !base_type
->is_unsigned () && (high
.const_val () & negative_mask
))
18367 high
.set_const_val (high
.const_val () | negative_mask
);
18369 /* Check for bit and byte strides. */
18370 struct dynamic_prop byte_stride_prop
;
18371 attribute
*attr_byte_stride
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
18372 if (attr_byte_stride
!= nullptr)
18374 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18375 attr_to_dynamic_prop (attr_byte_stride
, die
, cu
, &byte_stride_prop
,
18379 struct dynamic_prop bit_stride_prop
;
18380 attribute
*attr_bit_stride
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
18381 if (attr_bit_stride
!= nullptr)
18383 /* It only makes sense to have either a bit or byte stride. */
18384 if (attr_byte_stride
!= nullptr)
18386 complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
18387 "- DIE at %s [in module %s]"),
18388 sect_offset_str (die
->sect_off
),
18389 objfile_name (cu
->per_objfile
->objfile
));
18390 attr_bit_stride
= nullptr;
18394 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18395 attr_to_dynamic_prop (attr_bit_stride
, die
, cu
, &bit_stride_prop
,
18400 if (attr_byte_stride
!= nullptr
18401 || attr_bit_stride
!= nullptr)
18403 bool byte_stride_p
= (attr_byte_stride
!= nullptr);
18404 struct dynamic_prop
*stride
18405 = byte_stride_p
? &byte_stride_prop
: &bit_stride_prop
;
18408 = create_range_type_with_stride (NULL
, orig_base_type
, &low
,
18409 &high
, bias
, stride
, byte_stride_p
);
18412 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
, bias
);
18414 if (high_bound_is_count
)
18415 range_type
->bounds ()->flag_upper_bound_is_count
= 1;
18417 /* Ada expects an empty array on no boundary attributes. */
18418 if (attr
== NULL
&& cu
->language
!= language_ada
)
18419 range_type
->bounds ()->high
.set_undefined ();
18421 name
= dwarf2_name (die
, cu
);
18423 range_type
->set_name (name
);
18425 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18426 if (attr
!= nullptr)
18427 TYPE_LENGTH (range_type
) = attr
->constant_value (0);
18429 maybe_set_alignment (cu
, die
, range_type
);
18431 set_die_type (die
, range_type
, cu
);
18433 /* set_die_type should be already done. */
18434 set_descriptive_type (range_type
, die
, cu
);
18439 static struct type
*
18440 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18444 type
= init_type (cu
->per_objfile
->objfile
, TYPE_CODE_VOID
, 0, NULL
);
18445 type
->set_name (dwarf2_name (die
, cu
));
18447 /* In Ada, an unspecified type is typically used when the description
18448 of the type is deferred to a different unit. When encountering
18449 such a type, we treat it as a stub, and try to resolve it later on,
18451 if (cu
->language
== language_ada
)
18452 type
->set_is_stub (true);
18454 return set_die_type (die
, type
, cu
);
18457 /* Read a single die and all its descendents. Set the die's sibling
18458 field to NULL; set other fields in the die correctly, and set all
18459 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
18460 location of the info_ptr after reading all of those dies. PARENT
18461 is the parent of the die in question. */
18463 static struct die_info
*
18464 read_die_and_children (const struct die_reader_specs
*reader
,
18465 const gdb_byte
*info_ptr
,
18466 const gdb_byte
**new_info_ptr
,
18467 struct die_info
*parent
)
18469 struct die_info
*die
;
18470 const gdb_byte
*cur_ptr
;
18472 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, 0);
18475 *new_info_ptr
= cur_ptr
;
18478 store_in_ref_table (die
, reader
->cu
);
18480 if (die
->has_children
)
18481 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
18485 *new_info_ptr
= cur_ptr
;
18488 die
->sibling
= NULL
;
18489 die
->parent
= parent
;
18493 /* Read a die, all of its descendents, and all of its siblings; set
18494 all of the fields of all of the dies correctly. Arguments are as
18495 in read_die_and_children. */
18497 static struct die_info
*
18498 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
18499 const gdb_byte
*info_ptr
,
18500 const gdb_byte
**new_info_ptr
,
18501 struct die_info
*parent
)
18503 struct die_info
*first_die
, *last_sibling
;
18504 const gdb_byte
*cur_ptr
;
18506 cur_ptr
= info_ptr
;
18507 first_die
= last_sibling
= NULL
;
18511 struct die_info
*die
18512 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
18516 *new_info_ptr
= cur_ptr
;
18523 last_sibling
->sibling
= die
;
18525 last_sibling
= die
;
18529 /* Read a die, all of its descendents, and all of its siblings; set
18530 all of the fields of all of the dies correctly. Arguments are as
18531 in read_die_and_children.
18532 This the main entry point for reading a DIE and all its children. */
18534 static struct die_info
*
18535 read_die_and_siblings (const struct die_reader_specs
*reader
,
18536 const gdb_byte
*info_ptr
,
18537 const gdb_byte
**new_info_ptr
,
18538 struct die_info
*parent
)
18540 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
18541 new_info_ptr
, parent
);
18543 if (dwarf_die_debug
)
18545 fprintf_unfiltered (gdb_stdlog
,
18546 "Read die from %s@0x%x of %s:\n",
18547 reader
->die_section
->get_name (),
18548 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18549 bfd_get_filename (reader
->abfd
));
18550 dump_die (die
, dwarf_die_debug
);
18556 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18558 The caller is responsible for filling in the extra attributes
18559 and updating (*DIEP)->num_attrs.
18560 Set DIEP to point to a newly allocated die with its information,
18561 except for its child, sibling, and parent fields. */
18563 static const gdb_byte
*
18564 read_full_die_1 (const struct die_reader_specs
*reader
,
18565 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18566 int num_extra_attrs
)
18568 unsigned int abbrev_number
, bytes_read
, i
;
18569 struct abbrev_info
*abbrev
;
18570 struct die_info
*die
;
18571 struct dwarf2_cu
*cu
= reader
->cu
;
18572 bfd
*abfd
= reader
->abfd
;
18574 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
18575 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18576 info_ptr
+= bytes_read
;
18577 if (!abbrev_number
)
18583 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
18585 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18587 bfd_get_filename (abfd
));
18589 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
18590 die
->sect_off
= sect_off
;
18591 die
->tag
= abbrev
->tag
;
18592 die
->abbrev
= abbrev_number
;
18593 die
->has_children
= abbrev
->has_children
;
18595 /* Make the result usable.
18596 The caller needs to update num_attrs after adding the extra
18598 die
->num_attrs
= abbrev
->num_attrs
;
18600 bool any_need_reprocess
= false;
18601 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18603 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
18605 if (die
->attrs
[i
].requires_reprocessing_p ())
18606 any_need_reprocess
= true;
18609 struct attribute
*attr
= die
->attr (DW_AT_str_offsets_base
);
18610 if (attr
!= nullptr && attr
->form_is_unsigned ())
18611 cu
->str_offsets_base
= attr
->as_unsigned ();
18613 attr
= die
->attr (DW_AT_loclists_base
);
18614 if (attr
!= nullptr)
18615 cu
->loclist_base
= attr
->as_unsigned ();
18617 auto maybe_addr_base
= die
->addr_base ();
18618 if (maybe_addr_base
.has_value ())
18619 cu
->addr_base
= *maybe_addr_base
;
18621 attr
= die
->attr (DW_AT_rnglists_base
);
18622 if (attr
!= nullptr)
18623 cu
->ranges_base
= attr
->as_unsigned ();
18625 if (any_need_reprocess
)
18627 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18629 if (die
->attrs
[i
].requires_reprocessing_p ())
18630 read_attribute_reprocess (reader
, &die
->attrs
[i
], die
->tag
);
18637 /* Read a die and all its attributes.
18638 Set DIEP to point to a newly allocated die with its information,
18639 except for its child, sibling, and parent fields. */
18641 static const gdb_byte
*
18642 read_full_die (const struct die_reader_specs
*reader
,
18643 struct die_info
**diep
, const gdb_byte
*info_ptr
)
18645 const gdb_byte
*result
;
18647 result
= read_full_die_1 (reader
, diep
, info_ptr
, 0);
18649 if (dwarf_die_debug
)
18651 fprintf_unfiltered (gdb_stdlog
,
18652 "Read die from %s@0x%x of %s:\n",
18653 reader
->die_section
->get_name (),
18654 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18655 bfd_get_filename (reader
->abfd
));
18656 dump_die (*diep
, dwarf_die_debug
);
18663 /* Returns nonzero if TAG represents a type that we might generate a partial
18667 is_type_tag_for_partial (int tag
)
18672 /* Some types that would be reasonable to generate partial symbols for,
18673 that we don't at present. */
18674 case DW_TAG_array_type
:
18675 case DW_TAG_file_type
:
18676 case DW_TAG_ptr_to_member_type
:
18677 case DW_TAG_set_type
:
18678 case DW_TAG_string_type
:
18679 case DW_TAG_subroutine_type
:
18681 case DW_TAG_base_type
:
18682 case DW_TAG_class_type
:
18683 case DW_TAG_interface_type
:
18684 case DW_TAG_enumeration_type
:
18685 case DW_TAG_structure_type
:
18686 case DW_TAG_subrange_type
:
18687 case DW_TAG_typedef
:
18688 case DW_TAG_union_type
:
18695 /* Load all DIEs that are interesting for partial symbols into memory. */
18697 static struct partial_die_info
*
18698 load_partial_dies (const struct die_reader_specs
*reader
,
18699 const gdb_byte
*info_ptr
, int building_psymtab
)
18701 struct dwarf2_cu
*cu
= reader
->cu
;
18702 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18703 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
18704 unsigned int bytes_read
;
18705 unsigned int load_all
= 0;
18706 int nesting_level
= 1;
18711 gdb_assert (cu
->per_cu
!= NULL
);
18712 if (cu
->per_cu
->load_all_dies
)
18716 = htab_create_alloc_ex (cu
->header
.length
/ 12,
18720 &cu
->comp_unit_obstack
,
18721 hashtab_obstack_allocate
,
18722 dummy_obstack_deallocate
);
18726 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
18728 /* A NULL abbrev means the end of a series of children. */
18729 if (abbrev
== NULL
)
18731 if (--nesting_level
== 0)
18734 info_ptr
+= bytes_read
;
18735 last_die
= parent_die
;
18736 parent_die
= parent_die
->die_parent
;
18740 /* Check for template arguments. We never save these; if
18741 they're seen, we just mark the parent, and go on our way. */
18742 if (parent_die
!= NULL
18743 && cu
->language
== language_cplus
18744 && (abbrev
->tag
== DW_TAG_template_type_param
18745 || abbrev
->tag
== DW_TAG_template_value_param
))
18747 parent_die
->has_template_arguments
= 1;
18751 /* We don't need a partial DIE for the template argument. */
18752 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18757 /* We only recurse into c++ subprograms looking for template arguments.
18758 Skip their other children. */
18760 && cu
->language
== language_cplus
18761 && parent_die
!= NULL
18762 && parent_die
->tag
== DW_TAG_subprogram
18763 && abbrev
->tag
!= DW_TAG_inlined_subroutine
)
18765 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18769 /* Check whether this DIE is interesting enough to save. Normally
18770 we would not be interested in members here, but there may be
18771 later variables referencing them via DW_AT_specification (for
18772 static members). */
18774 && !is_type_tag_for_partial (abbrev
->tag
)
18775 && abbrev
->tag
!= DW_TAG_constant
18776 && abbrev
->tag
!= DW_TAG_enumerator
18777 && abbrev
->tag
!= DW_TAG_subprogram
18778 && abbrev
->tag
!= DW_TAG_inlined_subroutine
18779 && abbrev
->tag
!= DW_TAG_lexical_block
18780 && abbrev
->tag
!= DW_TAG_variable
18781 && abbrev
->tag
!= DW_TAG_namespace
18782 && abbrev
->tag
!= DW_TAG_module
18783 && abbrev
->tag
!= DW_TAG_member
18784 && abbrev
->tag
!= DW_TAG_imported_unit
18785 && abbrev
->tag
!= DW_TAG_imported_declaration
)
18787 /* Otherwise we skip to the next sibling, if any. */
18788 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18792 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
18795 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
18797 /* This two-pass algorithm for processing partial symbols has a
18798 high cost in cache pressure. Thus, handle some simple cases
18799 here which cover the majority of C partial symbols. DIEs
18800 which neither have specification tags in them, nor could have
18801 specification tags elsewhere pointing at them, can simply be
18802 processed and discarded.
18804 This segment is also optional; scan_partial_symbols and
18805 add_partial_symbol will handle these DIEs if we chain
18806 them in normally. When compilers which do not emit large
18807 quantities of duplicate debug information are more common,
18808 this code can probably be removed. */
18810 /* Any complete simple types at the top level (pretty much all
18811 of them, for a language without namespaces), can be processed
18813 if (parent_die
== NULL
18814 && pdi
.has_specification
== 0
18815 && pdi
.is_declaration
== 0
18816 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
18817 || pdi
.tag
== DW_TAG_base_type
18818 || pdi
.tag
== DW_TAG_subrange_type
))
18820 if (building_psymtab
&& pdi
.raw_name
!= NULL
)
18821 add_partial_symbol (&pdi
, cu
);
18823 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18827 /* The exception for DW_TAG_typedef with has_children above is
18828 a workaround of GCC PR debug/47510. In the case of this complaint
18829 type_name_or_error will error on such types later.
18831 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18832 it could not find the child DIEs referenced later, this is checked
18833 above. In correct DWARF DW_TAG_typedef should have no children. */
18835 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
18836 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18837 "- DIE at %s [in module %s]"),
18838 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
18840 /* If we're at the second level, and we're an enumerator, and
18841 our parent has no specification (meaning possibly lives in a
18842 namespace elsewhere), then we can add the partial symbol now
18843 instead of queueing it. */
18844 if (pdi
.tag
== DW_TAG_enumerator
18845 && parent_die
!= NULL
18846 && parent_die
->die_parent
== NULL
18847 && parent_die
->tag
== DW_TAG_enumeration_type
18848 && parent_die
->has_specification
== 0)
18850 if (pdi
.raw_name
== NULL
)
18851 complaint (_("malformed enumerator DIE ignored"));
18852 else if (building_psymtab
)
18853 add_partial_symbol (&pdi
, cu
);
18855 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18859 struct partial_die_info
*part_die
18860 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
18862 /* We'll save this DIE so link it in. */
18863 part_die
->die_parent
= parent_die
;
18864 part_die
->die_sibling
= NULL
;
18865 part_die
->die_child
= NULL
;
18867 if (last_die
&& last_die
== parent_die
)
18868 last_die
->die_child
= part_die
;
18870 last_die
->die_sibling
= part_die
;
18872 last_die
= part_die
;
18874 if (first_die
== NULL
)
18875 first_die
= part_die
;
18877 /* Maybe add the DIE to the hash table. Not all DIEs that we
18878 find interesting need to be in the hash table, because we
18879 also have the parent/sibling/child chains; only those that we
18880 might refer to by offset later during partial symbol reading.
18882 For now this means things that might have be the target of a
18883 DW_AT_specification, DW_AT_abstract_origin, or
18884 DW_AT_extension. DW_AT_extension will refer only to
18885 namespaces; DW_AT_abstract_origin refers to functions (and
18886 many things under the function DIE, but we do not recurse
18887 into function DIEs during partial symbol reading) and
18888 possibly variables as well; DW_AT_specification refers to
18889 declarations. Declarations ought to have the DW_AT_declaration
18890 flag. It happens that GCC forgets to put it in sometimes, but
18891 only for functions, not for types.
18893 Adding more things than necessary to the hash table is harmless
18894 except for the performance cost. Adding too few will result in
18895 wasted time in find_partial_die, when we reread the compilation
18896 unit with load_all_dies set. */
18899 || abbrev
->tag
== DW_TAG_constant
18900 || abbrev
->tag
== DW_TAG_subprogram
18901 || abbrev
->tag
== DW_TAG_variable
18902 || abbrev
->tag
== DW_TAG_namespace
18903 || part_die
->is_declaration
)
18907 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
18908 to_underlying (part_die
->sect_off
),
18913 /* For some DIEs we want to follow their children (if any). For C
18914 we have no reason to follow the children of structures; for other
18915 languages we have to, so that we can get at method physnames
18916 to infer fully qualified class names, for DW_AT_specification,
18917 and for C++ template arguments. For C++, we also look one level
18918 inside functions to find template arguments (if the name of the
18919 function does not already contain the template arguments).
18921 For Ada and Fortran, we need to scan the children of subprograms
18922 and lexical blocks as well because these languages allow the
18923 definition of nested entities that could be interesting for the
18924 debugger, such as nested subprograms for instance. */
18925 if (last_die
->has_children
18927 || last_die
->tag
== DW_TAG_namespace
18928 || last_die
->tag
== DW_TAG_module
18929 || last_die
->tag
== DW_TAG_enumeration_type
18930 || (cu
->language
== language_cplus
18931 && last_die
->tag
== DW_TAG_subprogram
18932 && (last_die
->raw_name
== NULL
18933 || strchr (last_die
->raw_name
, '<') == NULL
))
18934 || (cu
->language
!= language_c
18935 && (last_die
->tag
== DW_TAG_class_type
18936 || last_die
->tag
== DW_TAG_interface_type
18937 || last_die
->tag
== DW_TAG_structure_type
18938 || last_die
->tag
== DW_TAG_union_type
))
18939 || ((cu
->language
== language_ada
18940 || cu
->language
== language_fortran
)
18941 && (last_die
->tag
== DW_TAG_subprogram
18942 || last_die
->tag
== DW_TAG_lexical_block
))))
18945 parent_die
= last_die
;
18949 /* Otherwise we skip to the next sibling, if any. */
18950 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
18952 /* Back to the top, do it again. */
18956 partial_die_info::partial_die_info (sect_offset sect_off_
,
18957 struct abbrev_info
*abbrev
)
18958 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
18962 /* See class definition. */
18965 partial_die_info::name (dwarf2_cu
*cu
)
18967 if (!canonical_name
&& raw_name
!= nullptr)
18969 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18970 raw_name
= dwarf2_canonicalize_name (raw_name
, cu
, objfile
);
18971 canonical_name
= 1;
18977 /* Read a minimal amount of information into the minimal die structure.
18978 INFO_PTR should point just after the initial uleb128 of a DIE. */
18981 partial_die_info::read (const struct die_reader_specs
*reader
,
18982 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
18984 struct dwarf2_cu
*cu
= reader
->cu
;
18985 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
18987 int has_low_pc_attr
= 0;
18988 int has_high_pc_attr
= 0;
18989 int high_pc_relative
= 0;
18991 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
18994 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
18995 /* String and address offsets that need to do the reprocessing have
18996 already been read at this point, so there is no need to wait until
18997 the loop terminates to do the reprocessing. */
18998 if (attr
.requires_reprocessing_p ())
18999 read_attribute_reprocess (reader
, &attr
, tag
);
19000 /* Store the data if it is of an attribute we want to keep in a
19001 partial symbol table. */
19007 case DW_TAG_compile_unit
:
19008 case DW_TAG_partial_unit
:
19009 case DW_TAG_type_unit
:
19010 /* Compilation units have a DW_AT_name that is a filename, not
19011 a source language identifier. */
19012 case DW_TAG_enumeration_type
:
19013 case DW_TAG_enumerator
:
19014 /* These tags always have simple identifiers already; no need
19015 to canonicalize them. */
19016 canonical_name
= 1;
19017 raw_name
= attr
.as_string ();
19020 canonical_name
= 0;
19021 raw_name
= attr
.as_string ();
19025 case DW_AT_linkage_name
:
19026 case DW_AT_MIPS_linkage_name
:
19027 /* Note that both forms of linkage name might appear. We
19028 assume they will be the same, and we only store the last
19030 linkage_name
= attr
.as_string ();
19033 has_low_pc_attr
= 1;
19034 lowpc
= attr
.as_address ();
19036 case DW_AT_high_pc
:
19037 has_high_pc_attr
= 1;
19038 highpc
= attr
.as_address ();
19039 if (cu
->header
.version
>= 4 && attr
.form_is_constant ())
19040 high_pc_relative
= 1;
19042 case DW_AT_location
:
19043 /* Support the .debug_loc offsets. */
19044 if (attr
.form_is_block ())
19046 d
.locdesc
= attr
.as_block ();
19048 else if (attr
.form_is_section_offset ())
19050 dwarf2_complex_location_expr_complaint ();
19054 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
19055 "partial symbol information");
19058 case DW_AT_external
:
19059 is_external
= attr
.as_boolean ();
19061 case DW_AT_declaration
:
19062 is_declaration
= attr
.as_boolean ();
19067 case DW_AT_abstract_origin
:
19068 case DW_AT_specification
:
19069 case DW_AT_extension
:
19070 has_specification
= 1;
19071 spec_offset
= attr
.get_ref_die_offset ();
19072 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19073 || cu
->per_cu
->is_dwz
);
19075 case DW_AT_sibling
:
19076 /* Ignore absolute siblings, they might point outside of
19077 the current compile unit. */
19078 if (attr
.form
== DW_FORM_ref_addr
)
19079 complaint (_("ignoring absolute DW_AT_sibling"));
19082 const gdb_byte
*buffer
= reader
->buffer
;
19083 sect_offset off
= attr
.get_ref_die_offset ();
19084 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
19086 if (sibling_ptr
< info_ptr
)
19087 complaint (_("DW_AT_sibling points backwards"));
19088 else if (sibling_ptr
> reader
->buffer_end
)
19089 reader
->die_section
->overflow_complaint ();
19091 sibling
= sibling_ptr
;
19094 case DW_AT_byte_size
:
19097 case DW_AT_const_value
:
19098 has_const_value
= 1;
19100 case DW_AT_calling_convention
:
19101 /* DWARF doesn't provide a way to identify a program's source-level
19102 entry point. DW_AT_calling_convention attributes are only meant
19103 to describe functions' calling conventions.
19105 However, because it's a necessary piece of information in
19106 Fortran, and before DWARF 4 DW_CC_program was the only
19107 piece of debugging information whose definition refers to
19108 a 'main program' at all, several compilers marked Fortran
19109 main programs with DW_CC_program --- even when those
19110 functions use the standard calling conventions.
19112 Although DWARF now specifies a way to provide this
19113 information, we support this practice for backward
19115 if (attr
.constant_value (0) == DW_CC_program
19116 && cu
->language
== language_fortran
)
19117 main_subprogram
= 1;
19121 LONGEST value
= attr
.constant_value (-1);
19122 if (value
== DW_INL_inlined
19123 || value
== DW_INL_declared_inlined
)
19124 may_be_inlined
= 1;
19129 if (tag
== DW_TAG_imported_unit
)
19131 d
.sect_off
= attr
.get_ref_die_offset ();
19132 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19133 || cu
->per_cu
->is_dwz
);
19137 case DW_AT_main_subprogram
:
19138 main_subprogram
= attr
.as_boolean ();
19143 /* DW_AT_rnglists_base does not apply to DIEs from the DWO
19144 skeleton. We take advantage of the fact the DW_AT_ranges
19145 does not appear in DW_TAG_compile_unit of DWO files.
19147 Attributes of the form DW_FORM_rnglistx have already had
19148 their value changed by read_rnglist_index and already
19149 include DW_AT_rnglists_base, so don't need to add the ranges
19151 int need_ranges_base
= (tag
!= DW_TAG_compile_unit
19152 && attr
.form
!= DW_FORM_rnglistx
);
19153 /* It would be nice to reuse dwarf2_get_pc_bounds here,
19154 but that requires a full DIE, so instead we just
19156 unsigned int ranges_offset
= (attr
.constant_value (0)
19157 + (need_ranges_base
19161 /* Value of the DW_AT_ranges attribute is the offset in the
19162 .debug_ranges section. */
19163 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
19174 /* For Ada, if both the name and the linkage name appear, we prefer
19175 the latter. This lets "catch exception" work better, regardless
19176 of the order in which the name and linkage name were emitted.
19177 Really, though, this is just a workaround for the fact that gdb
19178 doesn't store both the name and the linkage name. */
19179 if (cu
->language
== language_ada
&& linkage_name
!= nullptr)
19180 raw_name
= linkage_name
;
19182 if (high_pc_relative
)
19185 if (has_low_pc_attr
&& has_high_pc_attr
)
19187 /* When using the GNU linker, .gnu.linkonce. sections are used to
19188 eliminate duplicate copies of functions and vtables and such.
19189 The linker will arbitrarily choose one and discard the others.
19190 The AT_*_pc values for such functions refer to local labels in
19191 these sections. If the section from that file was discarded, the
19192 labels are not in the output, so the relocs get a value of 0.
19193 If this is a discarded function, mark the pc bounds as invalid,
19194 so that GDB will ignore it. */
19195 if (lowpc
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
19197 struct objfile
*objfile
= per_objfile
->objfile
;
19198 struct gdbarch
*gdbarch
= objfile
->arch ();
19200 complaint (_("DW_AT_low_pc %s is zero "
19201 "for DIE at %s [in module %s]"),
19202 paddress (gdbarch
, lowpc
),
19203 sect_offset_str (sect_off
),
19204 objfile_name (objfile
));
19206 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
19207 else if (lowpc
>= highpc
)
19209 struct objfile
*objfile
= per_objfile
->objfile
;
19210 struct gdbarch
*gdbarch
= objfile
->arch ();
19212 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
19213 "for DIE at %s [in module %s]"),
19214 paddress (gdbarch
, lowpc
),
19215 paddress (gdbarch
, highpc
),
19216 sect_offset_str (sect_off
),
19217 objfile_name (objfile
));
19226 /* Find a cached partial DIE at OFFSET in CU. */
19228 struct partial_die_info
*
19229 dwarf2_cu::find_partial_die (sect_offset sect_off
)
19231 struct partial_die_info
*lookup_die
= NULL
;
19232 struct partial_die_info
part_die (sect_off
);
19234 lookup_die
= ((struct partial_die_info
*)
19235 htab_find_with_hash (partial_dies
, &part_die
,
19236 to_underlying (sect_off
)));
19241 /* Find a partial DIE at OFFSET, which may or may not be in CU,
19242 except in the case of .debug_types DIEs which do not reference
19243 outside their CU (they do however referencing other types via
19244 DW_FORM_ref_sig8). */
19246 static const struct cu_partial_die_info
19247 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
19249 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19250 struct objfile
*objfile
= per_objfile
->objfile
;
19251 struct partial_die_info
*pd
= NULL
;
19253 if (offset_in_dwz
== cu
->per_cu
->is_dwz
19254 && cu
->header
.offset_in_cu_p (sect_off
))
19256 pd
= cu
->find_partial_die (sect_off
);
19259 /* We missed recording what we needed.
19260 Load all dies and try again. */
19264 /* TUs don't reference other CUs/TUs (except via type signatures). */
19265 if (cu
->per_cu
->is_debug_types
)
19267 error (_("Dwarf Error: Type Unit at offset %s contains"
19268 " external reference to offset %s [in module %s].\n"),
19269 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
19270 bfd_get_filename (objfile
->obfd
));
19272 dwarf2_per_cu_data
*per_cu
19273 = dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
19276 cu
= per_objfile
->get_cu (per_cu
);
19277 if (cu
== NULL
|| cu
->partial_dies
== NULL
)
19278 load_partial_comp_unit (per_cu
, per_objfile
, nullptr);
19280 cu
= per_objfile
->get_cu (per_cu
);
19283 pd
= cu
->find_partial_die (sect_off
);
19286 /* If we didn't find it, and not all dies have been loaded,
19287 load them all and try again. */
19289 if (pd
== NULL
&& cu
->per_cu
->load_all_dies
== 0)
19291 cu
->per_cu
->load_all_dies
= 1;
19293 /* This is nasty. When we reread the DIEs, somewhere up the call chain
19294 THIS_CU->cu may already be in use. So we can't just free it and
19295 replace its DIEs with the ones we read in. Instead, we leave those
19296 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
19297 and clobber THIS_CU->cu->partial_dies with the hash table for the new
19299 load_partial_comp_unit (cu
->per_cu
, per_objfile
, cu
);
19301 pd
= cu
->find_partial_die (sect_off
);
19305 error (_("Dwarf Error: Cannot not find DIE at %s [from module %s]\n"),
19306 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
19310 /* See if we can figure out if the class lives in a namespace. We do
19311 this by looking for a member function; its demangled name will
19312 contain namespace info, if there is any. */
19315 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
19316 struct dwarf2_cu
*cu
)
19318 /* NOTE: carlton/2003-10-07: Getting the info this way changes
19319 what template types look like, because the demangler
19320 frequently doesn't give the same name as the debug info. We
19321 could fix this by only using the demangled name to get the
19322 prefix (but see comment in read_structure_type). */
19324 struct partial_die_info
*real_pdi
;
19325 struct partial_die_info
*child_pdi
;
19327 /* If this DIE (this DIE's specification, if any) has a parent, then
19328 we should not do this. We'll prepend the parent's fully qualified
19329 name when we create the partial symbol. */
19331 real_pdi
= struct_pdi
;
19332 while (real_pdi
->has_specification
)
19334 auto res
= find_partial_die (real_pdi
->spec_offset
,
19335 real_pdi
->spec_is_dwz
, cu
);
19336 real_pdi
= res
.pdi
;
19340 if (real_pdi
->die_parent
!= NULL
)
19343 for (child_pdi
= struct_pdi
->die_child
;
19345 child_pdi
= child_pdi
->die_sibling
)
19347 if (child_pdi
->tag
== DW_TAG_subprogram
19348 && child_pdi
->linkage_name
!= NULL
)
19350 gdb::unique_xmalloc_ptr
<char> actual_class_name
19351 (cu
->language_defn
->class_name_from_physname
19352 (child_pdi
->linkage_name
));
19353 if (actual_class_name
!= NULL
)
19355 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19356 struct_pdi
->raw_name
= objfile
->intern (actual_class_name
.get ());
19357 struct_pdi
->canonical_name
= 1;
19364 /* Return true if a DIE with TAG may have the DW_AT_const_value
19368 can_have_DW_AT_const_value_p (enum dwarf_tag tag
)
19372 case DW_TAG_constant
:
19373 case DW_TAG_enumerator
:
19374 case DW_TAG_formal_parameter
:
19375 case DW_TAG_template_value_param
:
19376 case DW_TAG_variable
:
19384 partial_die_info::fixup (struct dwarf2_cu
*cu
)
19386 /* Once we've fixed up a die, there's no point in doing so again.
19387 This also avoids a memory leak if we were to call
19388 guess_partial_die_structure_name multiple times. */
19392 /* If we found a reference attribute and the DIE has no name, try
19393 to find a name in the referred to DIE. */
19395 if (raw_name
== NULL
&& has_specification
)
19397 struct partial_die_info
*spec_die
;
19399 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19400 spec_die
= res
.pdi
;
19403 spec_die
->fixup (cu
);
19405 if (spec_die
->raw_name
)
19407 raw_name
= spec_die
->raw_name
;
19408 canonical_name
= spec_die
->canonical_name
;
19410 /* Copy DW_AT_external attribute if it is set. */
19411 if (spec_die
->is_external
)
19412 is_external
= spec_die
->is_external
;
19416 if (!has_const_value
&& has_specification
19417 && can_have_DW_AT_const_value_p (tag
))
19419 struct partial_die_info
*spec_die
;
19421 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19422 spec_die
= res
.pdi
;
19425 spec_die
->fixup (cu
);
19427 if (spec_die
->has_const_value
)
19429 /* Copy DW_AT_const_value attribute if it is set. */
19430 has_const_value
= spec_die
->has_const_value
;
19434 /* Set default names for some unnamed DIEs. */
19436 if (raw_name
== NULL
&& tag
== DW_TAG_namespace
)
19438 raw_name
= CP_ANONYMOUS_NAMESPACE_STR
;
19439 canonical_name
= 1;
19442 /* If there is no parent die to provide a namespace, and there are
19443 children, see if we can determine the namespace from their linkage
19445 if (cu
->language
== language_cplus
19446 && !cu
->per_objfile
->per_bfd
->types
.empty ()
19447 && die_parent
== NULL
19449 && (tag
== DW_TAG_class_type
19450 || tag
== DW_TAG_structure_type
19451 || tag
== DW_TAG_union_type
))
19452 guess_partial_die_structure_name (this, cu
);
19454 /* GCC might emit a nameless struct or union that has a linkage
19455 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19456 if (raw_name
== NULL
19457 && (tag
== DW_TAG_class_type
19458 || tag
== DW_TAG_interface_type
19459 || tag
== DW_TAG_structure_type
19460 || tag
== DW_TAG_union_type
)
19461 && linkage_name
!= NULL
)
19463 gdb::unique_xmalloc_ptr
<char> demangled
19464 (gdb_demangle (linkage_name
, DMGL_TYPES
));
19465 if (demangled
!= nullptr)
19469 /* Strip any leading namespaces/classes, keep only the base name.
19470 DW_AT_name for named DIEs does not contain the prefixes. */
19471 base
= strrchr (demangled
.get (), ':');
19472 if (base
&& base
> demangled
.get () && base
[-1] == ':')
19475 base
= demangled
.get ();
19477 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19478 raw_name
= objfile
->intern (base
);
19479 canonical_name
= 1;
19486 /* Read the .debug_loclists or .debug_rnglists header (they are the same format)
19487 contents from the given SECTION in the HEADER. */
19489 read_loclists_rnglists_header (struct loclists_rnglists_header
*header
,
19490 struct dwarf2_section_info
*section
)
19492 unsigned int bytes_read
;
19493 bfd
*abfd
= section
->get_bfd_owner ();
19494 const gdb_byte
*info_ptr
= section
->buffer
;
19495 header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
19496 info_ptr
+= bytes_read
;
19497 header
->version
= read_2_bytes (abfd
, info_ptr
);
19499 header
->addr_size
= read_1_byte (abfd
, info_ptr
);
19501 header
->segment_collector_size
= read_1_byte (abfd
, info_ptr
);
19503 header
->offset_entry_count
= read_4_bytes (abfd
, info_ptr
);
19506 /* Return the DW_AT_loclists_base value for the CU. */
19508 lookup_loclist_base (struct dwarf2_cu
*cu
)
19510 /* For the .dwo unit, the loclist_base points to the first offset following
19511 the header. The header consists of the following entities-
19512 1. Unit Length (4 bytes for 32 bit DWARF format, and 12 bytes for the 64
19514 2. version (2 bytes)
19515 3. address size (1 byte)
19516 4. segment selector size (1 byte)
19517 5. offset entry count (4 bytes)
19518 These sizes are derived as per the DWARFv5 standard. */
19519 if (cu
->dwo_unit
!= nullptr)
19521 if (cu
->header
.initial_length_size
== 4)
19522 return LOCLIST_HEADER_SIZE32
;
19523 return LOCLIST_HEADER_SIZE64
;
19525 return cu
->loclist_base
;
19528 /* Given a DW_FORM_loclistx value LOCLIST_INDEX, fetch the offset from the
19529 array of offsets in the .debug_loclists section. */
19531 read_loclist_index (struct dwarf2_cu
*cu
, ULONGEST loclist_index
)
19533 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19534 struct objfile
*objfile
= per_objfile
->objfile
;
19535 bfd
*abfd
= objfile
->obfd
;
19536 ULONGEST loclist_base
= lookup_loclist_base (cu
);
19537 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
19539 section
->read (objfile
);
19540 if (section
->buffer
== NULL
)
19541 complaint (_("DW_FORM_loclistx used without .debug_loclists "
19542 "section [in module %s]"), objfile_name (objfile
));
19543 struct loclists_rnglists_header header
;
19544 read_loclists_rnglists_header (&header
, section
);
19545 if (loclist_index
>= header
.offset_entry_count
)
19546 complaint (_("DW_FORM_loclistx pointing outside of "
19547 ".debug_loclists offset array [in module %s]"),
19548 objfile_name (objfile
));
19549 if (loclist_base
+ loclist_index
* cu
->header
.offset_size
19551 complaint (_("DW_FORM_loclistx pointing outside of "
19552 ".debug_loclists section [in module %s]"),
19553 objfile_name (objfile
));
19554 const gdb_byte
*info_ptr
19555 = section
->buffer
+ loclist_base
+ loclist_index
* cu
->header
.offset_size
;
19557 if (cu
->header
.offset_size
== 4)
19558 return bfd_get_32 (abfd
, info_ptr
) + loclist_base
;
19560 return bfd_get_64 (abfd
, info_ptr
) + loclist_base
;
19563 /* Given a DW_FORM_rnglistx value RNGLIST_INDEX, fetch the offset from the
19564 array of offsets in the .debug_rnglists section. */
19566 read_rnglist_index (struct dwarf2_cu
*cu
, ULONGEST rnglist_index
,
19569 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
19570 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19571 bfd
*abfd
= objfile
->obfd
;
19572 ULONGEST rnglist_header_size
=
19573 (cu
->header
.initial_length_size
== 4 ? RNGLIST_HEADER_SIZE32
19574 : RNGLIST_HEADER_SIZE64
);
19575 ULONGEST rnglist_base
=
19576 (cu
->dwo_unit
!= nullptr) ? rnglist_header_size
: cu
->ranges_base
;
19577 ULONGEST start_offset
=
19578 rnglist_base
+ rnglist_index
* cu
->header
.offset_size
;
19580 /* Get rnglists section. */
19581 struct dwarf2_section_info
*section
= cu_debug_rnglists_section (cu
, tag
);
19583 /* Read the rnglists section content. */
19584 section
->read (objfile
);
19585 if (section
->buffer
== nullptr)
19586 error (_("DW_FORM_rnglistx used without .debug_rnglists section "
19588 objfile_name (objfile
));
19590 /* Verify the rnglist index is valid. */
19591 struct loclists_rnglists_header header
;
19592 read_loclists_rnglists_header (&header
, section
);
19593 if (rnglist_index
>= header
.offset_entry_count
)
19594 error (_("DW_FORM_rnglistx index pointing outside of "
19595 ".debug_rnglists offset array [in module %s]"),
19596 objfile_name (objfile
));
19598 /* Validate that the offset is within the section's range. */
19599 if (start_offset
>= section
->size
)
19600 error (_("DW_FORM_rnglistx pointing outside of "
19601 ".debug_rnglists section [in module %s]"),
19602 objfile_name (objfile
));
19604 /* Validate that reading won't go beyond the end of the section. */
19605 if (start_offset
+ cu
->header
.offset_size
> rnglist_base
+ section
->size
)
19606 error (_("Reading DW_FORM_rnglistx index beyond end of"
19607 ".debug_rnglists section [in module %s]"),
19608 objfile_name (objfile
));
19610 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
19612 if (cu
->header
.offset_size
== 4)
19613 return read_4_bytes (abfd
, info_ptr
) + rnglist_base
;
19615 return read_8_bytes (abfd
, info_ptr
) + rnglist_base
;
19618 /* Process the attributes that had to be skipped in the first round. These
19619 attributes are the ones that need str_offsets_base or addr_base attributes.
19620 They could not have been processed in the first round, because at the time
19621 the values of str_offsets_base or addr_base may not have been known. */
19623 read_attribute_reprocess (const struct die_reader_specs
*reader
,
19624 struct attribute
*attr
, dwarf_tag tag
)
19626 struct dwarf2_cu
*cu
= reader
->cu
;
19627 switch (attr
->form
)
19629 case DW_FORM_addrx
:
19630 case DW_FORM_GNU_addr_index
:
19631 attr
->set_address (read_addr_index (cu
,
19632 attr
->as_unsigned_reprocess ()));
19634 case DW_FORM_loclistx
:
19635 attr
->set_address (read_loclist_index (cu
, attr
->as_unsigned ()));
19637 case DW_FORM_rnglistx
:
19638 attr
->set_address (read_rnglist_index (cu
, attr
->as_unsigned (), tag
));
19641 case DW_FORM_strx1
:
19642 case DW_FORM_strx2
:
19643 case DW_FORM_strx3
:
19644 case DW_FORM_strx4
:
19645 case DW_FORM_GNU_str_index
:
19647 unsigned int str_index
= attr
->as_unsigned_reprocess ();
19648 gdb_assert (!attr
->canonical_string_p ());
19649 if (reader
->dwo_file
!= NULL
)
19650 attr
->set_string_noncanonical (read_dwo_str_index (reader
,
19653 attr
->set_string_noncanonical (read_stub_str_index (cu
,
19658 gdb_assert_not_reached (_("Unexpected DWARF form."));
19662 /* Read an attribute value described by an attribute form. */
19664 static const gdb_byte
*
19665 read_attribute_value (const struct die_reader_specs
*reader
,
19666 struct attribute
*attr
, unsigned form
,
19667 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
19669 struct dwarf2_cu
*cu
= reader
->cu
;
19670 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19671 struct objfile
*objfile
= per_objfile
->objfile
;
19672 bfd
*abfd
= reader
->abfd
;
19673 struct comp_unit_head
*cu_header
= &cu
->header
;
19674 unsigned int bytes_read
;
19675 struct dwarf_block
*blk
;
19677 attr
->form
= (enum dwarf_form
) form
;
19680 case DW_FORM_ref_addr
:
19681 if (cu
->header
.version
== 2)
19682 attr
->set_unsigned (cu
->header
.read_address (abfd
, info_ptr
,
19685 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
19687 info_ptr
+= bytes_read
;
19689 case DW_FORM_GNU_ref_alt
:
19690 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
19692 info_ptr
+= bytes_read
;
19696 struct gdbarch
*gdbarch
= objfile
->arch ();
19697 CORE_ADDR addr
= cu
->header
.read_address (abfd
, info_ptr
, &bytes_read
);
19698 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
19699 attr
->set_address (addr
);
19700 info_ptr
+= bytes_read
;
19703 case DW_FORM_block2
:
19704 blk
= dwarf_alloc_block (cu
);
19705 blk
->size
= read_2_bytes (abfd
, info_ptr
);
19707 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19708 info_ptr
+= blk
->size
;
19709 attr
->set_block (blk
);
19711 case DW_FORM_block4
:
19712 blk
= dwarf_alloc_block (cu
);
19713 blk
->size
= read_4_bytes (abfd
, info_ptr
);
19715 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19716 info_ptr
+= blk
->size
;
19717 attr
->set_block (blk
);
19719 case DW_FORM_data2
:
19720 attr
->set_unsigned (read_2_bytes (abfd
, info_ptr
));
19723 case DW_FORM_data4
:
19724 attr
->set_unsigned (read_4_bytes (abfd
, info_ptr
));
19727 case DW_FORM_data8
:
19728 attr
->set_unsigned (read_8_bytes (abfd
, info_ptr
));
19731 case DW_FORM_data16
:
19732 blk
= dwarf_alloc_block (cu
);
19734 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
19736 attr
->set_block (blk
);
19738 case DW_FORM_sec_offset
:
19739 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
19741 info_ptr
+= bytes_read
;
19743 case DW_FORM_loclistx
:
19745 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
19747 info_ptr
+= bytes_read
;
19750 case DW_FORM_string
:
19751 attr
->set_string_noncanonical (read_direct_string (abfd
, info_ptr
,
19753 info_ptr
+= bytes_read
;
19756 if (!cu
->per_cu
->is_dwz
)
19758 attr
->set_string_noncanonical
19759 (read_indirect_string (per_objfile
,
19760 abfd
, info_ptr
, cu_header
,
19762 info_ptr
+= bytes_read
;
19766 case DW_FORM_line_strp
:
19767 if (!cu
->per_cu
->is_dwz
)
19769 attr
->set_string_noncanonical
19770 (per_objfile
->read_line_string (info_ptr
, cu_header
,
19772 info_ptr
+= bytes_read
;
19776 case DW_FORM_GNU_strp_alt
:
19778 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
19779 LONGEST str_offset
= cu_header
->read_offset (abfd
, info_ptr
,
19782 attr
->set_string_noncanonical
19783 (dwz
->read_string (objfile
, str_offset
));
19784 info_ptr
+= bytes_read
;
19787 case DW_FORM_exprloc
:
19788 case DW_FORM_block
:
19789 blk
= dwarf_alloc_block (cu
);
19790 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19791 info_ptr
+= bytes_read
;
19792 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19793 info_ptr
+= blk
->size
;
19794 attr
->set_block (blk
);
19796 case DW_FORM_block1
:
19797 blk
= dwarf_alloc_block (cu
);
19798 blk
->size
= read_1_byte (abfd
, info_ptr
);
19800 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19801 info_ptr
+= blk
->size
;
19802 attr
->set_block (blk
);
19804 case DW_FORM_data1
:
19806 attr
->set_unsigned (read_1_byte (abfd
, info_ptr
));
19809 case DW_FORM_flag_present
:
19810 attr
->set_unsigned (1);
19812 case DW_FORM_sdata
:
19813 attr
->set_signed (read_signed_leb128 (abfd
, info_ptr
, &bytes_read
));
19814 info_ptr
+= bytes_read
;
19816 case DW_FORM_rnglistx
:
19818 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
19820 info_ptr
+= bytes_read
;
19823 case DW_FORM_udata
:
19824 attr
->set_unsigned (read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
19825 info_ptr
+= bytes_read
;
19828 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
19829 + read_1_byte (abfd
, info_ptr
)));
19833 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
19834 + read_2_bytes (abfd
, info_ptr
)));
19838 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
19839 + read_4_bytes (abfd
, info_ptr
)));
19843 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
19844 + read_8_bytes (abfd
, info_ptr
)));
19847 case DW_FORM_ref_sig8
:
19848 attr
->set_signature (read_8_bytes (abfd
, info_ptr
));
19851 case DW_FORM_ref_udata
:
19852 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
19853 + read_unsigned_leb128 (abfd
, info_ptr
,
19855 info_ptr
+= bytes_read
;
19857 case DW_FORM_indirect
:
19858 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19859 info_ptr
+= bytes_read
;
19860 if (form
== DW_FORM_implicit_const
)
19862 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19863 info_ptr
+= bytes_read
;
19865 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
19868 case DW_FORM_implicit_const
:
19869 attr
->set_signed (implicit_const
);
19871 case DW_FORM_addrx
:
19872 case DW_FORM_GNU_addr_index
:
19873 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
19875 info_ptr
+= bytes_read
;
19878 case DW_FORM_strx1
:
19879 case DW_FORM_strx2
:
19880 case DW_FORM_strx3
:
19881 case DW_FORM_strx4
:
19882 case DW_FORM_GNU_str_index
:
19884 ULONGEST str_index
;
19885 if (form
== DW_FORM_strx1
)
19887 str_index
= read_1_byte (abfd
, info_ptr
);
19890 else if (form
== DW_FORM_strx2
)
19892 str_index
= read_2_bytes (abfd
, info_ptr
);
19895 else if (form
== DW_FORM_strx3
)
19897 str_index
= read_3_bytes (abfd
, info_ptr
);
19900 else if (form
== DW_FORM_strx4
)
19902 str_index
= read_4_bytes (abfd
, info_ptr
);
19907 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19908 info_ptr
+= bytes_read
;
19910 attr
->set_unsigned_reprocess (str_index
);
19914 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19915 dwarf_form_name (form
),
19916 bfd_get_filename (abfd
));
19920 if (cu
->per_cu
->is_dwz
&& attr
->form_is_ref ())
19921 attr
->form
= DW_FORM_GNU_ref_alt
;
19923 /* We have seen instances where the compiler tried to emit a byte
19924 size attribute of -1 which ended up being encoded as an unsigned
19925 0xffffffff. Although 0xffffffff is technically a valid size value,
19926 an object of this size seems pretty unlikely so we can relatively
19927 safely treat these cases as if the size attribute was invalid and
19928 treat them as zero by default. */
19929 if (attr
->name
== DW_AT_byte_size
19930 && form
== DW_FORM_data4
19931 && attr
->as_unsigned () >= 0xffffffff)
19934 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19935 hex_string (attr
->as_unsigned ()));
19936 attr
->set_unsigned (0);
19942 /* Read an attribute described by an abbreviated attribute. */
19944 static const gdb_byte
*
19945 read_attribute (const struct die_reader_specs
*reader
,
19946 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
19947 const gdb_byte
*info_ptr
)
19949 attr
->name
= abbrev
->name
;
19950 attr
->string_is_canonical
= 0;
19951 attr
->requires_reprocessing
= 0;
19952 return read_attribute_value (reader
, attr
, abbrev
->form
,
19953 abbrev
->implicit_const
, info_ptr
);
19956 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19958 static const char *
19959 read_indirect_string_at_offset (dwarf2_per_objfile
*per_objfile
,
19960 LONGEST str_offset
)
19962 return per_objfile
->per_bfd
->str
.read_string (per_objfile
->objfile
,
19963 str_offset
, "DW_FORM_strp");
19966 /* Return pointer to string at .debug_str offset as read from BUF.
19967 BUF is assumed to be in a compilation unit described by CU_HEADER.
19968 Return *BYTES_READ_PTR count of bytes read from BUF. */
19970 static const char *
19971 read_indirect_string (dwarf2_per_objfile
*per_objfile
, bfd
*abfd
,
19972 const gdb_byte
*buf
,
19973 const struct comp_unit_head
*cu_header
,
19974 unsigned int *bytes_read_ptr
)
19976 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
19978 return read_indirect_string_at_offset (per_objfile
, str_offset
);
19984 dwarf2_per_objfile::read_line_string (const gdb_byte
*buf
,
19985 const struct comp_unit_head
*cu_header
,
19986 unsigned int *bytes_read_ptr
)
19988 bfd
*abfd
= objfile
->obfd
;
19989 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
19991 return per_bfd
->line_str
.read_string (objfile
, str_offset
, "DW_FORM_line_strp");
19994 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19995 ADDR_BASE is the DW_AT_addr_base (DW_AT_GNU_addr_base) attribute or zero.
19996 ADDR_SIZE is the size of addresses from the CU header. */
19999 read_addr_index_1 (dwarf2_per_objfile
*per_objfile
, unsigned int addr_index
,
20000 gdb::optional
<ULONGEST
> addr_base
, int addr_size
)
20002 struct objfile
*objfile
= per_objfile
->objfile
;
20003 bfd
*abfd
= objfile
->obfd
;
20004 const gdb_byte
*info_ptr
;
20005 ULONGEST addr_base_or_zero
= addr_base
.has_value () ? *addr_base
: 0;
20007 per_objfile
->per_bfd
->addr
.read (objfile
);
20008 if (per_objfile
->per_bfd
->addr
.buffer
== NULL
)
20009 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
20010 objfile_name (objfile
));
20011 if (addr_base_or_zero
+ addr_index
* addr_size
20012 >= per_objfile
->per_bfd
->addr
.size
)
20013 error (_("DW_FORM_addr_index pointing outside of "
20014 ".debug_addr section [in module %s]"),
20015 objfile_name (objfile
));
20016 info_ptr
= (per_objfile
->per_bfd
->addr
.buffer
+ addr_base_or_zero
20017 + addr_index
* addr_size
);
20018 if (addr_size
== 4)
20019 return bfd_get_32 (abfd
, info_ptr
);
20021 return bfd_get_64 (abfd
, info_ptr
);
20024 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
20027 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
20029 return read_addr_index_1 (cu
->per_objfile
, addr_index
,
20030 cu
->addr_base
, cu
->header
.addr_size
);
20033 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
20036 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
20037 unsigned int *bytes_read
)
20039 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
20040 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
20042 return read_addr_index (cu
, addr_index
);
20048 dwarf2_read_addr_index (dwarf2_per_cu_data
*per_cu
,
20049 dwarf2_per_objfile
*per_objfile
,
20050 unsigned int addr_index
)
20052 struct dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
20053 gdb::optional
<ULONGEST
> addr_base
;
20056 /* We need addr_base and addr_size.
20057 If we don't have PER_CU->cu, we have to get it.
20058 Nasty, but the alternative is storing the needed info in PER_CU,
20059 which at this point doesn't seem justified: it's not clear how frequently
20060 it would get used and it would increase the size of every PER_CU.
20061 Entry points like dwarf2_per_cu_addr_size do a similar thing
20062 so we're not in uncharted territory here.
20063 Alas we need to be a bit more complicated as addr_base is contained
20066 We don't need to read the entire CU(/TU).
20067 We just need the header and top level die.
20069 IWBN to use the aging mechanism to let us lazily later discard the CU.
20070 For now we skip this optimization. */
20074 addr_base
= cu
->addr_base
;
20075 addr_size
= cu
->header
.addr_size
;
20079 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
20080 addr_base
= reader
.cu
->addr_base
;
20081 addr_size
= reader
.cu
->header
.addr_size
;
20084 return read_addr_index_1 (per_objfile
, addr_index
, addr_base
, addr_size
);
20087 /* Given a DW_FORM_GNU_str_index value STR_INDEX, fetch the string.
20088 STR_SECTION, STR_OFFSETS_SECTION can be from a Fission stub or a
20091 static const char *
20092 read_str_index (struct dwarf2_cu
*cu
,
20093 struct dwarf2_section_info
*str_section
,
20094 struct dwarf2_section_info
*str_offsets_section
,
20095 ULONGEST str_offsets_base
, ULONGEST str_index
)
20097 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20098 struct objfile
*objfile
= per_objfile
->objfile
;
20099 const char *objf_name
= objfile_name (objfile
);
20100 bfd
*abfd
= objfile
->obfd
;
20101 const gdb_byte
*info_ptr
;
20102 ULONGEST str_offset
;
20103 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
20105 str_section
->read (objfile
);
20106 str_offsets_section
->read (objfile
);
20107 if (str_section
->buffer
== NULL
)
20108 error (_("%s used without %s section"
20109 " in CU at offset %s [in module %s]"),
20110 form_name
, str_section
->get_name (),
20111 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20112 if (str_offsets_section
->buffer
== NULL
)
20113 error (_("%s used without %s section"
20114 " in CU at offset %s [in module %s]"),
20115 form_name
, str_section
->get_name (),
20116 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20117 info_ptr
= (str_offsets_section
->buffer
20119 + str_index
* cu
->header
.offset_size
);
20120 if (cu
->header
.offset_size
== 4)
20121 str_offset
= bfd_get_32 (abfd
, info_ptr
);
20123 str_offset
= bfd_get_64 (abfd
, info_ptr
);
20124 if (str_offset
>= str_section
->size
)
20125 error (_("Offset from %s pointing outside of"
20126 " .debug_str.dwo section in CU at offset %s [in module %s]"),
20127 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20128 return (const char *) (str_section
->buffer
+ str_offset
);
20131 /* Given a DW_FORM_GNU_str_index from a DWO file, fetch the string. */
20133 static const char *
20134 read_dwo_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
20136 ULONGEST str_offsets_base
= reader
->cu
->header
.version
>= 5
20137 ? reader
->cu
->header
.addr_size
: 0;
20138 return read_str_index (reader
->cu
,
20139 &reader
->dwo_file
->sections
.str
,
20140 &reader
->dwo_file
->sections
.str_offsets
,
20141 str_offsets_base
, str_index
);
20144 /* Given a DW_FORM_GNU_str_index from a Fission stub, fetch the string. */
20146 static const char *
20147 read_stub_str_index (struct dwarf2_cu
*cu
, ULONGEST str_index
)
20149 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20150 const char *objf_name
= objfile_name (objfile
);
20151 static const char form_name
[] = "DW_FORM_GNU_str_index";
20152 static const char str_offsets_attr_name
[] = "DW_AT_str_offsets";
20154 if (!cu
->str_offsets_base
.has_value ())
20155 error (_("%s used in Fission stub without %s"
20156 " in CU at offset 0x%lx [in module %s]"),
20157 form_name
, str_offsets_attr_name
,
20158 (long) cu
->header
.offset_size
, objf_name
);
20160 return read_str_index (cu
,
20161 &cu
->per_objfile
->per_bfd
->str
,
20162 &cu
->per_objfile
->per_bfd
->str_offsets
,
20163 *cu
->str_offsets_base
, str_index
);
20166 /* Return the length of an LEB128 number in BUF. */
20169 leb128_size (const gdb_byte
*buf
)
20171 const gdb_byte
*begin
= buf
;
20177 if ((byte
& 128) == 0)
20178 return buf
- begin
;
20183 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
20192 cu
->language
= language_c
;
20195 case DW_LANG_C_plus_plus
:
20196 case DW_LANG_C_plus_plus_11
:
20197 case DW_LANG_C_plus_plus_14
:
20198 cu
->language
= language_cplus
;
20201 cu
->language
= language_d
;
20203 case DW_LANG_Fortran77
:
20204 case DW_LANG_Fortran90
:
20205 case DW_LANG_Fortran95
:
20206 case DW_LANG_Fortran03
:
20207 case DW_LANG_Fortran08
:
20208 cu
->language
= language_fortran
;
20211 cu
->language
= language_go
;
20213 case DW_LANG_Mips_Assembler
:
20214 cu
->language
= language_asm
;
20216 case DW_LANG_Ada83
:
20217 case DW_LANG_Ada95
:
20218 cu
->language
= language_ada
;
20220 case DW_LANG_Modula2
:
20221 cu
->language
= language_m2
;
20223 case DW_LANG_Pascal83
:
20224 cu
->language
= language_pascal
;
20227 cu
->language
= language_objc
;
20230 case DW_LANG_Rust_old
:
20231 cu
->language
= language_rust
;
20233 case DW_LANG_Cobol74
:
20234 case DW_LANG_Cobol85
:
20236 cu
->language
= language_minimal
;
20239 cu
->language_defn
= language_def (cu
->language
);
20242 /* Return the named attribute or NULL if not there. */
20244 static struct attribute
*
20245 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20250 struct attribute
*spec
= NULL
;
20252 for (i
= 0; i
< die
->num_attrs
; ++i
)
20254 if (die
->attrs
[i
].name
== name
)
20255 return &die
->attrs
[i
];
20256 if (die
->attrs
[i
].name
== DW_AT_specification
20257 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
20258 spec
= &die
->attrs
[i
];
20264 die
= follow_die_ref (die
, spec
, &cu
);
20270 /* Return the string associated with a string-typed attribute, or NULL if it
20271 is either not found or is of an incorrect type. */
20273 static const char *
20274 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20276 struct attribute
*attr
;
20277 const char *str
= NULL
;
20279 attr
= dwarf2_attr (die
, name
, cu
);
20283 str
= attr
->as_string ();
20284 if (str
== nullptr)
20285 complaint (_("string type expected for attribute %s for "
20286 "DIE at %s in module %s"),
20287 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
20288 objfile_name (cu
->per_objfile
->objfile
));
20294 /* Return the dwo name or NULL if not present. If present, it is in either
20295 DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute. */
20296 static const char *
20297 dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
20299 const char *dwo_name
= dwarf2_string_attr (die
, DW_AT_GNU_dwo_name
, cu
);
20300 if (dwo_name
== nullptr)
20301 dwo_name
= dwarf2_string_attr (die
, DW_AT_dwo_name
, cu
);
20305 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20306 and holds a non-zero value. This function should only be used for
20307 DW_FORM_flag or DW_FORM_flag_present attributes. */
20310 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
20312 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
20314 return attr
!= nullptr && attr
->as_boolean ();
20318 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
20320 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20321 which value is non-zero. However, we have to be careful with
20322 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20323 (via dwarf2_flag_true_p) follows this attribute. So we may
20324 end up accidently finding a declaration attribute that belongs
20325 to a different DIE referenced by the specification attribute,
20326 even though the given DIE does not have a declaration attribute. */
20327 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
20328 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
20331 /* Return the die giving the specification for DIE, if there is
20332 one. *SPEC_CU is the CU containing DIE on input, and the CU
20333 containing the return value on output. If there is no
20334 specification, but there is an abstract origin, that is
20337 static struct die_info
*
20338 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
20340 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
20343 if (spec_attr
== NULL
)
20344 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
20346 if (spec_attr
== NULL
)
20349 return follow_die_ref (die
, spec_attr
, spec_cu
);
20352 /* Stub for free_line_header to match void * callback types. */
20355 free_line_header_voidp (void *arg
)
20357 struct line_header
*lh
= (struct line_header
*) arg
;
20362 /* A convenience function to find the proper .debug_line section for a CU. */
20364 static struct dwarf2_section_info
*
20365 get_debug_line_section (struct dwarf2_cu
*cu
)
20367 struct dwarf2_section_info
*section
;
20368 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20370 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20372 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20373 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
20374 else if (cu
->per_cu
->is_dwz
)
20376 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
20378 section
= &dwz
->line
;
20381 section
= &per_objfile
->per_bfd
->line
;
20386 /* Read the statement program header starting at OFFSET in
20387 .debug_line, or .debug_line.dwo. Return a pointer
20388 to a struct line_header, allocated using xmalloc.
20389 Returns NULL if there is a problem reading the header, e.g., if it
20390 has a version we don't understand.
20392 NOTE: the strings in the include directory and file name tables of
20393 the returned object point into the dwarf line section buffer,
20394 and must not be freed. */
20396 static line_header_up
20397 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
20399 struct dwarf2_section_info
*section
;
20400 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20402 section
= get_debug_line_section (cu
);
20403 section
->read (per_objfile
->objfile
);
20404 if (section
->buffer
== NULL
)
20406 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20407 complaint (_("missing .debug_line.dwo section"));
20409 complaint (_("missing .debug_line section"));
20413 return dwarf_decode_line_header (sect_off
, cu
->per_cu
->is_dwz
,
20414 per_objfile
, section
, &cu
->header
);
20417 /* Subroutine of dwarf_decode_lines to simplify it.
20418 Return the file name of the psymtab for the given file_entry.
20419 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20420 If space for the result is malloc'd, *NAME_HOLDER will be set.
20421 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20423 static const char *
20424 psymtab_include_file_name (const struct line_header
*lh
, const file_entry
&fe
,
20425 const dwarf2_psymtab
*pst
,
20426 const char *comp_dir
,
20427 gdb::unique_xmalloc_ptr
<char> *name_holder
)
20429 const char *include_name
= fe
.name
;
20430 const char *include_name_to_compare
= include_name
;
20431 const char *pst_filename
;
20434 const char *dir_name
= fe
.include_dir (lh
);
20436 gdb::unique_xmalloc_ptr
<char> hold_compare
;
20437 if (!IS_ABSOLUTE_PATH (include_name
)
20438 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
20440 /* Avoid creating a duplicate psymtab for PST.
20441 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20442 Before we do the comparison, however, we need to account
20443 for DIR_NAME and COMP_DIR.
20444 First prepend dir_name (if non-NULL). If we still don't
20445 have an absolute path prepend comp_dir (if non-NULL).
20446 However, the directory we record in the include-file's
20447 psymtab does not contain COMP_DIR (to match the
20448 corresponding symtab(s)).
20453 bash$ gcc -g ./hello.c
20454 include_name = "hello.c"
20456 DW_AT_comp_dir = comp_dir = "/tmp"
20457 DW_AT_name = "./hello.c"
20461 if (dir_name
!= NULL
)
20463 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
20464 include_name
, (char *) NULL
));
20465 include_name
= name_holder
->get ();
20466 include_name_to_compare
= include_name
;
20468 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
20470 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
20471 include_name
, (char *) NULL
));
20472 include_name_to_compare
= hold_compare
.get ();
20476 pst_filename
= pst
->filename
;
20477 gdb::unique_xmalloc_ptr
<char> copied_name
;
20478 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
20480 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
20481 pst_filename
, (char *) NULL
));
20482 pst_filename
= copied_name
.get ();
20485 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
20489 return include_name
;
20492 /* State machine to track the state of the line number program. */
20494 class lnp_state_machine
20497 /* Initialize a machine state for the start of a line number
20499 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
20500 bool record_lines_p
);
20502 file_entry
*current_file ()
20504 /* lh->file_names is 0-based, but the file name numbers in the
20505 statement program are 1-based. */
20506 return m_line_header
->file_name_at (m_file
);
20509 /* Record the line in the state machine. END_SEQUENCE is true if
20510 we're processing the end of a sequence. */
20511 void record_line (bool end_sequence
);
20513 /* Check ADDRESS is -1, or zero and less than UNRELOCATED_LOWPC, and if true
20514 nop-out rest of the lines in this sequence. */
20515 void check_line_address (struct dwarf2_cu
*cu
,
20516 const gdb_byte
*line_ptr
,
20517 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
20519 void handle_set_discriminator (unsigned int discriminator
)
20521 m_discriminator
= discriminator
;
20522 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
20525 /* Handle DW_LNE_set_address. */
20526 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
20529 address
+= baseaddr
;
20530 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
20533 /* Handle DW_LNS_advance_pc. */
20534 void handle_advance_pc (CORE_ADDR adjust
);
20536 /* Handle a special opcode. */
20537 void handle_special_opcode (unsigned char op_code
);
20539 /* Handle DW_LNS_advance_line. */
20540 void handle_advance_line (int line_delta
)
20542 advance_line (line_delta
);
20545 /* Handle DW_LNS_set_file. */
20546 void handle_set_file (file_name_index file
);
20548 /* Handle DW_LNS_negate_stmt. */
20549 void handle_negate_stmt ()
20551 m_is_stmt
= !m_is_stmt
;
20554 /* Handle DW_LNS_const_add_pc. */
20555 void handle_const_add_pc ();
20557 /* Handle DW_LNS_fixed_advance_pc. */
20558 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
20560 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20564 /* Handle DW_LNS_copy. */
20565 void handle_copy ()
20567 record_line (false);
20568 m_discriminator
= 0;
20571 /* Handle DW_LNE_end_sequence. */
20572 void handle_end_sequence ()
20574 m_currently_recording_lines
= true;
20578 /* Advance the line by LINE_DELTA. */
20579 void advance_line (int line_delta
)
20581 m_line
+= line_delta
;
20583 if (line_delta
!= 0)
20584 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20587 struct dwarf2_cu
*m_cu
;
20589 gdbarch
*m_gdbarch
;
20591 /* True if we're recording lines.
20592 Otherwise we're building partial symtabs and are just interested in
20593 finding include files mentioned by the line number program. */
20594 bool m_record_lines_p
;
20596 /* The line number header. */
20597 line_header
*m_line_header
;
20599 /* These are part of the standard DWARF line number state machine,
20600 and initialized according to the DWARF spec. */
20602 unsigned char m_op_index
= 0;
20603 /* The line table index of the current file. */
20604 file_name_index m_file
= 1;
20605 unsigned int m_line
= 1;
20607 /* These are initialized in the constructor. */
20609 CORE_ADDR m_address
;
20611 unsigned int m_discriminator
;
20613 /* Additional bits of state we need to track. */
20615 /* The last file that we called dwarf2_start_subfile for.
20616 This is only used for TLLs. */
20617 unsigned int m_last_file
= 0;
20618 /* The last file a line number was recorded for. */
20619 struct subfile
*m_last_subfile
= NULL
;
20621 /* The address of the last line entry. */
20622 CORE_ADDR m_last_address
;
20624 /* Set to true when a previous line at the same address (using
20625 m_last_address) had m_is_stmt true. This is reset to false when a
20626 line entry at a new address (m_address different to m_last_address) is
20628 bool m_stmt_at_address
= false;
20630 /* When true, record the lines we decode. */
20631 bool m_currently_recording_lines
= false;
20633 /* The last line number that was recorded, used to coalesce
20634 consecutive entries for the same line. This can happen, for
20635 example, when discriminators are present. PR 17276. */
20636 unsigned int m_last_line
= 0;
20637 bool m_line_has_non_zero_discriminator
= false;
20641 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
20643 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
20644 / m_line_header
->maximum_ops_per_instruction
)
20645 * m_line_header
->minimum_instruction_length
);
20646 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20647 m_op_index
= ((m_op_index
+ adjust
)
20648 % m_line_header
->maximum_ops_per_instruction
);
20652 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
20654 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
20655 unsigned char adj_opcode_d
= adj_opcode
/ m_line_header
->line_range
;
20656 unsigned char adj_opcode_r
= adj_opcode
% m_line_header
->line_range
;
20657 CORE_ADDR addr_adj
= (((m_op_index
+ adj_opcode_d
)
20658 / m_line_header
->maximum_ops_per_instruction
)
20659 * m_line_header
->minimum_instruction_length
);
20660 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20661 m_op_index
= ((m_op_index
+ adj_opcode_d
)
20662 % m_line_header
->maximum_ops_per_instruction
);
20664 int line_delta
= m_line_header
->line_base
+ adj_opcode_r
;
20665 advance_line (line_delta
);
20666 record_line (false);
20667 m_discriminator
= 0;
20671 lnp_state_machine::handle_set_file (file_name_index file
)
20675 const file_entry
*fe
= current_file ();
20677 dwarf2_debug_line_missing_file_complaint ();
20678 else if (m_record_lines_p
)
20680 const char *dir
= fe
->include_dir (m_line_header
);
20682 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20683 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20684 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
20689 lnp_state_machine::handle_const_add_pc ()
20692 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
20695 = (((m_op_index
+ adjust
)
20696 / m_line_header
->maximum_ops_per_instruction
)
20697 * m_line_header
->minimum_instruction_length
);
20699 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20700 m_op_index
= ((m_op_index
+ adjust
)
20701 % m_line_header
->maximum_ops_per_instruction
);
20704 /* Return non-zero if we should add LINE to the line number table.
20705 LINE is the line to add, LAST_LINE is the last line that was added,
20706 LAST_SUBFILE is the subfile for LAST_LINE.
20707 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20708 had a non-zero discriminator.
20710 We have to be careful in the presence of discriminators.
20711 E.g., for this line:
20713 for (i = 0; i < 100000; i++);
20715 clang can emit four line number entries for that one line,
20716 each with a different discriminator.
20717 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20719 However, we want gdb to coalesce all four entries into one.
20720 Otherwise the user could stepi into the middle of the line and
20721 gdb would get confused about whether the pc really was in the
20722 middle of the line.
20724 Things are further complicated by the fact that two consecutive
20725 line number entries for the same line is a heuristic used by gcc
20726 to denote the end of the prologue. So we can't just discard duplicate
20727 entries, we have to be selective about it. The heuristic we use is
20728 that we only collapse consecutive entries for the same line if at least
20729 one of those entries has a non-zero discriminator. PR 17276.
20731 Note: Addresses in the line number state machine can never go backwards
20732 within one sequence, thus this coalescing is ok. */
20735 dwarf_record_line_p (struct dwarf2_cu
*cu
,
20736 unsigned int line
, unsigned int last_line
,
20737 int line_has_non_zero_discriminator
,
20738 struct subfile
*last_subfile
)
20740 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
20742 if (line
!= last_line
)
20744 /* Same line for the same file that we've seen already.
20745 As a last check, for pr 17276, only record the line if the line
20746 has never had a non-zero discriminator. */
20747 if (!line_has_non_zero_discriminator
)
20752 /* Use the CU's builder to record line number LINE beginning at
20753 address ADDRESS in the line table of subfile SUBFILE. */
20756 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20757 unsigned int line
, CORE_ADDR address
, bool is_stmt
,
20758 struct dwarf2_cu
*cu
)
20760 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
20762 if (dwarf_line_debug
)
20764 fprintf_unfiltered (gdb_stdlog
,
20765 "Recording line %u, file %s, address %s\n",
20766 line
, lbasename (subfile
->name
),
20767 paddress (gdbarch
, address
));
20771 cu
->get_builder ()->record_line (subfile
, line
, addr
, is_stmt
);
20774 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20775 Mark the end of a set of line number records.
20776 The arguments are the same as for dwarf_record_line_1.
20777 If SUBFILE is NULL the request is ignored. */
20780 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20781 CORE_ADDR address
, struct dwarf2_cu
*cu
)
20783 if (subfile
== NULL
)
20786 if (dwarf_line_debug
)
20788 fprintf_unfiltered (gdb_stdlog
,
20789 "Finishing current line, file %s, address %s\n",
20790 lbasename (subfile
->name
),
20791 paddress (gdbarch
, address
));
20794 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, true, cu
);
20798 lnp_state_machine::record_line (bool end_sequence
)
20800 if (dwarf_line_debug
)
20802 fprintf_unfiltered (gdb_stdlog
,
20803 "Processing actual line %u: file %u,"
20804 " address %s, is_stmt %u, discrim %u%s\n",
20806 paddress (m_gdbarch
, m_address
),
20807 m_is_stmt
, m_discriminator
,
20808 (end_sequence
? "\t(end sequence)" : ""));
20811 file_entry
*fe
= current_file ();
20814 dwarf2_debug_line_missing_file_complaint ();
20815 /* For now we ignore lines not starting on an instruction boundary.
20816 But not when processing end_sequence for compatibility with the
20817 previous version of the code. */
20818 else if (m_op_index
== 0 || end_sequence
)
20820 fe
->included_p
= 1;
20821 if (m_record_lines_p
)
20823 /* When we switch files we insert an end maker in the first file,
20824 switch to the second file and add a new line entry. The
20825 problem is that the end marker inserted in the first file will
20826 discard any previous line entries at the same address. If the
20827 line entries in the first file are marked as is-stmt, while
20828 the new line in the second file is non-stmt, then this means
20829 the end marker will discard is-stmt lines so we can have a
20830 non-stmt line. This means that there are less addresses at
20831 which the user can insert a breakpoint.
20833 To improve this we track the last address in m_last_address,
20834 and whether we have seen an is-stmt at this address. Then
20835 when switching files, if we have seen a stmt at the current
20836 address, and we are switching to create a non-stmt line, then
20837 discard the new line. */
20839 = m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ();
20840 bool ignore_this_line
20841 = ((file_changed
&& !end_sequence
&& m_last_address
== m_address
20842 && !m_is_stmt
&& m_stmt_at_address
)
20843 || (!end_sequence
&& m_line
== 0));
20845 if ((file_changed
&& !ignore_this_line
) || end_sequence
)
20847 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
20848 m_currently_recording_lines
? m_cu
: nullptr);
20851 if (!end_sequence
&& !ignore_this_line
)
20853 bool is_stmt
= producer_is_codewarrior (m_cu
) || m_is_stmt
;
20855 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
20856 m_line_has_non_zero_discriminator
,
20859 buildsym_compunit
*builder
= m_cu
->get_builder ();
20860 dwarf_record_line_1 (m_gdbarch
,
20861 builder
->get_current_subfile (),
20862 m_line
, m_address
, is_stmt
,
20863 m_currently_recording_lines
? m_cu
: nullptr);
20865 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20866 m_last_line
= m_line
;
20871 /* Track whether we have seen any m_is_stmt true at m_address in case we
20872 have multiple line table entries all at m_address. */
20873 if (m_last_address
!= m_address
)
20875 m_stmt_at_address
= false;
20876 m_last_address
= m_address
;
20878 m_stmt_at_address
|= m_is_stmt
;
20881 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
20882 line_header
*lh
, bool record_lines_p
)
20886 m_record_lines_p
= record_lines_p
;
20887 m_line_header
= lh
;
20889 m_currently_recording_lines
= true;
20891 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20892 was a line entry for it so that the backend has a chance to adjust it
20893 and also record it in case it needs it. This is currently used by MIPS
20894 code, cf. `mips_adjust_dwarf2_line'. */
20895 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
20896 m_is_stmt
= lh
->default_is_stmt
;
20897 m_discriminator
= 0;
20899 m_last_address
= m_address
;
20900 m_stmt_at_address
= false;
20904 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
20905 const gdb_byte
*line_ptr
,
20906 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
20908 /* Linkers resolve a symbolic relocation referencing a GC'd function to 0 or
20909 -1. If ADDRESS is 0, ignoring the opcode will err if the text section is
20910 located at 0x0. In this case, additionally check that if
20911 ADDRESS < UNRELOCATED_LOWPC. */
20913 if ((address
== 0 && address
< unrelocated_lowpc
)
20914 || address
== (CORE_ADDR
) -1)
20916 /* This line table is for a function which has been
20917 GCd by the linker. Ignore it. PR gdb/12528 */
20919 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20920 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
20922 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20923 line_offset
, objfile_name (objfile
));
20924 m_currently_recording_lines
= false;
20925 /* Note: m_currently_recording_lines is left as false until we see
20926 DW_LNE_end_sequence. */
20930 /* Subroutine of dwarf_decode_lines to simplify it.
20931 Process the line number information in LH.
20932 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20933 program in order to set included_p for every referenced header. */
20936 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
20937 const int decode_for_pst_p
, CORE_ADDR lowpc
)
20939 const gdb_byte
*line_ptr
, *extended_end
;
20940 const gdb_byte
*line_end
;
20941 unsigned int bytes_read
, extended_len
;
20942 unsigned char op_code
, extended_op
;
20943 CORE_ADDR baseaddr
;
20944 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20945 bfd
*abfd
= objfile
->obfd
;
20946 struct gdbarch
*gdbarch
= objfile
->arch ();
20947 /* True if we're recording line info (as opposed to building partial
20948 symtabs and just interested in finding include files mentioned by
20949 the line number program). */
20950 bool record_lines_p
= !decode_for_pst_p
;
20952 baseaddr
= objfile
->text_section_offset ();
20954 line_ptr
= lh
->statement_program_start
;
20955 line_end
= lh
->statement_program_end
;
20957 /* Read the statement sequences until there's nothing left. */
20958 while (line_ptr
< line_end
)
20960 /* The DWARF line number program state machine. Reset the state
20961 machine at the start of each sequence. */
20962 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
20963 bool end_sequence
= false;
20965 if (record_lines_p
)
20967 /* Start a subfile for the current file of the state
20969 const file_entry
*fe
= state_machine
.current_file ();
20972 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
20975 /* Decode the table. */
20976 while (line_ptr
< line_end
&& !end_sequence
)
20978 op_code
= read_1_byte (abfd
, line_ptr
);
20981 if (op_code
>= lh
->opcode_base
)
20983 /* Special opcode. */
20984 state_machine
.handle_special_opcode (op_code
);
20986 else switch (op_code
)
20988 case DW_LNS_extended_op
:
20989 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
20991 line_ptr
+= bytes_read
;
20992 extended_end
= line_ptr
+ extended_len
;
20993 extended_op
= read_1_byte (abfd
, line_ptr
);
20995 if (DW_LNE_lo_user
<= extended_op
20996 && extended_op
<= DW_LNE_hi_user
)
20998 /* Vendor extension, ignore. */
20999 line_ptr
= extended_end
;
21002 switch (extended_op
)
21004 case DW_LNE_end_sequence
:
21005 state_machine
.handle_end_sequence ();
21006 end_sequence
= true;
21008 case DW_LNE_set_address
:
21011 = cu
->header
.read_address (abfd
, line_ptr
, &bytes_read
);
21012 line_ptr
+= bytes_read
;
21014 state_machine
.check_line_address (cu
, line_ptr
,
21015 lowpc
- baseaddr
, address
);
21016 state_machine
.handle_set_address (baseaddr
, address
);
21019 case DW_LNE_define_file
:
21021 const char *cur_file
;
21022 unsigned int mod_time
, length
;
21025 cur_file
= read_direct_string (abfd
, line_ptr
,
21027 line_ptr
+= bytes_read
;
21028 dindex
= (dir_index
)
21029 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21030 line_ptr
+= bytes_read
;
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
;
21037 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21040 case DW_LNE_set_discriminator
:
21042 /* The discriminator is not interesting to the
21043 debugger; just ignore it. We still need to
21044 check its value though:
21045 if there are consecutive entries for the same
21046 (non-prologue) line we want to coalesce them.
21049 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21050 line_ptr
+= bytes_read
;
21052 state_machine
.handle_set_discriminator (discr
);
21056 complaint (_("mangled .debug_line section"));
21059 /* Make sure that we parsed the extended op correctly. If e.g.
21060 we expected a different address size than the producer used,
21061 we may have read the wrong number of bytes. */
21062 if (line_ptr
!= extended_end
)
21064 complaint (_("mangled .debug_line section"));
21069 state_machine
.handle_copy ();
21071 case DW_LNS_advance_pc
:
21074 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21075 line_ptr
+= bytes_read
;
21077 state_machine
.handle_advance_pc (adjust
);
21080 case DW_LNS_advance_line
:
21083 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21084 line_ptr
+= bytes_read
;
21086 state_machine
.handle_advance_line (line_delta
);
21089 case DW_LNS_set_file
:
21091 file_name_index file
21092 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21094 line_ptr
+= bytes_read
;
21096 state_machine
.handle_set_file (file
);
21099 case DW_LNS_set_column
:
21100 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21101 line_ptr
+= bytes_read
;
21103 case DW_LNS_negate_stmt
:
21104 state_machine
.handle_negate_stmt ();
21106 case DW_LNS_set_basic_block
:
21108 /* Add to the address register of the state machine the
21109 address increment value corresponding to special opcode
21110 255. I.e., this value is scaled by the minimum
21111 instruction length since special opcode 255 would have
21112 scaled the increment. */
21113 case DW_LNS_const_add_pc
:
21114 state_machine
.handle_const_add_pc ();
21116 case DW_LNS_fixed_advance_pc
:
21118 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21121 state_machine
.handle_fixed_advance_pc (addr_adj
);
21126 /* Unknown standard opcode, ignore it. */
21129 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21131 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21132 line_ptr
+= bytes_read
;
21139 dwarf2_debug_line_missing_end_sequence_complaint ();
21141 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21142 in which case we still finish recording the last line). */
21143 state_machine
.record_line (true);
21147 /* Decode the Line Number Program (LNP) for the given line_header
21148 structure and CU. The actual information extracted and the type
21149 of structures created from the LNP depends on the value of PST.
21151 1. If PST is NULL, then this procedure uses the data from the program
21152 to create all necessary symbol tables, and their linetables.
21154 2. If PST is not NULL, this procedure reads the program to determine
21155 the list of files included by the unit represented by PST, and
21156 builds all the associated partial symbol tables.
21158 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21159 It is used for relative paths in the line table.
21160 NOTE: When processing partial symtabs (pst != NULL),
21161 comp_dir == pst->dirname.
21163 NOTE: It is important that psymtabs have the same file name (via strcmp)
21164 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21165 symtab we don't use it in the name of the psymtabs we create.
21166 E.g. expand_line_sal requires this when finding psymtabs to expand.
21167 A good testcase for this is mb-inline.exp.
21169 LOWPC is the lowest address in CU (or 0 if not known).
21171 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21172 for its PC<->lines mapping information. Otherwise only the filename
21173 table is read in. */
21176 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21177 struct dwarf2_cu
*cu
, dwarf2_psymtab
*pst
,
21178 CORE_ADDR lowpc
, int decode_mapping
)
21180 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21181 const int decode_for_pst_p
= (pst
!= NULL
);
21183 if (decode_mapping
)
21184 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21186 if (decode_for_pst_p
)
21188 /* Now that we're done scanning the Line Header Program, we can
21189 create the psymtab of each included file. */
21190 for (auto &file_entry
: lh
->file_names ())
21191 if (file_entry
.included_p
== 1)
21193 gdb::unique_xmalloc_ptr
<char> name_holder
;
21194 const char *include_name
=
21195 psymtab_include_file_name (lh
, file_entry
, pst
,
21196 comp_dir
, &name_holder
);
21197 if (include_name
!= NULL
)
21198 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
21203 /* Make sure a symtab is created for every file, even files
21204 which contain only variables (i.e. no code with associated
21206 buildsym_compunit
*builder
= cu
->get_builder ();
21207 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21209 for (auto &fe
: lh
->file_names ())
21211 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21212 if (builder
->get_current_subfile ()->symtab
== NULL
)
21214 builder
->get_current_subfile ()->symtab
21215 = allocate_symtab (cust
,
21216 builder
->get_current_subfile ()->name
);
21218 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21223 /* Start a subfile for DWARF. FILENAME is the name of the file and
21224 DIRNAME the name of the source directory which contains FILENAME
21225 or NULL if not known.
21226 This routine tries to keep line numbers from identical absolute and
21227 relative file names in a common subfile.
21229 Using the `list' example from the GDB testsuite, which resides in
21230 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21231 of /srcdir/list0.c yields the following debugging information for list0.c:
21233 DW_AT_name: /srcdir/list0.c
21234 DW_AT_comp_dir: /compdir
21235 files.files[0].name: list0.h
21236 files.files[0].dir: /srcdir
21237 files.files[1].name: list0.c
21238 files.files[1].dir: /srcdir
21240 The line number information for list0.c has to end up in a single
21241 subfile, so that `break /srcdir/list0.c:1' works as expected.
21242 start_subfile will ensure that this happens provided that we pass the
21243 concatenation of files.files[1].dir and files.files[1].name as the
21247 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
21248 const char *dirname
)
21250 gdb::unique_xmalloc_ptr
<char> copy
;
21252 /* In order not to lose the line information directory,
21253 we concatenate it to the filename when it makes sense.
21254 Note that the Dwarf3 standard says (speaking of filenames in line
21255 information): ``The directory index is ignored for file names
21256 that represent full path names''. Thus ignoring dirname in the
21257 `else' branch below isn't an issue. */
21259 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
21261 copy
.reset (concat (dirname
, SLASH_STRING
, filename
, (char *) NULL
));
21262 filename
= copy
.get ();
21265 cu
->get_builder ()->start_subfile (filename
);
21268 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21269 buildsym_compunit constructor. */
21271 struct compunit_symtab
*
21272 dwarf2_cu::start_symtab (const char *name
, const char *comp_dir
,
21275 gdb_assert (m_builder
== nullptr);
21277 m_builder
.reset (new struct buildsym_compunit
21278 (this->per_objfile
->objfile
,
21279 name
, comp_dir
, language
, low_pc
));
21281 list_in_scope
= get_builder ()->get_file_symbols ();
21283 get_builder ()->record_debugformat ("DWARF 2");
21284 get_builder ()->record_producer (producer
);
21286 processing_has_namespace_info
= false;
21288 return get_builder ()->get_compunit_symtab ();
21292 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
21293 struct dwarf2_cu
*cu
)
21295 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21296 struct comp_unit_head
*cu_header
= &cu
->header
;
21298 /* NOTE drow/2003-01-30: There used to be a comment and some special
21299 code here to turn a symbol with DW_AT_external and a
21300 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21301 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21302 with some versions of binutils) where shared libraries could have
21303 relocations against symbols in their debug information - the
21304 minimal symbol would have the right address, but the debug info
21305 would not. It's no longer necessary, because we will explicitly
21306 apply relocations when we read in the debug information now. */
21308 /* A DW_AT_location attribute with no contents indicates that a
21309 variable has been optimized away. */
21310 if (attr
->form_is_block () && attr
->as_block ()->size
== 0)
21312 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21316 /* Handle one degenerate form of location expression specially, to
21317 preserve GDB's previous behavior when section offsets are
21318 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
21319 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
21321 if (attr
->form_is_block ())
21323 struct dwarf_block
*block
= attr
->as_block ();
21325 if ((block
->data
[0] == DW_OP_addr
21326 && block
->size
== 1 + cu_header
->addr_size
)
21327 || ((block
->data
[0] == DW_OP_GNU_addr_index
21328 || block
->data
[0] == DW_OP_addrx
)
21330 == 1 + leb128_size (&block
->data
[1]))))
21332 unsigned int dummy
;
21334 if (block
->data
[0] == DW_OP_addr
)
21335 SET_SYMBOL_VALUE_ADDRESS
21336 (sym
, cu
->header
.read_address (objfile
->obfd
,
21340 SET_SYMBOL_VALUE_ADDRESS
21341 (sym
, read_addr_index_from_leb128 (cu
, block
->data
+ 1,
21343 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
21344 fixup_symbol_section (sym
, objfile
);
21345 SET_SYMBOL_VALUE_ADDRESS
21347 SYMBOL_VALUE_ADDRESS (sym
)
21348 + objfile
->section_offsets
[SYMBOL_SECTION (sym
)]);
21353 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21354 expression evaluator, and use LOC_COMPUTED only when necessary
21355 (i.e. when the value of a register or memory location is
21356 referenced, or a thread-local block, etc.). Then again, it might
21357 not be worthwhile. I'm assuming that it isn't unless performance
21358 or memory numbers show me otherwise. */
21360 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
21362 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
21363 cu
->has_loclist
= true;
21366 /* Given a pointer to a DWARF information entry, figure out if we need
21367 to make a symbol table entry for it, and if so, create a new entry
21368 and return a pointer to it.
21369 If TYPE is NULL, determine symbol type from the die, otherwise
21370 used the passed type.
21371 If SPACE is not NULL, use it to hold the new symbol. If it is
21372 NULL, allocate a new symbol on the objfile's obstack. */
21374 static struct symbol
*
21375 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
21376 struct symbol
*space
)
21378 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21379 struct objfile
*objfile
= per_objfile
->objfile
;
21380 struct gdbarch
*gdbarch
= objfile
->arch ();
21381 struct symbol
*sym
= NULL
;
21383 struct attribute
*attr
= NULL
;
21384 struct attribute
*attr2
= NULL
;
21385 CORE_ADDR baseaddr
;
21386 struct pending
**list_to_add
= NULL
;
21388 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
21390 baseaddr
= objfile
->text_section_offset ();
21392 name
= dwarf2_name (die
, cu
);
21395 int suppress_add
= 0;
21400 sym
= new (&objfile
->objfile_obstack
) symbol
;
21401 OBJSTAT (objfile
, n_syms
++);
21403 /* Cache this symbol's name and the name's demangled form (if any). */
21404 sym
->set_language (cu
->language
, &objfile
->objfile_obstack
);
21405 /* Fortran does not have mangling standard and the mangling does differ
21406 between gfortran, iFort etc. */
21407 const char *physname
21408 = (cu
->language
== language_fortran
21409 ? dwarf2_full_name (name
, die
, cu
)
21410 : dwarf2_physname (name
, die
, cu
));
21411 const char *linkagename
= dw2_linkage_name (die
, cu
);
21413 if (linkagename
== nullptr || cu
->language
== language_ada
)
21414 sym
->set_linkage_name (physname
);
21417 sym
->set_demangled_name (physname
, &objfile
->objfile_obstack
);
21418 sym
->set_linkage_name (linkagename
);
21421 /* Default assumptions.
21422 Use the passed type or decode it from the die. */
21423 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21424 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21426 SYMBOL_TYPE (sym
) = type
;
21428 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
21429 attr
= dwarf2_attr (die
,
21430 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
21432 if (attr
!= nullptr)
21433 SYMBOL_LINE (sym
) = attr
->constant_value (0);
21435 attr
= dwarf2_attr (die
,
21436 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
21438 if (attr
!= nullptr && attr
->form_is_unsigned ())
21440 file_name_index file_index
21441 = (file_name_index
) attr
->as_unsigned ();
21442 struct file_entry
*fe
;
21444 if (cu
->line_header
!= NULL
)
21445 fe
= cu
->line_header
->file_name_at (file_index
);
21450 complaint (_("file index out of range"));
21452 symbol_set_symtab (sym
, fe
->symtab
);
21458 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
21459 if (attr
!= nullptr)
21463 addr
= attr
->as_address ();
21464 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
21465 SET_SYMBOL_VALUE_ADDRESS (sym
, addr
);
21466 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
21469 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21470 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
21471 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
21472 add_symbol_to_list (sym
, cu
->list_in_scope
);
21474 case DW_TAG_subprogram
:
21475 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21477 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21478 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21479 if ((attr2
!= nullptr && attr2
->as_boolean ())
21480 || cu
->language
== language_ada
21481 || cu
->language
== language_fortran
)
21483 /* Subprograms marked external are stored as a global symbol.
21484 Ada and Fortran subprograms, whether marked external or
21485 not, are always stored as a global symbol, because we want
21486 to be able to access them globally. For instance, we want
21487 to be able to break on a nested subprogram without having
21488 to specify the context. */
21489 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21493 list_to_add
= cu
->list_in_scope
;
21496 case DW_TAG_inlined_subroutine
:
21497 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21499 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21500 SYMBOL_INLINED (sym
) = 1;
21501 list_to_add
= cu
->list_in_scope
;
21503 case DW_TAG_template_value_param
:
21505 /* Fall through. */
21506 case DW_TAG_constant
:
21507 case DW_TAG_variable
:
21508 case DW_TAG_member
:
21509 /* Compilation with minimal debug info may result in
21510 variables with missing type entries. Change the
21511 misleading `void' type to something sensible. */
21512 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
21513 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
21515 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21516 /* In the case of DW_TAG_member, we should only be called for
21517 static const members. */
21518 if (die
->tag
== DW_TAG_member
)
21520 /* dwarf2_add_field uses die_is_declaration,
21521 so we do the same. */
21522 gdb_assert (die_is_declaration (die
, cu
));
21525 if (attr
!= nullptr)
21527 dwarf2_const_value (attr
, sym
, cu
);
21528 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21531 if (attr2
!= nullptr && attr2
->as_boolean ())
21532 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21534 list_to_add
= cu
->list_in_scope
;
21538 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21539 if (attr
!= nullptr)
21541 var_decode_location (attr
, sym
, cu
);
21542 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21544 /* Fortran explicitly imports any global symbols to the local
21545 scope by DW_TAG_common_block. */
21546 if (cu
->language
== language_fortran
&& die
->parent
21547 && die
->parent
->tag
== DW_TAG_common_block
)
21550 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21551 && SYMBOL_VALUE_ADDRESS (sym
) == 0
21552 && !per_objfile
->per_bfd
->has_section_at_zero
)
21554 /* When a static variable is eliminated by the linker,
21555 the corresponding debug information is not stripped
21556 out, but the variable address is set to null;
21557 do not add such variables into symbol table. */
21559 else if (attr2
!= nullptr && attr2
->as_boolean ())
21561 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21562 && (objfile
->flags
& OBJF_MAINLINE
) == 0
21563 && per_objfile
->per_bfd
->can_copy
)
21565 /* A global static variable might be subject to
21566 copy relocation. We first check for a local
21567 minsym, though, because maybe the symbol was
21568 marked hidden, in which case this would not
21570 bound_minimal_symbol found
21571 = (lookup_minimal_symbol_linkage
21572 (sym
->linkage_name (), objfile
));
21573 if (found
.minsym
!= nullptr)
21574 sym
->maybe_copied
= 1;
21577 /* A variable with DW_AT_external is never static,
21578 but it may be block-scoped. */
21580 = ((cu
->list_in_scope
21581 == cu
->get_builder ()->get_file_symbols ())
21582 ? cu
->get_builder ()->get_global_symbols ()
21583 : cu
->list_in_scope
);
21586 list_to_add
= cu
->list_in_scope
;
21590 /* We do not know the address of this symbol.
21591 If it is an external symbol and we have type information
21592 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21593 The address of the variable will then be determined from
21594 the minimal symbol table whenever the variable is
21596 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21598 /* Fortran explicitly imports any global symbols to the local
21599 scope by DW_TAG_common_block. */
21600 if (cu
->language
== language_fortran
&& die
->parent
21601 && die
->parent
->tag
== DW_TAG_common_block
)
21603 /* SYMBOL_CLASS doesn't matter here because
21604 read_common_block is going to reset it. */
21606 list_to_add
= cu
->list_in_scope
;
21608 else if (attr2
!= nullptr && attr2
->as_boolean ()
21609 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
21611 /* A variable with DW_AT_external is never static, but it
21612 may be block-scoped. */
21614 = ((cu
->list_in_scope
21615 == cu
->get_builder ()->get_file_symbols ())
21616 ? cu
->get_builder ()->get_global_symbols ()
21617 : cu
->list_in_scope
);
21619 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21621 else if (!die_is_declaration (die
, cu
))
21623 /* Use the default LOC_OPTIMIZED_OUT class. */
21624 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
21626 list_to_add
= cu
->list_in_scope
;
21630 case DW_TAG_formal_parameter
:
21632 /* If we are inside a function, mark this as an argument. If
21633 not, we might be looking at an argument to an inlined function
21634 when we do not have enough information to show inlined frames;
21635 pretend it's a local variable in that case so that the user can
21637 struct context_stack
*curr
21638 = cu
->get_builder ()->get_current_context_stack ();
21639 if (curr
!= nullptr && curr
->name
!= nullptr)
21640 SYMBOL_IS_ARGUMENT (sym
) = 1;
21641 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21642 if (attr
!= nullptr)
21644 var_decode_location (attr
, sym
, cu
);
21646 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21647 if (attr
!= nullptr)
21649 dwarf2_const_value (attr
, sym
, cu
);
21652 list_to_add
= cu
->list_in_scope
;
21655 case DW_TAG_unspecified_parameters
:
21656 /* From varargs functions; gdb doesn't seem to have any
21657 interest in this information, so just ignore it for now.
21660 case DW_TAG_template_type_param
:
21662 /* Fall through. */
21663 case DW_TAG_class_type
:
21664 case DW_TAG_interface_type
:
21665 case DW_TAG_structure_type
:
21666 case DW_TAG_union_type
:
21667 case DW_TAG_set_type
:
21668 case DW_TAG_enumeration_type
:
21669 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21670 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
21673 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21674 really ever be static objects: otherwise, if you try
21675 to, say, break of a class's method and you're in a file
21676 which doesn't mention that class, it won't work unless
21677 the check for all static symbols in lookup_symbol_aux
21678 saves you. See the OtherFileClass tests in
21679 gdb.c++/namespace.exp. */
21683 buildsym_compunit
*builder
= cu
->get_builder ();
21685 = (cu
->list_in_scope
== builder
->get_file_symbols ()
21686 && cu
->language
== language_cplus
21687 ? builder
->get_global_symbols ()
21688 : cu
->list_in_scope
);
21690 /* The semantics of C++ state that "struct foo {
21691 ... }" also defines a typedef for "foo". */
21692 if (cu
->language
== language_cplus
21693 || cu
->language
== language_ada
21694 || cu
->language
== language_d
21695 || cu
->language
== language_rust
)
21697 /* The symbol's name is already allocated along
21698 with this objfile, so we don't need to
21699 duplicate it for the type. */
21700 if (SYMBOL_TYPE (sym
)->name () == 0)
21701 SYMBOL_TYPE (sym
)->set_name (sym
->search_name ());
21706 case DW_TAG_typedef
:
21707 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21708 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21709 list_to_add
= cu
->list_in_scope
;
21711 case DW_TAG_base_type
:
21712 case DW_TAG_subrange_type
:
21713 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21714 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21715 list_to_add
= cu
->list_in_scope
;
21717 case DW_TAG_enumerator
:
21718 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21719 if (attr
!= nullptr)
21721 dwarf2_const_value (attr
, sym
, cu
);
21724 /* NOTE: carlton/2003-11-10: See comment above in the
21725 DW_TAG_class_type, etc. block. */
21728 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
21729 && cu
->language
== language_cplus
21730 ? cu
->get_builder ()->get_global_symbols ()
21731 : cu
->list_in_scope
);
21734 case DW_TAG_imported_declaration
:
21735 case DW_TAG_namespace
:
21736 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21737 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21739 case DW_TAG_module
:
21740 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21741 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
21742 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21744 case DW_TAG_common_block
:
21745 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
21746 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
21747 add_symbol_to_list (sym
, cu
->list_in_scope
);
21750 /* Not a tag we recognize. Hopefully we aren't processing
21751 trash data, but since we must specifically ignore things
21752 we don't recognize, there is nothing else we should do at
21754 complaint (_("unsupported tag: '%s'"),
21755 dwarf_tag_name (die
->tag
));
21761 sym
->hash_next
= objfile
->template_symbols
;
21762 objfile
->template_symbols
= sym
;
21763 list_to_add
= NULL
;
21766 if (list_to_add
!= NULL
)
21767 add_symbol_to_list (sym
, list_to_add
);
21769 /* For the benefit of old versions of GCC, check for anonymous
21770 namespaces based on the demangled name. */
21771 if (!cu
->processing_has_namespace_info
21772 && cu
->language
== language_cplus
)
21773 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
21778 /* Given an attr with a DW_FORM_dataN value in host byte order,
21779 zero-extend it as appropriate for the symbol's type. The DWARF
21780 standard (v4) is not entirely clear about the meaning of using
21781 DW_FORM_dataN for a constant with a signed type, where the type is
21782 wider than the data. The conclusion of a discussion on the DWARF
21783 list was that this is unspecified. We choose to always zero-extend
21784 because that is the interpretation long in use by GCC. */
21787 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
21788 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
21790 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21791 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
21792 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
21793 LONGEST l
= attr
->constant_value (0);
21795 if (bits
< sizeof (*value
) * 8)
21797 l
&= ((LONGEST
) 1 << bits
) - 1;
21800 else if (bits
== sizeof (*value
) * 8)
21804 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
21805 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
21812 /* Read a constant value from an attribute. Either set *VALUE, or if
21813 the value does not fit in *VALUE, set *BYTES - either already
21814 allocated on the objfile obstack, or newly allocated on OBSTACK,
21815 or, set *BATON, if we translated the constant to a location
21819 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
21820 const char *name
, struct obstack
*obstack
,
21821 struct dwarf2_cu
*cu
,
21822 LONGEST
*value
, const gdb_byte
**bytes
,
21823 struct dwarf2_locexpr_baton
**baton
)
21825 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21826 struct objfile
*objfile
= per_objfile
->objfile
;
21827 struct comp_unit_head
*cu_header
= &cu
->header
;
21828 struct dwarf_block
*blk
;
21829 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
21830 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
21836 switch (attr
->form
)
21839 case DW_FORM_addrx
:
21840 case DW_FORM_GNU_addr_index
:
21844 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
21845 dwarf2_const_value_length_mismatch_complaint (name
,
21846 cu_header
->addr_size
,
21847 TYPE_LENGTH (type
));
21848 /* Symbols of this form are reasonably rare, so we just
21849 piggyback on the existing location code rather than writing
21850 a new implementation of symbol_computed_ops. */
21851 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
21852 (*baton
)->per_objfile
= per_objfile
;
21853 (*baton
)->per_cu
= cu
->per_cu
;
21854 gdb_assert ((*baton
)->per_cu
);
21856 (*baton
)->size
= 2 + cu_header
->addr_size
;
21857 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
21858 (*baton
)->data
= data
;
21860 data
[0] = DW_OP_addr
;
21861 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
21862 byte_order
, attr
->as_address ());
21863 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
21866 case DW_FORM_string
:
21869 case DW_FORM_GNU_str_index
:
21870 case DW_FORM_GNU_strp_alt
:
21871 /* The string is already allocated on the objfile obstack, point
21873 *bytes
= (const gdb_byte
*) attr
->as_string ();
21875 case DW_FORM_block1
:
21876 case DW_FORM_block2
:
21877 case DW_FORM_block4
:
21878 case DW_FORM_block
:
21879 case DW_FORM_exprloc
:
21880 case DW_FORM_data16
:
21881 blk
= attr
->as_block ();
21882 if (TYPE_LENGTH (type
) != blk
->size
)
21883 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
21884 TYPE_LENGTH (type
));
21885 *bytes
= blk
->data
;
21888 /* The DW_AT_const_value attributes are supposed to carry the
21889 symbol's value "represented as it would be on the target
21890 architecture." By the time we get here, it's already been
21891 converted to host endianness, so we just need to sign- or
21892 zero-extend it as appropriate. */
21893 case DW_FORM_data1
:
21894 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
21896 case DW_FORM_data2
:
21897 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
21899 case DW_FORM_data4
:
21900 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
21902 case DW_FORM_data8
:
21903 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
21906 case DW_FORM_sdata
:
21907 case DW_FORM_implicit_const
:
21908 *value
= attr
->as_signed ();
21911 case DW_FORM_udata
:
21912 *value
= attr
->as_unsigned ();
21916 complaint (_("unsupported const value attribute form: '%s'"),
21917 dwarf_form_name (attr
->form
));
21924 /* Copy constant value from an attribute to a symbol. */
21927 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
21928 struct dwarf2_cu
*cu
)
21930 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21932 const gdb_byte
*bytes
;
21933 struct dwarf2_locexpr_baton
*baton
;
21935 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
21936 sym
->print_name (),
21937 &objfile
->objfile_obstack
, cu
,
21938 &value
, &bytes
, &baton
);
21942 SYMBOL_LOCATION_BATON (sym
) = baton
;
21943 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
21945 else if (bytes
!= NULL
)
21947 SYMBOL_VALUE_BYTES (sym
) = bytes
;
21948 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
21952 SYMBOL_VALUE (sym
) = value
;
21953 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
21957 /* Return the type of the die in question using its DW_AT_type attribute. */
21959 static struct type
*
21960 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
21962 struct attribute
*type_attr
;
21964 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
21967 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21968 /* A missing DW_AT_type represents a void type. */
21969 return objfile_type (objfile
)->builtin_void
;
21972 return lookup_die_type (die
, type_attr
, cu
);
21975 /* True iff CU's producer generates GNAT Ada auxiliary information
21976 that allows to find parallel types through that information instead
21977 of having to do expensive parallel lookups by type name. */
21980 need_gnat_info (struct dwarf2_cu
*cu
)
21982 /* Assume that the Ada compiler was GNAT, which always produces
21983 the auxiliary information. */
21984 return (cu
->language
== language_ada
);
21987 /* Return the auxiliary type of the die in question using its
21988 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
21989 attribute is not present. */
21991 static struct type
*
21992 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
21994 struct attribute
*type_attr
;
21996 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22000 return lookup_die_type (die
, type_attr
, cu
);
22003 /* If DIE has a descriptive_type attribute, then set the TYPE's
22004 descriptive type accordingly. */
22007 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22008 struct dwarf2_cu
*cu
)
22010 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22012 if (descriptive_type
)
22014 ALLOCATE_GNAT_AUX_TYPE (type
);
22015 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22019 /* Return the containing type of the die in question using its
22020 DW_AT_containing_type attribute. */
22022 static struct type
*
22023 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22025 struct attribute
*type_attr
;
22026 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22028 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22030 error (_("Dwarf Error: Problem turning containing type into gdb type "
22031 "[in module %s]"), objfile_name (objfile
));
22033 return lookup_die_type (die
, type_attr
, cu
);
22036 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22038 static struct type
*
22039 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22041 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22042 struct objfile
*objfile
= per_objfile
->objfile
;
22045 std::string message
22046 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22047 objfile_name (objfile
),
22048 sect_offset_str (cu
->header
.sect_off
),
22049 sect_offset_str (die
->sect_off
));
22050 saved
= obstack_strdup (&objfile
->objfile_obstack
, message
);
22052 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22055 /* Look up the type of DIE in CU using its type attribute ATTR.
22056 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22057 DW_AT_containing_type.
22058 If there is no type substitute an error marker. */
22060 static struct type
*
22061 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22062 struct dwarf2_cu
*cu
)
22064 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22065 struct objfile
*objfile
= per_objfile
->objfile
;
22066 struct type
*this_type
;
22068 gdb_assert (attr
->name
== DW_AT_type
22069 || attr
->name
== DW_AT_GNAT_descriptive_type
22070 || attr
->name
== DW_AT_containing_type
);
22072 /* First see if we have it cached. */
22074 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22076 struct dwarf2_per_cu_data
*per_cu
;
22077 sect_offset sect_off
= attr
->get_ref_die_offset ();
22079 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1, per_objfile
);
22080 this_type
= get_die_type_at_offset (sect_off
, per_cu
, per_objfile
);
22082 else if (attr
->form_is_ref ())
22084 sect_offset sect_off
= attr
->get_ref_die_offset ();
22086 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, per_objfile
);
22088 else if (attr
->form
== DW_FORM_ref_sig8
)
22090 ULONGEST signature
= attr
->as_signature ();
22092 return get_signatured_type (die
, signature
, cu
);
22096 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22097 " at %s [in module %s]"),
22098 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22099 objfile_name (objfile
));
22100 return build_error_marker_type (cu
, die
);
22103 /* If not cached we need to read it in. */
22105 if (this_type
== NULL
)
22107 struct die_info
*type_die
= NULL
;
22108 struct dwarf2_cu
*type_cu
= cu
;
22110 if (attr
->form_is_ref ())
22111 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22112 if (type_die
== NULL
)
22113 return build_error_marker_type (cu
, die
);
22114 /* If we find the type now, it's probably because the type came
22115 from an inter-CU reference and the type's CU got expanded before
22117 this_type
= read_type_die (type_die
, type_cu
);
22120 /* If we still don't have a type use an error marker. */
22122 if (this_type
== NULL
)
22123 return build_error_marker_type (cu
, die
);
22128 /* Return the type in DIE, CU.
22129 Returns NULL for invalid types.
22131 This first does a lookup in die_type_hash,
22132 and only reads the die in if necessary.
22134 NOTE: This can be called when reading in partial or full symbols. */
22136 static struct type
*
22137 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22139 struct type
*this_type
;
22141 this_type
= get_die_type (die
, cu
);
22145 return read_type_die_1 (die
, cu
);
22148 /* Read the type in DIE, CU.
22149 Returns NULL for invalid types. */
22151 static struct type
*
22152 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22154 struct type
*this_type
= NULL
;
22158 case DW_TAG_class_type
:
22159 case DW_TAG_interface_type
:
22160 case DW_TAG_structure_type
:
22161 case DW_TAG_union_type
:
22162 this_type
= read_structure_type (die
, cu
);
22164 case DW_TAG_enumeration_type
:
22165 this_type
= read_enumeration_type (die
, cu
);
22167 case DW_TAG_subprogram
:
22168 case DW_TAG_subroutine_type
:
22169 case DW_TAG_inlined_subroutine
:
22170 this_type
= read_subroutine_type (die
, cu
);
22172 case DW_TAG_array_type
:
22173 this_type
= read_array_type (die
, cu
);
22175 case DW_TAG_set_type
:
22176 this_type
= read_set_type (die
, cu
);
22178 case DW_TAG_pointer_type
:
22179 this_type
= read_tag_pointer_type (die
, cu
);
22181 case DW_TAG_ptr_to_member_type
:
22182 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22184 case DW_TAG_reference_type
:
22185 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22187 case DW_TAG_rvalue_reference_type
:
22188 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22190 case DW_TAG_const_type
:
22191 this_type
= read_tag_const_type (die
, cu
);
22193 case DW_TAG_volatile_type
:
22194 this_type
= read_tag_volatile_type (die
, cu
);
22196 case DW_TAG_restrict_type
:
22197 this_type
= read_tag_restrict_type (die
, cu
);
22199 case DW_TAG_string_type
:
22200 this_type
= read_tag_string_type (die
, cu
);
22202 case DW_TAG_typedef
:
22203 this_type
= read_typedef (die
, cu
);
22205 case DW_TAG_subrange_type
:
22206 this_type
= read_subrange_type (die
, cu
);
22208 case DW_TAG_base_type
:
22209 this_type
= read_base_type (die
, cu
);
22211 case DW_TAG_unspecified_type
:
22212 this_type
= read_unspecified_type (die
, cu
);
22214 case DW_TAG_namespace
:
22215 this_type
= read_namespace_type (die
, cu
);
22217 case DW_TAG_module
:
22218 this_type
= read_module_type (die
, cu
);
22220 case DW_TAG_atomic_type
:
22221 this_type
= read_tag_atomic_type (die
, cu
);
22224 complaint (_("unexpected tag in read_type_die: '%s'"),
22225 dwarf_tag_name (die
->tag
));
22232 /* See if we can figure out if the class lives in a namespace. We do
22233 this by looking for a member function; its demangled name will
22234 contain namespace info, if there is any.
22235 Return the computed name or NULL.
22236 Space for the result is allocated on the objfile's obstack.
22237 This is the full-die version of guess_partial_die_structure_name.
22238 In this case we know DIE has no useful parent. */
22240 static const char *
22241 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22243 struct die_info
*spec_die
;
22244 struct dwarf2_cu
*spec_cu
;
22245 struct die_info
*child
;
22246 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22249 spec_die
= die_specification (die
, &spec_cu
);
22250 if (spec_die
!= NULL
)
22256 for (child
= die
->child
;
22258 child
= child
->sibling
)
22260 if (child
->tag
== DW_TAG_subprogram
)
22262 const char *linkage_name
= dw2_linkage_name (child
, cu
);
22264 if (linkage_name
!= NULL
)
22266 gdb::unique_xmalloc_ptr
<char> actual_name
22267 (cu
->language_defn
->class_name_from_physname (linkage_name
));
22268 const char *name
= NULL
;
22270 if (actual_name
!= NULL
)
22272 const char *die_name
= dwarf2_name (die
, cu
);
22274 if (die_name
!= NULL
22275 && strcmp (die_name
, actual_name
.get ()) != 0)
22277 /* Strip off the class name from the full name.
22278 We want the prefix. */
22279 int die_name_len
= strlen (die_name
);
22280 int actual_name_len
= strlen (actual_name
.get ());
22281 const char *ptr
= actual_name
.get ();
22283 /* Test for '::' as a sanity check. */
22284 if (actual_name_len
> die_name_len
+ 2
22285 && ptr
[actual_name_len
- die_name_len
- 1] == ':')
22286 name
= obstack_strndup (
22287 &objfile
->per_bfd
->storage_obstack
,
22288 ptr
, actual_name_len
- die_name_len
- 2);
22299 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22300 prefix part in such case. See
22301 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22303 static const char *
22304 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22306 struct attribute
*attr
;
22309 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
22310 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
22313 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
22316 attr
= dw2_linkage_name_attr (die
, cu
);
22317 const char *attr_name
= attr
->as_string ();
22318 if (attr
== NULL
|| attr_name
== NULL
)
22321 /* dwarf2_name had to be already called. */
22322 gdb_assert (attr
->canonical_string_p ());
22324 /* Strip the base name, keep any leading namespaces/classes. */
22325 base
= strrchr (attr_name
, ':');
22326 if (base
== NULL
|| base
== attr_name
|| base
[-1] != ':')
22329 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22330 return obstack_strndup (&objfile
->per_bfd
->storage_obstack
,
22332 &base
[-1] - attr_name
);
22335 /* Return the name of the namespace/class that DIE is defined within,
22336 or "" if we can't tell. The caller should not xfree the result.
22338 For example, if we're within the method foo() in the following
22348 then determine_prefix on foo's die will return "N::C". */
22350 static const char *
22351 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22353 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22354 struct die_info
*parent
, *spec_die
;
22355 struct dwarf2_cu
*spec_cu
;
22356 struct type
*parent_type
;
22357 const char *retval
;
22359 if (cu
->language
!= language_cplus
22360 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
22361 && cu
->language
!= language_rust
)
22364 retval
= anonymous_struct_prefix (die
, cu
);
22368 /* We have to be careful in the presence of DW_AT_specification.
22369 For example, with GCC 3.4, given the code
22373 // Definition of N::foo.
22377 then we'll have a tree of DIEs like this:
22379 1: DW_TAG_compile_unit
22380 2: DW_TAG_namespace // N
22381 3: DW_TAG_subprogram // declaration of N::foo
22382 4: DW_TAG_subprogram // definition of N::foo
22383 DW_AT_specification // refers to die #3
22385 Thus, when processing die #4, we have to pretend that we're in
22386 the context of its DW_AT_specification, namely the contex of die
22389 spec_die
= die_specification (die
, &spec_cu
);
22390 if (spec_die
== NULL
)
22391 parent
= die
->parent
;
22394 parent
= spec_die
->parent
;
22398 if (parent
== NULL
)
22400 else if (parent
->building_fullname
)
22403 const char *parent_name
;
22405 /* It has been seen on RealView 2.2 built binaries,
22406 DW_TAG_template_type_param types actually _defined_ as
22407 children of the parent class:
22410 template class <class Enum> Class{};
22411 Class<enum E> class_e;
22413 1: DW_TAG_class_type (Class)
22414 2: DW_TAG_enumeration_type (E)
22415 3: DW_TAG_enumerator (enum1:0)
22416 3: DW_TAG_enumerator (enum2:1)
22418 2: DW_TAG_template_type_param
22419 DW_AT_type DW_FORM_ref_udata (E)
22421 Besides being broken debug info, it can put GDB into an
22422 infinite loop. Consider:
22424 When we're building the full name for Class<E>, we'll start
22425 at Class, and go look over its template type parameters,
22426 finding E. We'll then try to build the full name of E, and
22427 reach here. We're now trying to build the full name of E,
22428 and look over the parent DIE for containing scope. In the
22429 broken case, if we followed the parent DIE of E, we'd again
22430 find Class, and once again go look at its template type
22431 arguments, etc., etc. Simply don't consider such parent die
22432 as source-level parent of this die (it can't be, the language
22433 doesn't allow it), and break the loop here. */
22434 name
= dwarf2_name (die
, cu
);
22435 parent_name
= dwarf2_name (parent
, cu
);
22436 complaint (_("template param type '%s' defined within parent '%s'"),
22437 name
? name
: "<unknown>",
22438 parent_name
? parent_name
: "<unknown>");
22442 switch (parent
->tag
)
22444 case DW_TAG_namespace
:
22445 parent_type
= read_type_die (parent
, cu
);
22446 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22447 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22448 Work around this problem here. */
22449 if (cu
->language
== language_cplus
22450 && strcmp (parent_type
->name (), "::") == 0)
22452 /* We give a name to even anonymous namespaces. */
22453 return parent_type
->name ();
22454 case DW_TAG_class_type
:
22455 case DW_TAG_interface_type
:
22456 case DW_TAG_structure_type
:
22457 case DW_TAG_union_type
:
22458 case DW_TAG_module
:
22459 parent_type
= read_type_die (parent
, cu
);
22460 if (parent_type
->name () != NULL
)
22461 return parent_type
->name ();
22463 /* An anonymous structure is only allowed non-static data
22464 members; no typedefs, no member functions, et cetera.
22465 So it does not need a prefix. */
22467 case DW_TAG_compile_unit
:
22468 case DW_TAG_partial_unit
:
22469 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22470 if (cu
->language
== language_cplus
22471 && !per_objfile
->per_bfd
->types
.empty ()
22472 && die
->child
!= NULL
22473 && (die
->tag
== DW_TAG_class_type
22474 || die
->tag
== DW_TAG_structure_type
22475 || die
->tag
== DW_TAG_union_type
))
22477 const char *name
= guess_full_die_structure_name (die
, cu
);
22482 case DW_TAG_subprogram
:
22483 /* Nested subroutines in Fortran get a prefix with the name
22484 of the parent's subroutine. */
22485 if (cu
->language
== language_fortran
)
22487 if ((die
->tag
== DW_TAG_subprogram
)
22488 && (dwarf2_name (parent
, cu
) != NULL
))
22489 return dwarf2_name (parent
, cu
);
22491 return determine_prefix (parent
, cu
);
22492 case DW_TAG_enumeration_type
:
22493 parent_type
= read_type_die (parent
, cu
);
22494 if (TYPE_DECLARED_CLASS (parent_type
))
22496 if (parent_type
->name () != NULL
)
22497 return parent_type
->name ();
22500 /* Fall through. */
22502 return determine_prefix (parent
, cu
);
22506 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22507 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22508 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22509 an obconcat, otherwise allocate storage for the result. The CU argument is
22510 used to determine the language and hence, the appropriate separator. */
22512 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22515 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
22516 int physname
, struct dwarf2_cu
*cu
)
22518 const char *lead
= "";
22521 if (suffix
== NULL
|| suffix
[0] == '\0'
22522 || prefix
== NULL
|| prefix
[0] == '\0')
22524 else if (cu
->language
== language_d
)
22526 /* For D, the 'main' function could be defined in any module, but it
22527 should never be prefixed. */
22528 if (strcmp (suffix
, "D main") == 0)
22536 else if (cu
->language
== language_fortran
&& physname
)
22538 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22539 DW_AT_MIPS_linkage_name is preferred and used instead. */
22547 if (prefix
== NULL
)
22549 if (suffix
== NULL
)
22556 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
22558 strcpy (retval
, lead
);
22559 strcat (retval
, prefix
);
22560 strcat (retval
, sep
);
22561 strcat (retval
, suffix
);
22566 /* We have an obstack. */
22567 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
22571 /* Get name of a die, return NULL if not found. */
22573 static const char *
22574 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
22575 struct objfile
*objfile
)
22577 if (name
&& cu
->language
== language_cplus
)
22579 gdb::unique_xmalloc_ptr
<char> canon_name
22580 = cp_canonicalize_string (name
);
22582 if (canon_name
!= nullptr)
22583 name
= objfile
->intern (canon_name
.get ());
22589 /* Get name of a die, return NULL if not found.
22590 Anonymous namespaces are converted to their magic string. */
22592 static const char *
22593 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22595 struct attribute
*attr
;
22596 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22598 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
22599 const char *attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
22600 if (attr_name
== nullptr
22601 && die
->tag
!= DW_TAG_namespace
22602 && die
->tag
!= DW_TAG_class_type
22603 && die
->tag
!= DW_TAG_interface_type
22604 && die
->tag
!= DW_TAG_structure_type
22605 && die
->tag
!= DW_TAG_union_type
)
22610 case DW_TAG_compile_unit
:
22611 case DW_TAG_partial_unit
:
22612 /* Compilation units have a DW_AT_name that is a filename, not
22613 a source language identifier. */
22614 case DW_TAG_enumeration_type
:
22615 case DW_TAG_enumerator
:
22616 /* These tags always have simple identifiers already; no need
22617 to canonicalize them. */
22620 case DW_TAG_namespace
:
22621 if (attr_name
!= nullptr)
22623 return CP_ANONYMOUS_NAMESPACE_STR
;
22625 case DW_TAG_class_type
:
22626 case DW_TAG_interface_type
:
22627 case DW_TAG_structure_type
:
22628 case DW_TAG_union_type
:
22629 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22630 structures or unions. These were of the form "._%d" in GCC 4.1,
22631 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22632 and GCC 4.4. We work around this problem by ignoring these. */
22633 if (attr_name
!= nullptr
22634 && (startswith (attr_name
, "._")
22635 || startswith (attr_name
, "<anonymous")))
22638 /* GCC might emit a nameless typedef that has a linkage name. See
22639 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22640 if (!attr
|| attr_name
== NULL
)
22642 attr
= dw2_linkage_name_attr (die
, cu
);
22643 attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
22644 if (attr
== NULL
|| attr_name
== NULL
)
22647 /* Avoid demangling attr_name the second time on a second
22648 call for the same DIE. */
22649 if (!attr
->canonical_string_p ())
22651 gdb::unique_xmalloc_ptr
<char> demangled
22652 (gdb_demangle (attr_name
, DMGL_TYPES
));
22653 if (demangled
== nullptr)
22656 attr
->set_string_canonical (objfile
->intern (demangled
.get ()));
22657 attr_name
= attr
->as_string ();
22660 /* Strip any leading namespaces/classes, keep only the
22661 base name. DW_AT_name for named DIEs does not
22662 contain the prefixes. */
22663 const char *base
= strrchr (attr_name
, ':');
22664 if (base
&& base
> attr_name
&& base
[-1] == ':')
22675 if (!attr
->canonical_string_p ())
22676 attr
->set_string_canonical (dwarf2_canonicalize_name (attr_name
, cu
,
22678 return attr
->as_string ();
22681 /* Return the die that this die in an extension of, or NULL if there
22682 is none. *EXT_CU is the CU containing DIE on input, and the CU
22683 containing the return value on output. */
22685 static struct die_info
*
22686 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
22688 struct attribute
*attr
;
22690 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
22694 return follow_die_ref (die
, attr
, ext_cu
);
22698 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
22702 print_spaces (indent
, f
);
22703 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
22704 dwarf_tag_name (die
->tag
), die
->abbrev
,
22705 sect_offset_str (die
->sect_off
));
22707 if (die
->parent
!= NULL
)
22709 print_spaces (indent
, f
);
22710 fprintf_unfiltered (f
, " parent at offset: %s\n",
22711 sect_offset_str (die
->parent
->sect_off
));
22714 print_spaces (indent
, f
);
22715 fprintf_unfiltered (f
, " has children: %s\n",
22716 dwarf_bool_name (die
->child
!= NULL
));
22718 print_spaces (indent
, f
);
22719 fprintf_unfiltered (f
, " attributes:\n");
22721 for (i
= 0; i
< die
->num_attrs
; ++i
)
22723 print_spaces (indent
, f
);
22724 fprintf_unfiltered (f
, " %s (%s) ",
22725 dwarf_attr_name (die
->attrs
[i
].name
),
22726 dwarf_form_name (die
->attrs
[i
].form
));
22728 switch (die
->attrs
[i
].form
)
22731 case DW_FORM_addrx
:
22732 case DW_FORM_GNU_addr_index
:
22733 fprintf_unfiltered (f
, "address: ");
22734 fputs_filtered (hex_string (die
->attrs
[i
].as_address ()), f
);
22736 case DW_FORM_block2
:
22737 case DW_FORM_block4
:
22738 case DW_FORM_block
:
22739 case DW_FORM_block1
:
22740 fprintf_unfiltered (f
, "block: size %s",
22741 pulongest (die
->attrs
[i
].as_block ()->size
));
22743 case DW_FORM_exprloc
:
22744 fprintf_unfiltered (f
, "expression: size %s",
22745 pulongest (die
->attrs
[i
].as_block ()->size
));
22747 case DW_FORM_data16
:
22748 fprintf_unfiltered (f
, "constant of 16 bytes");
22750 case DW_FORM_ref_addr
:
22751 fprintf_unfiltered (f
, "ref address: ");
22752 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
22754 case DW_FORM_GNU_ref_alt
:
22755 fprintf_unfiltered (f
, "alt ref address: ");
22756 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
22762 case DW_FORM_ref_udata
:
22763 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
22764 (long) (die
->attrs
[i
].as_unsigned ()));
22766 case DW_FORM_data1
:
22767 case DW_FORM_data2
:
22768 case DW_FORM_data4
:
22769 case DW_FORM_data8
:
22770 case DW_FORM_udata
:
22771 fprintf_unfiltered (f
, "constant: %s",
22772 pulongest (die
->attrs
[i
].as_unsigned ()));
22774 case DW_FORM_sec_offset
:
22775 fprintf_unfiltered (f
, "section offset: %s",
22776 pulongest (die
->attrs
[i
].as_unsigned ()));
22778 case DW_FORM_ref_sig8
:
22779 fprintf_unfiltered (f
, "signature: %s",
22780 hex_string (die
->attrs
[i
].as_signature ()));
22782 case DW_FORM_string
:
22784 case DW_FORM_line_strp
:
22786 case DW_FORM_GNU_str_index
:
22787 case DW_FORM_GNU_strp_alt
:
22788 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
22789 die
->attrs
[i
].as_string ()
22790 ? die
->attrs
[i
].as_string () : "",
22791 die
->attrs
[i
].canonical_string_p () ? "is" : "not");
22794 if (die
->attrs
[i
].as_boolean ())
22795 fprintf_unfiltered (f
, "flag: TRUE");
22797 fprintf_unfiltered (f
, "flag: FALSE");
22799 case DW_FORM_flag_present
:
22800 fprintf_unfiltered (f
, "flag: TRUE");
22802 case DW_FORM_indirect
:
22803 /* The reader will have reduced the indirect form to
22804 the "base form" so this form should not occur. */
22805 fprintf_unfiltered (f
,
22806 "unexpected attribute form: DW_FORM_indirect");
22808 case DW_FORM_sdata
:
22809 case DW_FORM_implicit_const
:
22810 fprintf_unfiltered (f
, "constant: %s",
22811 plongest (die
->attrs
[i
].as_signed ()));
22814 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
22815 die
->attrs
[i
].form
);
22818 fprintf_unfiltered (f
, "\n");
22823 dump_die_for_error (struct die_info
*die
)
22825 dump_die_shallow (gdb_stderr
, 0, die
);
22829 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
22831 int indent
= level
* 4;
22833 gdb_assert (die
!= NULL
);
22835 if (level
>= max_level
)
22838 dump_die_shallow (f
, indent
, die
);
22840 if (die
->child
!= NULL
)
22842 print_spaces (indent
, f
);
22843 fprintf_unfiltered (f
, " Children:");
22844 if (level
+ 1 < max_level
)
22846 fprintf_unfiltered (f
, "\n");
22847 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
22851 fprintf_unfiltered (f
,
22852 " [not printed, max nesting level reached]\n");
22856 if (die
->sibling
!= NULL
&& level
> 0)
22858 dump_die_1 (f
, level
, max_level
, die
->sibling
);
22862 /* This is called from the pdie macro in gdbinit.in.
22863 It's not static so gcc will keep a copy callable from gdb. */
22866 dump_die (struct die_info
*die
, int max_level
)
22868 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
22872 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
22876 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
22877 to_underlying (die
->sect_off
),
22883 /* Follow reference or signature attribute ATTR of SRC_DIE.
22884 On entry *REF_CU is the CU of SRC_DIE.
22885 On exit *REF_CU is the CU of the result. */
22887 static struct die_info
*
22888 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
22889 struct dwarf2_cu
**ref_cu
)
22891 struct die_info
*die
;
22893 if (attr
->form_is_ref ())
22894 die
= follow_die_ref (src_die
, attr
, ref_cu
);
22895 else if (attr
->form
== DW_FORM_ref_sig8
)
22896 die
= follow_die_sig (src_die
, attr
, ref_cu
);
22899 dump_die_for_error (src_die
);
22900 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
22901 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
22907 /* Follow reference OFFSET.
22908 On entry *REF_CU is the CU of the source die referencing OFFSET.
22909 On exit *REF_CU is the CU of the result.
22910 Returns NULL if OFFSET is invalid. */
22912 static struct die_info
*
22913 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
22914 struct dwarf2_cu
**ref_cu
)
22916 struct die_info temp_die
;
22917 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
22918 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22920 gdb_assert (cu
->per_cu
!= NULL
);
22924 if (cu
->per_cu
->is_debug_types
)
22926 /* .debug_types CUs cannot reference anything outside their CU.
22927 If they need to, they have to reference a signatured type via
22928 DW_FORM_ref_sig8. */
22929 if (!cu
->header
.offset_in_cu_p (sect_off
))
22932 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
22933 || !cu
->header
.offset_in_cu_p (sect_off
))
22935 struct dwarf2_per_cu_data
*per_cu
;
22937 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
22940 /* If necessary, add it to the queue and load its DIEs. */
22941 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
))
22942 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
22943 false, cu
->language
);
22945 target_cu
= per_objfile
->get_cu (per_cu
);
22947 else if (cu
->dies
== NULL
)
22949 /* We're loading full DIEs during partial symbol reading. */
22950 gdb_assert (per_objfile
->per_bfd
->reading_partial_symbols
);
22951 load_full_comp_unit (cu
->per_cu
, per_objfile
, cu
, false,
22955 *ref_cu
= target_cu
;
22956 temp_die
.sect_off
= sect_off
;
22958 if (target_cu
!= cu
)
22959 target_cu
->ancestor
= cu
;
22961 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
22963 to_underlying (sect_off
));
22966 /* Follow reference attribute ATTR of SRC_DIE.
22967 On entry *REF_CU is the CU of SRC_DIE.
22968 On exit *REF_CU is the CU of the result. */
22970 static struct die_info
*
22971 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
22972 struct dwarf2_cu
**ref_cu
)
22974 sect_offset sect_off
= attr
->get_ref_die_offset ();
22975 struct dwarf2_cu
*cu
= *ref_cu
;
22976 struct die_info
*die
;
22978 die
= follow_die_offset (sect_off
,
22979 (attr
->form
== DW_FORM_GNU_ref_alt
22980 || cu
->per_cu
->is_dwz
),
22983 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
22984 "at %s [in module %s]"),
22985 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
22986 objfile_name (cu
->per_objfile
->objfile
));
22993 struct dwarf2_locexpr_baton
22994 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
22995 dwarf2_per_cu_data
*per_cu
,
22996 dwarf2_per_objfile
*per_objfile
,
22997 gdb::function_view
<CORE_ADDR ()> get_frame_pc
,
22998 bool resolve_abstract_p
)
23000 struct die_info
*die
;
23001 struct attribute
*attr
;
23002 struct dwarf2_locexpr_baton retval
;
23003 struct objfile
*objfile
= per_objfile
->objfile
;
23005 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23007 cu
= load_cu (per_cu
, per_objfile
, false);
23011 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23012 Instead just throw an error, not much else we can do. */
23013 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23014 sect_offset_str (sect_off
), objfile_name (objfile
));
23017 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23019 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23020 sect_offset_str (sect_off
), objfile_name (objfile
));
23022 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23023 if (!attr
&& resolve_abstract_p
23024 && (per_objfile
->per_bfd
->abstract_to_concrete
.find (die
->sect_off
)
23025 != per_objfile
->per_bfd
->abstract_to_concrete
.end ()))
23027 CORE_ADDR pc
= get_frame_pc ();
23028 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
23029 struct gdbarch
*gdbarch
= objfile
->arch ();
23031 for (const auto &cand_off
23032 : per_objfile
->per_bfd
->abstract_to_concrete
[die
->sect_off
])
23034 struct dwarf2_cu
*cand_cu
= cu
;
23035 struct die_info
*cand
23036 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23039 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23042 CORE_ADDR pc_low
, pc_high
;
23043 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23044 if (pc_low
== ((CORE_ADDR
) -1))
23046 pc_low
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_low
+ baseaddr
);
23047 pc_high
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_high
+ baseaddr
);
23048 if (!(pc_low
<= pc
&& pc
< pc_high
))
23052 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23059 /* DWARF: "If there is no such attribute, then there is no effect.".
23060 DATA is ignored if SIZE is 0. */
23062 retval
.data
= NULL
;
23065 else if (attr
->form_is_section_offset ())
23067 struct dwarf2_loclist_baton loclist_baton
;
23068 CORE_ADDR pc
= get_frame_pc ();
23071 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23073 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23075 retval
.size
= size
;
23079 if (!attr
->form_is_block ())
23080 error (_("Dwarf Error: DIE at %s referenced in module %s "
23081 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23082 sect_offset_str (sect_off
), objfile_name (objfile
));
23084 struct dwarf_block
*block
= attr
->as_block ();
23085 retval
.data
= block
->data
;
23086 retval
.size
= block
->size
;
23088 retval
.per_objfile
= per_objfile
;
23089 retval
.per_cu
= cu
->per_cu
;
23091 per_objfile
->age_comp_units ();
23098 struct dwarf2_locexpr_baton
23099 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23100 dwarf2_per_cu_data
*per_cu
,
23101 dwarf2_per_objfile
*per_objfile
,
23102 gdb::function_view
<CORE_ADDR ()> get_frame_pc
)
23104 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23106 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, per_objfile
,
23110 /* Write a constant of a given type as target-ordered bytes into
23113 static const gdb_byte
*
23114 write_constant_as_bytes (struct obstack
*obstack
,
23115 enum bfd_endian byte_order
,
23122 *len
= TYPE_LENGTH (type
);
23123 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23124 store_unsigned_integer (result
, *len
, byte_order
, value
);
23132 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23133 dwarf2_per_cu_data
*per_cu
,
23134 dwarf2_per_objfile
*per_objfile
,
23138 struct die_info
*die
;
23139 struct attribute
*attr
;
23140 const gdb_byte
*result
= NULL
;
23143 enum bfd_endian byte_order
;
23144 struct objfile
*objfile
= per_objfile
->objfile
;
23146 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23148 cu
= load_cu (per_cu
, per_objfile
, false);
23152 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23153 Instead just throw an error, not much else we can do. */
23154 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23155 sect_offset_str (sect_off
), objfile_name (objfile
));
23158 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23160 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23161 sect_offset_str (sect_off
), objfile_name (objfile
));
23163 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23167 byte_order
= (bfd_big_endian (objfile
->obfd
)
23168 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23170 switch (attr
->form
)
23173 case DW_FORM_addrx
:
23174 case DW_FORM_GNU_addr_index
:
23178 *len
= cu
->header
.addr_size
;
23179 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23180 store_unsigned_integer (tem
, *len
, byte_order
, attr
->as_address ());
23184 case DW_FORM_string
:
23187 case DW_FORM_GNU_str_index
:
23188 case DW_FORM_GNU_strp_alt
:
23189 /* The string is already allocated on the objfile obstack, point
23192 const char *attr_name
= attr
->as_string ();
23193 result
= (const gdb_byte
*) attr_name
;
23194 *len
= strlen (attr_name
);
23197 case DW_FORM_block1
:
23198 case DW_FORM_block2
:
23199 case DW_FORM_block4
:
23200 case DW_FORM_block
:
23201 case DW_FORM_exprloc
:
23202 case DW_FORM_data16
:
23204 struct dwarf_block
*block
= attr
->as_block ();
23205 result
= block
->data
;
23206 *len
= block
->size
;
23210 /* The DW_AT_const_value attributes are supposed to carry the
23211 symbol's value "represented as it would be on the target
23212 architecture." By the time we get here, it's already been
23213 converted to host endianness, so we just need to sign- or
23214 zero-extend it as appropriate. */
23215 case DW_FORM_data1
:
23216 type
= die_type (die
, cu
);
23217 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23218 if (result
== NULL
)
23219 result
= write_constant_as_bytes (obstack
, byte_order
,
23222 case DW_FORM_data2
:
23223 type
= die_type (die
, cu
);
23224 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23225 if (result
== NULL
)
23226 result
= write_constant_as_bytes (obstack
, byte_order
,
23229 case DW_FORM_data4
:
23230 type
= die_type (die
, cu
);
23231 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23232 if (result
== NULL
)
23233 result
= write_constant_as_bytes (obstack
, byte_order
,
23236 case DW_FORM_data8
:
23237 type
= die_type (die
, cu
);
23238 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23239 if (result
== NULL
)
23240 result
= write_constant_as_bytes (obstack
, byte_order
,
23244 case DW_FORM_sdata
:
23245 case DW_FORM_implicit_const
:
23246 type
= die_type (die
, cu
);
23247 result
= write_constant_as_bytes (obstack
, byte_order
,
23248 type
, attr
->as_signed (), len
);
23251 case DW_FORM_udata
:
23252 type
= die_type (die
, cu
);
23253 result
= write_constant_as_bytes (obstack
, byte_order
,
23254 type
, attr
->as_unsigned (), len
);
23258 complaint (_("unsupported const value attribute form: '%s'"),
23259 dwarf_form_name (attr
->form
));
23269 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
23270 dwarf2_per_cu_data
*per_cu
,
23271 dwarf2_per_objfile
*per_objfile
)
23273 struct die_info
*die
;
23275 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23277 cu
= load_cu (per_cu
, per_objfile
, false);
23282 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23286 return die_type (die
, cu
);
23292 dwarf2_get_die_type (cu_offset die_offset
,
23293 dwarf2_per_cu_data
*per_cu
,
23294 dwarf2_per_objfile
*per_objfile
)
23296 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
23297 return get_die_type_at_offset (die_offset_sect
, per_cu
, per_objfile
);
23300 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23301 On entry *REF_CU is the CU of SRC_DIE.
23302 On exit *REF_CU is the CU of the result.
23303 Returns NULL if the referenced DIE isn't found. */
23305 static struct die_info
*
23306 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
23307 struct dwarf2_cu
**ref_cu
)
23309 struct die_info temp_die
;
23310 struct dwarf2_cu
*sig_cu
, *cu
= *ref_cu
;
23311 struct die_info
*die
;
23312 dwarf2_per_objfile
*per_objfile
= (*ref_cu
)->per_objfile
;
23315 /* While it might be nice to assert sig_type->type == NULL here,
23316 we can get here for DW_AT_imported_declaration where we need
23317 the DIE not the type. */
23319 /* If necessary, add it to the queue and load its DIEs. */
23321 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, per_objfile
,
23323 read_signatured_type (sig_type
, per_objfile
);
23325 sig_cu
= per_objfile
->get_cu (&sig_type
->per_cu
);
23326 gdb_assert (sig_cu
!= NULL
);
23327 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
23328 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
23329 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
23330 to_underlying (temp_die
.sect_off
));
23333 /* For .gdb_index version 7 keep track of included TUs.
23334 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23335 if (per_objfile
->per_bfd
->index_table
!= NULL
23336 && per_objfile
->per_bfd
->index_table
->version
<= 7)
23338 (*ref_cu
)->per_cu
->imported_symtabs_push (sig_cu
->per_cu
);
23343 sig_cu
->ancestor
= cu
;
23351 /* Follow signatured type referenced by ATTR in SRC_DIE.
23352 On entry *REF_CU is the CU of SRC_DIE.
23353 On exit *REF_CU is the CU of the result.
23354 The result is the DIE of the type.
23355 If the referenced type cannot be found an error is thrown. */
23357 static struct die_info
*
23358 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23359 struct dwarf2_cu
**ref_cu
)
23361 ULONGEST signature
= attr
->as_signature ();
23362 struct signatured_type
*sig_type
;
23363 struct die_info
*die
;
23365 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
23367 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
23368 /* sig_type will be NULL if the signatured type is missing from
23370 if (sig_type
== NULL
)
23372 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23373 " from DIE at %s [in module %s]"),
23374 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23375 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23378 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
23381 dump_die_for_error (src_die
);
23382 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23383 " from DIE at %s [in module %s]"),
23384 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23385 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23391 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23392 reading in and processing the type unit if necessary. */
23394 static struct type
*
23395 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
23396 struct dwarf2_cu
*cu
)
23398 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23399 struct signatured_type
*sig_type
;
23400 struct dwarf2_cu
*type_cu
;
23401 struct die_info
*type_die
;
23404 sig_type
= lookup_signatured_type (cu
, signature
);
23405 /* sig_type will be NULL if the signatured type is missing from
23407 if (sig_type
== NULL
)
23409 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23410 " from DIE at %s [in module %s]"),
23411 hex_string (signature
), sect_offset_str (die
->sect_off
),
23412 objfile_name (per_objfile
->objfile
));
23413 return build_error_marker_type (cu
, die
);
23416 /* If we already know the type we're done. */
23417 type
= per_objfile
->get_type_for_signatured_type (sig_type
);
23418 if (type
!= nullptr)
23422 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
23423 if (type_die
!= NULL
)
23425 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23426 is created. This is important, for example, because for c++ classes
23427 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23428 type
= read_type_die (type_die
, type_cu
);
23431 complaint (_("Dwarf Error: Cannot build signatured type %s"
23432 " referenced from DIE at %s [in module %s]"),
23433 hex_string (signature
), sect_offset_str (die
->sect_off
),
23434 objfile_name (per_objfile
->objfile
));
23435 type
= build_error_marker_type (cu
, die
);
23440 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23441 " from DIE at %s [in module %s]"),
23442 hex_string (signature
), sect_offset_str (die
->sect_off
),
23443 objfile_name (per_objfile
->objfile
));
23444 type
= build_error_marker_type (cu
, die
);
23447 per_objfile
->set_type_for_signatured_type (sig_type
, type
);
23452 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23453 reading in and processing the type unit if necessary. */
23455 static struct type
*
23456 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
23457 struct dwarf2_cu
*cu
) /* ARI: editCase function */
23459 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23460 if (attr
->form_is_ref ())
23462 struct dwarf2_cu
*type_cu
= cu
;
23463 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
23465 return read_type_die (type_die
, type_cu
);
23467 else if (attr
->form
== DW_FORM_ref_sig8
)
23469 return get_signatured_type (die
, attr
->as_signature (), cu
);
23473 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23475 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23476 " at %s [in module %s]"),
23477 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
23478 objfile_name (per_objfile
->objfile
));
23479 return build_error_marker_type (cu
, die
);
23483 /* Load the DIEs associated with type unit PER_CU into memory. */
23486 load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
23487 dwarf2_per_objfile
*per_objfile
)
23489 struct signatured_type
*sig_type
;
23491 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23492 gdb_assert (! per_cu
->type_unit_group_p ());
23494 /* We have the per_cu, but we need the signatured_type.
23495 Fortunately this is an easy translation. */
23496 gdb_assert (per_cu
->is_debug_types
);
23497 sig_type
= (struct signatured_type
*) per_cu
;
23499 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
23501 read_signatured_type (sig_type
, per_objfile
);
23503 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
23506 /* Read in a signatured type and build its CU and DIEs.
23507 If the type is a stub for the real type in a DWO file,
23508 read in the real type from the DWO file as well. */
23511 read_signatured_type (signatured_type
*sig_type
,
23512 dwarf2_per_objfile
*per_objfile
)
23514 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
23516 gdb_assert (per_cu
->is_debug_types
);
23517 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
23519 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
23521 if (!reader
.dummy_p
)
23523 struct dwarf2_cu
*cu
= reader
.cu
;
23524 const gdb_byte
*info_ptr
= reader
.info_ptr
;
23526 gdb_assert (cu
->die_hash
== NULL
);
23528 htab_create_alloc_ex (cu
->header
.length
/ 12,
23532 &cu
->comp_unit_obstack
,
23533 hashtab_obstack_allocate
,
23534 dummy_obstack_deallocate
);
23536 if (reader
.comp_unit_die
->has_children
)
23537 reader
.comp_unit_die
->child
23538 = read_die_and_siblings (&reader
, info_ptr
, &info_ptr
,
23539 reader
.comp_unit_die
);
23540 cu
->dies
= reader
.comp_unit_die
;
23541 /* comp_unit_die is not stored in die_hash, no need. */
23543 /* We try not to read any attributes in this function, because
23544 not all CUs needed for references have been loaded yet, and
23545 symbol table processing isn't initialized. But we have to
23546 set the CU language, or we won't be able to build types
23547 correctly. Similarly, if we do not read the producer, we can
23548 not apply producer-specific interpretation. */
23549 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
23554 sig_type
->per_cu
.tu_read
= 1;
23557 /* Decode simple location descriptions.
23558 Given a pointer to a dwarf block that defines a location, compute
23559 the location and return the value. If COMPUTED is non-null, it is
23560 set to true to indicate that decoding was successful, and false
23561 otherwise. If COMPUTED is null, then this function may emit a
23565 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
, bool *computed
)
23567 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
23569 size_t size
= blk
->size
;
23570 const gdb_byte
*data
= blk
->data
;
23571 CORE_ADDR stack
[64];
23573 unsigned int bytes_read
, unsnd
;
23576 if (computed
!= nullptr)
23582 stack
[++stacki
] = 0;
23621 stack
[++stacki
] = op
- DW_OP_lit0
;
23656 stack
[++stacki
] = op
- DW_OP_reg0
;
23659 if (computed
== nullptr)
23660 dwarf2_complex_location_expr_complaint ();
23667 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
23669 stack
[++stacki
] = unsnd
;
23672 if (computed
== nullptr)
23673 dwarf2_complex_location_expr_complaint ();
23680 stack
[++stacki
] = cu
->header
.read_address (objfile
->obfd
, &data
[i
],
23685 case DW_OP_const1u
:
23686 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
23690 case DW_OP_const1s
:
23691 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
23695 case DW_OP_const2u
:
23696 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
23700 case DW_OP_const2s
:
23701 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
23705 case DW_OP_const4u
:
23706 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
23710 case DW_OP_const4s
:
23711 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
23715 case DW_OP_const8u
:
23716 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
23721 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
23727 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
23732 stack
[stacki
+ 1] = stack
[stacki
];
23737 stack
[stacki
- 1] += stack
[stacki
];
23741 case DW_OP_plus_uconst
:
23742 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
23748 stack
[stacki
- 1] -= stack
[stacki
];
23753 /* If we're not the last op, then we definitely can't encode
23754 this using GDB's address_class enum. This is valid for partial
23755 global symbols, although the variable's address will be bogus
23759 if (computed
== nullptr)
23760 dwarf2_complex_location_expr_complaint ();
23766 case DW_OP_GNU_push_tls_address
:
23767 case DW_OP_form_tls_address
:
23768 /* The top of the stack has the offset from the beginning
23769 of the thread control block at which the variable is located. */
23770 /* Nothing should follow this operator, so the top of stack would
23772 /* This is valid for partial global symbols, but the variable's
23773 address will be bogus in the psymtab. Make it always at least
23774 non-zero to not look as a variable garbage collected by linker
23775 which have DW_OP_addr 0. */
23778 if (computed
== nullptr)
23779 dwarf2_complex_location_expr_complaint ();
23786 case DW_OP_GNU_uninit
:
23787 if (computed
!= nullptr)
23792 case DW_OP_GNU_addr_index
:
23793 case DW_OP_GNU_const_index
:
23794 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
23800 if (computed
== nullptr)
23802 const char *name
= get_DW_OP_name (op
);
23805 complaint (_("unsupported stack op: '%s'"),
23808 complaint (_("unsupported stack op: '%02x'"),
23812 return (stack
[stacki
]);
23815 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23816 outside of the allocated space. Also enforce minimum>0. */
23817 if (stacki
>= ARRAY_SIZE (stack
) - 1)
23819 if (computed
== nullptr)
23820 complaint (_("location description stack overflow"));
23826 if (computed
== nullptr)
23827 complaint (_("location description stack underflow"));
23832 if (computed
!= nullptr)
23834 return (stack
[stacki
]);
23837 /* memory allocation interface */
23839 static struct dwarf_block
*
23840 dwarf_alloc_block (struct dwarf2_cu
*cu
)
23842 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
23845 static struct die_info
*
23846 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
23848 struct die_info
*die
;
23849 size_t size
= sizeof (struct die_info
);
23852 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
23854 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
23855 memset (die
, 0, sizeof (struct die_info
));
23861 /* Macro support. */
23863 /* An overload of dwarf_decode_macros that finds the correct section
23864 and ensures it is read in before calling the other overload. */
23867 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
23868 int section_is_gnu
)
23870 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23871 struct objfile
*objfile
= per_objfile
->objfile
;
23872 const struct line_header
*lh
= cu
->line_header
;
23873 unsigned int offset_size
= cu
->header
.offset_size
;
23874 struct dwarf2_section_info
*section
;
23875 const char *section_name
;
23877 if (cu
->dwo_unit
!= nullptr)
23879 if (section_is_gnu
)
23881 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
23882 section_name
= ".debug_macro.dwo";
23886 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
23887 section_name
= ".debug_macinfo.dwo";
23892 if (section_is_gnu
)
23894 section
= &per_objfile
->per_bfd
->macro
;
23895 section_name
= ".debug_macro";
23899 section
= &per_objfile
->per_bfd
->macinfo
;
23900 section_name
= ".debug_macinfo";
23904 section
->read (objfile
);
23905 if (section
->buffer
== nullptr)
23907 complaint (_("missing %s section"), section_name
);
23911 buildsym_compunit
*builder
= cu
->get_builder ();
23913 struct dwarf2_section_info
*str_offsets_section
;
23914 struct dwarf2_section_info
*str_section
;
23915 ULONGEST str_offsets_base
;
23917 if (cu
->dwo_unit
!= nullptr)
23919 str_offsets_section
= &cu
->dwo_unit
->dwo_file
23920 ->sections
.str_offsets
;
23921 str_section
= &cu
->dwo_unit
->dwo_file
->sections
.str
;
23922 str_offsets_base
= cu
->header
.addr_size
;
23926 str_offsets_section
= &per_objfile
->per_bfd
->str_offsets
;
23927 str_section
= &per_objfile
->per_bfd
->str
;
23928 str_offsets_base
= *cu
->str_offsets_base
;
23931 dwarf_decode_macros (per_objfile
, builder
, section
, lh
,
23932 offset_size
, offset
, str_section
, str_offsets_section
,
23933 str_offsets_base
, section_is_gnu
);
23936 /* Return the .debug_loc section to use for CU.
23937 For DWO files use .debug_loc.dwo. */
23939 static struct dwarf2_section_info
*
23940 cu_debug_loc_section (struct dwarf2_cu
*cu
)
23942 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23946 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
23948 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
23950 return (cu
->header
.version
>= 5 ? &per_objfile
->per_bfd
->loclists
23951 : &per_objfile
->per_bfd
->loc
);
23954 /* Return the .debug_rnglists section to use for CU. */
23955 static struct dwarf2_section_info
*
23956 cu_debug_rnglists_section (struct dwarf2_cu
*cu
, dwarf_tag tag
)
23958 if (cu
->header
.version
< 5)
23959 error (_(".debug_rnglists section cannot be used in DWARF %d"),
23960 cu
->header
.version
);
23961 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
23963 /* Make sure we read the .debug_rnglists section from the file that
23964 contains the DW_AT_ranges attribute we are reading. Normally that
23965 would be the .dwo file, if there is one. However for DW_TAG_compile_unit
23966 or DW_TAG_skeleton unit, we always want to read from objfile/linked
23968 if (cu
->dwo_unit
!= nullptr
23969 && tag
!= DW_TAG_compile_unit
23970 && tag
!= DW_TAG_skeleton_unit
)
23972 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
23974 if (sections
->rnglists
.size
> 0)
23975 return §ions
->rnglists
;
23977 error (_(".debug_rnglists section is missing from .dwo file."));
23979 return &dwarf2_per_objfile
->per_bfd
->rnglists
;
23982 /* A helper function that fills in a dwarf2_loclist_baton. */
23985 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
23986 struct dwarf2_loclist_baton
*baton
,
23987 const struct attribute
*attr
)
23989 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23990 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
23992 section
->read (per_objfile
->objfile
);
23994 baton
->per_objfile
= per_objfile
;
23995 baton
->per_cu
= cu
->per_cu
;
23996 gdb_assert (baton
->per_cu
);
23997 /* We don't know how long the location list is, but make sure we
23998 don't run off the edge of the section. */
23999 baton
->size
= section
->size
- attr
->as_unsigned ();
24000 baton
->data
= section
->buffer
+ attr
->as_unsigned ();
24001 if (cu
->base_address
.has_value ())
24002 baton
->base_address
= *cu
->base_address
;
24004 baton
->base_address
= 0;
24005 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
24009 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
24010 struct dwarf2_cu
*cu
, int is_block
)
24012 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24013 struct objfile
*objfile
= per_objfile
->objfile
;
24014 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24016 if (attr
->form_is_section_offset ()
24017 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24018 the section. If so, fall through to the complaint in the
24020 && attr
->as_unsigned () < section
->get_size (objfile
))
24022 struct dwarf2_loclist_baton
*baton
;
24024 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
24026 fill_in_loclist_baton (cu
, baton
, attr
);
24028 if (!cu
->base_address
.has_value ())
24029 complaint (_("Location list used without "
24030 "specifying the CU base address."));
24032 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24033 ? dwarf2_loclist_block_index
24034 : dwarf2_loclist_index
);
24035 SYMBOL_LOCATION_BATON (sym
) = baton
;
24039 struct dwarf2_locexpr_baton
*baton
;
24041 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
24042 baton
->per_objfile
= per_objfile
;
24043 baton
->per_cu
= cu
->per_cu
;
24044 gdb_assert (baton
->per_cu
);
24046 if (attr
->form_is_block ())
24048 /* Note that we're just copying the block's data pointer
24049 here, not the actual data. We're still pointing into the
24050 info_buffer for SYM's objfile; right now we never release
24051 that buffer, but when we do clean up properly this may
24053 struct dwarf_block
*block
= attr
->as_block ();
24054 baton
->size
= block
->size
;
24055 baton
->data
= block
->data
;
24059 dwarf2_invalid_attrib_class_complaint ("location description",
24060 sym
->natural_name ());
24064 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24065 ? dwarf2_locexpr_block_index
24066 : dwarf2_locexpr_index
);
24067 SYMBOL_LOCATION_BATON (sym
) = baton
;
24073 const comp_unit_head
*
24074 dwarf2_per_cu_data::get_header () const
24076 if (!m_header_read_in
)
24078 const gdb_byte
*info_ptr
24079 = this->section
->buffer
+ to_underlying (this->sect_off
);
24081 memset (&m_header
, 0, sizeof (m_header
));
24083 read_comp_unit_head (&m_header
, info_ptr
, this->section
,
24084 rcuh_kind::COMPILE
);
24093 dwarf2_per_cu_data::addr_size () const
24095 return this->get_header ()->addr_size
;
24101 dwarf2_per_cu_data::offset_size () const
24103 return this->get_header ()->offset_size
;
24109 dwarf2_per_cu_data::ref_addr_size () const
24111 const comp_unit_head
*header
= this->get_header ();
24113 if (header
->version
== 2)
24114 return header
->addr_size
;
24116 return header
->offset_size
;
24122 dwarf2_cu::addr_type () const
24124 struct objfile
*objfile
= this->per_objfile
->objfile
;
24125 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
24126 struct type
*addr_type
= lookup_pointer_type (void_type
);
24127 int addr_size
= this->per_cu
->addr_size ();
24129 if (TYPE_LENGTH (addr_type
) == addr_size
)
24132 addr_type
= addr_sized_int_type (addr_type
->is_unsigned ());
24136 /* A helper function for dwarf2_find_containing_comp_unit that returns
24137 the index of the result, and that searches a vector. It will
24138 return a result even if the offset in question does not actually
24139 occur in any CU. This is separate so that it can be unit
24143 dwarf2_find_containing_comp_unit
24144 (sect_offset sect_off
,
24145 unsigned int offset_in_dwz
,
24146 const std::vector
<dwarf2_per_cu_data
*> &all_comp_units
)
24151 high
= all_comp_units
.size () - 1;
24154 struct dwarf2_per_cu_data
*mid_cu
;
24155 int mid
= low
+ (high
- low
) / 2;
24157 mid_cu
= all_comp_units
[mid
];
24158 if (mid_cu
->is_dwz
> offset_in_dwz
24159 || (mid_cu
->is_dwz
== offset_in_dwz
24160 && mid_cu
->sect_off
+ mid_cu
->length
> sect_off
))
24165 gdb_assert (low
== high
);
24169 /* Locate the .debug_info compilation unit from CU's objfile which contains
24170 the DIE at OFFSET. Raises an error on failure. */
24172 static struct dwarf2_per_cu_data
*
24173 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
24174 unsigned int offset_in_dwz
,
24175 dwarf2_per_objfile
*per_objfile
)
24177 int low
= dwarf2_find_containing_comp_unit
24178 (sect_off
, offset_in_dwz
, per_objfile
->per_bfd
->all_comp_units
);
24179 dwarf2_per_cu_data
*this_cu
= per_objfile
->per_bfd
->all_comp_units
[low
];
24181 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
24183 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
24184 error (_("Dwarf Error: could not find partial DIE containing "
24185 "offset %s [in module %s]"),
24186 sect_offset_str (sect_off
),
24187 bfd_get_filename (per_objfile
->objfile
->obfd
));
24189 gdb_assert (per_objfile
->per_bfd
->all_comp_units
[low
-1]->sect_off
24191 return per_objfile
->per_bfd
->all_comp_units
[low
-1];
24195 if (low
== per_objfile
->per_bfd
->all_comp_units
.size () - 1
24196 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
24197 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
24198 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
24205 namespace selftests
{
24206 namespace find_containing_comp_unit
{
24211 struct dwarf2_per_cu_data one
{};
24212 struct dwarf2_per_cu_data two
{};
24213 struct dwarf2_per_cu_data three
{};
24214 struct dwarf2_per_cu_data four
{};
24217 two
.sect_off
= sect_offset (one
.length
);
24222 four
.sect_off
= sect_offset (three
.length
);
24226 std::vector
<dwarf2_per_cu_data
*> units
;
24227 units
.push_back (&one
);
24228 units
.push_back (&two
);
24229 units
.push_back (&three
);
24230 units
.push_back (&four
);
24234 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 0, units
);
24235 SELF_CHECK (units
[result
] == &one
);
24236 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 0, units
);
24237 SELF_CHECK (units
[result
] == &one
);
24238 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 0, units
);
24239 SELF_CHECK (units
[result
] == &two
);
24241 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 1, units
);
24242 SELF_CHECK (units
[result
] == &three
);
24243 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 1, units
);
24244 SELF_CHECK (units
[result
] == &three
);
24245 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 1, units
);
24246 SELF_CHECK (units
[result
] == &four
);
24252 #endif /* GDB_SELF_TEST */
24254 /* Initialize dwarf2_cu to read PER_CU, in the context of PER_OBJFILE. */
24256 dwarf2_cu::dwarf2_cu (dwarf2_per_cu_data
*per_cu
,
24257 dwarf2_per_objfile
*per_objfile
)
24259 per_objfile (per_objfile
),
24261 has_loclist (false),
24262 checked_producer (false),
24263 producer_is_gxx_lt_4_6 (false),
24264 producer_is_gcc_lt_4_3 (false),
24265 producer_is_icc (false),
24266 producer_is_icc_lt_14 (false),
24267 producer_is_codewarrior (false),
24268 processing_has_namespace_info (false)
24272 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
24275 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
24276 enum language pretend_language
)
24278 struct attribute
*attr
;
24280 /* Set the language we're debugging. */
24281 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
24282 if (attr
!= nullptr)
24283 set_cu_language (attr
->constant_value (0), cu
);
24286 cu
->language
= pretend_language
;
24287 cu
->language_defn
= language_def (cu
->language
);
24290 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
24296 dwarf2_per_objfile::get_cu (dwarf2_per_cu_data
*per_cu
)
24298 auto it
= m_dwarf2_cus
.find (per_cu
);
24299 if (it
== m_dwarf2_cus
.end ())
24308 dwarf2_per_objfile::set_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_cu
*cu
)
24310 gdb_assert (this->get_cu (per_cu
) == nullptr);
24312 m_dwarf2_cus
[per_cu
] = cu
;
24318 dwarf2_per_objfile::age_comp_units ()
24320 /* Start by clearing all marks. */
24321 for (auto pair
: m_dwarf2_cus
)
24322 pair
.second
->mark
= false;
24324 /* Traverse all CUs, mark them and their dependencies if used recently
24326 for (auto pair
: m_dwarf2_cus
)
24328 dwarf2_cu
*cu
= pair
.second
;
24331 if (cu
->last_used
<= dwarf_max_cache_age
)
24335 /* Delete all CUs still not marked. */
24336 for (auto it
= m_dwarf2_cus
.begin (); it
!= m_dwarf2_cus
.end ();)
24338 dwarf2_cu
*cu
= it
->second
;
24343 it
= m_dwarf2_cus
.erase (it
);
24353 dwarf2_per_objfile::remove_cu (dwarf2_per_cu_data
*per_cu
)
24355 auto it
= m_dwarf2_cus
.find (per_cu
);
24356 if (it
== m_dwarf2_cus
.end ())
24361 m_dwarf2_cus
.erase (it
);
24364 dwarf2_per_objfile::~dwarf2_per_objfile ()
24369 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
24370 We store these in a hash table separate from the DIEs, and preserve them
24371 when the DIEs are flushed out of cache.
24373 The CU "per_cu" pointer is needed because offset alone is not enough to
24374 uniquely identify the type. A file may have multiple .debug_types sections,
24375 or the type may come from a DWO file. Furthermore, while it's more logical
24376 to use per_cu->section+offset, with Fission the section with the data is in
24377 the DWO file but we don't know that section at the point we need it.
24378 We have to use something in dwarf2_per_cu_data (or the pointer to it)
24379 because we can enter the lookup routine, get_die_type_at_offset, from
24380 outside this file, and thus won't necessarily have PER_CU->cu.
24381 Fortunately, PER_CU is stable for the life of the objfile. */
24383 struct dwarf2_per_cu_offset_and_type
24385 const struct dwarf2_per_cu_data
*per_cu
;
24386 sect_offset sect_off
;
24390 /* Hash function for a dwarf2_per_cu_offset_and_type. */
24393 per_cu_offset_and_type_hash (const void *item
)
24395 const struct dwarf2_per_cu_offset_and_type
*ofs
24396 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
24398 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
24401 /* Equality function for a dwarf2_per_cu_offset_and_type. */
24404 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
24406 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
24407 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
24408 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
24409 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
24411 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
24412 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
24415 /* Set the type associated with DIE to TYPE. Save it in CU's hash
24416 table if necessary. For convenience, return TYPE.
24418 The DIEs reading must have careful ordering to:
24419 * Not cause infinite loops trying to read in DIEs as a prerequisite for
24420 reading current DIE.
24421 * Not trying to dereference contents of still incompletely read in types
24422 while reading in other DIEs.
24423 * Enable referencing still incompletely read in types just by a pointer to
24424 the type without accessing its fields.
24426 Therefore caller should follow these rules:
24427 * Try to fetch any prerequisite types we may need to build this DIE type
24428 before building the type and calling set_die_type.
24429 * After building type call set_die_type for current DIE as soon as
24430 possible before fetching more types to complete the current type.
24431 * Make the type as complete as possible before fetching more types. */
24433 static struct type
*
24434 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
24436 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24437 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
24438 struct objfile
*objfile
= per_objfile
->objfile
;
24439 struct attribute
*attr
;
24440 struct dynamic_prop prop
;
24442 /* For Ada types, make sure that the gnat-specific data is always
24443 initialized (if not already set). There are a few types where
24444 we should not be doing so, because the type-specific area is
24445 already used to hold some other piece of info (eg: TYPE_CODE_FLT
24446 where the type-specific area is used to store the floatformat).
24447 But this is not a problem, because the gnat-specific information
24448 is actually not needed for these types. */
24449 if (need_gnat_info (cu
)
24450 && type
->code () != TYPE_CODE_FUNC
24451 && type
->code () != TYPE_CODE_FLT
24452 && type
->code () != TYPE_CODE_METHODPTR
24453 && type
->code () != TYPE_CODE_MEMBERPTR
24454 && type
->code () != TYPE_CODE_METHOD
24455 && !HAVE_GNAT_AUX_INFO (type
))
24456 INIT_GNAT_SPECIFIC (type
);
24458 /* Read DW_AT_allocated and set in type. */
24459 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
24462 struct type
*prop_type
= cu
->addr_sized_int_type (false);
24463 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24464 type
->add_dyn_prop (DYN_PROP_ALLOCATED
, prop
);
24467 /* Read DW_AT_associated and set in type. */
24468 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
24471 struct type
*prop_type
= cu
->addr_sized_int_type (false);
24472 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24473 type
->add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
);
24476 /* Read DW_AT_data_location and set in type. */
24477 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
24478 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
24479 type
->add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
);
24481 if (per_objfile
->die_type_hash
== NULL
)
24482 per_objfile
->die_type_hash
24483 = htab_up (htab_create_alloc (127,
24484 per_cu_offset_and_type_hash
,
24485 per_cu_offset_and_type_eq
,
24486 NULL
, xcalloc
, xfree
));
24488 ofs
.per_cu
= cu
->per_cu
;
24489 ofs
.sect_off
= die
->sect_off
;
24491 slot
= (struct dwarf2_per_cu_offset_and_type
**)
24492 htab_find_slot (per_objfile
->die_type_hash
.get (), &ofs
, INSERT
);
24494 complaint (_("A problem internal to GDB: DIE %s has type already set"),
24495 sect_offset_str (die
->sect_off
));
24496 *slot
= XOBNEW (&objfile
->objfile_obstack
,
24497 struct dwarf2_per_cu_offset_and_type
);
24502 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
24503 or return NULL if the die does not have a saved type. */
24505 static struct type
*
24506 get_die_type_at_offset (sect_offset sect_off
,
24507 dwarf2_per_cu_data
*per_cu
,
24508 dwarf2_per_objfile
*per_objfile
)
24510 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
24512 if (per_objfile
->die_type_hash
== NULL
)
24515 ofs
.per_cu
= per_cu
;
24516 ofs
.sect_off
= sect_off
;
24517 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
24518 htab_find (per_objfile
->die_type_hash
.get (), &ofs
));
24525 /* Look up the type for DIE in CU in die_type_hash,
24526 or return NULL if DIE does not have a saved type. */
24528 static struct type
*
24529 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
24531 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
, cu
->per_objfile
);
24534 /* Add a dependence relationship from CU to REF_PER_CU. */
24537 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
24538 struct dwarf2_per_cu_data
*ref_per_cu
)
24542 if (cu
->dependencies
== NULL
)
24544 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
24545 NULL
, &cu
->comp_unit_obstack
,
24546 hashtab_obstack_allocate
,
24547 dummy_obstack_deallocate
);
24549 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
24551 *slot
= ref_per_cu
;
24554 /* Subroutine of dwarf2_mark to pass to htab_traverse.
24555 Set the mark field in every compilation unit in the
24556 cache that we must keep because we are keeping CU.
24558 DATA is the dwarf2_per_objfile object in which to look up CUs. */
24561 dwarf2_mark_helper (void **slot
, void *data
)
24563 dwarf2_per_cu_data
*per_cu
= (dwarf2_per_cu_data
*) *slot
;
24564 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) data
;
24565 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
24567 /* cu->dependencies references may not yet have been ever read if QUIT aborts
24568 reading of the chain. As such dependencies remain valid it is not much
24569 useful to track and undo them during QUIT cleanups. */
24578 if (cu
->dependencies
!= nullptr)
24579 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, per_objfile
);
24584 /* Set the mark field in CU and in every other compilation unit in the
24585 cache that we must keep because we are keeping CU. */
24588 dwarf2_mark (struct dwarf2_cu
*cu
)
24595 if (cu
->dependencies
!= nullptr)
24596 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, cu
->per_objfile
);
24599 /* Trivial hash function for partial_die_info: the hash value of a DIE
24600 is its offset in .debug_info for this objfile. */
24603 partial_die_hash (const void *item
)
24605 const struct partial_die_info
*part_die
24606 = (const struct partial_die_info
*) item
;
24608 return to_underlying (part_die
->sect_off
);
24611 /* Trivial comparison function for partial_die_info structures: two DIEs
24612 are equal if they have the same offset. */
24615 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
24617 const struct partial_die_info
*part_die_lhs
24618 = (const struct partial_die_info
*) item_lhs
;
24619 const struct partial_die_info
*part_die_rhs
24620 = (const struct partial_die_info
*) item_rhs
;
24622 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
24625 struct cmd_list_element
*set_dwarf_cmdlist
;
24626 struct cmd_list_element
*show_dwarf_cmdlist
;
24629 show_check_physname (struct ui_file
*file
, int from_tty
,
24630 struct cmd_list_element
*c
, const char *value
)
24632 fprintf_filtered (file
,
24633 _("Whether to check \"physname\" is %s.\n"),
24637 void _initialize_dwarf2_read ();
24639 _initialize_dwarf2_read ()
24641 add_basic_prefix_cmd ("dwarf", class_maintenance
, _("\
24642 Set DWARF specific variables.\n\
24643 Configure DWARF variables such as the cache size."),
24644 &set_dwarf_cmdlist
, "maintenance set dwarf ",
24645 0/*allow-unknown*/, &maintenance_set_cmdlist
);
24647 add_show_prefix_cmd ("dwarf", class_maintenance
, _("\
24648 Show DWARF specific variables.\n\
24649 Show DWARF variables such as the cache size."),
24650 &show_dwarf_cmdlist
, "maintenance show dwarf ",
24651 0/*allow-unknown*/, &maintenance_show_cmdlist
);
24653 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
24654 &dwarf_max_cache_age
, _("\
24655 Set the upper bound on the age of cached DWARF compilation units."), _("\
24656 Show the upper bound on the age of cached DWARF compilation units."), _("\
24657 A higher limit means that cached compilation units will be stored\n\
24658 in memory longer, and more total memory will be used. Zero disables\n\
24659 caching, which can slow down startup."),
24661 show_dwarf_max_cache_age
,
24662 &set_dwarf_cmdlist
,
24663 &show_dwarf_cmdlist
);
24665 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
24666 Set debugging of the DWARF reader."), _("\
24667 Show debugging of the DWARF reader."), _("\
24668 When enabled (non-zero), debugging messages are printed during DWARF\n\
24669 reading and symtab expansion. A value of 1 (one) provides basic\n\
24670 information. A value greater than 1 provides more verbose information."),
24673 &setdebuglist
, &showdebuglist
);
24675 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
24676 Set debugging of the DWARF DIE reader."), _("\
24677 Show debugging of the DWARF DIE reader."), _("\
24678 When enabled (non-zero), DIEs are dumped after they are read in.\n\
24679 The value is the maximum depth to print."),
24682 &setdebuglist
, &showdebuglist
);
24684 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
24685 Set debugging of the dwarf line reader."), _("\
24686 Show debugging of the dwarf line reader."), _("\
24687 When enabled (non-zero), line number entries are dumped as they are read in.\n\
24688 A value of 1 (one) provides basic information.\n\
24689 A value greater than 1 provides more verbose information."),
24692 &setdebuglist
, &showdebuglist
);
24694 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
24695 Set cross-checking of \"physname\" code against demangler."), _("\
24696 Show cross-checking of \"physname\" code against demangler."), _("\
24697 When enabled, GDB's internal \"physname\" code is checked against\n\
24699 NULL
, show_check_physname
,
24700 &setdebuglist
, &showdebuglist
);
24702 add_setshow_boolean_cmd ("use-deprecated-index-sections",
24703 no_class
, &use_deprecated_index_sections
, _("\
24704 Set whether to use deprecated gdb_index sections."), _("\
24705 Show whether to use deprecated gdb_index sections."), _("\
24706 When enabled, deprecated .gdb_index sections are used anyway.\n\
24707 Normally they are ignored either because of a missing feature or\n\
24708 performance issue.\n\
24709 Warning: This option must be enabled before gdb reads the file."),
24712 &setlist
, &showlist
);
24714 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
24715 &dwarf2_locexpr_funcs
);
24716 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
24717 &dwarf2_loclist_funcs
);
24719 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
24720 &dwarf2_block_frame_base_locexpr_funcs
);
24721 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
24722 &dwarf2_block_frame_base_loclist_funcs
);
24725 selftests::register_test ("dw2_expand_symtabs_matching",
24726 selftests::dw2_expand_symtabs_matching::run_test
);
24727 selftests::register_test ("dwarf2_find_containing_comp_unit",
24728 selftests::find_containing_comp_unit::run_test
);