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
*read_subrange_index_type (struct die_info
*die
,
1377 struct dwarf2_cu
*cu
);
1379 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1381 static int need_gnat_info (struct dwarf2_cu
*);
1383 static struct type
*die_descriptive_type (struct die_info
*,
1384 struct dwarf2_cu
*);
1386 static void set_descriptive_type (struct type
*, struct die_info
*,
1387 struct dwarf2_cu
*);
1389 static struct type
*die_containing_type (struct die_info
*,
1390 struct dwarf2_cu
*);
1392 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1393 struct dwarf2_cu
*);
1395 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1397 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1399 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1401 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1402 const char *suffix
, int physname
,
1403 struct dwarf2_cu
*cu
);
1405 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1407 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1409 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1411 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1413 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1415 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1417 /* Return the .debug_loclists section to use for cu. */
1418 static struct dwarf2_section_info
*cu_debug_loc_section (struct dwarf2_cu
*cu
);
1420 /* Return the .debug_rnglists section to use for cu. */
1421 static struct dwarf2_section_info
*cu_debug_rnglists_section
1422 (struct dwarf2_cu
*cu
, dwarf_tag tag
);
1424 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1425 values. Keep the items ordered with increasing constraints compliance. */
1428 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1429 PC_BOUNDS_NOT_PRESENT
,
1431 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1432 were present but they do not form a valid range of PC addresses. */
1435 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1438 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1442 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1443 CORE_ADDR
*, CORE_ADDR
*,
1447 static void get_scope_pc_bounds (struct die_info
*,
1448 CORE_ADDR
*, CORE_ADDR
*,
1449 struct dwarf2_cu
*);
1451 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1452 CORE_ADDR
, struct dwarf2_cu
*);
1454 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1455 struct dwarf2_cu
*);
1457 static void dwarf2_attach_fields_to_type (struct field_info
*,
1458 struct type
*, struct dwarf2_cu
*);
1460 static void dwarf2_add_member_fn (struct field_info
*,
1461 struct die_info
*, struct type
*,
1462 struct dwarf2_cu
*);
1464 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1466 struct dwarf2_cu
*);
1468 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1470 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1472 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1474 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1476 static struct using_direct
**using_directives (struct dwarf2_cu
*cu
);
1478 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1480 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1482 static struct type
*read_module_type (struct die_info
*die
,
1483 struct dwarf2_cu
*cu
);
1485 static const char *namespace_name (struct die_info
*die
,
1486 int *is_anonymous
, struct dwarf2_cu
*);
1488 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1490 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*,
1493 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1494 struct dwarf2_cu
*);
1496 static struct die_info
*read_die_and_siblings_1
1497 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1500 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1501 const gdb_byte
*info_ptr
,
1502 const gdb_byte
**new_info_ptr
,
1503 struct die_info
*parent
);
1505 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1506 struct die_info
**, const gdb_byte
*,
1509 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1510 struct die_info
**, const gdb_byte
*);
1512 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1514 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1517 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1519 static const char *dwarf2_full_name (const char *name
,
1520 struct die_info
*die
,
1521 struct dwarf2_cu
*cu
);
1523 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1524 struct dwarf2_cu
*cu
);
1526 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1527 struct dwarf2_cu
**);
1529 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1531 static void dump_die_for_error (struct die_info
*);
1533 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1536 /*static*/ void dump_die (struct die_info
*, int max_level
);
1538 static void store_in_ref_table (struct die_info
*,
1539 struct dwarf2_cu
*);
1541 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1542 const struct attribute
*,
1543 struct dwarf2_cu
**);
1545 static struct die_info
*follow_die_ref (struct die_info
*,
1546 const struct attribute
*,
1547 struct dwarf2_cu
**);
1549 static struct die_info
*follow_die_sig (struct die_info
*,
1550 const struct attribute
*,
1551 struct dwarf2_cu
**);
1553 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1554 struct dwarf2_cu
*);
1556 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1557 const struct attribute
*,
1558 struct dwarf2_cu
*);
1560 static void load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
1561 dwarf2_per_objfile
*per_objfile
);
1563 static void read_signatured_type (signatured_type
*sig_type
,
1564 dwarf2_per_objfile
*per_objfile
);
1566 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1567 struct die_info
*die
, struct dwarf2_cu
*cu
,
1568 struct dynamic_prop
*prop
, struct type
*type
);
1570 /* memory allocation interface */
1572 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1574 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1576 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1578 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1579 struct dwarf2_loclist_baton
*baton
,
1580 const struct attribute
*attr
);
1582 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1584 struct dwarf2_cu
*cu
,
1587 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1588 const gdb_byte
*info_ptr
,
1589 struct abbrev_info
*abbrev
);
1591 static hashval_t
partial_die_hash (const void *item
);
1593 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1595 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1596 (sect_offset sect_off
, unsigned int offset_in_dwz
,
1597 dwarf2_per_objfile
*per_objfile
);
1599 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1600 struct die_info
*comp_unit_die
,
1601 enum language pretend_language
);
1603 static struct type
*set_die_type (struct die_info
*, struct type
*,
1604 struct dwarf2_cu
*, bool = false);
1606 static void create_all_comp_units (dwarf2_per_objfile
*per_objfile
);
1608 static int create_all_type_units (dwarf2_per_objfile
*per_objfile
);
1610 static void load_full_comp_unit (dwarf2_per_cu_data
*per_cu
,
1611 dwarf2_per_objfile
*per_objfile
,
1612 dwarf2_cu
*existing_cu
,
1614 enum language pretend_language
);
1616 static void process_full_comp_unit (dwarf2_cu
*cu
,
1617 enum language pretend_language
);
1619 static void process_full_type_unit (dwarf2_cu
*cu
,
1620 enum language pretend_language
);
1622 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1623 struct dwarf2_per_cu_data
*);
1625 static void dwarf2_mark (struct dwarf2_cu
*);
1627 static struct type
*get_die_type_at_offset (sect_offset
,
1628 dwarf2_per_cu_data
*per_cu
,
1629 dwarf2_per_objfile
*per_objfile
);
1631 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1633 static void queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
1634 dwarf2_per_objfile
*per_objfile
,
1635 enum language pretend_language
);
1637 static void process_queue (dwarf2_per_objfile
*per_objfile
);
1639 /* Class, the destructor of which frees all allocated queue entries. This
1640 will only have work to do if an error was thrown while processing the
1641 dwarf. If no error was thrown then the queue entries should have all
1642 been processed, and freed, as we went along. */
1644 class dwarf2_queue_guard
1647 explicit dwarf2_queue_guard (dwarf2_per_objfile
*per_objfile
)
1648 : m_per_objfile (per_objfile
)
1652 /* Free any entries remaining on the queue. There should only be
1653 entries left if we hit an error while processing the dwarf. */
1654 ~dwarf2_queue_guard ()
1656 /* Ensure that no memory is allocated by the queue. */
1657 std::queue
<dwarf2_queue_item
> empty
;
1658 std::swap (m_per_objfile
->per_bfd
->queue
, empty
);
1661 DISABLE_COPY_AND_ASSIGN (dwarf2_queue_guard
);
1664 dwarf2_per_objfile
*m_per_objfile
;
1667 dwarf2_queue_item::~dwarf2_queue_item ()
1669 /* Anything still marked queued is likely to be in an
1670 inconsistent state, so discard it. */
1673 per_objfile
->remove_cu (per_cu
);
1678 /* The return type of find_file_and_directory. Note, the enclosed
1679 string pointers are only valid while this object is valid. */
1681 struct file_and_directory
1683 /* The filename. This is never NULL. */
1686 /* The compilation directory. NULL if not known. If we needed to
1687 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1688 points directly to the DW_AT_comp_dir string attribute owned by
1689 the obstack that owns the DIE. */
1690 const char *comp_dir
;
1692 /* If we needed to build a new string for comp_dir, this is what
1693 owns the storage. */
1694 std::string comp_dir_storage
;
1697 static file_and_directory
find_file_and_directory (struct die_info
*die
,
1698 struct dwarf2_cu
*cu
);
1700 static htab_up
allocate_signatured_type_table ();
1702 static htab_up
allocate_dwo_unit_table ();
1704 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1705 (dwarf2_per_objfile
*per_objfile
, struct dwp_file
*dwp_file
,
1706 const char *comp_dir
, ULONGEST signature
, int is_debug_types
);
1708 static struct dwp_file
*get_dwp_file (dwarf2_per_objfile
*per_objfile
);
1710 static struct dwo_unit
*lookup_dwo_comp_unit
1711 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
1712 ULONGEST signature
);
1714 static struct dwo_unit
*lookup_dwo_type_unit
1715 (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
);
1717 static void queue_and_load_all_dwo_tus (dwarf2_cu
*cu
);
1719 /* A unique pointer to a dwo_file. */
1721 typedef std::unique_ptr
<struct dwo_file
> dwo_file_up
;
1723 static void process_cu_includes (dwarf2_per_objfile
*per_objfile
);
1725 static void check_producer (struct dwarf2_cu
*cu
);
1727 static void free_line_header_voidp (void *arg
);
1729 /* Various complaints about symbol reading that don't abort the process. */
1732 dwarf2_debug_line_missing_file_complaint (void)
1734 complaint (_(".debug_line section has line data without a file"));
1738 dwarf2_debug_line_missing_end_sequence_complaint (void)
1740 complaint (_(".debug_line section has line "
1741 "program sequence without an end"));
1745 dwarf2_complex_location_expr_complaint (void)
1747 complaint (_("location expression too complex"));
1751 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
1754 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
1759 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
1761 complaint (_("invalid attribute class or form for '%s' in '%s'"),
1765 /* Hash function for line_header_hash. */
1768 line_header_hash (const struct line_header
*ofs
)
1770 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
1773 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1776 line_header_hash_voidp (const void *item
)
1778 const struct line_header
*ofs
= (const struct line_header
*) item
;
1780 return line_header_hash (ofs
);
1783 /* Equality function for line_header_hash. */
1786 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
1788 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
1789 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
1791 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
1792 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
1797 /* See declaration. */
1799 dwarf2_per_bfd::dwarf2_per_bfd (bfd
*obfd
, const dwarf2_debug_sections
*names
,
1802 can_copy (can_copy_
)
1805 names
= &dwarf2_elf_names
;
1807 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
1808 locate_sections (obfd
, sec
, *names
);
1811 dwarf2_per_bfd::~dwarf2_per_bfd ()
1813 for (dwarf2_per_cu_data
*per_cu
: all_comp_units
)
1814 per_cu
->imported_symtabs_free ();
1816 for (signatured_type
*sig_type
: all_type_units
)
1817 sig_type
->per_cu
.imported_symtabs_free ();
1819 /* Everything else should be on this->obstack. */
1825 dwarf2_per_objfile::remove_all_cus ()
1827 for (auto pair
: m_dwarf2_cus
)
1830 m_dwarf2_cus
.clear ();
1833 /* A helper class that calls free_cached_comp_units on
1836 class free_cached_comp_units
1840 explicit free_cached_comp_units (dwarf2_per_objfile
*per_objfile
)
1841 : m_per_objfile (per_objfile
)
1845 ~free_cached_comp_units ()
1847 m_per_objfile
->remove_all_cus ();
1850 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units
);
1854 dwarf2_per_objfile
*m_per_objfile
;
1860 dwarf2_per_objfile::symtab_set_p (const dwarf2_per_cu_data
*per_cu
) const
1862 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1864 return this->m_symtabs
[per_cu
->index
] != nullptr;
1870 dwarf2_per_objfile::get_symtab (const dwarf2_per_cu_data
*per_cu
) const
1872 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1874 return this->m_symtabs
[per_cu
->index
];
1880 dwarf2_per_objfile::set_symtab (const dwarf2_per_cu_data
*per_cu
,
1881 compunit_symtab
*symtab
)
1883 gdb_assert (per_cu
->index
< this->m_symtabs
.size ());
1884 gdb_assert (this->m_symtabs
[per_cu
->index
] == nullptr);
1886 this->m_symtabs
[per_cu
->index
] = symtab
;
1889 /* Try to locate the sections we need for DWARF 2 debugging
1890 information and return true if we have enough to do something.
1891 NAMES points to the dwarf2 section names, or is NULL if the standard
1892 ELF names are used. CAN_COPY is true for formats where symbol
1893 interposition is possible and so symbol values must follow copy
1894 relocation rules. */
1897 dwarf2_has_info (struct objfile
*objfile
,
1898 const struct dwarf2_debug_sections
*names
,
1901 if (objfile
->flags
& OBJF_READNEVER
)
1904 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
1906 if (per_objfile
== NULL
)
1908 dwarf2_per_bfd
*per_bfd
;
1910 /* We can share a "dwarf2_per_bfd" with other objfiles if the BFD
1911 doesn't require relocations and if there aren't partial symbols
1912 from some other reader. */
1913 if (!objfile_has_partial_symbols (objfile
)
1914 && !gdb_bfd_requires_relocations (objfile
->obfd
))
1916 /* See if one has been created for this BFD yet. */
1917 per_bfd
= dwarf2_per_bfd_bfd_data_key
.get (objfile
->obfd
);
1919 if (per_bfd
== nullptr)
1921 /* No, create it now. */
1922 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1923 dwarf2_per_bfd_bfd_data_key
.set (objfile
->obfd
, per_bfd
);
1928 /* No sharing possible, create one specifically for this objfile. */
1929 per_bfd
= new dwarf2_per_bfd (objfile
->obfd
, names
, can_copy
);
1930 dwarf2_per_bfd_objfile_data_key
.set (objfile
, per_bfd
);
1933 per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
, per_bfd
);
1936 return (!per_objfile
->per_bfd
->info
.is_virtual
1937 && per_objfile
->per_bfd
->info
.s
.section
!= NULL
1938 && !per_objfile
->per_bfd
->abbrev
.is_virtual
1939 && per_objfile
->per_bfd
->abbrev
.s
.section
!= NULL
);
1942 /* When loading sections, we look either for uncompressed section or for
1943 compressed section names. */
1946 section_is_p (const char *section_name
,
1947 const struct dwarf2_section_names
*names
)
1949 if (names
->normal
!= NULL
1950 && strcmp (section_name
, names
->normal
) == 0)
1952 if (names
->compressed
!= NULL
1953 && strcmp (section_name
, names
->compressed
) == 0)
1958 /* See declaration. */
1961 dwarf2_per_bfd::locate_sections (bfd
*abfd
, asection
*sectp
,
1962 const dwarf2_debug_sections
&names
)
1964 flagword aflag
= bfd_section_flags (sectp
);
1966 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
1969 else if (elf_section_data (sectp
)->this_hdr
.sh_size
1970 > bfd_get_file_size (abfd
))
1972 bfd_size_type size
= elf_section_data (sectp
)->this_hdr
.sh_size
;
1973 warning (_("Discarding section %s which has a section size (%s"
1974 ") larger than the file size [in module %s]"),
1975 bfd_section_name (sectp
), phex_nz (size
, sizeof (size
)),
1976 bfd_get_filename (abfd
));
1978 else if (section_is_p (sectp
->name
, &names
.info
))
1980 this->info
.s
.section
= sectp
;
1981 this->info
.size
= bfd_section_size (sectp
);
1983 else if (section_is_p (sectp
->name
, &names
.abbrev
))
1985 this->abbrev
.s
.section
= sectp
;
1986 this->abbrev
.size
= bfd_section_size (sectp
);
1988 else if (section_is_p (sectp
->name
, &names
.line
))
1990 this->line
.s
.section
= sectp
;
1991 this->line
.size
= bfd_section_size (sectp
);
1993 else if (section_is_p (sectp
->name
, &names
.loc
))
1995 this->loc
.s
.section
= sectp
;
1996 this->loc
.size
= bfd_section_size (sectp
);
1998 else if (section_is_p (sectp
->name
, &names
.loclists
))
2000 this->loclists
.s
.section
= sectp
;
2001 this->loclists
.size
= bfd_section_size (sectp
);
2003 else if (section_is_p (sectp
->name
, &names
.macinfo
))
2005 this->macinfo
.s
.section
= sectp
;
2006 this->macinfo
.size
= bfd_section_size (sectp
);
2008 else if (section_is_p (sectp
->name
, &names
.macro
))
2010 this->macro
.s
.section
= sectp
;
2011 this->macro
.size
= bfd_section_size (sectp
);
2013 else if (section_is_p (sectp
->name
, &names
.str
))
2015 this->str
.s
.section
= sectp
;
2016 this->str
.size
= bfd_section_size (sectp
);
2018 else if (section_is_p (sectp
->name
, &names
.str_offsets
))
2020 this->str_offsets
.s
.section
= sectp
;
2021 this->str_offsets
.size
= bfd_section_size (sectp
);
2023 else if (section_is_p (sectp
->name
, &names
.line_str
))
2025 this->line_str
.s
.section
= sectp
;
2026 this->line_str
.size
= bfd_section_size (sectp
);
2028 else if (section_is_p (sectp
->name
, &names
.addr
))
2030 this->addr
.s
.section
= sectp
;
2031 this->addr
.size
= bfd_section_size (sectp
);
2033 else if (section_is_p (sectp
->name
, &names
.frame
))
2035 this->frame
.s
.section
= sectp
;
2036 this->frame
.size
= bfd_section_size (sectp
);
2038 else if (section_is_p (sectp
->name
, &names
.eh_frame
))
2040 this->eh_frame
.s
.section
= sectp
;
2041 this->eh_frame
.size
= bfd_section_size (sectp
);
2043 else if (section_is_p (sectp
->name
, &names
.ranges
))
2045 this->ranges
.s
.section
= sectp
;
2046 this->ranges
.size
= bfd_section_size (sectp
);
2048 else if (section_is_p (sectp
->name
, &names
.rnglists
))
2050 this->rnglists
.s
.section
= sectp
;
2051 this->rnglists
.size
= bfd_section_size (sectp
);
2053 else if (section_is_p (sectp
->name
, &names
.types
))
2055 struct dwarf2_section_info type_section
;
2057 memset (&type_section
, 0, sizeof (type_section
));
2058 type_section
.s
.section
= sectp
;
2059 type_section
.size
= bfd_section_size (sectp
);
2061 this->types
.push_back (type_section
);
2063 else if (section_is_p (sectp
->name
, &names
.gdb_index
))
2065 this->gdb_index
.s
.section
= sectp
;
2066 this->gdb_index
.size
= bfd_section_size (sectp
);
2068 else if (section_is_p (sectp
->name
, &names
.debug_names
))
2070 this->debug_names
.s
.section
= sectp
;
2071 this->debug_names
.size
= bfd_section_size (sectp
);
2073 else if (section_is_p (sectp
->name
, &names
.debug_aranges
))
2075 this->debug_aranges
.s
.section
= sectp
;
2076 this->debug_aranges
.size
= bfd_section_size (sectp
);
2079 if ((bfd_section_flags (sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2080 && bfd_section_vma (sectp
) == 0)
2081 this->has_section_at_zero
= true;
2084 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2088 dwarf2_get_section_info (struct objfile
*objfile
,
2089 enum dwarf2_section_enum sect
,
2090 asection
**sectp
, const gdb_byte
**bufp
,
2091 bfd_size_type
*sizep
)
2093 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
2094 struct dwarf2_section_info
*info
;
2096 /* We may see an objfile without any DWARF, in which case we just
2098 if (per_objfile
== NULL
)
2107 case DWARF2_DEBUG_FRAME
:
2108 info
= &per_objfile
->per_bfd
->frame
;
2110 case DWARF2_EH_FRAME
:
2111 info
= &per_objfile
->per_bfd
->eh_frame
;
2114 gdb_assert_not_reached ("unexpected section");
2117 info
->read (objfile
);
2119 *sectp
= info
->get_bfd_section ();
2120 *bufp
= info
->buffer
;
2121 *sizep
= info
->size
;
2124 /* A helper function to find the sections for a .dwz file. */
2127 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, dwz_file
*dwz_file
)
2129 /* Note that we only support the standard ELF names, because .dwz
2130 is ELF-only (at the time of writing). */
2131 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2133 dwz_file
->abbrev
.s
.section
= sectp
;
2134 dwz_file
->abbrev
.size
= bfd_section_size (sectp
);
2136 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2138 dwz_file
->info
.s
.section
= sectp
;
2139 dwz_file
->info
.size
= bfd_section_size (sectp
);
2141 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2143 dwz_file
->str
.s
.section
= sectp
;
2144 dwz_file
->str
.size
= bfd_section_size (sectp
);
2146 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2148 dwz_file
->line
.s
.section
= sectp
;
2149 dwz_file
->line
.size
= bfd_section_size (sectp
);
2151 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2153 dwz_file
->macro
.s
.section
= sectp
;
2154 dwz_file
->macro
.size
= bfd_section_size (sectp
);
2156 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2158 dwz_file
->gdb_index
.s
.section
= sectp
;
2159 dwz_file
->gdb_index
.size
= bfd_section_size (sectp
);
2161 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.debug_names
))
2163 dwz_file
->debug_names
.s
.section
= sectp
;
2164 dwz_file
->debug_names
.size
= bfd_section_size (sectp
);
2168 /* See dwarf2read.h. */
2171 dwarf2_get_dwz_file (dwarf2_per_bfd
*per_bfd
)
2173 const char *filename
;
2174 bfd_size_type buildid_len_arg
;
2178 if (per_bfd
->dwz_file
!= NULL
)
2179 return per_bfd
->dwz_file
.get ();
2181 bfd_set_error (bfd_error_no_error
);
2182 gdb::unique_xmalloc_ptr
<char> data
2183 (bfd_get_alt_debug_link_info (per_bfd
->obfd
,
2184 &buildid_len_arg
, &buildid
));
2187 if (bfd_get_error () == bfd_error_no_error
)
2189 error (_("could not read '.gnu_debugaltlink' section: %s"),
2190 bfd_errmsg (bfd_get_error ()));
2193 gdb::unique_xmalloc_ptr
<bfd_byte
> buildid_holder (buildid
);
2195 buildid_len
= (size_t) buildid_len_arg
;
2197 filename
= data
.get ();
2199 std::string abs_storage
;
2200 if (!IS_ABSOLUTE_PATH (filename
))
2202 gdb::unique_xmalloc_ptr
<char> abs
2203 = gdb_realpath (bfd_get_filename (per_bfd
->obfd
));
2205 abs_storage
= ldirname (abs
.get ()) + SLASH_STRING
+ filename
;
2206 filename
= abs_storage
.c_str ();
2209 /* First try the file name given in the section. If that doesn't
2210 work, try to use the build-id instead. */
2211 gdb_bfd_ref_ptr
dwz_bfd (gdb_bfd_open (filename
, gnutarget
));
2212 if (dwz_bfd
!= NULL
)
2214 if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2215 dwz_bfd
.reset (nullptr);
2218 if (dwz_bfd
== NULL
)
2219 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2221 if (dwz_bfd
== nullptr)
2223 gdb::unique_xmalloc_ptr
<char> alt_filename
;
2224 const char *origname
= bfd_get_filename (per_bfd
->obfd
);
2226 scoped_fd
fd (debuginfod_debuginfo_query (buildid
,
2233 /* File successfully retrieved from server. */
2234 dwz_bfd
= gdb_bfd_open (alt_filename
.get (), gnutarget
);
2236 if (dwz_bfd
== nullptr)
2237 warning (_("File \"%s\" from debuginfod cannot be opened as bfd"),
2238 alt_filename
.get ());
2239 else if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2240 dwz_bfd
.reset (nullptr);
2244 if (dwz_bfd
== NULL
)
2245 error (_("could not find '.gnu_debugaltlink' file for %s"),
2246 bfd_get_filename (per_bfd
->obfd
));
2248 std::unique_ptr
<struct dwz_file
> result
2249 (new struct dwz_file (std::move (dwz_bfd
)));
2251 for (asection
*sec
: gdb_bfd_sections (result
->dwz_bfd
))
2252 locate_dwz_sections (result
->dwz_bfd
.get (), sec
, result
.get ());
2254 gdb_bfd_record_inclusion (per_bfd
->obfd
, result
->dwz_bfd
.get ());
2255 per_bfd
->dwz_file
= std::move (result
);
2256 return per_bfd
->dwz_file
.get ();
2259 /* DWARF quick_symbols_functions support. */
2261 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2262 unique line tables, so we maintain a separate table of all .debug_line
2263 derived entries to support the sharing.
2264 All the quick functions need is the list of file names. We discard the
2265 line_header when we're done and don't need to record it here. */
2266 struct quick_file_names
2268 /* The data used to construct the hash key. */
2269 struct stmt_list_hash hash
;
2271 /* The number of entries in file_names, real_names. */
2272 unsigned int num_file_names
;
2274 /* The file names from the line table, after being run through
2276 const char **file_names
;
2278 /* The file names from the line table after being run through
2279 gdb_realpath. These are computed lazily. */
2280 const char **real_names
;
2283 /* When using the index (and thus not using psymtabs), each CU has an
2284 object of this type. This is used to hold information needed by
2285 the various "quick" methods. */
2286 struct dwarf2_per_cu_quick_data
2288 /* The file table. This can be NULL if there was no file table
2289 or it's currently not read in.
2290 NOTE: This points into dwarf2_per_objfile->per_bfd->quick_file_names_table. */
2291 struct quick_file_names
*file_names
;
2293 /* A temporary mark bit used when iterating over all CUs in
2294 expand_symtabs_matching. */
2295 unsigned int mark
: 1;
2297 /* True if we've tried to read the file table and found there isn't one.
2298 There will be no point in trying to read it again next time. */
2299 unsigned int no_file_data
: 1;
2302 /* Utility hash function for a stmt_list_hash. */
2305 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2309 if (stmt_list_hash
->dwo_unit
!= NULL
)
2310 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2311 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2315 /* Utility equality function for a stmt_list_hash. */
2318 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2319 const struct stmt_list_hash
*rhs
)
2321 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2323 if (lhs
->dwo_unit
!= NULL
2324 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2327 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2330 /* Hash function for a quick_file_names. */
2333 hash_file_name_entry (const void *e
)
2335 const struct quick_file_names
*file_data
2336 = (const struct quick_file_names
*) e
;
2338 return hash_stmt_list_entry (&file_data
->hash
);
2341 /* Equality function for a quick_file_names. */
2344 eq_file_name_entry (const void *a
, const void *b
)
2346 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2347 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2349 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2352 /* Delete function for a quick_file_names. */
2355 delete_file_name_entry (void *e
)
2357 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2360 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2362 xfree ((void*) file_data
->file_names
[i
]);
2363 if (file_data
->real_names
)
2364 xfree ((void*) file_data
->real_names
[i
]);
2367 /* The space for the struct itself lives on the obstack, so we don't
2371 /* Create a quick_file_names hash table. */
2374 create_quick_file_names_table (unsigned int nr_initial_entries
)
2376 return htab_up (htab_create_alloc (nr_initial_entries
,
2377 hash_file_name_entry
, eq_file_name_entry
,
2378 delete_file_name_entry
, xcalloc
, xfree
));
2381 /* Read in CU (dwarf2_cu object) for PER_CU in the context of PER_OBJFILE. This
2382 function is unrelated to symtabs, symtab would have to be created afterwards.
2383 You should call age_cached_comp_units after processing the CU. */
2386 load_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_per_objfile
*per_objfile
,
2389 if (per_cu
->is_debug_types
)
2390 load_full_type_unit (per_cu
, per_objfile
);
2392 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
2393 skip_partial
, language_minimal
);
2395 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
2397 return nullptr; /* Dummy CU. */
2399 dwarf2_find_base_address (cu
->dies
, cu
);
2404 /* Read in the symbols for PER_CU in the context of DWARF"_PER_OBJFILE. */
2407 dw2_do_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2408 dwarf2_per_objfile
*per_objfile
, bool skip_partial
)
2410 /* Skip type_unit_groups, reading the type units they contain
2411 is handled elsewhere. */
2412 if (per_cu
->type_unit_group_p ())
2415 /* The destructor of dwarf2_queue_guard frees any entries left on
2416 the queue. After this point we're guaranteed to leave this function
2417 with the dwarf queue empty. */
2418 dwarf2_queue_guard
q_guard (dwarf2_per_objfile
);
2420 if (!per_objfile
->symtab_set_p (per_cu
))
2422 queue_comp_unit (per_cu
, per_objfile
, language_minimal
);
2423 dwarf2_cu
*cu
= load_cu (per_cu
, per_objfile
, skip_partial
);
2425 /* If we just loaded a CU from a DWO, and we're working with an index
2426 that may badly handle TUs, load all the TUs in that DWO as well.
2427 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2428 if (!per_cu
->is_debug_types
2430 && cu
->dwo_unit
!= NULL
2431 && per_objfile
->per_bfd
->index_table
!= NULL
2432 && per_objfile
->per_bfd
->index_table
->version
<= 7
2433 /* DWP files aren't supported yet. */
2434 && get_dwp_file (per_objfile
) == NULL
)
2435 queue_and_load_all_dwo_tus (cu
);
2438 process_queue (per_objfile
);
2440 /* Age the cache, releasing compilation units that have not
2441 been used recently. */
2442 per_objfile
->age_comp_units ();
2445 /* Ensure that the symbols for PER_CU have been read in. DWARF2_PER_OBJFILE is
2446 the per-objfile for which this symtab is instantiated.
2448 Returns the resulting symbol table. */
2450 static struct compunit_symtab
*
2451 dw2_instantiate_symtab (dwarf2_per_cu_data
*per_cu
,
2452 dwarf2_per_objfile
*per_objfile
,
2455 gdb_assert (per_objfile
->per_bfd
->using_index
);
2457 if (!per_objfile
->symtab_set_p (per_cu
))
2459 free_cached_comp_units
freer (per_objfile
);
2460 scoped_restore decrementer
= increment_reading_symtab ();
2461 dw2_do_instantiate_symtab (per_cu
, per_objfile
, skip_partial
);
2462 process_cu_includes (per_objfile
);
2465 return per_objfile
->get_symtab (per_cu
);
2468 /* See declaration. */
2470 dwarf2_per_cu_data
*
2471 dwarf2_per_bfd::get_cutu (int index
)
2473 if (index
>= this->all_comp_units
.size ())
2475 index
-= this->all_comp_units
.size ();
2476 gdb_assert (index
< this->all_type_units
.size ());
2477 return &this->all_type_units
[index
]->per_cu
;
2480 return this->all_comp_units
[index
];
2483 /* See declaration. */
2485 dwarf2_per_cu_data
*
2486 dwarf2_per_bfd::get_cu (int index
)
2488 gdb_assert (index
>= 0 && index
< this->all_comp_units
.size ());
2490 return this->all_comp_units
[index
];
2493 /* See declaration. */
2496 dwarf2_per_bfd::get_tu (int index
)
2498 gdb_assert (index
>= 0 && index
< this->all_type_units
.size ());
2500 return this->all_type_units
[index
];
2505 dwarf2_per_cu_data
*
2506 dwarf2_per_bfd::allocate_per_cu ()
2508 dwarf2_per_cu_data
*result
= OBSTACK_ZALLOC (&obstack
, dwarf2_per_cu_data
);
2509 result
->per_bfd
= this;
2510 result
->index
= m_num_psymtabs
++;
2517 dwarf2_per_bfd::allocate_signatured_type ()
2519 signatured_type
*result
= OBSTACK_ZALLOC (&obstack
, signatured_type
);
2520 result
->per_cu
.per_bfd
= this;
2521 result
->per_cu
.index
= m_num_psymtabs
++;
2525 /* Return a new dwarf2_per_cu_data allocated on the per-bfd
2526 obstack, and constructed with the specified field values. */
2528 static dwarf2_per_cu_data
*
2529 create_cu_from_index_list (dwarf2_per_bfd
*per_bfd
,
2530 struct dwarf2_section_info
*section
,
2532 sect_offset sect_off
, ULONGEST length
)
2534 dwarf2_per_cu_data
*the_cu
= per_bfd
->allocate_per_cu ();
2535 the_cu
->sect_off
= sect_off
;
2536 the_cu
->length
= length
;
2537 the_cu
->section
= section
;
2538 the_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
2539 struct dwarf2_per_cu_quick_data
);
2540 the_cu
->is_dwz
= is_dwz
;
2544 /* A helper for create_cus_from_index that handles a given list of
2548 create_cus_from_index_list (dwarf2_per_bfd
*per_bfd
,
2549 const gdb_byte
*cu_list
, offset_type n_elements
,
2550 struct dwarf2_section_info
*section
,
2553 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
2555 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2557 sect_offset sect_off
2558 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2559 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2562 dwarf2_per_cu_data
*per_cu
2563 = create_cu_from_index_list (per_bfd
, section
, is_dwz
, sect_off
,
2565 per_bfd
->all_comp_units
.push_back (per_cu
);
2569 /* Read the CU list from the mapped index, and use it to create all
2570 the CU objects for PER_BFD. */
2573 create_cus_from_index (dwarf2_per_bfd
*per_bfd
,
2574 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
2575 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
2577 gdb_assert (per_bfd
->all_comp_units
.empty ());
2578 per_bfd
->all_comp_units
.reserve ((cu_list_elements
+ dwz_elements
) / 2);
2580 create_cus_from_index_list (per_bfd
, cu_list
, cu_list_elements
,
2583 if (dwz_elements
== 0)
2586 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
2587 create_cus_from_index_list (per_bfd
, dwz_list
, dwz_elements
,
2591 /* Create the signatured type hash table from the index. */
2594 create_signatured_type_table_from_index
2595 (dwarf2_per_bfd
*per_bfd
, struct dwarf2_section_info
*section
,
2596 const gdb_byte
*bytes
, offset_type elements
)
2598 gdb_assert (per_bfd
->all_type_units
.empty ());
2599 per_bfd
->all_type_units
.reserve (elements
/ 3);
2601 htab_up sig_types_hash
= allocate_signatured_type_table ();
2603 for (offset_type i
= 0; i
< elements
; i
+= 3)
2605 struct signatured_type
*sig_type
;
2608 cu_offset type_offset_in_tu
;
2610 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2611 sect_offset sect_off
2612 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
2614 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
2616 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
2619 sig_type
= per_bfd
->allocate_signatured_type ();
2620 sig_type
->signature
= signature
;
2621 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
2622 sig_type
->per_cu
.is_debug_types
= 1;
2623 sig_type
->per_cu
.section
= section
;
2624 sig_type
->per_cu
.sect_off
= sect_off
;
2625 sig_type
->per_cu
.v
.quick
2626 = OBSTACK_ZALLOC (&per_bfd
->obstack
,
2627 struct dwarf2_per_cu_quick_data
);
2629 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2632 per_bfd
->all_type_units
.push_back (sig_type
);
2635 per_bfd
->signatured_types
= std::move (sig_types_hash
);
2638 /* Create the signatured type hash table from .debug_names. */
2641 create_signatured_type_table_from_debug_names
2642 (dwarf2_per_objfile
*per_objfile
,
2643 const mapped_debug_names
&map
,
2644 struct dwarf2_section_info
*section
,
2645 struct dwarf2_section_info
*abbrev_section
)
2647 struct objfile
*objfile
= per_objfile
->objfile
;
2649 section
->read (objfile
);
2650 abbrev_section
->read (objfile
);
2652 gdb_assert (per_objfile
->per_bfd
->all_type_units
.empty ());
2653 per_objfile
->per_bfd
->all_type_units
.reserve (map
.tu_count
);
2655 htab_up sig_types_hash
= allocate_signatured_type_table ();
2657 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
2659 struct signatured_type
*sig_type
;
2662 sect_offset sect_off
2663 = (sect_offset
) (extract_unsigned_integer
2664 (map
.tu_table_reordered
+ i
* map
.offset_size
,
2666 map
.dwarf5_byte_order
));
2668 comp_unit_head cu_header
;
2669 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
2671 section
->buffer
+ to_underlying (sect_off
),
2674 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
2675 sig_type
->signature
= cu_header
.signature
;
2676 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
2677 sig_type
->per_cu
.is_debug_types
= 1;
2678 sig_type
->per_cu
.section
= section
;
2679 sig_type
->per_cu
.sect_off
= sect_off
;
2680 sig_type
->per_cu
.v
.quick
2681 = OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
2682 struct dwarf2_per_cu_quick_data
);
2684 slot
= htab_find_slot (sig_types_hash
.get (), sig_type
, INSERT
);
2687 per_objfile
->per_bfd
->all_type_units
.push_back (sig_type
);
2690 per_objfile
->per_bfd
->signatured_types
= std::move (sig_types_hash
);
2693 /* Read the address map data from the mapped index, and use it to
2694 populate the objfile's psymtabs_addrmap. */
2697 create_addrmap_from_index (dwarf2_per_objfile
*per_objfile
,
2698 struct mapped_index
*index
)
2700 struct objfile
*objfile
= per_objfile
->objfile
;
2701 struct gdbarch
*gdbarch
= objfile
->arch ();
2702 const gdb_byte
*iter
, *end
;
2703 struct addrmap
*mutable_map
;
2706 auto_obstack temp_obstack
;
2708 mutable_map
= addrmap_create_mutable (&temp_obstack
);
2710 iter
= index
->address_table
.data ();
2711 end
= iter
+ index
->address_table
.size ();
2713 baseaddr
= objfile
->text_section_offset ();
2717 ULONGEST hi
, lo
, cu_index
;
2718 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2720 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
2722 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
2727 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
2728 hex_string (lo
), hex_string (hi
));
2732 if (cu_index
>= per_objfile
->per_bfd
->all_comp_units
.size ())
2734 complaint (_(".gdb_index address table has invalid CU number %u"),
2735 (unsigned) cu_index
);
2739 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
2740 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
2741 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
2742 per_objfile
->per_bfd
->get_cu (cu_index
));
2745 objfile
->partial_symtabs
->psymtabs_addrmap
2746 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
2749 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
2750 populate the objfile's psymtabs_addrmap. */
2753 create_addrmap_from_aranges (dwarf2_per_objfile
*per_objfile
,
2754 struct dwarf2_section_info
*section
)
2756 struct objfile
*objfile
= per_objfile
->objfile
;
2757 bfd
*abfd
= objfile
->obfd
;
2758 struct gdbarch
*gdbarch
= objfile
->arch ();
2759 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
2761 auto_obstack temp_obstack
;
2762 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
2764 std::unordered_map
<sect_offset
,
2765 dwarf2_per_cu_data
*,
2766 gdb::hash_enum
<sect_offset
>>
2767 debug_info_offset_to_per_cu
;
2768 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
2770 const auto insertpair
2771 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
, per_cu
);
2772 if (!insertpair
.second
)
2774 warning (_("Section .debug_aranges in %s has duplicate "
2775 "debug_info_offset %s, ignoring .debug_aranges."),
2776 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
2781 section
->read (objfile
);
2783 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
2785 const gdb_byte
*addr
= section
->buffer
;
2787 while (addr
< section
->buffer
+ section
->size
)
2789 const gdb_byte
*const entry_addr
= addr
;
2790 unsigned int bytes_read
;
2792 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
2796 const gdb_byte
*const entry_end
= addr
+ entry_length
;
2797 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
2798 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
2799 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
2801 warning (_("Section .debug_aranges in %s entry at offset %s "
2802 "length %s exceeds section length %s, "
2803 "ignoring .debug_aranges."),
2804 objfile_name (objfile
),
2805 plongest (entry_addr
- section
->buffer
),
2806 plongest (bytes_read
+ entry_length
),
2807 pulongest (section
->size
));
2811 /* The version number. */
2812 const uint16_t version
= read_2_bytes (abfd
, addr
);
2816 warning (_("Section .debug_aranges in %s entry at offset %s "
2817 "has unsupported version %d, ignoring .debug_aranges."),
2818 objfile_name (objfile
),
2819 plongest (entry_addr
- section
->buffer
), version
);
2823 const uint64_t debug_info_offset
2824 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
2825 addr
+= offset_size
;
2826 const auto per_cu_it
2827 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
2828 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
2830 warning (_("Section .debug_aranges in %s entry at offset %s "
2831 "debug_info_offset %s does not exists, "
2832 "ignoring .debug_aranges."),
2833 objfile_name (objfile
),
2834 plongest (entry_addr
- section
->buffer
),
2835 pulongest (debug_info_offset
));
2838 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
2840 const uint8_t address_size
= *addr
++;
2841 if (address_size
< 1 || address_size
> 8)
2843 warning (_("Section .debug_aranges in %s entry at offset %s "
2844 "address_size %u is invalid, ignoring .debug_aranges."),
2845 objfile_name (objfile
),
2846 plongest (entry_addr
- section
->buffer
), address_size
);
2850 const uint8_t segment_selector_size
= *addr
++;
2851 if (segment_selector_size
!= 0)
2853 warning (_("Section .debug_aranges in %s entry at offset %s "
2854 "segment_selector_size %u is not supported, "
2855 "ignoring .debug_aranges."),
2856 objfile_name (objfile
),
2857 plongest (entry_addr
- section
->buffer
),
2858 segment_selector_size
);
2862 /* Must pad to an alignment boundary that is twice the address
2863 size. It is undocumented by the DWARF standard but GCC does
2865 for (size_t padding
= ((-(addr
- section
->buffer
))
2866 & (2 * address_size
- 1));
2867 padding
> 0; padding
--)
2870 warning (_("Section .debug_aranges in %s entry at offset %s "
2871 "padding is not zero, ignoring .debug_aranges."),
2872 objfile_name (objfile
),
2873 plongest (entry_addr
- section
->buffer
));
2879 if (addr
+ 2 * address_size
> entry_end
)
2881 warning (_("Section .debug_aranges in %s entry at offset %s "
2882 "address list is not properly terminated, "
2883 "ignoring .debug_aranges."),
2884 objfile_name (objfile
),
2885 plongest (entry_addr
- section
->buffer
));
2888 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
2890 addr
+= address_size
;
2891 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
2893 addr
+= address_size
;
2894 if (start
== 0 && length
== 0)
2896 if (start
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
2898 /* Symbol was eliminated due to a COMDAT group. */
2901 ULONGEST end
= start
+ length
;
2902 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
2904 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
2906 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
2910 objfile
->partial_symtabs
->psymtabs_addrmap
2911 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
2914 /* Find a slot in the mapped index INDEX for the object named NAME.
2915 If NAME is found, set *VEC_OUT to point to the CU vector in the
2916 constant pool and return true. If NAME cannot be found, return
2920 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
2921 offset_type
**vec_out
)
2924 offset_type slot
, step
;
2925 int (*cmp
) (const char *, const char *);
2927 gdb::unique_xmalloc_ptr
<char> without_params
;
2928 if (current_language
->la_language
== language_cplus
2929 || current_language
->la_language
== language_fortran
2930 || current_language
->la_language
== language_d
)
2932 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2935 if (strchr (name
, '(') != NULL
)
2937 without_params
= cp_remove_params (name
);
2939 if (without_params
!= NULL
)
2940 name
= without_params
.get ();
2944 /* Index version 4 did not support case insensitive searches. But the
2945 indices for case insensitive languages are built in lowercase, therefore
2946 simulate our NAME being searched is also lowercased. */
2947 hash
= mapped_index_string_hash ((index
->version
== 4
2948 && case_sensitivity
== case_sensitive_off
2949 ? 5 : index
->version
),
2952 slot
= hash
& (index
->symbol_table
.size () - 1);
2953 step
= ((hash
* 17) & (index
->symbol_table
.size () - 1)) | 1;
2954 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
2960 const auto &bucket
= index
->symbol_table
[slot
];
2961 if (bucket
.name
== 0 && bucket
.vec
== 0)
2964 str
= index
->constant_pool
+ MAYBE_SWAP (bucket
.name
);
2965 if (!cmp (name
, str
))
2967 *vec_out
= (offset_type
*) (index
->constant_pool
2968 + MAYBE_SWAP (bucket
.vec
));
2972 slot
= (slot
+ step
) & (index
->symbol_table
.size () - 1);
2976 /* A helper function that reads the .gdb_index from BUFFER and fills
2977 in MAP. FILENAME is the name of the file containing the data;
2978 it is used for error reporting. DEPRECATED_OK is true if it is
2979 ok to use deprecated sections.
2981 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2982 out parameters that are filled in with information about the CU and
2983 TU lists in the section.
2985 Returns true if all went well, false otherwise. */
2988 read_gdb_index_from_buffer (const char *filename
,
2990 gdb::array_view
<const gdb_byte
> buffer
,
2991 struct mapped_index
*map
,
2992 const gdb_byte
**cu_list
,
2993 offset_type
*cu_list_elements
,
2994 const gdb_byte
**types_list
,
2995 offset_type
*types_list_elements
)
2997 const gdb_byte
*addr
= &buffer
[0];
2999 /* Version check. */
3000 offset_type version
= MAYBE_SWAP (*(offset_type
*) addr
);
3001 /* Versions earlier than 3 emitted every copy of a psymbol. This
3002 causes the index to behave very poorly for certain requests. Version 3
3003 contained incomplete addrmap. So, it seems better to just ignore such
3007 static int warning_printed
= 0;
3008 if (!warning_printed
)
3010 warning (_("Skipping obsolete .gdb_index section in %s."),
3012 warning_printed
= 1;
3016 /* Index version 4 uses a different hash function than index version
3019 Versions earlier than 6 did not emit psymbols for inlined
3020 functions. Using these files will cause GDB not to be able to
3021 set breakpoints on inlined functions by name, so we ignore these
3022 indices unless the user has done
3023 "set use-deprecated-index-sections on". */
3024 if (version
< 6 && !deprecated_ok
)
3026 static int warning_printed
= 0;
3027 if (!warning_printed
)
3030 Skipping deprecated .gdb_index section in %s.\n\
3031 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3032 to use the section anyway."),
3034 warning_printed
= 1;
3038 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3039 of the TU (for symbols coming from TUs),
3040 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3041 Plus gold-generated indices can have duplicate entries for global symbols,
3042 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3043 These are just performance bugs, and we can't distinguish gdb-generated
3044 indices from gold-generated ones, so issue no warning here. */
3046 /* Indexes with higher version than the one supported by GDB may be no
3047 longer backward compatible. */
3051 map
->version
= version
;
3053 offset_type
*metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3056 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3057 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3061 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3062 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3063 - MAYBE_SWAP (metadata
[i
]))
3067 const gdb_byte
*address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3068 const gdb_byte
*address_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3070 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
3073 const gdb_byte
*symbol_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3074 const gdb_byte
*symbol_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3076 = gdb::array_view
<mapped_index::symbol_table_slot
>
3077 ((mapped_index::symbol_table_slot
*) symbol_table
,
3078 (mapped_index::symbol_table_slot
*) symbol_table_end
);
3081 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3086 /* Callback types for dwarf2_read_gdb_index. */
3088 typedef gdb::function_view
3089 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_bfd
*)>
3090 get_gdb_index_contents_ftype
;
3091 typedef gdb::function_view
3092 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
3093 get_gdb_index_contents_dwz_ftype
;
3095 /* Read .gdb_index. If everything went ok, initialize the "quick"
3096 elements of all the CUs and return 1. Otherwise, return 0. */
3099 dwarf2_read_gdb_index
3100 (dwarf2_per_objfile
*per_objfile
,
3101 get_gdb_index_contents_ftype get_gdb_index_contents
,
3102 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
3104 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3105 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3106 struct dwz_file
*dwz
;
3107 struct objfile
*objfile
= per_objfile
->objfile
;
3108 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
3110 gdb::array_view
<const gdb_byte
> main_index_contents
3111 = get_gdb_index_contents (objfile
, per_bfd
);
3113 if (main_index_contents
.empty ())
3116 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
3117 if (!read_gdb_index_from_buffer (objfile_name (objfile
),
3118 use_deprecated_index_sections
,
3119 main_index_contents
, map
.get (), &cu_list
,
3120 &cu_list_elements
, &types_list
,
3121 &types_list_elements
))
3124 /* Don't use the index if it's empty. */
3125 if (map
->symbol_table
.empty ())
3128 /* If there is a .dwz file, read it so we can get its CU list as
3130 dwz
= dwarf2_get_dwz_file (per_bfd
);
3133 struct mapped_index dwz_map
;
3134 const gdb_byte
*dwz_types_ignore
;
3135 offset_type dwz_types_elements_ignore
;
3137 gdb::array_view
<const gdb_byte
> dwz_index_content
3138 = get_gdb_index_contents_dwz (objfile
, dwz
);
3140 if (dwz_index_content
.empty ())
3143 if (!read_gdb_index_from_buffer (bfd_get_filename (dwz
->dwz_bfd
.get ()),
3144 1, dwz_index_content
, &dwz_map
,
3145 &dwz_list
, &dwz_list_elements
,
3147 &dwz_types_elements_ignore
))
3149 warning (_("could not read '.gdb_index' section from %s; skipping"),
3150 bfd_get_filename (dwz
->dwz_bfd
.get ()));
3155 create_cus_from_index (per_bfd
, cu_list
, cu_list_elements
, dwz_list
,
3158 if (types_list_elements
)
3160 /* We can only handle a single .debug_types when we have an
3162 if (per_bfd
->types
.size () != 1)
3165 dwarf2_section_info
*section
= &per_bfd
->types
[0];
3167 create_signatured_type_table_from_index (per_bfd
, section
, types_list
,
3168 types_list_elements
);
3171 create_addrmap_from_index (per_objfile
, map
.get ());
3173 per_bfd
->index_table
= std::move (map
);
3174 per_bfd
->using_index
= 1;
3175 per_bfd
->quick_file_names_table
=
3176 create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
3178 /* Save partial symtabs in the per_bfd object, for the benefit of subsequent
3179 objfiles using the same BFD. */
3180 gdb_assert (per_bfd
->partial_symtabs
== nullptr);
3181 per_bfd
->partial_symtabs
= objfile
->partial_symtabs
;
3186 /* die_reader_func for dw2_get_file_names. */
3189 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3190 const gdb_byte
*info_ptr
,
3191 struct die_info
*comp_unit_die
)
3193 struct dwarf2_cu
*cu
= reader
->cu
;
3194 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3195 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
3196 struct dwarf2_per_cu_data
*lh_cu
;
3197 struct attribute
*attr
;
3199 struct quick_file_names
*qfn
;
3201 gdb_assert (! this_cu
->is_debug_types
);
3203 /* Our callers never want to match partial units -- instead they
3204 will match the enclosing full CU. */
3205 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3207 this_cu
->v
.quick
->no_file_data
= 1;
3215 sect_offset line_offset
{};
3217 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3218 if (attr
!= nullptr && attr
->form_is_unsigned ())
3220 struct quick_file_names find_entry
;
3222 line_offset
= (sect_offset
) attr
->as_unsigned ();
3224 /* We may have already read in this line header (TU line header sharing).
3225 If we have we're done. */
3226 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3227 find_entry
.hash
.line_sect_off
= line_offset
;
3228 slot
= htab_find_slot (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3229 &find_entry
, INSERT
);
3232 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3236 lh
= dwarf_decode_line_header (line_offset
, cu
);
3240 lh_cu
->v
.quick
->no_file_data
= 1;
3244 qfn
= XOBNEW (&per_objfile
->per_bfd
->obstack
, struct quick_file_names
);
3245 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3246 qfn
->hash
.line_sect_off
= line_offset
;
3247 gdb_assert (slot
!= NULL
);
3250 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3253 if (strcmp (fnd
.name
, "<unknown>") != 0)
3256 qfn
->num_file_names
= offset
+ lh
->file_names_size ();
3258 XOBNEWVEC (&per_objfile
->per_bfd
->obstack
, const char *,
3259 qfn
->num_file_names
);
3261 qfn
->file_names
[0] = xstrdup (fnd
.name
);
3262 for (int i
= 0; i
< lh
->file_names_size (); ++i
)
3263 qfn
->file_names
[i
+ offset
] = lh
->file_full_name (i
+ 1,
3264 fnd
.comp_dir
).release ();
3265 qfn
->real_names
= NULL
;
3267 lh_cu
->v
.quick
->file_names
= qfn
;
3270 /* A helper for the "quick" functions which attempts to read the line
3271 table for THIS_CU. */
3273 static struct quick_file_names
*
3274 dw2_get_file_names (dwarf2_per_cu_data
*this_cu
,
3275 dwarf2_per_objfile
*per_objfile
)
3277 /* This should never be called for TUs. */
3278 gdb_assert (! this_cu
->is_debug_types
);
3279 /* Nor type unit groups. */
3280 gdb_assert (! this_cu
->type_unit_group_p ());
3282 if (this_cu
->v
.quick
->file_names
!= NULL
)
3283 return this_cu
->v
.quick
->file_names
;
3284 /* If we know there is no line data, no point in looking again. */
3285 if (this_cu
->v
.quick
->no_file_data
)
3288 cutu_reader
reader (this_cu
, per_objfile
);
3289 if (!reader
.dummy_p
)
3290 dw2_get_file_names_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
);
3292 if (this_cu
->v
.quick
->no_file_data
)
3294 return this_cu
->v
.quick
->file_names
;
3297 /* A helper for the "quick" functions which computes and caches the
3298 real path for a given file name from the line table. */
3301 dw2_get_real_path (dwarf2_per_objfile
*per_objfile
,
3302 struct quick_file_names
*qfn
, int index
)
3304 if (qfn
->real_names
== NULL
)
3305 qfn
->real_names
= OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
3306 qfn
->num_file_names
, const char *);
3308 if (qfn
->real_names
[index
] == NULL
)
3309 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3311 return qfn
->real_names
[index
];
3314 static struct symtab
*
3315 dw2_find_last_source_symtab (struct objfile
*objfile
)
3317 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3318 dwarf2_per_cu_data
*dwarf_cu
= per_objfile
->per_bfd
->all_comp_units
.back ();
3319 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, per_objfile
, false);
3324 return compunit_primary_filetab (cust
);
3327 /* Traversal function for dw2_forget_cached_source_info. */
3330 dw2_free_cached_file_names (void **slot
, void *info
)
3332 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3334 if (file_data
->real_names
)
3338 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3340 xfree ((void*) file_data
->real_names
[i
]);
3341 file_data
->real_names
[i
] = NULL
;
3349 dw2_forget_cached_source_info (struct objfile
*objfile
)
3351 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3353 htab_traverse_noresize (per_objfile
->per_bfd
->quick_file_names_table
.get (),
3354 dw2_free_cached_file_names
, NULL
);
3357 /* Helper function for dw2_map_symtabs_matching_filename that expands
3358 the symtabs and calls the iterator. */
3361 dw2_map_expand_apply (struct objfile
*objfile
,
3362 struct dwarf2_per_cu_data
*per_cu
,
3363 const char *name
, const char *real_path
,
3364 gdb::function_view
<bool (symtab
*)> callback
)
3366 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3368 /* Don't visit already-expanded CUs. */
3369 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3370 if (per_objfile
->symtab_set_p (per_cu
))
3373 /* This may expand more than one symtab, and we want to iterate over
3375 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3377 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
3378 last_made
, callback
);
3381 /* Implementation of the map_symtabs_matching_filename method. */
3384 dw2_map_symtabs_matching_filename
3385 (struct objfile
*objfile
, const char *name
, const char *real_path
,
3386 gdb::function_view
<bool (symtab
*)> callback
)
3388 const char *name_basename
= lbasename (name
);
3389 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3391 /* The rule is CUs specify all the files, including those used by
3392 any TU, so there's no need to scan TUs here. */
3394 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
3396 /* We only need to look at symtabs not already expanded. */
3397 if (per_objfile
->symtab_set_p (per_cu
))
3400 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
3401 if (file_data
== NULL
)
3404 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3406 const char *this_name
= file_data
->file_names
[j
];
3407 const char *this_real_name
;
3409 if (compare_filenames_for_search (this_name
, name
))
3411 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3417 /* Before we invoke realpath, which can get expensive when many
3418 files are involved, do a quick comparison of the basenames. */
3419 if (! basenames_may_differ
3420 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3423 this_real_name
= dw2_get_real_path (per_objfile
, file_data
, j
);
3424 if (compare_filenames_for_search (this_real_name
, name
))
3426 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3432 if (real_path
!= NULL
)
3434 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3435 gdb_assert (IS_ABSOLUTE_PATH (name
));
3436 if (this_real_name
!= NULL
3437 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3439 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3451 /* Struct used to manage iterating over all CUs looking for a symbol. */
3453 struct dw2_symtab_iterator
3455 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3456 dwarf2_per_objfile
*per_objfile
;
3457 /* If set, only look for symbols that match that block. Valid values are
3458 GLOBAL_BLOCK and STATIC_BLOCK. */
3459 gdb::optional
<block_enum
> block_index
;
3460 /* The kind of symbol we're looking for. */
3462 /* The list of CUs from the index entry of the symbol,
3463 or NULL if not found. */
3465 /* The next element in VEC to look at. */
3467 /* The number of elements in VEC, or zero if there is no match. */
3469 /* Have we seen a global version of the symbol?
3470 If so we can ignore all further global instances.
3471 This is to work around gold/15646, inefficient gold-generated
3476 /* Initialize the index symtab iterator ITER, common part. */
3479 dw2_symtab_iter_init_common (struct dw2_symtab_iterator
*iter
,
3480 dwarf2_per_objfile
*per_objfile
,
3481 gdb::optional
<block_enum
> block_index
,
3484 iter
->per_objfile
= per_objfile
;
3485 iter
->block_index
= block_index
;
3486 iter
->domain
= domain
;
3488 iter
->global_seen
= 0;
3493 /* Initialize the index symtab iterator ITER, const char *NAME variant. */
3496 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3497 dwarf2_per_objfile
*per_objfile
,
3498 gdb::optional
<block_enum
> block_index
,
3502 dw2_symtab_iter_init_common (iter
, per_objfile
, block_index
, domain
);
3504 mapped_index
*index
= per_objfile
->per_bfd
->index_table
.get ();
3505 /* index is NULL if OBJF_READNOW. */
3509 if (find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3510 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3513 /* Initialize the index symtab iterator ITER, offset_type NAMEI variant. */
3516 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3517 dwarf2_per_objfile
*per_objfile
,
3518 gdb::optional
<block_enum
> block_index
,
3519 domain_enum domain
, offset_type namei
)
3521 dw2_symtab_iter_init_common (iter
, per_objfile
, block_index
, domain
);
3523 mapped_index
*index
= per_objfile
->per_bfd
->index_table
.get ();
3524 /* index is NULL if OBJF_READNOW. */
3528 gdb_assert (!index
->symbol_name_slot_invalid (namei
));
3529 const auto &bucket
= index
->symbol_table
[namei
];
3531 iter
->vec
= (offset_type
*) (index
->constant_pool
3532 + MAYBE_SWAP (bucket
.vec
));
3533 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3536 /* Return the next matching CU or NULL if there are no more. */
3538 static struct dwarf2_per_cu_data
*
3539 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3541 dwarf2_per_objfile
*per_objfile
= iter
->per_objfile
;
3543 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3545 offset_type cu_index_and_attrs
=
3546 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3547 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3548 gdb_index_symbol_kind symbol_kind
=
3549 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3550 /* Only check the symbol attributes if they're present.
3551 Indices prior to version 7 don't record them,
3552 and indices >= 7 may elide them for certain symbols
3553 (gold does this). */
3555 (per_objfile
->per_bfd
->index_table
->version
>= 7
3556 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3558 /* Don't crash on bad data. */
3559 if (cu_index
>= (per_objfile
->per_bfd
->all_comp_units
.size ()
3560 + per_objfile
->per_bfd
->all_type_units
.size ()))
3562 complaint (_(".gdb_index entry has bad CU index"
3563 " [in module %s]"), objfile_name (per_objfile
->objfile
));
3567 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (cu_index
);
3569 /* Skip if already read in. */
3570 if (per_objfile
->symtab_set_p (per_cu
))
3573 /* Check static vs global. */
3576 bool is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3578 if (iter
->block_index
.has_value ())
3580 bool want_static
= *iter
->block_index
== STATIC_BLOCK
;
3582 if (is_static
!= want_static
)
3586 /* Work around gold/15646. */
3588 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
3590 if (iter
->global_seen
)
3593 iter
->global_seen
= 1;
3597 /* Only check the symbol's kind if it has one. */
3600 switch (iter
->domain
)
3603 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3604 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3605 /* Some types are also in VAR_DOMAIN. */
3606 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3610 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
3614 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3618 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
3633 static struct compunit_symtab
*
3634 dw2_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
3635 const char *name
, domain_enum domain
)
3637 struct compunit_symtab
*stab_best
= NULL
;
3638 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3640 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
3642 struct dw2_symtab_iterator iter
;
3643 struct dwarf2_per_cu_data
*per_cu
;
3645 dw2_symtab_iter_init (&iter
, per_objfile
, block_index
, domain
, name
);
3647 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3649 struct symbol
*sym
, *with_opaque
= NULL
;
3650 struct compunit_symtab
*stab
3651 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3652 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
3653 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
3655 sym
= block_find_symbol (block
, name
, domain
,
3656 block_find_non_opaque_type_preferred
,
3659 /* Some caution must be observed with overloaded functions
3660 and methods, since the index will not contain any overload
3661 information (but NAME might contain it). */
3664 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
3666 if (with_opaque
!= NULL
3667 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
3670 /* Keep looking through other CUs. */
3677 dw2_print_stats (struct objfile
*objfile
)
3679 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3680 int total
= (per_objfile
->per_bfd
->all_comp_units
.size ()
3681 + per_objfile
->per_bfd
->all_type_units
.size ());
3684 for (int i
= 0; i
< total
; ++i
)
3686 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (i
);
3688 if (!per_objfile
->symtab_set_p (per_cu
))
3691 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
3692 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
3695 /* This dumps minimal information about the index.
3696 It is called via "mt print objfiles".
3697 One use is to verify .gdb_index has been loaded by the
3698 gdb.dwarf2/gdb-index.exp testcase. */
3701 dw2_dump (struct objfile
*objfile
)
3703 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3705 gdb_assert (per_objfile
->per_bfd
->using_index
);
3706 printf_filtered (".gdb_index:");
3707 if (per_objfile
->per_bfd
->index_table
!= NULL
)
3709 printf_filtered (" version %d\n",
3710 per_objfile
->per_bfd
->index_table
->version
);
3713 printf_filtered (" faked for \"readnow\"\n");
3714 printf_filtered ("\n");
3718 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
3719 const char *func_name
)
3721 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3723 struct dw2_symtab_iterator iter
;
3724 struct dwarf2_per_cu_data
*per_cu
;
3726 dw2_symtab_iter_init (&iter
, per_objfile
, {}, VAR_DOMAIN
, func_name
);
3728 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3729 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3734 dw2_expand_all_symtabs (struct objfile
*objfile
)
3736 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3737 int total_units
= (per_objfile
->per_bfd
->all_comp_units
.size ()
3738 + per_objfile
->per_bfd
->all_type_units
.size ());
3740 for (int i
= 0; i
< total_units
; ++i
)
3742 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (i
);
3744 /* We don't want to directly expand a partial CU, because if we
3745 read it with the wrong language, then assertion failures can
3746 be triggered later on. See PR symtab/23010. So, tell
3747 dw2_instantiate_symtab to skip partial CUs -- any important
3748 partial CU will be read via DW_TAG_imported_unit anyway. */
3749 dw2_instantiate_symtab (per_cu
, per_objfile
, true);
3754 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
3755 const char *fullname
)
3757 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3759 /* We don't need to consider type units here.
3760 This is only called for examining code, e.g. expand_line_sal.
3761 There can be an order of magnitude (or more) more type units
3762 than comp units, and we avoid them if we can. */
3764 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
3766 /* We only need to look at symtabs not already expanded. */
3767 if (per_objfile
->symtab_set_p (per_cu
))
3770 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
3771 if (file_data
== NULL
)
3774 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3776 const char *this_fullname
= file_data
->file_names
[j
];
3778 if (filename_cmp (this_fullname
, fullname
) == 0)
3780 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
3788 dw2_expand_symtabs_matching_symbol
3789 (mapped_index_base
&index
,
3790 const lookup_name_info
&lookup_name_in
,
3791 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
3792 enum search_domain kind
,
3793 gdb::function_view
<bool (offset_type
)> match_callback
,
3794 dwarf2_per_objfile
*per_objfile
);
3797 dw2_expand_symtabs_matching_one
3798 (dwarf2_per_cu_data
*per_cu
,
3799 dwarf2_per_objfile
*per_objfile
,
3800 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
3801 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
);
3804 dw2_map_matching_symbols
3805 (struct objfile
*objfile
,
3806 const lookup_name_info
&name
, domain_enum domain
,
3808 gdb::function_view
<symbol_found_callback_ftype
> callback
,
3809 symbol_compare_ftype
*ordered_compare
)
3812 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
3814 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
3816 if (per_objfile
->per_bfd
->index_table
!= nullptr)
3818 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
3820 const char *match_name
= name
.ada ().lookup_name ().c_str ();
3821 auto matcher
= [&] (const char *symname
)
3823 if (ordered_compare
== nullptr)
3825 return ordered_compare (symname
, match_name
) == 0;
3828 dw2_expand_symtabs_matching_symbol (index
, name
, matcher
, ALL_DOMAIN
,
3829 [&] (offset_type namei
)
3831 struct dw2_symtab_iterator iter
;
3832 struct dwarf2_per_cu_data
*per_cu
;
3834 dw2_symtab_iter_init (&iter
, per_objfile
, block_kind
, domain
,
3836 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
3837 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
3844 /* We have -readnow: no .gdb_index, but no partial symtabs either. So,
3845 proceed assuming all symtabs have been read in. */
3848 for (compunit_symtab
*cust
: objfile
->compunits ())
3850 const struct block
*block
;
3854 block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
3855 if (!iterate_over_symbols_terminated (block
, name
,
3861 /* Starting from a search name, return the string that finds the upper
3862 bound of all strings that start with SEARCH_NAME in a sorted name
3863 list. Returns the empty string to indicate that the upper bound is
3864 the end of the list. */
3867 make_sort_after_prefix_name (const char *search_name
)
3869 /* When looking to complete "func", we find the upper bound of all
3870 symbols that start with "func" by looking for where we'd insert
3871 the closest string that would follow "func" in lexicographical
3872 order. Usually, that's "func"-with-last-character-incremented,
3873 i.e. "fund". Mind non-ASCII characters, though. Usually those
3874 will be UTF-8 multi-byte sequences, but we can't be certain.
3875 Especially mind the 0xff character, which is a valid character in
3876 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
3877 rule out compilers allowing it in identifiers. Note that
3878 conveniently, strcmp/strcasecmp are specified to compare
3879 characters interpreted as unsigned char. So what we do is treat
3880 the whole string as a base 256 number composed of a sequence of
3881 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
3882 to 0, and carries 1 to the following more-significant position.
3883 If the very first character in SEARCH_NAME ends up incremented
3884 and carries/overflows, then the upper bound is the end of the
3885 list. The string after the empty string is also the empty
3888 Some examples of this operation:
3890 SEARCH_NAME => "+1" RESULT
3894 "\xff" "a" "\xff" => "\xff" "b"
3899 Then, with these symbols for example:
3905 completing "func" looks for symbols between "func" and
3906 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
3907 which finds "func" and "func1", but not "fund".
3911 funcÿ (Latin1 'ÿ' [0xff])
3915 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
3916 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
3920 ÿÿ (Latin1 'ÿ' [0xff])
3923 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
3924 the end of the list.
3926 std::string after
= search_name
;
3927 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
3929 if (!after
.empty ())
3930 after
.back () = (unsigned char) after
.back () + 1;
3934 /* See declaration. */
3936 std::pair
<std::vector
<name_component
>::const_iterator
,
3937 std::vector
<name_component
>::const_iterator
>
3938 mapped_index_base::find_name_components_bounds
3939 (const lookup_name_info
&lookup_name_without_params
, language lang
,
3940 dwarf2_per_objfile
*per_objfile
) const
3943 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
3945 const char *lang_name
3946 = lookup_name_without_params
.language_lookup_name (lang
);
3948 /* Comparison function object for lower_bound that matches against a
3949 given symbol name. */
3950 auto lookup_compare_lower
= [&] (const name_component
&elem
,
3953 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3954 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3955 return name_cmp (elem_name
, name
) < 0;
3958 /* Comparison function object for upper_bound that matches against a
3959 given symbol name. */
3960 auto lookup_compare_upper
= [&] (const char *name
,
3961 const name_component
&elem
)
3963 const char *elem_qualified
= this->symbol_name_at (elem
.idx
, per_objfile
);
3964 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
3965 return name_cmp (name
, elem_name
) < 0;
3968 auto begin
= this->name_components
.begin ();
3969 auto end
= this->name_components
.end ();
3971 /* Find the lower bound. */
3974 if (lookup_name_without_params
.completion_mode () && lang_name
[0] == '\0')
3977 return std::lower_bound (begin
, end
, lang_name
, lookup_compare_lower
);
3980 /* Find the upper bound. */
3983 if (lookup_name_without_params
.completion_mode ())
3985 /* In completion mode, we want UPPER to point past all
3986 symbols names that have the same prefix. I.e., with
3987 these symbols, and completing "func":
3989 function << lower bound
3991 other_function << upper bound
3993 We find the upper bound by looking for the insertion
3994 point of "func"-with-last-character-incremented,
3996 std::string after
= make_sort_after_prefix_name (lang_name
);
3999 return std::lower_bound (lower
, end
, after
.c_str (),
4000 lookup_compare_lower
);
4003 return std::upper_bound (lower
, end
, lang_name
, lookup_compare_upper
);
4006 return {lower
, upper
};
4009 /* See declaration. */
4012 mapped_index_base::build_name_components (dwarf2_per_objfile
*per_objfile
)
4014 if (!this->name_components
.empty ())
4017 this->name_components_casing
= case_sensitivity
;
4019 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4021 /* The code below only knows how to break apart components of C++
4022 symbol names (and other languages that use '::' as
4023 namespace/module separator) and Ada symbol names. */
4024 auto count
= this->symbol_name_count ();
4025 for (offset_type idx
= 0; idx
< count
; idx
++)
4027 if (this->symbol_name_slot_invalid (idx
))
4030 const char *name
= this->symbol_name_at (idx
, per_objfile
);
4032 /* Add each name component to the name component table. */
4033 unsigned int previous_len
= 0;
4035 if (strstr (name
, "::") != nullptr)
4037 for (unsigned int current_len
= cp_find_first_component (name
);
4038 name
[current_len
] != '\0';
4039 current_len
+= cp_find_first_component (name
+ current_len
))
4041 gdb_assert (name
[current_len
] == ':');
4042 this->name_components
.push_back ({previous_len
, idx
});
4043 /* Skip the '::'. */
4045 previous_len
= current_len
;
4050 /* Handle the Ada encoded (aka mangled) form here. */
4051 for (const char *iter
= strstr (name
, "__");
4053 iter
= strstr (iter
, "__"))
4055 this->name_components
.push_back ({previous_len
, idx
});
4057 previous_len
= iter
- name
;
4061 this->name_components
.push_back ({previous_len
, idx
});
4064 /* Sort name_components elements by name. */
4065 auto name_comp_compare
= [&] (const name_component
&left
,
4066 const name_component
&right
)
4068 const char *left_qualified
4069 = this->symbol_name_at (left
.idx
, per_objfile
);
4070 const char *right_qualified
4071 = this->symbol_name_at (right
.idx
, per_objfile
);
4073 const char *left_name
= left_qualified
+ left
.name_offset
;
4074 const char *right_name
= right_qualified
+ right
.name_offset
;
4076 return name_cmp (left_name
, right_name
) < 0;
4079 std::sort (this->name_components
.begin (),
4080 this->name_components
.end (),
4084 /* Helper for dw2_expand_symtabs_matching that works with a
4085 mapped_index_base instead of the containing objfile. This is split
4086 to a separate function in order to be able to unit test the
4087 name_components matching using a mock mapped_index_base. For each
4088 symbol name that matches, calls MATCH_CALLBACK, passing it the
4089 symbol's index in the mapped_index_base symbol table. */
4092 dw2_expand_symtabs_matching_symbol
4093 (mapped_index_base
&index
,
4094 const lookup_name_info
&lookup_name_in
,
4095 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4096 enum search_domain kind
,
4097 gdb::function_view
<bool (offset_type
)> match_callback
,
4098 dwarf2_per_objfile
*per_objfile
)
4100 lookup_name_info lookup_name_without_params
4101 = lookup_name_in
.make_ignore_params ();
4103 /* Build the symbol name component sorted vector, if we haven't
4105 index
.build_name_components (per_objfile
);
4107 /* The same symbol may appear more than once in the range though.
4108 E.g., if we're looking for symbols that complete "w", and we have
4109 a symbol named "w1::w2", we'll find the two name components for
4110 that same symbol in the range. To be sure we only call the
4111 callback once per symbol, we first collect the symbol name
4112 indexes that matched in a temporary vector and ignore
4114 std::vector
<offset_type
> matches
;
4116 struct name_and_matcher
4118 symbol_name_matcher_ftype
*matcher
;
4121 bool operator== (const name_and_matcher
&other
) const
4123 return matcher
== other
.matcher
&& strcmp (name
, other
.name
) == 0;
4127 /* A vector holding all the different symbol name matchers, for all
4129 std::vector
<name_and_matcher
> matchers
;
4131 for (int i
= 0; i
< nr_languages
; i
++)
4133 enum language lang_e
= (enum language
) i
;
4135 const language_defn
*lang
= language_def (lang_e
);
4136 symbol_name_matcher_ftype
*name_matcher
4137 = lang
->get_symbol_name_matcher (lookup_name_without_params
);
4139 name_and_matcher key
{
4141 lookup_name_without_params
.language_lookup_name (lang_e
)
4144 /* Don't insert the same comparison routine more than once.
4145 Note that we do this linear walk. This is not a problem in
4146 practice because the number of supported languages is
4148 if (std::find (matchers
.begin (), matchers
.end (), key
)
4151 matchers
.push_back (std::move (key
));
4154 = index
.find_name_components_bounds (lookup_name_without_params
,
4155 lang_e
, per_objfile
);
4157 /* Now for each symbol name in range, check to see if we have a name
4158 match, and if so, call the MATCH_CALLBACK callback. */
4160 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
4162 const char *qualified
4163 = index
.symbol_name_at (bounds
.first
->idx
, per_objfile
);
4165 if (!name_matcher (qualified
, lookup_name_without_params
, NULL
)
4166 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
4169 matches
.push_back (bounds
.first
->idx
);
4173 std::sort (matches
.begin (), matches
.end ());
4175 /* Finally call the callback, once per match. */
4177 for (offset_type idx
: matches
)
4181 if (!match_callback (idx
))
4187 /* Above we use a type wider than idx's for 'prev', since 0 and
4188 (offset_type)-1 are both possible values. */
4189 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
4194 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
4196 /* A mock .gdb_index/.debug_names-like name index table, enough to
4197 exercise dw2_expand_symtabs_matching_symbol, which works with the
4198 mapped_index_base interface. Builds an index from the symbol list
4199 passed as parameter to the constructor. */
4200 class mock_mapped_index
: public mapped_index_base
4203 mock_mapped_index (gdb::array_view
<const char *> symbols
)
4204 : m_symbol_table (symbols
)
4207 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
4209 /* Return the number of names in the symbol table. */
4210 size_t symbol_name_count () const override
4212 return m_symbol_table
.size ();
4215 /* Get the name of the symbol at IDX in the symbol table. */
4216 const char *symbol_name_at
4217 (offset_type idx
, dwarf2_per_objfile
*per_objfile
) const override
4219 return m_symbol_table
[idx
];
4223 gdb::array_view
<const char *> m_symbol_table
;
4226 /* Convenience function that converts a NULL pointer to a "<null>"
4227 string, to pass to print routines. */
4230 string_or_null (const char *str
)
4232 return str
!= NULL
? str
: "<null>";
4235 /* Check if a lookup_name_info built from
4236 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4237 index. EXPECTED_LIST is the list of expected matches, in expected
4238 matching order. If no match expected, then an empty list is
4239 specified. Returns true on success. On failure prints a warning
4240 indicating the file:line that failed, and returns false. */
4243 check_match (const char *file
, int line
,
4244 mock_mapped_index
&mock_index
,
4245 const char *name
, symbol_name_match_type match_type
,
4246 bool completion_mode
,
4247 std::initializer_list
<const char *> expected_list
,
4248 dwarf2_per_objfile
*per_objfile
)
4250 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4252 bool matched
= true;
4254 auto mismatch
= [&] (const char *expected_str
,
4257 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4258 "expected=\"%s\", got=\"%s\"\n"),
4260 (match_type
== symbol_name_match_type::FULL
4262 name
, string_or_null (expected_str
), string_or_null (got
));
4266 auto expected_it
= expected_list
.begin ();
4267 auto expected_end
= expected_list
.end ();
4269 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
4271 [&] (offset_type idx
)
4273 const char *matched_name
= mock_index
.symbol_name_at (idx
, per_objfile
);
4274 const char *expected_str
4275 = expected_it
== expected_end
? NULL
: *expected_it
++;
4277 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4278 mismatch (expected_str
, matched_name
);
4282 const char *expected_str
4283 = expected_it
== expected_end
? NULL
: *expected_it
++;
4284 if (expected_str
!= NULL
)
4285 mismatch (expected_str
, NULL
);
4290 /* The symbols added to the mock mapped_index for testing (in
4292 static const char *test_symbols
[] = {
4301 "ns2::tmpl<int>::foo2",
4302 "(anonymous namespace)::A::B::C",
4304 /* These are used to check that the increment-last-char in the
4305 matching algorithm for completion doesn't match "t1_fund" when
4306 completing "t1_func". */
4312 /* A UTF-8 name with multi-byte sequences to make sure that
4313 cp-name-parser understands this as a single identifier ("função"
4314 is "function" in PT). */
4317 /* \377 (0xff) is Latin1 'ÿ'. */
4320 /* \377 (0xff) is Latin1 'ÿ'. */
4324 /* A name with all sorts of complications. Starts with "z" to make
4325 it easier for the completion tests below. */
4326 #define Z_SYM_NAME \
4327 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4328 "::tuple<(anonymous namespace)::ui*, " \
4329 "std::default_delete<(anonymous namespace)::ui>, void>"
4334 /* Returns true if the mapped_index_base::find_name_component_bounds
4335 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4336 in completion mode. */
4339 check_find_bounds_finds (mapped_index_base
&index
,
4340 const char *search_name
,
4341 gdb::array_view
<const char *> expected_syms
,
4342 dwarf2_per_objfile
*per_objfile
)
4344 lookup_name_info
lookup_name (search_name
,
4345 symbol_name_match_type::FULL
, true);
4347 auto bounds
= index
.find_name_components_bounds (lookup_name
,
4351 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
4352 if (distance
!= expected_syms
.size ())
4355 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
4357 auto nc_elem
= bounds
.first
+ exp_elem
;
4358 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
, per_objfile
);
4359 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
4366 /* Test the lower-level mapped_index::find_name_component_bounds
4370 test_mapped_index_find_name_component_bounds ()
4372 mock_mapped_index
mock_index (test_symbols
);
4374 mock_index
.build_name_components (NULL
/* per_objfile */);
4376 /* Test the lower-level mapped_index::find_name_component_bounds
4377 method in completion mode. */
4379 static const char *expected_syms
[] = {
4384 SELF_CHECK (check_find_bounds_finds
4385 (mock_index
, "t1_func", expected_syms
,
4386 NULL
/* per_objfile */));
4389 /* Check that the increment-last-char in the name matching algorithm
4390 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4392 static const char *expected_syms1
[] = {
4396 SELF_CHECK (check_find_bounds_finds
4397 (mock_index
, "\377", expected_syms1
, NULL
/* per_objfile */));
4399 static const char *expected_syms2
[] = {
4402 SELF_CHECK (check_find_bounds_finds
4403 (mock_index
, "\377\377", expected_syms2
,
4404 NULL
/* per_objfile */));
4408 /* Test dw2_expand_symtabs_matching_symbol. */
4411 test_dw2_expand_symtabs_matching_symbol ()
4413 mock_mapped_index
mock_index (test_symbols
);
4415 /* We let all tests run until the end even if some fails, for debug
4417 bool any_mismatch
= false;
4419 /* Create the expected symbols list (an initializer_list). Needed
4420 because lists have commas, and we need to pass them to CHECK,
4421 which is a macro. */
4422 #define EXPECT(...) { __VA_ARGS__ }
4424 /* Wrapper for check_match that passes down the current
4425 __FILE__/__LINE__. */
4426 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4427 any_mismatch |= !check_match (__FILE__, __LINE__, \
4429 NAME, MATCH_TYPE, COMPLETION_MODE, \
4430 EXPECTED_LIST, NULL)
4432 /* Identity checks. */
4433 for (const char *sym
: test_symbols
)
4435 /* Should be able to match all existing symbols. */
4436 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4439 /* Should be able to match all existing symbols with
4441 std::string with_params
= std::string (sym
) + "(int)";
4442 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4445 /* Should be able to match all existing symbols with
4446 parameters and qualifiers. */
4447 with_params
= std::string (sym
) + " ( int ) const";
4448 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4451 /* This should really find sym, but cp-name-parser.y doesn't
4452 know about lvalue/rvalue qualifiers yet. */
4453 with_params
= std::string (sym
) + " ( int ) &&";
4454 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4458 /* Check that the name matching algorithm for completion doesn't get
4459 confused with Latin1 'ÿ' / 0xff. */
4461 static const char str
[] = "\377";
4462 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4463 EXPECT ("\377", "\377\377123"));
4466 /* Check that the increment-last-char in the matching algorithm for
4467 completion doesn't match "t1_fund" when completing "t1_func". */
4469 static const char str
[] = "t1_func";
4470 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4471 EXPECT ("t1_func", "t1_func1"));
4474 /* Check that completion mode works at each prefix of the expected
4477 static const char str
[] = "function(int)";
4478 size_t len
= strlen (str
);
4481 for (size_t i
= 1; i
< len
; i
++)
4483 lookup
.assign (str
, i
);
4484 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4485 EXPECT ("function"));
4489 /* While "w" is a prefix of both components, the match function
4490 should still only be called once. */
4492 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4494 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4498 /* Same, with a "complicated" symbol. */
4500 static const char str
[] = Z_SYM_NAME
;
4501 size_t len
= strlen (str
);
4504 for (size_t i
= 1; i
< len
; i
++)
4506 lookup
.assign (str
, i
);
4507 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4508 EXPECT (Z_SYM_NAME
));
4512 /* In FULL mode, an incomplete symbol doesn't match. */
4514 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4518 /* A complete symbol with parameters matches any overload, since the
4519 index has no overload info. */
4521 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4522 EXPECT ("std::zfunction", "std::zfunction2"));
4523 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4524 EXPECT ("std::zfunction", "std::zfunction2"));
4525 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4526 EXPECT ("std::zfunction", "std::zfunction2"));
4529 /* Check that whitespace is ignored appropriately. A symbol with a
4530 template argument list. */
4532 static const char expected
[] = "ns::foo<int>";
4533 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4535 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4539 /* Check that whitespace is ignored appropriately. A symbol with a
4540 template argument list that includes a pointer. */
4542 static const char expected
[] = "ns::foo<char*>";
4543 /* Try both completion and non-completion modes. */
4544 static const bool completion_mode
[2] = {false, true};
4545 for (size_t i
= 0; i
< 2; i
++)
4547 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4548 completion_mode
[i
], EXPECT (expected
));
4549 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4550 completion_mode
[i
], EXPECT (expected
));
4552 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4553 completion_mode
[i
], EXPECT (expected
));
4554 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4555 completion_mode
[i
], EXPECT (expected
));
4560 /* Check method qualifiers are ignored. */
4561 static const char expected
[] = "ns::foo<char*>";
4562 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4563 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4564 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4565 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4566 CHECK_MATCH ("foo < char * > ( int ) const",
4567 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4568 CHECK_MATCH ("foo < char * > ( int ) &&",
4569 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4572 /* Test lookup names that don't match anything. */
4574 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4577 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4581 /* Some wild matching tests, exercising "(anonymous namespace)",
4582 which should not be confused with a parameter list. */
4584 static const char *syms
[] = {
4588 "A :: B :: C ( int )",
4593 for (const char *s
: syms
)
4595 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4596 EXPECT ("(anonymous namespace)::A::B::C"));
4601 static const char expected
[] = "ns2::tmpl<int>::foo2";
4602 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4604 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4608 SELF_CHECK (!any_mismatch
);
4617 test_mapped_index_find_name_component_bounds ();
4618 test_dw2_expand_symtabs_matching_symbol ();
4621 }} // namespace selftests::dw2_expand_symtabs_matching
4623 #endif /* GDB_SELF_TEST */
4625 /* If FILE_MATCHER is NULL or if PER_CU has
4626 dwarf2_per_cu_quick_data::MARK set (see
4627 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4628 EXPANSION_NOTIFY on it. */
4631 dw2_expand_symtabs_matching_one
4632 (dwarf2_per_cu_data
*per_cu
,
4633 dwarf2_per_objfile
*per_objfile
,
4634 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4635 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4637 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4639 bool symtab_was_null
= !per_objfile
->symtab_set_p (per_cu
);
4641 compunit_symtab
*symtab
4642 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
4643 gdb_assert (symtab
!= nullptr);
4645 if (expansion_notify
!= NULL
&& symtab_was_null
)
4646 expansion_notify (symtab
);
4650 /* Helper for dw2_expand_matching symtabs. Called on each symbol
4651 matched, to expand corresponding CUs that were marked. IDX is the
4652 index of the symbol name that matched. */
4655 dw2_expand_marked_cus
4656 (dwarf2_per_objfile
*per_objfile
, offset_type idx
,
4657 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4658 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4661 offset_type
*vec
, vec_len
, vec_idx
;
4662 bool global_seen
= false;
4663 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4665 vec
= (offset_type
*) (index
.constant_pool
4666 + MAYBE_SWAP (index
.symbol_table
[idx
].vec
));
4667 vec_len
= MAYBE_SWAP (vec
[0]);
4668 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
4670 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
4671 /* This value is only valid for index versions >= 7. */
4672 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4673 gdb_index_symbol_kind symbol_kind
=
4674 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
4675 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
4676 /* Only check the symbol attributes if they're present.
4677 Indices prior to version 7 don't record them,
4678 and indices >= 7 may elide them for certain symbols
4679 (gold does this). */
4682 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
4684 /* Work around gold/15646. */
4687 && symbol_kind
== GDB_INDEX_SYMBOL_KIND_TYPE
)
4695 /* Only check the symbol's kind if it has one. */
4700 case VARIABLES_DOMAIN
:
4701 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
4704 case FUNCTIONS_DOMAIN
:
4705 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
4709 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4712 case MODULES_DOMAIN
:
4713 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4721 /* Don't crash on bad data. */
4722 if (cu_index
>= (per_objfile
->per_bfd
->all_comp_units
.size ()
4723 + per_objfile
->per_bfd
->all_type_units
.size ()))
4725 complaint (_(".gdb_index entry has bad CU index"
4726 " [in module %s]"), objfile_name (per_objfile
->objfile
));
4730 dwarf2_per_cu_data
*per_cu
= per_objfile
->per_bfd
->get_cutu (cu_index
);
4731 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
4736 /* If FILE_MATCHER is non-NULL, set all the
4737 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
4738 that match FILE_MATCHER. */
4741 dw_expand_symtabs_matching_file_matcher
4742 (dwarf2_per_objfile
*per_objfile
,
4743 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
4745 if (file_matcher
== NULL
)
4748 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
4750 NULL
, xcalloc
, xfree
));
4751 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
4753 NULL
, xcalloc
, xfree
));
4755 /* The rule is CUs specify all the files, including those used by
4756 any TU, so there's no need to scan TUs here. */
4758 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4762 per_cu
->v
.quick
->mark
= 0;
4764 /* We only need to look at symtabs not already expanded. */
4765 if (per_objfile
->symtab_set_p (per_cu
))
4768 quick_file_names
*file_data
= dw2_get_file_names (per_cu
, per_objfile
);
4769 if (file_data
== NULL
)
4772 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
4774 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
4776 per_cu
->v
.quick
->mark
= 1;
4780 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4782 const char *this_real_name
;
4784 if (file_matcher (file_data
->file_names
[j
], false))
4786 per_cu
->v
.quick
->mark
= 1;
4790 /* Before we invoke realpath, which can get expensive when many
4791 files are involved, do a quick comparison of the basenames. */
4792 if (!basenames_may_differ
4793 && !file_matcher (lbasename (file_data
->file_names
[j
]),
4797 this_real_name
= dw2_get_real_path (per_objfile
, file_data
, j
);
4798 if (file_matcher (this_real_name
, false))
4800 per_cu
->v
.quick
->mark
= 1;
4805 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
4806 ? visited_found
.get ()
4807 : visited_not_found
.get (),
4814 dw2_expand_symtabs_matching
4815 (struct objfile
*objfile
,
4816 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4817 const lookup_name_info
*lookup_name
,
4818 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4819 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
4820 enum search_domain kind
)
4822 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4824 /* index_table is NULL if OBJF_READNOW. */
4825 if (!per_objfile
->per_bfd
->index_table
)
4828 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
4830 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
4832 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4836 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
,
4837 file_matcher
, expansion_notify
);
4842 mapped_index
&index
= *per_objfile
->per_bfd
->index_table
;
4844 dw2_expand_symtabs_matching_symbol (index
, *lookup_name
,
4846 kind
, [&] (offset_type idx
)
4848 dw2_expand_marked_cus (per_objfile
, idx
, file_matcher
, expansion_notify
,
4854 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4857 static struct compunit_symtab
*
4858 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
4863 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
4864 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
4867 if (cust
->includes
== NULL
)
4870 for (i
= 0; cust
->includes
[i
]; ++i
)
4872 struct compunit_symtab
*s
= cust
->includes
[i
];
4874 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
4882 static struct compunit_symtab
*
4883 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
4884 struct bound_minimal_symbol msymbol
,
4886 struct obj_section
*section
,
4889 struct dwarf2_per_cu_data
*data
;
4890 struct compunit_symtab
*result
;
4892 if (!objfile
->partial_symtabs
->psymtabs_addrmap
)
4895 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
4896 data
= (struct dwarf2_per_cu_data
*) addrmap_find
4897 (objfile
->partial_symtabs
->psymtabs_addrmap
, pc
- baseaddr
);
4901 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4902 if (warn_if_readin
&& per_objfile
->symtab_set_p (data
))
4903 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4904 paddress (objfile
->arch (), pc
));
4906 result
= recursively_find_pc_sect_compunit_symtab
4907 (dw2_instantiate_symtab (data
, per_objfile
, false), pc
);
4909 gdb_assert (result
!= NULL
);
4914 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
4915 void *data
, int need_fullname
)
4917 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
4919 if (!per_objfile
->per_bfd
->filenames_cache
)
4921 per_objfile
->per_bfd
->filenames_cache
.emplace ();
4923 htab_up
visited (htab_create_alloc (10,
4924 htab_hash_pointer
, htab_eq_pointer
,
4925 NULL
, xcalloc
, xfree
));
4927 /* The rule is CUs specify all the files, including those used
4928 by any TU, so there's no need to scan TUs here. We can
4929 ignore file names coming from already-expanded CUs. */
4931 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4933 if (per_objfile
->symtab_set_p (per_cu
))
4935 void **slot
= htab_find_slot (visited
.get (),
4936 per_cu
->v
.quick
->file_names
,
4939 *slot
= per_cu
->v
.quick
->file_names
;
4943 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
4945 /* We only need to look at symtabs not already expanded. */
4946 if (per_objfile
->symtab_set_p (per_cu
))
4949 quick_file_names
*file_data
4950 = dw2_get_file_names (per_cu
, per_objfile
);
4951 if (file_data
== NULL
)
4954 void **slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
4957 /* Already visited. */
4962 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4964 const char *filename
= file_data
->file_names
[j
];
4965 per_objfile
->per_bfd
->filenames_cache
->seen (filename
);
4970 per_objfile
->per_bfd
->filenames_cache
->traverse ([&] (const char *filename
)
4972 gdb::unique_xmalloc_ptr
<char> this_real_name
;
4975 this_real_name
= gdb_realpath (filename
);
4976 (*fun
) (filename
, this_real_name
.get (), data
);
4981 dw2_has_symbols (struct objfile
*objfile
)
4986 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
4989 dw2_find_last_source_symtab
,
4990 dw2_forget_cached_source_info
,
4991 dw2_map_symtabs_matching_filename
,
4996 dw2_expand_symtabs_for_function
,
4997 dw2_expand_all_symtabs
,
4998 dw2_expand_symtabs_with_fullname
,
4999 dw2_map_matching_symbols
,
5000 dw2_expand_symtabs_matching
,
5001 dw2_find_pc_sect_compunit_symtab
,
5003 dw2_map_symbol_filenames
5006 /* DWARF-5 debug_names reader. */
5008 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5009 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
5011 /* A helper function that reads the .debug_names section in SECTION
5012 and fills in MAP. FILENAME is the name of the file containing the
5013 section; it is used for error reporting.
5015 Returns true if all went well, false otherwise. */
5018 read_debug_names_from_section (struct objfile
*objfile
,
5019 const char *filename
,
5020 struct dwarf2_section_info
*section
,
5021 mapped_debug_names
&map
)
5023 if (section
->empty ())
5026 /* Older elfutils strip versions could keep the section in the main
5027 executable while splitting it for the separate debug info file. */
5028 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
5031 section
->read (objfile
);
5033 map
.dwarf5_byte_order
= gdbarch_byte_order (objfile
->arch ());
5035 const gdb_byte
*addr
= section
->buffer
;
5037 bfd
*const abfd
= section
->get_bfd_owner ();
5039 unsigned int bytes_read
;
5040 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
5043 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
5044 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
5045 if (bytes_read
+ length
!= section
->size
)
5047 /* There may be multiple per-CU indices. */
5048 warning (_("Section .debug_names in %s length %s does not match "
5049 "section length %s, ignoring .debug_names."),
5050 filename
, plongest (bytes_read
+ length
),
5051 pulongest (section
->size
));
5055 /* The version number. */
5056 uint16_t version
= read_2_bytes (abfd
, addr
);
5060 warning (_("Section .debug_names in %s has unsupported version %d, "
5061 "ignoring .debug_names."),
5067 uint16_t padding
= read_2_bytes (abfd
, addr
);
5071 warning (_("Section .debug_names in %s has unsupported padding %d, "
5072 "ignoring .debug_names."),
5077 /* comp_unit_count - The number of CUs in the CU list. */
5078 map
.cu_count
= read_4_bytes (abfd
, addr
);
5081 /* local_type_unit_count - The number of TUs in the local TU
5083 map
.tu_count
= read_4_bytes (abfd
, addr
);
5086 /* foreign_type_unit_count - The number of TUs in the foreign TU
5088 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
5090 if (foreign_tu_count
!= 0)
5092 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5093 "ignoring .debug_names."),
5094 filename
, static_cast<unsigned long> (foreign_tu_count
));
5098 /* bucket_count - The number of hash buckets in the hash lookup
5100 map
.bucket_count
= read_4_bytes (abfd
, addr
);
5103 /* name_count - The number of unique names in the index. */
5104 map
.name_count
= read_4_bytes (abfd
, addr
);
5107 /* abbrev_table_size - The size in bytes of the abbreviations
5109 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
5112 /* augmentation_string_size - The size in bytes of the augmentation
5113 string. This value is rounded up to a multiple of 4. */
5114 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
5116 map
.augmentation_is_gdb
= ((augmentation_string_size
5117 == sizeof (dwarf5_augmentation
))
5118 && memcmp (addr
, dwarf5_augmentation
,
5119 sizeof (dwarf5_augmentation
)) == 0);
5120 augmentation_string_size
+= (-augmentation_string_size
) & 3;
5121 addr
+= augmentation_string_size
;
5124 map
.cu_table_reordered
= addr
;
5125 addr
+= map
.cu_count
* map
.offset_size
;
5127 /* List of Local TUs */
5128 map
.tu_table_reordered
= addr
;
5129 addr
+= map
.tu_count
* map
.offset_size
;
5131 /* Hash Lookup Table */
5132 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5133 addr
+= map
.bucket_count
* 4;
5134 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5135 addr
+= map
.name_count
* 4;
5138 map
.name_table_string_offs_reordered
= addr
;
5139 addr
+= map
.name_count
* map
.offset_size
;
5140 map
.name_table_entry_offs_reordered
= addr
;
5141 addr
+= map
.name_count
* map
.offset_size
;
5143 const gdb_byte
*abbrev_table_start
= addr
;
5146 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5151 const auto insertpair
5152 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
5153 if (!insertpair
.second
)
5155 warning (_("Section .debug_names in %s has duplicate index %s, "
5156 "ignoring .debug_names."),
5157 filename
, pulongest (index_num
));
5160 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
5161 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5166 mapped_debug_names::index_val::attr attr
;
5167 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5169 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5171 if (attr
.form
== DW_FORM_implicit_const
)
5173 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
5177 if (attr
.dw_idx
== 0 && attr
.form
== 0)
5179 indexval
.attr_vec
.push_back (std::move (attr
));
5182 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
5184 warning (_("Section .debug_names in %s has abbreviation_table "
5185 "of size %s vs. written as %u, ignoring .debug_names."),
5186 filename
, plongest (addr
- abbrev_table_start
),
5190 map
.entry_pool
= addr
;
5195 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5199 create_cus_from_debug_names_list (dwarf2_per_bfd
*per_bfd
,
5200 const mapped_debug_names
&map
,
5201 dwarf2_section_info
§ion
,
5204 if (!map
.augmentation_is_gdb
)
5206 for (uint32_t i
= 0; i
< map
.cu_count
; ++i
)
5208 sect_offset sect_off
5209 = (sect_offset
) (extract_unsigned_integer
5210 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5212 map
.dwarf5_byte_order
));
5213 /* We don't know the length of the CU, because the CU list in a
5214 .debug_names index can be incomplete, so we can't use the start of
5215 the next CU as end of this CU. We create the CUs here with length 0,
5216 and in cutu_reader::cutu_reader we'll fill in the actual length. */
5217 dwarf2_per_cu_data
*per_cu
5218 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
, sect_off
, 0);
5219 per_bfd
->all_comp_units
.push_back (per_cu
);
5223 sect_offset sect_off_prev
;
5224 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
5226 sect_offset sect_off_next
;
5227 if (i
< map
.cu_count
)
5230 = (sect_offset
) (extract_unsigned_integer
5231 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5233 map
.dwarf5_byte_order
));
5236 sect_off_next
= (sect_offset
) section
.size
;
5239 const ULONGEST length
= sect_off_next
- sect_off_prev
;
5240 dwarf2_per_cu_data
*per_cu
5241 = create_cu_from_index_list (per_bfd
, §ion
, is_dwz
,
5242 sect_off_prev
, length
);
5243 per_bfd
->all_comp_units
.push_back (per_cu
);
5245 sect_off_prev
= sect_off_next
;
5249 /* Read the CU list from the mapped index, and use it to create all
5250 the CU objects for this dwarf2_per_objfile. */
5253 create_cus_from_debug_names (dwarf2_per_bfd
*per_bfd
,
5254 const mapped_debug_names
&map
,
5255 const mapped_debug_names
&dwz_map
)
5257 gdb_assert (per_bfd
->all_comp_units
.empty ());
5258 per_bfd
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
5260 create_cus_from_debug_names_list (per_bfd
, map
, per_bfd
->info
,
5261 false /* is_dwz */);
5263 if (dwz_map
.cu_count
== 0)
5266 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
5267 create_cus_from_debug_names_list (per_bfd
, dwz_map
, dwz
->info
,
5271 /* Read .debug_names. If everything went ok, initialize the "quick"
5272 elements of all the CUs and return true. Otherwise, return false. */
5275 dwarf2_read_debug_names (dwarf2_per_objfile
*per_objfile
)
5277 std::unique_ptr
<mapped_debug_names
> map (new mapped_debug_names
);
5278 mapped_debug_names dwz_map
;
5279 struct objfile
*objfile
= per_objfile
->objfile
;
5280 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
5282 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
5283 &per_objfile
->per_bfd
->debug_names
, *map
))
5286 /* Don't use the index if it's empty. */
5287 if (map
->name_count
== 0)
5290 /* If there is a .dwz file, read it so we can get its CU list as
5292 dwz_file
*dwz
= dwarf2_get_dwz_file (per_bfd
);
5295 if (!read_debug_names_from_section (objfile
,
5296 bfd_get_filename (dwz
->dwz_bfd
.get ()),
5297 &dwz
->debug_names
, dwz_map
))
5299 warning (_("could not read '.debug_names' section from %s; skipping"),
5300 bfd_get_filename (dwz
->dwz_bfd
.get ()));
5305 create_cus_from_debug_names (per_bfd
, *map
, dwz_map
);
5307 if (map
->tu_count
!= 0)
5309 /* We can only handle a single .debug_types when we have an
5311 if (per_bfd
->types
.size () != 1)
5314 dwarf2_section_info
*section
= &per_bfd
->types
[0];
5316 create_signatured_type_table_from_debug_names
5317 (per_objfile
, *map
, section
, &per_bfd
->abbrev
);
5320 create_addrmap_from_aranges (per_objfile
, &per_bfd
->debug_aranges
);
5322 per_bfd
->debug_names_table
= std::move (map
);
5323 per_bfd
->using_index
= 1;
5324 per_bfd
->quick_file_names_table
=
5325 create_quick_file_names_table (per_objfile
->per_bfd
->all_comp_units
.size ());
5327 /* Save partial symtabs in the per_bfd object, for the benefit of subsequent
5328 objfiles using the same BFD. */
5329 gdb_assert (per_bfd
->partial_symtabs
== nullptr);
5330 per_bfd
->partial_symtabs
= objfile
->partial_symtabs
;
5335 /* Type used to manage iterating over all CUs looking for a symbol for
5338 class dw2_debug_names_iterator
5341 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5342 gdb::optional
<block_enum
> block_index
,
5344 const char *name
, dwarf2_per_objfile
*per_objfile
)
5345 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5346 m_addr (find_vec_in_debug_names (map
, name
, per_objfile
)),
5347 m_per_objfile (per_objfile
)
5350 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5351 search_domain search
, uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5354 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
5355 m_per_objfile (per_objfile
)
5358 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5359 block_enum block_index
, domain_enum domain
,
5360 uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5361 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5362 m_addr (find_vec_in_debug_names (map
, namei
, per_objfile
)),
5363 m_per_objfile (per_objfile
)
5366 /* Return the next matching CU or NULL if there are no more. */
5367 dwarf2_per_cu_data
*next ();
5370 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5372 dwarf2_per_objfile
*per_objfile
);
5373 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5375 dwarf2_per_objfile
*per_objfile
);
5377 /* The internalized form of .debug_names. */
5378 const mapped_debug_names
&m_map
;
5380 /* If set, only look for symbols that match that block. Valid values are
5381 GLOBAL_BLOCK and STATIC_BLOCK. */
5382 const gdb::optional
<block_enum
> m_block_index
;
5384 /* The kind of symbol we're looking for. */
5385 const domain_enum m_domain
= UNDEF_DOMAIN
;
5386 const search_domain m_search
= ALL_DOMAIN
;
5388 /* The list of CUs from the index entry of the symbol, or NULL if
5390 const gdb_byte
*m_addr
;
5392 dwarf2_per_objfile
*m_per_objfile
;
5396 mapped_debug_names::namei_to_name
5397 (uint32_t namei
, dwarf2_per_objfile
*per_objfile
) const
5399 const ULONGEST namei_string_offs
5400 = extract_unsigned_integer ((name_table_string_offs_reordered
5401 + namei
* offset_size
),
5404 return read_indirect_string_at_offset (per_objfile
, namei_string_offs
);
5407 /* Find a slot in .debug_names for the object named NAME. If NAME is
5408 found, return pointer to its pool data. If NAME cannot be found,
5412 dw2_debug_names_iterator::find_vec_in_debug_names
5413 (const mapped_debug_names
&map
, const char *name
,
5414 dwarf2_per_objfile
*per_objfile
)
5416 int (*cmp
) (const char *, const char *);
5418 gdb::unique_xmalloc_ptr
<char> without_params
;
5419 if (current_language
->la_language
== language_cplus
5420 || current_language
->la_language
== language_fortran
5421 || current_language
->la_language
== language_d
)
5423 /* NAME is already canonical. Drop any qualifiers as
5424 .debug_names does not contain any. */
5426 if (strchr (name
, '(') != NULL
)
5428 without_params
= cp_remove_params (name
);
5429 if (without_params
!= NULL
)
5430 name
= without_params
.get ();
5434 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
5436 const uint32_t full_hash
= dwarf5_djb_hash (name
);
5438 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5439 (map
.bucket_table_reordered
5440 + (full_hash
% map
.bucket_count
)), 4,
5441 map
.dwarf5_byte_order
);
5445 if (namei
>= map
.name_count
)
5447 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5449 namei
, map
.name_count
,
5450 objfile_name (per_objfile
->objfile
));
5456 const uint32_t namei_full_hash
5457 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5458 (map
.hash_table_reordered
+ namei
), 4,
5459 map
.dwarf5_byte_order
);
5460 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
5463 if (full_hash
== namei_full_hash
)
5465 const char *const namei_string
= map
.namei_to_name (namei
, per_objfile
);
5467 #if 0 /* An expensive sanity check. */
5468 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
5470 complaint (_("Wrong .debug_names hash for string at index %u "
5472 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
5477 if (cmp (namei_string
, name
) == 0)
5479 const ULONGEST namei_entry_offs
5480 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5481 + namei
* map
.offset_size
),
5482 map
.offset_size
, map
.dwarf5_byte_order
);
5483 return map
.entry_pool
+ namei_entry_offs
;
5488 if (namei
>= map
.name_count
)
5494 dw2_debug_names_iterator::find_vec_in_debug_names
5495 (const mapped_debug_names
&map
, uint32_t namei
, dwarf2_per_objfile
*per_objfile
)
5497 if (namei
>= map
.name_count
)
5499 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5501 namei
, map
.name_count
,
5502 objfile_name (per_objfile
->objfile
));
5506 const ULONGEST namei_entry_offs
5507 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5508 + namei
* map
.offset_size
),
5509 map
.offset_size
, map
.dwarf5_byte_order
);
5510 return map
.entry_pool
+ namei_entry_offs
;
5513 /* See dw2_debug_names_iterator. */
5515 dwarf2_per_cu_data
*
5516 dw2_debug_names_iterator::next ()
5521 dwarf2_per_bfd
*per_bfd
= m_per_objfile
->per_bfd
;
5522 struct objfile
*objfile
= m_per_objfile
->objfile
;
5523 bfd
*const abfd
= objfile
->obfd
;
5527 unsigned int bytes_read
;
5528 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5529 m_addr
+= bytes_read
;
5533 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5534 if (indexval_it
== m_map
.abbrev_map
.cend ())
5536 complaint (_("Wrong .debug_names undefined abbrev code %s "
5538 pulongest (abbrev
), objfile_name (objfile
));
5541 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5542 enum class symbol_linkage
{
5546 } symbol_linkage_
= symbol_linkage::unknown
;
5547 dwarf2_per_cu_data
*per_cu
= NULL
;
5548 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5553 case DW_FORM_implicit_const
:
5554 ull
= attr
.implicit_const
;
5556 case DW_FORM_flag_present
:
5560 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5561 m_addr
+= bytes_read
;
5564 ull
= read_4_bytes (abfd
, m_addr
);
5568 ull
= read_8_bytes (abfd
, m_addr
);
5571 case DW_FORM_ref_sig8
:
5572 ull
= read_8_bytes (abfd
, m_addr
);
5576 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5577 dwarf_form_name (attr
.form
),
5578 objfile_name (objfile
));
5581 switch (attr
.dw_idx
)
5583 case DW_IDX_compile_unit
:
5584 /* Don't crash on bad data. */
5585 if (ull
>= m_per_objfile
->per_bfd
->all_comp_units
.size ())
5587 complaint (_(".debug_names entry has bad CU index %s"
5590 objfile_name (objfile
));
5593 per_cu
= per_bfd
->get_cutu (ull
);
5595 case DW_IDX_type_unit
:
5596 /* Don't crash on bad data. */
5597 if (ull
>= per_bfd
->all_type_units
.size ())
5599 complaint (_(".debug_names entry has bad TU index %s"
5602 objfile_name (objfile
));
5605 per_cu
= &per_bfd
->get_tu (ull
)->per_cu
;
5607 case DW_IDX_die_offset
:
5608 /* In a per-CU index (as opposed to a per-module index), index
5609 entries without CU attribute implicitly refer to the single CU. */
5611 per_cu
= per_bfd
->get_cu (0);
5613 case DW_IDX_GNU_internal
:
5614 if (!m_map
.augmentation_is_gdb
)
5616 symbol_linkage_
= symbol_linkage::static_
;
5618 case DW_IDX_GNU_external
:
5619 if (!m_map
.augmentation_is_gdb
)
5621 symbol_linkage_
= symbol_linkage::extern_
;
5626 /* Skip if already read in. */
5627 if (m_per_objfile
->symtab_set_p (per_cu
))
5630 /* Check static vs global. */
5631 if (symbol_linkage_
!= symbol_linkage::unknown
&& m_block_index
.has_value ())
5633 const bool want_static
= *m_block_index
== STATIC_BLOCK
;
5634 const bool symbol_is_static
=
5635 symbol_linkage_
== symbol_linkage::static_
;
5636 if (want_static
!= symbol_is_static
)
5640 /* Match dw2_symtab_iter_next, symbol_kind
5641 and debug_names::psymbol_tag. */
5645 switch (indexval
.dwarf_tag
)
5647 case DW_TAG_variable
:
5648 case DW_TAG_subprogram
:
5649 /* Some types are also in VAR_DOMAIN. */
5650 case DW_TAG_typedef
:
5651 case DW_TAG_structure_type
:
5658 switch (indexval
.dwarf_tag
)
5660 case DW_TAG_typedef
:
5661 case DW_TAG_structure_type
:
5668 switch (indexval
.dwarf_tag
)
5671 case DW_TAG_variable
:
5678 switch (indexval
.dwarf_tag
)
5690 /* Match dw2_expand_symtabs_matching, symbol_kind and
5691 debug_names::psymbol_tag. */
5694 case VARIABLES_DOMAIN
:
5695 switch (indexval
.dwarf_tag
)
5697 case DW_TAG_variable
:
5703 case FUNCTIONS_DOMAIN
:
5704 switch (indexval
.dwarf_tag
)
5706 case DW_TAG_subprogram
:
5713 switch (indexval
.dwarf_tag
)
5715 case DW_TAG_typedef
:
5716 case DW_TAG_structure_type
:
5722 case MODULES_DOMAIN
:
5723 switch (indexval
.dwarf_tag
)
5737 static struct compunit_symtab
*
5738 dw2_debug_names_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
5739 const char *name
, domain_enum domain
)
5741 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5743 const auto &mapp
= per_objfile
->per_bfd
->debug_names_table
;
5746 /* index is NULL if OBJF_READNOW. */
5749 const auto &map
= *mapp
;
5751 dw2_debug_names_iterator
iter (map
, block_index
, domain
, name
, per_objfile
);
5753 struct compunit_symtab
*stab_best
= NULL
;
5754 struct dwarf2_per_cu_data
*per_cu
;
5755 while ((per_cu
= iter
.next ()) != NULL
)
5757 struct symbol
*sym
, *with_opaque
= NULL
;
5758 compunit_symtab
*stab
5759 = dw2_instantiate_symtab (per_cu
, per_objfile
, false);
5760 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
5761 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
5763 sym
= block_find_symbol (block
, name
, domain
,
5764 block_find_non_opaque_type_preferred
,
5767 /* Some caution must be observed with overloaded functions and
5768 methods, since the index will not contain any overload
5769 information (but NAME might contain it). */
5772 && strcmp_iw (sym
->search_name (), name
) == 0)
5774 if (with_opaque
!= NULL
5775 && strcmp_iw (with_opaque
->search_name (), name
) == 0)
5778 /* Keep looking through other CUs. */
5784 /* This dumps minimal information about .debug_names. It is called
5785 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
5786 uses this to verify that .debug_names has been loaded. */
5789 dw2_debug_names_dump (struct objfile
*objfile
)
5791 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5793 gdb_assert (per_objfile
->per_bfd
->using_index
);
5794 printf_filtered (".debug_names:");
5795 if (per_objfile
->per_bfd
->debug_names_table
)
5796 printf_filtered (" exists\n");
5798 printf_filtered (" faked for \"readnow\"\n");
5799 printf_filtered ("\n");
5803 dw2_debug_names_expand_symtabs_for_function (struct objfile
*objfile
,
5804 const char *func_name
)
5806 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5808 /* per_objfile->per_bfd->debug_names_table is NULL if OBJF_READNOW. */
5809 if (per_objfile
->per_bfd
->debug_names_table
)
5811 const mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5813 dw2_debug_names_iterator
iter (map
, {}, VAR_DOMAIN
, func_name
,
5816 struct dwarf2_per_cu_data
*per_cu
;
5817 while ((per_cu
= iter
.next ()) != NULL
)
5818 dw2_instantiate_symtab (per_cu
, per_objfile
, false);
5823 dw2_debug_names_map_matching_symbols
5824 (struct objfile
*objfile
,
5825 const lookup_name_info
&name
, domain_enum domain
,
5827 gdb::function_view
<symbol_found_callback_ftype
> callback
,
5828 symbol_compare_ftype
*ordered_compare
)
5830 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5832 /* debug_names_table is NULL if OBJF_READNOW. */
5833 if (!per_objfile
->per_bfd
->debug_names_table
)
5836 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5837 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
5839 const char *match_name
= name
.ada ().lookup_name ().c_str ();
5840 auto matcher
= [&] (const char *symname
)
5842 if (ordered_compare
== nullptr)
5844 return ordered_compare (symname
, match_name
) == 0;
5847 dw2_expand_symtabs_matching_symbol (map
, name
, matcher
, ALL_DOMAIN
,
5848 [&] (offset_type namei
)
5850 /* The name was matched, now expand corresponding CUs that were
5852 dw2_debug_names_iterator
iter (map
, block_kind
, domain
, namei
,
5855 struct dwarf2_per_cu_data
*per_cu
;
5856 while ((per_cu
= iter
.next ()) != NULL
)
5857 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, nullptr,
5862 /* It's a shame we couldn't do this inside the
5863 dw2_expand_symtabs_matching_symbol callback, but that skips CUs
5864 that have already been expanded. Instead, this loop matches what
5865 the psymtab code does. */
5866 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5868 compunit_symtab
*symtab
= per_objfile
->get_symtab (per_cu
);
5869 if (symtab
!= nullptr)
5871 const struct block
*block
5872 = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (symtab
), block_kind
);
5873 if (!iterate_over_symbols_terminated (block
, name
,
5881 dw2_debug_names_expand_symtabs_matching
5882 (struct objfile
*objfile
,
5883 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5884 const lookup_name_info
*lookup_name
,
5885 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5886 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5887 enum search_domain kind
)
5889 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
5891 /* debug_names_table is NULL if OBJF_READNOW. */
5892 if (!per_objfile
->per_bfd
->debug_names_table
)
5895 dw_expand_symtabs_matching_file_matcher (per_objfile
, file_matcher
);
5897 if (symbol_matcher
== NULL
&& lookup_name
== NULL
)
5899 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
5903 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
5909 mapped_debug_names
&map
= *per_objfile
->per_bfd
->debug_names_table
;
5911 dw2_expand_symtabs_matching_symbol (map
, *lookup_name
,
5913 kind
, [&] (offset_type namei
)
5915 /* The name was matched, now expand corresponding CUs that were
5917 dw2_debug_names_iterator
iter (map
, kind
, namei
, per_objfile
);
5919 struct dwarf2_per_cu_data
*per_cu
;
5920 while ((per_cu
= iter
.next ()) != NULL
)
5921 dw2_expand_symtabs_matching_one (per_cu
, per_objfile
, file_matcher
,
5927 const struct quick_symbol_functions dwarf2_debug_names_functions
=
5930 dw2_find_last_source_symtab
,
5931 dw2_forget_cached_source_info
,
5932 dw2_map_symtabs_matching_filename
,
5933 dw2_debug_names_lookup_symbol
,
5936 dw2_debug_names_dump
,
5937 dw2_debug_names_expand_symtabs_for_function
,
5938 dw2_expand_all_symtabs
,
5939 dw2_expand_symtabs_with_fullname
,
5940 dw2_debug_names_map_matching_symbols
,
5941 dw2_debug_names_expand_symtabs_matching
,
5942 dw2_find_pc_sect_compunit_symtab
,
5944 dw2_map_symbol_filenames
5947 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
5948 to either a dwarf2_per_bfd or dwz_file object. */
5950 template <typename T
>
5951 static gdb::array_view
<const gdb_byte
>
5952 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
5954 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
5956 if (section
->empty ())
5959 /* Older elfutils strip versions could keep the section in the main
5960 executable while splitting it for the separate debug info file. */
5961 if ((section
->get_flags () & SEC_HAS_CONTENTS
) == 0)
5964 section
->read (obj
);
5966 /* dwarf2_section_info::size is a bfd_size_type, while
5967 gdb::array_view works with size_t. On 32-bit hosts, with
5968 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
5969 is 32-bit. So we need an explicit narrowing conversion here.
5970 This is fine, because it's impossible to allocate or mmap an
5971 array/buffer larger than what size_t can represent. */
5972 return gdb::make_array_view (section
->buffer
, section
->size
);
5975 /* Lookup the index cache for the contents of the index associated to
5978 static gdb::array_view
<const gdb_byte
>
5979 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_bfd
*dwarf2_per_bfd
)
5981 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
5982 if (build_id
== nullptr)
5985 return global_index_cache
.lookup_gdb_index (build_id
,
5986 &dwarf2_per_bfd
->index_cache_res
);
5989 /* Same as the above, but for DWZ. */
5991 static gdb::array_view
<const gdb_byte
>
5992 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
5994 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
5995 if (build_id
== nullptr)
5998 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
6001 /* See symfile.h. */
6004 dwarf2_initialize_objfile (struct objfile
*objfile
, dw_index_kind
*index_kind
)
6006 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
6007 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6009 /* If we're about to read full symbols, don't bother with the
6010 indices. In this case we also don't care if some other debug
6011 format is making psymtabs, because they are all about to be
6013 if ((objfile
->flags
& OBJF_READNOW
))
6015 /* When using READNOW, the using_index flag (set below) indicates that
6016 PER_BFD was already initialized, when we loaded some other objfile. */
6017 if (per_bfd
->using_index
)
6019 *index_kind
= dw_index_kind::GDB_INDEX
;
6020 per_objfile
->resize_symtabs ();
6024 per_bfd
->using_index
= 1;
6025 create_all_comp_units (per_objfile
);
6026 create_all_type_units (per_objfile
);
6027 per_bfd
->quick_file_names_table
6028 = create_quick_file_names_table (per_bfd
->all_comp_units
.size ());
6029 per_objfile
->resize_symtabs ();
6031 for (int i
= 0; i
< (per_bfd
->all_comp_units
.size ()
6032 + per_bfd
->all_type_units
.size ()); ++i
)
6034 dwarf2_per_cu_data
*per_cu
= per_bfd
->get_cutu (i
);
6036 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
6037 struct dwarf2_per_cu_quick_data
);
6040 /* Return 1 so that gdb sees the "quick" functions. However,
6041 these functions will be no-ops because we will have expanded
6043 *index_kind
= dw_index_kind::GDB_INDEX
;
6047 /* Was a debug names index already read when we processed an objfile sharing
6049 if (per_bfd
->debug_names_table
!= nullptr)
6051 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6052 per_objfile
->objfile
->partial_symtabs
= per_bfd
->partial_symtabs
;
6053 per_objfile
->resize_symtabs ();
6057 /* Was a GDB index already read when we processed an objfile sharing
6059 if (per_bfd
->index_table
!= nullptr)
6061 *index_kind
= dw_index_kind::GDB_INDEX
;
6062 per_objfile
->objfile
->partial_symtabs
= per_bfd
->partial_symtabs
;
6063 per_objfile
->resize_symtabs ();
6067 /* There might already be partial symtabs built for this BFD. This happens
6068 when loading the same binary twice with the index-cache enabled. If so,
6069 don't try to read an index. The objfile / per_objfile initialization will
6070 be completed in dwarf2_build_psymtabs, in the standard partial symtabs
6072 if (per_bfd
->partial_symtabs
!= nullptr)
6075 if (dwarf2_read_debug_names (per_objfile
))
6077 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6078 per_objfile
->resize_symtabs ();
6082 if (dwarf2_read_gdb_index (per_objfile
,
6083 get_gdb_index_contents_from_section
<struct dwarf2_per_bfd
>,
6084 get_gdb_index_contents_from_section
<dwz_file
>))
6086 *index_kind
= dw_index_kind::GDB_INDEX
;
6087 per_objfile
->resize_symtabs ();
6091 /* ... otherwise, try to find the index in the index cache. */
6092 if (dwarf2_read_gdb_index (per_objfile
,
6093 get_gdb_index_contents_from_cache
,
6094 get_gdb_index_contents_from_cache_dwz
))
6096 global_index_cache
.hit ();
6097 *index_kind
= dw_index_kind::GDB_INDEX
;
6098 per_objfile
->resize_symtabs ();
6102 global_index_cache
.miss ();
6108 /* Build a partial symbol table. */
6111 dwarf2_build_psymtabs (struct objfile
*objfile
)
6113 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
6114 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6116 if (per_bfd
->partial_symtabs
!= nullptr)
6118 /* Partial symbols were already read, so now we can simply
6120 objfile
->partial_symtabs
= per_bfd
->partial_symtabs
;
6121 per_objfile
->resize_symtabs ();
6127 /* This isn't really ideal: all the data we allocate on the
6128 objfile's obstack is still uselessly kept around. However,
6129 freeing it seems unsafe. */
6130 psymtab_discarder
psymtabs (objfile
);
6131 dwarf2_build_psymtabs_hard (per_objfile
);
6134 per_objfile
->resize_symtabs ();
6136 /* (maybe) store an index in the cache. */
6137 global_index_cache
.store (per_objfile
);
6139 catch (const gdb_exception_error
&except
)
6141 exception_print (gdb_stderr
, except
);
6144 /* Finish by setting the local reference to partial symtabs, so that
6145 we don't try to read them again if reading another objfile with the same
6146 BFD. If we can't in fact share, this won't make a difference anyway as
6147 the dwarf2_per_bfd object won't be shared. */
6148 per_bfd
->partial_symtabs
= objfile
->partial_symtabs
;
6151 /* Find the base address of the compilation unit for range lists and
6152 location lists. It will normally be specified by DW_AT_low_pc.
6153 In DWARF-3 draft 4, the base address could be overridden by
6154 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6155 compilation units with discontinuous ranges. */
6158 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
6160 struct attribute
*attr
;
6162 cu
->base_address
.reset ();
6164 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
6165 if (attr
!= nullptr)
6166 cu
->base_address
= attr
->as_address ();
6169 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6170 if (attr
!= nullptr)
6171 cu
->base_address
= attr
->as_address ();
6175 /* Helper function that returns the proper abbrev section for
6178 static struct dwarf2_section_info
*
6179 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
6181 struct dwarf2_section_info
*abbrev
;
6182 dwarf2_per_bfd
*per_bfd
= this_cu
->per_bfd
;
6184 if (this_cu
->is_dwz
)
6185 abbrev
= &dwarf2_get_dwz_file (per_bfd
)->abbrev
;
6187 abbrev
= &per_bfd
->abbrev
;
6192 /* Fetch the abbreviation table offset from a comp or type unit header. */
6195 read_abbrev_offset (dwarf2_per_objfile
*per_objfile
,
6196 struct dwarf2_section_info
*section
,
6197 sect_offset sect_off
)
6199 bfd
*abfd
= section
->get_bfd_owner ();
6200 const gdb_byte
*info_ptr
;
6201 unsigned int initial_length_size
, offset_size
;
6204 section
->read (per_objfile
->objfile
);
6205 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
6206 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6207 offset_size
= initial_length_size
== 4 ? 4 : 8;
6208 info_ptr
+= initial_length_size
;
6210 version
= read_2_bytes (abfd
, info_ptr
);
6214 /* Skip unit type and address size. */
6218 return (sect_offset
) read_offset (abfd
, info_ptr
, offset_size
);
6221 /* A partial symtab that is used only for include files. */
6222 struct dwarf2_include_psymtab
: public partial_symtab
6224 dwarf2_include_psymtab (const char *filename
, struct objfile
*objfile
)
6225 : partial_symtab (filename
, objfile
)
6229 void read_symtab (struct objfile
*objfile
) override
6231 /* It's an include file, no symbols to read for it.
6232 Everything is in the includer symtab. */
6234 /* The expansion of a dwarf2_include_psymtab is just a trigger for
6235 expansion of the includer psymtab. We use the dependencies[0] field to
6236 model the includer. But if we go the regular route of calling
6237 expand_psymtab here, and having expand_psymtab call expand_dependencies
6238 to expand the includer, we'll only use expand_psymtab on the includer
6239 (making it a non-toplevel psymtab), while if we expand the includer via
6240 another path, we'll use read_symtab (making it a toplevel psymtab).
6241 So, don't pretend a dwarf2_include_psymtab is an actual toplevel
6242 psymtab, and trigger read_symtab on the includer here directly. */
6243 includer ()->read_symtab (objfile
);
6246 void expand_psymtab (struct objfile
*objfile
) override
6248 /* This is not called by read_symtab, and should not be called by any
6249 expand_dependencies. */
6253 bool readin_p (struct objfile
*objfile
) const override
6255 return includer ()->readin_p (objfile
);
6258 compunit_symtab
*get_compunit_symtab (struct objfile
*objfile
) const override
6264 partial_symtab
*includer () const
6266 /* An include psymtab has exactly one dependency: the psymtab that
6268 gdb_assert (this->number_of_dependencies
== 1);
6269 return this->dependencies
[0];
6273 /* Allocate a new partial symtab for file named NAME and mark this new
6274 partial symtab as being an include of PST. */
6277 dwarf2_create_include_psymtab (const char *name
, dwarf2_psymtab
*pst
,
6278 struct objfile
*objfile
)
6280 dwarf2_include_psymtab
*subpst
= new dwarf2_include_psymtab (name
, objfile
);
6282 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
6283 subpst
->dirname
= pst
->dirname
;
6285 subpst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (1);
6286 subpst
->dependencies
[0] = pst
;
6287 subpst
->number_of_dependencies
= 1;
6290 /* Read the Line Number Program data and extract the list of files
6291 included by the source file represented by PST. Build an include
6292 partial symtab for each of these included files. */
6295 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
6296 struct die_info
*die
,
6297 dwarf2_psymtab
*pst
)
6300 struct attribute
*attr
;
6302 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6303 if (attr
!= nullptr && attr
->form_is_unsigned ())
6304 lh
= dwarf_decode_line_header ((sect_offset
) attr
->as_unsigned (), cu
);
6306 return; /* No linetable, so no includes. */
6308 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6309 that we pass in the raw text_low here; that is ok because we're
6310 only decoding the line table to make include partial symtabs, and
6311 so the addresses aren't really used. */
6312 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
6313 pst
->raw_text_low (), 1);
6317 hash_signatured_type (const void *item
)
6319 const struct signatured_type
*sig_type
6320 = (const struct signatured_type
*) item
;
6322 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6323 return sig_type
->signature
;
6327 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6329 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6330 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6332 return lhs
->signature
== rhs
->signature
;
6335 /* Allocate a hash table for signatured types. */
6338 allocate_signatured_type_table ()
6340 return htab_up (htab_create_alloc (41,
6341 hash_signatured_type
,
6343 NULL
, xcalloc
, xfree
));
6346 /* A helper function to add a signatured type CU to a table. */
6349 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6351 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6352 std::vector
<signatured_type
*> *all_type_units
6353 = (std::vector
<signatured_type
*> *) datum
;
6355 all_type_units
->push_back (sigt
);
6360 /* A helper for create_debug_types_hash_table. Read types from SECTION
6361 and fill them into TYPES_HTAB. It will process only type units,
6362 therefore DW_UT_type. */
6365 create_debug_type_hash_table (dwarf2_per_objfile
*per_objfile
,
6366 struct dwo_file
*dwo_file
,
6367 dwarf2_section_info
*section
, htab_up
&types_htab
,
6368 rcuh_kind section_kind
)
6370 struct objfile
*objfile
= per_objfile
->objfile
;
6371 struct dwarf2_section_info
*abbrev_section
;
6373 const gdb_byte
*info_ptr
, *end_ptr
;
6375 abbrev_section
= (dwo_file
!= NULL
6376 ? &dwo_file
->sections
.abbrev
6377 : &per_objfile
->per_bfd
->abbrev
);
6379 if (dwarf_read_debug
)
6380 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
6381 section
->get_name (),
6382 abbrev_section
->get_file_name ());
6384 section
->read (objfile
);
6385 info_ptr
= section
->buffer
;
6387 if (info_ptr
== NULL
)
6390 /* We can't set abfd until now because the section may be empty or
6391 not present, in which case the bfd is unknown. */
6392 abfd
= section
->get_bfd_owner ();
6394 /* We don't use cutu_reader here because we don't need to read
6395 any dies: the signature is in the header. */
6397 end_ptr
= info_ptr
+ section
->size
;
6398 while (info_ptr
< end_ptr
)
6400 struct signatured_type
*sig_type
;
6401 struct dwo_unit
*dwo_tu
;
6403 const gdb_byte
*ptr
= info_ptr
;
6404 struct comp_unit_head header
;
6405 unsigned int length
;
6407 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
6409 /* Initialize it due to a false compiler warning. */
6410 header
.signature
= -1;
6411 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
6413 /* We need to read the type's signature in order to build the hash
6414 table, but we don't need anything else just yet. */
6416 ptr
= read_and_check_comp_unit_head (per_objfile
, &header
, section
,
6417 abbrev_section
, ptr
, section_kind
);
6419 length
= header
.get_length ();
6421 /* Skip dummy type units. */
6422 if (ptr
>= info_ptr
+ length
6423 || peek_abbrev_code (abfd
, ptr
) == 0
6424 || (header
.unit_type
!= DW_UT_type
6425 && header
.unit_type
!= DW_UT_split_type
))
6431 if (types_htab
== NULL
)
6434 types_htab
= allocate_dwo_unit_table ();
6436 types_htab
= allocate_signatured_type_table ();
6442 dwo_tu
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, dwo_unit
);
6443 dwo_tu
->dwo_file
= dwo_file
;
6444 dwo_tu
->signature
= header
.signature
;
6445 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6446 dwo_tu
->section
= section
;
6447 dwo_tu
->sect_off
= sect_off
;
6448 dwo_tu
->length
= length
;
6452 /* N.B.: type_offset is not usable if this type uses a DWO file.
6453 The real type_offset is in the DWO file. */
6455 sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6456 sig_type
->signature
= header
.signature
;
6457 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6458 sig_type
->per_cu
.is_debug_types
= 1;
6459 sig_type
->per_cu
.section
= section
;
6460 sig_type
->per_cu
.sect_off
= sect_off
;
6461 sig_type
->per_cu
.length
= length
;
6464 slot
= htab_find_slot (types_htab
.get (),
6465 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
6467 gdb_assert (slot
!= NULL
);
6470 sect_offset dup_sect_off
;
6474 const struct dwo_unit
*dup_tu
6475 = (const struct dwo_unit
*) *slot
;
6477 dup_sect_off
= dup_tu
->sect_off
;
6481 const struct signatured_type
*dup_tu
6482 = (const struct signatured_type
*) *slot
;
6484 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
6487 complaint (_("debug type entry at offset %s is duplicate to"
6488 " the entry at offset %s, signature %s"),
6489 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
6490 hex_string (header
.signature
));
6492 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
6494 if (dwarf_read_debug
> 1)
6495 fprintf_unfiltered (gdb_stdlog
, " offset %s, signature %s\n",
6496 sect_offset_str (sect_off
),
6497 hex_string (header
.signature
));
6503 /* Create the hash table of all entries in the .debug_types
6504 (or .debug_types.dwo) section(s).
6505 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6506 otherwise it is NULL.
6508 The result is a pointer to the hash table or NULL if there are no types.
6510 Note: This function processes DWO files only, not DWP files. */
6513 create_debug_types_hash_table (dwarf2_per_objfile
*per_objfile
,
6514 struct dwo_file
*dwo_file
,
6515 gdb::array_view
<dwarf2_section_info
> type_sections
,
6516 htab_up
&types_htab
)
6518 for (dwarf2_section_info
§ion
: type_sections
)
6519 create_debug_type_hash_table (per_objfile
, dwo_file
, §ion
, types_htab
,
6523 /* Create the hash table of all entries in the .debug_types section,
6524 and initialize all_type_units.
6525 The result is zero if there is an error (e.g. missing .debug_types section),
6526 otherwise non-zero. */
6529 create_all_type_units (dwarf2_per_objfile
*per_objfile
)
6533 create_debug_type_hash_table (per_objfile
, NULL
, &per_objfile
->per_bfd
->info
,
6534 types_htab
, rcuh_kind::COMPILE
);
6535 create_debug_types_hash_table (per_objfile
, NULL
, per_objfile
->per_bfd
->types
,
6537 if (types_htab
== NULL
)
6539 per_objfile
->per_bfd
->signatured_types
= NULL
;
6543 per_objfile
->per_bfd
->signatured_types
= std::move (types_htab
);
6545 gdb_assert (per_objfile
->per_bfd
->all_type_units
.empty ());
6546 per_objfile
->per_bfd
->all_type_units
.reserve
6547 (htab_elements (per_objfile
->per_bfd
->signatured_types
.get ()));
6549 htab_traverse_noresize (per_objfile
->per_bfd
->signatured_types
.get (),
6550 add_signatured_type_cu_to_table
,
6551 &per_objfile
->per_bfd
->all_type_units
);
6556 /* Add an entry for signature SIG to dwarf2_per_objfile->per_bfd->signatured_types.
6557 If SLOT is non-NULL, it is the entry to use in the hash table.
6558 Otherwise we find one. */
6560 static struct signatured_type
*
6561 add_type_unit (dwarf2_per_objfile
*per_objfile
, ULONGEST sig
, void **slot
)
6563 if (per_objfile
->per_bfd
->all_type_units
.size ()
6564 == per_objfile
->per_bfd
->all_type_units
.capacity ())
6565 ++per_objfile
->per_bfd
->tu_stats
.nr_all_type_units_reallocs
;
6567 signatured_type
*sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
6569 per_objfile
->resize_symtabs ();
6571 per_objfile
->per_bfd
->all_type_units
.push_back (sig_type
);
6572 sig_type
->signature
= sig
;
6573 sig_type
->per_cu
.is_debug_types
= 1;
6574 if (per_objfile
->per_bfd
->using_index
)
6576 sig_type
->per_cu
.v
.quick
=
6577 OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
,
6578 struct dwarf2_per_cu_quick_data
);
6583 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6586 gdb_assert (*slot
== NULL
);
6588 /* The rest of sig_type must be filled in by the caller. */
6592 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6593 Fill in SIG_ENTRY with DWO_ENTRY. */
6596 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
*per_objfile
,
6597 struct signatured_type
*sig_entry
,
6598 struct dwo_unit
*dwo_entry
)
6600 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
6602 /* Make sure we're not clobbering something we don't expect to. */
6603 gdb_assert (! sig_entry
->per_cu
.queued
);
6604 gdb_assert (per_objfile
->get_cu (&sig_entry
->per_cu
) == NULL
);
6605 if (per_bfd
->using_index
)
6607 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
6608 gdb_assert (!per_objfile
->symtab_set_p (&sig_entry
->per_cu
));
6611 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
6612 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
6613 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
6614 gdb_assert (sig_entry
->type_unit_group
== NULL
);
6615 gdb_assert (sig_entry
->dwo_unit
== NULL
);
6617 sig_entry
->per_cu
.section
= dwo_entry
->section
;
6618 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
6619 sig_entry
->per_cu
.length
= dwo_entry
->length
;
6620 sig_entry
->per_cu
.reading_dwo_directly
= 1;
6621 sig_entry
->per_cu
.per_bfd
= per_bfd
;
6622 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
6623 sig_entry
->dwo_unit
= dwo_entry
;
6626 /* Subroutine of lookup_signatured_type.
6627 If we haven't read the TU yet, create the signatured_type data structure
6628 for a TU to be read in directly from a DWO file, bypassing the stub.
6629 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6630 using .gdb_index, then when reading a CU we want to stay in the DWO file
6631 containing that CU. Otherwise we could end up reading several other DWO
6632 files (due to comdat folding) to process the transitive closure of all the
6633 mentioned TUs, and that can be slow. The current DWO file will have every
6634 type signature that it needs.
6635 We only do this for .gdb_index because in the psymtab case we already have
6636 to read all the DWOs to build the type unit groups. */
6638 static struct signatured_type
*
6639 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6641 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6642 struct dwo_file
*dwo_file
;
6643 struct dwo_unit find_dwo_entry
, *dwo_entry
;
6644 struct signatured_type find_sig_entry
, *sig_entry
;
6647 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6649 /* If TU skeletons have been removed then we may not have read in any
6651 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6652 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6654 /* We only ever need to read in one copy of a signatured type.
6655 Use the global signatured_types array to do our own comdat-folding
6656 of types. If this is the first time we're reading this TU, and
6657 the TU has an entry in .gdb_index, replace the recorded data from
6658 .gdb_index with this TU. */
6660 find_sig_entry
.signature
= sig
;
6661 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6662 &find_sig_entry
, INSERT
);
6663 sig_entry
= (struct signatured_type
*) *slot
;
6665 /* We can get here with the TU already read, *or* in the process of being
6666 read. Don't reassign the global entry to point to this DWO if that's
6667 the case. Also note that if the TU is already being read, it may not
6668 have come from a DWO, the program may be a mix of Fission-compiled
6669 code and non-Fission-compiled code. */
6671 /* Have we already tried to read this TU?
6672 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6673 needn't exist in the global table yet). */
6674 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
6677 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6678 dwo_unit of the TU itself. */
6679 dwo_file
= cu
->dwo_unit
->dwo_file
;
6681 /* Ok, this is the first time we're reading this TU. */
6682 if (dwo_file
->tus
== NULL
)
6684 find_dwo_entry
.signature
= sig
;
6685 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
6687 if (dwo_entry
== NULL
)
6690 /* If the global table doesn't have an entry for this TU, add one. */
6691 if (sig_entry
== NULL
)
6692 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6694 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6695 sig_entry
->per_cu
.tu_read
= 1;
6699 /* Subroutine of lookup_signatured_type.
6700 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6701 then try the DWP file. If the TU stub (skeleton) has been removed then
6702 it won't be in .gdb_index. */
6704 static struct signatured_type
*
6705 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6707 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6708 struct dwp_file
*dwp_file
= get_dwp_file (per_objfile
);
6709 struct dwo_unit
*dwo_entry
;
6710 struct signatured_type find_sig_entry
, *sig_entry
;
6713 gdb_assert (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
);
6714 gdb_assert (dwp_file
!= NULL
);
6716 /* If TU skeletons have been removed then we may not have read in any
6718 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6719 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
6721 find_sig_entry
.signature
= sig
;
6722 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
6723 &find_sig_entry
, INSERT
);
6724 sig_entry
= (struct signatured_type
*) *slot
;
6726 /* Have we already tried to read this TU?
6727 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6728 needn't exist in the global table yet). */
6729 if (sig_entry
!= NULL
)
6732 if (dwp_file
->tus
== NULL
)
6734 dwo_entry
= lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, NULL
, sig
,
6735 1 /* is_debug_types */);
6736 if (dwo_entry
== NULL
)
6739 sig_entry
= add_type_unit (per_objfile
, sig
, slot
);
6740 fill_in_sig_entry_from_dwo_entry (per_objfile
, sig_entry
, dwo_entry
);
6745 /* Lookup a signature based type for DW_FORM_ref_sig8.
6746 Returns NULL if signature SIG is not present in the table.
6747 It is up to the caller to complain about this. */
6749 static struct signatured_type
*
6750 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6752 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6754 if (cu
->dwo_unit
&& per_objfile
->per_bfd
->using_index
)
6756 /* We're in a DWO/DWP file, and we're using .gdb_index.
6757 These cases require special processing. */
6758 if (get_dwp_file (per_objfile
) == NULL
)
6759 return lookup_dwo_signatured_type (cu
, sig
);
6761 return lookup_dwp_signatured_type (cu
, sig
);
6765 struct signatured_type find_entry
, *entry
;
6767 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
6769 find_entry
.signature
= sig
;
6770 entry
= ((struct signatured_type
*)
6771 htab_find (per_objfile
->per_bfd
->signatured_types
.get (),
6777 /* Low level DIE reading support. */
6779 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
6782 init_cu_die_reader (struct die_reader_specs
*reader
,
6783 struct dwarf2_cu
*cu
,
6784 struct dwarf2_section_info
*section
,
6785 struct dwo_file
*dwo_file
,
6786 struct abbrev_table
*abbrev_table
)
6788 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
6789 reader
->abfd
= section
->get_bfd_owner ();
6791 reader
->dwo_file
= dwo_file
;
6792 reader
->die_section
= section
;
6793 reader
->buffer
= section
->buffer
;
6794 reader
->buffer_end
= section
->buffer
+ section
->size
;
6795 reader
->abbrev_table
= abbrev_table
;
6798 /* Subroutine of cutu_reader to simplify it.
6799 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
6800 There's just a lot of work to do, and cutu_reader is big enough
6803 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
6804 from it to the DIE in the DWO. If NULL we are skipping the stub.
6805 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
6806 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
6807 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
6808 STUB_COMP_DIR may be non-NULL.
6809 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE
6810 are filled in with the info of the DIE from the DWO file.
6811 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
6812 from the dwo. Since *RESULT_READER references this abbrev table, it must be
6813 kept around for at least as long as *RESULT_READER.
6815 The result is non-zero if a valid (non-dummy) DIE was found. */
6818 read_cutu_die_from_dwo (dwarf2_cu
*cu
,
6819 struct dwo_unit
*dwo_unit
,
6820 struct die_info
*stub_comp_unit_die
,
6821 const char *stub_comp_dir
,
6822 struct die_reader_specs
*result_reader
,
6823 const gdb_byte
**result_info_ptr
,
6824 struct die_info
**result_comp_unit_die
,
6825 abbrev_table_up
*result_dwo_abbrev_table
)
6827 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
6828 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
6829 struct objfile
*objfile
= per_objfile
->objfile
;
6831 const gdb_byte
*begin_info_ptr
, *info_ptr
;
6832 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
6833 int i
,num_extra_attrs
;
6834 struct dwarf2_section_info
*dwo_abbrev_section
;
6835 struct die_info
*comp_unit_die
;
6837 /* At most one of these may be provided. */
6838 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
6840 /* These attributes aren't processed until later:
6841 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
6842 DW_AT_comp_dir is used now, to find the DWO file, but it is also
6843 referenced later. However, these attributes are found in the stub
6844 which we won't have later. In order to not impose this complication
6845 on the rest of the code, we read them here and copy them to the
6854 if (stub_comp_unit_die
!= NULL
)
6856 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
6858 if (!per_cu
->is_debug_types
)
6859 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
6860 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
6861 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
6862 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
6863 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
6865 cu
->addr_base
= stub_comp_unit_die
->addr_base ();
6867 /* There should be a DW_AT_rnglists_base (DW_AT_GNU_ranges_base) attribute
6868 here (if needed). We need the value before we can process
6870 cu
->ranges_base
= stub_comp_unit_die
->ranges_base ();
6872 else if (stub_comp_dir
!= NULL
)
6874 /* Reconstruct the comp_dir attribute to simplify the code below. */
6875 comp_dir
= OBSTACK_ZALLOC (&cu
->comp_unit_obstack
, struct attribute
);
6876 comp_dir
->name
= DW_AT_comp_dir
;
6877 comp_dir
->form
= DW_FORM_string
;
6878 comp_dir
->set_string_noncanonical (stub_comp_dir
);
6881 /* Set up for reading the DWO CU/TU. */
6882 cu
->dwo_unit
= dwo_unit
;
6883 dwarf2_section_info
*section
= dwo_unit
->section
;
6884 section
->read (objfile
);
6885 abfd
= section
->get_bfd_owner ();
6886 begin_info_ptr
= info_ptr
= (section
->buffer
6887 + to_underlying (dwo_unit
->sect_off
));
6888 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
6890 if (per_cu
->is_debug_types
)
6892 signatured_type
*sig_type
= (struct signatured_type
*) per_cu
;
6894 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6895 section
, dwo_abbrev_section
,
6896 info_ptr
, rcuh_kind::TYPE
);
6897 /* This is not an assert because it can be caused by bad debug info. */
6898 if (sig_type
->signature
!= cu
->header
.signature
)
6900 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
6901 " TU at offset %s [in module %s]"),
6902 hex_string (sig_type
->signature
),
6903 hex_string (cu
->header
.signature
),
6904 sect_offset_str (dwo_unit
->sect_off
),
6905 bfd_get_filename (abfd
));
6907 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6908 /* For DWOs coming from DWP files, we don't know the CU length
6909 nor the type's offset in the TU until now. */
6910 dwo_unit
->length
= cu
->header
.get_length ();
6911 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
6913 /* Establish the type offset that can be used to lookup the type.
6914 For DWO files, we don't know it until now. */
6915 sig_type
->type_offset_in_section
6916 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
6920 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
6921 section
, dwo_abbrev_section
,
6922 info_ptr
, rcuh_kind::COMPILE
);
6923 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
6924 /* For DWOs coming from DWP files, we don't know the CU length
6926 dwo_unit
->length
= cu
->header
.get_length ();
6929 *result_dwo_abbrev_table
6930 = abbrev_table::read (objfile
, dwo_abbrev_section
,
6931 cu
->header
.abbrev_sect_off
);
6932 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
6933 result_dwo_abbrev_table
->get ());
6935 /* Read in the die, but leave space to copy over the attributes
6936 from the stub. This has the benefit of simplifying the rest of
6937 the code - all the work to maintain the illusion of a single
6938 DW_TAG_{compile,type}_unit DIE is done here. */
6939 num_extra_attrs
= ((stmt_list
!= NULL
)
6943 + (comp_dir
!= NULL
));
6944 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
6947 /* Copy over the attributes from the stub to the DIE we just read in. */
6948 comp_unit_die
= *result_comp_unit_die
;
6949 i
= comp_unit_die
->num_attrs
;
6950 if (stmt_list
!= NULL
)
6951 comp_unit_die
->attrs
[i
++] = *stmt_list
;
6953 comp_unit_die
->attrs
[i
++] = *low_pc
;
6954 if (high_pc
!= NULL
)
6955 comp_unit_die
->attrs
[i
++] = *high_pc
;
6957 comp_unit_die
->attrs
[i
++] = *ranges
;
6958 if (comp_dir
!= NULL
)
6959 comp_unit_die
->attrs
[i
++] = *comp_dir
;
6960 comp_unit_die
->num_attrs
+= num_extra_attrs
;
6962 if (dwarf_die_debug
)
6964 fprintf_unfiltered (gdb_stdlog
,
6965 "Read die from %s@0x%x of %s:\n",
6966 section
->get_name (),
6967 (unsigned) (begin_info_ptr
- section
->buffer
),
6968 bfd_get_filename (abfd
));
6969 dump_die (comp_unit_die
, dwarf_die_debug
);
6972 /* Skip dummy compilation units. */
6973 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
6974 || peek_abbrev_code (abfd
, info_ptr
) == 0)
6977 *result_info_ptr
= info_ptr
;
6981 /* Return the signature of the compile unit, if found. In DWARF 4 and before,
6982 the signature is in the DW_AT_GNU_dwo_id attribute. In DWARF 5 and later, the
6983 signature is part of the header. */
6984 static gdb::optional
<ULONGEST
>
6985 lookup_dwo_id (struct dwarf2_cu
*cu
, struct die_info
* comp_unit_die
)
6987 if (cu
->header
.version
>= 5)
6988 return cu
->header
.signature
;
6989 struct attribute
*attr
;
6990 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
6991 if (attr
== nullptr || !attr
->form_is_unsigned ())
6992 return gdb::optional
<ULONGEST
> ();
6993 return attr
->as_unsigned ();
6996 /* Subroutine of cutu_reader to simplify it.
6997 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
6998 Returns NULL if the specified DWO unit cannot be found. */
7000 static struct dwo_unit
*
7001 lookup_dwo_unit (dwarf2_cu
*cu
, die_info
*comp_unit_die
, const char *dwo_name
)
7003 dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7004 struct dwo_unit
*dwo_unit
;
7005 const char *comp_dir
;
7007 gdb_assert (cu
!= NULL
);
7009 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7010 dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7011 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7013 if (per_cu
->is_debug_types
)
7014 dwo_unit
= lookup_dwo_type_unit (cu
, dwo_name
, comp_dir
);
7017 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
7019 if (!signature
.has_value ())
7020 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7022 dwo_name
, bfd_get_filename (per_cu
->per_bfd
->obfd
));
7024 dwo_unit
= lookup_dwo_comp_unit (cu
, dwo_name
, comp_dir
, *signature
);
7030 /* Subroutine of cutu_reader to simplify it.
7031 See it for a description of the parameters.
7032 Read a TU directly from a DWO file, bypassing the stub. */
7035 cutu_reader::init_tu_and_read_dwo_dies (dwarf2_per_cu_data
*this_cu
,
7036 dwarf2_per_objfile
*per_objfile
,
7037 dwarf2_cu
*existing_cu
)
7039 struct signatured_type
*sig_type
;
7041 /* Verify we can do the following downcast, and that we have the
7043 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
7044 sig_type
= (struct signatured_type
*) this_cu
;
7045 gdb_assert (sig_type
->dwo_unit
!= NULL
);
7049 if (existing_cu
!= nullptr)
7052 gdb_assert (cu
->dwo_unit
== sig_type
->dwo_unit
);
7053 /* There's no need to do the rereading_dwo_cu handling that
7054 cutu_reader does since we don't read the stub. */
7058 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
7059 in per_objfile yet. */
7060 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7061 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7062 cu
= m_new_cu
.get ();
7065 /* A future optimization, if needed, would be to use an existing
7066 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7067 could share abbrev tables. */
7069 if (read_cutu_die_from_dwo (cu
, sig_type
->dwo_unit
,
7070 NULL
/* stub_comp_unit_die */,
7071 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
7074 &m_dwo_abbrev_table
) == 0)
7081 /* Initialize a CU (or TU) and read its DIEs.
7082 If the CU defers to a DWO file, read the DWO file as well.
7084 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7085 Otherwise the table specified in the comp unit header is read in and used.
7086 This is an optimization for when we already have the abbrev table.
7088 If EXISTING_CU is non-NULL, then use it. Otherwise, a new CU is
7091 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
7092 dwarf2_per_objfile
*per_objfile
,
7093 struct abbrev_table
*abbrev_table
,
7094 dwarf2_cu
*existing_cu
,
7096 : die_reader_specs
{},
7099 struct objfile
*objfile
= per_objfile
->objfile
;
7100 struct dwarf2_section_info
*section
= this_cu
->section
;
7101 bfd
*abfd
= section
->get_bfd_owner ();
7102 const gdb_byte
*begin_info_ptr
;
7103 struct signatured_type
*sig_type
= NULL
;
7104 struct dwarf2_section_info
*abbrev_section
;
7105 /* Non-zero if CU currently points to a DWO file and we need to
7106 reread it. When this happens we need to reread the skeleton die
7107 before we can reread the DWO file (this only applies to CUs, not TUs). */
7108 int rereading_dwo_cu
= 0;
7110 if (dwarf_die_debug
)
7111 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7112 this_cu
->is_debug_types
? "type" : "comp",
7113 sect_offset_str (this_cu
->sect_off
));
7115 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7116 file (instead of going through the stub), short-circuit all of this. */
7117 if (this_cu
->reading_dwo_directly
)
7119 /* Narrow down the scope of possibilities to have to understand. */
7120 gdb_assert (this_cu
->is_debug_types
);
7121 gdb_assert (abbrev_table
== NULL
);
7122 init_tu_and_read_dwo_dies (this_cu
, per_objfile
, existing_cu
);
7126 /* This is cheap if the section is already read in. */
7127 section
->read (objfile
);
7129 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7131 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
7135 if (existing_cu
!= nullptr)
7138 /* If this CU is from a DWO file we need to start over, we need to
7139 refetch the attributes from the skeleton CU.
7140 This could be optimized by retrieving those attributes from when we
7141 were here the first time: the previous comp_unit_die was stored in
7142 comp_unit_obstack. But there's no data yet that we need this
7144 if (cu
->dwo_unit
!= NULL
)
7145 rereading_dwo_cu
= 1;
7149 /* If an existing_cu is provided, a dwarf2_cu must not exist for this_cu
7150 in per_objfile yet. */
7151 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7152 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7153 cu
= m_new_cu
.get ();
7156 /* Get the header. */
7157 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
7159 /* We already have the header, there's no need to read it in again. */
7160 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
7164 if (this_cu
->is_debug_types
)
7166 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7167 section
, abbrev_section
,
7168 info_ptr
, rcuh_kind::TYPE
);
7170 /* Since per_cu is the first member of struct signatured_type,
7171 we can go from a pointer to one to a pointer to the other. */
7172 sig_type
= (struct signatured_type
*) this_cu
;
7173 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
7174 gdb_assert (sig_type
->type_offset_in_tu
7175 == cu
->header
.type_cu_offset_in_tu
);
7176 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7178 /* LENGTH has not been set yet for type units if we're
7179 using .gdb_index. */
7180 this_cu
->length
= cu
->header
.get_length ();
7182 /* Establish the type offset that can be used to lookup the type. */
7183 sig_type
->type_offset_in_section
=
7184 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
7186 this_cu
->dwarf_version
= cu
->header
.version
;
7190 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &cu
->header
,
7191 section
, abbrev_section
,
7193 rcuh_kind::COMPILE
);
7195 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7196 if (this_cu
->length
== 0)
7197 this_cu
->length
= cu
->header
.get_length ();
7199 gdb_assert (this_cu
->length
== cu
->header
.get_length ());
7200 this_cu
->dwarf_version
= cu
->header
.version
;
7204 /* Skip dummy compilation units. */
7205 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7206 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7212 /* If we don't have them yet, read the abbrevs for this compilation unit.
7213 And if we need to read them now, make sure they're freed when we're
7215 if (abbrev_table
!= NULL
)
7216 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
7219 m_abbrev_table_holder
7220 = abbrev_table::read (objfile
, abbrev_section
,
7221 cu
->header
.abbrev_sect_off
);
7222 abbrev_table
= m_abbrev_table_holder
.get ();
7225 /* Read the top level CU/TU die. */
7226 init_cu_die_reader (this, cu
, section
, NULL
, abbrev_table
);
7227 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7229 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
7235 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7236 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7237 table from the DWO file and pass the ownership over to us. It will be
7238 referenced from READER, so we must make sure to free it after we're done
7241 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7242 DWO CU, that this test will fail (the attribute will not be present). */
7243 const char *dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7244 if (dwo_name
!= nullptr)
7246 struct dwo_unit
*dwo_unit
;
7247 struct die_info
*dwo_comp_unit_die
;
7249 if (comp_unit_die
->has_children
)
7251 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7252 " has children (offset %s) [in module %s]"),
7253 sect_offset_str (this_cu
->sect_off
),
7254 bfd_get_filename (abfd
));
7256 dwo_unit
= lookup_dwo_unit (cu
, comp_unit_die
, dwo_name
);
7257 if (dwo_unit
!= NULL
)
7259 if (read_cutu_die_from_dwo (cu
, dwo_unit
,
7260 comp_unit_die
, NULL
,
7263 &m_dwo_abbrev_table
) == 0)
7269 comp_unit_die
= dwo_comp_unit_die
;
7273 /* Yikes, we couldn't find the rest of the DIE, we only have
7274 the stub. A complaint has already been logged. There's
7275 not much more we can do except pass on the stub DIE to
7276 die_reader_func. We don't want to throw an error on bad
7283 cutu_reader::keep ()
7285 /* Done, clean up. */
7286 gdb_assert (!dummy_p
);
7287 if (m_new_cu
!= NULL
)
7289 /* Save this dwarf2_cu in the per_objfile. The per_objfile owns it
7291 dwarf2_per_objfile
*per_objfile
= m_new_cu
->per_objfile
;
7292 per_objfile
->set_cu (m_this_cu
, m_new_cu
.release ());
7296 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name (DW_AT_dwo_name)
7297 if present. DWO_FILE, if non-NULL, is the DWO file to read (the caller is
7298 assumed to have already done the lookup to find the DWO file).
7300 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7301 THIS_CU->is_debug_types, but nothing else.
7303 We fill in THIS_CU->length.
7305 THIS_CU->cu is always freed when done.
7306 This is done in order to not leave THIS_CU->cu in a state where we have
7307 to care whether it refers to the "main" CU or the DWO CU.
7309 When parent_cu is passed, it is used to provide a default value for
7310 str_offsets_base and addr_base from the parent. */
7312 cutu_reader::cutu_reader (dwarf2_per_cu_data
*this_cu
,
7313 dwarf2_per_objfile
*per_objfile
,
7314 struct dwarf2_cu
*parent_cu
,
7315 struct dwo_file
*dwo_file
)
7316 : die_reader_specs
{},
7319 struct objfile
*objfile
= per_objfile
->objfile
;
7320 struct dwarf2_section_info
*section
= this_cu
->section
;
7321 bfd
*abfd
= section
->get_bfd_owner ();
7322 struct dwarf2_section_info
*abbrev_section
;
7323 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7325 if (dwarf_die_debug
)
7326 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7327 this_cu
->is_debug_types
? "type" : "comp",
7328 sect_offset_str (this_cu
->sect_off
));
7330 gdb_assert (per_objfile
->get_cu (this_cu
) == nullptr);
7332 abbrev_section
= (dwo_file
!= NULL
7333 ? &dwo_file
->sections
.abbrev
7334 : get_abbrev_section_for_cu (this_cu
));
7336 /* This is cheap if the section is already read in. */
7337 section
->read (objfile
);
7339 m_new_cu
.reset (new dwarf2_cu (this_cu
, per_objfile
));
7341 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7342 info_ptr
= read_and_check_comp_unit_head (per_objfile
, &m_new_cu
->header
,
7343 section
, abbrev_section
, info_ptr
,
7344 (this_cu
->is_debug_types
7346 : rcuh_kind::COMPILE
));
7348 if (parent_cu
!= nullptr)
7350 m_new_cu
->str_offsets_base
= parent_cu
->str_offsets_base
;
7351 m_new_cu
->addr_base
= parent_cu
->addr_base
;
7353 this_cu
->length
= m_new_cu
->header
.get_length ();
7355 /* Skip dummy compilation units. */
7356 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7357 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7363 m_abbrev_table_holder
7364 = abbrev_table::read (objfile
, abbrev_section
,
7365 m_new_cu
->header
.abbrev_sect_off
);
7367 init_cu_die_reader (this, m_new_cu
.get (), section
, dwo_file
,
7368 m_abbrev_table_holder
.get ());
7369 info_ptr
= read_full_die (this, &comp_unit_die
, info_ptr
);
7373 /* Type Unit Groups.
7375 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7376 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7377 so that all types coming from the same compilation (.o file) are grouped
7378 together. A future step could be to put the types in the same symtab as
7379 the CU the types ultimately came from. */
7382 hash_type_unit_group (const void *item
)
7384 const struct type_unit_group
*tu_group
7385 = (const struct type_unit_group
*) item
;
7387 return hash_stmt_list_entry (&tu_group
->hash
);
7391 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
7393 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
7394 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
7396 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
7399 /* Allocate a hash table for type unit groups. */
7402 allocate_type_unit_groups_table ()
7404 return htab_up (htab_create_alloc (3,
7405 hash_type_unit_group
,
7407 NULL
, xcalloc
, xfree
));
7410 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7411 partial symtabs. We combine several TUs per psymtab to not let the size
7412 of any one psymtab grow too big. */
7413 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7414 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7416 /* Helper routine for get_type_unit_group.
7417 Create the type_unit_group object used to hold one or more TUs. */
7419 static struct type_unit_group
*
7420 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
7422 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7423 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
7424 struct dwarf2_per_cu_data
*per_cu
;
7425 struct type_unit_group
*tu_group
;
7427 tu_group
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, type_unit_group
);
7428 per_cu
= &tu_group
->per_cu
;
7429 per_cu
->per_bfd
= per_bfd
;
7431 if (per_bfd
->using_index
)
7433 per_cu
->v
.quick
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
7434 struct dwarf2_per_cu_quick_data
);
7438 unsigned int line_offset
= to_underlying (line_offset_struct
);
7439 dwarf2_psymtab
*pst
;
7442 /* Give the symtab a useful name for debug purposes. */
7443 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
7444 name
= string_printf ("<type_units_%d>",
7445 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
7447 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
7449 pst
= create_partial_symtab (per_cu
, per_objfile
, name
.c_str ());
7450 pst
->anonymous
= true;
7453 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
7454 tu_group
->hash
.line_sect_off
= line_offset_struct
;
7459 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7460 STMT_LIST is a DW_AT_stmt_list attribute. */
7462 static struct type_unit_group
*
7463 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
7465 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7466 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7467 struct type_unit_group
*tu_group
;
7469 unsigned int line_offset
;
7470 struct type_unit_group type_unit_group_for_lookup
;
7472 if (per_objfile
->per_bfd
->type_unit_groups
== NULL
)
7473 per_objfile
->per_bfd
->type_unit_groups
= allocate_type_unit_groups_table ();
7475 /* Do we need to create a new group, or can we use an existing one? */
7477 if (stmt_list
!= nullptr && stmt_list
->form_is_unsigned ())
7479 line_offset
= stmt_list
->as_unsigned ();
7480 ++tu_stats
->nr_symtab_sharers
;
7484 /* Ugh, no stmt_list. Rare, but we have to handle it.
7485 We can do various things here like create one group per TU or
7486 spread them over multiple groups to split up the expansion work.
7487 To avoid worst case scenarios (too many groups or too large groups)
7488 we, umm, group them in bunches. */
7489 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7490 | (tu_stats
->nr_stmt_less_type_units
7491 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
7492 ++tu_stats
->nr_stmt_less_type_units
;
7495 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
7496 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
7497 slot
= htab_find_slot (per_objfile
->per_bfd
->type_unit_groups
.get (),
7498 &type_unit_group_for_lookup
, INSERT
);
7501 tu_group
= (struct type_unit_group
*) *slot
;
7502 gdb_assert (tu_group
!= NULL
);
7506 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
7507 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
7509 ++tu_stats
->nr_symtabs
;
7515 /* Partial symbol tables. */
7517 /* Create a psymtab named NAME and assign it to PER_CU.
7519 The caller must fill in the following details:
7520 dirname, textlow, texthigh. */
7522 static dwarf2_psymtab
*
7523 create_partial_symtab (dwarf2_per_cu_data
*per_cu
,
7524 dwarf2_per_objfile
*per_objfile
,
7527 struct objfile
*objfile
= per_objfile
->objfile
;
7528 dwarf2_psymtab
*pst
;
7530 pst
= new dwarf2_psymtab (name
, objfile
, per_cu
);
7532 pst
->psymtabs_addrmap_supported
= true;
7534 /* This is the glue that links PST into GDB's symbol API. */
7535 per_cu
->v
.psymtab
= pst
;
7540 /* DIE reader function for process_psymtab_comp_unit. */
7543 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
7544 const gdb_byte
*info_ptr
,
7545 struct die_info
*comp_unit_die
,
7546 enum language pretend_language
)
7548 struct dwarf2_cu
*cu
= reader
->cu
;
7549 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
7550 struct objfile
*objfile
= per_objfile
->objfile
;
7551 struct gdbarch
*gdbarch
= objfile
->arch ();
7552 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7554 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
7555 dwarf2_psymtab
*pst
;
7556 enum pc_bounds_kind cu_bounds_kind
;
7557 const char *filename
;
7559 gdb_assert (! per_cu
->is_debug_types
);
7561 prepare_one_comp_unit (cu
, comp_unit_die
, pretend_language
);
7563 /* Allocate a new partial symbol table structure. */
7564 gdb::unique_xmalloc_ptr
<char> debug_filename
;
7565 static const char artificial
[] = "<artificial>";
7566 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
7567 if (filename
== NULL
)
7569 else if (strcmp (filename
, artificial
) == 0)
7571 debug_filename
.reset (concat (artificial
, "@",
7572 sect_offset_str (per_cu
->sect_off
),
7574 filename
= debug_filename
.get ();
7577 pst
= create_partial_symtab (per_cu
, per_objfile
, filename
);
7579 /* This must be done before calling dwarf2_build_include_psymtabs. */
7580 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7582 baseaddr
= objfile
->text_section_offset ();
7584 dwarf2_find_base_address (comp_unit_die
, cu
);
7586 /* Possibly set the default values of LOWPC and HIGHPC from
7588 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
7589 &best_highpc
, cu
, pst
);
7590 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
7593 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
7596 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
7598 /* Store the contiguous range if it is not empty; it can be
7599 empty for CUs with no code. */
7600 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
7604 /* Check if comp unit has_children.
7605 If so, read the rest of the partial symbols from this comp unit.
7606 If not, there's no more debug_info for this comp unit. */
7607 if (comp_unit_die
->has_children
)
7609 struct partial_die_info
*first_die
;
7610 CORE_ADDR lowpc
, highpc
;
7612 lowpc
= ((CORE_ADDR
) -1);
7613 highpc
= ((CORE_ADDR
) 0);
7615 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7617 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
7618 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
7620 /* If we didn't find a lowpc, set it to highpc to avoid
7621 complaints from `maint check'. */
7622 if (lowpc
== ((CORE_ADDR
) -1))
7625 /* If the compilation unit didn't have an explicit address range,
7626 then use the information extracted from its child dies. */
7627 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
7630 best_highpc
= highpc
;
7633 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
7634 best_lowpc
+ baseaddr
)
7636 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
7637 best_highpc
+ baseaddr
)
7642 if (!cu
->per_cu
->imported_symtabs_empty ())
7645 int len
= cu
->per_cu
->imported_symtabs_size ();
7647 /* Fill in 'dependencies' here; we fill in 'users' in a
7649 pst
->number_of_dependencies
= len
;
7651 = objfile
->partial_symtabs
->allocate_dependencies (len
);
7652 for (i
= 0; i
< len
; ++i
)
7654 pst
->dependencies
[i
]
7655 = cu
->per_cu
->imported_symtabs
->at (i
)->v
.psymtab
;
7658 cu
->per_cu
->imported_symtabs_free ();
7661 /* Get the list of files included in the current compilation unit,
7662 and build a psymtab for each of them. */
7663 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
7665 if (dwarf_read_debug
)
7666 fprintf_unfiltered (gdb_stdlog
,
7667 "Psymtab for %s unit @%s: %s - %s"
7668 ", %d global, %d static syms\n",
7669 per_cu
->is_debug_types
? "type" : "comp",
7670 sect_offset_str (per_cu
->sect_off
),
7671 paddress (gdbarch
, pst
->text_low (objfile
)),
7672 paddress (gdbarch
, pst
->text_high (objfile
)),
7673 (int) pst
->global_psymbols
.size (),
7674 (int) pst
->static_psymbols
.size ());
7677 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7678 Process compilation unit THIS_CU for a psymtab. */
7681 process_psymtab_comp_unit (dwarf2_per_cu_data
*this_cu
,
7682 dwarf2_per_objfile
*per_objfile
,
7683 bool want_partial_unit
,
7684 enum language pretend_language
)
7686 /* If this compilation unit was already read in, free the
7687 cached copy in order to read it in again. This is
7688 necessary because we skipped some symbols when we first
7689 read in the compilation unit (see load_partial_dies).
7690 This problem could be avoided, but the benefit is unclear. */
7691 per_objfile
->remove_cu (this_cu
);
7693 cutu_reader
reader (this_cu
, per_objfile
, nullptr, nullptr, false);
7695 switch (reader
.comp_unit_die
->tag
)
7697 case DW_TAG_compile_unit
:
7698 this_cu
->unit_type
= DW_UT_compile
;
7700 case DW_TAG_partial_unit
:
7701 this_cu
->unit_type
= DW_UT_partial
;
7711 else if (this_cu
->is_debug_types
)
7712 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7713 reader
.comp_unit_die
);
7714 else if (want_partial_unit
7715 || reader
.comp_unit_die
->tag
!= DW_TAG_partial_unit
)
7716 process_psymtab_comp_unit_reader (&reader
, reader
.info_ptr
,
7717 reader
.comp_unit_die
,
7720 this_cu
->lang
= reader
.cu
->language
;
7722 /* Age out any secondary CUs. */
7723 per_objfile
->age_comp_units ();
7726 /* Reader function for build_type_psymtabs. */
7729 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
7730 const gdb_byte
*info_ptr
,
7731 struct die_info
*type_unit_die
)
7733 dwarf2_per_objfile
*per_objfile
= reader
->cu
->per_objfile
;
7734 struct dwarf2_cu
*cu
= reader
->cu
;
7735 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7736 struct signatured_type
*sig_type
;
7737 struct type_unit_group
*tu_group
;
7738 struct attribute
*attr
;
7739 struct partial_die_info
*first_die
;
7740 CORE_ADDR lowpc
, highpc
;
7741 dwarf2_psymtab
*pst
;
7743 gdb_assert (per_cu
->is_debug_types
);
7744 sig_type
= (struct signatured_type
*) per_cu
;
7746 if (! type_unit_die
->has_children
)
7749 attr
= type_unit_die
->attr (DW_AT_stmt_list
);
7750 tu_group
= get_type_unit_group (cu
, attr
);
7752 if (tu_group
->tus
== nullptr)
7753 tu_group
->tus
= new std::vector
<signatured_type
*>;
7754 tu_group
->tus
->push_back (sig_type
);
7756 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
7757 pst
= create_partial_symtab (per_cu
, per_objfile
, "");
7758 pst
->anonymous
= true;
7760 first_die
= load_partial_dies (reader
, info_ptr
, 1);
7762 lowpc
= (CORE_ADDR
) -1;
7763 highpc
= (CORE_ADDR
) 0;
7764 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
7769 /* Struct used to sort TUs by their abbreviation table offset. */
7771 struct tu_abbrev_offset
7773 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
7774 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
7777 signatured_type
*sig_type
;
7778 sect_offset abbrev_offset
;
7781 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
7784 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset
&a
,
7785 const struct tu_abbrev_offset
&b
)
7787 return a
.abbrev_offset
< b
.abbrev_offset
;
7790 /* Efficiently read all the type units.
7791 This does the bulk of the work for build_type_psymtabs.
7793 The efficiency is because we sort TUs by the abbrev table they use and
7794 only read each abbrev table once. In one program there are 200K TUs
7795 sharing 8K abbrev tables.
7797 The main purpose of this function is to support building the
7798 dwarf2_per_objfile->per_bfd->type_unit_groups table.
7799 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
7800 can collapse the search space by grouping them by stmt_list.
7801 The savings can be significant, in the same program from above the 200K TUs
7802 share 8K stmt_list tables.
7804 FUNC is expected to call get_type_unit_group, which will create the
7805 struct type_unit_group if necessary and add it to
7806 dwarf2_per_objfile->per_bfd->type_unit_groups. */
7809 build_type_psymtabs_1 (dwarf2_per_objfile
*per_objfile
)
7811 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7812 abbrev_table_up abbrev_table
;
7813 sect_offset abbrev_offset
;
7815 /* It's up to the caller to not call us multiple times. */
7816 gdb_assert (per_objfile
->per_bfd
->type_unit_groups
== NULL
);
7818 if (per_objfile
->per_bfd
->all_type_units
.empty ())
7821 /* TUs typically share abbrev tables, and there can be way more TUs than
7822 abbrev tables. Sort by abbrev table to reduce the number of times we
7823 read each abbrev table in.
7824 Alternatives are to punt or to maintain a cache of abbrev tables.
7825 This is simpler and efficient enough for now.
7827 Later we group TUs by their DW_AT_stmt_list value (as this defines the
7828 symtab to use). Typically TUs with the same abbrev offset have the same
7829 stmt_list value too so in practice this should work well.
7831 The basic algorithm here is:
7833 sort TUs by abbrev table
7834 for each TU with same abbrev table:
7835 read abbrev table if first user
7836 read TU top level DIE
7837 [IWBN if DWO skeletons had DW_AT_stmt_list]
7840 if (dwarf_read_debug
)
7841 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
7843 /* Sort in a separate table to maintain the order of all_type_units
7844 for .gdb_index: TU indices directly index all_type_units. */
7845 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
7846 sorted_by_abbrev
.reserve (per_objfile
->per_bfd
->all_type_units
.size ());
7848 for (signatured_type
*sig_type
: per_objfile
->per_bfd
->all_type_units
)
7849 sorted_by_abbrev
.emplace_back
7850 (sig_type
, read_abbrev_offset (per_objfile
, sig_type
->per_cu
.section
,
7851 sig_type
->per_cu
.sect_off
));
7853 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end (),
7854 sort_tu_by_abbrev_offset
);
7856 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
7858 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
7860 /* Switch to the next abbrev table if necessary. */
7861 if (abbrev_table
== NULL
7862 || tu
.abbrev_offset
!= abbrev_offset
)
7864 abbrev_offset
= tu
.abbrev_offset
;
7866 abbrev_table::read (per_objfile
->objfile
,
7867 &per_objfile
->per_bfd
->abbrev
, abbrev_offset
);
7868 ++tu_stats
->nr_uniq_abbrev_tables
;
7871 cutu_reader
reader (&tu
.sig_type
->per_cu
, per_objfile
,
7872 abbrev_table
.get (), nullptr, false);
7873 if (!reader
.dummy_p
)
7874 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7875 reader
.comp_unit_die
);
7879 /* Print collected type unit statistics. */
7882 print_tu_stats (dwarf2_per_objfile
*per_objfile
)
7884 struct tu_stats
*tu_stats
= &per_objfile
->per_bfd
->tu_stats
;
7886 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
7887 fprintf_unfiltered (gdb_stdlog
, " %zu TUs\n",
7888 per_objfile
->per_bfd
->all_type_units
.size ());
7889 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
7890 tu_stats
->nr_uniq_abbrev_tables
);
7891 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
7892 tu_stats
->nr_symtabs
);
7893 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
7894 tu_stats
->nr_symtab_sharers
);
7895 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
7896 tu_stats
->nr_stmt_less_type_units
);
7897 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
7898 tu_stats
->nr_all_type_units_reallocs
);
7901 /* Traversal function for build_type_psymtabs. */
7904 build_type_psymtab_dependencies (void **slot
, void *info
)
7906 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7907 struct objfile
*objfile
= per_objfile
->objfile
;
7908 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
7909 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
7910 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
7911 int len
= (tu_group
->tus
== nullptr) ? 0 : tu_group
->tus
->size ();
7914 gdb_assert (len
> 0);
7915 gdb_assert (per_cu
->type_unit_group_p ());
7917 pst
->number_of_dependencies
= len
;
7918 pst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (len
);
7919 for (i
= 0; i
< len
; ++i
)
7921 struct signatured_type
*iter
= tu_group
->tus
->at (i
);
7922 gdb_assert (iter
->per_cu
.is_debug_types
);
7923 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
7924 iter
->type_unit_group
= tu_group
;
7927 delete tu_group
->tus
;
7928 tu_group
->tus
= nullptr;
7933 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
7934 Build partial symbol tables for the .debug_types comp-units. */
7937 build_type_psymtabs (dwarf2_per_objfile
*per_objfile
)
7939 if (! create_all_type_units (per_objfile
))
7942 build_type_psymtabs_1 (per_objfile
);
7945 /* Traversal function for process_skeletonless_type_unit.
7946 Read a TU in a DWO file and build partial symbols for it. */
7949 process_skeletonless_type_unit (void **slot
, void *info
)
7951 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
7952 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) info
;
7953 struct signatured_type find_entry
, *entry
;
7955 /* If this TU doesn't exist in the global table, add it and read it in. */
7957 if (per_objfile
->per_bfd
->signatured_types
== NULL
)
7958 per_objfile
->per_bfd
->signatured_types
= allocate_signatured_type_table ();
7960 find_entry
.signature
= dwo_unit
->signature
;
7961 slot
= htab_find_slot (per_objfile
->per_bfd
->signatured_types
.get (),
7962 &find_entry
, INSERT
);
7963 /* If we've already seen this type there's nothing to do. What's happening
7964 is we're doing our own version of comdat-folding here. */
7968 /* This does the job that create_all_type_units would have done for
7970 entry
= add_type_unit (per_objfile
, dwo_unit
->signature
, slot
);
7971 fill_in_sig_entry_from_dwo_entry (per_objfile
, entry
, dwo_unit
);
7974 /* This does the job that build_type_psymtabs_1 would have done. */
7975 cutu_reader
reader (&entry
->per_cu
, per_objfile
, nullptr, nullptr, false);
7976 if (!reader
.dummy_p
)
7977 build_type_psymtabs_reader (&reader
, reader
.info_ptr
,
7978 reader
.comp_unit_die
);
7983 /* Traversal function for process_skeletonless_type_units. */
7986 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
7988 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
7990 if (dwo_file
->tus
!= NULL
)
7991 htab_traverse_noresize (dwo_file
->tus
.get (),
7992 process_skeletonless_type_unit
, info
);
7997 /* Scan all TUs of DWO files, verifying we've processed them.
7998 This is needed in case a TU was emitted without its skeleton.
7999 Note: This can't be done until we know what all the DWO files are. */
8002 process_skeletonless_type_units (dwarf2_per_objfile
*per_objfile
)
8004 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8005 if (get_dwp_file (per_objfile
) == NULL
8006 && per_objfile
->per_bfd
->dwo_files
!= NULL
)
8008 htab_traverse_noresize (per_objfile
->per_bfd
->dwo_files
.get (),
8009 process_dwo_file_for_skeletonless_type_units
,
8014 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8017 set_partial_user (dwarf2_per_objfile
*per_objfile
)
8019 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
8021 dwarf2_psymtab
*pst
= per_cu
->v
.psymtab
;
8026 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
8028 /* Set the 'user' field only if it is not already set. */
8029 if (pst
->dependencies
[j
]->user
== NULL
)
8030 pst
->dependencies
[j
]->user
= pst
;
8035 /* Build the partial symbol table by doing a quick pass through the
8036 .debug_info and .debug_abbrev sections. */
8039 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
*per_objfile
)
8041 struct objfile
*objfile
= per_objfile
->objfile
;
8043 if (dwarf_read_debug
)
8045 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
8046 objfile_name (objfile
));
8049 scoped_restore restore_reading_psyms
8050 = make_scoped_restore (&per_objfile
->per_bfd
->reading_partial_symbols
,
8053 per_objfile
->per_bfd
->info
.read (objfile
);
8055 /* Any cached compilation units will be linked by the per-objfile
8056 read_in_chain. Make sure to free them when we're done. */
8057 free_cached_comp_units
freer (per_objfile
);
8059 build_type_psymtabs (per_objfile
);
8061 create_all_comp_units (per_objfile
);
8063 /* Create a temporary address map on a temporary obstack. We later
8064 copy this to the final obstack. */
8065 auto_obstack temp_obstack
;
8067 scoped_restore save_psymtabs_addrmap
8068 = make_scoped_restore (&objfile
->partial_symtabs
->psymtabs_addrmap
,
8069 addrmap_create_mutable (&temp_obstack
));
8071 for (dwarf2_per_cu_data
*per_cu
: per_objfile
->per_bfd
->all_comp_units
)
8073 if (per_cu
->v
.psymtab
!= NULL
)
8074 /* In case a forward DW_TAG_imported_unit has read the CU already. */
8076 process_psymtab_comp_unit (per_cu
, per_objfile
, false,
8080 /* This has to wait until we read the CUs, we need the list of DWOs. */
8081 process_skeletonless_type_units (per_objfile
);
8083 /* Now that all TUs have been processed we can fill in the dependencies. */
8084 if (per_objfile
->per_bfd
->type_unit_groups
!= NULL
)
8086 htab_traverse_noresize (per_objfile
->per_bfd
->type_unit_groups
.get (),
8087 build_type_psymtab_dependencies
, per_objfile
);
8090 if (dwarf_read_debug
)
8091 print_tu_stats (per_objfile
);
8093 set_partial_user (per_objfile
);
8095 objfile
->partial_symtabs
->psymtabs_addrmap
8096 = addrmap_create_fixed (objfile
->partial_symtabs
->psymtabs_addrmap
,
8097 objfile
->partial_symtabs
->obstack ());
8098 /* At this point we want to keep the address map. */
8099 save_psymtabs_addrmap
.release ();
8101 if (dwarf_read_debug
)
8102 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
8103 objfile_name (objfile
));
8106 /* Load the partial DIEs for a secondary CU into memory.
8107 This is also used when rereading a primary CU with load_all_dies. */
8110 load_partial_comp_unit (dwarf2_per_cu_data
*this_cu
,
8111 dwarf2_per_objfile
*per_objfile
,
8112 dwarf2_cu
*existing_cu
)
8114 cutu_reader
reader (this_cu
, per_objfile
, nullptr, existing_cu
, false);
8116 if (!reader
.dummy_p
)
8118 prepare_one_comp_unit (reader
.cu
, reader
.comp_unit_die
,
8121 /* Check if comp unit has_children.
8122 If so, read the rest of the partial symbols from this comp unit.
8123 If not, there's no more debug_info for this comp unit. */
8124 if (reader
.comp_unit_die
->has_children
)
8125 load_partial_dies (&reader
, reader
.info_ptr
, 0);
8132 read_comp_units_from_section (dwarf2_per_objfile
*per_objfile
,
8133 struct dwarf2_section_info
*section
,
8134 struct dwarf2_section_info
*abbrev_section
,
8135 unsigned int is_dwz
)
8137 const gdb_byte
*info_ptr
;
8138 struct objfile
*objfile
= per_objfile
->objfile
;
8140 if (dwarf_read_debug
)
8141 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
8142 section
->get_name (),
8143 section
->get_file_name ());
8145 section
->read (objfile
);
8147 info_ptr
= section
->buffer
;
8149 while (info_ptr
< section
->buffer
+ section
->size
)
8151 struct dwarf2_per_cu_data
*this_cu
;
8153 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
8155 comp_unit_head cu_header
;
8156 read_and_check_comp_unit_head (per_objfile
, &cu_header
, section
,
8157 abbrev_section
, info_ptr
,
8158 rcuh_kind::COMPILE
);
8160 /* Save the compilation unit for later lookup. */
8161 if (cu_header
.unit_type
!= DW_UT_type
)
8162 this_cu
= per_objfile
->per_bfd
->allocate_per_cu ();
8165 auto sig_type
= per_objfile
->per_bfd
->allocate_signatured_type ();
8166 sig_type
->signature
= cu_header
.signature
;
8167 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
8168 this_cu
= &sig_type
->per_cu
;
8170 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
8171 this_cu
->sect_off
= sect_off
;
8172 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
8173 this_cu
->is_dwz
= is_dwz
;
8174 this_cu
->section
= section
;
8176 per_objfile
->per_bfd
->all_comp_units
.push_back (this_cu
);
8178 info_ptr
= info_ptr
+ this_cu
->length
;
8182 /* Create a list of all compilation units in OBJFILE.
8183 This is only done for -readnow and building partial symtabs. */
8186 create_all_comp_units (dwarf2_per_objfile
*per_objfile
)
8188 gdb_assert (per_objfile
->per_bfd
->all_comp_units
.empty ());
8189 read_comp_units_from_section (per_objfile
, &per_objfile
->per_bfd
->info
,
8190 &per_objfile
->per_bfd
->abbrev
, 0);
8192 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
8194 read_comp_units_from_section (per_objfile
, &dwz
->info
, &dwz
->abbrev
, 1);
8197 /* Process all loaded DIEs for compilation unit CU, starting at
8198 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8199 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8200 DW_AT_ranges). See the comments of add_partial_subprogram on how
8201 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8204 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
8205 CORE_ADDR
*highpc
, int set_addrmap
,
8206 struct dwarf2_cu
*cu
)
8208 struct partial_die_info
*pdi
;
8210 /* Now, march along the PDI's, descending into ones which have
8211 interesting children but skipping the children of the other ones,
8212 until we reach the end of the compilation unit. */
8220 /* Anonymous namespaces or modules have no name but have interesting
8221 children, so we need to look at them. Ditto for anonymous
8224 if (pdi
->raw_name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
8225 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
8226 || pdi
->tag
== DW_TAG_imported_unit
8227 || pdi
->tag
== DW_TAG_inlined_subroutine
)
8231 case DW_TAG_subprogram
:
8232 case DW_TAG_inlined_subroutine
:
8233 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8234 if (cu
->language
== language_cplus
)
8235 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8238 case DW_TAG_constant
:
8239 case DW_TAG_variable
:
8240 case DW_TAG_typedef
:
8241 case DW_TAG_union_type
:
8242 if (!pdi
->is_declaration
8243 || (pdi
->tag
== DW_TAG_variable
&& pdi
->is_external
))
8245 add_partial_symbol (pdi
, cu
);
8248 case DW_TAG_class_type
:
8249 case DW_TAG_interface_type
:
8250 case DW_TAG_structure_type
:
8251 if (!pdi
->is_declaration
)
8253 add_partial_symbol (pdi
, cu
);
8255 if ((cu
->language
== language_rust
8256 || cu
->language
== language_cplus
) && pdi
->has_children
)
8257 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8260 case DW_TAG_enumeration_type
:
8261 if (!pdi
->is_declaration
)
8262 add_partial_enumeration (pdi
, cu
);
8264 case DW_TAG_base_type
:
8265 case DW_TAG_subrange_type
:
8266 /* File scope base type definitions are added to the partial
8268 add_partial_symbol (pdi
, cu
);
8270 case DW_TAG_namespace
:
8271 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8274 if (!pdi
->is_declaration
)
8275 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8277 case DW_TAG_imported_unit
:
8279 struct dwarf2_per_cu_data
*per_cu
;
8281 /* For now we don't handle imported units in type units. */
8282 if (cu
->per_cu
->is_debug_types
)
8284 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8285 " supported in type units [in module %s]"),
8286 objfile_name (cu
->per_objfile
->objfile
));
8289 per_cu
= dwarf2_find_containing_comp_unit
8290 (pdi
->d
.sect_off
, pdi
->is_dwz
, cu
->per_objfile
);
8292 /* Go read the partial unit, if needed. */
8293 if (per_cu
->v
.psymtab
== NULL
)
8294 process_psymtab_comp_unit (per_cu
, cu
->per_objfile
, true,
8297 cu
->per_cu
->imported_symtabs_push (per_cu
);
8300 case DW_TAG_imported_declaration
:
8301 add_partial_symbol (pdi
, cu
);
8308 /* If the die has a sibling, skip to the sibling. */
8310 pdi
= pdi
->die_sibling
;
8314 /* Functions used to compute the fully scoped name of a partial DIE.
8316 Normally, this is simple. For C++, the parent DIE's fully scoped
8317 name is concatenated with "::" and the partial DIE's name.
8318 Enumerators are an exception; they use the scope of their parent
8319 enumeration type, i.e. the name of the enumeration type is not
8320 prepended to the enumerator.
8322 There are two complexities. One is DW_AT_specification; in this
8323 case "parent" means the parent of the target of the specification,
8324 instead of the direct parent of the DIE. The other is compilers
8325 which do not emit DW_TAG_namespace; in this case we try to guess
8326 the fully qualified name of structure types from their members'
8327 linkage names. This must be done using the DIE's children rather
8328 than the children of any DW_AT_specification target. We only need
8329 to do this for structures at the top level, i.e. if the target of
8330 any DW_AT_specification (if any; otherwise the DIE itself) does not
8333 /* Compute the scope prefix associated with PDI's parent, in
8334 compilation unit CU. The result will be allocated on CU's
8335 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8336 field. NULL is returned if no prefix is necessary. */
8338 partial_die_parent_scope (struct partial_die_info
*pdi
,
8339 struct dwarf2_cu
*cu
)
8341 const char *grandparent_scope
;
8342 struct partial_die_info
*parent
, *real_pdi
;
8344 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8345 then this means the parent of the specification DIE. */
8348 while (real_pdi
->has_specification
)
8350 auto res
= find_partial_die (real_pdi
->spec_offset
,
8351 real_pdi
->spec_is_dwz
, cu
);
8356 parent
= real_pdi
->die_parent
;
8360 if (parent
->scope_set
)
8361 return parent
->scope
;
8365 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
8367 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8368 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8369 Work around this problem here. */
8370 if (cu
->language
== language_cplus
8371 && parent
->tag
== DW_TAG_namespace
8372 && strcmp (parent
->name (cu
), "::") == 0
8373 && grandparent_scope
== NULL
)
8375 parent
->scope
= NULL
;
8376 parent
->scope_set
= 1;
8380 /* Nested subroutines in Fortran get a prefix. */
8381 if (pdi
->tag
== DW_TAG_enumerator
)
8382 /* Enumerators should not get the name of the enumeration as a prefix. */
8383 parent
->scope
= grandparent_scope
;
8384 else if (parent
->tag
== DW_TAG_namespace
8385 || parent
->tag
== DW_TAG_module
8386 || parent
->tag
== DW_TAG_structure_type
8387 || parent
->tag
== DW_TAG_class_type
8388 || parent
->tag
== DW_TAG_interface_type
8389 || parent
->tag
== DW_TAG_union_type
8390 || parent
->tag
== DW_TAG_enumeration_type
8391 || (cu
->language
== language_fortran
8392 && parent
->tag
== DW_TAG_subprogram
8393 && pdi
->tag
== DW_TAG_subprogram
))
8395 if (grandparent_scope
== NULL
)
8396 parent
->scope
= parent
->name (cu
);
8398 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
8400 parent
->name (cu
), 0, cu
);
8404 /* FIXME drow/2004-04-01: What should we be doing with
8405 function-local names? For partial symbols, we should probably be
8407 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8408 dwarf_tag_name (parent
->tag
),
8409 sect_offset_str (pdi
->sect_off
));
8410 parent
->scope
= grandparent_scope
;
8413 parent
->scope_set
= 1;
8414 return parent
->scope
;
8417 /* Return the fully scoped name associated with PDI, from compilation unit
8418 CU. The result will be allocated with malloc. */
8420 static gdb::unique_xmalloc_ptr
<char>
8421 partial_die_full_name (struct partial_die_info
*pdi
,
8422 struct dwarf2_cu
*cu
)
8424 const char *parent_scope
;
8426 /* If this is a template instantiation, we can not work out the
8427 template arguments from partial DIEs. So, unfortunately, we have
8428 to go through the full DIEs. At least any work we do building
8429 types here will be reused if full symbols are loaded later. */
8430 if (pdi
->has_template_arguments
)
8434 if (pdi
->name (cu
) != NULL
&& strchr (pdi
->name (cu
), '<') == NULL
)
8436 struct die_info
*die
;
8437 struct attribute attr
;
8438 struct dwarf2_cu
*ref_cu
= cu
;
8440 /* DW_FORM_ref_addr is using section offset. */
8441 attr
.name
= (enum dwarf_attribute
) 0;
8442 attr
.form
= DW_FORM_ref_addr
;
8443 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
8444 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
8446 return make_unique_xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
8450 parent_scope
= partial_die_parent_scope (pdi
, cu
);
8451 if (parent_scope
== NULL
)
8454 return gdb::unique_xmalloc_ptr
<char> (typename_concat (NULL
, parent_scope
,
8460 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
8462 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
8463 struct objfile
*objfile
= per_objfile
->objfile
;
8464 struct gdbarch
*gdbarch
= objfile
->arch ();
8466 const char *actual_name
= NULL
;
8469 baseaddr
= objfile
->text_section_offset ();
8471 gdb::unique_xmalloc_ptr
<char> built_actual_name
8472 = partial_die_full_name (pdi
, cu
);
8473 if (built_actual_name
!= NULL
)
8474 actual_name
= built_actual_name
.get ();
8476 if (actual_name
== NULL
)
8477 actual_name
= pdi
->name (cu
);
8479 partial_symbol psymbol
;
8480 memset (&psymbol
, 0, sizeof (psymbol
));
8481 psymbol
.ginfo
.set_language (cu
->language
, &objfile
->objfile_obstack
);
8482 psymbol
.ginfo
.section
= -1;
8484 /* The code below indicates that the psymbol should be installed by
8486 gdb::optional
<psymbol_placement
> where
;
8490 case DW_TAG_inlined_subroutine
:
8491 case DW_TAG_subprogram
:
8492 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
8494 if (pdi
->is_external
8495 || cu
->language
== language_ada
8496 || (cu
->language
== language_fortran
8497 && pdi
->die_parent
!= NULL
8498 && pdi
->die_parent
->tag
== DW_TAG_subprogram
))
8500 /* Normally, only "external" DIEs are part of the global scope.
8501 But in Ada and Fortran, we want to be able to access nested
8502 procedures globally. So all Ada and Fortran subprograms are
8503 stored in the global scope. */
8504 where
= psymbol_placement::GLOBAL
;
8507 where
= psymbol_placement::STATIC
;
8509 psymbol
.domain
= VAR_DOMAIN
;
8510 psymbol
.aclass
= LOC_BLOCK
;
8511 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8512 psymbol
.ginfo
.value
.address
= addr
;
8514 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8515 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
8517 case DW_TAG_constant
:
8518 psymbol
.domain
= VAR_DOMAIN
;
8519 psymbol
.aclass
= LOC_STATIC
;
8520 where
= (pdi
->is_external
8521 ? psymbol_placement::GLOBAL
8522 : psymbol_placement::STATIC
);
8524 case DW_TAG_variable
:
8526 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
8530 && !per_objfile
->per_bfd
->has_section_at_zero
)
8532 /* A global or static variable may also have been stripped
8533 out by the linker if unused, in which case its address
8534 will be nullified; do not add such variables into partial
8535 symbol table then. */
8537 else if (pdi
->is_external
)
8540 Don't enter into the minimal symbol tables as there is
8541 a minimal symbol table entry from the ELF symbols already.
8542 Enter into partial symbol table if it has a location
8543 descriptor or a type.
8544 If the location descriptor is missing, new_symbol will create
8545 a LOC_UNRESOLVED symbol, the address of the variable will then
8546 be determined from the minimal symbol table whenever the variable
8548 The address for the partial symbol table entry is not
8549 used by GDB, but it comes in handy for debugging partial symbol
8552 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8554 psymbol
.domain
= VAR_DOMAIN
;
8555 psymbol
.aclass
= LOC_STATIC
;
8556 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8557 psymbol
.ginfo
.value
.address
= addr
;
8558 where
= psymbol_placement::GLOBAL
;
8563 int has_loc
= pdi
->d
.locdesc
!= NULL
;
8565 /* Static Variable. Skip symbols whose value we cannot know (those
8566 without location descriptors or constant values). */
8567 if (!has_loc
&& !pdi
->has_const_value
)
8570 psymbol
.domain
= VAR_DOMAIN
;
8571 psymbol
.aclass
= LOC_STATIC
;
8572 psymbol
.ginfo
.section
= SECT_OFF_TEXT (objfile
);
8574 psymbol
.ginfo
.value
.address
= addr
;
8575 where
= psymbol_placement::STATIC
;
8578 case DW_TAG_typedef
:
8579 case DW_TAG_base_type
:
8580 case DW_TAG_subrange_type
:
8581 psymbol
.domain
= VAR_DOMAIN
;
8582 psymbol
.aclass
= LOC_TYPEDEF
;
8583 where
= psymbol_placement::STATIC
;
8585 case DW_TAG_imported_declaration
:
8586 case DW_TAG_namespace
:
8587 psymbol
.domain
= VAR_DOMAIN
;
8588 psymbol
.aclass
= LOC_TYPEDEF
;
8589 where
= psymbol_placement::GLOBAL
;
8592 /* With Fortran 77 there might be a "BLOCK DATA" module
8593 available without any name. If so, we skip the module as it
8594 doesn't bring any value. */
8595 if (actual_name
!= nullptr)
8597 psymbol
.domain
= MODULE_DOMAIN
;
8598 psymbol
.aclass
= LOC_TYPEDEF
;
8599 where
= psymbol_placement::GLOBAL
;
8602 case DW_TAG_class_type
:
8603 case DW_TAG_interface_type
:
8604 case DW_TAG_structure_type
:
8605 case DW_TAG_union_type
:
8606 case DW_TAG_enumeration_type
:
8607 /* Skip external references. The DWARF standard says in the section
8608 about "Structure, Union, and Class Type Entries": "An incomplete
8609 structure, union or class type is represented by a structure,
8610 union or class entry that does not have a byte size attribute
8611 and that has a DW_AT_declaration attribute." */
8612 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
8615 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8616 static vs. global. */
8617 psymbol
.domain
= STRUCT_DOMAIN
;
8618 psymbol
.aclass
= LOC_TYPEDEF
;
8619 where
= (cu
->language
== language_cplus
8620 ? psymbol_placement::GLOBAL
8621 : psymbol_placement::STATIC
);
8623 case DW_TAG_enumerator
:
8624 psymbol
.domain
= VAR_DOMAIN
;
8625 psymbol
.aclass
= LOC_CONST
;
8626 where
= (cu
->language
== language_cplus
8627 ? psymbol_placement::GLOBAL
8628 : psymbol_placement::STATIC
);
8634 if (where
.has_value ())
8636 if (built_actual_name
!= nullptr)
8637 actual_name
= objfile
->intern (actual_name
);
8638 if (pdi
->linkage_name
== nullptr || cu
->language
== language_ada
)
8639 psymbol
.ginfo
.set_linkage_name (actual_name
);
8642 psymbol
.ginfo
.set_demangled_name (actual_name
,
8643 &objfile
->objfile_obstack
);
8644 psymbol
.ginfo
.set_linkage_name (pdi
->linkage_name
);
8646 cu
->per_cu
->v
.psymtab
->add_psymbol (psymbol
, *where
, objfile
);
8650 /* Read a partial die corresponding to a namespace; also, add a symbol
8651 corresponding to that namespace to the symbol table. NAMESPACE is
8652 the name of the enclosing namespace. */
8655 add_partial_namespace (struct partial_die_info
*pdi
,
8656 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8657 int set_addrmap
, struct dwarf2_cu
*cu
)
8659 /* Add a symbol for the namespace. */
8661 add_partial_symbol (pdi
, cu
);
8663 /* Now scan partial symbols in that namespace. */
8665 if (pdi
->has_children
)
8666 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8669 /* Read a partial die corresponding to a Fortran module. */
8672 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
8673 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
8675 /* Add a symbol for the namespace. */
8677 add_partial_symbol (pdi
, cu
);
8679 /* Now scan partial symbols in that module. */
8681 if (pdi
->has_children
)
8682 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
8685 /* Read a partial die corresponding to a subprogram or an inlined
8686 subprogram and create a partial symbol for that subprogram.
8687 When the CU language allows it, this routine also defines a partial
8688 symbol for each nested subprogram that this subprogram contains.
8689 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
8690 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
8692 PDI may also be a lexical block, in which case we simply search
8693 recursively for subprograms defined inside that lexical block.
8694 Again, this is only performed when the CU language allows this
8695 type of definitions. */
8698 add_partial_subprogram (struct partial_die_info
*pdi
,
8699 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
8700 int set_addrmap
, struct dwarf2_cu
*cu
)
8702 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
8704 if (pdi
->has_pc_info
)
8706 if (pdi
->lowpc
< *lowpc
)
8707 *lowpc
= pdi
->lowpc
;
8708 if (pdi
->highpc
> *highpc
)
8709 *highpc
= pdi
->highpc
;
8712 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
8713 struct gdbarch
*gdbarch
= objfile
->arch ();
8715 CORE_ADDR this_highpc
;
8716 CORE_ADDR this_lowpc
;
8718 baseaddr
= objfile
->text_section_offset ();
8720 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8721 pdi
->lowpc
+ baseaddr
)
8724 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
8725 pdi
->highpc
+ baseaddr
)
8727 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
8728 this_lowpc
, this_highpc
- 1,
8729 cu
->per_cu
->v
.psymtab
);
8733 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
8735 if (!pdi
->is_declaration
)
8736 /* Ignore subprogram DIEs that do not have a name, they are
8737 illegal. Do not emit a complaint at this point, we will
8738 do so when we convert this psymtab into a symtab. */
8740 add_partial_symbol (pdi
, cu
);
8744 if (! pdi
->has_children
)
8747 if (cu
->language
== language_ada
|| cu
->language
== language_fortran
)
8749 pdi
= pdi
->die_child
;
8753 if (pdi
->tag
== DW_TAG_subprogram
8754 || pdi
->tag
== DW_TAG_inlined_subroutine
8755 || pdi
->tag
== DW_TAG_lexical_block
)
8756 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8757 pdi
= pdi
->die_sibling
;
8762 /* Read a partial die corresponding to an enumeration type. */
8765 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
8766 struct dwarf2_cu
*cu
)
8768 struct partial_die_info
*pdi
;
8770 if (enum_pdi
->name (cu
) != NULL
)
8771 add_partial_symbol (enum_pdi
, cu
);
8773 pdi
= enum_pdi
->die_child
;
8776 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->raw_name
== NULL
)
8777 complaint (_("malformed enumerator DIE ignored"));
8779 add_partial_symbol (pdi
, cu
);
8780 pdi
= pdi
->die_sibling
;
8784 /* Return the initial uleb128 in the die at INFO_PTR. */
8787 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
8789 unsigned int bytes_read
;
8791 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8794 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
8795 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
8797 Return the corresponding abbrev, or NULL if the number is zero (indicating
8798 an empty DIE). In either case *BYTES_READ will be set to the length of
8799 the initial number. */
8801 static struct abbrev_info
*
8802 peek_die_abbrev (const die_reader_specs
&reader
,
8803 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
8805 dwarf2_cu
*cu
= reader
.cu
;
8806 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
8807 unsigned int abbrev_number
8808 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
8810 if (abbrev_number
== 0)
8813 abbrev_info
*abbrev
= reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
8816 error (_("Dwarf Error: Could not find abbrev number %d in %s"
8817 " at offset %s [in module %s]"),
8818 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
8819 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
8825 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8826 Returns a pointer to the end of a series of DIEs, terminated by an empty
8827 DIE. Any children of the skipped DIEs will also be skipped. */
8829 static const gdb_byte
*
8830 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
8834 unsigned int bytes_read
;
8835 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
8838 return info_ptr
+ bytes_read
;
8840 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
8844 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
8845 INFO_PTR should point just after the initial uleb128 of a DIE, and the
8846 abbrev corresponding to that skipped uleb128 should be passed in
8847 ABBREV. Returns a pointer to this DIE's sibling, skipping any
8850 static const gdb_byte
*
8851 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
8852 struct abbrev_info
*abbrev
)
8854 unsigned int bytes_read
;
8855 struct attribute attr
;
8856 bfd
*abfd
= reader
->abfd
;
8857 struct dwarf2_cu
*cu
= reader
->cu
;
8858 const gdb_byte
*buffer
= reader
->buffer
;
8859 const gdb_byte
*buffer_end
= reader
->buffer_end
;
8860 unsigned int form
, i
;
8862 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
8864 /* The only abbrev we care about is DW_AT_sibling. */
8865 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
8867 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
8868 if (attr
.form
== DW_FORM_ref_addr
)
8869 complaint (_("ignoring absolute DW_AT_sibling"));
8872 sect_offset off
= attr
.get_ref_die_offset ();
8873 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
8875 if (sibling_ptr
< info_ptr
)
8876 complaint (_("DW_AT_sibling points backwards"));
8877 else if (sibling_ptr
> reader
->buffer_end
)
8878 reader
->die_section
->overflow_complaint ();
8884 /* If it isn't DW_AT_sibling, skip this attribute. */
8885 form
= abbrev
->attrs
[i
].form
;
8889 case DW_FORM_ref_addr
:
8890 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
8891 and later it is offset sized. */
8892 if (cu
->header
.version
== 2)
8893 info_ptr
+= cu
->header
.addr_size
;
8895 info_ptr
+= cu
->header
.offset_size
;
8897 case DW_FORM_GNU_ref_alt
:
8898 info_ptr
+= cu
->header
.offset_size
;
8901 info_ptr
+= cu
->header
.addr_size
;
8909 case DW_FORM_flag_present
:
8910 case DW_FORM_implicit_const
:
8927 case DW_FORM_ref_sig8
:
8930 case DW_FORM_data16
:
8933 case DW_FORM_string
:
8934 read_direct_string (abfd
, info_ptr
, &bytes_read
);
8935 info_ptr
+= bytes_read
;
8937 case DW_FORM_sec_offset
:
8939 case DW_FORM_GNU_strp_alt
:
8940 info_ptr
+= cu
->header
.offset_size
;
8942 case DW_FORM_exprloc
:
8944 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8945 info_ptr
+= bytes_read
;
8947 case DW_FORM_block1
:
8948 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
8950 case DW_FORM_block2
:
8951 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
8953 case DW_FORM_block4
:
8954 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
8960 case DW_FORM_ref_udata
:
8961 case DW_FORM_GNU_addr_index
:
8962 case DW_FORM_GNU_str_index
:
8963 case DW_FORM_rnglistx
:
8964 case DW_FORM_loclistx
:
8965 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
8967 case DW_FORM_indirect
:
8968 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
8969 info_ptr
+= bytes_read
;
8970 /* We need to continue parsing from here, so just go back to
8972 goto skip_attribute
;
8975 error (_("Dwarf Error: Cannot handle %s "
8976 "in DWARF reader [in module %s]"),
8977 dwarf_form_name (form
),
8978 bfd_get_filename (abfd
));
8982 if (abbrev
->has_children
)
8983 return skip_children (reader
, info_ptr
);
8988 /* Locate ORIG_PDI's sibling.
8989 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
8991 static const gdb_byte
*
8992 locate_pdi_sibling (const struct die_reader_specs
*reader
,
8993 struct partial_die_info
*orig_pdi
,
8994 const gdb_byte
*info_ptr
)
8996 /* Do we know the sibling already? */
8998 if (orig_pdi
->sibling
)
8999 return orig_pdi
->sibling
;
9001 /* Are there any children to deal with? */
9003 if (!orig_pdi
->has_children
)
9006 /* Skip the children the long way. */
9008 return skip_children (reader
, info_ptr
);
9011 /* Expand this partial symbol table into a full symbol table. SELF is
9015 dwarf2_psymtab::read_symtab (struct objfile
*objfile
)
9017 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9019 gdb_assert (!per_objfile
->symtab_set_p (per_cu_data
));
9021 /* If this psymtab is constructed from a debug-only objfile, the
9022 has_section_at_zero flag will not necessarily be correct. We
9023 can get the correct value for this flag by looking at the data
9024 associated with the (presumably stripped) associated objfile. */
9025 if (objfile
->separate_debug_objfile_backlink
)
9027 dwarf2_per_objfile
*per_objfile_backlink
9028 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
9030 per_objfile
->per_bfd
->has_section_at_zero
9031 = per_objfile_backlink
->per_bfd
->has_section_at_zero
;
9034 expand_psymtab (objfile
);
9036 process_cu_includes (per_objfile
);
9039 /* Reading in full CUs. */
9041 /* Add PER_CU to the queue. */
9044 queue_comp_unit (dwarf2_per_cu_data
*per_cu
,
9045 dwarf2_per_objfile
*per_objfile
,
9046 enum language pretend_language
)
9049 per_cu
->per_bfd
->queue
.emplace (per_cu
, per_objfile
, pretend_language
);
9052 /* If PER_CU is not yet queued, add it to the queue.
9053 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9055 The result is non-zero if PER_CU was queued, otherwise the result is zero
9056 meaning either PER_CU is already queued or it is already loaded.
9058 N.B. There is an invariant here that if a CU is queued then it is loaded.
9059 The caller is required to load PER_CU if we return non-zero. */
9062 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
9063 dwarf2_per_cu_data
*per_cu
,
9064 dwarf2_per_objfile
*per_objfile
,
9065 enum language pretend_language
)
9067 /* We may arrive here during partial symbol reading, if we need full
9068 DIEs to process an unusual case (e.g. template arguments). Do
9069 not queue PER_CU, just tell our caller to load its DIEs. */
9070 if (per_cu
->per_bfd
->reading_partial_symbols
)
9072 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9074 if (cu
== NULL
|| cu
->dies
== NULL
)
9079 /* Mark the dependence relation so that we don't flush PER_CU
9081 if (dependent_cu
!= NULL
)
9082 dwarf2_add_dependence (dependent_cu
, per_cu
);
9084 /* If it's already on the queue, we have nothing to do. */
9088 /* If the compilation unit is already loaded, just mark it as
9090 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9097 /* Add it to the queue. */
9098 queue_comp_unit (per_cu
, per_objfile
, pretend_language
);
9103 /* Process the queue. */
9106 process_queue (dwarf2_per_objfile
*per_objfile
)
9108 if (dwarf_read_debug
)
9110 fprintf_unfiltered (gdb_stdlog
,
9111 "Expanding one or more symtabs of objfile %s ...\n",
9112 objfile_name (per_objfile
->objfile
));
9115 /* The queue starts out with one item, but following a DIE reference
9116 may load a new CU, adding it to the end of the queue. */
9117 while (!per_objfile
->per_bfd
->queue
.empty ())
9119 dwarf2_queue_item
&item
= per_objfile
->per_bfd
->queue
.front ();
9120 dwarf2_per_cu_data
*per_cu
= item
.per_cu
;
9122 if (!per_objfile
->symtab_set_p (per_cu
))
9124 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
9126 /* Skip dummy CUs. */
9129 unsigned int debug_print_threshold
;
9132 if (per_cu
->is_debug_types
)
9134 struct signatured_type
*sig_type
=
9135 (struct signatured_type
*) per_cu
;
9137 sprintf (buf
, "TU %s at offset %s",
9138 hex_string (sig_type
->signature
),
9139 sect_offset_str (per_cu
->sect_off
));
9140 /* There can be 100s of TUs.
9141 Only print them in verbose mode. */
9142 debug_print_threshold
= 2;
9146 sprintf (buf
, "CU at offset %s",
9147 sect_offset_str (per_cu
->sect_off
));
9148 debug_print_threshold
= 1;
9151 if (dwarf_read_debug
>= debug_print_threshold
)
9152 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
9154 if (per_cu
->is_debug_types
)
9155 process_full_type_unit (cu
, item
.pretend_language
);
9157 process_full_comp_unit (cu
, item
.pretend_language
);
9159 if (dwarf_read_debug
>= debug_print_threshold
)
9160 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
9165 per_objfile
->per_bfd
->queue
.pop ();
9168 if (dwarf_read_debug
)
9170 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
9171 objfile_name (per_objfile
->objfile
));
9175 /* Read in full symbols for PST, and anything it depends on. */
9178 dwarf2_psymtab::expand_psymtab (struct objfile
*objfile
)
9180 gdb_assert (!readin_p (objfile
));
9182 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9183 free_cached_comp_units
freer (per_objfile
);
9184 expand_dependencies (objfile
);
9186 dw2_do_instantiate_symtab (per_cu_data
, per_objfile
, false);
9187 gdb_assert (get_compunit_symtab (objfile
) != nullptr);
9190 /* See psympriv.h. */
9193 dwarf2_psymtab::readin_p (struct objfile
*objfile
) const
9195 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9196 return per_objfile
->symtab_set_p (per_cu_data
);
9199 /* See psympriv.h. */
9202 dwarf2_psymtab::get_compunit_symtab (struct objfile
*objfile
) const
9204 dwarf2_per_objfile
*per_objfile
= get_dwarf2_per_objfile (objfile
);
9205 return per_objfile
->get_symtab (per_cu_data
);
9208 /* Trivial hash function for die_info: the hash value of a DIE
9209 is its offset in .debug_info for this objfile. */
9212 die_hash (const void *item
)
9214 const struct die_info
*die
= (const struct die_info
*) item
;
9216 return to_underlying (die
->sect_off
);
9219 /* Trivial comparison function for die_info structures: two DIEs
9220 are equal if they have the same offset. */
9223 die_eq (const void *item_lhs
, const void *item_rhs
)
9225 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
9226 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
9228 return die_lhs
->sect_off
== die_rhs
->sect_off
;
9231 /* Load the DIEs associated with PER_CU into memory.
9233 In some cases, the caller, while reading partial symbols, will need to load
9234 the full symbols for the CU for some reason. It will already have a
9235 dwarf2_cu object for THIS_CU and pass it as EXISTING_CU, so it can be re-used
9236 rather than creating a new one. */
9239 load_full_comp_unit (dwarf2_per_cu_data
*this_cu
,
9240 dwarf2_per_objfile
*per_objfile
,
9241 dwarf2_cu
*existing_cu
,
9243 enum language pretend_language
)
9245 gdb_assert (! this_cu
->is_debug_types
);
9247 cutu_reader
reader (this_cu
, per_objfile
, NULL
, existing_cu
, skip_partial
);
9251 struct dwarf2_cu
*cu
= reader
.cu
;
9252 const gdb_byte
*info_ptr
= reader
.info_ptr
;
9254 gdb_assert (cu
->die_hash
== NULL
);
9256 htab_create_alloc_ex (cu
->header
.length
/ 12,
9260 &cu
->comp_unit_obstack
,
9261 hashtab_obstack_allocate
,
9262 dummy_obstack_deallocate
);
9264 if (reader
.comp_unit_die
->has_children
)
9265 reader
.comp_unit_die
->child
9266 = read_die_and_siblings (&reader
, reader
.info_ptr
,
9267 &info_ptr
, reader
.comp_unit_die
);
9268 cu
->dies
= reader
.comp_unit_die
;
9269 /* comp_unit_die is not stored in die_hash, no need. */
9271 /* We try not to read any attributes in this function, because not
9272 all CUs needed for references have been loaded yet, and symbol
9273 table processing isn't initialized. But we have to set the CU language,
9274 or we won't be able to build types correctly.
9275 Similarly, if we do not read the producer, we can not apply
9276 producer-specific interpretation. */
9277 prepare_one_comp_unit (cu
, cu
->dies
, pretend_language
);
9282 /* Add a DIE to the delayed physname list. */
9285 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
9286 const char *name
, struct die_info
*die
,
9287 struct dwarf2_cu
*cu
)
9289 struct delayed_method_info mi
;
9291 mi
.fnfield_index
= fnfield_index
;
9295 cu
->method_list
.push_back (mi
);
9298 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9299 "const" / "volatile". If so, decrements LEN by the length of the
9300 modifier and return true. Otherwise return false. */
9304 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
9306 size_t mod_len
= sizeof (mod
) - 1;
9307 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
9315 /* Compute the physnames of any methods on the CU's method list.
9317 The computation of method physnames is delayed in order to avoid the
9318 (bad) condition that one of the method's formal parameters is of an as yet
9322 compute_delayed_physnames (struct dwarf2_cu
*cu
)
9324 /* Only C++ delays computing physnames. */
9325 if (cu
->method_list
.empty ())
9327 gdb_assert (cu
->language
== language_cplus
);
9329 for (const delayed_method_info
&mi
: cu
->method_list
)
9331 const char *physname
;
9332 struct fn_fieldlist
*fn_flp
9333 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
9334 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
9335 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
9336 = physname
? physname
: "";
9338 /* Since there's no tag to indicate whether a method is a
9339 const/volatile overload, extract that information out of the
9341 if (physname
!= NULL
)
9343 size_t len
= strlen (physname
);
9347 if (physname
[len
] == ')') /* shortcut */
9349 else if (check_modifier (physname
, len
, " const"))
9350 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
9351 else if (check_modifier (physname
, len
, " volatile"))
9352 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
9359 /* The list is no longer needed. */
9360 cu
->method_list
.clear ();
9363 /* Go objects should be embedded in a DW_TAG_module DIE,
9364 and it's not clear if/how imported objects will appear.
9365 To keep Go support simple until that's worked out,
9366 go back through what we've read and create something usable.
9367 We could do this while processing each DIE, and feels kinda cleaner,
9368 but that way is more invasive.
9369 This is to, for example, allow the user to type "p var" or "b main"
9370 without having to specify the package name, and allow lookups
9371 of module.object to work in contexts that use the expression
9375 fixup_go_packaging (struct dwarf2_cu
*cu
)
9377 gdb::unique_xmalloc_ptr
<char> package_name
;
9378 struct pending
*list
;
9381 for (list
= *cu
->get_builder ()->get_global_symbols ();
9385 for (i
= 0; i
< list
->nsyms
; ++i
)
9387 struct symbol
*sym
= list
->symbol
[i
];
9389 if (sym
->language () == language_go
9390 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
9392 gdb::unique_xmalloc_ptr
<char> this_package_name
9393 (go_symbol_package_name (sym
));
9395 if (this_package_name
== NULL
)
9397 if (package_name
== NULL
)
9398 package_name
= std::move (this_package_name
);
9401 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9402 if (strcmp (package_name
.get (), this_package_name
.get ()) != 0)
9403 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9404 (symbol_symtab (sym
) != NULL
9405 ? symtab_to_filename_for_display
9406 (symbol_symtab (sym
))
9407 : objfile_name (objfile
)),
9408 this_package_name
.get (), package_name
.get ());
9414 if (package_name
!= NULL
)
9416 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
9417 const char *saved_package_name
= objfile
->intern (package_name
.get ());
9418 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9419 saved_package_name
);
9422 sym
= new (&objfile
->objfile_obstack
) symbol
;
9423 sym
->set_language (language_go
, &objfile
->objfile_obstack
);
9424 sym
->compute_and_set_names (saved_package_name
, false, objfile
->per_bfd
);
9425 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9426 e.g., "main" finds the "main" module and not C's main(). */
9427 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9428 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9429 SYMBOL_TYPE (sym
) = type
;
9431 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
9435 /* Allocate a fully-qualified name consisting of the two parts on the
9439 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
9441 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
9444 /* A helper that allocates a variant part to attach to a Rust enum
9445 type. OBSTACK is where the results should be allocated. TYPE is
9446 the type we're processing. DISCRIMINANT_INDEX is the index of the
9447 discriminant. It must be the index of one of the fields of TYPE,
9448 or -1 to mean there is no discriminant (univariant enum).
9449 DEFAULT_INDEX is the index of the default field; or -1 if there is
9450 no default. RANGES is indexed by "effective" field number (the
9451 field index, but omitting the discriminant and default fields) and
9452 must hold the discriminant values used by the variants. Note that
9453 RANGES must have a lifetime at least as long as OBSTACK -- either
9454 already allocated on it, or static. */
9457 alloc_rust_variant (struct obstack
*obstack
, struct type
*type
,
9458 int discriminant_index
, int default_index
,
9459 gdb::array_view
<discriminant_range
> ranges
)
9461 /* When DISCRIMINANT_INDEX == -1, we have a univariant enum. */
9462 gdb_assert (discriminant_index
== -1
9463 || (discriminant_index
>= 0
9464 && discriminant_index
< type
->num_fields ()));
9465 gdb_assert (default_index
== -1
9466 || (default_index
>= 0 && default_index
< type
->num_fields ()));
9468 /* We have one variant for each non-discriminant field. */
9469 int n_variants
= type
->num_fields ();
9470 if (discriminant_index
!= -1)
9473 variant
*variants
= new (obstack
) variant
[n_variants
];
9476 for (int i
= 0; i
< type
->num_fields (); ++i
)
9478 if (i
== discriminant_index
)
9481 variants
[var_idx
].first_field
= i
;
9482 variants
[var_idx
].last_field
= i
+ 1;
9484 /* The default field does not need a range, but other fields do.
9485 We skipped the discriminant above. */
9486 if (i
!= default_index
)
9488 variants
[var_idx
].discriminants
= ranges
.slice (range_idx
, 1);
9495 gdb_assert (range_idx
== ranges
.size ());
9496 gdb_assert (var_idx
== n_variants
);
9498 variant_part
*part
= new (obstack
) variant_part
;
9499 part
->discriminant_index
= discriminant_index
;
9500 /* If there is no discriminant, then whether it is signed is of no
9503 = (discriminant_index
== -1
9505 : type
->field (discriminant_index
).type ()->is_unsigned ());
9506 part
->variants
= gdb::array_view
<variant
> (variants
, n_variants
);
9508 void *storage
= obstack_alloc (obstack
, sizeof (gdb::array_view
<variant_part
>));
9509 gdb::array_view
<variant_part
> *prop_value
9510 = new (storage
) gdb::array_view
<variant_part
> (part
, 1);
9512 struct dynamic_prop prop
;
9513 prop
.set_variant_parts (prop_value
);
9515 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
9518 /* Some versions of rustc emitted enums in an unusual way.
9520 Ordinary enums were emitted as unions. The first element of each
9521 structure in the union was named "RUST$ENUM$DISR". This element
9522 held the discriminant.
9524 These versions of Rust also implemented the "non-zero"
9525 optimization. When the enum had two values, and one is empty and
9526 the other holds a pointer that cannot be zero, the pointer is used
9527 as the discriminant, with a zero value meaning the empty variant.
9528 Here, the union's first member is of the form
9529 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9530 where the fieldnos are the indices of the fields that should be
9531 traversed in order to find the field (which may be several fields deep)
9532 and the variantname is the name of the variant of the case when the
9535 This function recognizes whether TYPE is of one of these forms,
9536 and, if so, smashes it to be a variant type. */
9539 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
9541 gdb_assert (type
->code () == TYPE_CODE_UNION
);
9543 /* We don't need to deal with empty enums. */
9544 if (type
->num_fields () == 0)
9547 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9548 if (type
->num_fields () == 1
9549 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
9551 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
9553 /* Decode the field name to find the offset of the
9555 ULONGEST bit_offset
= 0;
9556 struct type
*field_type
= type
->field (0).type ();
9557 while (name
[0] >= '0' && name
[0] <= '9')
9560 unsigned long index
= strtoul (name
, &tail
, 10);
9563 || index
>= field_type
->num_fields ()
9564 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
9565 != FIELD_LOC_KIND_BITPOS
))
9567 complaint (_("Could not parse Rust enum encoding string \"%s\""
9569 TYPE_FIELD_NAME (type
, 0),
9570 objfile_name (objfile
));
9575 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
9576 field_type
= field_type
->field (index
).type ();
9579 /* Smash this type to be a structure type. We have to do this
9580 because the type has already been recorded. */
9581 type
->set_code (TYPE_CODE_STRUCT
);
9582 type
->set_num_fields (3);
9583 /* Save the field we care about. */
9584 struct field saved_field
= type
->field (0);
9586 ((struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
)));
9588 /* Put the discriminant at index 0. */
9589 type
->field (0).set_type (field_type
);
9590 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9591 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9592 SET_FIELD_BITPOS (type
->field (0), bit_offset
);
9594 /* The order of fields doesn't really matter, so put the real
9595 field at index 1 and the data-less field at index 2. */
9596 type
->field (1) = saved_field
;
9597 TYPE_FIELD_NAME (type
, 1)
9598 = rust_last_path_segment (type
->field (1).type ()->name ());
9599 type
->field (1).type ()->set_name
9600 (rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9601 TYPE_FIELD_NAME (type
, 1)));
9603 const char *dataless_name
9604 = rust_fully_qualify (&objfile
->objfile_obstack
, type
->name (),
9606 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
9608 type
->field (2).set_type (dataless_type
);
9609 /* NAME points into the original discriminant name, which
9610 already has the correct lifetime. */
9611 TYPE_FIELD_NAME (type
, 2) = name
;
9612 SET_FIELD_BITPOS (type
->field (2), 0);
9614 /* Indicate that this is a variant type. */
9615 static discriminant_range ranges
[1] = { { 0, 0 } };
9616 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, 1, ranges
);
9618 /* A union with a single anonymous field is probably an old-style
9620 else if (type
->num_fields () == 1 && streq (TYPE_FIELD_NAME (type
, 0), ""))
9622 /* Smash this type to be a structure type. We have to do this
9623 because the type has already been recorded. */
9624 type
->set_code (TYPE_CODE_STRUCT
);
9626 struct type
*field_type
= type
->field (0).type ();
9627 const char *variant_name
9628 = rust_last_path_segment (field_type
->name ());
9629 TYPE_FIELD_NAME (type
, 0) = variant_name
;
9630 field_type
->set_name
9631 (rust_fully_qualify (&objfile
->objfile_obstack
,
9632 type
->name (), variant_name
));
9634 alloc_rust_variant (&objfile
->objfile_obstack
, type
, -1, 0, {});
9638 struct type
*disr_type
= nullptr;
9639 for (int i
= 0; i
< type
->num_fields (); ++i
)
9641 disr_type
= type
->field (i
).type ();
9643 if (disr_type
->code () != TYPE_CODE_STRUCT
)
9645 /* All fields of a true enum will be structs. */
9648 else if (disr_type
->num_fields () == 0)
9650 /* Could be data-less variant, so keep going. */
9651 disr_type
= nullptr;
9653 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
9654 "RUST$ENUM$DISR") != 0)
9656 /* Not a Rust enum. */
9666 /* If we got here without a discriminant, then it's probably
9668 if (disr_type
== nullptr)
9671 /* Smash this type to be a structure type. We have to do this
9672 because the type has already been recorded. */
9673 type
->set_code (TYPE_CODE_STRUCT
);
9675 /* Make space for the discriminant field. */
9676 struct field
*disr_field
= &disr_type
->field (0);
9678 = (struct field
*) TYPE_ZALLOC (type
, ((type
->num_fields () + 1)
9679 * sizeof (struct field
)));
9680 memcpy (new_fields
+ 1, type
->fields (),
9681 type
->num_fields () * sizeof (struct field
));
9682 type
->set_fields (new_fields
);
9683 type
->set_num_fields (type
->num_fields () + 1);
9685 /* Install the discriminant at index 0 in the union. */
9686 type
->field (0) = *disr_field
;
9687 TYPE_FIELD_ARTIFICIAL (type
, 0) = 1;
9688 TYPE_FIELD_NAME (type
, 0) = "<<discriminant>>";
9690 /* We need a way to find the correct discriminant given a
9691 variant name. For convenience we build a map here. */
9692 struct type
*enum_type
= disr_field
->type ();
9693 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
9694 for (int i
= 0; i
< enum_type
->num_fields (); ++i
)
9696 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
9699 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
9700 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
9704 int n_fields
= type
->num_fields ();
9705 /* We don't need a range entry for the discriminant, but we do
9706 need one for every other field, as there is no default
9708 discriminant_range
*ranges
= XOBNEWVEC (&objfile
->objfile_obstack
,
9711 /* Skip the discriminant here. */
9712 for (int i
= 1; i
< n_fields
; ++i
)
9714 /* Find the final word in the name of this variant's type.
9715 That name can be used to look up the correct
9717 const char *variant_name
9718 = rust_last_path_segment (type
->field (i
).type ()->name ());
9720 auto iter
= discriminant_map
.find (variant_name
);
9721 if (iter
!= discriminant_map
.end ())
9723 ranges
[i
- 1].low
= iter
->second
;
9724 ranges
[i
- 1].high
= iter
->second
;
9727 /* In Rust, each element should have the size of the
9729 TYPE_LENGTH (type
->field (i
).type ()) = TYPE_LENGTH (type
);
9731 /* Remove the discriminant field, if it exists. */
9732 struct type
*sub_type
= type
->field (i
).type ();
9733 if (sub_type
->num_fields () > 0)
9735 sub_type
->set_num_fields (sub_type
->num_fields () - 1);
9736 sub_type
->set_fields (sub_type
->fields () + 1);
9738 TYPE_FIELD_NAME (type
, i
) = variant_name
;
9740 (rust_fully_qualify (&objfile
->objfile_obstack
,
9741 type
->name (), variant_name
));
9744 /* Indicate that this is a variant type. */
9745 alloc_rust_variant (&objfile
->objfile_obstack
, type
, 0, -1,
9746 gdb::array_view
<discriminant_range
> (ranges
,
9751 /* Rewrite some Rust unions to be structures with variants parts. */
9754 rust_union_quirks (struct dwarf2_cu
*cu
)
9756 gdb_assert (cu
->language
== language_rust
);
9757 for (type
*type_
: cu
->rust_unions
)
9758 quirk_rust_enum (type_
, cu
->per_objfile
->objfile
);
9759 /* We don't need this any more. */
9760 cu
->rust_unions
.clear ();
9765 type_unit_group_unshareable
*
9766 dwarf2_per_objfile::get_type_unit_group_unshareable (type_unit_group
*tu_group
)
9768 auto iter
= this->m_type_units
.find (tu_group
);
9769 if (iter
!= this->m_type_units
.end ())
9770 return iter
->second
.get ();
9772 type_unit_group_unshareable_up
uniq (new type_unit_group_unshareable
);
9773 type_unit_group_unshareable
*result
= uniq
.get ();
9774 this->m_type_units
[tu_group
] = std::move (uniq
);
9779 dwarf2_per_objfile::get_type_for_signatured_type
9780 (signatured_type
*sig_type
) const
9782 auto iter
= this->m_type_map
.find (sig_type
);
9783 if (iter
== this->m_type_map
.end ())
9786 return iter
->second
;
9789 void dwarf2_per_objfile::set_type_for_signatured_type
9790 (signatured_type
*sig_type
, struct type
*type
)
9792 gdb_assert (this->m_type_map
.find (sig_type
) == this->m_type_map
.end ());
9794 this->m_type_map
[sig_type
] = type
;
9797 /* A helper function for computing the list of all symbol tables
9798 included by PER_CU. */
9801 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
9802 htab_t all_children
, htab_t all_type_symtabs
,
9803 dwarf2_per_cu_data
*per_cu
,
9804 dwarf2_per_objfile
*per_objfile
,
9805 struct compunit_symtab
*immediate_parent
)
9807 void **slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
9810 /* This inclusion and its children have been processed. */
9816 /* Only add a CU if it has a symbol table. */
9817 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9820 /* If this is a type unit only add its symbol table if we haven't
9821 seen it yet (type unit per_cu's can share symtabs). */
9822 if (per_cu
->is_debug_types
)
9824 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
9828 result
->push_back (cust
);
9829 if (cust
->user
== NULL
)
9830 cust
->user
= immediate_parent
;
9835 result
->push_back (cust
);
9836 if (cust
->user
== NULL
)
9837 cust
->user
= immediate_parent
;
9841 if (!per_cu
->imported_symtabs_empty ())
9842 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9844 recursively_compute_inclusions (result
, all_children
,
9845 all_type_symtabs
, ptr
, per_objfile
,
9850 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
9854 compute_compunit_symtab_includes (dwarf2_per_cu_data
*per_cu
,
9855 dwarf2_per_objfile
*per_objfile
)
9857 gdb_assert (! per_cu
->is_debug_types
);
9859 if (!per_cu
->imported_symtabs_empty ())
9862 std::vector
<compunit_symtab
*> result_symtabs
;
9863 compunit_symtab
*cust
= per_objfile
->get_symtab (per_cu
);
9865 /* If we don't have a symtab, we can just skip this case. */
9869 htab_up
all_children (htab_create_alloc (1, htab_hash_pointer
,
9871 NULL
, xcalloc
, xfree
));
9872 htab_up
all_type_symtabs (htab_create_alloc (1, htab_hash_pointer
,
9874 NULL
, xcalloc
, xfree
));
9876 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
9878 recursively_compute_inclusions (&result_symtabs
, all_children
.get (),
9879 all_type_symtabs
.get (), ptr
,
9883 /* Now we have a transitive closure of all the included symtabs. */
9884 len
= result_symtabs
.size ();
9886 = XOBNEWVEC (&per_objfile
->objfile
->objfile_obstack
,
9887 struct compunit_symtab
*, len
+ 1);
9888 memcpy (cust
->includes
, result_symtabs
.data (),
9889 len
* sizeof (compunit_symtab
*));
9890 cust
->includes
[len
] = NULL
;
9894 /* Compute the 'includes' field for the symtabs of all the CUs we just
9898 process_cu_includes (dwarf2_per_objfile
*per_objfile
)
9900 for (dwarf2_per_cu_data
*iter
: per_objfile
->per_bfd
->just_read_cus
)
9902 if (! iter
->is_debug_types
)
9903 compute_compunit_symtab_includes (iter
, per_objfile
);
9906 per_objfile
->per_bfd
->just_read_cus
.clear ();
9909 /* Generate full symbol information for CU, whose DIEs have
9910 already been loaded into memory. */
9913 process_full_comp_unit (dwarf2_cu
*cu
, enum language pretend_language
)
9915 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
9916 struct objfile
*objfile
= per_objfile
->objfile
;
9917 struct gdbarch
*gdbarch
= objfile
->arch ();
9918 CORE_ADDR lowpc
, highpc
;
9919 struct compunit_symtab
*cust
;
9921 struct block
*static_block
;
9924 baseaddr
= objfile
->text_section_offset ();
9926 /* Clear the list here in case something was left over. */
9927 cu
->method_list
.clear ();
9929 cu
->language
= pretend_language
;
9930 cu
->language_defn
= language_def (cu
->language
);
9932 dwarf2_find_base_address (cu
->dies
, cu
);
9934 /* Do line number decoding in read_file_scope () */
9935 process_die (cu
->dies
, cu
);
9937 /* For now fudge the Go package. */
9938 if (cu
->language
== language_go
)
9939 fixup_go_packaging (cu
);
9941 /* Now that we have processed all the DIEs in the CU, all the types
9942 should be complete, and it should now be safe to compute all of the
9944 compute_delayed_physnames (cu
);
9946 if (cu
->language
== language_rust
)
9947 rust_union_quirks (cu
);
9949 /* Some compilers don't define a DW_AT_high_pc attribute for the
9950 compilation unit. If the DW_AT_high_pc is missing, synthesize
9951 it, by scanning the DIE's below the compilation unit. */
9952 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
9954 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
9955 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
9957 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
9958 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
9959 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
9960 addrmap to help ensure it has an accurate map of pc values belonging to
9962 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
9964 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
9965 SECT_OFF_TEXT (objfile
),
9970 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
9972 /* Set symtab language to language from DW_AT_language. If the
9973 compilation is from a C file generated by language preprocessors, do
9974 not set the language if it was already deduced by start_subfile. */
9975 if (!(cu
->language
== language_c
9976 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
9977 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
9979 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
9980 produce DW_AT_location with location lists but it can be possibly
9981 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
9982 there were bugs in prologue debug info, fixed later in GCC-4.5
9983 by "unwind info for epilogues" patch (which is not directly related).
9985 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
9986 needed, it would be wrong due to missing DW_AT_producer there.
9988 Still one can confuse GDB by using non-standard GCC compilation
9989 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
9991 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
9992 cust
->locations_valid
= 1;
9994 if (gcc_4_minor
>= 5)
9995 cust
->epilogue_unwind_valid
= 1;
9997 cust
->call_site_htab
= cu
->call_site_htab
;
10000 per_objfile
->set_symtab (cu
->per_cu
, cust
);
10002 /* Push it for inclusion processing later. */
10003 per_objfile
->per_bfd
->just_read_cus
.push_back (cu
->per_cu
);
10005 /* Not needed any more. */
10006 cu
->reset_builder ();
10009 /* Generate full symbol information for type unit CU, whose DIEs have
10010 already been loaded into memory. */
10013 process_full_type_unit (dwarf2_cu
*cu
,
10014 enum language pretend_language
)
10016 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10017 struct objfile
*objfile
= per_objfile
->objfile
;
10018 struct compunit_symtab
*cust
;
10019 struct signatured_type
*sig_type
;
10021 gdb_assert (cu
->per_cu
->is_debug_types
);
10022 sig_type
= (struct signatured_type
*) cu
->per_cu
;
10024 /* Clear the list here in case something was left over. */
10025 cu
->method_list
.clear ();
10027 cu
->language
= pretend_language
;
10028 cu
->language_defn
= language_def (cu
->language
);
10030 /* The symbol tables are set up in read_type_unit_scope. */
10031 process_die (cu
->dies
, cu
);
10033 /* For now fudge the Go package. */
10034 if (cu
->language
== language_go
)
10035 fixup_go_packaging (cu
);
10037 /* Now that we have processed all the DIEs in the CU, all the types
10038 should be complete, and it should now be safe to compute all of the
10040 compute_delayed_physnames (cu
);
10042 if (cu
->language
== language_rust
)
10043 rust_union_quirks (cu
);
10045 /* TUs share symbol tables.
10046 If this is the first TU to use this symtab, complete the construction
10047 of it with end_expandable_symtab. Otherwise, complete the addition of
10048 this TU's symbols to the existing symtab. */
10049 type_unit_group_unshareable
*tug_unshare
=
10050 per_objfile
->get_type_unit_group_unshareable (sig_type
->type_unit_group
);
10051 if (tug_unshare
->compunit_symtab
== NULL
)
10053 buildsym_compunit
*builder
= cu
->get_builder ();
10054 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
10055 tug_unshare
->compunit_symtab
= cust
;
10059 /* Set symtab language to language from DW_AT_language. If the
10060 compilation is from a C file generated by language preprocessors,
10061 do not set the language if it was already deduced by
10063 if (!(cu
->language
== language_c
10064 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
10065 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10070 cu
->get_builder ()->augment_type_symtab ();
10071 cust
= tug_unshare
->compunit_symtab
;
10074 per_objfile
->set_symtab (cu
->per_cu
, cust
);
10076 /* Not needed any more. */
10077 cu
->reset_builder ();
10080 /* Process an imported unit DIE. */
10083 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10085 struct attribute
*attr
;
10087 /* For now we don't handle imported units in type units. */
10088 if (cu
->per_cu
->is_debug_types
)
10090 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10091 " supported in type units [in module %s]"),
10092 objfile_name (cu
->per_objfile
->objfile
));
10095 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10098 sect_offset sect_off
= attr
->get_ref_die_offset ();
10099 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
10100 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
10101 dwarf2_per_cu_data
*per_cu
10102 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
, per_objfile
);
10104 /* We're importing a C++ compilation unit with tag DW_TAG_compile_unit
10105 into another compilation unit, at root level. Regard this as a hint,
10107 if (die
->parent
&& die
->parent
->parent
== NULL
10108 && per_cu
->unit_type
== DW_UT_compile
10109 && per_cu
->lang
== language_cplus
)
10112 /* If necessary, add it to the queue and load its DIEs. */
10113 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
))
10114 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
10115 false, cu
->language
);
10117 cu
->per_cu
->imported_symtabs_push (per_cu
);
10121 /* RAII object that represents a process_die scope: i.e.,
10122 starts/finishes processing a DIE. */
10123 class process_die_scope
10126 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
10127 : m_die (die
), m_cu (cu
)
10129 /* We should only be processing DIEs not already in process. */
10130 gdb_assert (!m_die
->in_process
);
10131 m_die
->in_process
= true;
10134 ~process_die_scope ()
10136 m_die
->in_process
= false;
10138 /* If we're done processing the DIE for the CU that owns the line
10139 header, we don't need the line header anymore. */
10140 if (m_cu
->line_header_die_owner
== m_die
)
10142 delete m_cu
->line_header
;
10143 m_cu
->line_header
= NULL
;
10144 m_cu
->line_header_die_owner
= NULL
;
10153 /* Process a die and its children. */
10156 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10158 process_die_scope
scope (die
, cu
);
10162 case DW_TAG_padding
:
10164 case DW_TAG_compile_unit
:
10165 case DW_TAG_partial_unit
:
10166 read_file_scope (die
, cu
);
10168 case DW_TAG_type_unit
:
10169 read_type_unit_scope (die
, cu
);
10171 case DW_TAG_subprogram
:
10172 /* Nested subprograms in Fortran get a prefix. */
10173 if (cu
->language
== language_fortran
10174 && die
->parent
!= NULL
10175 && die
->parent
->tag
== DW_TAG_subprogram
)
10176 cu
->processing_has_namespace_info
= true;
10177 /* Fall through. */
10178 case DW_TAG_inlined_subroutine
:
10179 read_func_scope (die
, cu
);
10181 case DW_TAG_lexical_block
:
10182 case DW_TAG_try_block
:
10183 case DW_TAG_catch_block
:
10184 read_lexical_block_scope (die
, cu
);
10186 case DW_TAG_call_site
:
10187 case DW_TAG_GNU_call_site
:
10188 read_call_site_scope (die
, cu
);
10190 case DW_TAG_class_type
:
10191 case DW_TAG_interface_type
:
10192 case DW_TAG_structure_type
:
10193 case DW_TAG_union_type
:
10194 process_structure_scope (die
, cu
);
10196 case DW_TAG_enumeration_type
:
10197 process_enumeration_scope (die
, cu
);
10200 /* These dies have a type, but processing them does not create
10201 a symbol or recurse to process the children. Therefore we can
10202 read them on-demand through read_type_die. */
10203 case DW_TAG_subroutine_type
:
10204 case DW_TAG_set_type
:
10205 case DW_TAG_array_type
:
10206 case DW_TAG_pointer_type
:
10207 case DW_TAG_ptr_to_member_type
:
10208 case DW_TAG_reference_type
:
10209 case DW_TAG_rvalue_reference_type
:
10210 case DW_TAG_string_type
:
10213 case DW_TAG_base_type
:
10214 case DW_TAG_subrange_type
:
10215 case DW_TAG_typedef
:
10216 /* Add a typedef symbol for the type definition, if it has a
10218 new_symbol (die
, read_type_die (die
, cu
), cu
);
10220 case DW_TAG_common_block
:
10221 read_common_block (die
, cu
);
10223 case DW_TAG_common_inclusion
:
10225 case DW_TAG_namespace
:
10226 cu
->processing_has_namespace_info
= true;
10227 read_namespace (die
, cu
);
10229 case DW_TAG_module
:
10230 cu
->processing_has_namespace_info
= true;
10231 read_module (die
, cu
);
10233 case DW_TAG_imported_declaration
:
10234 cu
->processing_has_namespace_info
= true;
10235 if (read_namespace_alias (die
, cu
))
10237 /* The declaration is not a global namespace alias. */
10238 /* Fall through. */
10239 case DW_TAG_imported_module
:
10240 cu
->processing_has_namespace_info
= true;
10241 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
10242 || cu
->language
!= language_fortran
))
10243 complaint (_("Tag '%s' has unexpected children"),
10244 dwarf_tag_name (die
->tag
));
10245 read_import_statement (die
, cu
);
10248 case DW_TAG_imported_unit
:
10249 process_imported_unit_die (die
, cu
);
10252 case DW_TAG_variable
:
10253 read_variable (die
, cu
);
10257 new_symbol (die
, NULL
, cu
);
10262 /* DWARF name computation. */
10264 /* A helper function for dwarf2_compute_name which determines whether DIE
10265 needs to have the name of the scope prepended to the name listed in the
10269 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
10271 struct attribute
*attr
;
10275 case DW_TAG_namespace
:
10276 case DW_TAG_typedef
:
10277 case DW_TAG_class_type
:
10278 case DW_TAG_interface_type
:
10279 case DW_TAG_structure_type
:
10280 case DW_TAG_union_type
:
10281 case DW_TAG_enumeration_type
:
10282 case DW_TAG_enumerator
:
10283 case DW_TAG_subprogram
:
10284 case DW_TAG_inlined_subroutine
:
10285 case DW_TAG_member
:
10286 case DW_TAG_imported_declaration
:
10289 case DW_TAG_variable
:
10290 case DW_TAG_constant
:
10291 /* We only need to prefix "globally" visible variables. These include
10292 any variable marked with DW_AT_external or any variable that
10293 lives in a namespace. [Variables in anonymous namespaces
10294 require prefixing, but they are not DW_AT_external.] */
10296 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
10298 struct dwarf2_cu
*spec_cu
= cu
;
10300 return die_needs_namespace (die_specification (die
, &spec_cu
),
10304 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
10305 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
10306 && die
->parent
->tag
!= DW_TAG_module
)
10308 /* A variable in a lexical block of some kind does not need a
10309 namespace, even though in C++ such variables may be external
10310 and have a mangled name. */
10311 if (die
->parent
->tag
== DW_TAG_lexical_block
10312 || die
->parent
->tag
== DW_TAG_try_block
10313 || die
->parent
->tag
== DW_TAG_catch_block
10314 || die
->parent
->tag
== DW_TAG_subprogram
)
10323 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10324 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10325 defined for the given DIE. */
10327 static struct attribute
*
10328 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
10330 struct attribute
*attr
;
10332 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
10334 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10339 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10340 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10341 defined for the given DIE. */
10343 static const char *
10344 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10346 const char *linkage_name
;
10348 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
10349 if (linkage_name
== NULL
)
10350 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10352 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
10353 See https://github.com/rust-lang/rust/issues/32925. */
10354 if (cu
->language
== language_rust
&& linkage_name
!= NULL
10355 && strchr (linkage_name
, '{') != NULL
)
10356 linkage_name
= NULL
;
10358 return linkage_name
;
10361 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10362 compute the physname for the object, which include a method's:
10363 - formal parameters (C++),
10364 - receiver type (Go),
10366 The term "physname" is a bit confusing.
10367 For C++, for example, it is the demangled name.
10368 For Go, for example, it's the mangled name.
10370 For Ada, return the DIE's linkage name rather than the fully qualified
10371 name. PHYSNAME is ignored..
10373 The result is allocated on the objfile->per_bfd's obstack and
10376 static const char *
10377 dwarf2_compute_name (const char *name
,
10378 struct die_info
*die
, struct dwarf2_cu
*cu
,
10381 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10384 name
= dwarf2_name (die
, cu
);
10386 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10387 but otherwise compute it by typename_concat inside GDB.
10388 FIXME: Actually this is not really true, or at least not always true.
10389 It's all very confusing. compute_and_set_names doesn't try to demangle
10390 Fortran names because there is no mangling standard. So new_symbol
10391 will set the demangled name to the result of dwarf2_full_name, and it is
10392 the demangled name that GDB uses if it exists. */
10393 if (cu
->language
== language_ada
10394 || (cu
->language
== language_fortran
&& physname
))
10396 /* For Ada unit, we prefer the linkage name over the name, as
10397 the former contains the exported name, which the user expects
10398 to be able to reference. Ideally, we want the user to be able
10399 to reference this entity using either natural or linkage name,
10400 but we haven't started looking at this enhancement yet. */
10401 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10403 if (linkage_name
!= NULL
)
10404 return linkage_name
;
10407 /* These are the only languages we know how to qualify names in. */
10409 && (cu
->language
== language_cplus
10410 || cu
->language
== language_fortran
|| cu
->language
== language_d
10411 || cu
->language
== language_rust
))
10413 if (die_needs_namespace (die
, cu
))
10415 const char *prefix
;
10416 const char *canonical_name
= NULL
;
10420 prefix
= determine_prefix (die
, cu
);
10421 if (*prefix
!= '\0')
10423 gdb::unique_xmalloc_ptr
<char> prefixed_name
10424 (typename_concat (NULL
, prefix
, name
, physname
, cu
));
10426 buf
.puts (prefixed_name
.get ());
10431 /* Template parameters may be specified in the DIE's DW_AT_name, or
10432 as children with DW_TAG_template_type_param or
10433 DW_TAG_value_type_param. If the latter, add them to the name
10434 here. If the name already has template parameters, then
10435 skip this step; some versions of GCC emit both, and
10436 it is more efficient to use the pre-computed name.
10438 Something to keep in mind about this process: it is very
10439 unlikely, or in some cases downright impossible, to produce
10440 something that will match the mangled name of a function.
10441 If the definition of the function has the same debug info,
10442 we should be able to match up with it anyway. But fallbacks
10443 using the minimal symbol, for instance to find a method
10444 implemented in a stripped copy of libstdc++, will not work.
10445 If we do not have debug info for the definition, we will have to
10446 match them up some other way.
10448 When we do name matching there is a related problem with function
10449 templates; two instantiated function templates are allowed to
10450 differ only by their return types, which we do not add here. */
10452 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
10454 struct attribute
*attr
;
10455 struct die_info
*child
;
10458 die
->building_fullname
= 1;
10460 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
10464 const gdb_byte
*bytes
;
10465 struct dwarf2_locexpr_baton
*baton
;
10468 if (child
->tag
!= DW_TAG_template_type_param
10469 && child
->tag
!= DW_TAG_template_value_param
)
10480 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10483 complaint (_("template parameter missing DW_AT_type"));
10484 buf
.puts ("UNKNOWN_TYPE");
10487 type
= die_type (child
, cu
);
10489 if (child
->tag
== DW_TAG_template_type_param
)
10491 c_print_type (type
, "", &buf
, -1, 0, cu
->language
,
10492 &type_print_raw_options
);
10496 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10499 complaint (_("template parameter missing "
10500 "DW_AT_const_value"));
10501 buf
.puts ("UNKNOWN_VALUE");
10505 dwarf2_const_value_attr (attr
, type
, name
,
10506 &cu
->comp_unit_obstack
, cu
,
10507 &value
, &bytes
, &baton
);
10509 if (type
->has_no_signedness ())
10510 /* GDB prints characters as NUMBER 'CHAR'. If that's
10511 changed, this can use value_print instead. */
10512 c_printchar (value
, type
, &buf
);
10515 struct value_print_options opts
;
10518 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
10522 baton
->per_objfile
);
10523 else if (bytes
!= NULL
)
10525 v
= allocate_value (type
);
10526 memcpy (value_contents_writeable (v
), bytes
,
10527 TYPE_LENGTH (type
));
10530 v
= value_from_longest (type
, value
);
10532 /* Specify decimal so that we do not depend on
10534 get_formatted_print_options (&opts
, 'd');
10536 value_print (v
, &buf
, &opts
);
10541 die
->building_fullname
= 0;
10545 /* Close the argument list, with a space if necessary
10546 (nested templates). */
10547 if (!buf
.empty () && buf
.string ().back () == '>')
10554 /* For C++ methods, append formal parameter type
10555 information, if PHYSNAME. */
10557 if (physname
&& die
->tag
== DW_TAG_subprogram
10558 && cu
->language
== language_cplus
)
10560 struct type
*type
= read_type_die (die
, cu
);
10562 c_type_print_args (type
, &buf
, 1, cu
->language
,
10563 &type_print_raw_options
);
10565 if (cu
->language
== language_cplus
)
10567 /* Assume that an artificial first parameter is
10568 "this", but do not crash if it is not. RealView
10569 marks unnamed (and thus unused) parameters as
10570 artificial; there is no way to differentiate
10572 if (type
->num_fields () > 0
10573 && TYPE_FIELD_ARTIFICIAL (type
, 0)
10574 && type
->field (0).type ()->code () == TYPE_CODE_PTR
10575 && TYPE_CONST (TYPE_TARGET_TYPE (type
->field (0).type ())))
10576 buf
.puts (" const");
10580 const std::string
&intermediate_name
= buf
.string ();
10582 if (cu
->language
== language_cplus
)
10584 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
10587 /* If we only computed INTERMEDIATE_NAME, or if
10588 INTERMEDIATE_NAME is already canonical, then we need to
10590 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
10591 name
= objfile
->intern (intermediate_name
);
10593 name
= canonical_name
;
10600 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10601 If scope qualifiers are appropriate they will be added. The result
10602 will be allocated on the storage_obstack, or NULL if the DIE does
10603 not have a name. NAME may either be from a previous call to
10604 dwarf2_name or NULL.
10606 The output string will be canonicalized (if C++). */
10608 static const char *
10609 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10611 return dwarf2_compute_name (name
, die
, cu
, 0);
10614 /* Construct a physname for the given DIE in CU. NAME may either be
10615 from a previous call to dwarf2_name or NULL. The result will be
10616 allocated on the objfile_objstack or NULL if the DIE does not have a
10619 The output string will be canonicalized (if C++). */
10621 static const char *
10622 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10624 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10625 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
10628 /* In this case dwarf2_compute_name is just a shortcut not building anything
10630 if (!die_needs_namespace (die
, cu
))
10631 return dwarf2_compute_name (name
, die
, cu
, 1);
10633 if (cu
->language
!= language_rust
)
10634 mangled
= dw2_linkage_name (die
, cu
);
10636 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
10638 gdb::unique_xmalloc_ptr
<char> demangled
;
10639 if (mangled
!= NULL
)
10642 if (language_def (cu
->language
)->store_sym_names_in_linkage_form_p ())
10644 /* Do nothing (do not demangle the symbol name). */
10648 /* Use DMGL_RET_DROP for C++ template functions to suppress
10649 their return type. It is easier for GDB users to search
10650 for such functions as `name(params)' than `long name(params)'.
10651 In such case the minimal symbol names do not match the full
10652 symbol names but for template functions there is never a need
10653 to look up their definition from their declaration so
10654 the only disadvantage remains the minimal symbol variant
10655 `long name(params)' does not have the proper inferior type. */
10656 demangled
.reset (gdb_demangle (mangled
,
10657 (DMGL_PARAMS
| DMGL_ANSI
10658 | DMGL_RET_DROP
)));
10661 canon
= demangled
.get ();
10669 if (canon
== NULL
|| check_physname
)
10671 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
10673 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
10675 /* It may not mean a bug in GDB. The compiler could also
10676 compute DW_AT_linkage_name incorrectly. But in such case
10677 GDB would need to be bug-to-bug compatible. */
10679 complaint (_("Computed physname <%s> does not match demangled <%s> "
10680 "(from linkage <%s>) - DIE at %s [in module %s]"),
10681 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
10682 objfile_name (objfile
));
10684 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
10685 is available here - over computed PHYSNAME. It is safer
10686 against both buggy GDB and buggy compilers. */
10700 retval
= objfile
->intern (retval
);
10705 /* Inspect DIE in CU for a namespace alias. If one exists, record
10706 a new symbol for it.
10708 Returns 1 if a namespace alias was recorded, 0 otherwise. */
10711 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
10713 struct attribute
*attr
;
10715 /* If the die does not have a name, this is not a namespace
10717 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
10721 struct die_info
*d
= die
;
10722 struct dwarf2_cu
*imported_cu
= cu
;
10724 /* If the compiler has nested DW_AT_imported_declaration DIEs,
10725 keep inspecting DIEs until we hit the underlying import. */
10726 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
10727 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
10729 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
10733 d
= follow_die_ref (d
, attr
, &imported_cu
);
10734 if (d
->tag
!= DW_TAG_imported_declaration
)
10738 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
10740 complaint (_("DIE at %s has too many recursively imported "
10741 "declarations"), sect_offset_str (d
->sect_off
));
10748 sect_offset sect_off
= attr
->get_ref_die_offset ();
10750 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, cu
->per_objfile
);
10751 if (type
!= NULL
&& type
->code () == TYPE_CODE_NAMESPACE
)
10753 /* This declaration is a global namespace alias. Add
10754 a symbol for it whose type is the aliased namespace. */
10755 new_symbol (die
, type
, cu
);
10764 /* Return the using directives repository (global or local?) to use in the
10765 current context for CU.
10767 For Ada, imported declarations can materialize renamings, which *may* be
10768 global. However it is impossible (for now?) in DWARF to distinguish
10769 "external" imported declarations and "static" ones. As all imported
10770 declarations seem to be static in all other languages, make them all CU-wide
10771 global only in Ada. */
10773 static struct using_direct
**
10774 using_directives (struct dwarf2_cu
*cu
)
10776 if (cu
->language
== language_ada
10777 && cu
->get_builder ()->outermost_context_p ())
10778 return cu
->get_builder ()->get_global_using_directives ();
10780 return cu
->get_builder ()->get_local_using_directives ();
10783 /* Read the import statement specified by the given die and record it. */
10786 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
10788 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
10789 struct attribute
*import_attr
;
10790 struct die_info
*imported_die
, *child_die
;
10791 struct dwarf2_cu
*imported_cu
;
10792 const char *imported_name
;
10793 const char *imported_name_prefix
;
10794 const char *canonical_name
;
10795 const char *import_alias
;
10796 const char *imported_declaration
= NULL
;
10797 const char *import_prefix
;
10798 std::vector
<const char *> excludes
;
10800 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10801 if (import_attr
== NULL
)
10803 complaint (_("Tag '%s' has no DW_AT_import"),
10804 dwarf_tag_name (die
->tag
));
10809 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
10810 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10811 if (imported_name
== NULL
)
10813 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
10815 The import in the following code:
10829 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
10830 <52> DW_AT_decl_file : 1
10831 <53> DW_AT_decl_line : 6
10832 <54> DW_AT_import : <0x75>
10833 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
10834 <59> DW_AT_name : B
10835 <5b> DW_AT_decl_file : 1
10836 <5c> DW_AT_decl_line : 2
10837 <5d> DW_AT_type : <0x6e>
10839 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
10840 <76> DW_AT_byte_size : 4
10841 <77> DW_AT_encoding : 5 (signed)
10843 imports the wrong die ( 0x75 instead of 0x58 ).
10844 This case will be ignored until the gcc bug is fixed. */
10848 /* Figure out the local name after import. */
10849 import_alias
= dwarf2_name (die
, cu
);
10851 /* Figure out where the statement is being imported to. */
10852 import_prefix
= determine_prefix (die
, cu
);
10854 /* Figure out what the scope of the imported die is and prepend it
10855 to the name of the imported die. */
10856 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
10858 if (imported_die
->tag
!= DW_TAG_namespace
10859 && imported_die
->tag
!= DW_TAG_module
)
10861 imported_declaration
= imported_name
;
10862 canonical_name
= imported_name_prefix
;
10864 else if (strlen (imported_name_prefix
) > 0)
10865 canonical_name
= obconcat (&objfile
->objfile_obstack
,
10866 imported_name_prefix
,
10867 (cu
->language
== language_d
? "." : "::"),
10868 imported_name
, (char *) NULL
);
10870 canonical_name
= imported_name
;
10872 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
10873 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
10874 child_die
= child_die
->sibling
)
10876 /* DWARF-4: A Fortran use statement with a “rename list” may be
10877 represented by an imported module entry with an import attribute
10878 referring to the module and owned entries corresponding to those
10879 entities that are renamed as part of being imported. */
10881 if (child_die
->tag
!= DW_TAG_imported_declaration
)
10883 complaint (_("child DW_TAG_imported_declaration expected "
10884 "- DIE at %s [in module %s]"),
10885 sect_offset_str (child_die
->sect_off
),
10886 objfile_name (objfile
));
10890 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
10891 if (import_attr
== NULL
)
10893 complaint (_("Tag '%s' has no DW_AT_import"),
10894 dwarf_tag_name (child_die
->tag
));
10899 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
10901 imported_name
= dwarf2_name (imported_die
, imported_cu
);
10902 if (imported_name
== NULL
)
10904 complaint (_("child DW_TAG_imported_declaration has unknown "
10905 "imported name - DIE at %s [in module %s]"),
10906 sect_offset_str (child_die
->sect_off
),
10907 objfile_name (objfile
));
10911 excludes
.push_back (imported_name
);
10913 process_die (child_die
, cu
);
10916 add_using_directive (using_directives (cu
),
10920 imported_declaration
,
10923 &objfile
->objfile_obstack
);
10926 /* ICC<14 does not output the required DW_AT_declaration on incomplete
10927 types, but gives them a size of zero. Starting with version 14,
10928 ICC is compatible with GCC. */
10931 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
10933 if (!cu
->checked_producer
)
10934 check_producer (cu
);
10936 return cu
->producer_is_icc_lt_14
;
10939 /* ICC generates a DW_AT_type for C void functions. This was observed on
10940 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
10941 which says that void functions should not have a DW_AT_type. */
10944 producer_is_icc (struct dwarf2_cu
*cu
)
10946 if (!cu
->checked_producer
)
10947 check_producer (cu
);
10949 return cu
->producer_is_icc
;
10952 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
10953 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
10954 this, it was first present in GCC release 4.3.0. */
10957 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
10959 if (!cu
->checked_producer
)
10960 check_producer (cu
);
10962 return cu
->producer_is_gcc_lt_4_3
;
10965 static file_and_directory
10966 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
10968 file_and_directory res
;
10970 /* Find the filename. Do not use dwarf2_name here, since the filename
10971 is not a source language identifier. */
10972 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
10973 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
10975 if (res
.comp_dir
== NULL
10976 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
10977 && IS_ABSOLUTE_PATH (res
.name
))
10979 res
.comp_dir_storage
= ldirname (res
.name
);
10980 if (!res
.comp_dir_storage
.empty ())
10981 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
10983 if (res
.comp_dir
!= NULL
)
10985 /* Irix 6.2 native cc prepends <machine>.: to the compilation
10986 directory, get rid of it. */
10987 const char *cp
= strchr (res
.comp_dir
, ':');
10989 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
10990 res
.comp_dir
= cp
+ 1;
10993 if (res
.name
== NULL
)
10994 res
.name
= "<unknown>";
10999 /* Handle DW_AT_stmt_list for a compilation unit.
11000 DIE is the DW_TAG_compile_unit die for CU.
11001 COMP_DIR is the compilation directory. LOWPC is passed to
11002 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11005 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
11006 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
11008 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
11009 struct attribute
*attr
;
11010 struct line_header line_header_local
;
11011 hashval_t line_header_local_hash
;
11013 int decode_mapping
;
11015 gdb_assert (! cu
->per_cu
->is_debug_types
);
11017 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
11018 if (attr
== NULL
|| !attr
->form_is_unsigned ())
11021 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
11023 /* The line header hash table is only created if needed (it exists to
11024 prevent redundant reading of the line table for partial_units).
11025 If we're given a partial_unit, we'll need it. If we're given a
11026 compile_unit, then use the line header hash table if it's already
11027 created, but don't create one just yet. */
11029 if (per_objfile
->line_header_hash
== NULL
11030 && die
->tag
== DW_TAG_partial_unit
)
11032 per_objfile
->line_header_hash
11033 .reset (htab_create_alloc (127, line_header_hash_voidp
,
11034 line_header_eq_voidp
,
11035 free_line_header_voidp
,
11039 line_header_local
.sect_off
= line_offset
;
11040 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
11041 line_header_local_hash
= line_header_hash (&line_header_local
);
11042 if (per_objfile
->line_header_hash
!= NULL
)
11044 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
11045 &line_header_local
,
11046 line_header_local_hash
, NO_INSERT
);
11048 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11049 is not present in *SLOT (since if there is something in *SLOT then
11050 it will be for a partial_unit). */
11051 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
11053 gdb_assert (*slot
!= NULL
);
11054 cu
->line_header
= (struct line_header
*) *slot
;
11059 /* dwarf_decode_line_header does not yet provide sufficient information.
11060 We always have to call also dwarf_decode_lines for it. */
11061 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
11065 cu
->line_header
= lh
.release ();
11066 cu
->line_header_die_owner
= die
;
11068 if (per_objfile
->line_header_hash
== NULL
)
11072 slot
= htab_find_slot_with_hash (per_objfile
->line_header_hash
.get (),
11073 &line_header_local
,
11074 line_header_local_hash
, INSERT
);
11075 gdb_assert (slot
!= NULL
);
11077 if (slot
!= NULL
&& *slot
== NULL
)
11079 /* This newly decoded line number information unit will be owned
11080 by line_header_hash hash table. */
11081 *slot
= cu
->line_header
;
11082 cu
->line_header_die_owner
= NULL
;
11086 /* We cannot free any current entry in (*slot) as that struct line_header
11087 may be already used by multiple CUs. Create only temporary decoded
11088 line_header for this CU - it may happen at most once for each line
11089 number information unit. And if we're not using line_header_hash
11090 then this is what we want as well. */
11091 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
11093 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
11094 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
11099 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11102 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11104 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
11105 struct objfile
*objfile
= per_objfile
->objfile
;
11106 struct gdbarch
*gdbarch
= objfile
->arch ();
11107 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
11108 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
11109 struct attribute
*attr
;
11110 struct die_info
*child_die
;
11111 CORE_ADDR baseaddr
;
11113 prepare_one_comp_unit (cu
, die
, cu
->language
);
11114 baseaddr
= objfile
->text_section_offset ();
11116 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
11118 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11119 from finish_block. */
11120 if (lowpc
== ((CORE_ADDR
) -1))
11122 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11124 file_and_directory fnd
= find_file_and_directory (die
, cu
);
11126 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11127 standardised yet. As a workaround for the language detection we fall
11128 back to the DW_AT_producer string. */
11129 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
11130 cu
->language
= language_opencl
;
11132 /* Similar hack for Go. */
11133 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
11134 set_cu_language (DW_LANG_Go
, cu
);
11136 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
11138 /* Decode line number information if present. We do this before
11139 processing child DIEs, so that the line header table is available
11140 for DW_AT_decl_file. */
11141 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
11143 /* Process all dies in compilation unit. */
11144 if (die
->child
!= NULL
)
11146 child_die
= die
->child
;
11147 while (child_die
&& child_die
->tag
)
11149 process_die (child_die
, cu
);
11150 child_die
= child_die
->sibling
;
11154 /* Decode macro information, if present. Dwarf 2 macro information
11155 refers to information in the line number info statement program
11156 header, so we can only read it if we've read the header
11158 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
11160 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
11161 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
11163 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
11164 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11166 dwarf_decode_macros (cu
, attr
->as_unsigned (), 1);
11170 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
11171 if (attr
!= nullptr && attr
->form_is_unsigned () && cu
->line_header
)
11173 unsigned int macro_offset
= attr
->as_unsigned ();
11175 dwarf_decode_macros (cu
, macro_offset
, 0);
11181 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
11183 struct type_unit_group
*tu_group
;
11185 struct attribute
*attr
;
11187 struct signatured_type
*sig_type
;
11189 gdb_assert (per_cu
->is_debug_types
);
11190 sig_type
= (struct signatured_type
*) per_cu
;
11192 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
11194 /* If we're using .gdb_index (includes -readnow) then
11195 per_cu->type_unit_group may not have been set up yet. */
11196 if (sig_type
->type_unit_group
== NULL
)
11197 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
11198 tu_group
= sig_type
->type_unit_group
;
11200 /* If we've already processed this stmt_list there's no real need to
11201 do it again, we could fake it and just recreate the part we need
11202 (file name,index -> symtab mapping). If data shows this optimization
11203 is useful we can do it then. */
11204 type_unit_group_unshareable
*tug_unshare
11205 = per_objfile
->get_type_unit_group_unshareable (tu_group
);
11206 first_time
= tug_unshare
->compunit_symtab
== NULL
;
11208 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11211 if (attr
!= NULL
&& attr
->form_is_unsigned ())
11213 sect_offset line_offset
= (sect_offset
) attr
->as_unsigned ();
11214 lh
= dwarf_decode_line_header (line_offset
, this);
11219 start_symtab ("", NULL
, 0);
11222 gdb_assert (tug_unshare
->symtabs
== NULL
);
11223 gdb_assert (m_builder
== nullptr);
11224 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11225 m_builder
.reset (new struct buildsym_compunit
11226 (COMPUNIT_OBJFILE (cust
), "",
11227 COMPUNIT_DIRNAME (cust
),
11228 compunit_language (cust
),
11230 list_in_scope
= get_builder ()->get_file_symbols ();
11235 line_header
= lh
.release ();
11236 line_header_die_owner
= die
;
11240 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
11242 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11243 still initializing it, and our caller (a few levels up)
11244 process_full_type_unit still needs to know if this is the first
11247 tug_unshare
->symtabs
11248 = XOBNEWVEC (&COMPUNIT_OBJFILE (cust
)->objfile_obstack
,
11249 struct symtab
*, line_header
->file_names_size ());
11251 auto &file_names
= line_header
->file_names ();
11252 for (i
= 0; i
< file_names
.size (); ++i
)
11254 file_entry
&fe
= file_names
[i
];
11255 dwarf2_start_subfile (this, fe
.name
,
11256 fe
.include_dir (line_header
));
11257 buildsym_compunit
*b
= get_builder ();
11258 if (b
->get_current_subfile ()->symtab
== NULL
)
11260 /* NOTE: start_subfile will recognize when it's been
11261 passed a file it has already seen. So we can't
11262 assume there's a simple mapping from
11263 cu->line_header->file_names to subfiles, plus
11264 cu->line_header->file_names may contain dups. */
11265 b
->get_current_subfile ()->symtab
11266 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
11269 fe
.symtab
= b
->get_current_subfile ()->symtab
;
11270 tug_unshare
->symtabs
[i
] = fe
.symtab
;
11275 gdb_assert (m_builder
== nullptr);
11276 struct compunit_symtab
*cust
= tug_unshare
->compunit_symtab
;
11277 m_builder
.reset (new struct buildsym_compunit
11278 (COMPUNIT_OBJFILE (cust
), "",
11279 COMPUNIT_DIRNAME (cust
),
11280 compunit_language (cust
),
11282 list_in_scope
= get_builder ()->get_file_symbols ();
11284 auto &file_names
= line_header
->file_names ();
11285 for (i
= 0; i
< file_names
.size (); ++i
)
11287 file_entry
&fe
= file_names
[i
];
11288 fe
.symtab
= tug_unshare
->symtabs
[i
];
11292 /* The main symtab is allocated last. Type units don't have DW_AT_name
11293 so they don't have a "real" (so to speak) symtab anyway.
11294 There is later code that will assign the main symtab to all symbols
11295 that don't have one. We need to handle the case of a symbol with a
11296 missing symtab (DW_AT_decl_file) anyway. */
11299 /* Process DW_TAG_type_unit.
11300 For TUs we want to skip the first top level sibling if it's not the
11301 actual type being defined by this TU. In this case the first top
11302 level sibling is there to provide context only. */
11305 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11307 struct die_info
*child_die
;
11309 prepare_one_comp_unit (cu
, die
, language_minimal
);
11311 /* Initialize (or reinitialize) the machinery for building symtabs.
11312 We do this before processing child DIEs, so that the line header table
11313 is available for DW_AT_decl_file. */
11314 cu
->setup_type_unit_groups (die
);
11316 if (die
->child
!= NULL
)
11318 child_die
= die
->child
;
11319 while (child_die
&& child_die
->tag
)
11321 process_die (child_die
, cu
);
11322 child_die
= child_die
->sibling
;
11329 http://gcc.gnu.org/wiki/DebugFission
11330 http://gcc.gnu.org/wiki/DebugFissionDWP
11332 To simplify handling of both DWO files ("object" files with the DWARF info)
11333 and DWP files (a file with the DWOs packaged up into one file), we treat
11334 DWP files as having a collection of virtual DWO files. */
11337 hash_dwo_file (const void *item
)
11339 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
11342 hash
= htab_hash_string (dwo_file
->dwo_name
);
11343 if (dwo_file
->comp_dir
!= NULL
)
11344 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11349 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11351 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11352 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11354 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11356 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11357 return lhs
->comp_dir
== rhs
->comp_dir
;
11358 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11361 /* Allocate a hash table for DWO files. */
11364 allocate_dwo_file_hash_table ()
11366 auto delete_dwo_file
= [] (void *item
)
11368 struct dwo_file
*dwo_file
= (struct dwo_file
*) item
;
11373 return htab_up (htab_create_alloc (41,
11380 /* Lookup DWO file DWO_NAME. */
11383 lookup_dwo_file_slot (dwarf2_per_objfile
*per_objfile
,
11384 const char *dwo_name
,
11385 const char *comp_dir
)
11387 struct dwo_file find_entry
;
11390 if (per_objfile
->per_bfd
->dwo_files
== NULL
)
11391 per_objfile
->per_bfd
->dwo_files
= allocate_dwo_file_hash_table ();
11393 find_entry
.dwo_name
= dwo_name
;
11394 find_entry
.comp_dir
= comp_dir
;
11395 slot
= htab_find_slot (per_objfile
->per_bfd
->dwo_files
.get (), &find_entry
,
11402 hash_dwo_unit (const void *item
)
11404 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11406 /* This drops the top 32 bits of the id, but is ok for a hash. */
11407 return dwo_unit
->signature
;
11411 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11413 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11414 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11416 /* The signature is assumed to be unique within the DWO file.
11417 So while object file CU dwo_id's always have the value zero,
11418 that's OK, assuming each object file DWO file has only one CU,
11419 and that's the rule for now. */
11420 return lhs
->signature
== rhs
->signature
;
11423 /* Allocate a hash table for DWO CUs,TUs.
11424 There is one of these tables for each of CUs,TUs for each DWO file. */
11427 allocate_dwo_unit_table ()
11429 /* Start out with a pretty small number.
11430 Generally DWO files contain only one CU and maybe some TUs. */
11431 return htab_up (htab_create_alloc (3,
11434 NULL
, xcalloc
, xfree
));
11437 /* die_reader_func for create_dwo_cu. */
11440 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
11441 const gdb_byte
*info_ptr
,
11442 struct die_info
*comp_unit_die
,
11443 struct dwo_file
*dwo_file
,
11444 struct dwo_unit
*dwo_unit
)
11446 struct dwarf2_cu
*cu
= reader
->cu
;
11447 sect_offset sect_off
= cu
->per_cu
->sect_off
;
11448 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
11450 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
11451 if (!signature
.has_value ())
11453 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11454 " its dwo_id [in module %s]"),
11455 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
11459 dwo_unit
->dwo_file
= dwo_file
;
11460 dwo_unit
->signature
= *signature
;
11461 dwo_unit
->section
= section
;
11462 dwo_unit
->sect_off
= sect_off
;
11463 dwo_unit
->length
= cu
->per_cu
->length
;
11465 if (dwarf_read_debug
)
11466 fprintf_unfiltered (gdb_stdlog
, " offset %s, dwo_id %s\n",
11467 sect_offset_str (sect_off
),
11468 hex_string (dwo_unit
->signature
));
11471 /* Create the dwo_units for the CUs in a DWO_FILE.
11472 Note: This function processes DWO files only, not DWP files. */
11475 create_cus_hash_table (dwarf2_per_objfile
*per_objfile
,
11476 dwarf2_cu
*cu
, struct dwo_file
&dwo_file
,
11477 dwarf2_section_info
§ion
, htab_up
&cus_htab
)
11479 struct objfile
*objfile
= per_objfile
->objfile
;
11480 dwarf2_per_bfd
*per_bfd
= per_objfile
->per_bfd
;
11481 const gdb_byte
*info_ptr
, *end_ptr
;
11483 section
.read (objfile
);
11484 info_ptr
= section
.buffer
;
11486 if (info_ptr
== NULL
)
11489 if (dwarf_read_debug
)
11491 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
11492 section
.get_name (),
11493 section
.get_file_name ());
11496 end_ptr
= info_ptr
+ section
.size
;
11497 while (info_ptr
< end_ptr
)
11499 struct dwarf2_per_cu_data per_cu
;
11500 struct dwo_unit read_unit
{};
11501 struct dwo_unit
*dwo_unit
;
11503 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
11505 memset (&per_cu
, 0, sizeof (per_cu
));
11506 per_cu
.per_bfd
= per_bfd
;
11507 per_cu
.is_debug_types
= 0;
11508 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
11509 per_cu
.section
= §ion
;
11511 cutu_reader
reader (&per_cu
, per_objfile
, cu
, &dwo_file
);
11512 if (!reader
.dummy_p
)
11513 create_dwo_cu_reader (&reader
, reader
.info_ptr
, reader
.comp_unit_die
,
11514 &dwo_file
, &read_unit
);
11515 info_ptr
+= per_cu
.length
;
11517 // If the unit could not be parsed, skip it.
11518 if (read_unit
.dwo_file
== NULL
)
11521 if (cus_htab
== NULL
)
11522 cus_htab
= allocate_dwo_unit_table ();
11524 dwo_unit
= OBSTACK_ZALLOC (&per_bfd
->obstack
,
11526 *dwo_unit
= read_unit
;
11527 slot
= htab_find_slot (cus_htab
.get (), dwo_unit
, INSERT
);
11528 gdb_assert (slot
!= NULL
);
11531 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
11532 sect_offset dup_sect_off
= dup_cu
->sect_off
;
11534 complaint (_("debug cu entry at offset %s is duplicate to"
11535 " the entry at offset %s, signature %s"),
11536 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
11537 hex_string (dwo_unit
->signature
));
11539 *slot
= (void *)dwo_unit
;
11543 /* DWP file .debug_{cu,tu}_index section format:
11544 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11545 [ref: http://dwarfstd.org/doc/DWARF5.pdf, sect 7.3.5 "DWARF Package Files"]
11547 DWP Versions 1 & 2 are older, pre-standard format versions. The first
11548 officially standard DWP format was published with DWARF v5 and is called
11549 Version 5. There are no versions 3 or 4.
11553 Both index sections have the same format, and serve to map a 64-bit
11554 signature to a set of section numbers. Each section begins with a header,
11555 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11556 indexes, and a pool of 32-bit section numbers. The index sections will be
11557 aligned at 8-byte boundaries in the file.
11559 The index section header consists of:
11561 V, 32 bit version number
11563 N, 32 bit number of compilation units or type units in the index
11564 M, 32 bit number of slots in the hash table
11566 Numbers are recorded using the byte order of the application binary.
11568 The hash table begins at offset 16 in the section, and consists of an array
11569 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11570 order of the application binary). Unused slots in the hash table are 0.
11571 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11573 The parallel table begins immediately after the hash table
11574 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11575 array of 32-bit indexes (using the byte order of the application binary),
11576 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11577 table contains a 32-bit index into the pool of section numbers. For unused
11578 hash table slots, the corresponding entry in the parallel table will be 0.
11580 The pool of section numbers begins immediately following the hash table
11581 (at offset 16 + 12 * M from the beginning of the section). The pool of
11582 section numbers consists of an array of 32-bit words (using the byte order
11583 of the application binary). Each item in the array is indexed starting
11584 from 0. The hash table entry provides the index of the first section
11585 number in the set. Additional section numbers in the set follow, and the
11586 set is terminated by a 0 entry (section number 0 is not used in ELF).
11588 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
11589 section must be the first entry in the set, and the .debug_abbrev.dwo must
11590 be the second entry. Other members of the set may follow in any order.
11594 DWP Versions 2 and 5:
11596 DWP Versions 2 and 5 combine all the .debug_info, etc. sections into one,
11597 and the entries in the index tables are now offsets into these sections.
11598 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
11601 Index Section Contents:
11603 Hash Table of Signatures dwp_hash_table.hash_table
11604 Parallel Table of Indices dwp_hash_table.unit_table
11605 Table of Section Offsets dwp_hash_table.{v2|v5}.{section_ids,offsets}
11606 Table of Section Sizes dwp_hash_table.{v2|v5}.sizes
11608 The index section header consists of:
11610 V, 32 bit version number
11611 L, 32 bit number of columns in the table of section offsets
11612 N, 32 bit number of compilation units or type units in the index
11613 M, 32 bit number of slots in the hash table
11615 Numbers are recorded using the byte order of the application binary.
11617 The hash table has the same format as version 1.
11618 The parallel table of indices has the same format as version 1,
11619 except that the entries are origin-1 indices into the table of sections
11620 offsets and the table of section sizes.
11622 The table of offsets begins immediately following the parallel table
11623 (at offset 16 + 12 * M from the beginning of the section). The table is
11624 a two-dimensional array of 32-bit words (using the byte order of the
11625 application binary), with L columns and N+1 rows, in row-major order.
11626 Each row in the array is indexed starting from 0. The first row provides
11627 a key to the remaining rows: each column in this row provides an identifier
11628 for a debug section, and the offsets in the same column of subsequent rows
11629 refer to that section. The section identifiers for Version 2 are:
11631 DW_SECT_INFO 1 .debug_info.dwo
11632 DW_SECT_TYPES 2 .debug_types.dwo
11633 DW_SECT_ABBREV 3 .debug_abbrev.dwo
11634 DW_SECT_LINE 4 .debug_line.dwo
11635 DW_SECT_LOC 5 .debug_loc.dwo
11636 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
11637 DW_SECT_MACINFO 7 .debug_macinfo.dwo
11638 DW_SECT_MACRO 8 .debug_macro.dwo
11640 The section identifiers for Version 5 are:
11642 DW_SECT_INFO_V5 1 .debug_info.dwo
11643 DW_SECT_RESERVED_V5 2 --
11644 DW_SECT_ABBREV_V5 3 .debug_abbrev.dwo
11645 DW_SECT_LINE_V5 4 .debug_line.dwo
11646 DW_SECT_LOCLISTS_V5 5 .debug_loclists.dwo
11647 DW_SECT_STR_OFFSETS_V5 6 .debug_str_offsets.dwo
11648 DW_SECT_MACRO_V5 7 .debug_macro.dwo
11649 DW_SECT_RNGLISTS_V5 8 .debug_rnglists.dwo
11651 The offsets provided by the CU and TU index sections are the base offsets
11652 for the contributions made by each CU or TU to the corresponding section
11653 in the package file. Each CU and TU header contains an abbrev_offset
11654 field, used to find the abbreviations table for that CU or TU within the
11655 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
11656 be interpreted as relative to the base offset given in the index section.
11657 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
11658 should be interpreted as relative to the base offset for .debug_line.dwo,
11659 and offsets into other debug sections obtained from DWARF attributes should
11660 also be interpreted as relative to the corresponding base offset.
11662 The table of sizes begins immediately following the table of offsets.
11663 Like the table of offsets, it is a two-dimensional array of 32-bit words,
11664 with L columns and N rows, in row-major order. Each row in the array is
11665 indexed starting from 1 (row 0 is shared by the two tables).
11669 Hash table lookup is handled the same in version 1 and 2:
11671 We assume that N and M will not exceed 2^32 - 1.
11672 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
11674 Given a 64-bit compilation unit signature or a type signature S, an entry
11675 in the hash table is located as follows:
11677 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
11678 the low-order k bits all set to 1.
11680 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
11682 3) If the hash table entry at index H matches the signature, use that
11683 entry. If the hash table entry at index H is unused (all zeroes),
11684 terminate the search: the signature is not present in the table.
11686 4) Let H = (H + H') modulo M. Repeat at Step 3.
11688 Because M > N and H' and M are relatively prime, the search is guaranteed
11689 to stop at an unused slot or find the match. */
11691 /* Create a hash table to map DWO IDs to their CU/TU entry in
11692 .debug_{info,types}.dwo in DWP_FILE.
11693 Returns NULL if there isn't one.
11694 Note: This function processes DWP files only, not DWO files. */
11696 static struct dwp_hash_table
*
11697 create_dwp_hash_table (dwarf2_per_objfile
*per_objfile
,
11698 struct dwp_file
*dwp_file
, int is_debug_types
)
11700 struct objfile
*objfile
= per_objfile
->objfile
;
11701 bfd
*dbfd
= dwp_file
->dbfd
.get ();
11702 const gdb_byte
*index_ptr
, *index_end
;
11703 struct dwarf2_section_info
*index
;
11704 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
11705 struct dwp_hash_table
*htab
;
11707 if (is_debug_types
)
11708 index
= &dwp_file
->sections
.tu_index
;
11710 index
= &dwp_file
->sections
.cu_index
;
11712 if (index
->empty ())
11714 index
->read (objfile
);
11716 index_ptr
= index
->buffer
;
11717 index_end
= index_ptr
+ index
->size
;
11719 /* For Version 5, the version is really 2 bytes of data & 2 bytes of padding.
11720 For now it's safe to just read 4 bytes (particularly as it's difficult to
11721 tell if you're dealing with Version 5 before you've read the version). */
11722 version
= read_4_bytes (dbfd
, index_ptr
);
11724 if (version
== 2 || version
== 5)
11725 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
11729 nr_units
= read_4_bytes (dbfd
, index_ptr
);
11731 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
11734 if (version
!= 1 && version
!= 2 && version
!= 5)
11736 error (_("Dwarf Error: unsupported DWP file version (%s)"
11737 " [in module %s]"),
11738 pulongest (version
), dwp_file
->name
);
11740 if (nr_slots
!= (nr_slots
& -nr_slots
))
11742 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
11743 " is not power of 2 [in module %s]"),
11744 pulongest (nr_slots
), dwp_file
->name
);
11747 htab
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwp_hash_table
);
11748 htab
->version
= version
;
11749 htab
->nr_columns
= nr_columns
;
11750 htab
->nr_units
= nr_units
;
11751 htab
->nr_slots
= nr_slots
;
11752 htab
->hash_table
= index_ptr
;
11753 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
11755 /* Exit early if the table is empty. */
11756 if (nr_slots
== 0 || nr_units
== 0
11757 || (version
== 2 && nr_columns
== 0)
11758 || (version
== 5 && nr_columns
== 0))
11760 /* All must be zero. */
11761 if (nr_slots
!= 0 || nr_units
!= 0
11762 || (version
== 2 && nr_columns
!= 0)
11763 || (version
== 5 && nr_columns
!= 0))
11765 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
11766 " all zero [in modules %s]"),
11774 htab
->section_pool
.v1
.indices
=
11775 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11776 /* It's harder to decide whether the section is too small in v1.
11777 V1 is deprecated anyway so we punt. */
11779 else if (version
== 2)
11781 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11782 int *ids
= htab
->section_pool
.v2
.section_ids
;
11783 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
11784 /* Reverse map for error checking. */
11785 int ids_seen
[DW_SECT_MAX
+ 1];
11788 if (nr_columns
< 2)
11790 error (_("Dwarf Error: bad DWP hash table, too few columns"
11791 " in section table [in module %s]"),
11794 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
11796 error (_("Dwarf Error: bad DWP hash table, too many columns"
11797 " in section table [in module %s]"),
11800 memset (ids
, 255, sizeof_ids
);
11801 memset (ids_seen
, 255, sizeof (ids_seen
));
11802 for (i
= 0; i
< nr_columns
; ++i
)
11804 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11806 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
11808 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11809 " in section table [in module %s]"),
11810 id
, dwp_file
->name
);
11812 if (ids_seen
[id
] != -1)
11814 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11815 " id %d in section table [in module %s]"),
11816 id
, dwp_file
->name
);
11821 /* Must have exactly one info or types section. */
11822 if (((ids_seen
[DW_SECT_INFO
] != -1)
11823 + (ids_seen
[DW_SECT_TYPES
] != -1))
11826 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11827 " DWO info/types section [in module %s]"),
11830 /* Must have an abbrev section. */
11831 if (ids_seen
[DW_SECT_ABBREV
] == -1)
11833 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11834 " section [in module %s]"),
11837 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11838 htab
->section_pool
.v2
.sizes
=
11839 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
11840 * nr_units
* nr_columns
);
11841 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
11842 * nr_units
* nr_columns
))
11845 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11846 " [in module %s]"),
11850 else /* version == 5 */
11852 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
11853 int *ids
= htab
->section_pool
.v5
.section_ids
;
11854 size_t sizeof_ids
= sizeof (htab
->section_pool
.v5
.section_ids
);
11855 /* Reverse map for error checking. */
11856 int ids_seen
[DW_SECT_MAX_V5
+ 1];
11858 if (nr_columns
< 2)
11860 error (_("Dwarf Error: bad DWP hash table, too few columns"
11861 " in section table [in module %s]"),
11864 if (nr_columns
> MAX_NR_V5_DWO_SECTIONS
)
11866 error (_("Dwarf Error: bad DWP hash table, too many columns"
11867 " in section table [in module %s]"),
11870 memset (ids
, 255, sizeof_ids
);
11871 memset (ids_seen
, 255, sizeof (ids_seen
));
11872 for (int i
= 0; i
< nr_columns
; ++i
)
11874 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
11876 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX_V5
)
11878 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
11879 " in section table [in module %s]"),
11880 id
, dwp_file
->name
);
11882 if (ids_seen
[id
] != -1)
11884 error (_("Dwarf Error: bad DWP hash table, duplicate section"
11885 " id %d in section table [in module %s]"),
11886 id
, dwp_file
->name
);
11891 /* Must have seen an info section. */
11892 if (ids_seen
[DW_SECT_INFO_V5
] == -1)
11894 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
11895 " DWO info/types section [in module %s]"),
11898 /* Must have an abbrev section. */
11899 if (ids_seen
[DW_SECT_ABBREV_V5
] == -1)
11901 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
11902 " section [in module %s]"),
11905 htab
->section_pool
.v5
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
11906 htab
->section_pool
.v5
.sizes
11907 = htab
->section_pool
.v5
.offsets
+ (sizeof (uint32_t)
11908 * nr_units
* nr_columns
);
11909 if ((htab
->section_pool
.v5
.sizes
+ (sizeof (uint32_t)
11910 * nr_units
* nr_columns
))
11913 error (_("Dwarf Error: DWP index section is corrupt (too small)"
11914 " [in module %s]"),
11922 /* Update SECTIONS with the data from SECTP.
11924 This function is like the other "locate" section routines, but in
11925 this context the sections to read comes from the DWP V1 hash table,
11926 not the full ELF section table.
11928 The result is non-zero for success, or zero if an error was found. */
11931 locate_v1_virtual_dwo_sections (asection
*sectp
,
11932 struct virtual_v1_dwo_sections
*sections
)
11934 const struct dwop_section_names
*names
= &dwop_section_names
;
11936 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
11938 /* There can be only one. */
11939 if (sections
->abbrev
.s
.section
!= NULL
)
11941 sections
->abbrev
.s
.section
= sectp
;
11942 sections
->abbrev
.size
= bfd_section_size (sectp
);
11944 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
11945 || section_is_p (sectp
->name
, &names
->types_dwo
))
11947 /* There can be only one. */
11948 if (sections
->info_or_types
.s
.section
!= NULL
)
11950 sections
->info_or_types
.s
.section
= sectp
;
11951 sections
->info_or_types
.size
= bfd_section_size (sectp
);
11953 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
11955 /* There can be only one. */
11956 if (sections
->line
.s
.section
!= NULL
)
11958 sections
->line
.s
.section
= sectp
;
11959 sections
->line
.size
= bfd_section_size (sectp
);
11961 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
11963 /* There can be only one. */
11964 if (sections
->loc
.s
.section
!= NULL
)
11966 sections
->loc
.s
.section
= sectp
;
11967 sections
->loc
.size
= bfd_section_size (sectp
);
11969 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
11971 /* There can be only one. */
11972 if (sections
->macinfo
.s
.section
!= NULL
)
11974 sections
->macinfo
.s
.section
= sectp
;
11975 sections
->macinfo
.size
= bfd_section_size (sectp
);
11977 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
11979 /* There can be only one. */
11980 if (sections
->macro
.s
.section
!= NULL
)
11982 sections
->macro
.s
.section
= sectp
;
11983 sections
->macro
.size
= bfd_section_size (sectp
);
11985 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
11987 /* There can be only one. */
11988 if (sections
->str_offsets
.s
.section
!= NULL
)
11990 sections
->str_offsets
.s
.section
= sectp
;
11991 sections
->str_offsets
.size
= bfd_section_size (sectp
);
11995 /* No other kind of section is valid. */
12002 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12003 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12004 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12005 This is for DWP version 1 files. */
12007 static struct dwo_unit
*
12008 create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
*per_objfile
,
12009 struct dwp_file
*dwp_file
,
12010 uint32_t unit_index
,
12011 const char *comp_dir
,
12012 ULONGEST signature
, int is_debug_types
)
12014 const struct dwp_hash_table
*dwp_htab
=
12015 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12016 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12017 const char *kind
= is_debug_types
? "TU" : "CU";
12018 struct dwo_file
*dwo_file
;
12019 struct dwo_unit
*dwo_unit
;
12020 struct virtual_v1_dwo_sections sections
;
12021 void **dwo_file_slot
;
12024 gdb_assert (dwp_file
->version
== 1);
12026 if (dwarf_read_debug
)
12028 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
12030 pulongest (unit_index
), hex_string (signature
),
12034 /* Fetch the sections of this DWO unit.
12035 Put a limit on the number of sections we look for so that bad data
12036 doesn't cause us to loop forever. */
12038 #define MAX_NR_V1_DWO_SECTIONS \
12039 (1 /* .debug_info or .debug_types */ \
12040 + 1 /* .debug_abbrev */ \
12041 + 1 /* .debug_line */ \
12042 + 1 /* .debug_loc */ \
12043 + 1 /* .debug_str_offsets */ \
12044 + 1 /* .debug_macro or .debug_macinfo */ \
12045 + 1 /* trailing zero */)
12047 memset (§ions
, 0, sizeof (sections
));
12049 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
12052 uint32_t section_nr
=
12053 read_4_bytes (dbfd
,
12054 dwp_htab
->section_pool
.v1
.indices
12055 + (unit_index
+ i
) * sizeof (uint32_t));
12057 if (section_nr
== 0)
12059 if (section_nr
>= dwp_file
->num_sections
)
12061 error (_("Dwarf Error: bad DWP hash table, section number too large"
12062 " [in module %s]"),
12066 sectp
= dwp_file
->elf_sections
[section_nr
];
12067 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
12069 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12070 " [in module %s]"),
12076 || sections
.info_or_types
.empty ()
12077 || sections
.abbrev
.empty ())
12079 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12080 " [in module %s]"),
12083 if (i
== MAX_NR_V1_DWO_SECTIONS
)
12085 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12086 " [in module %s]"),
12090 /* It's easier for the rest of the code if we fake a struct dwo_file and
12091 have dwo_unit "live" in that. At least for now.
12093 The DWP file can be made up of a random collection of CUs and TUs.
12094 However, for each CU + set of TUs that came from the same original DWO
12095 file, we can combine them back into a virtual DWO file to save space
12096 (fewer struct dwo_file objects to allocate). Remember that for really
12097 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12099 std::string virtual_dwo_name
=
12100 string_printf ("virtual-dwo/%d-%d-%d-%d",
12101 sections
.abbrev
.get_id (),
12102 sections
.line
.get_id (),
12103 sections
.loc
.get_id (),
12104 sections
.str_offsets
.get_id ());
12105 /* Can we use an existing virtual DWO file? */
12106 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
12108 /* Create one if necessary. */
12109 if (*dwo_file_slot
== NULL
)
12111 if (dwarf_read_debug
)
12113 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12114 virtual_dwo_name
.c_str ());
12116 dwo_file
= new struct dwo_file
;
12117 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12118 dwo_file
->comp_dir
= comp_dir
;
12119 dwo_file
->sections
.abbrev
= sections
.abbrev
;
12120 dwo_file
->sections
.line
= sections
.line
;
12121 dwo_file
->sections
.loc
= sections
.loc
;
12122 dwo_file
->sections
.macinfo
= sections
.macinfo
;
12123 dwo_file
->sections
.macro
= sections
.macro
;
12124 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
12125 /* The "str" section is global to the entire DWP file. */
12126 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12127 /* The info or types section is assigned below to dwo_unit,
12128 there's no need to record it in dwo_file.
12129 Also, we can't simply record type sections in dwo_file because
12130 we record a pointer into the vector in dwo_unit. As we collect more
12131 types we'll grow the vector and eventually have to reallocate space
12132 for it, invalidating all copies of pointers into the previous
12134 *dwo_file_slot
= dwo_file
;
12138 if (dwarf_read_debug
)
12140 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12141 virtual_dwo_name
.c_str ());
12143 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12146 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12147 dwo_unit
->dwo_file
= dwo_file
;
12148 dwo_unit
->signature
= signature
;
12149 dwo_unit
->section
=
12150 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12151 *dwo_unit
->section
= sections
.info_or_types
;
12152 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12157 /* Subroutine of create_dwo_unit_in_dwp_v2 and create_dwo_unit_in_dwp_v5 to
12158 simplify them. Given a pointer to the containing section SECTION, and
12159 OFFSET,SIZE of the piece within that section used by a TU/CU, return a
12160 virtual section of just that piece. */
12162 static struct dwarf2_section_info
12163 create_dwp_v2_or_v5_section (dwarf2_per_objfile
*per_objfile
,
12164 struct dwarf2_section_info
*section
,
12165 bfd_size_type offset
, bfd_size_type size
)
12167 struct dwarf2_section_info result
;
12170 gdb_assert (section
!= NULL
);
12171 gdb_assert (!section
->is_virtual
);
12173 memset (&result
, 0, sizeof (result
));
12174 result
.s
.containing_section
= section
;
12175 result
.is_virtual
= true;
12180 sectp
= section
->get_bfd_section ();
12182 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12183 bounds of the real section. This is a pretty-rare event, so just
12184 flag an error (easier) instead of a warning and trying to cope. */
12186 || offset
+ size
> bfd_section_size (sectp
))
12188 error (_("Dwarf Error: Bad DWP V2 or V5 section info, doesn't fit"
12189 " in section %s [in module %s]"),
12190 sectp
? bfd_section_name (sectp
) : "<unknown>",
12191 objfile_name (per_objfile
->objfile
));
12194 result
.virtual_offset
= offset
;
12195 result
.size
= size
;
12199 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12200 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12201 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12202 This is for DWP version 2 files. */
12204 static struct dwo_unit
*
12205 create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
*per_objfile
,
12206 struct dwp_file
*dwp_file
,
12207 uint32_t unit_index
,
12208 const char *comp_dir
,
12209 ULONGEST signature
, int is_debug_types
)
12211 const struct dwp_hash_table
*dwp_htab
=
12212 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12213 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12214 const char *kind
= is_debug_types
? "TU" : "CU";
12215 struct dwo_file
*dwo_file
;
12216 struct dwo_unit
*dwo_unit
;
12217 struct virtual_v2_or_v5_dwo_sections sections
;
12218 void **dwo_file_slot
;
12221 gdb_assert (dwp_file
->version
== 2);
12223 if (dwarf_read_debug
)
12225 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
12227 pulongest (unit_index
), hex_string (signature
),
12231 /* Fetch the section offsets of this DWO unit. */
12233 memset (§ions
, 0, sizeof (sections
));
12235 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12237 uint32_t offset
= read_4_bytes (dbfd
,
12238 dwp_htab
->section_pool
.v2
.offsets
12239 + (((unit_index
- 1) * dwp_htab
->nr_columns
12241 * sizeof (uint32_t)));
12242 uint32_t size
= read_4_bytes (dbfd
,
12243 dwp_htab
->section_pool
.v2
.sizes
12244 + (((unit_index
- 1) * dwp_htab
->nr_columns
12246 * sizeof (uint32_t)));
12248 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
12251 case DW_SECT_TYPES
:
12252 sections
.info_or_types_offset
= offset
;
12253 sections
.info_or_types_size
= size
;
12255 case DW_SECT_ABBREV
:
12256 sections
.abbrev_offset
= offset
;
12257 sections
.abbrev_size
= size
;
12260 sections
.line_offset
= offset
;
12261 sections
.line_size
= size
;
12264 sections
.loc_offset
= offset
;
12265 sections
.loc_size
= size
;
12267 case DW_SECT_STR_OFFSETS
:
12268 sections
.str_offsets_offset
= offset
;
12269 sections
.str_offsets_size
= size
;
12271 case DW_SECT_MACINFO
:
12272 sections
.macinfo_offset
= offset
;
12273 sections
.macinfo_size
= size
;
12275 case DW_SECT_MACRO
:
12276 sections
.macro_offset
= offset
;
12277 sections
.macro_size
= size
;
12282 /* It's easier for the rest of the code if we fake a struct dwo_file and
12283 have dwo_unit "live" in that. At least for now.
12285 The DWP file can be made up of a random collection of CUs and TUs.
12286 However, for each CU + set of TUs that came from the same original DWO
12287 file, we can combine them back into a virtual DWO file to save space
12288 (fewer struct dwo_file objects to allocate). Remember that for really
12289 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12291 std::string virtual_dwo_name
=
12292 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12293 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12294 (long) (sections
.line_size
? sections
.line_offset
: 0),
12295 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
12296 (long) (sections
.str_offsets_size
12297 ? sections
.str_offsets_offset
: 0));
12298 /* Can we use an existing virtual DWO file? */
12299 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, virtual_dwo_name
.c_str (),
12301 /* Create one if necessary. */
12302 if (*dwo_file_slot
== NULL
)
12304 if (dwarf_read_debug
)
12306 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12307 virtual_dwo_name
.c_str ());
12309 dwo_file
= new struct dwo_file
;
12310 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12311 dwo_file
->comp_dir
= comp_dir
;
12312 dwo_file
->sections
.abbrev
=
12313 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.abbrev
,
12314 sections
.abbrev_offset
,
12315 sections
.abbrev_size
);
12316 dwo_file
->sections
.line
=
12317 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.line
,
12318 sections
.line_offset
,
12319 sections
.line_size
);
12320 dwo_file
->sections
.loc
=
12321 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.loc
,
12322 sections
.loc_offset
, sections
.loc_size
);
12323 dwo_file
->sections
.macinfo
=
12324 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macinfo
,
12325 sections
.macinfo_offset
,
12326 sections
.macinfo_size
);
12327 dwo_file
->sections
.macro
=
12328 create_dwp_v2_or_v5_section (per_objfile
, &dwp_file
->sections
.macro
,
12329 sections
.macro_offset
,
12330 sections
.macro_size
);
12331 dwo_file
->sections
.str_offsets
=
12332 create_dwp_v2_or_v5_section (per_objfile
,
12333 &dwp_file
->sections
.str_offsets
,
12334 sections
.str_offsets_offset
,
12335 sections
.str_offsets_size
);
12336 /* The "str" section is global to the entire DWP file. */
12337 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12338 /* The info or types section is assigned below to dwo_unit,
12339 there's no need to record it in dwo_file.
12340 Also, we can't simply record type sections in dwo_file because
12341 we record a pointer into the vector in dwo_unit. As we collect more
12342 types we'll grow the vector and eventually have to reallocate space
12343 for it, invalidating all copies of pointers into the previous
12345 *dwo_file_slot
= dwo_file
;
12349 if (dwarf_read_debug
)
12351 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12352 virtual_dwo_name
.c_str ());
12354 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12357 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12358 dwo_unit
->dwo_file
= dwo_file
;
12359 dwo_unit
->signature
= signature
;
12360 dwo_unit
->section
=
12361 XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12362 *dwo_unit
->section
= create_dwp_v2_or_v5_section
12365 ? &dwp_file
->sections
.types
12366 : &dwp_file
->sections
.info
,
12367 sections
.info_or_types_offset
,
12368 sections
.info_or_types_size
);
12369 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12374 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12375 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12376 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12377 This is for DWP version 5 files. */
12379 static struct dwo_unit
*
12380 create_dwo_unit_in_dwp_v5 (dwarf2_per_objfile
*per_objfile
,
12381 struct dwp_file
*dwp_file
,
12382 uint32_t unit_index
,
12383 const char *comp_dir
,
12384 ULONGEST signature
, int is_debug_types
)
12386 const struct dwp_hash_table
*dwp_htab
12387 = is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12388 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12389 const char *kind
= is_debug_types
? "TU" : "CU";
12390 struct dwo_file
*dwo_file
;
12391 struct dwo_unit
*dwo_unit
;
12392 struct virtual_v2_or_v5_dwo_sections sections
{};
12393 void **dwo_file_slot
;
12395 gdb_assert (dwp_file
->version
== 5);
12397 if (dwarf_read_debug
)
12399 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V5 file: %s\n",
12401 pulongest (unit_index
), hex_string (signature
),
12405 /* Fetch the section offsets of this DWO unit. */
12407 /* memset (§ions, 0, sizeof (sections)); */
12409 for (int i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12411 uint32_t offset
= read_4_bytes (dbfd
,
12412 dwp_htab
->section_pool
.v5
.offsets
12413 + (((unit_index
- 1)
12414 * dwp_htab
->nr_columns
12416 * sizeof (uint32_t)));
12417 uint32_t size
= read_4_bytes (dbfd
,
12418 dwp_htab
->section_pool
.v5
.sizes
12419 + (((unit_index
- 1) * dwp_htab
->nr_columns
12421 * sizeof (uint32_t)));
12423 switch (dwp_htab
->section_pool
.v5
.section_ids
[i
])
12425 case DW_SECT_ABBREV_V5
:
12426 sections
.abbrev_offset
= offset
;
12427 sections
.abbrev_size
= size
;
12429 case DW_SECT_INFO_V5
:
12430 sections
.info_or_types_offset
= offset
;
12431 sections
.info_or_types_size
= size
;
12433 case DW_SECT_LINE_V5
:
12434 sections
.line_offset
= offset
;
12435 sections
.line_size
= size
;
12437 case DW_SECT_LOCLISTS_V5
:
12438 sections
.loclists_offset
= offset
;
12439 sections
.loclists_size
= size
;
12441 case DW_SECT_MACRO_V5
:
12442 sections
.macro_offset
= offset
;
12443 sections
.macro_size
= size
;
12445 case DW_SECT_RNGLISTS_V5
:
12446 sections
.rnglists_offset
= offset
;
12447 sections
.rnglists_size
= size
;
12449 case DW_SECT_STR_OFFSETS_V5
:
12450 sections
.str_offsets_offset
= offset
;
12451 sections
.str_offsets_size
= size
;
12453 case DW_SECT_RESERVED_V5
:
12459 /* It's easier for the rest of the code if we fake a struct dwo_file and
12460 have dwo_unit "live" in that. At least for now.
12462 The DWP file can be made up of a random collection of CUs and TUs.
12463 However, for each CU + set of TUs that came from the same original DWO
12464 file, we can combine them back into a virtual DWO file to save space
12465 (fewer struct dwo_file objects to allocate). Remember that for really
12466 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12468 std::string virtual_dwo_name
=
12469 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld-%ld-%ld",
12470 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12471 (long) (sections
.line_size
? sections
.line_offset
: 0),
12472 (long) (sections
.loclists_size
? sections
.loclists_offset
: 0),
12473 (long) (sections
.str_offsets_size
12474 ? sections
.str_offsets_offset
: 0),
12475 (long) (sections
.macro_size
? sections
.macro_offset
: 0),
12476 (long) (sections
.rnglists_size
? sections
.rnglists_offset
: 0));
12477 /* Can we use an existing virtual DWO file? */
12478 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
,
12479 virtual_dwo_name
.c_str (),
12481 /* Create one if necessary. */
12482 if (*dwo_file_slot
== NULL
)
12484 if (dwarf_read_debug
)
12486 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12487 virtual_dwo_name
.c_str ());
12489 dwo_file
= new struct dwo_file
;
12490 dwo_file
->dwo_name
= per_objfile
->objfile
->intern (virtual_dwo_name
);
12491 dwo_file
->comp_dir
= comp_dir
;
12492 dwo_file
->sections
.abbrev
=
12493 create_dwp_v2_or_v5_section (per_objfile
,
12494 &dwp_file
->sections
.abbrev
,
12495 sections
.abbrev_offset
,
12496 sections
.abbrev_size
);
12497 dwo_file
->sections
.line
=
12498 create_dwp_v2_or_v5_section (per_objfile
,
12499 &dwp_file
->sections
.line
,
12500 sections
.line_offset
, sections
.line_size
);
12501 dwo_file
->sections
.macro
=
12502 create_dwp_v2_or_v5_section (per_objfile
,
12503 &dwp_file
->sections
.macro
,
12504 sections
.macro_offset
,
12505 sections
.macro_size
);
12506 dwo_file
->sections
.loclists
=
12507 create_dwp_v2_or_v5_section (per_objfile
,
12508 &dwp_file
->sections
.loclists
,
12509 sections
.loclists_offset
,
12510 sections
.loclists_size
);
12511 dwo_file
->sections
.rnglists
=
12512 create_dwp_v2_or_v5_section (per_objfile
,
12513 &dwp_file
->sections
.rnglists
,
12514 sections
.rnglists_offset
,
12515 sections
.rnglists_size
);
12516 dwo_file
->sections
.str_offsets
=
12517 create_dwp_v2_or_v5_section (per_objfile
,
12518 &dwp_file
->sections
.str_offsets
,
12519 sections
.str_offsets_offset
,
12520 sections
.str_offsets_size
);
12521 /* The "str" section is global to the entire DWP file. */
12522 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12523 /* The info or types section is assigned below to dwo_unit,
12524 there's no need to record it in dwo_file.
12525 Also, we can't simply record type sections in dwo_file because
12526 we record a pointer into the vector in dwo_unit. As we collect more
12527 types we'll grow the vector and eventually have to reallocate space
12528 for it, invalidating all copies of pointers into the previous
12530 *dwo_file_slot
= dwo_file
;
12534 if (dwarf_read_debug
)
12536 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12537 virtual_dwo_name
.c_str ());
12539 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12542 dwo_unit
= OBSTACK_ZALLOC (&per_objfile
->per_bfd
->obstack
, struct dwo_unit
);
12543 dwo_unit
->dwo_file
= dwo_file
;
12544 dwo_unit
->signature
= signature
;
12546 = XOBNEW (&per_objfile
->per_bfd
->obstack
, struct dwarf2_section_info
);
12547 *dwo_unit
->section
= create_dwp_v2_or_v5_section (per_objfile
,
12548 &dwp_file
->sections
.info
,
12549 sections
.info_or_types_offset
,
12550 sections
.info_or_types_size
);
12551 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12556 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12557 Returns NULL if the signature isn't found. */
12559 static struct dwo_unit
*
12560 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
*per_objfile
,
12561 struct dwp_file
*dwp_file
, const char *comp_dir
,
12562 ULONGEST signature
, int is_debug_types
)
12564 const struct dwp_hash_table
*dwp_htab
=
12565 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12566 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12567 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12568 uint32_t hash
= signature
& mask
;
12569 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12572 struct dwo_unit find_dwo_cu
;
12574 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12575 find_dwo_cu
.signature
= signature
;
12576 slot
= htab_find_slot (is_debug_types
12577 ? dwp_file
->loaded_tus
.get ()
12578 : dwp_file
->loaded_cus
.get (),
12579 &find_dwo_cu
, INSERT
);
12582 return (struct dwo_unit
*) *slot
;
12584 /* Use a for loop so that we don't loop forever on bad debug info. */
12585 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12587 ULONGEST signature_in_table
;
12589 signature_in_table
=
12590 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12591 if (signature_in_table
== signature
)
12593 uint32_t unit_index
=
12594 read_4_bytes (dbfd
,
12595 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12597 if (dwp_file
->version
== 1)
12599 *slot
= create_dwo_unit_in_dwp_v1 (per_objfile
, dwp_file
,
12600 unit_index
, comp_dir
,
12601 signature
, is_debug_types
);
12603 else if (dwp_file
->version
== 2)
12605 *slot
= create_dwo_unit_in_dwp_v2 (per_objfile
, dwp_file
,
12606 unit_index
, comp_dir
,
12607 signature
, is_debug_types
);
12609 else /* version == 5 */
12611 *slot
= create_dwo_unit_in_dwp_v5 (per_objfile
, dwp_file
,
12612 unit_index
, comp_dir
,
12613 signature
, is_debug_types
);
12615 return (struct dwo_unit
*) *slot
;
12617 if (signature_in_table
== 0)
12619 hash
= (hash
+ hash2
) & mask
;
12622 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12623 " [in module %s]"),
12627 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12628 Open the file specified by FILE_NAME and hand it off to BFD for
12629 preliminary analysis. Return a newly initialized bfd *, which
12630 includes a canonicalized copy of FILE_NAME.
12631 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12632 SEARCH_CWD is true if the current directory is to be searched.
12633 It will be searched before debug-file-directory.
12634 If successful, the file is added to the bfd include table of the
12635 objfile's bfd (see gdb_bfd_record_inclusion).
12636 If unable to find/open the file, return NULL.
12637 NOTE: This function is derived from symfile_bfd_open. */
12639 static gdb_bfd_ref_ptr
12640 try_open_dwop_file (dwarf2_per_objfile
*per_objfile
,
12641 const char *file_name
, int is_dwp
, int search_cwd
)
12644 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12645 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12646 to debug_file_directory. */
12647 const char *search_path
;
12648 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12650 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12653 if (*debug_file_directory
!= '\0')
12655 search_path_holder
.reset (concat (".", dirname_separator_string
,
12656 debug_file_directory
,
12658 search_path
= search_path_holder
.get ();
12664 search_path
= debug_file_directory
;
12666 openp_flags flags
= OPF_RETURN_REALPATH
;
12668 flags
|= OPF_SEARCH_IN_PATH
;
12670 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12671 desc
= openp (search_path
, flags
, file_name
,
12672 O_RDONLY
| O_BINARY
, &absolute_name
);
12676 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12678 if (sym_bfd
== NULL
)
12680 bfd_set_cacheable (sym_bfd
.get (), 1);
12682 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12685 /* Success. Record the bfd as having been included by the objfile's bfd.
12686 This is important because things like demangled_names_hash lives in the
12687 objfile's per_bfd space and may have references to things like symbol
12688 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12689 gdb_bfd_record_inclusion (per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12694 /* Try to open DWO file FILE_NAME.
12695 COMP_DIR is the DW_AT_comp_dir attribute.
12696 The result is the bfd handle of the file.
12697 If there is a problem finding or opening the file, return NULL.
12698 Upon success, the canonicalized path of the file is stored in the bfd,
12699 same as symfile_bfd_open. */
12701 static gdb_bfd_ref_ptr
12702 open_dwo_file (dwarf2_per_objfile
*per_objfile
,
12703 const char *file_name
, const char *comp_dir
)
12705 if (IS_ABSOLUTE_PATH (file_name
))
12706 return try_open_dwop_file (per_objfile
, file_name
,
12707 0 /*is_dwp*/, 0 /*search_cwd*/);
12709 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12711 if (comp_dir
!= NULL
)
12713 gdb::unique_xmalloc_ptr
<char> path_to_try
12714 (concat (comp_dir
, SLASH_STRING
, file_name
, (char *) NULL
));
12716 /* NOTE: If comp_dir is a relative path, this will also try the
12717 search path, which seems useful. */
12718 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, path_to_try
.get (),
12720 1 /*search_cwd*/));
12725 /* That didn't work, try debug-file-directory, which, despite its name,
12726 is a list of paths. */
12728 if (*debug_file_directory
== '\0')
12731 return try_open_dwop_file (per_objfile
, file_name
,
12732 0 /*is_dwp*/, 1 /*search_cwd*/);
12735 /* This function is mapped across the sections and remembers the offset and
12736 size of each of the DWO debugging sections we are interested in. */
12739 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
,
12740 dwo_sections
*dwo_sections
)
12742 const struct dwop_section_names
*names
= &dwop_section_names
;
12744 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12746 dwo_sections
->abbrev
.s
.section
= sectp
;
12747 dwo_sections
->abbrev
.size
= bfd_section_size (sectp
);
12749 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12751 dwo_sections
->info
.s
.section
= sectp
;
12752 dwo_sections
->info
.size
= bfd_section_size (sectp
);
12754 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12756 dwo_sections
->line
.s
.section
= sectp
;
12757 dwo_sections
->line
.size
= bfd_section_size (sectp
);
12759 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12761 dwo_sections
->loc
.s
.section
= sectp
;
12762 dwo_sections
->loc
.size
= bfd_section_size (sectp
);
12764 else if (section_is_p (sectp
->name
, &names
->loclists_dwo
))
12766 dwo_sections
->loclists
.s
.section
= sectp
;
12767 dwo_sections
->loclists
.size
= bfd_section_size (sectp
);
12769 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12771 dwo_sections
->macinfo
.s
.section
= sectp
;
12772 dwo_sections
->macinfo
.size
= bfd_section_size (sectp
);
12774 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12776 dwo_sections
->macro
.s
.section
= sectp
;
12777 dwo_sections
->macro
.size
= bfd_section_size (sectp
);
12779 else if (section_is_p (sectp
->name
, &names
->rnglists_dwo
))
12781 dwo_sections
->rnglists
.s
.section
= sectp
;
12782 dwo_sections
->rnglists
.size
= bfd_section_size (sectp
);
12784 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
12786 dwo_sections
->str
.s
.section
= sectp
;
12787 dwo_sections
->str
.size
= bfd_section_size (sectp
);
12789 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12791 dwo_sections
->str_offsets
.s
.section
= sectp
;
12792 dwo_sections
->str_offsets
.size
= bfd_section_size (sectp
);
12794 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
12796 struct dwarf2_section_info type_section
;
12798 memset (&type_section
, 0, sizeof (type_section
));
12799 type_section
.s
.section
= sectp
;
12800 type_section
.size
= bfd_section_size (sectp
);
12801 dwo_sections
->types
.push_back (type_section
);
12805 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12806 by PER_CU. This is for the non-DWP case.
12807 The result is NULL if DWO_NAME can't be found. */
12809 static struct dwo_file
*
12810 open_and_init_dwo_file (dwarf2_cu
*cu
, const char *dwo_name
,
12811 const char *comp_dir
)
12813 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
12815 gdb_bfd_ref_ptr dbfd
= open_dwo_file (per_objfile
, dwo_name
, comp_dir
);
12818 if (dwarf_read_debug
)
12819 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
12823 dwo_file_up
dwo_file (new struct dwo_file
);
12824 dwo_file
->dwo_name
= dwo_name
;
12825 dwo_file
->comp_dir
= comp_dir
;
12826 dwo_file
->dbfd
= std::move (dbfd
);
12828 for (asection
*sec
: gdb_bfd_sections (dwo_file
->dbfd
))
12829 dwarf2_locate_dwo_sections (dwo_file
->dbfd
.get (), sec
,
12830 &dwo_file
->sections
);
12832 create_cus_hash_table (per_objfile
, cu
, *dwo_file
, dwo_file
->sections
.info
,
12835 if (cu
->per_cu
->dwarf_version
< 5)
12837 create_debug_types_hash_table (per_objfile
, dwo_file
.get (),
12838 dwo_file
->sections
.types
, dwo_file
->tus
);
12842 create_debug_type_hash_table (per_objfile
, dwo_file
.get (),
12843 &dwo_file
->sections
.info
, dwo_file
->tus
,
12847 if (dwarf_read_debug
)
12848 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
12850 return dwo_file
.release ();
12853 /* This function is mapped across the sections and remembers the offset and
12854 size of each of the DWP debugging sections common to version 1 and 2 that
12855 we are interested in. */
12858 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
12859 dwp_file
*dwp_file
)
12861 const struct dwop_section_names
*names
= &dwop_section_names
;
12862 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12864 /* Record the ELF section number for later lookup: this is what the
12865 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12866 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12867 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12869 /* Look for specific sections that we need. */
12870 if (section_is_p (sectp
->name
, &names
->str_dwo
))
12872 dwp_file
->sections
.str
.s
.section
= sectp
;
12873 dwp_file
->sections
.str
.size
= bfd_section_size (sectp
);
12875 else if (section_is_p (sectp
->name
, &names
->cu_index
))
12877 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
12878 dwp_file
->sections
.cu_index
.size
= bfd_section_size (sectp
);
12880 else if (section_is_p (sectp
->name
, &names
->tu_index
))
12882 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
12883 dwp_file
->sections
.tu_index
.size
= bfd_section_size (sectp
);
12887 /* This function is mapped across the sections and remembers the offset and
12888 size of each of the DWP version 2 debugging sections that we are interested
12889 in. This is split into a separate function because we don't know if we
12890 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12893 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12895 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12896 const struct dwop_section_names
*names
= &dwop_section_names
;
12897 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12899 /* Record the ELF section number for later lookup: this is what the
12900 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12901 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12902 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12904 /* Look for specific sections that we need. */
12905 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12907 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12908 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12910 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12912 dwp_file
->sections
.info
.s
.section
= sectp
;
12913 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12915 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12917 dwp_file
->sections
.line
.s
.section
= sectp
;
12918 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12920 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12922 dwp_file
->sections
.loc
.s
.section
= sectp
;
12923 dwp_file
->sections
.loc
.size
= bfd_section_size (sectp
);
12925 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12927 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
12928 dwp_file
->sections
.macinfo
.size
= bfd_section_size (sectp
);
12930 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12932 dwp_file
->sections
.macro
.s
.section
= sectp
;
12933 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12935 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12937 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12938 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
12940 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
12942 dwp_file
->sections
.types
.s
.section
= sectp
;
12943 dwp_file
->sections
.types
.size
= bfd_section_size (sectp
);
12947 /* This function is mapped across the sections and remembers the offset and
12948 size of each of the DWP version 5 debugging sections that we are interested
12949 in. This is split into a separate function because we don't know if we
12950 have version 1 or 2 or 5 until we parse the cu_index/tu_index sections. */
12953 dwarf2_locate_v5_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
12955 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12956 const struct dwop_section_names
*names
= &dwop_section_names
;
12957 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12959 /* Record the ELF section number for later lookup: this is what the
12960 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12961 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12962 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12964 /* Look for specific sections that we need. */
12965 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12967 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
12968 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
12970 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12972 dwp_file
->sections
.info
.s
.section
= sectp
;
12973 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
12975 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12977 dwp_file
->sections
.line
.s
.section
= sectp
;
12978 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
12980 else if (section_is_p (sectp
->name
, &names
->loclists_dwo
))
12982 dwp_file
->sections
.loclists
.s
.section
= sectp
;
12983 dwp_file
->sections
.loclists
.size
= bfd_section_size (sectp
);
12985 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12987 dwp_file
->sections
.macro
.s
.section
= sectp
;
12988 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
12990 else if (section_is_p (sectp
->name
, &names
->rnglists_dwo
))
12992 dwp_file
->sections
.rnglists
.s
.section
= sectp
;
12993 dwp_file
->sections
.rnglists
.size
= bfd_section_size (sectp
);
12995 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12997 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
12998 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
13002 /* Hash function for dwp_file loaded CUs/TUs. */
13005 hash_dwp_loaded_cutus (const void *item
)
13007 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
13009 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13010 return dwo_unit
->signature
;
13013 /* Equality function for dwp_file loaded CUs/TUs. */
13016 eq_dwp_loaded_cutus (const void *a
, const void *b
)
13018 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
13019 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
13021 return dua
->signature
== dub
->signature
;
13024 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13027 allocate_dwp_loaded_cutus_table ()
13029 return htab_up (htab_create_alloc (3,
13030 hash_dwp_loaded_cutus
,
13031 eq_dwp_loaded_cutus
,
13032 NULL
, xcalloc
, xfree
));
13035 /* Try to open DWP file FILE_NAME.
13036 The result is the bfd handle of the file.
13037 If there is a problem finding or opening the file, return NULL.
13038 Upon success, the canonicalized path of the file is stored in the bfd,
13039 same as symfile_bfd_open. */
13041 static gdb_bfd_ref_ptr
13042 open_dwp_file (dwarf2_per_objfile
*per_objfile
, const char *file_name
)
13044 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (per_objfile
, file_name
,
13046 1 /*search_cwd*/));
13050 /* Work around upstream bug 15652.
13051 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13052 [Whether that's a "bug" is debatable, but it is getting in our way.]
13053 We have no real idea where the dwp file is, because gdb's realpath-ing
13054 of the executable's path may have discarded the needed info.
13055 [IWBN if the dwp file name was recorded in the executable, akin to
13056 .gnu_debuglink, but that doesn't exist yet.]
13057 Strip the directory from FILE_NAME and search again. */
13058 if (*debug_file_directory
!= '\0')
13060 /* Don't implicitly search the current directory here.
13061 If the user wants to search "." to handle this case,
13062 it must be added to debug-file-directory. */
13063 return try_open_dwop_file (per_objfile
, lbasename (file_name
),
13071 /* Initialize the use of the DWP file for the current objfile.
13072 By convention the name of the DWP file is ${objfile}.dwp.
13073 The result is NULL if it can't be found. */
13075 static std::unique_ptr
<struct dwp_file
>
13076 open_and_init_dwp_file (dwarf2_per_objfile
*per_objfile
)
13078 struct objfile
*objfile
= per_objfile
->objfile
;
13080 /* Try to find first .dwp for the binary file before any symbolic links
13083 /* If the objfile is a debug file, find the name of the real binary
13084 file and get the name of dwp file from there. */
13085 std::string dwp_name
;
13086 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
13088 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
13089 const char *backlink_basename
= lbasename (backlink
->original_name
);
13091 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
13094 dwp_name
= objfile
->original_name
;
13096 dwp_name
+= ".dwp";
13098 gdb_bfd_ref_ptr
dbfd (open_dwp_file (per_objfile
, dwp_name
.c_str ()));
13100 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
13102 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13103 dwp_name
= objfile_name (objfile
);
13104 dwp_name
+= ".dwp";
13105 dbfd
= open_dwp_file (per_objfile
, dwp_name
.c_str ());
13110 if (dwarf_read_debug
)
13111 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
.c_str ());
13112 return std::unique_ptr
<dwp_file
> ();
13115 const char *name
= bfd_get_filename (dbfd
.get ());
13116 std::unique_ptr
<struct dwp_file
> dwp_file
13117 (new struct dwp_file (name
, std::move (dbfd
)));
13119 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
13120 dwp_file
->elf_sections
=
13121 OBSTACK_CALLOC (&per_objfile
->per_bfd
->obstack
,
13122 dwp_file
->num_sections
, asection
*);
13124 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
13125 dwarf2_locate_common_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13128 dwp_file
->cus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 0);
13130 dwp_file
->tus
= create_dwp_hash_table (per_objfile
, dwp_file
.get (), 1);
13132 /* The DWP file version is stored in the hash table. Oh well. */
13133 if (dwp_file
->cus
&& dwp_file
->tus
13134 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
13136 /* Technically speaking, we should try to limp along, but this is
13137 pretty bizarre. We use pulongest here because that's the established
13138 portability solution (e.g, we cannot use %u for uint32_t). */
13139 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13140 " TU version %s [in DWP file %s]"),
13141 pulongest (dwp_file
->cus
->version
),
13142 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
13146 dwp_file
->version
= dwp_file
->cus
->version
;
13147 else if (dwp_file
->tus
)
13148 dwp_file
->version
= dwp_file
->tus
->version
;
13150 dwp_file
->version
= 2;
13152 for (asection
*sec
: gdb_bfd_sections (dwp_file
->dbfd
))
13154 if (dwp_file
->version
== 2)
13155 dwarf2_locate_v2_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13158 dwarf2_locate_v5_dwp_sections (dwp_file
->dbfd
.get (), sec
,
13162 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table ();
13163 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table ();
13165 if (dwarf_read_debug
)
13167 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
13168 fprintf_unfiltered (gdb_stdlog
,
13169 " %s CUs, %s TUs\n",
13170 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
13171 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
13177 /* Wrapper around open_and_init_dwp_file, only open it once. */
13179 static struct dwp_file
*
13180 get_dwp_file (dwarf2_per_objfile
*per_objfile
)
13182 if (!per_objfile
->per_bfd
->dwp_checked
)
13184 per_objfile
->per_bfd
->dwp_file
= open_and_init_dwp_file (per_objfile
);
13185 per_objfile
->per_bfd
->dwp_checked
= 1;
13187 return per_objfile
->per_bfd
->dwp_file
.get ();
13190 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13191 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13192 or in the DWP file for the objfile, referenced by THIS_UNIT.
13193 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13194 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13196 This is called, for example, when wanting to read a variable with a
13197 complex location. Therefore we don't want to do file i/o for every call.
13198 Therefore we don't want to look for a DWO file on every call.
13199 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13200 then we check if we've already seen DWO_NAME, and only THEN do we check
13203 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13204 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13206 static struct dwo_unit
*
13207 lookup_dwo_cutu (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
13208 ULONGEST signature
, int is_debug_types
)
13210 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13211 struct objfile
*objfile
= per_objfile
->objfile
;
13212 const char *kind
= is_debug_types
? "TU" : "CU";
13213 void **dwo_file_slot
;
13214 struct dwo_file
*dwo_file
;
13215 struct dwp_file
*dwp_file
;
13217 /* First see if there's a DWP file.
13218 If we have a DWP file but didn't find the DWO inside it, don't
13219 look for the original DWO file. It makes gdb behave differently
13220 depending on whether one is debugging in the build tree. */
13222 dwp_file
= get_dwp_file (per_objfile
);
13223 if (dwp_file
!= NULL
)
13225 const struct dwp_hash_table
*dwp_htab
=
13226 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
13228 if (dwp_htab
!= NULL
)
13230 struct dwo_unit
*dwo_cutu
=
13231 lookup_dwo_unit_in_dwp (per_objfile
, dwp_file
, comp_dir
, signature
,
13234 if (dwo_cutu
!= NULL
)
13236 if (dwarf_read_debug
)
13238 fprintf_unfiltered (gdb_stdlog
,
13239 "Virtual DWO %s %s found: @%s\n",
13240 kind
, hex_string (signature
),
13241 host_address_to_string (dwo_cutu
));
13249 /* No DWP file, look for the DWO file. */
13251 dwo_file_slot
= lookup_dwo_file_slot (per_objfile
, dwo_name
, comp_dir
);
13252 if (*dwo_file_slot
== NULL
)
13254 /* Read in the file and build a table of the CUs/TUs it contains. */
13255 *dwo_file_slot
= open_and_init_dwo_file (cu
, dwo_name
, comp_dir
);
13257 /* NOTE: This will be NULL if unable to open the file. */
13258 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
13260 if (dwo_file
!= NULL
)
13262 struct dwo_unit
*dwo_cutu
= NULL
;
13264 if (is_debug_types
&& dwo_file
->tus
)
13266 struct dwo_unit find_dwo_cutu
;
13268 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13269 find_dwo_cutu
.signature
= signature
;
13271 = (struct dwo_unit
*) htab_find (dwo_file
->tus
.get (),
13274 else if (!is_debug_types
&& dwo_file
->cus
)
13276 struct dwo_unit find_dwo_cutu
;
13278 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13279 find_dwo_cutu
.signature
= signature
;
13280 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
.get (),
13284 if (dwo_cutu
!= NULL
)
13286 if (dwarf_read_debug
)
13288 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
13289 kind
, dwo_name
, hex_string (signature
),
13290 host_address_to_string (dwo_cutu
));
13297 /* We didn't find it. This could mean a dwo_id mismatch, or
13298 someone deleted the DWO/DWP file, or the search path isn't set up
13299 correctly to find the file. */
13301 if (dwarf_read_debug
)
13303 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
13304 kind
, dwo_name
, hex_string (signature
));
13307 /* This is a warning and not a complaint because it can be caused by
13308 pilot error (e.g., user accidentally deleting the DWO). */
13310 /* Print the name of the DWP file if we looked there, helps the user
13311 better diagnose the problem. */
13312 std::string dwp_text
;
13314 if (dwp_file
!= NULL
)
13315 dwp_text
= string_printf (" [in DWP file %s]",
13316 lbasename (dwp_file
->name
));
13318 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13319 " [in module %s]"),
13320 kind
, dwo_name
, hex_string (signature
), dwp_text
.c_str (), kind
,
13321 sect_offset_str (cu
->per_cu
->sect_off
), objfile_name (objfile
));
13326 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13327 See lookup_dwo_cutu_unit for details. */
13329 static struct dwo_unit
*
13330 lookup_dwo_comp_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
,
13331 ULONGEST signature
)
13333 gdb_assert (!cu
->per_cu
->is_debug_types
);
13335 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, signature
, 0);
13338 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13339 See lookup_dwo_cutu_unit for details. */
13341 static struct dwo_unit
*
13342 lookup_dwo_type_unit (dwarf2_cu
*cu
, const char *dwo_name
, const char *comp_dir
)
13344 gdb_assert (cu
->per_cu
->is_debug_types
);
13346 signatured_type
*sig_type
= (signatured_type
*) cu
->per_cu
;
13348 return lookup_dwo_cutu (cu
, dwo_name
, comp_dir
, sig_type
->signature
, 1);
13351 /* Traversal function for queue_and_load_all_dwo_tus. */
13354 queue_and_load_dwo_tu (void **slot
, void *info
)
13356 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
13357 dwarf2_cu
*cu
= (dwarf2_cu
*) info
;
13358 ULONGEST signature
= dwo_unit
->signature
;
13359 signatured_type
*sig_type
= lookup_dwo_signatured_type (cu
, signature
);
13361 if (sig_type
!= NULL
)
13363 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
13365 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13366 a real dependency of PER_CU on SIG_TYPE. That is detected later
13367 while processing PER_CU. */
13368 if (maybe_queue_comp_unit (NULL
, sig_cu
, cu
->per_objfile
, cu
->language
))
13369 load_full_type_unit (sig_cu
, cu
->per_objfile
);
13370 cu
->per_cu
->imported_symtabs_push (sig_cu
);
13376 /* Queue all TUs contained in the DWO of CU to be read in.
13377 The DWO may have the only definition of the type, though it may not be
13378 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13379 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13382 queue_and_load_all_dwo_tus (dwarf2_cu
*cu
)
13384 struct dwo_unit
*dwo_unit
;
13385 struct dwo_file
*dwo_file
;
13387 gdb_assert (cu
!= nullptr);
13388 gdb_assert (!cu
->per_cu
->is_debug_types
);
13389 gdb_assert (get_dwp_file (cu
->per_objfile
) == nullptr);
13391 dwo_unit
= cu
->dwo_unit
;
13392 gdb_assert (dwo_unit
!= NULL
);
13394 dwo_file
= dwo_unit
->dwo_file
;
13395 if (dwo_file
->tus
!= NULL
)
13396 htab_traverse_noresize (dwo_file
->tus
.get (), queue_and_load_dwo_tu
, cu
);
13399 /* Read in various DIEs. */
13401 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13402 Inherit only the children of the DW_AT_abstract_origin DIE not being
13403 already referenced by DW_AT_abstract_origin from the children of the
13407 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
13409 struct die_info
*child_die
;
13410 sect_offset
*offsetp
;
13411 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13412 struct die_info
*origin_die
;
13413 /* Iterator of the ORIGIN_DIE children. */
13414 struct die_info
*origin_child_die
;
13415 struct attribute
*attr
;
13416 struct dwarf2_cu
*origin_cu
;
13417 struct pending
**origin_previous_list_in_scope
;
13419 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13423 /* Note that following die references may follow to a die in a
13427 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
13429 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13431 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
13432 origin_cu
->list_in_scope
= cu
->list_in_scope
;
13434 if (die
->tag
!= origin_die
->tag
13435 && !(die
->tag
== DW_TAG_inlined_subroutine
13436 && origin_die
->tag
== DW_TAG_subprogram
))
13437 complaint (_("DIE %s and its abstract origin %s have different tags"),
13438 sect_offset_str (die
->sect_off
),
13439 sect_offset_str (origin_die
->sect_off
));
13441 std::vector
<sect_offset
> offsets
;
13443 for (child_die
= die
->child
;
13444 child_die
&& child_die
->tag
;
13445 child_die
= child_die
->sibling
)
13447 struct die_info
*child_origin_die
;
13448 struct dwarf2_cu
*child_origin_cu
;
13450 /* We are trying to process concrete instance entries:
13451 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13452 it's not relevant to our analysis here. i.e. detecting DIEs that are
13453 present in the abstract instance but not referenced in the concrete
13455 if (child_die
->tag
== DW_TAG_call_site
13456 || child_die
->tag
== DW_TAG_GNU_call_site
)
13459 /* For each CHILD_DIE, find the corresponding child of
13460 ORIGIN_DIE. If there is more than one layer of
13461 DW_AT_abstract_origin, follow them all; there shouldn't be,
13462 but GCC versions at least through 4.4 generate this (GCC PR
13464 child_origin_die
= child_die
;
13465 child_origin_cu
= cu
;
13468 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
13472 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
13476 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13477 counterpart may exist. */
13478 if (child_origin_die
!= child_die
)
13480 if (child_die
->tag
!= child_origin_die
->tag
13481 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13482 && child_origin_die
->tag
== DW_TAG_subprogram
))
13483 complaint (_("Child DIE %s and its abstract origin %s have "
13485 sect_offset_str (child_die
->sect_off
),
13486 sect_offset_str (child_origin_die
->sect_off
));
13487 if (child_origin_die
->parent
!= origin_die
)
13488 complaint (_("Child DIE %s and its abstract origin %s have "
13489 "different parents"),
13490 sect_offset_str (child_die
->sect_off
),
13491 sect_offset_str (child_origin_die
->sect_off
));
13493 offsets
.push_back (child_origin_die
->sect_off
);
13496 std::sort (offsets
.begin (), offsets
.end ());
13497 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13498 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13499 if (offsetp
[-1] == *offsetp
)
13500 complaint (_("Multiple children of DIE %s refer "
13501 "to DIE %s as their abstract origin"),
13502 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
13504 offsetp
= offsets
.data ();
13505 origin_child_die
= origin_die
->child
;
13506 while (origin_child_die
&& origin_child_die
->tag
)
13508 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13509 while (offsetp
< offsets_end
13510 && *offsetp
< origin_child_die
->sect_off
)
13512 if (offsetp
>= offsets_end
13513 || *offsetp
> origin_child_die
->sect_off
)
13515 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13516 Check whether we're already processing ORIGIN_CHILD_DIE.
13517 This can happen with mutually referenced abstract_origins.
13519 if (!origin_child_die
->in_process
)
13520 process_die (origin_child_die
, origin_cu
);
13522 origin_child_die
= origin_child_die
->sibling
;
13524 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13526 if (cu
!= origin_cu
)
13527 compute_delayed_physnames (origin_cu
);
13531 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13533 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13534 struct gdbarch
*gdbarch
= objfile
->arch ();
13535 struct context_stack
*newobj
;
13538 struct die_info
*child_die
;
13539 struct attribute
*attr
, *call_line
, *call_file
;
13541 CORE_ADDR baseaddr
;
13542 struct block
*block
;
13543 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13544 std::vector
<struct symbol
*> template_args
;
13545 struct template_symbol
*templ_func
= NULL
;
13549 /* If we do not have call site information, we can't show the
13550 caller of this inlined function. That's too confusing, so
13551 only use the scope for local variables. */
13552 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13553 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13554 if (call_line
== NULL
|| call_file
== NULL
)
13556 read_lexical_block_scope (die
, cu
);
13561 baseaddr
= objfile
->text_section_offset ();
13563 name
= dwarf2_name (die
, cu
);
13565 /* Ignore functions with missing or empty names. These are actually
13566 illegal according to the DWARF standard. */
13569 complaint (_("missing name for subprogram DIE at %s"),
13570 sect_offset_str (die
->sect_off
));
13574 /* Ignore functions with missing or invalid low and high pc attributes. */
13575 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13576 <= PC_BOUNDS_INVALID
)
13578 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13579 if (attr
== nullptr || !attr
->as_boolean ())
13580 complaint (_("cannot get low and high bounds "
13581 "for subprogram DIE at %s"),
13582 sect_offset_str (die
->sect_off
));
13586 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13587 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13589 /* If we have any template arguments, then we must allocate a
13590 different sort of symbol. */
13591 for (child_die
= die
->child
; child_die
; child_die
= child_die
->sibling
)
13593 if (child_die
->tag
== DW_TAG_template_type_param
13594 || child_die
->tag
== DW_TAG_template_value_param
)
13596 templ_func
= new (&objfile
->objfile_obstack
) template_symbol
;
13597 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13602 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13603 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13604 (struct symbol
*) templ_func
);
13606 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13607 set_objfile_main_name (objfile
, newobj
->name
->linkage_name (),
13610 /* If there is a location expression for DW_AT_frame_base, record
13612 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13613 if (attr
!= nullptr)
13614 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13616 /* If there is a location for the static link, record it. */
13617 newobj
->static_link
= NULL
;
13618 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13619 if (attr
!= nullptr)
13621 newobj
->static_link
13622 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13623 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
13627 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13629 if (die
->child
!= NULL
)
13631 child_die
= die
->child
;
13632 while (child_die
&& child_die
->tag
)
13634 if (child_die
->tag
== DW_TAG_template_type_param
13635 || child_die
->tag
== DW_TAG_template_value_param
)
13637 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13640 template_args
.push_back (arg
);
13643 process_die (child_die
, cu
);
13644 child_die
= child_die
->sibling
;
13648 inherit_abstract_dies (die
, cu
);
13650 /* If we have a DW_AT_specification, we might need to import using
13651 directives from the context of the specification DIE. See the
13652 comment in determine_prefix. */
13653 if (cu
->language
== language_cplus
13654 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13656 struct dwarf2_cu
*spec_cu
= cu
;
13657 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13661 child_die
= spec_die
->child
;
13662 while (child_die
&& child_die
->tag
)
13664 if (child_die
->tag
== DW_TAG_imported_module
)
13665 process_die (child_die
, spec_cu
);
13666 child_die
= child_die
->sibling
;
13669 /* In some cases, GCC generates specification DIEs that
13670 themselves contain DW_AT_specification attributes. */
13671 spec_die
= die_specification (spec_die
, &spec_cu
);
13675 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13676 /* Make a block for the local symbols within. */
13677 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13678 cstk
.static_link
, lowpc
, highpc
);
13680 /* For C++, set the block's scope. */
13681 if ((cu
->language
== language_cplus
13682 || cu
->language
== language_fortran
13683 || cu
->language
== language_d
13684 || cu
->language
== language_rust
)
13685 && cu
->processing_has_namespace_info
)
13686 block_set_scope (block
, determine_prefix (die
, cu
),
13687 &objfile
->objfile_obstack
);
13689 /* If we have address ranges, record them. */
13690 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13692 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13694 /* Attach template arguments to function. */
13695 if (!template_args
.empty ())
13697 gdb_assert (templ_func
!= NULL
);
13699 templ_func
->n_template_arguments
= template_args
.size ();
13700 templ_func
->template_arguments
13701 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13702 templ_func
->n_template_arguments
);
13703 memcpy (templ_func
->template_arguments
,
13704 template_args
.data (),
13705 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13707 /* Make sure that the symtab is set on the new symbols. Even
13708 though they don't appear in this symtab directly, other parts
13709 of gdb assume that symbols do, and this is reasonably
13711 for (symbol
*sym
: template_args
)
13712 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13715 /* In C++, we can have functions nested inside functions (e.g., when
13716 a function declares a class that has methods). This means that
13717 when we finish processing a function scope, we may need to go
13718 back to building a containing block's symbol lists. */
13719 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13720 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13722 /* If we've finished processing a top-level function, subsequent
13723 symbols go in the file symbol list. */
13724 if (cu
->get_builder ()->outermost_context_p ())
13725 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13728 /* Process all the DIES contained within a lexical block scope. Start
13729 a new scope, process the dies, and then close the scope. */
13732 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13734 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
13735 struct gdbarch
*gdbarch
= objfile
->arch ();
13736 CORE_ADDR lowpc
, highpc
;
13737 struct die_info
*child_die
;
13738 CORE_ADDR baseaddr
;
13740 baseaddr
= objfile
->text_section_offset ();
13742 /* Ignore blocks with missing or invalid low and high pc attributes. */
13743 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13744 as multiple lexical blocks? Handling children in a sane way would
13745 be nasty. Might be easier to properly extend generic blocks to
13746 describe ranges. */
13747 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13749 case PC_BOUNDS_NOT_PRESENT
:
13750 /* DW_TAG_lexical_block has no attributes, process its children as if
13751 there was no wrapping by that DW_TAG_lexical_block.
13752 GCC does no longer produces such DWARF since GCC r224161. */
13753 for (child_die
= die
->child
;
13754 child_die
!= NULL
&& child_die
->tag
;
13755 child_die
= child_die
->sibling
)
13757 /* We might already be processing this DIE. This can happen
13758 in an unusual circumstance -- where a subroutine A
13759 appears lexically in another subroutine B, but A actually
13760 inlines B. The recursion is broken here, rather than in
13761 inherit_abstract_dies, because it seems better to simply
13762 drop concrete children here. */
13763 if (!child_die
->in_process
)
13764 process_die (child_die
, cu
);
13767 case PC_BOUNDS_INVALID
:
13770 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13771 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13773 cu
->get_builder ()->push_context (0, lowpc
);
13774 if (die
->child
!= NULL
)
13776 child_die
= die
->child
;
13777 while (child_die
&& child_die
->tag
)
13779 process_die (child_die
, cu
);
13780 child_die
= child_die
->sibling
;
13783 inherit_abstract_dies (die
, cu
);
13784 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13786 if (*cu
->get_builder ()->get_local_symbols () != NULL
13787 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13789 struct block
*block
13790 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13791 cstk
.start_addr
, highpc
);
13793 /* Note that recording ranges after traversing children, as we
13794 do here, means that recording a parent's ranges entails
13795 walking across all its children's ranges as they appear in
13796 the address map, which is quadratic behavior.
13798 It would be nicer to record the parent's ranges before
13799 traversing its children, simply overriding whatever you find
13800 there. But since we don't even decide whether to create a
13801 block until after we've traversed its children, that's hard
13803 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13805 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13806 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13809 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13812 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13814 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
13815 struct objfile
*objfile
= per_objfile
->objfile
;
13816 struct gdbarch
*gdbarch
= objfile
->arch ();
13817 CORE_ADDR pc
, baseaddr
;
13818 struct attribute
*attr
;
13819 struct call_site
*call_site
, call_site_local
;
13822 struct die_info
*child_die
;
13824 baseaddr
= objfile
->text_section_offset ();
13826 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13829 /* This was a pre-DWARF-5 GNU extension alias
13830 for DW_AT_call_return_pc. */
13831 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13835 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13836 "DIE %s [in module %s]"),
13837 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13840 pc
= attr
->as_address () + baseaddr
;
13841 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13843 if (cu
->call_site_htab
== NULL
)
13844 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13845 NULL
, &objfile
->objfile_obstack
,
13846 hashtab_obstack_allocate
, NULL
);
13847 call_site_local
.pc
= pc
;
13848 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13851 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13852 "DIE %s [in module %s]"),
13853 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13854 objfile_name (objfile
));
13858 /* Count parameters at the caller. */
13861 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13862 child_die
= child_die
->sibling
)
13864 if (child_die
->tag
!= DW_TAG_call_site_parameter
13865 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13867 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13868 "DW_TAG_call_site child DIE %s [in module %s]"),
13869 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
13870 objfile_name (objfile
));
13878 = ((struct call_site
*)
13879 obstack_alloc (&objfile
->objfile_obstack
,
13880 sizeof (*call_site
)
13881 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
13883 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
13884 call_site
->pc
= pc
;
13886 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
13887 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
13889 struct die_info
*func_die
;
13891 /* Skip also over DW_TAG_inlined_subroutine. */
13892 for (func_die
= die
->parent
;
13893 func_die
&& func_die
->tag
!= DW_TAG_subprogram
13894 && func_die
->tag
!= DW_TAG_subroutine_type
;
13895 func_die
= func_die
->parent
);
13897 /* DW_AT_call_all_calls is a superset
13898 of DW_AT_call_all_tail_calls. */
13900 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
13901 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
13902 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
13903 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
13905 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13906 not complete. But keep CALL_SITE for look ups via call_site_htab,
13907 both the initial caller containing the real return address PC and
13908 the final callee containing the current PC of a chain of tail
13909 calls do not need to have the tail call list complete. But any
13910 function candidate for a virtual tail call frame searched via
13911 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13912 determined unambiguously. */
13916 struct type
*func_type
= NULL
;
13919 func_type
= get_die_type (func_die
, cu
);
13920 if (func_type
!= NULL
)
13922 gdb_assert (func_type
->code () == TYPE_CODE_FUNC
);
13924 /* Enlist this call site to the function. */
13925 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
13926 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
13929 complaint (_("Cannot find function owning DW_TAG_call_site "
13930 "DIE %s [in module %s]"),
13931 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13935 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
13937 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
13939 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
13942 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
13943 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13945 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
13946 if (!attr
|| (attr
->form_is_block () && attr
->as_block ()->size
== 0))
13947 /* Keep NULL DWARF_BLOCK. */;
13948 else if (attr
->form_is_block ())
13950 struct dwarf2_locexpr_baton
*dlbaton
;
13951 struct dwarf_block
*block
= attr
->as_block ();
13953 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
13954 dlbaton
->data
= block
->data
;
13955 dlbaton
->size
= block
->size
;
13956 dlbaton
->per_objfile
= per_objfile
;
13957 dlbaton
->per_cu
= cu
->per_cu
;
13959 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
13961 else if (attr
->form_is_ref ())
13963 struct dwarf2_cu
*target_cu
= cu
;
13964 struct die_info
*target_die
;
13966 target_die
= follow_die_ref (die
, attr
, &target_cu
);
13967 gdb_assert (target_cu
->per_objfile
->objfile
== objfile
);
13968 if (die_is_declaration (target_die
, target_cu
))
13970 const char *target_physname
;
13972 /* Prefer the mangled name; otherwise compute the demangled one. */
13973 target_physname
= dw2_linkage_name (target_die
, target_cu
);
13974 if (target_physname
== NULL
)
13975 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
13976 if (target_physname
== NULL
)
13977 complaint (_("DW_AT_call_target target DIE has invalid "
13978 "physname, for referencing DIE %s [in module %s]"),
13979 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13981 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
13987 /* DW_AT_entry_pc should be preferred. */
13988 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
13989 <= PC_BOUNDS_INVALID
)
13990 complaint (_("DW_AT_call_target target DIE has invalid "
13991 "low pc, for referencing DIE %s [in module %s]"),
13992 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13995 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13996 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
14001 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14002 "block nor reference, for DIE %s [in module %s]"),
14003 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14005 call_site
->per_cu
= cu
->per_cu
;
14006 call_site
->per_objfile
= per_objfile
;
14008 for (child_die
= die
->child
;
14009 child_die
&& child_die
->tag
;
14010 child_die
= child_die
->sibling
)
14012 struct call_site_parameter
*parameter
;
14013 struct attribute
*loc
, *origin
;
14015 if (child_die
->tag
!= DW_TAG_call_site_parameter
14016 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14018 /* Already printed the complaint above. */
14022 gdb_assert (call_site
->parameter_count
< nparams
);
14023 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
14025 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14026 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14027 register is contained in DW_AT_call_value. */
14029 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
14030 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
14031 if (origin
== NULL
)
14033 /* This was a pre-DWARF-5 GNU extension alias
14034 for DW_AT_call_parameter. */
14035 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
14037 if (loc
== NULL
&& origin
!= NULL
&& origin
->form_is_ref ())
14039 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
14041 sect_offset sect_off
= origin
->get_ref_die_offset ();
14042 if (!cu
->header
.offset_in_cu_p (sect_off
))
14044 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14045 binding can be done only inside one CU. Such referenced DIE
14046 therefore cannot be even moved to DW_TAG_partial_unit. */
14047 complaint (_("DW_AT_call_parameter offset is not in CU for "
14048 "DW_TAG_call_site child DIE %s [in module %s]"),
14049 sect_offset_str (child_die
->sect_off
),
14050 objfile_name (objfile
));
14053 parameter
->u
.param_cu_off
14054 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
14056 else if (loc
== NULL
|| origin
!= NULL
|| !loc
->form_is_block ())
14058 complaint (_("No DW_FORM_block* DW_AT_location for "
14059 "DW_TAG_call_site child DIE %s [in module %s]"),
14060 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
14065 struct dwarf_block
*block
= loc
->as_block ();
14067 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
14068 (block
->data
, &block
->data
[block
->size
]);
14069 if (parameter
->u
.dwarf_reg
!= -1)
14070 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
14071 else if (dwarf_block_to_sp_offset (gdbarch
, block
->data
,
14072 &block
->data
[block
->size
],
14073 ¶meter
->u
.fb_offset
))
14074 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
14077 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14078 "for DW_FORM_block* DW_AT_location is supported for "
14079 "DW_TAG_call_site child DIE %s "
14081 sect_offset_str (child_die
->sect_off
),
14082 objfile_name (objfile
));
14087 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
14089 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
14090 if (attr
== NULL
|| !attr
->form_is_block ())
14092 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14093 "DW_TAG_call_site child DIE %s [in module %s]"),
14094 sect_offset_str (child_die
->sect_off
),
14095 objfile_name (objfile
));
14099 struct dwarf_block
*block
= attr
->as_block ();
14100 parameter
->value
= block
->data
;
14101 parameter
->value_size
= block
->size
;
14103 /* Parameters are not pre-cleared by memset above. */
14104 parameter
->data_value
= NULL
;
14105 parameter
->data_value_size
= 0;
14106 call_site
->parameter_count
++;
14108 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
14110 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
14111 if (attr
!= nullptr)
14113 if (!attr
->form_is_block ())
14114 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14115 "DW_TAG_call_site child DIE %s [in module %s]"),
14116 sect_offset_str (child_die
->sect_off
),
14117 objfile_name (objfile
));
14120 block
= attr
->as_block ();
14121 parameter
->data_value
= block
->data
;
14122 parameter
->data_value_size
= block
->size
;
14128 /* Helper function for read_variable. If DIE represents a virtual
14129 table, then return the type of the concrete object that is
14130 associated with the virtual table. Otherwise, return NULL. */
14132 static struct type
*
14133 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14135 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
14139 /* Find the type DIE. */
14140 struct die_info
*type_die
= NULL
;
14141 struct dwarf2_cu
*type_cu
= cu
;
14143 if (attr
->form_is_ref ())
14144 type_die
= follow_die_ref (die
, attr
, &type_cu
);
14145 if (type_die
== NULL
)
14148 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
14150 return die_containing_type (type_die
, type_cu
);
14153 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14156 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
14158 struct rust_vtable_symbol
*storage
= NULL
;
14160 if (cu
->language
== language_rust
)
14162 struct type
*containing_type
= rust_containing_type (die
, cu
);
14164 if (containing_type
!= NULL
)
14166 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14168 storage
= new (&objfile
->objfile_obstack
) rust_vtable_symbol
;
14169 storage
->concrete_type
= containing_type
;
14170 storage
->subclass
= SYMBOL_RUST_VTABLE
;
14174 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
14175 struct attribute
*abstract_origin
14176 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14177 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
14178 if (res
== NULL
&& loc
&& abstract_origin
)
14180 /* We have a variable without a name, but with a location and an abstract
14181 origin. This may be a concrete instance of an abstract variable
14182 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14184 struct dwarf2_cu
*origin_cu
= cu
;
14185 struct die_info
*origin_die
14186 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
14187 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14188 per_objfile
->per_bfd
->abstract_to_concrete
14189 [origin_die
->sect_off
].push_back (die
->sect_off
);
14193 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14194 reading .debug_rnglists.
14195 Callback's type should be:
14196 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14197 Return true if the attributes are present and valid, otherwise,
14200 template <typename Callback
>
14202 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
14203 dwarf_tag tag
, Callback
&&callback
)
14205 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14206 struct objfile
*objfile
= per_objfile
->objfile
;
14207 bfd
*obfd
= objfile
->obfd
;
14208 /* Base address selection entry. */
14209 gdb::optional
<CORE_ADDR
> base
;
14210 const gdb_byte
*buffer
;
14211 CORE_ADDR baseaddr
;
14212 bool overflow
= false;
14213 ULONGEST addr_index
;
14214 struct dwarf2_section_info
*rnglists_section
;
14216 base
= cu
->base_address
;
14217 rnglists_section
= cu_debug_rnglists_section (cu
, tag
);
14218 rnglists_section
->read (objfile
);
14220 if (offset
>= rnglists_section
->size
)
14222 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14226 buffer
= rnglists_section
->buffer
+ offset
;
14228 baseaddr
= objfile
->text_section_offset ();
14232 /* Initialize it due to a false compiler warning. */
14233 CORE_ADDR range_beginning
= 0, range_end
= 0;
14234 const gdb_byte
*buf_end
= (rnglists_section
->buffer
14235 + rnglists_section
->size
);
14236 unsigned int bytes_read
;
14238 if (buffer
== buf_end
)
14243 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
14246 case DW_RLE_end_of_list
:
14248 case DW_RLE_base_address
:
14249 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14254 base
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14255 buffer
+= bytes_read
;
14257 case DW_RLE_base_addressx
:
14258 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14259 buffer
+= bytes_read
;
14260 base
= read_addr_index (cu
, addr_index
);
14262 case DW_RLE_start_length
:
14263 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14268 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14270 buffer
+= bytes_read
;
14271 range_end
= (range_beginning
14272 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14273 buffer
+= bytes_read
;
14274 if (buffer
> buf_end
)
14280 case DW_RLE_startx_length
:
14281 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14282 buffer
+= bytes_read
;
14283 range_beginning
= read_addr_index (cu
, addr_index
);
14284 if (buffer
> buf_end
)
14289 range_end
= (range_beginning
14290 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14291 buffer
+= bytes_read
;
14293 case DW_RLE_offset_pair
:
14294 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14295 buffer
+= bytes_read
;
14296 if (buffer
> buf_end
)
14301 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14302 buffer
+= bytes_read
;
14303 if (buffer
> buf_end
)
14309 case DW_RLE_start_end
:
14310 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
14315 range_beginning
= cu
->header
.read_address (obfd
, buffer
,
14317 buffer
+= bytes_read
;
14318 range_end
= cu
->header
.read_address (obfd
, buffer
, &bytes_read
);
14319 buffer
+= bytes_read
;
14321 case DW_RLE_startx_endx
:
14322 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14323 buffer
+= bytes_read
;
14324 range_beginning
= read_addr_index (cu
, addr_index
);
14325 if (buffer
> buf_end
)
14330 addr_index
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14331 buffer
+= bytes_read
;
14332 range_end
= read_addr_index (cu
, addr_index
);
14335 complaint (_("Invalid .debug_rnglists data (no base address)"));
14338 if (rlet
== DW_RLE_end_of_list
|| overflow
)
14340 if (rlet
== DW_RLE_base_address
)
14343 if (range_beginning
> range_end
)
14345 /* Inverted range entries are invalid. */
14346 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14350 /* Empty range entries have no effect. */
14351 if (range_beginning
== range_end
)
14354 /* Only DW_RLE_offset_pair needs the base address added. */
14355 if (rlet
== DW_RLE_offset_pair
)
14357 if (!base
.has_value ())
14359 /* We have no valid base address for the DW_RLE_offset_pair. */
14360 complaint (_("Invalid .debug_rnglists data (no base address for "
14361 "DW_RLE_offset_pair)"));
14365 range_beginning
+= *base
;
14366 range_end
+= *base
;
14369 /* A not-uncommon case of bad debug info.
14370 Don't pollute the addrmap with bad data. */
14371 if (range_beginning
+ baseaddr
== 0
14372 && !per_objfile
->per_bfd
->has_section_at_zero
)
14374 complaint (_(".debug_rnglists entry has start address of zero"
14375 " [in module %s]"), objfile_name (objfile
));
14379 callback (range_beginning
, range_end
);
14384 complaint (_("Offset %d is not terminated "
14385 "for DW_AT_ranges attribute"),
14393 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14394 Callback's type should be:
14395 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14396 Return 1 if the attributes are present and valid, otherwise, return 0. */
14398 template <typename Callback
>
14400 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
, dwarf_tag tag
,
14401 Callback
&&callback
)
14403 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14404 struct objfile
*objfile
= per_objfile
->objfile
;
14405 struct comp_unit_head
*cu_header
= &cu
->header
;
14406 bfd
*obfd
= objfile
->obfd
;
14407 unsigned int addr_size
= cu_header
->addr_size
;
14408 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
14409 /* Base address selection entry. */
14410 gdb::optional
<CORE_ADDR
> base
;
14411 unsigned int dummy
;
14412 const gdb_byte
*buffer
;
14413 CORE_ADDR baseaddr
;
14415 if (cu_header
->version
>= 5)
14416 return dwarf2_rnglists_process (offset
, cu
, tag
, callback
);
14418 base
= cu
->base_address
;
14420 per_objfile
->per_bfd
->ranges
.read (objfile
);
14421 if (offset
>= per_objfile
->per_bfd
->ranges
.size
)
14423 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14427 buffer
= per_objfile
->per_bfd
->ranges
.buffer
+ offset
;
14429 baseaddr
= objfile
->text_section_offset ();
14433 CORE_ADDR range_beginning
, range_end
;
14435 range_beginning
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14436 buffer
+= addr_size
;
14437 range_end
= cu
->header
.read_address (obfd
, buffer
, &dummy
);
14438 buffer
+= addr_size
;
14439 offset
+= 2 * addr_size
;
14441 /* An end of list marker is a pair of zero addresses. */
14442 if (range_beginning
== 0 && range_end
== 0)
14443 /* Found the end of list entry. */
14446 /* Each base address selection entry is a pair of 2 values.
14447 The first is the largest possible address, the second is
14448 the base address. Check for a base address here. */
14449 if ((range_beginning
& mask
) == mask
)
14451 /* If we found the largest possible address, then we already
14452 have the base address in range_end. */
14457 if (!base
.has_value ())
14459 /* We have no valid base address for the ranges
14461 complaint (_("Invalid .debug_ranges data (no base address)"));
14465 if (range_beginning
> range_end
)
14467 /* Inverted range entries are invalid. */
14468 complaint (_("Invalid .debug_ranges data (inverted range)"));
14472 /* Empty range entries have no effect. */
14473 if (range_beginning
== range_end
)
14476 range_beginning
+= *base
;
14477 range_end
+= *base
;
14479 /* A not-uncommon case of bad debug info.
14480 Don't pollute the addrmap with bad data. */
14481 if (range_beginning
+ baseaddr
== 0
14482 && !per_objfile
->per_bfd
->has_section_at_zero
)
14484 complaint (_(".debug_ranges entry has start address of zero"
14485 " [in module %s]"), objfile_name (objfile
));
14489 callback (range_beginning
, range_end
);
14495 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14496 Return 1 if the attributes are present and valid, otherwise, return 0.
14497 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14500 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14501 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14502 dwarf2_psymtab
*ranges_pst
, dwarf_tag tag
)
14504 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14505 struct gdbarch
*gdbarch
= objfile
->arch ();
14506 const CORE_ADDR baseaddr
= objfile
->text_section_offset ();
14509 CORE_ADDR high
= 0;
14512 retval
= dwarf2_ranges_process (offset
, cu
, tag
,
14513 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14515 if (ranges_pst
!= NULL
)
14520 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14521 range_beginning
+ baseaddr
)
14523 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14524 range_end
+ baseaddr
)
14526 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
14527 lowpc
, highpc
- 1, ranges_pst
);
14530 /* FIXME: This is recording everything as a low-high
14531 segment of consecutive addresses. We should have a
14532 data structure for discontiguous block ranges
14536 low
= range_beginning
;
14542 if (range_beginning
< low
)
14543 low
= range_beginning
;
14544 if (range_end
> high
)
14552 /* If the first entry is an end-of-list marker, the range
14553 describes an empty scope, i.e. no instructions. */
14559 *high_return
= high
;
14563 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14564 definition for the return value. *LOWPC and *HIGHPC are set iff
14565 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14567 static enum pc_bounds_kind
14568 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14569 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14570 dwarf2_psymtab
*pst
)
14572 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14573 struct attribute
*attr
;
14574 struct attribute
*attr_high
;
14576 CORE_ADDR high
= 0;
14577 enum pc_bounds_kind ret
;
14579 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14582 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14583 if (attr
!= nullptr)
14585 low
= attr
->as_address ();
14586 high
= attr_high
->as_address ();
14587 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14591 /* Found high w/o low attribute. */
14592 return PC_BOUNDS_INVALID
;
14594 /* Found consecutive range of addresses. */
14595 ret
= PC_BOUNDS_HIGH_LOW
;
14599 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14600 if (attr
!= nullptr && attr
->form_is_unsigned ())
14602 /* DW_AT_rnglists_base does not apply to DIEs from the DWO skeleton.
14603 We take advantage of the fact that DW_AT_ranges does not appear
14604 in DW_TAG_compile_unit of DWO files.
14606 Attributes of the form DW_FORM_rnglistx have already had their
14607 value changed by read_rnglist_index and already include
14608 DW_AT_rnglists_base, so don't need to add the ranges base,
14610 int need_ranges_base
= (die
->tag
!= DW_TAG_compile_unit
14611 && attr
->form
!= DW_FORM_rnglistx
);
14612 unsigned int ranges_offset
= (attr
->as_unsigned ()
14613 + (need_ranges_base
14617 /* Value of the DW_AT_ranges attribute is the offset in the
14618 .debug_ranges section. */
14619 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
,
14621 return PC_BOUNDS_INVALID
;
14622 /* Found discontinuous range of addresses. */
14623 ret
= PC_BOUNDS_RANGES
;
14626 return PC_BOUNDS_NOT_PRESENT
;
14629 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14631 return PC_BOUNDS_INVALID
;
14633 /* When using the GNU linker, .gnu.linkonce. sections are used to
14634 eliminate duplicate copies of functions and vtables and such.
14635 The linker will arbitrarily choose one and discard the others.
14636 The AT_*_pc values for such functions refer to local labels in
14637 these sections. If the section from that file was discarded, the
14638 labels are not in the output, so the relocs get a value of 0.
14639 If this is a discarded function, mark the pc bounds as invalid,
14640 so that GDB will ignore it. */
14641 if (low
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
14642 return PC_BOUNDS_INVALID
;
14650 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14651 its low and high PC addresses. Do nothing if these addresses could not
14652 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14653 and HIGHPC to the high address if greater than HIGHPC. */
14656 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14657 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14658 struct dwarf2_cu
*cu
)
14660 CORE_ADDR low
, high
;
14661 struct die_info
*child
= die
->child
;
14663 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14665 *lowpc
= std::min (*lowpc
, low
);
14666 *highpc
= std::max (*highpc
, high
);
14669 /* If the language does not allow nested subprograms (either inside
14670 subprograms or lexical blocks), we're done. */
14671 if (cu
->language
!= language_ada
)
14674 /* Check all the children of the given DIE. If it contains nested
14675 subprograms, then check their pc bounds. Likewise, we need to
14676 check lexical blocks as well, as they may also contain subprogram
14678 while (child
&& child
->tag
)
14680 if (child
->tag
== DW_TAG_subprogram
14681 || child
->tag
== DW_TAG_lexical_block
)
14682 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14683 child
= child
->sibling
;
14687 /* Get the low and high pc's represented by the scope DIE, and store
14688 them in *LOWPC and *HIGHPC. If the correct values can't be
14689 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14692 get_scope_pc_bounds (struct die_info
*die
,
14693 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14694 struct dwarf2_cu
*cu
)
14696 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14697 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14698 CORE_ADDR current_low
, current_high
;
14700 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14701 >= PC_BOUNDS_RANGES
)
14703 best_low
= current_low
;
14704 best_high
= current_high
;
14708 struct die_info
*child
= die
->child
;
14710 while (child
&& child
->tag
)
14712 switch (child
->tag
) {
14713 case DW_TAG_subprogram
:
14714 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14716 case DW_TAG_namespace
:
14717 case DW_TAG_module
:
14718 /* FIXME: carlton/2004-01-16: Should we do this for
14719 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14720 that current GCC's always emit the DIEs corresponding
14721 to definitions of methods of classes as children of a
14722 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14723 the DIEs giving the declarations, which could be
14724 anywhere). But I don't see any reason why the
14725 standards says that they have to be there. */
14726 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14728 if (current_low
!= ((CORE_ADDR
) -1))
14730 best_low
= std::min (best_low
, current_low
);
14731 best_high
= std::max (best_high
, current_high
);
14739 child
= child
->sibling
;
14744 *highpc
= best_high
;
14747 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14751 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14752 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14754 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
14755 struct gdbarch
*gdbarch
= objfile
->arch ();
14756 struct attribute
*attr
;
14757 struct attribute
*attr_high
;
14759 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14762 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14763 if (attr
!= nullptr)
14765 CORE_ADDR low
= attr
->as_address ();
14766 CORE_ADDR high
= attr_high
->as_address ();
14768 if (cu
->header
.version
>= 4 && attr_high
->form_is_constant ())
14771 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14772 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14773 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14777 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14778 if (attr
!= nullptr && attr
->form_is_unsigned ())
14780 /* DW_AT_rnglists_base does not apply to DIEs from the DWO skeleton.
14781 We take advantage of the fact that DW_AT_ranges does not appear
14782 in DW_TAG_compile_unit of DWO files.
14784 Attributes of the form DW_FORM_rnglistx have already had their
14785 value changed by read_rnglist_index and already include
14786 DW_AT_rnglists_base, so don't need to add the ranges base,
14788 int need_ranges_base
= (die
->tag
!= DW_TAG_compile_unit
14789 && attr
->form
!= DW_FORM_rnglistx
);
14791 /* The value of the DW_AT_ranges attribute is the offset of the
14792 address range list in the .debug_ranges section. */
14793 unsigned long offset
= (attr
->as_unsigned ()
14794 + (need_ranges_base
? cu
->ranges_base
: 0));
14796 std::vector
<blockrange
> blockvec
;
14797 dwarf2_ranges_process (offset
, cu
, die
->tag
,
14798 [&] (CORE_ADDR start
, CORE_ADDR end
)
14802 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14803 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14804 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14805 blockvec
.emplace_back (start
, end
);
14808 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14812 /* Check whether the producer field indicates either of GCC < 4.6, or the
14813 Intel C/C++ compiler, and cache the result in CU. */
14816 check_producer (struct dwarf2_cu
*cu
)
14820 if (cu
->producer
== NULL
)
14822 /* For unknown compilers expect their behavior is DWARF version
14825 GCC started to support .debug_types sections by -gdwarf-4 since
14826 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14827 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14828 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14829 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14831 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14833 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14834 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14836 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14838 cu
->producer_is_icc
= true;
14839 cu
->producer_is_icc_lt_14
= major
< 14;
14841 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14842 cu
->producer_is_codewarrior
= true;
14845 /* For other non-GCC compilers, expect their behavior is DWARF version
14849 cu
->checked_producer
= true;
14852 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14853 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14854 during 4.6.0 experimental. */
14857 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14859 if (!cu
->checked_producer
)
14860 check_producer (cu
);
14862 return cu
->producer_is_gxx_lt_4_6
;
14866 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14867 with incorrect is_stmt attributes. */
14870 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14872 if (!cu
->checked_producer
)
14873 check_producer (cu
);
14875 return cu
->producer_is_codewarrior
;
14878 /* Return the accessibility of DIE, as given by DW_AT_accessibility.
14879 If that attribute is not available, return the appropriate
14882 static enum dwarf_access_attribute
14883 dwarf2_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14885 attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14886 if (attr
!= nullptr)
14888 LONGEST value
= attr
->constant_value (-1);
14889 if (value
== DW_ACCESS_public
14890 || value
== DW_ACCESS_protected
14891 || value
== DW_ACCESS_private
)
14892 return (dwarf_access_attribute
) value
;
14893 complaint (_("Unhandled DW_AT_accessibility value (%s)"),
14897 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14899 /* The default DWARF 2 accessibility for members is public, the default
14900 accessibility for inheritance is private. */
14902 if (die
->tag
!= DW_TAG_inheritance
)
14903 return DW_ACCESS_public
;
14905 return DW_ACCESS_private
;
14909 /* DWARF 3+ defines the default accessibility a different way. The same
14910 rules apply now for DW_TAG_inheritance as for the members and it only
14911 depends on the container kind. */
14913 if (die
->parent
->tag
== DW_TAG_class_type
)
14914 return DW_ACCESS_private
;
14916 return DW_ACCESS_public
;
14920 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14921 offset. If the attribute was not found return 0, otherwise return
14922 1. If it was found but could not properly be handled, set *OFFSET
14926 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14929 struct attribute
*attr
;
14931 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14936 /* Note that we do not check for a section offset first here.
14937 This is because DW_AT_data_member_location is new in DWARF 4,
14938 so if we see it, we can assume that a constant form is really
14939 a constant and not a section offset. */
14940 if (attr
->form_is_constant ())
14941 *offset
= attr
->constant_value (0);
14942 else if (attr
->form_is_section_offset ())
14943 dwarf2_complex_location_expr_complaint ();
14944 else if (attr
->form_is_block ())
14945 *offset
= decode_locdesc (attr
->as_block (), cu
);
14947 dwarf2_complex_location_expr_complaint ();
14955 /* Look for DW_AT_data_member_location and store the results in FIELD. */
14958 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14959 struct field
*field
)
14961 struct attribute
*attr
;
14963 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14966 if (attr
->form_is_constant ())
14968 LONGEST offset
= attr
->constant_value (0);
14969 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14971 else if (attr
->form_is_section_offset ())
14972 dwarf2_complex_location_expr_complaint ();
14973 else if (attr
->form_is_block ())
14976 CORE_ADDR offset
= decode_locdesc (attr
->as_block (), cu
, &handled
);
14978 SET_FIELD_BITPOS (*field
, offset
* bits_per_byte
);
14981 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
14982 struct objfile
*objfile
= per_objfile
->objfile
;
14983 struct dwarf2_locexpr_baton
*dlbaton
14984 = XOBNEW (&objfile
->objfile_obstack
,
14985 struct dwarf2_locexpr_baton
);
14986 dlbaton
->data
= attr
->as_block ()->data
;
14987 dlbaton
->size
= attr
->as_block ()->size
;
14988 /* When using this baton, we want to compute the address
14989 of the field, not the value. This is why
14990 is_reference is set to false here. */
14991 dlbaton
->is_reference
= false;
14992 dlbaton
->per_objfile
= per_objfile
;
14993 dlbaton
->per_cu
= cu
->per_cu
;
14995 SET_FIELD_DWARF_BLOCK (*field
, dlbaton
);
14999 dwarf2_complex_location_expr_complaint ();
15003 /* Add an aggregate field to the field list. */
15006 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
15007 struct dwarf2_cu
*cu
)
15009 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15010 struct gdbarch
*gdbarch
= objfile
->arch ();
15011 struct nextfield
*new_field
;
15012 struct attribute
*attr
;
15014 const char *fieldname
= "";
15016 if (die
->tag
== DW_TAG_inheritance
)
15018 fip
->baseclasses
.emplace_back ();
15019 new_field
= &fip
->baseclasses
.back ();
15023 fip
->fields
.emplace_back ();
15024 new_field
= &fip
->fields
.back ();
15027 new_field
->offset
= die
->sect_off
;
15029 new_field
->accessibility
= dwarf2_access_attribute (die
, cu
);
15030 if (new_field
->accessibility
!= DW_ACCESS_public
)
15031 fip
->non_public_fields
= true;
15033 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15034 if (attr
!= nullptr)
15035 new_field
->virtuality
= attr
->as_virtuality ();
15037 new_field
->virtuality
= DW_VIRTUALITY_none
;
15039 fp
= &new_field
->field
;
15041 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
15043 /* Data member other than a C++ static data member. */
15045 /* Get type of field. */
15046 fp
->set_type (die_type (die
, cu
));
15048 SET_FIELD_BITPOS (*fp
, 0);
15050 /* Get bit size of field (zero if none). */
15051 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
15052 if (attr
!= nullptr)
15054 FIELD_BITSIZE (*fp
) = attr
->constant_value (0);
15058 FIELD_BITSIZE (*fp
) = 0;
15061 /* Get bit offset of field. */
15062 handle_data_member_location (die
, cu
, fp
);
15063 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
15064 if (attr
!= nullptr && attr
->form_is_constant ())
15066 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
15068 /* For big endian bits, the DW_AT_bit_offset gives the
15069 additional bit offset from the MSB of the containing
15070 anonymous object to the MSB of the field. We don't
15071 have to do anything special since we don't need to
15072 know the size of the anonymous object. */
15073 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15074 + attr
->constant_value (0)));
15078 /* For little endian bits, compute the bit offset to the
15079 MSB of the anonymous object, subtract off the number of
15080 bits from the MSB of the field to the MSB of the
15081 object, and then subtract off the number of bits of
15082 the field itself. The result is the bit offset of
15083 the LSB of the field. */
15084 int anonymous_size
;
15085 int bit_offset
= attr
->constant_value (0);
15087 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15088 if (attr
!= nullptr && attr
->form_is_constant ())
15090 /* The size of the anonymous object containing
15091 the bit field is explicit, so use the
15092 indicated size (in bytes). */
15093 anonymous_size
= attr
->constant_value (0);
15097 /* The size of the anonymous object containing
15098 the bit field must be inferred from the type
15099 attribute of the data member containing the
15101 anonymous_size
= TYPE_LENGTH (fp
->type ());
15103 SET_FIELD_BITPOS (*fp
,
15104 (FIELD_BITPOS (*fp
)
15105 + anonymous_size
* bits_per_byte
15106 - bit_offset
- FIELD_BITSIZE (*fp
)));
15109 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
15111 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15112 + attr
->constant_value (0)));
15114 /* Get name of field. */
15115 fieldname
= dwarf2_name (die
, cu
);
15116 if (fieldname
== NULL
)
15119 /* The name is already allocated along with this objfile, so we don't
15120 need to duplicate it for the type. */
15121 fp
->name
= fieldname
;
15123 /* Change accessibility for artificial fields (e.g. virtual table
15124 pointer or virtual base class pointer) to private. */
15125 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
15127 FIELD_ARTIFICIAL (*fp
) = 1;
15128 new_field
->accessibility
= DW_ACCESS_private
;
15129 fip
->non_public_fields
= true;
15132 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
15134 /* C++ static member. */
15136 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15137 is a declaration, but all versions of G++ as of this writing
15138 (so through at least 3.2.1) incorrectly generate
15139 DW_TAG_variable tags. */
15141 const char *physname
;
15143 /* Get name of field. */
15144 fieldname
= dwarf2_name (die
, cu
);
15145 if (fieldname
== NULL
)
15148 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15150 /* Only create a symbol if this is an external value.
15151 new_symbol checks this and puts the value in the global symbol
15152 table, which we want. If it is not external, new_symbol
15153 will try to put the value in cu->list_in_scope which is wrong. */
15154 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
15156 /* A static const member, not much different than an enum as far as
15157 we're concerned, except that we can support more types. */
15158 new_symbol (die
, NULL
, cu
);
15161 /* Get physical name. */
15162 physname
= dwarf2_physname (fieldname
, die
, cu
);
15164 /* The name is already allocated along with this objfile, so we don't
15165 need to duplicate it for the type. */
15166 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
15167 fp
->set_type (die_type (die
, cu
));
15168 FIELD_NAME (*fp
) = fieldname
;
15170 else if (die
->tag
== DW_TAG_inheritance
)
15172 /* C++ base class field. */
15173 handle_data_member_location (die
, cu
, fp
);
15174 FIELD_BITSIZE (*fp
) = 0;
15175 fp
->set_type (die_type (die
, cu
));
15176 FIELD_NAME (*fp
) = fp
->type ()->name ();
15179 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15182 /* Can the type given by DIE define another type? */
15185 type_can_define_types (const struct die_info
*die
)
15189 case DW_TAG_typedef
:
15190 case DW_TAG_class_type
:
15191 case DW_TAG_structure_type
:
15192 case DW_TAG_union_type
:
15193 case DW_TAG_enumeration_type
:
15201 /* Add a type definition defined in the scope of the FIP's class. */
15204 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
15205 struct dwarf2_cu
*cu
)
15207 struct decl_field fp
;
15208 memset (&fp
, 0, sizeof (fp
));
15210 gdb_assert (type_can_define_types (die
));
15212 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15213 fp
.name
= dwarf2_name (die
, cu
);
15214 fp
.type
= read_type_die (die
, cu
);
15216 /* Save accessibility. */
15217 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15218 switch (accessibility
)
15220 case DW_ACCESS_public
:
15221 /* The assumed value if neither private nor protected. */
15223 case DW_ACCESS_private
:
15226 case DW_ACCESS_protected
:
15227 fp
.is_protected
= 1;
15231 if (die
->tag
== DW_TAG_typedef
)
15232 fip
->typedef_field_list
.push_back (fp
);
15234 fip
->nested_types_list
.push_back (fp
);
15237 /* A convenience typedef that's used when finding the discriminant
15238 field for a variant part. */
15239 typedef std::unordered_map
<sect_offset
, int, gdb::hash_enum
<sect_offset
>>
15242 /* Compute the discriminant range for a given variant. OBSTACK is
15243 where the results will be stored. VARIANT is the variant to
15244 process. IS_UNSIGNED indicates whether the discriminant is signed
15247 static const gdb::array_view
<discriminant_range
>
15248 convert_variant_range (struct obstack
*obstack
, const variant_field
&variant
,
15251 std::vector
<discriminant_range
> ranges
;
15253 if (variant
.default_branch
)
15256 if (variant
.discr_list_data
== nullptr)
15258 discriminant_range r
15259 = {variant
.discriminant_value
, variant
.discriminant_value
};
15260 ranges
.push_back (r
);
15264 gdb::array_view
<const gdb_byte
> data (variant
.discr_list_data
->data
,
15265 variant
.discr_list_data
->size
);
15266 while (!data
.empty ())
15268 if (data
[0] != DW_DSC_range
&& data
[0] != DW_DSC_label
)
15270 complaint (_("invalid discriminant marker: %d"), data
[0]);
15273 bool is_range
= data
[0] == DW_DSC_range
;
15274 data
= data
.slice (1);
15276 ULONGEST low
, high
;
15277 unsigned int bytes_read
;
15281 complaint (_("DW_AT_discr_list missing low value"));
15285 low
= read_unsigned_leb128 (nullptr, data
.data (), &bytes_read
);
15287 low
= (ULONGEST
) read_signed_leb128 (nullptr, data
.data (),
15289 data
= data
.slice (bytes_read
);
15295 complaint (_("DW_AT_discr_list missing high value"));
15299 high
= read_unsigned_leb128 (nullptr, data
.data (),
15302 high
= (LONGEST
) read_signed_leb128 (nullptr, data
.data (),
15304 data
= data
.slice (bytes_read
);
15309 ranges
.push_back ({ low
, high
});
15313 discriminant_range
*result
= XOBNEWVEC (obstack
, discriminant_range
,
15315 std::copy (ranges
.begin (), ranges
.end (), result
);
15316 return gdb::array_view
<discriminant_range
> (result
, ranges
.size ());
15319 static const gdb::array_view
<variant_part
> create_variant_parts
15320 (struct obstack
*obstack
,
15321 const offset_map_type
&offset_map
,
15322 struct field_info
*fi
,
15323 const std::vector
<variant_part_builder
> &variant_parts
);
15325 /* Fill in a "struct variant" for a given variant field. RESULT is
15326 the variant to fill in. OBSTACK is where any needed allocations
15327 will be done. OFFSET_MAP holds the mapping from section offsets to
15328 fields for the type. FI describes the fields of the type we're
15329 processing. FIELD is the variant field we're converting. */
15332 create_one_variant (variant
&result
, struct obstack
*obstack
,
15333 const offset_map_type
&offset_map
,
15334 struct field_info
*fi
, const variant_field
&field
)
15336 result
.discriminants
= convert_variant_range (obstack
, field
, false);
15337 result
.first_field
= field
.first_field
+ fi
->baseclasses
.size ();
15338 result
.last_field
= field
.last_field
+ fi
->baseclasses
.size ();
15339 result
.parts
= create_variant_parts (obstack
, offset_map
, fi
,
15340 field
.variant_parts
);
15343 /* Fill in a "struct variant_part" for a given variant part. RESULT
15344 is the variant part to fill in. OBSTACK is where any needed
15345 allocations will be done. OFFSET_MAP holds the mapping from
15346 section offsets to fields for the type. FI describes the fields of
15347 the type we're processing. BUILDER is the variant part to be
15351 create_one_variant_part (variant_part
&result
,
15352 struct obstack
*obstack
,
15353 const offset_map_type
&offset_map
,
15354 struct field_info
*fi
,
15355 const variant_part_builder
&builder
)
15357 auto iter
= offset_map
.find (builder
.discriminant_offset
);
15358 if (iter
== offset_map
.end ())
15360 result
.discriminant_index
= -1;
15361 /* Doesn't matter. */
15362 result
.is_unsigned
= false;
15366 result
.discriminant_index
= iter
->second
;
15368 = fi
->fields
[result
.discriminant_index
].field
.type ()->is_unsigned ();
15371 size_t n
= builder
.variants
.size ();
15372 variant
*output
= new (obstack
) variant
[n
];
15373 for (size_t i
= 0; i
< n
; ++i
)
15374 create_one_variant (output
[i
], obstack
, offset_map
, fi
,
15375 builder
.variants
[i
]);
15377 result
.variants
= gdb::array_view
<variant
> (output
, n
);
15380 /* Create a vector of variant parts that can be attached to a type.
15381 OBSTACK is where any needed allocations will be done. OFFSET_MAP
15382 holds the mapping from section offsets to fields for the type. FI
15383 describes the fields of the type we're processing. VARIANT_PARTS
15384 is the vector to convert. */
15386 static const gdb::array_view
<variant_part
>
15387 create_variant_parts (struct obstack
*obstack
,
15388 const offset_map_type
&offset_map
,
15389 struct field_info
*fi
,
15390 const std::vector
<variant_part_builder
> &variant_parts
)
15392 if (variant_parts
.empty ())
15395 size_t n
= variant_parts
.size ();
15396 variant_part
*result
= new (obstack
) variant_part
[n
];
15397 for (size_t i
= 0; i
< n
; ++i
)
15398 create_one_variant_part (result
[i
], obstack
, offset_map
, fi
,
15401 return gdb::array_view
<variant_part
> (result
, n
);
15404 /* Compute the variant part vector for FIP, attaching it to TYPE when
15408 add_variant_property (struct field_info
*fip
, struct type
*type
,
15409 struct dwarf2_cu
*cu
)
15411 /* Map section offsets of fields to their field index. Note the
15412 field index here does not take the number of baseclasses into
15414 offset_map_type offset_map
;
15415 for (int i
= 0; i
< fip
->fields
.size (); ++i
)
15416 offset_map
[fip
->fields
[i
].offset
] = i
;
15418 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15419 gdb::array_view
<variant_part
> parts
15420 = create_variant_parts (&objfile
->objfile_obstack
, offset_map
, fip
,
15421 fip
->variant_parts
);
15423 struct dynamic_prop prop
;
15424 prop
.set_variant_parts ((gdb::array_view
<variant_part
> *)
15425 obstack_copy (&objfile
->objfile_obstack
, &parts
,
15428 type
->add_dyn_prop (DYN_PROP_VARIANT_PARTS
, prop
);
15431 /* Create the vector of fields, and attach it to the type. */
15434 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
15435 struct dwarf2_cu
*cu
)
15437 int nfields
= fip
->nfields ();
15439 /* Record the field count, allocate space for the array of fields,
15440 and create blank accessibility bitfields if necessary. */
15441 type
->set_num_fields (nfields
);
15443 ((struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
));
15445 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
15447 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15449 TYPE_FIELD_PRIVATE_BITS (type
) =
15450 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15451 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
15453 TYPE_FIELD_PROTECTED_BITS (type
) =
15454 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15455 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
15457 TYPE_FIELD_IGNORE_BITS (type
) =
15458 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15459 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
15462 /* If the type has baseclasses, allocate and clear a bit vector for
15463 TYPE_FIELD_VIRTUAL_BITS. */
15464 if (!fip
->baseclasses
.empty () && cu
->language
!= language_ada
)
15466 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
15467 unsigned char *pointer
;
15469 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15470 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
15471 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
15472 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
15473 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
15476 if (!fip
->variant_parts
.empty ())
15477 add_variant_property (fip
, type
, cu
);
15479 /* Copy the saved-up fields into the field vector. */
15480 for (int i
= 0; i
< nfields
; ++i
)
15482 struct nextfield
&field
15483 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
15484 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
15486 type
->field (i
) = field
.field
;
15487 switch (field
.accessibility
)
15489 case DW_ACCESS_private
:
15490 if (cu
->language
!= language_ada
)
15491 SET_TYPE_FIELD_PRIVATE (type
, i
);
15494 case DW_ACCESS_protected
:
15495 if (cu
->language
!= language_ada
)
15496 SET_TYPE_FIELD_PROTECTED (type
, i
);
15499 case DW_ACCESS_public
:
15503 /* Unknown accessibility. Complain and treat it as public. */
15505 complaint (_("unsupported accessibility %d"),
15506 field
.accessibility
);
15510 if (i
< fip
->baseclasses
.size ())
15512 switch (field
.virtuality
)
15514 case DW_VIRTUALITY_virtual
:
15515 case DW_VIRTUALITY_pure_virtual
:
15516 if (cu
->language
== language_ada
)
15517 error (_("unexpected virtuality in component of Ada type"));
15518 SET_TYPE_FIELD_VIRTUAL (type
, i
);
15525 /* Return true if this member function is a constructor, false
15529 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15531 const char *fieldname
;
15532 const char *type_name
;
15535 if (die
->parent
== NULL
)
15538 if (die
->parent
->tag
!= DW_TAG_structure_type
15539 && die
->parent
->tag
!= DW_TAG_union_type
15540 && die
->parent
->tag
!= DW_TAG_class_type
)
15543 fieldname
= dwarf2_name (die
, cu
);
15544 type_name
= dwarf2_name (die
->parent
, cu
);
15545 if (fieldname
== NULL
|| type_name
== NULL
)
15548 len
= strlen (fieldname
);
15549 return (strncmp (fieldname
, type_name
, len
) == 0
15550 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15553 /* Add a member function to the proper fieldlist. */
15556 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15557 struct type
*type
, struct dwarf2_cu
*cu
)
15559 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
15560 struct attribute
*attr
;
15562 struct fnfieldlist
*flp
= nullptr;
15563 struct fn_field
*fnp
;
15564 const char *fieldname
;
15565 struct type
*this_type
;
15567 if (cu
->language
== language_ada
)
15568 error (_("unexpected member function in Ada type"));
15570 /* Get name of member function. */
15571 fieldname
= dwarf2_name (die
, cu
);
15572 if (fieldname
== NULL
)
15575 /* Look up member function name in fieldlist. */
15576 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15578 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15580 flp
= &fip
->fnfieldlists
[i
];
15585 /* Create a new fnfieldlist if necessary. */
15586 if (flp
== nullptr)
15588 fip
->fnfieldlists
.emplace_back ();
15589 flp
= &fip
->fnfieldlists
.back ();
15590 flp
->name
= fieldname
;
15591 i
= fip
->fnfieldlists
.size () - 1;
15594 /* Create a new member function field and add it to the vector of
15596 flp
->fnfields
.emplace_back ();
15597 fnp
= &flp
->fnfields
.back ();
15599 /* Delay processing of the physname until later. */
15600 if (cu
->language
== language_cplus
)
15601 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15605 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15606 fnp
->physname
= physname
? physname
: "";
15609 fnp
->type
= alloc_type (objfile
);
15610 this_type
= read_type_die (die
, cu
);
15611 if (this_type
&& this_type
->code () == TYPE_CODE_FUNC
)
15613 int nparams
= this_type
->num_fields ();
15615 /* TYPE is the domain of this method, and THIS_TYPE is the type
15616 of the method itself (TYPE_CODE_METHOD). */
15617 smash_to_method_type (fnp
->type
, type
,
15618 TYPE_TARGET_TYPE (this_type
),
15619 this_type
->fields (),
15620 this_type
->num_fields (),
15621 this_type
->has_varargs ());
15623 /* Handle static member functions.
15624 Dwarf2 has no clean way to discern C++ static and non-static
15625 member functions. G++ helps GDB by marking the first
15626 parameter for non-static member functions (which is the this
15627 pointer) as artificial. We obtain this information from
15628 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15629 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15630 fnp
->voffset
= VOFFSET_STATIC
;
15633 complaint (_("member function type missing for '%s'"),
15634 dwarf2_full_name (fieldname
, die
, cu
));
15636 /* Get fcontext from DW_AT_containing_type if present. */
15637 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15638 fnp
->fcontext
= die_containing_type (die
, cu
);
15640 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15641 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15643 /* Get accessibility. */
15644 dwarf_access_attribute accessibility
= dwarf2_access_attribute (die
, cu
);
15645 switch (accessibility
)
15647 case DW_ACCESS_private
:
15648 fnp
->is_private
= 1;
15650 case DW_ACCESS_protected
:
15651 fnp
->is_protected
= 1;
15655 /* Check for artificial methods. */
15656 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15657 if (attr
&& attr
->as_boolean ())
15658 fnp
->is_artificial
= 1;
15660 /* Check for defaulted methods. */
15661 attr
= dwarf2_attr (die
, DW_AT_defaulted
, cu
);
15662 if (attr
!= nullptr)
15663 fnp
->defaulted
= attr
->defaulted ();
15665 /* Check for deleted methods. */
15666 attr
= dwarf2_attr (die
, DW_AT_deleted
, cu
);
15667 if (attr
!= nullptr && attr
->as_boolean ())
15668 fnp
->is_deleted
= 1;
15670 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15672 /* Get index in virtual function table if it is a virtual member
15673 function. For older versions of GCC, this is an offset in the
15674 appropriate virtual table, as specified by DW_AT_containing_type.
15675 For everyone else, it is an expression to be evaluated relative
15676 to the object address. */
15678 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15679 if (attr
!= nullptr)
15681 if (attr
->form_is_block () && attr
->as_block ()->size
> 0)
15683 struct dwarf_block
*block
= attr
->as_block ();
15685 if (block
->data
[0] == DW_OP_constu
)
15687 /* Old-style GCC. */
15688 fnp
->voffset
= decode_locdesc (block
, cu
) + 2;
15690 else if (block
->data
[0] == DW_OP_deref
15691 || (block
->size
> 1
15692 && block
->data
[0] == DW_OP_deref_size
15693 && block
->data
[1] == cu
->header
.addr_size
))
15695 fnp
->voffset
= decode_locdesc (block
, cu
);
15696 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15697 dwarf2_complex_location_expr_complaint ();
15699 fnp
->voffset
/= cu
->header
.addr_size
;
15703 dwarf2_complex_location_expr_complaint ();
15705 if (!fnp
->fcontext
)
15707 /* If there is no `this' field and no DW_AT_containing_type,
15708 we cannot actually find a base class context for the
15710 if (this_type
->num_fields () == 0
15711 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15713 complaint (_("cannot determine context for virtual member "
15714 "function \"%s\" (offset %s)"),
15715 fieldname
, sect_offset_str (die
->sect_off
));
15720 = TYPE_TARGET_TYPE (this_type
->field (0).type ());
15724 else if (attr
->form_is_section_offset ())
15726 dwarf2_complex_location_expr_complaint ();
15730 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15736 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15737 if (attr
!= nullptr && attr
->as_virtuality () != DW_VIRTUALITY_none
)
15739 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15740 complaint (_("Member function \"%s\" (offset %s) is virtual "
15741 "but the vtable offset is not specified"),
15742 fieldname
, sect_offset_str (die
->sect_off
));
15743 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15744 TYPE_CPLUS_DYNAMIC (type
) = 1;
15749 /* Create the vector of member function fields, and attach it to the type. */
15752 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15753 struct dwarf2_cu
*cu
)
15755 if (cu
->language
== language_ada
)
15756 error (_("unexpected member functions in Ada type"));
15758 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15759 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15761 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15763 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15765 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15766 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15768 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15769 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15770 fn_flp
->fn_fields
= (struct fn_field
*)
15771 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15773 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15774 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15777 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15780 /* Returns non-zero if NAME is the name of a vtable member in CU's
15781 language, zero otherwise. */
15783 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15785 static const char vptr
[] = "_vptr";
15787 /* Look for the C++ form of the vtable. */
15788 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15794 /* GCC outputs unnamed structures that are really pointers to member
15795 functions, with the ABI-specified layout. If TYPE describes
15796 such a structure, smash it into a member function type.
15798 GCC shouldn't do this; it should just output pointer to member DIEs.
15799 This is GCC PR debug/28767. */
15802 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15804 struct type
*pfn_type
, *self_type
, *new_type
;
15806 /* Check for a structure with no name and two children. */
15807 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15810 /* Check for __pfn and __delta members. */
15811 if (TYPE_FIELD_NAME (type
, 0) == NULL
15812 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15813 || TYPE_FIELD_NAME (type
, 1) == NULL
15814 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15817 /* Find the type of the method. */
15818 pfn_type
= type
->field (0).type ();
15819 if (pfn_type
== NULL
15820 || pfn_type
->code () != TYPE_CODE_PTR
15821 || TYPE_TARGET_TYPE (pfn_type
)->code () != TYPE_CODE_FUNC
)
15824 /* Look for the "this" argument. */
15825 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15826 if (pfn_type
->num_fields () == 0
15827 /* || pfn_type->field (0).type () == NULL */
15828 || pfn_type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15831 self_type
= TYPE_TARGET_TYPE (pfn_type
->field (0).type ());
15832 new_type
= alloc_type (objfile
);
15833 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15834 pfn_type
->fields (), pfn_type
->num_fields (),
15835 pfn_type
->has_varargs ());
15836 smash_to_methodptr_type (type
, new_type
);
15839 /* While some versions of GCC will generate complicated DWARF for an
15840 array (see quirk_ada_thick_pointer), more recent versions were
15841 modified to emit an explicit thick pointer structure. However, in
15842 this case, the array still has DWARF expressions for its ranges,
15843 and these must be ignored. */
15846 quirk_ada_thick_pointer_struct (struct die_info
*die
, struct dwarf2_cu
*cu
,
15849 gdb_assert (cu
->language
== language_ada
);
15851 /* Check for a structure with two children. */
15852 if (type
->code () != TYPE_CODE_STRUCT
|| type
->num_fields () != 2)
15855 /* Check for P_ARRAY and P_BOUNDS members. */
15856 if (TYPE_FIELD_NAME (type
, 0) == NULL
15857 || strcmp (TYPE_FIELD_NAME (type
, 0), "P_ARRAY") != 0
15858 || TYPE_FIELD_NAME (type
, 1) == NULL
15859 || strcmp (TYPE_FIELD_NAME (type
, 1), "P_BOUNDS") != 0)
15862 /* Make sure we're looking at a pointer to an array. */
15863 if (type
->field (0).type ()->code () != TYPE_CODE_PTR
)
15865 struct type
*ary_type
= TYPE_TARGET_TYPE (type
->field (0).type ());
15867 while (ary_type
->code () == TYPE_CODE_ARRAY
)
15869 /* The Ada code already knows how to handle these types, so all
15870 that we need to do is turn the bounds into static bounds. */
15871 struct type
*index_type
= ary_type
->index_type ();
15873 index_type
->bounds ()->low
.set_const_val (1);
15874 index_type
->bounds ()->high
.set_const_val (0);
15876 /* Handle multi-dimensional arrays. */
15877 ary_type
= TYPE_TARGET_TYPE (ary_type
);
15881 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15882 appropriate error checking and issuing complaints if there is a
15886 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
15888 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
15890 if (attr
== nullptr)
15893 if (!attr
->form_is_constant ())
15895 complaint (_("DW_AT_alignment must have constant form"
15896 " - DIE at %s [in module %s]"),
15897 sect_offset_str (die
->sect_off
),
15898 objfile_name (cu
->per_objfile
->objfile
));
15902 LONGEST val
= attr
->constant_value (0);
15905 complaint (_("DW_AT_alignment value must not be negative"
15906 " - DIE at %s [in module %s]"),
15907 sect_offset_str (die
->sect_off
),
15908 objfile_name (cu
->per_objfile
->objfile
));
15911 ULONGEST align
= val
;
15915 complaint (_("DW_AT_alignment value must not be zero"
15916 " - DIE at %s [in module %s]"),
15917 sect_offset_str (die
->sect_off
),
15918 objfile_name (cu
->per_objfile
->objfile
));
15921 if ((align
& (align
- 1)) != 0)
15923 complaint (_("DW_AT_alignment value must be a power of 2"
15924 " - DIE at %s [in module %s]"),
15925 sect_offset_str (die
->sect_off
),
15926 objfile_name (cu
->per_objfile
->objfile
));
15933 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15934 the alignment for TYPE. */
15937 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
15940 if (!set_type_align (type
, get_alignment (cu
, die
)))
15941 complaint (_("DW_AT_alignment value too large"
15942 " - DIE at %s [in module %s]"),
15943 sect_offset_str (die
->sect_off
),
15944 objfile_name (cu
->per_objfile
->objfile
));
15947 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15948 constant for a type, according to DWARF5 spec, Table 5.5. */
15951 is_valid_DW_AT_calling_convention_for_type (ULONGEST value
)
15956 case DW_CC_pass_by_reference
:
15957 case DW_CC_pass_by_value
:
15961 complaint (_("unrecognized DW_AT_calling_convention value "
15962 "(%s) for a type"), pulongest (value
));
15967 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15968 constant for a subroutine, according to DWARF5 spec, Table 3.3, and
15969 also according to GNU-specific values (see include/dwarf2.h). */
15972 is_valid_DW_AT_calling_convention_for_subroutine (ULONGEST value
)
15977 case DW_CC_program
:
15981 case DW_CC_GNU_renesas_sh
:
15982 case DW_CC_GNU_borland_fastcall_i386
:
15983 case DW_CC_GDB_IBM_OpenCL
:
15987 complaint (_("unrecognized DW_AT_calling_convention value "
15988 "(%s) for a subroutine"), pulongest (value
));
15993 /* Called when we find the DIE that starts a structure or union scope
15994 (definition) to create a type for the structure or union. Fill in
15995 the type's name and general properties; the members will not be
15996 processed until process_structure_scope. A symbol table entry for
15997 the type will also not be done until process_structure_scope (assuming
15998 the type has a name).
16000 NOTE: we need to call these functions regardless of whether or not the
16001 DIE has a DW_AT_name attribute, since it might be an anonymous
16002 structure or union. This gets the type entered into our set of
16003 user defined types. */
16005 static struct type
*
16006 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16008 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16010 struct attribute
*attr
;
16013 /* If the definition of this type lives in .debug_types, read that type.
16014 Don't follow DW_AT_specification though, that will take us back up
16015 the chain and we want to go down. */
16016 attr
= die
->attr (DW_AT_signature
);
16017 if (attr
!= nullptr)
16019 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16021 /* The type's CU may not be the same as CU.
16022 Ensure TYPE is recorded with CU in die_type_hash. */
16023 return set_die_type (die
, type
, cu
);
16026 type
= alloc_type (objfile
);
16027 INIT_CPLUS_SPECIFIC (type
);
16029 name
= dwarf2_name (die
, cu
);
16032 if (cu
->language
== language_cplus
16033 || cu
->language
== language_d
16034 || cu
->language
== language_rust
)
16036 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
16038 /* dwarf2_full_name might have already finished building the DIE's
16039 type. If so, there is no need to continue. */
16040 if (get_die_type (die
, cu
) != NULL
)
16041 return get_die_type (die
, cu
);
16043 type
->set_name (full_name
);
16047 /* The name is already allocated along with this objfile, so
16048 we don't need to duplicate it for the type. */
16049 type
->set_name (name
);
16053 if (die
->tag
== DW_TAG_structure_type
)
16055 type
->set_code (TYPE_CODE_STRUCT
);
16057 else if (die
->tag
== DW_TAG_union_type
)
16059 type
->set_code (TYPE_CODE_UNION
);
16063 type
->set_code (TYPE_CODE_STRUCT
);
16066 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
16067 TYPE_DECLARED_CLASS (type
) = 1;
16069 /* Store the calling convention in the type if it's available in
16070 the die. Otherwise the calling convention remains set to
16071 the default value DW_CC_normal. */
16072 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
16073 if (attr
!= nullptr
16074 && is_valid_DW_AT_calling_convention_for_type (attr
->constant_value (0)))
16076 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16077 TYPE_CPLUS_CALLING_CONVENTION (type
)
16078 = (enum dwarf_calling_convention
) (attr
->constant_value (0));
16081 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16082 if (attr
!= nullptr)
16084 if (attr
->form_is_constant ())
16085 TYPE_LENGTH (type
) = attr
->constant_value (0);
16088 struct dynamic_prop prop
;
16089 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
16090 type
->add_dyn_prop (DYN_PROP_BYTE_SIZE
, prop
);
16091 TYPE_LENGTH (type
) = 0;
16096 TYPE_LENGTH (type
) = 0;
16099 maybe_set_alignment (cu
, die
, type
);
16101 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
16103 /* ICC<14 does not output the required DW_AT_declaration on
16104 incomplete types, but gives them a size of zero. */
16105 type
->set_is_stub (true);
16108 type
->set_stub_is_supported (true);
16110 if (die_is_declaration (die
, cu
))
16111 type
->set_is_stub (true);
16112 else if (attr
== NULL
&& die
->child
== NULL
16113 && producer_is_realview (cu
->producer
))
16114 /* RealView does not output the required DW_AT_declaration
16115 on incomplete types. */
16116 type
->set_is_stub (true);
16118 /* We need to add the type field to the die immediately so we don't
16119 infinitely recurse when dealing with pointers to the structure
16120 type within the structure itself. */
16121 set_die_type (die
, type
, cu
);
16123 /* set_die_type should be already done. */
16124 set_descriptive_type (type
, die
, cu
);
16129 static void handle_struct_member_die
16130 (struct die_info
*child_die
,
16132 struct field_info
*fi
,
16133 std::vector
<struct symbol
*> *template_args
,
16134 struct dwarf2_cu
*cu
);
16136 /* A helper for handle_struct_member_die that handles
16137 DW_TAG_variant_part. */
16140 handle_variant_part (struct die_info
*die
, struct type
*type
,
16141 struct field_info
*fi
,
16142 std::vector
<struct symbol
*> *template_args
,
16143 struct dwarf2_cu
*cu
)
16145 variant_part_builder
*new_part
;
16146 if (fi
->current_variant_part
== nullptr)
16148 fi
->variant_parts
.emplace_back ();
16149 new_part
= &fi
->variant_parts
.back ();
16151 else if (!fi
->current_variant_part
->processing_variant
)
16153 complaint (_("nested DW_TAG_variant_part seen "
16154 "- DIE at %s [in module %s]"),
16155 sect_offset_str (die
->sect_off
),
16156 objfile_name (cu
->per_objfile
->objfile
));
16161 variant_field
¤t
= fi
->current_variant_part
->variants
.back ();
16162 current
.variant_parts
.emplace_back ();
16163 new_part
= ¤t
.variant_parts
.back ();
16166 /* When we recurse, we want callees to add to this new variant
16168 scoped_restore save_current_variant_part
16169 = make_scoped_restore (&fi
->current_variant_part
, new_part
);
16171 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
16174 /* It's a univariant form, an extension we support. */
16176 else if (discr
->form_is_ref ())
16178 struct dwarf2_cu
*target_cu
= cu
;
16179 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
16181 new_part
->discriminant_offset
= target_die
->sect_off
;
16185 complaint (_("DW_AT_discr does not have DIE reference form"
16186 " - DIE at %s [in module %s]"),
16187 sect_offset_str (die
->sect_off
),
16188 objfile_name (cu
->per_objfile
->objfile
));
16191 for (die_info
*child_die
= die
->child
;
16193 child_die
= child_die
->sibling
)
16194 handle_struct_member_die (child_die
, type
, fi
, template_args
, cu
);
16197 /* A helper for handle_struct_member_die that handles
16201 handle_variant (struct die_info
*die
, struct type
*type
,
16202 struct field_info
*fi
,
16203 std::vector
<struct symbol
*> *template_args
,
16204 struct dwarf2_cu
*cu
)
16206 if (fi
->current_variant_part
== nullptr)
16208 complaint (_("saw DW_TAG_variant outside DW_TAG_variant_part "
16209 "- DIE at %s [in module %s]"),
16210 sect_offset_str (die
->sect_off
),
16211 objfile_name (cu
->per_objfile
->objfile
));
16214 if (fi
->current_variant_part
->processing_variant
)
16216 complaint (_("nested DW_TAG_variant seen "
16217 "- DIE at %s [in module %s]"),
16218 sect_offset_str (die
->sect_off
),
16219 objfile_name (cu
->per_objfile
->objfile
));
16223 scoped_restore save_processing_variant
16224 = make_scoped_restore (&fi
->current_variant_part
->processing_variant
,
16227 fi
->current_variant_part
->variants
.emplace_back ();
16228 variant_field
&variant
= fi
->current_variant_part
->variants
.back ();
16229 variant
.first_field
= fi
->fields
.size ();
16231 /* In a variant we want to get the discriminant and also add a
16232 field for our sole member child. */
16233 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr_value
, cu
);
16234 if (discr
== nullptr || !discr
->form_is_constant ())
16236 discr
= dwarf2_attr (die
, DW_AT_discr_list
, cu
);
16237 if (discr
== nullptr || discr
->as_block ()->size
== 0)
16238 variant
.default_branch
= true;
16240 variant
.discr_list_data
= discr
->as_block ();
16243 variant
.discriminant_value
= discr
->constant_value (0);
16245 for (die_info
*variant_child
= die
->child
;
16246 variant_child
!= NULL
;
16247 variant_child
= variant_child
->sibling
)
16248 handle_struct_member_die (variant_child
, type
, fi
, template_args
, cu
);
16250 variant
.last_field
= fi
->fields
.size ();
16253 /* A helper for process_structure_scope that handles a single member
16257 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
16258 struct field_info
*fi
,
16259 std::vector
<struct symbol
*> *template_args
,
16260 struct dwarf2_cu
*cu
)
16262 if (child_die
->tag
== DW_TAG_member
16263 || child_die
->tag
== DW_TAG_variable
)
16265 /* NOTE: carlton/2002-11-05: A C++ static data member
16266 should be a DW_TAG_member that is a declaration, but
16267 all versions of G++ as of this writing (so through at
16268 least 3.2.1) incorrectly generate DW_TAG_variable
16269 tags for them instead. */
16270 dwarf2_add_field (fi
, child_die
, cu
);
16272 else if (child_die
->tag
== DW_TAG_subprogram
)
16274 /* Rust doesn't have member functions in the C++ sense.
16275 However, it does emit ordinary functions as children
16276 of a struct DIE. */
16277 if (cu
->language
== language_rust
)
16278 read_func_scope (child_die
, cu
);
16281 /* C++ member function. */
16282 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
16285 else if (child_die
->tag
== DW_TAG_inheritance
)
16287 /* C++ base class field. */
16288 dwarf2_add_field (fi
, child_die
, cu
);
16290 else if (type_can_define_types (child_die
))
16291 dwarf2_add_type_defn (fi
, child_die
, cu
);
16292 else if (child_die
->tag
== DW_TAG_template_type_param
16293 || child_die
->tag
== DW_TAG_template_value_param
)
16295 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
16298 template_args
->push_back (arg
);
16300 else if (child_die
->tag
== DW_TAG_variant_part
)
16301 handle_variant_part (child_die
, type
, fi
, template_args
, cu
);
16302 else if (child_die
->tag
== DW_TAG_variant
)
16303 handle_variant (child_die
, type
, fi
, template_args
, cu
);
16306 /* Finish creating a structure or union type, including filling in
16307 its members and creating a symbol for it. */
16310 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16312 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16313 struct die_info
*child_die
;
16316 type
= get_die_type (die
, cu
);
16318 type
= read_structure_type (die
, cu
);
16320 bool has_template_parameters
= false;
16321 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
16323 struct field_info fi
;
16324 std::vector
<struct symbol
*> template_args
;
16326 child_die
= die
->child
;
16328 while (child_die
&& child_die
->tag
)
16330 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
16331 child_die
= child_die
->sibling
;
16334 /* Attach template arguments to type. */
16335 if (!template_args
.empty ())
16337 has_template_parameters
= true;
16338 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16339 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
16340 TYPE_TEMPLATE_ARGUMENTS (type
)
16341 = XOBNEWVEC (&objfile
->objfile_obstack
,
16343 TYPE_N_TEMPLATE_ARGUMENTS (type
));
16344 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
16345 template_args
.data (),
16346 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
16347 * sizeof (struct symbol
*)));
16350 /* Attach fields and member functions to the type. */
16351 if (fi
.nfields () > 0)
16352 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
16353 if (!fi
.fnfieldlists
.empty ())
16355 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
16357 /* Get the type which refers to the base class (possibly this
16358 class itself) which contains the vtable pointer for the current
16359 class from the DW_AT_containing_type attribute. This use of
16360 DW_AT_containing_type is a GNU extension. */
16362 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
16364 struct type
*t
= die_containing_type (die
, cu
);
16366 set_type_vptr_basetype (type
, t
);
16371 /* Our own class provides vtbl ptr. */
16372 for (i
= t
->num_fields () - 1;
16373 i
>= TYPE_N_BASECLASSES (t
);
16376 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
16378 if (is_vtable_name (fieldname
, cu
))
16380 set_type_vptr_fieldno (type
, i
);
16385 /* Complain if virtual function table field not found. */
16386 if (i
< TYPE_N_BASECLASSES (t
))
16387 complaint (_("virtual function table pointer "
16388 "not found when defining class '%s'"),
16389 type
->name () ? type
->name () : "");
16393 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
16396 else if (cu
->producer
16397 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
16399 /* The IBM XLC compiler does not provide direct indication
16400 of the containing type, but the vtable pointer is
16401 always named __vfp. */
16405 for (i
= type
->num_fields () - 1;
16406 i
>= TYPE_N_BASECLASSES (type
);
16409 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
16411 set_type_vptr_fieldno (type
, i
);
16412 set_type_vptr_basetype (type
, type
);
16419 /* Copy fi.typedef_field_list linked list elements content into the
16420 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16421 if (!fi
.typedef_field_list
.empty ())
16423 int count
= fi
.typedef_field_list
.size ();
16425 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16426 TYPE_TYPEDEF_FIELD_ARRAY (type
)
16427 = ((struct decl_field
*)
16429 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
16430 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
16432 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
16433 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
16436 /* Copy fi.nested_types_list linked list elements content into the
16437 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16438 if (!fi
.nested_types_list
.empty () && cu
->language
!= language_ada
)
16440 int count
= fi
.nested_types_list
.size ();
16442 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16443 TYPE_NESTED_TYPES_ARRAY (type
)
16444 = ((struct decl_field
*)
16445 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
16446 TYPE_NESTED_TYPES_COUNT (type
) = count
;
16448 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
16449 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
16453 quirk_gcc_member_function_pointer (type
, objfile
);
16454 if (cu
->language
== language_rust
&& die
->tag
== DW_TAG_union_type
)
16455 cu
->rust_unions
.push_back (type
);
16456 else if (cu
->language
== language_ada
)
16457 quirk_ada_thick_pointer_struct (die
, cu
, type
);
16459 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16460 snapshots) has been known to create a die giving a declaration
16461 for a class that has, as a child, a die giving a definition for a
16462 nested class. So we have to process our children even if the
16463 current die is a declaration. Normally, of course, a declaration
16464 won't have any children at all. */
16466 child_die
= die
->child
;
16468 while (child_die
!= NULL
&& child_die
->tag
)
16470 if (child_die
->tag
== DW_TAG_member
16471 || child_die
->tag
== DW_TAG_variable
16472 || child_die
->tag
== DW_TAG_inheritance
16473 || child_die
->tag
== DW_TAG_template_value_param
16474 || child_die
->tag
== DW_TAG_template_type_param
)
16479 process_die (child_die
, cu
);
16481 child_die
= child_die
->sibling
;
16484 /* Do not consider external references. According to the DWARF standard,
16485 these DIEs are identified by the fact that they have no byte_size
16486 attribute, and a declaration attribute. */
16487 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16488 || !die_is_declaration (die
, cu
)
16489 || dwarf2_attr (die
, DW_AT_signature
, cu
) != NULL
)
16491 struct symbol
*sym
= new_symbol (die
, type
, cu
);
16493 if (has_template_parameters
)
16495 struct symtab
*symtab
;
16496 if (sym
!= nullptr)
16497 symtab
= symbol_symtab (sym
);
16498 else if (cu
->line_header
!= nullptr)
16500 /* Any related symtab will do. */
16502 = cu
->line_header
->file_names ()[0].symtab
;
16507 complaint (_("could not find suitable "
16508 "symtab for template parameter"
16509 " - DIE at %s [in module %s]"),
16510 sect_offset_str (die
->sect_off
),
16511 objfile_name (objfile
));
16514 if (symtab
!= nullptr)
16516 /* Make sure that the symtab is set on the new symbols.
16517 Even though they don't appear in this symtab directly,
16518 other parts of gdb assume that symbols do, and this is
16519 reasonably true. */
16520 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
16521 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
16527 /* Assuming DIE is an enumeration type, and TYPE is its associated
16528 type, update TYPE using some information only available in DIE's
16529 children. In particular, the fields are computed. */
16532 update_enumeration_type_from_children (struct die_info
*die
,
16534 struct dwarf2_cu
*cu
)
16536 struct die_info
*child_die
;
16537 int unsigned_enum
= 1;
16540 auto_obstack obstack
;
16541 std::vector
<struct field
> fields
;
16543 for (child_die
= die
->child
;
16544 child_die
!= NULL
&& child_die
->tag
;
16545 child_die
= child_die
->sibling
)
16547 struct attribute
*attr
;
16549 const gdb_byte
*bytes
;
16550 struct dwarf2_locexpr_baton
*baton
;
16553 if (child_die
->tag
!= DW_TAG_enumerator
)
16556 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16560 name
= dwarf2_name (child_die
, cu
);
16562 name
= "<anonymous enumerator>";
16564 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16565 &value
, &bytes
, &baton
);
16573 if (count_one_bits_ll (value
) >= 2)
16577 fields
.emplace_back ();
16578 struct field
&field
= fields
.back ();
16579 FIELD_NAME (field
) = dwarf2_physname (name
, child_die
, cu
);
16580 SET_FIELD_ENUMVAL (field
, value
);
16583 if (!fields
.empty ())
16585 type
->set_num_fields (fields
.size ());
16588 TYPE_ALLOC (type
, sizeof (struct field
) * fields
.size ()));
16589 memcpy (type
->fields (), fields
.data (),
16590 sizeof (struct field
) * fields
.size ());
16594 type
->set_is_unsigned (true);
16597 TYPE_FLAG_ENUM (type
) = 1;
16600 /* Given a DW_AT_enumeration_type die, set its type. We do not
16601 complete the type's fields yet, or create any symbols. */
16603 static struct type
*
16604 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16606 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16608 struct attribute
*attr
;
16611 /* If the definition of this type lives in .debug_types, read that type.
16612 Don't follow DW_AT_specification though, that will take us back up
16613 the chain and we want to go down. */
16614 attr
= die
->attr (DW_AT_signature
);
16615 if (attr
!= nullptr)
16617 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16619 /* The type's CU may not be the same as CU.
16620 Ensure TYPE is recorded with CU in die_type_hash. */
16621 return set_die_type (die
, type
, cu
);
16624 type
= alloc_type (objfile
);
16626 type
->set_code (TYPE_CODE_ENUM
);
16627 name
= dwarf2_full_name (NULL
, die
, cu
);
16629 type
->set_name (name
);
16631 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16634 struct type
*underlying_type
= die_type (die
, cu
);
16636 TYPE_TARGET_TYPE (type
) = underlying_type
;
16639 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16640 if (attr
!= nullptr)
16642 TYPE_LENGTH (type
) = attr
->constant_value (0);
16646 TYPE_LENGTH (type
) = 0;
16649 maybe_set_alignment (cu
, die
, type
);
16651 /* The enumeration DIE can be incomplete. In Ada, any type can be
16652 declared as private in the package spec, and then defined only
16653 inside the package body. Such types are known as Taft Amendment
16654 Types. When another package uses such a type, an incomplete DIE
16655 may be generated by the compiler. */
16656 if (die_is_declaration (die
, cu
))
16657 type
->set_is_stub (true);
16659 /* If this type has an underlying type that is not a stub, then we
16660 may use its attributes. We always use the "unsigned" attribute
16661 in this situation, because ordinarily we guess whether the type
16662 is unsigned -- but the guess can be wrong and the underlying type
16663 can tell us the reality. However, we defer to a local size
16664 attribute if one exists, because this lets the compiler override
16665 the underlying type if needed. */
16666 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_TARGET_TYPE (type
)->is_stub ())
16668 struct type
*underlying_type
= TYPE_TARGET_TYPE (type
);
16669 underlying_type
= check_typedef (underlying_type
);
16671 type
->set_is_unsigned (underlying_type
->is_unsigned ());
16673 if (TYPE_LENGTH (type
) == 0)
16674 TYPE_LENGTH (type
) = TYPE_LENGTH (underlying_type
);
16676 if (TYPE_RAW_ALIGN (type
) == 0
16677 && TYPE_RAW_ALIGN (underlying_type
) != 0)
16678 set_type_align (type
, TYPE_RAW_ALIGN (underlying_type
));
16681 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
16683 set_die_type (die
, type
, cu
);
16685 /* Finish the creation of this type by using the enum's children.
16686 Note that, as usual, this must come after set_die_type to avoid
16687 infinite recursion when trying to compute the names of the
16689 update_enumeration_type_from_children (die
, type
, cu
);
16694 /* Given a pointer to a die which begins an enumeration, process all
16695 the dies that define the members of the enumeration, and create the
16696 symbol for the enumeration type.
16698 NOTE: We reverse the order of the element list. */
16701 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16703 struct type
*this_type
;
16705 this_type
= get_die_type (die
, cu
);
16706 if (this_type
== NULL
)
16707 this_type
= read_enumeration_type (die
, cu
);
16709 if (die
->child
!= NULL
)
16711 struct die_info
*child_die
;
16714 child_die
= die
->child
;
16715 while (child_die
&& child_die
->tag
)
16717 if (child_die
->tag
!= DW_TAG_enumerator
)
16719 process_die (child_die
, cu
);
16723 name
= dwarf2_name (child_die
, cu
);
16725 new_symbol (child_die
, this_type
, cu
);
16728 child_die
= child_die
->sibling
;
16732 /* If we are reading an enum from a .debug_types unit, and the enum
16733 is a declaration, and the enum is not the signatured type in the
16734 unit, then we do not want to add a symbol for it. Adding a
16735 symbol would in some cases obscure the true definition of the
16736 enum, giving users an incomplete type when the definition is
16737 actually available. Note that we do not want to do this for all
16738 enums which are just declarations, because C++0x allows forward
16739 enum declarations. */
16740 if (cu
->per_cu
->is_debug_types
16741 && die_is_declaration (die
, cu
))
16743 struct signatured_type
*sig_type
;
16745 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16746 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16747 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16751 new_symbol (die
, this_type
, cu
);
16754 /* Helper function for quirk_ada_thick_pointer that examines a bounds
16755 expression for an index type and finds the corresponding field
16756 offset in the hidden "P_BOUNDS" structure. Returns true on success
16757 and updates *FIELD, false if it fails to recognize an
16761 recognize_bound_expression (struct die_info
*die
, enum dwarf_attribute name
,
16762 int *bounds_offset
, struct field
*field
,
16763 struct dwarf2_cu
*cu
)
16765 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
16766 if (attr
== nullptr || !attr
->form_is_block ())
16769 const struct dwarf_block
*block
= attr
->as_block ();
16770 const gdb_byte
*start
= block
->data
;
16771 const gdb_byte
*end
= block
->data
+ block
->size
;
16773 /* The expression to recognize generally looks like:
16775 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16776 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
16778 However, the second "plus_uconst" may be missing:
16780 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16781 DW_OP_deref_size: 4)
16783 This happens when the field is at the start of the structure.
16785 Also, the final deref may not be sized:
16787 (DW_OP_push_object_address; DW_OP_plus_uconst: 4; DW_OP_deref;
16790 This happens when the size of the index type happens to be the
16791 same as the architecture's word size. This can occur with or
16792 without the second plus_uconst. */
16794 if (end
- start
< 2)
16796 if (*start
++ != DW_OP_push_object_address
)
16798 if (*start
++ != DW_OP_plus_uconst
)
16801 uint64_t this_bound_off
;
16802 start
= gdb_read_uleb128 (start
, end
, &this_bound_off
);
16803 if (start
== nullptr || (int) this_bound_off
!= this_bound_off
)
16805 /* Update *BOUNDS_OFFSET if needed, or alternatively verify that it
16806 is consistent among all bounds. */
16807 if (*bounds_offset
== -1)
16808 *bounds_offset
= this_bound_off
;
16809 else if (*bounds_offset
!= this_bound_off
)
16812 if (start
== end
|| *start
++ != DW_OP_deref
)
16818 else if (*start
== DW_OP_deref_size
|| *start
== DW_OP_deref
)
16820 /* This means an offset of 0. */
16822 else if (*start
++ != DW_OP_plus_uconst
)
16826 /* The size is the parameter to DW_OP_plus_uconst. */
16828 start
= gdb_read_uleb128 (start
, end
, &val
);
16829 if (start
== nullptr)
16831 if ((int) val
!= val
)
16840 if (*start
== DW_OP_deref_size
)
16842 start
= gdb_read_uleb128 (start
+ 1, end
, &size
);
16843 if (start
== nullptr)
16846 else if (*start
== DW_OP_deref
)
16848 size
= cu
->header
.addr_size
;
16854 SET_FIELD_BITPOS (*field
, 8 * offset
);
16855 if (size
!= TYPE_LENGTH (field
->type ()))
16856 FIELD_BITSIZE (*field
) = 8 * size
;
16861 /* With -fgnat-encodings=minimal, gcc will emit some unusual DWARF for
16862 some kinds of Ada arrays:
16864 <1><11db>: Abbrev Number: 7 (DW_TAG_array_type)
16865 <11dc> DW_AT_name : (indirect string, offset: 0x1bb8): string
16866 <11e0> DW_AT_data_location: 2 byte block: 97 6
16867 (DW_OP_push_object_address; DW_OP_deref)
16868 <11e3> DW_AT_type : <0x1173>
16869 <11e7> DW_AT_sibling : <0x1201>
16870 <2><11eb>: Abbrev Number: 8 (DW_TAG_subrange_type)
16871 <11ec> DW_AT_type : <0x1206>
16872 <11f0> DW_AT_lower_bound : 6 byte block: 97 23 8 6 94 4
16873 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16874 DW_OP_deref_size: 4)
16875 <11f7> DW_AT_upper_bound : 8 byte block: 97 23 8 6 23 4 94 4
16876 (DW_OP_push_object_address; DW_OP_plus_uconst: 8; DW_OP_deref;
16877 DW_OP_plus_uconst: 4; DW_OP_deref_size: 4)
16879 This actually represents a "thick pointer", which is a structure
16880 with two elements: one that is a pointer to the array data, and one
16881 that is a pointer to another structure; this second structure holds
16884 This returns a new type on success, or nullptr if this didn't
16885 recognize the type. */
16887 static struct type
*
16888 quirk_ada_thick_pointer (struct die_info
*die
, struct dwarf2_cu
*cu
,
16891 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
16892 /* So far we've only seen this with block form. */
16893 if (attr
== nullptr || !attr
->form_is_block ())
16896 /* Note that this will fail if the structure layout is changed by
16897 the compiler. However, we have no good way to recognize some
16898 other layout, because we don't know what expression the compiler
16899 might choose to emit should this happen. */
16900 struct dwarf_block
*blk
= attr
->as_block ();
16902 || blk
->data
[0] != DW_OP_push_object_address
16903 || blk
->data
[1] != DW_OP_deref
)
16906 int bounds_offset
= -1;
16907 int max_align
= -1;
16908 std::vector
<struct field
> range_fields
;
16909 for (struct die_info
*child_die
= die
->child
;
16911 child_die
= child_die
->sibling
)
16913 if (child_die
->tag
== DW_TAG_subrange_type
)
16915 struct type
*underlying
= read_subrange_index_type (child_die
, cu
);
16917 int this_align
= type_align (underlying
);
16918 if (this_align
> max_align
)
16919 max_align
= this_align
;
16921 range_fields
.emplace_back ();
16922 range_fields
.emplace_back ();
16924 struct field
&lower
= range_fields
[range_fields
.size () - 2];
16925 struct field
&upper
= range_fields
[range_fields
.size () - 1];
16927 lower
.set_type (underlying
);
16928 FIELD_ARTIFICIAL (lower
) = 1;
16930 upper
.set_type (underlying
);
16931 FIELD_ARTIFICIAL (upper
) = 1;
16933 if (!recognize_bound_expression (child_die
, DW_AT_lower_bound
,
16934 &bounds_offset
, &lower
, cu
)
16935 || !recognize_bound_expression (child_die
, DW_AT_upper_bound
,
16936 &bounds_offset
, &upper
, cu
))
16941 /* This shouldn't really happen, but double-check that we found
16942 where the bounds are stored. */
16943 if (bounds_offset
== -1)
16946 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
16947 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
16951 /* Set the name of each field in the bounds. */
16952 xsnprintf (name
, sizeof (name
), "LB%d", i
/ 2);
16953 FIELD_NAME (range_fields
[i
]) = objfile
->intern (name
);
16954 xsnprintf (name
, sizeof (name
), "UB%d", i
/ 2);
16955 FIELD_NAME (range_fields
[i
+ 1]) = objfile
->intern (name
);
16958 struct type
*bounds
= alloc_type (objfile
);
16959 bounds
->set_code (TYPE_CODE_STRUCT
);
16961 bounds
->set_num_fields (range_fields
.size ());
16963 ((struct field
*) TYPE_ALLOC (bounds
, (bounds
->num_fields ()
16964 * sizeof (struct field
))));
16965 memcpy (bounds
->fields (), range_fields
.data (),
16966 bounds
->num_fields () * sizeof (struct field
));
16968 int last_fieldno
= range_fields
.size () - 1;
16969 int bounds_size
= (TYPE_FIELD_BITPOS (bounds
, last_fieldno
) / 8
16970 + TYPE_LENGTH (bounds
->field (last_fieldno
).type ()));
16971 TYPE_LENGTH (bounds
) = align_up (bounds_size
, max_align
);
16973 /* Rewrite the existing array type in place. Specifically, we
16974 remove any dynamic properties we might have read, and we replace
16975 the index types. */
16976 struct type
*iter
= type
;
16977 for (int i
= 0; i
< range_fields
.size (); i
+= 2)
16979 gdb_assert (iter
->code () == TYPE_CODE_ARRAY
);
16980 iter
->main_type
->dyn_prop_list
= nullptr;
16981 iter
->set_index_type
16982 (create_static_range_type (NULL
, bounds
->field (i
).type (), 1, 0));
16983 iter
= TYPE_TARGET_TYPE (iter
);
16986 struct type
*result
= alloc_type (objfile
);
16987 result
->set_code (TYPE_CODE_STRUCT
);
16989 result
->set_num_fields (2);
16991 ((struct field
*) TYPE_ZALLOC (result
, (result
->num_fields ()
16992 * sizeof (struct field
))));
16994 /* The names are chosen to coincide with what the compiler does with
16995 -fgnat-encodings=all, which the Ada code in gdb already
16997 TYPE_FIELD_NAME (result
, 0) = "P_ARRAY";
16998 result
->field (0).set_type (lookup_pointer_type (type
));
17000 TYPE_FIELD_NAME (result
, 1) = "P_BOUNDS";
17001 result
->field (1).set_type (lookup_pointer_type (bounds
));
17002 SET_FIELD_BITPOS (result
->field (1), 8 * bounds_offset
);
17004 result
->set_name (type
->name ());
17005 TYPE_LENGTH (result
) = (TYPE_LENGTH (result
->field (0).type ())
17006 + TYPE_LENGTH (result
->field (1).type ()));
17011 /* Extract all information from a DW_TAG_array_type DIE and put it in
17012 the DIE's type field. For now, this only handles one dimensional
17015 static struct type
*
17016 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17018 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17019 struct die_info
*child_die
;
17021 struct type
*element_type
, *range_type
, *index_type
;
17022 struct attribute
*attr
;
17024 struct dynamic_prop
*byte_stride_prop
= NULL
;
17025 unsigned int bit_stride
= 0;
17027 element_type
= die_type (die
, cu
);
17029 /* The die_type call above may have already set the type for this DIE. */
17030 type
= get_die_type (die
, cu
);
17034 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
17038 struct type
*prop_type
= cu
->addr_sized_int_type (false);
17041 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
17042 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
17046 complaint (_("unable to read array DW_AT_byte_stride "
17047 " - DIE at %s [in module %s]"),
17048 sect_offset_str (die
->sect_off
),
17049 objfile_name (cu
->per_objfile
->objfile
));
17050 /* Ignore this attribute. We will likely not be able to print
17051 arrays of this type correctly, but there is little we can do
17052 to help if we cannot read the attribute's value. */
17053 byte_stride_prop
= NULL
;
17057 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
17059 bit_stride
= attr
->constant_value (0);
17061 /* Irix 6.2 native cc creates array types without children for
17062 arrays with unspecified length. */
17063 if (die
->child
== NULL
)
17065 index_type
= objfile_type (objfile
)->builtin_int
;
17066 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
17067 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
17068 byte_stride_prop
, bit_stride
);
17069 return set_die_type (die
, type
, cu
);
17072 std::vector
<struct type
*> range_types
;
17073 child_die
= die
->child
;
17074 while (child_die
&& child_die
->tag
)
17076 if (child_die
->tag
== DW_TAG_subrange_type
)
17078 struct type
*child_type
= read_type_die (child_die
, cu
);
17080 if (child_type
!= NULL
)
17082 /* The range type was succesfully read. Save it for the
17083 array type creation. */
17084 range_types
.push_back (child_type
);
17087 child_die
= child_die
->sibling
;
17090 /* Dwarf2 dimensions are output from left to right, create the
17091 necessary array types in backwards order. */
17093 type
= element_type
;
17095 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
17099 while (i
< range_types
.size ())
17101 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
17102 byte_stride_prop
, bit_stride
);
17104 byte_stride_prop
= nullptr;
17109 size_t ndim
= range_types
.size ();
17112 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
17113 byte_stride_prop
, bit_stride
);
17115 byte_stride_prop
= nullptr;
17119 /* Understand Dwarf2 support for vector types (like they occur on
17120 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
17121 array type. This is not part of the Dwarf2/3 standard yet, but a
17122 custom vendor extension. The main difference between a regular
17123 array and the vector variant is that vectors are passed by value
17125 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
17126 if (attr
!= nullptr)
17127 make_vector_type (type
);
17129 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
17130 implementation may choose to implement triple vectors using this
17132 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17133 if (attr
!= nullptr && attr
->form_is_unsigned ())
17135 if (attr
->as_unsigned () >= TYPE_LENGTH (type
))
17136 TYPE_LENGTH (type
) = attr
->as_unsigned ();
17138 complaint (_("DW_AT_byte_size for array type smaller "
17139 "than the total size of elements"));
17142 name
= dwarf2_name (die
, cu
);
17144 type
->set_name (name
);
17146 maybe_set_alignment (cu
, die
, type
);
17148 struct type
*replacement_type
= nullptr;
17149 if (cu
->language
== language_ada
)
17151 replacement_type
= quirk_ada_thick_pointer (die
, cu
, type
);
17152 if (replacement_type
!= nullptr)
17153 type
= replacement_type
;
17156 /* Install the type in the die. */
17157 set_die_type (die
, type
, cu
, replacement_type
!= nullptr);
17159 /* set_die_type should be already done. */
17160 set_descriptive_type (type
, die
, cu
);
17165 static enum dwarf_array_dim_ordering
17166 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
17168 struct attribute
*attr
;
17170 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
17172 if (attr
!= nullptr)
17174 LONGEST val
= attr
->constant_value (-1);
17175 if (val
== DW_ORD_row_major
|| val
== DW_ORD_col_major
)
17176 return (enum dwarf_array_dim_ordering
) val
;
17179 /* GNU F77 is a special case, as at 08/2004 array type info is the
17180 opposite order to the dwarf2 specification, but data is still
17181 laid out as per normal fortran.
17183 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
17184 version checking. */
17186 if (cu
->language
== language_fortran
17187 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
17189 return DW_ORD_row_major
;
17192 switch (cu
->language_defn
->array_ordering ())
17194 case array_column_major
:
17195 return DW_ORD_col_major
;
17196 case array_row_major
:
17198 return DW_ORD_row_major
;
17202 /* Extract all information from a DW_TAG_set_type DIE and put it in
17203 the DIE's type field. */
17205 static struct type
*
17206 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17208 struct type
*domain_type
, *set_type
;
17209 struct attribute
*attr
;
17211 domain_type
= die_type (die
, cu
);
17213 /* The die_type call above may have already set the type for this DIE. */
17214 set_type
= get_die_type (die
, cu
);
17218 set_type
= create_set_type (NULL
, domain_type
);
17220 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17221 if (attr
!= nullptr && attr
->form_is_unsigned ())
17222 TYPE_LENGTH (set_type
) = attr
->as_unsigned ();
17224 maybe_set_alignment (cu
, die
, set_type
);
17226 return set_die_type (die
, set_type
, cu
);
17229 /* A helper for read_common_block that creates a locexpr baton.
17230 SYM is the symbol which we are marking as computed.
17231 COMMON_DIE is the DIE for the common block.
17232 COMMON_LOC is the location expression attribute for the common
17234 MEMBER_LOC is the location expression attribute for the particular
17235 member of the common block that we are processing.
17236 CU is the CU from which the above come. */
17239 mark_common_block_symbol_computed (struct symbol
*sym
,
17240 struct die_info
*common_die
,
17241 struct attribute
*common_loc
,
17242 struct attribute
*member_loc
,
17243 struct dwarf2_cu
*cu
)
17245 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
17246 struct objfile
*objfile
= per_objfile
->objfile
;
17247 struct dwarf2_locexpr_baton
*baton
;
17249 unsigned int cu_off
;
17250 enum bfd_endian byte_order
= gdbarch_byte_order (objfile
->arch ());
17251 LONGEST offset
= 0;
17253 gdb_assert (common_loc
&& member_loc
);
17254 gdb_assert (common_loc
->form_is_block ());
17255 gdb_assert (member_loc
->form_is_block ()
17256 || member_loc
->form_is_constant ());
17258 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
17259 baton
->per_objfile
= per_objfile
;
17260 baton
->per_cu
= cu
->per_cu
;
17261 gdb_assert (baton
->per_cu
);
17263 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
17265 if (member_loc
->form_is_constant ())
17267 offset
= member_loc
->constant_value (0);
17268 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
17271 baton
->size
+= member_loc
->as_block ()->size
;
17273 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
17276 *ptr
++ = DW_OP_call4
;
17277 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
17278 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
17281 if (member_loc
->form_is_constant ())
17283 *ptr
++ = DW_OP_addr
;
17284 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
17285 ptr
+= cu
->header
.addr_size
;
17289 /* We have to copy the data here, because DW_OP_call4 will only
17290 use a DW_AT_location attribute. */
17291 struct dwarf_block
*block
= member_loc
->as_block ();
17292 memcpy (ptr
, block
->data
, block
->size
);
17293 ptr
+= block
->size
;
17296 *ptr
++ = DW_OP_plus
;
17297 gdb_assert (ptr
- baton
->data
== baton
->size
);
17299 SYMBOL_LOCATION_BATON (sym
) = baton
;
17300 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
17303 /* Create appropriate locally-scoped variables for all the
17304 DW_TAG_common_block entries. Also create a struct common_block
17305 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
17306 is used to separate the common blocks name namespace from regular
17310 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
17312 struct attribute
*attr
;
17314 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
17315 if (attr
!= nullptr)
17317 /* Support the .debug_loc offsets. */
17318 if (attr
->form_is_block ())
17322 else if (attr
->form_is_section_offset ())
17324 dwarf2_complex_location_expr_complaint ();
17329 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17330 "common block member");
17335 if (die
->child
!= NULL
)
17337 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17338 struct die_info
*child_die
;
17339 size_t n_entries
= 0, size
;
17340 struct common_block
*common_block
;
17341 struct symbol
*sym
;
17343 for (child_die
= die
->child
;
17344 child_die
&& child_die
->tag
;
17345 child_die
= child_die
->sibling
)
17348 size
= (sizeof (struct common_block
)
17349 + (n_entries
- 1) * sizeof (struct symbol
*));
17351 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
17353 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
17354 common_block
->n_entries
= 0;
17356 for (child_die
= die
->child
;
17357 child_die
&& child_die
->tag
;
17358 child_die
= child_die
->sibling
)
17360 /* Create the symbol in the DW_TAG_common_block block in the current
17362 sym
= new_symbol (child_die
, NULL
, cu
);
17365 struct attribute
*member_loc
;
17367 common_block
->contents
[common_block
->n_entries
++] = sym
;
17369 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
17373 /* GDB has handled this for a long time, but it is
17374 not specified by DWARF. It seems to have been
17375 emitted by gfortran at least as recently as:
17376 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
17377 complaint (_("Variable in common block has "
17378 "DW_AT_data_member_location "
17379 "- DIE at %s [in module %s]"),
17380 sect_offset_str (child_die
->sect_off
),
17381 objfile_name (objfile
));
17383 if (member_loc
->form_is_section_offset ())
17384 dwarf2_complex_location_expr_complaint ();
17385 else if (member_loc
->form_is_constant ()
17386 || member_loc
->form_is_block ())
17388 if (attr
!= nullptr)
17389 mark_common_block_symbol_computed (sym
, die
, attr
,
17393 dwarf2_complex_location_expr_complaint ();
17398 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
17399 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
17403 /* Create a type for a C++ namespace. */
17405 static struct type
*
17406 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17408 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17409 const char *previous_prefix
, *name
;
17413 /* For extensions, reuse the type of the original namespace. */
17414 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
17416 struct die_info
*ext_die
;
17417 struct dwarf2_cu
*ext_cu
= cu
;
17419 ext_die
= dwarf2_extension (die
, &ext_cu
);
17420 type
= read_type_die (ext_die
, ext_cu
);
17422 /* EXT_CU may not be the same as CU.
17423 Ensure TYPE is recorded with CU in die_type_hash. */
17424 return set_die_type (die
, type
, cu
);
17427 name
= namespace_name (die
, &is_anonymous
, cu
);
17429 /* Now build the name of the current namespace. */
17431 previous_prefix
= determine_prefix (die
, cu
);
17432 if (previous_prefix
[0] != '\0')
17433 name
= typename_concat (&objfile
->objfile_obstack
,
17434 previous_prefix
, name
, 0, cu
);
17436 /* Create the type. */
17437 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
17439 return set_die_type (die
, type
, cu
);
17442 /* Read a namespace scope. */
17445 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
17447 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17450 /* Add a symbol associated to this if we haven't seen the namespace
17451 before. Also, add a using directive if it's an anonymous
17454 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
17458 type
= read_type_die (die
, cu
);
17459 new_symbol (die
, type
, cu
);
17461 namespace_name (die
, &is_anonymous
, cu
);
17464 const char *previous_prefix
= determine_prefix (die
, cu
);
17466 std::vector
<const char *> excludes
;
17467 add_using_directive (using_directives (cu
),
17468 previous_prefix
, type
->name (), NULL
,
17469 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
17473 if (die
->child
!= NULL
)
17475 struct die_info
*child_die
= die
->child
;
17477 while (child_die
&& child_die
->tag
)
17479 process_die (child_die
, cu
);
17480 child_die
= child_die
->sibling
;
17485 /* Read a Fortran module as type. This DIE can be only a declaration used for
17486 imported module. Still we need that type as local Fortran "use ... only"
17487 declaration imports depend on the created type in determine_prefix. */
17489 static struct type
*
17490 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17492 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17493 const char *module_name
;
17496 module_name
= dwarf2_name (die
, cu
);
17497 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
17499 return set_die_type (die
, type
, cu
);
17502 /* Read a Fortran module. */
17505 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
17507 struct die_info
*child_die
= die
->child
;
17510 type
= read_type_die (die
, cu
);
17511 new_symbol (die
, type
, cu
);
17513 while (child_die
&& child_die
->tag
)
17515 process_die (child_die
, cu
);
17516 child_die
= child_die
->sibling
;
17520 /* Return the name of the namespace represented by DIE. Set
17521 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
17524 static const char *
17525 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
17527 struct die_info
*current_die
;
17528 const char *name
= NULL
;
17530 /* Loop through the extensions until we find a name. */
17532 for (current_die
= die
;
17533 current_die
!= NULL
;
17534 current_die
= dwarf2_extension (die
, &cu
))
17536 /* We don't use dwarf2_name here so that we can detect the absence
17537 of a name -> anonymous namespace. */
17538 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
17544 /* Is it an anonymous namespace? */
17546 *is_anonymous
= (name
== NULL
);
17548 name
= CP_ANONYMOUS_NAMESPACE_STR
;
17553 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17554 the user defined type vector. */
17556 static struct type
*
17557 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17559 struct gdbarch
*gdbarch
= cu
->per_objfile
->objfile
->arch ();
17560 struct comp_unit_head
*cu_header
= &cu
->header
;
17562 struct attribute
*attr_byte_size
;
17563 struct attribute
*attr_address_class
;
17564 int byte_size
, addr_class
;
17565 struct type
*target_type
;
17567 target_type
= die_type (die
, cu
);
17569 /* The die_type call above may have already set the type for this DIE. */
17570 type
= get_die_type (die
, cu
);
17574 type
= lookup_pointer_type (target_type
);
17576 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17577 if (attr_byte_size
)
17578 byte_size
= attr_byte_size
->constant_value (cu_header
->addr_size
);
17580 byte_size
= cu_header
->addr_size
;
17582 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
17583 if (attr_address_class
)
17584 addr_class
= attr_address_class
->constant_value (DW_ADDR_none
);
17586 addr_class
= DW_ADDR_none
;
17588 ULONGEST alignment
= get_alignment (cu
, die
);
17590 /* If the pointer size, alignment, or address class is different
17591 than the default, create a type variant marked as such and set
17592 the length accordingly. */
17593 if (TYPE_LENGTH (type
) != byte_size
17594 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
17595 && alignment
!= TYPE_RAW_ALIGN (type
))
17596 || addr_class
!= DW_ADDR_none
)
17598 if (gdbarch_address_class_type_flags_p (gdbarch
))
17600 type_instance_flags type_flags
17601 = gdbarch_address_class_type_flags (gdbarch
, byte_size
,
17603 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17605 type
= make_type_with_address_space (type
, type_flags
);
17607 else if (TYPE_LENGTH (type
) != byte_size
)
17609 complaint (_("invalid pointer size %d"), byte_size
);
17611 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17613 complaint (_("Invalid DW_AT_alignment"
17614 " - DIE at %s [in module %s]"),
17615 sect_offset_str (die
->sect_off
),
17616 objfile_name (cu
->per_objfile
->objfile
));
17620 /* Should we also complain about unhandled address classes? */
17624 TYPE_LENGTH (type
) = byte_size
;
17625 set_type_align (type
, alignment
);
17626 return set_die_type (die
, type
, cu
);
17629 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17630 the user defined type vector. */
17632 static struct type
*
17633 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17636 struct type
*to_type
;
17637 struct type
*domain
;
17639 to_type
= die_type (die
, cu
);
17640 domain
= die_containing_type (die
, cu
);
17642 /* The calls above may have already set the type for this DIE. */
17643 type
= get_die_type (die
, cu
);
17647 if (check_typedef (to_type
)->code () == TYPE_CODE_METHOD
)
17648 type
= lookup_methodptr_type (to_type
);
17649 else if (check_typedef (to_type
)->code () == TYPE_CODE_FUNC
)
17651 struct type
*new_type
= alloc_type (cu
->per_objfile
->objfile
);
17653 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17654 to_type
->fields (), to_type
->num_fields (),
17655 to_type
->has_varargs ());
17656 type
= lookup_methodptr_type (new_type
);
17659 type
= lookup_memberptr_type (to_type
, domain
);
17661 return set_die_type (die
, type
, cu
);
17664 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17665 the user defined type vector. */
17667 static struct type
*
17668 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17669 enum type_code refcode
)
17671 struct comp_unit_head
*cu_header
= &cu
->header
;
17672 struct type
*type
, *target_type
;
17673 struct attribute
*attr
;
17675 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17677 target_type
= die_type (die
, cu
);
17679 /* The die_type call above may have already set the type for this DIE. */
17680 type
= get_die_type (die
, cu
);
17684 type
= lookup_reference_type (target_type
, refcode
);
17685 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17686 if (attr
!= nullptr)
17688 TYPE_LENGTH (type
) = attr
->constant_value (cu_header
->addr_size
);
17692 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17694 maybe_set_alignment (cu
, die
, type
);
17695 return set_die_type (die
, type
, cu
);
17698 /* Add the given cv-qualifiers to the element type of the array. GCC
17699 outputs DWARF type qualifiers that apply to an array, not the
17700 element type. But GDB relies on the array element type to carry
17701 the cv-qualifiers. This mimics section 6.7.3 of the C99
17704 static struct type
*
17705 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17706 struct type
*base_type
, int cnst
, int voltl
)
17708 struct type
*el_type
, *inner_array
;
17710 base_type
= copy_type (base_type
);
17711 inner_array
= base_type
;
17713 while (TYPE_TARGET_TYPE (inner_array
)->code () == TYPE_CODE_ARRAY
)
17715 TYPE_TARGET_TYPE (inner_array
) =
17716 copy_type (TYPE_TARGET_TYPE (inner_array
));
17717 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17720 el_type
= TYPE_TARGET_TYPE (inner_array
);
17721 cnst
|= TYPE_CONST (el_type
);
17722 voltl
|= TYPE_VOLATILE (el_type
);
17723 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17725 return set_die_type (die
, base_type
, cu
);
17728 static struct type
*
17729 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17731 struct type
*base_type
, *cv_type
;
17733 base_type
= die_type (die
, cu
);
17735 /* The die_type call above may have already set the type for this DIE. */
17736 cv_type
= get_die_type (die
, cu
);
17740 /* In case the const qualifier is applied to an array type, the element type
17741 is so qualified, not the array type (section 6.7.3 of C99). */
17742 if (base_type
->code () == TYPE_CODE_ARRAY
)
17743 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17745 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17746 return set_die_type (die
, cv_type
, cu
);
17749 static struct type
*
17750 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17752 struct type
*base_type
, *cv_type
;
17754 base_type
= die_type (die
, cu
);
17756 /* The die_type call above may have already set the type for this DIE. */
17757 cv_type
= get_die_type (die
, cu
);
17761 /* In case the volatile qualifier is applied to an array type, the
17762 element type is so qualified, not the array type (section 6.7.3
17764 if (base_type
->code () == TYPE_CODE_ARRAY
)
17765 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17767 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17768 return set_die_type (die
, cv_type
, cu
);
17771 /* Handle DW_TAG_restrict_type. */
17773 static struct type
*
17774 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17776 struct type
*base_type
, *cv_type
;
17778 base_type
= die_type (die
, cu
);
17780 /* The die_type call above may have already set the type for this DIE. */
17781 cv_type
= get_die_type (die
, cu
);
17785 cv_type
= make_restrict_type (base_type
);
17786 return set_die_type (die
, cv_type
, cu
);
17789 /* Handle DW_TAG_atomic_type. */
17791 static struct type
*
17792 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17794 struct type
*base_type
, *cv_type
;
17796 base_type
= die_type (die
, cu
);
17798 /* The die_type call above may have already set the type for this DIE. */
17799 cv_type
= get_die_type (die
, cu
);
17803 cv_type
= make_atomic_type (base_type
);
17804 return set_die_type (die
, cv_type
, cu
);
17807 /* Extract all information from a DW_TAG_string_type DIE and add to
17808 the user defined type vector. It isn't really a user defined type,
17809 but it behaves like one, with other DIE's using an AT_user_def_type
17810 attribute to reference it. */
17812 static struct type
*
17813 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17815 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17816 struct gdbarch
*gdbarch
= objfile
->arch ();
17817 struct type
*type
, *range_type
, *index_type
, *char_type
;
17818 struct attribute
*attr
;
17819 struct dynamic_prop prop
;
17820 bool length_is_constant
= true;
17823 /* There are a couple of places where bit sizes might be made use of
17824 when parsing a DW_TAG_string_type, however, no producer that we know
17825 of make use of these. Handling bit sizes that are a multiple of the
17826 byte size is easy enough, but what about other bit sizes? Lets deal
17827 with that problem when we have to. Warn about these attributes being
17828 unsupported, then parse the type and ignore them like we always
17830 if (dwarf2_attr (die
, DW_AT_bit_size
, cu
) != nullptr
17831 || dwarf2_attr (die
, DW_AT_string_length_bit_size
, cu
) != nullptr)
17833 static bool warning_printed
= false;
17834 if (!warning_printed
)
17836 warning (_("DW_AT_bit_size and DW_AT_string_length_bit_size not "
17837 "currently supported on DW_TAG_string_type."));
17838 warning_printed
= true;
17842 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17843 if (attr
!= nullptr && !attr
->form_is_constant ())
17845 /* The string length describes the location at which the length of
17846 the string can be found. The size of the length field can be
17847 specified with one of the attributes below. */
17848 struct type
*prop_type
;
17849 struct attribute
*len
17850 = dwarf2_attr (die
, DW_AT_string_length_byte_size
, cu
);
17851 if (len
== nullptr)
17852 len
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17853 if (len
!= nullptr && len
->form_is_constant ())
17855 /* Pass 0 as the default as we know this attribute is constant
17856 and the default value will not be returned. */
17857 LONGEST sz
= len
->constant_value (0);
17858 prop_type
= cu
->per_objfile
->int_type (sz
, true);
17862 /* If the size is not specified then we assume it is the size of
17863 an address on this target. */
17864 prop_type
= cu
->addr_sized_int_type (true);
17867 /* Convert the attribute into a dynamic property. */
17868 if (!attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
17871 length_is_constant
= false;
17873 else if (attr
!= nullptr)
17875 /* This DW_AT_string_length just contains the length with no
17876 indirection. There's no need to create a dynamic property in this
17877 case. Pass 0 for the default value as we know it will not be
17878 returned in this case. */
17879 length
= attr
->constant_value (0);
17881 else if ((attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
)) != nullptr)
17883 /* We don't currently support non-constant byte sizes for strings. */
17884 length
= attr
->constant_value (1);
17888 /* Use 1 as a fallback length if we have nothing else. */
17892 index_type
= objfile_type (objfile
)->builtin_int
;
17893 if (length_is_constant
)
17894 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17897 struct dynamic_prop low_bound
;
17899 low_bound
.set_const_val (1);
17900 range_type
= create_range_type (NULL
, index_type
, &low_bound
, &prop
, 0);
17902 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17903 type
= create_string_type (NULL
, char_type
, range_type
);
17905 return set_die_type (die
, type
, cu
);
17908 /* Assuming that DIE corresponds to a function, returns nonzero
17909 if the function is prototyped. */
17912 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17914 struct attribute
*attr
;
17916 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17917 if (attr
&& attr
->as_boolean ())
17920 /* The DWARF standard implies that the DW_AT_prototyped attribute
17921 is only meaningful for C, but the concept also extends to other
17922 languages that allow unprototyped functions (Eg: Objective C).
17923 For all other languages, assume that functions are always
17925 if (cu
->language
!= language_c
17926 && cu
->language
!= language_objc
17927 && cu
->language
!= language_opencl
)
17930 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17931 prototyped and unprototyped functions; default to prototyped,
17932 since that is more common in modern code (and RealView warns
17933 about unprototyped functions). */
17934 if (producer_is_realview (cu
->producer
))
17940 /* Handle DIES due to C code like:
17944 int (*funcp)(int a, long l);
17948 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17950 static struct type
*
17951 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17953 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
17954 struct type
*type
; /* Type that this function returns. */
17955 struct type
*ftype
; /* Function that returns above type. */
17956 struct attribute
*attr
;
17958 type
= die_type (die
, cu
);
17960 /* The die_type call above may have already set the type for this DIE. */
17961 ftype
= get_die_type (die
, cu
);
17965 ftype
= lookup_function_type (type
);
17967 if (prototyped_function_p (die
, cu
))
17968 ftype
->set_is_prototyped (true);
17970 /* Store the calling convention in the type if it's available in
17971 the subroutine die. Otherwise set the calling convention to
17972 the default value DW_CC_normal. */
17973 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
17974 if (attr
!= nullptr
17975 && is_valid_DW_AT_calling_convention_for_subroutine (attr
->constant_value (0)))
17976 TYPE_CALLING_CONVENTION (ftype
)
17977 = (enum dwarf_calling_convention
) attr
->constant_value (0);
17978 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
17979 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
17981 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
17983 /* Record whether the function returns normally to its caller or not
17984 if the DWARF producer set that information. */
17985 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
17986 if (attr
&& attr
->as_boolean ())
17987 TYPE_NO_RETURN (ftype
) = 1;
17989 /* We need to add the subroutine type to the die immediately so
17990 we don't infinitely recurse when dealing with parameters
17991 declared as the same subroutine type. */
17992 set_die_type (die
, ftype
, cu
);
17994 if (die
->child
!= NULL
)
17996 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
17997 struct die_info
*child_die
;
17998 int nparams
, iparams
;
18000 /* Count the number of parameters.
18001 FIXME: GDB currently ignores vararg functions, but knows about
18002 vararg member functions. */
18004 child_die
= die
->child
;
18005 while (child_die
&& child_die
->tag
)
18007 if (child_die
->tag
== DW_TAG_formal_parameter
)
18009 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
18010 ftype
->set_has_varargs (true);
18012 child_die
= child_die
->sibling
;
18015 /* Allocate storage for parameters and fill them in. */
18016 ftype
->set_num_fields (nparams
);
18018 ((struct field
*) TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
)));
18020 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
18021 even if we error out during the parameters reading below. */
18022 for (iparams
= 0; iparams
< nparams
; iparams
++)
18023 ftype
->field (iparams
).set_type (void_type
);
18026 child_die
= die
->child
;
18027 while (child_die
&& child_die
->tag
)
18029 if (child_die
->tag
== DW_TAG_formal_parameter
)
18031 struct type
*arg_type
;
18033 /* DWARF version 2 has no clean way to discern C++
18034 static and non-static member functions. G++ helps
18035 GDB by marking the first parameter for non-static
18036 member functions (which is the this pointer) as
18037 artificial. We pass this information to
18038 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
18040 DWARF version 3 added DW_AT_object_pointer, which GCC
18041 4.5 does not yet generate. */
18042 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
18043 if (attr
!= nullptr)
18044 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = attr
->as_boolean ();
18046 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
18047 arg_type
= die_type (child_die
, cu
);
18049 /* RealView does not mark THIS as const, which the testsuite
18050 expects. GCC marks THIS as const in method definitions,
18051 but not in the class specifications (GCC PR 43053). */
18052 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
18053 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
18056 struct dwarf2_cu
*arg_cu
= cu
;
18057 const char *name
= dwarf2_name (child_die
, cu
);
18059 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
18060 if (attr
!= nullptr)
18062 /* If the compiler emits this, use it. */
18063 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
18066 else if (name
&& strcmp (name
, "this") == 0)
18067 /* Function definitions will have the argument names. */
18069 else if (name
== NULL
&& iparams
== 0)
18070 /* Declarations may not have the names, so like
18071 elsewhere in GDB, assume an artificial first
18072 argument is "this". */
18076 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
18080 ftype
->field (iparams
).set_type (arg_type
);
18083 child_die
= child_die
->sibling
;
18090 static struct type
*
18091 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
18093 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18094 const char *name
= NULL
;
18095 struct type
*this_type
, *target_type
;
18097 name
= dwarf2_full_name (NULL
, die
, cu
);
18098 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
18099 this_type
->set_target_is_stub (true);
18100 set_die_type (die
, this_type
, cu
);
18101 target_type
= die_type (die
, cu
);
18102 if (target_type
!= this_type
)
18103 TYPE_TARGET_TYPE (this_type
) = target_type
;
18106 /* Self-referential typedefs are, it seems, not allowed by the DWARF
18107 spec and cause infinite loops in GDB. */
18108 complaint (_("Self-referential DW_TAG_typedef "
18109 "- DIE at %s [in module %s]"),
18110 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
18111 TYPE_TARGET_TYPE (this_type
) = NULL
;
18115 /* Gcc-7 and before supports -feliminate-dwarf2-dups, which generates
18116 anonymous typedefs, which is, strictly speaking, invalid DWARF.
18117 Handle these by just returning the target type, rather than
18118 constructing an anonymous typedef type and trying to handle this
18120 set_die_type (die
, target_type
, cu
);
18121 return target_type
;
18126 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
18127 (which may be different from NAME) to the architecture back-end to allow
18128 it to guess the correct format if necessary. */
18130 static struct type
*
18131 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
18132 const char *name_hint
, enum bfd_endian byte_order
)
18134 struct gdbarch
*gdbarch
= objfile
->arch ();
18135 const struct floatformat
**format
;
18138 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
18140 type
= init_float_type (objfile
, bits
, name
, format
, byte_order
);
18142 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18147 /* Allocate an integer type of size BITS and name NAME. */
18149 static struct type
*
18150 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
18151 int bits
, int unsigned_p
, const char *name
)
18155 /* Versions of Intel's C Compiler generate an integer type called "void"
18156 instead of using DW_TAG_unspecified_type. This has been seen on
18157 at least versions 14, 17, and 18. */
18158 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
18159 && strcmp (name
, "void") == 0)
18160 type
= objfile_type (objfile
)->builtin_void
;
18162 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
18167 /* Initialise and return a floating point type of size BITS suitable for
18168 use as a component of a complex number. The NAME_HINT is passed through
18169 when initialising the floating point type and is the name of the complex
18172 As DWARF doesn't currently provide an explicit name for the components
18173 of a complex number, but it can be helpful to have these components
18174 named, we try to select a suitable name based on the size of the
18176 static struct type
*
18177 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
18178 struct objfile
*objfile
,
18179 int bits
, const char *name_hint
,
18180 enum bfd_endian byte_order
)
18182 gdbarch
*gdbarch
= objfile
->arch ();
18183 struct type
*tt
= nullptr;
18185 /* Try to find a suitable floating point builtin type of size BITS.
18186 We're going to use the name of this type as the name for the complex
18187 target type that we are about to create. */
18188 switch (cu
->language
)
18190 case language_fortran
:
18194 tt
= builtin_f_type (gdbarch
)->builtin_real
;
18197 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
18199 case 96: /* The x86-32 ABI specifies 96-bit long double. */
18201 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
18209 tt
= builtin_type (gdbarch
)->builtin_float
;
18212 tt
= builtin_type (gdbarch
)->builtin_double
;
18214 case 96: /* The x86-32 ABI specifies 96-bit long double. */
18216 tt
= builtin_type (gdbarch
)->builtin_long_double
;
18222 /* If the type we found doesn't match the size we were looking for, then
18223 pretend we didn't find a type at all, the complex target type we
18224 create will then be nameless. */
18225 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
18228 const char *name
= (tt
== nullptr) ? nullptr : tt
->name ();
18229 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
, byte_order
);
18232 /* Find a representation of a given base type and install
18233 it in the TYPE field of the die. */
18235 static struct type
*
18236 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18238 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
18240 struct attribute
*attr
;
18241 int encoding
= 0, bits
= 0;
18245 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
18246 if (attr
!= nullptr && attr
->form_is_constant ())
18247 encoding
= attr
->constant_value (0);
18248 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18249 if (attr
!= nullptr)
18250 bits
= attr
->constant_value (0) * TARGET_CHAR_BIT
;
18251 name
= dwarf2_name (die
, cu
);
18253 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
18255 arch
= objfile
->arch ();
18256 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
18258 attr
= dwarf2_attr (die
, DW_AT_endianity
, cu
);
18259 if (attr
!= nullptr && attr
->form_is_constant ())
18261 int endianity
= attr
->constant_value (0);
18266 byte_order
= BFD_ENDIAN_BIG
;
18268 case DW_END_little
:
18269 byte_order
= BFD_ENDIAN_LITTLE
;
18272 complaint (_("DW_AT_endianity has unrecognized value %d"), endianity
);
18279 case DW_ATE_address
:
18280 /* Turn DW_ATE_address into a void * pointer. */
18281 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
18282 type
= init_pointer_type (objfile
, bits
, name
, type
);
18284 case DW_ATE_boolean
:
18285 type
= init_boolean_type (objfile
, bits
, 1, name
);
18287 case DW_ATE_complex_float
:
18288 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
,
18290 if (type
->code () == TYPE_CODE_ERROR
)
18292 if (name
== nullptr)
18294 struct obstack
*obstack
18295 = &cu
->per_objfile
->objfile
->objfile_obstack
;
18296 name
= obconcat (obstack
, "_Complex ", type
->name (),
18299 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18302 type
= init_complex_type (name
, type
);
18304 case DW_ATE_decimal_float
:
18305 type
= init_decfloat_type (objfile
, bits
, name
);
18308 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
, byte_order
);
18310 case DW_ATE_signed
:
18311 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18313 case DW_ATE_unsigned
:
18314 if (cu
->language
== language_fortran
18316 && startswith (name
, "character("))
18317 type
= init_character_type (objfile
, bits
, 1, name
);
18319 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18321 case DW_ATE_signed_char
:
18322 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18323 || cu
->language
== language_pascal
18324 || cu
->language
== language_fortran
)
18325 type
= init_character_type (objfile
, bits
, 0, name
);
18327 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
18329 case DW_ATE_unsigned_char
:
18330 if (cu
->language
== language_ada
|| cu
->language
== language_m2
18331 || cu
->language
== language_pascal
18332 || cu
->language
== language_fortran
18333 || cu
->language
== language_rust
)
18334 type
= init_character_type (objfile
, bits
, 1, name
);
18336 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18341 type
= builtin_type (arch
)->builtin_char16
;
18342 else if (bits
== 32)
18343 type
= builtin_type (arch
)->builtin_char32
;
18346 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
18348 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
18350 return set_die_type (die
, type
, cu
);
18355 complaint (_("unsupported DW_AT_encoding: '%s'"),
18356 dwarf_type_encoding_name (encoding
));
18357 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
18361 if (name
&& strcmp (name
, "char") == 0)
18362 type
->set_has_no_signedness (true);
18364 maybe_set_alignment (cu
, die
, type
);
18366 type
->set_endianity_is_not_default (gdbarch_byte_order (arch
) != byte_order
);
18368 if (TYPE_SPECIFIC_FIELD (type
) == TYPE_SPECIFIC_INT
)
18370 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
18371 if (attr
!= nullptr && attr
->as_unsigned () <= 8 * TYPE_LENGTH (type
))
18373 unsigned real_bit_size
= attr
->as_unsigned ();
18374 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
18375 /* Only use the attributes if they make sense together. */
18376 if (attr
== nullptr
18377 || (attr
->as_unsigned () + real_bit_size
18378 <= 8 * TYPE_LENGTH (type
)))
18380 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_size
18382 if (attr
!= nullptr)
18383 TYPE_MAIN_TYPE (type
)->type_specific
.int_stuff
.bit_offset
18384 = attr
->as_unsigned ();
18389 return set_die_type (die
, type
, cu
);
18392 /* Parse dwarf attribute if it's a block, reference or constant and put the
18393 resulting value of the attribute into struct bound_prop.
18394 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
18397 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
18398 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
18399 struct type
*default_type
)
18401 struct dwarf2_property_baton
*baton
;
18402 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
18403 struct objfile
*objfile
= per_objfile
->objfile
;
18404 struct obstack
*obstack
= &objfile
->objfile_obstack
;
18406 gdb_assert (default_type
!= NULL
);
18408 if (attr
== NULL
|| prop
== NULL
)
18411 if (attr
->form_is_block ())
18413 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18414 baton
->property_type
= default_type
;
18415 baton
->locexpr
.per_cu
= cu
->per_cu
;
18416 baton
->locexpr
.per_objfile
= per_objfile
;
18418 struct dwarf_block
*block
= attr
->as_block ();
18419 baton
->locexpr
.size
= block
->size
;
18420 baton
->locexpr
.data
= block
->data
;
18421 switch (attr
->name
)
18423 case DW_AT_string_length
:
18424 baton
->locexpr
.is_reference
= true;
18427 baton
->locexpr
.is_reference
= false;
18431 prop
->set_locexpr (baton
);
18432 gdb_assert (prop
->baton () != NULL
);
18434 else if (attr
->form_is_ref ())
18436 struct dwarf2_cu
*target_cu
= cu
;
18437 struct die_info
*target_die
;
18438 struct attribute
*target_attr
;
18440 target_die
= follow_die_ref (die
, attr
, &target_cu
);
18441 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
18442 if (target_attr
== NULL
)
18443 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
18445 if (target_attr
== NULL
)
18448 switch (target_attr
->name
)
18450 case DW_AT_location
:
18451 if (target_attr
->form_is_section_offset ())
18453 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18454 baton
->property_type
= die_type (target_die
, target_cu
);
18455 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
18456 prop
->set_loclist (baton
);
18457 gdb_assert (prop
->baton () != NULL
);
18459 else if (target_attr
->form_is_block ())
18461 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18462 baton
->property_type
= die_type (target_die
, target_cu
);
18463 baton
->locexpr
.per_cu
= cu
->per_cu
;
18464 baton
->locexpr
.per_objfile
= per_objfile
;
18465 struct dwarf_block
*block
= target_attr
->as_block ();
18466 baton
->locexpr
.size
= block
->size
;
18467 baton
->locexpr
.data
= block
->data
;
18468 baton
->locexpr
.is_reference
= true;
18469 prop
->set_locexpr (baton
);
18470 gdb_assert (prop
->baton () != NULL
);
18474 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18475 "dynamic property");
18479 case DW_AT_data_member_location
:
18483 if (!handle_data_member_location (target_die
, target_cu
,
18487 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18488 baton
->property_type
= read_type_die (target_die
->parent
,
18490 baton
->offset_info
.offset
= offset
;
18491 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
18492 prop
->set_addr_offset (baton
);
18497 else if (attr
->form_is_constant ())
18498 prop
->set_const_val (attr
->constant_value (0));
18501 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
18502 dwarf2_name (die
, cu
));
18512 dwarf2_per_objfile::int_type (int size_in_bytes
, bool unsigned_p
) const
18514 struct type
*int_type
;
18516 /* Helper macro to examine the various builtin types. */
18517 #define TRY_TYPE(F) \
18518 int_type = (unsigned_p \
18519 ? objfile_type (objfile)->builtin_unsigned_ ## F \
18520 : objfile_type (objfile)->builtin_ ## F); \
18521 if (int_type != NULL && TYPE_LENGTH (int_type) == size_in_bytes) \
18528 TRY_TYPE (long_long
);
18532 gdb_assert_not_reached ("unable to find suitable integer type");
18538 dwarf2_cu::addr_sized_int_type (bool unsigned_p
) const
18540 int addr_size
= this->per_cu
->addr_size ();
18541 return this->per_objfile
->int_type (addr_size
, unsigned_p
);
18544 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
18545 present (which is valid) then compute the default type based on the
18546 compilation units address size. */
18548 static struct type
*
18549 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18551 struct type
*index_type
= die_type (die
, cu
);
18553 /* Dwarf-2 specifications explicitly allows to create subrange types
18554 without specifying a base type.
18555 In that case, the base type must be set to the type of
18556 the lower bound, upper bound or count, in that order, if any of these
18557 three attributes references an object that has a type.
18558 If no base type is found, the Dwarf-2 specifications say that
18559 a signed integer type of size equal to the size of an address should
18561 For the following C code: `extern char gdb_int [];'
18562 GCC produces an empty range DIE.
18563 FIXME: muller/2010-05-28: Possible references to object for low bound,
18564 high bound or count are not yet handled by this code. */
18565 if (index_type
->code () == TYPE_CODE_VOID
)
18566 index_type
= cu
->addr_sized_int_type (false);
18571 /* Read the given DW_AT_subrange DIE. */
18573 static struct type
*
18574 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18576 struct type
*base_type
, *orig_base_type
;
18577 struct type
*range_type
;
18578 struct attribute
*attr
;
18579 struct dynamic_prop low
, high
;
18580 int low_default_is_valid
;
18581 int high_bound_is_count
= 0;
18583 ULONGEST negative_mask
;
18585 orig_base_type
= read_subrange_index_type (die
, cu
);
18587 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
18588 whereas the real type might be. So, we use ORIG_BASE_TYPE when
18589 creating the range type, but we use the result of check_typedef
18590 when examining properties of the type. */
18591 base_type
= check_typedef (orig_base_type
);
18593 /* The die_type call above may have already set the type for this DIE. */
18594 range_type
= get_die_type (die
, cu
);
18598 high
.set_const_val (0);
18600 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
18601 omitting DW_AT_lower_bound. */
18602 switch (cu
->language
)
18605 case language_cplus
:
18606 low
.set_const_val (0);
18607 low_default_is_valid
= 1;
18609 case language_fortran
:
18610 low
.set_const_val (1);
18611 low_default_is_valid
= 1;
18614 case language_objc
:
18615 case language_rust
:
18616 low
.set_const_val (0);
18617 low_default_is_valid
= (cu
->header
.version
>= 4);
18621 case language_pascal
:
18622 low
.set_const_val (1);
18623 low_default_is_valid
= (cu
->header
.version
>= 4);
18626 low
.set_const_val (0);
18627 low_default_is_valid
= 0;
18631 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
18632 if (attr
!= nullptr)
18633 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
18634 else if (!low_default_is_valid
)
18635 complaint (_("Missing DW_AT_lower_bound "
18636 "- DIE at %s [in module %s]"),
18637 sect_offset_str (die
->sect_off
),
18638 objfile_name (cu
->per_objfile
->objfile
));
18640 struct attribute
*attr_ub
, *attr_count
;
18641 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
18642 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18644 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
18645 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18647 /* If bounds are constant do the final calculation here. */
18648 if (low
.kind () == PROP_CONST
&& high
.kind () == PROP_CONST
)
18649 high
.set_const_val (low
.const_val () + high
.const_val () - 1);
18651 high_bound_is_count
= 1;
18655 if (attr_ub
!= NULL
)
18656 complaint (_("Unresolved DW_AT_upper_bound "
18657 "- DIE at %s [in module %s]"),
18658 sect_offset_str (die
->sect_off
),
18659 objfile_name (cu
->per_objfile
->objfile
));
18660 if (attr_count
!= NULL
)
18661 complaint (_("Unresolved DW_AT_count "
18662 "- DIE at %s [in module %s]"),
18663 sect_offset_str (die
->sect_off
),
18664 objfile_name (cu
->per_objfile
->objfile
));
18669 struct attribute
*bias_attr
= dwarf2_attr (die
, DW_AT_GNU_bias
, cu
);
18670 if (bias_attr
!= nullptr && bias_attr
->form_is_constant ())
18671 bias
= bias_attr
->constant_value (0);
18673 /* Normally, the DWARF producers are expected to use a signed
18674 constant form (Eg. DW_FORM_sdata) to express negative bounds.
18675 But this is unfortunately not always the case, as witnessed
18676 with GCC, for instance, where the ambiguous DW_FORM_dataN form
18677 is used instead. To work around that ambiguity, we treat
18678 the bounds as signed, and thus sign-extend their values, when
18679 the base type is signed. */
18681 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
18682 if (low
.kind () == PROP_CONST
18683 && !base_type
->is_unsigned () && (low
.const_val () & negative_mask
))
18684 low
.set_const_val (low
.const_val () | negative_mask
);
18685 if (high
.kind () == PROP_CONST
18686 && !base_type
->is_unsigned () && (high
.const_val () & negative_mask
))
18687 high
.set_const_val (high
.const_val () | negative_mask
);
18689 /* Check for bit and byte strides. */
18690 struct dynamic_prop byte_stride_prop
;
18691 attribute
*attr_byte_stride
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
18692 if (attr_byte_stride
!= nullptr)
18694 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18695 attr_to_dynamic_prop (attr_byte_stride
, die
, cu
, &byte_stride_prop
,
18699 struct dynamic_prop bit_stride_prop
;
18700 attribute
*attr_bit_stride
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
18701 if (attr_bit_stride
!= nullptr)
18703 /* It only makes sense to have either a bit or byte stride. */
18704 if (attr_byte_stride
!= nullptr)
18706 complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
18707 "- DIE at %s [in module %s]"),
18708 sect_offset_str (die
->sect_off
),
18709 objfile_name (cu
->per_objfile
->objfile
));
18710 attr_bit_stride
= nullptr;
18714 struct type
*prop_type
= cu
->addr_sized_int_type (false);
18715 attr_to_dynamic_prop (attr_bit_stride
, die
, cu
, &bit_stride_prop
,
18720 if (attr_byte_stride
!= nullptr
18721 || attr_bit_stride
!= nullptr)
18723 bool byte_stride_p
= (attr_byte_stride
!= nullptr);
18724 struct dynamic_prop
*stride
18725 = byte_stride_p
? &byte_stride_prop
: &bit_stride_prop
;
18728 = create_range_type_with_stride (NULL
, orig_base_type
, &low
,
18729 &high
, bias
, stride
, byte_stride_p
);
18732 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
, bias
);
18734 if (high_bound_is_count
)
18735 range_type
->bounds ()->flag_upper_bound_is_count
= 1;
18737 /* Ada expects an empty array on no boundary attributes. */
18738 if (attr
== NULL
&& cu
->language
!= language_ada
)
18739 range_type
->bounds ()->high
.set_undefined ();
18741 name
= dwarf2_name (die
, cu
);
18743 range_type
->set_name (name
);
18745 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18746 if (attr
!= nullptr)
18747 TYPE_LENGTH (range_type
) = attr
->constant_value (0);
18749 maybe_set_alignment (cu
, die
, range_type
);
18751 set_die_type (die
, range_type
, cu
);
18753 /* set_die_type should be already done. */
18754 set_descriptive_type (range_type
, die
, cu
);
18759 static struct type
*
18760 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18764 type
= init_type (cu
->per_objfile
->objfile
, TYPE_CODE_VOID
, 0, NULL
);
18765 type
->set_name (dwarf2_name (die
, cu
));
18767 /* In Ada, an unspecified type is typically used when the description
18768 of the type is deferred to a different unit. When encountering
18769 such a type, we treat it as a stub, and try to resolve it later on,
18771 if (cu
->language
== language_ada
)
18772 type
->set_is_stub (true);
18774 return set_die_type (die
, type
, cu
);
18777 /* Read a single die and all its descendents. Set the die's sibling
18778 field to NULL; set other fields in the die correctly, and set all
18779 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
18780 location of the info_ptr after reading all of those dies. PARENT
18781 is the parent of the die in question. */
18783 static struct die_info
*
18784 read_die_and_children (const struct die_reader_specs
*reader
,
18785 const gdb_byte
*info_ptr
,
18786 const gdb_byte
**new_info_ptr
,
18787 struct die_info
*parent
)
18789 struct die_info
*die
;
18790 const gdb_byte
*cur_ptr
;
18792 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, 0);
18795 *new_info_ptr
= cur_ptr
;
18798 store_in_ref_table (die
, reader
->cu
);
18800 if (die
->has_children
)
18801 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
18805 *new_info_ptr
= cur_ptr
;
18808 die
->sibling
= NULL
;
18809 die
->parent
= parent
;
18813 /* Read a die, all of its descendents, and all of its siblings; set
18814 all of the fields of all of the dies correctly. Arguments are as
18815 in read_die_and_children. */
18817 static struct die_info
*
18818 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
18819 const gdb_byte
*info_ptr
,
18820 const gdb_byte
**new_info_ptr
,
18821 struct die_info
*parent
)
18823 struct die_info
*first_die
, *last_sibling
;
18824 const gdb_byte
*cur_ptr
;
18826 cur_ptr
= info_ptr
;
18827 first_die
= last_sibling
= NULL
;
18831 struct die_info
*die
18832 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
18836 *new_info_ptr
= cur_ptr
;
18843 last_sibling
->sibling
= die
;
18845 last_sibling
= die
;
18849 /* Read a die, all of its descendents, and all of its siblings; set
18850 all of the fields of all of the dies correctly. Arguments are as
18851 in read_die_and_children.
18852 This the main entry point for reading a DIE and all its children. */
18854 static struct die_info
*
18855 read_die_and_siblings (const struct die_reader_specs
*reader
,
18856 const gdb_byte
*info_ptr
,
18857 const gdb_byte
**new_info_ptr
,
18858 struct die_info
*parent
)
18860 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
18861 new_info_ptr
, parent
);
18863 if (dwarf_die_debug
)
18865 fprintf_unfiltered (gdb_stdlog
,
18866 "Read die from %s@0x%x of %s:\n",
18867 reader
->die_section
->get_name (),
18868 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18869 bfd_get_filename (reader
->abfd
));
18870 dump_die (die
, dwarf_die_debug
);
18876 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18878 The caller is responsible for filling in the extra attributes
18879 and updating (*DIEP)->num_attrs.
18880 Set DIEP to point to a newly allocated die with its information,
18881 except for its child, sibling, and parent fields. */
18883 static const gdb_byte
*
18884 read_full_die_1 (const struct die_reader_specs
*reader
,
18885 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18886 int num_extra_attrs
)
18888 unsigned int abbrev_number
, bytes_read
, i
;
18889 struct abbrev_info
*abbrev
;
18890 struct die_info
*die
;
18891 struct dwarf2_cu
*cu
= reader
->cu
;
18892 bfd
*abfd
= reader
->abfd
;
18894 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
18895 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18896 info_ptr
+= bytes_read
;
18897 if (!abbrev_number
)
18903 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
18905 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18907 bfd_get_filename (abfd
));
18909 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
18910 die
->sect_off
= sect_off
;
18911 die
->tag
= abbrev
->tag
;
18912 die
->abbrev
= abbrev_number
;
18913 die
->has_children
= abbrev
->has_children
;
18915 /* Make the result usable.
18916 The caller needs to update num_attrs after adding the extra
18918 die
->num_attrs
= abbrev
->num_attrs
;
18920 bool any_need_reprocess
= false;
18921 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18923 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
18925 if (die
->attrs
[i
].requires_reprocessing_p ())
18926 any_need_reprocess
= true;
18929 struct attribute
*attr
= die
->attr (DW_AT_str_offsets_base
);
18930 if (attr
!= nullptr && attr
->form_is_unsigned ())
18931 cu
->str_offsets_base
= attr
->as_unsigned ();
18933 attr
= die
->attr (DW_AT_loclists_base
);
18934 if (attr
!= nullptr)
18935 cu
->loclist_base
= attr
->as_unsigned ();
18937 auto maybe_addr_base
= die
->addr_base ();
18938 if (maybe_addr_base
.has_value ())
18939 cu
->addr_base
= *maybe_addr_base
;
18941 attr
= die
->attr (DW_AT_rnglists_base
);
18942 if (attr
!= nullptr)
18943 cu
->ranges_base
= attr
->as_unsigned ();
18945 if (any_need_reprocess
)
18947 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18949 if (die
->attrs
[i
].requires_reprocessing_p ())
18950 read_attribute_reprocess (reader
, &die
->attrs
[i
], die
->tag
);
18957 /* Read a die and all its attributes.
18958 Set DIEP to point to a newly allocated die with its information,
18959 except for its child, sibling, and parent fields. */
18961 static const gdb_byte
*
18962 read_full_die (const struct die_reader_specs
*reader
,
18963 struct die_info
**diep
, const gdb_byte
*info_ptr
)
18965 const gdb_byte
*result
;
18967 result
= read_full_die_1 (reader
, diep
, info_ptr
, 0);
18969 if (dwarf_die_debug
)
18971 fprintf_unfiltered (gdb_stdlog
,
18972 "Read die from %s@0x%x of %s:\n",
18973 reader
->die_section
->get_name (),
18974 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18975 bfd_get_filename (reader
->abfd
));
18976 dump_die (*diep
, dwarf_die_debug
);
18983 /* Returns nonzero if TAG represents a type that we might generate a partial
18987 is_type_tag_for_partial (int tag
)
18992 /* Some types that would be reasonable to generate partial symbols for,
18993 that we don't at present. */
18994 case DW_TAG_array_type
:
18995 case DW_TAG_file_type
:
18996 case DW_TAG_ptr_to_member_type
:
18997 case DW_TAG_set_type
:
18998 case DW_TAG_string_type
:
18999 case DW_TAG_subroutine_type
:
19001 case DW_TAG_base_type
:
19002 case DW_TAG_class_type
:
19003 case DW_TAG_interface_type
:
19004 case DW_TAG_enumeration_type
:
19005 case DW_TAG_structure_type
:
19006 case DW_TAG_subrange_type
:
19007 case DW_TAG_typedef
:
19008 case DW_TAG_union_type
:
19015 /* Load all DIEs that are interesting for partial symbols into memory. */
19017 static struct partial_die_info
*
19018 load_partial_dies (const struct die_reader_specs
*reader
,
19019 const gdb_byte
*info_ptr
, int building_psymtab
)
19021 struct dwarf2_cu
*cu
= reader
->cu
;
19022 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19023 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
19024 unsigned int bytes_read
;
19025 unsigned int load_all
= 0;
19026 int nesting_level
= 1;
19031 gdb_assert (cu
->per_cu
!= NULL
);
19032 if (cu
->per_cu
->load_all_dies
)
19036 = htab_create_alloc_ex (cu
->header
.length
/ 12,
19040 &cu
->comp_unit_obstack
,
19041 hashtab_obstack_allocate
,
19042 dummy_obstack_deallocate
);
19046 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
19048 /* A NULL abbrev means the end of a series of children. */
19049 if (abbrev
== NULL
)
19051 if (--nesting_level
== 0)
19054 info_ptr
+= bytes_read
;
19055 last_die
= parent_die
;
19056 parent_die
= parent_die
->die_parent
;
19060 /* Check for template arguments. We never save these; if
19061 they're seen, we just mark the parent, and go on our way. */
19062 if (parent_die
!= NULL
19063 && cu
->language
== language_cplus
19064 && (abbrev
->tag
== DW_TAG_template_type_param
19065 || abbrev
->tag
== DW_TAG_template_value_param
))
19067 parent_die
->has_template_arguments
= 1;
19071 /* We don't need a partial DIE for the template argument. */
19072 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19077 /* We only recurse into c++ subprograms looking for template arguments.
19078 Skip their other children. */
19080 && cu
->language
== language_cplus
19081 && parent_die
!= NULL
19082 && parent_die
->tag
== DW_TAG_subprogram
19083 && abbrev
->tag
!= DW_TAG_inlined_subroutine
)
19085 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19089 /* Check whether this DIE is interesting enough to save. Normally
19090 we would not be interested in members here, but there may be
19091 later variables referencing them via DW_AT_specification (for
19092 static members). */
19094 && !is_type_tag_for_partial (abbrev
->tag
)
19095 && abbrev
->tag
!= DW_TAG_constant
19096 && abbrev
->tag
!= DW_TAG_enumerator
19097 && abbrev
->tag
!= DW_TAG_subprogram
19098 && abbrev
->tag
!= DW_TAG_inlined_subroutine
19099 && abbrev
->tag
!= DW_TAG_lexical_block
19100 && abbrev
->tag
!= DW_TAG_variable
19101 && abbrev
->tag
!= DW_TAG_namespace
19102 && abbrev
->tag
!= DW_TAG_module
19103 && abbrev
->tag
!= DW_TAG_member
19104 && abbrev
->tag
!= DW_TAG_imported_unit
19105 && abbrev
->tag
!= DW_TAG_imported_declaration
)
19107 /* Otherwise we skip to the next sibling, if any. */
19108 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
19112 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
19115 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
19117 /* This two-pass algorithm for processing partial symbols has a
19118 high cost in cache pressure. Thus, handle some simple cases
19119 here which cover the majority of C partial symbols. DIEs
19120 which neither have specification tags in them, nor could have
19121 specification tags elsewhere pointing at them, can simply be
19122 processed and discarded.
19124 This segment is also optional; scan_partial_symbols and
19125 add_partial_symbol will handle these DIEs if we chain
19126 them in normally. When compilers which do not emit large
19127 quantities of duplicate debug information are more common,
19128 this code can probably be removed. */
19130 /* Any complete simple types at the top level (pretty much all
19131 of them, for a language without namespaces), can be processed
19133 if (parent_die
== NULL
19134 && pdi
.has_specification
== 0
19135 && pdi
.is_declaration
== 0
19136 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
19137 || pdi
.tag
== DW_TAG_base_type
19138 || pdi
.tag
== DW_TAG_subrange_type
))
19140 if (building_psymtab
&& pdi
.raw_name
!= NULL
)
19141 add_partial_symbol (&pdi
, cu
);
19143 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
19147 /* The exception for DW_TAG_typedef with has_children above is
19148 a workaround of GCC PR debug/47510. In the case of this complaint
19149 type_name_or_error will error on such types later.
19151 GDB skipped children of DW_TAG_typedef by the shortcut above and then
19152 it could not find the child DIEs referenced later, this is checked
19153 above. In correct DWARF DW_TAG_typedef should have no children. */
19155 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
19156 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
19157 "- DIE at %s [in module %s]"),
19158 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
19160 /* If we're at the second level, and we're an enumerator, and
19161 our parent has no specification (meaning possibly lives in a
19162 namespace elsewhere), then we can add the partial symbol now
19163 instead of queueing it. */
19164 if (pdi
.tag
== DW_TAG_enumerator
19165 && parent_die
!= NULL
19166 && parent_die
->die_parent
== NULL
19167 && parent_die
->tag
== DW_TAG_enumeration_type
19168 && parent_die
->has_specification
== 0)
19170 if (pdi
.raw_name
== NULL
)
19171 complaint (_("malformed enumerator DIE ignored"));
19172 else if (building_psymtab
)
19173 add_partial_symbol (&pdi
, cu
);
19175 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
19179 struct partial_die_info
*part_die
19180 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
19182 /* We'll save this DIE so link it in. */
19183 part_die
->die_parent
= parent_die
;
19184 part_die
->die_sibling
= NULL
;
19185 part_die
->die_child
= NULL
;
19187 if (last_die
&& last_die
== parent_die
)
19188 last_die
->die_child
= part_die
;
19190 last_die
->die_sibling
= part_die
;
19192 last_die
= part_die
;
19194 if (first_die
== NULL
)
19195 first_die
= part_die
;
19197 /* Maybe add the DIE to the hash table. Not all DIEs that we
19198 find interesting need to be in the hash table, because we
19199 also have the parent/sibling/child chains; only those that we
19200 might refer to by offset later during partial symbol reading.
19202 For now this means things that might have be the target of a
19203 DW_AT_specification, DW_AT_abstract_origin, or
19204 DW_AT_extension. DW_AT_extension will refer only to
19205 namespaces; DW_AT_abstract_origin refers to functions (and
19206 many things under the function DIE, but we do not recurse
19207 into function DIEs during partial symbol reading) and
19208 possibly variables as well; DW_AT_specification refers to
19209 declarations. Declarations ought to have the DW_AT_declaration
19210 flag. It happens that GCC forgets to put it in sometimes, but
19211 only for functions, not for types.
19213 Adding more things than necessary to the hash table is harmless
19214 except for the performance cost. Adding too few will result in
19215 wasted time in find_partial_die, when we reread the compilation
19216 unit with load_all_dies set. */
19219 || abbrev
->tag
== DW_TAG_constant
19220 || abbrev
->tag
== DW_TAG_subprogram
19221 || abbrev
->tag
== DW_TAG_variable
19222 || abbrev
->tag
== DW_TAG_namespace
19223 || part_die
->is_declaration
)
19227 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
19228 to_underlying (part_die
->sect_off
),
19233 /* For some DIEs we want to follow their children (if any). For C
19234 we have no reason to follow the children of structures; for other
19235 languages we have to, so that we can get at method physnames
19236 to infer fully qualified class names, for DW_AT_specification,
19237 and for C++ template arguments. For C++, we also look one level
19238 inside functions to find template arguments (if the name of the
19239 function does not already contain the template arguments).
19241 For Ada and Fortran, we need to scan the children of subprograms
19242 and lexical blocks as well because these languages allow the
19243 definition of nested entities that could be interesting for the
19244 debugger, such as nested subprograms for instance. */
19245 if (last_die
->has_children
19247 || last_die
->tag
== DW_TAG_namespace
19248 || last_die
->tag
== DW_TAG_module
19249 || last_die
->tag
== DW_TAG_enumeration_type
19250 || (cu
->language
== language_cplus
19251 && last_die
->tag
== DW_TAG_subprogram
19252 && (last_die
->raw_name
== NULL
19253 || strchr (last_die
->raw_name
, '<') == NULL
))
19254 || (cu
->language
!= language_c
19255 && (last_die
->tag
== DW_TAG_class_type
19256 || last_die
->tag
== DW_TAG_interface_type
19257 || last_die
->tag
== DW_TAG_structure_type
19258 || last_die
->tag
== DW_TAG_union_type
))
19259 || ((cu
->language
== language_ada
19260 || cu
->language
== language_fortran
)
19261 && (last_die
->tag
== DW_TAG_subprogram
19262 || last_die
->tag
== DW_TAG_lexical_block
))))
19265 parent_die
= last_die
;
19269 /* Otherwise we skip to the next sibling, if any. */
19270 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
19272 /* Back to the top, do it again. */
19276 partial_die_info::partial_die_info (sect_offset sect_off_
,
19277 struct abbrev_info
*abbrev
)
19278 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
19282 /* See class definition. */
19285 partial_die_info::name (dwarf2_cu
*cu
)
19287 if (!canonical_name
&& raw_name
!= nullptr)
19289 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19290 raw_name
= dwarf2_canonicalize_name (raw_name
, cu
, objfile
);
19291 canonical_name
= 1;
19297 /* Read a minimal amount of information into the minimal die structure.
19298 INFO_PTR should point just after the initial uleb128 of a DIE. */
19301 partial_die_info::read (const struct die_reader_specs
*reader
,
19302 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
19304 struct dwarf2_cu
*cu
= reader
->cu
;
19305 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19307 int has_low_pc_attr
= 0;
19308 int has_high_pc_attr
= 0;
19309 int high_pc_relative
= 0;
19311 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
19314 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
19315 /* String and address offsets that need to do the reprocessing have
19316 already been read at this point, so there is no need to wait until
19317 the loop terminates to do the reprocessing. */
19318 if (attr
.requires_reprocessing_p ())
19319 read_attribute_reprocess (reader
, &attr
, tag
);
19320 /* Store the data if it is of an attribute we want to keep in a
19321 partial symbol table. */
19327 case DW_TAG_compile_unit
:
19328 case DW_TAG_partial_unit
:
19329 case DW_TAG_type_unit
:
19330 /* Compilation units have a DW_AT_name that is a filename, not
19331 a source language identifier. */
19332 case DW_TAG_enumeration_type
:
19333 case DW_TAG_enumerator
:
19334 /* These tags always have simple identifiers already; no need
19335 to canonicalize them. */
19336 canonical_name
= 1;
19337 raw_name
= attr
.as_string ();
19340 canonical_name
= 0;
19341 raw_name
= attr
.as_string ();
19345 case DW_AT_linkage_name
:
19346 case DW_AT_MIPS_linkage_name
:
19347 /* Note that both forms of linkage name might appear. We
19348 assume they will be the same, and we only store the last
19350 linkage_name
= attr
.as_string ();
19353 has_low_pc_attr
= 1;
19354 lowpc
= attr
.as_address ();
19356 case DW_AT_high_pc
:
19357 has_high_pc_attr
= 1;
19358 highpc
= attr
.as_address ();
19359 if (cu
->header
.version
>= 4 && attr
.form_is_constant ())
19360 high_pc_relative
= 1;
19362 case DW_AT_location
:
19363 /* Support the .debug_loc offsets. */
19364 if (attr
.form_is_block ())
19366 d
.locdesc
= attr
.as_block ();
19368 else if (attr
.form_is_section_offset ())
19370 dwarf2_complex_location_expr_complaint ();
19374 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
19375 "partial symbol information");
19378 case DW_AT_external
:
19379 is_external
= attr
.as_boolean ();
19381 case DW_AT_declaration
:
19382 is_declaration
= attr
.as_boolean ();
19387 case DW_AT_abstract_origin
:
19388 case DW_AT_specification
:
19389 case DW_AT_extension
:
19390 has_specification
= 1;
19391 spec_offset
= attr
.get_ref_die_offset ();
19392 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19393 || cu
->per_cu
->is_dwz
);
19395 case DW_AT_sibling
:
19396 /* Ignore absolute siblings, they might point outside of
19397 the current compile unit. */
19398 if (attr
.form
== DW_FORM_ref_addr
)
19399 complaint (_("ignoring absolute DW_AT_sibling"));
19402 const gdb_byte
*buffer
= reader
->buffer
;
19403 sect_offset off
= attr
.get_ref_die_offset ();
19404 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
19406 if (sibling_ptr
< info_ptr
)
19407 complaint (_("DW_AT_sibling points backwards"));
19408 else if (sibling_ptr
> reader
->buffer_end
)
19409 reader
->die_section
->overflow_complaint ();
19411 sibling
= sibling_ptr
;
19414 case DW_AT_byte_size
:
19417 case DW_AT_const_value
:
19418 has_const_value
= 1;
19420 case DW_AT_calling_convention
:
19421 /* DWARF doesn't provide a way to identify a program's source-level
19422 entry point. DW_AT_calling_convention attributes are only meant
19423 to describe functions' calling conventions.
19425 However, because it's a necessary piece of information in
19426 Fortran, and before DWARF 4 DW_CC_program was the only
19427 piece of debugging information whose definition refers to
19428 a 'main program' at all, several compilers marked Fortran
19429 main programs with DW_CC_program --- even when those
19430 functions use the standard calling conventions.
19432 Although DWARF now specifies a way to provide this
19433 information, we support this practice for backward
19435 if (attr
.constant_value (0) == DW_CC_program
19436 && cu
->language
== language_fortran
)
19437 main_subprogram
= 1;
19441 LONGEST value
= attr
.constant_value (-1);
19442 if (value
== DW_INL_inlined
19443 || value
== DW_INL_declared_inlined
)
19444 may_be_inlined
= 1;
19449 if (tag
== DW_TAG_imported_unit
)
19451 d
.sect_off
= attr
.get_ref_die_offset ();
19452 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19453 || cu
->per_cu
->is_dwz
);
19457 case DW_AT_main_subprogram
:
19458 main_subprogram
= attr
.as_boolean ();
19463 /* DW_AT_rnglists_base does not apply to DIEs from the DWO
19464 skeleton. We take advantage of the fact the DW_AT_ranges
19465 does not appear in DW_TAG_compile_unit of DWO files.
19467 Attributes of the form DW_FORM_rnglistx have already had
19468 their value changed by read_rnglist_index and already
19469 include DW_AT_rnglists_base, so don't need to add the ranges
19471 int need_ranges_base
= (tag
!= DW_TAG_compile_unit
19472 && attr
.form
!= DW_FORM_rnglistx
);
19473 /* It would be nice to reuse dwarf2_get_pc_bounds here,
19474 but that requires a full DIE, so instead we just
19476 unsigned int ranges_offset
= (attr
.constant_value (0)
19477 + (need_ranges_base
19481 /* Value of the DW_AT_ranges attribute is the offset in the
19482 .debug_ranges section. */
19483 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
19494 /* For Ada, if both the name and the linkage name appear, we prefer
19495 the latter. This lets "catch exception" work better, regardless
19496 of the order in which the name and linkage name were emitted.
19497 Really, though, this is just a workaround for the fact that gdb
19498 doesn't store both the name and the linkage name. */
19499 if (cu
->language
== language_ada
&& linkage_name
!= nullptr)
19500 raw_name
= linkage_name
;
19502 if (high_pc_relative
)
19505 if (has_low_pc_attr
&& has_high_pc_attr
)
19507 /* When using the GNU linker, .gnu.linkonce. sections are used to
19508 eliminate duplicate copies of functions and vtables and such.
19509 The linker will arbitrarily choose one and discard the others.
19510 The AT_*_pc values for such functions refer to local labels in
19511 these sections. If the section from that file was discarded, the
19512 labels are not in the output, so the relocs get a value of 0.
19513 If this is a discarded function, mark the pc bounds as invalid,
19514 so that GDB will ignore it. */
19515 if (lowpc
== 0 && !per_objfile
->per_bfd
->has_section_at_zero
)
19517 struct objfile
*objfile
= per_objfile
->objfile
;
19518 struct gdbarch
*gdbarch
= objfile
->arch ();
19520 complaint (_("DW_AT_low_pc %s is zero "
19521 "for DIE at %s [in module %s]"),
19522 paddress (gdbarch
, lowpc
),
19523 sect_offset_str (sect_off
),
19524 objfile_name (objfile
));
19526 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
19527 else if (lowpc
>= highpc
)
19529 struct objfile
*objfile
= per_objfile
->objfile
;
19530 struct gdbarch
*gdbarch
= objfile
->arch ();
19532 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
19533 "for DIE at %s [in module %s]"),
19534 paddress (gdbarch
, lowpc
),
19535 paddress (gdbarch
, highpc
),
19536 sect_offset_str (sect_off
),
19537 objfile_name (objfile
));
19546 /* Find a cached partial DIE at OFFSET in CU. */
19548 struct partial_die_info
*
19549 dwarf2_cu::find_partial_die (sect_offset sect_off
)
19551 struct partial_die_info
*lookup_die
= NULL
;
19552 struct partial_die_info
part_die (sect_off
);
19554 lookup_die
= ((struct partial_die_info
*)
19555 htab_find_with_hash (partial_dies
, &part_die
,
19556 to_underlying (sect_off
)));
19561 /* Find a partial DIE at OFFSET, which may or may not be in CU,
19562 except in the case of .debug_types DIEs which do not reference
19563 outside their CU (they do however referencing other types via
19564 DW_FORM_ref_sig8). */
19566 static const struct cu_partial_die_info
19567 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
19569 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19570 struct objfile
*objfile
= per_objfile
->objfile
;
19571 struct partial_die_info
*pd
= NULL
;
19573 if (offset_in_dwz
== cu
->per_cu
->is_dwz
19574 && cu
->header
.offset_in_cu_p (sect_off
))
19576 pd
= cu
->find_partial_die (sect_off
);
19579 /* We missed recording what we needed.
19580 Load all dies and try again. */
19584 /* TUs don't reference other CUs/TUs (except via type signatures). */
19585 if (cu
->per_cu
->is_debug_types
)
19587 error (_("Dwarf Error: Type Unit at offset %s contains"
19588 " external reference to offset %s [in module %s].\n"),
19589 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
19590 bfd_get_filename (objfile
->obfd
));
19592 dwarf2_per_cu_data
*per_cu
19593 = dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
19596 cu
= per_objfile
->get_cu (per_cu
);
19597 if (cu
== NULL
|| cu
->partial_dies
== NULL
)
19598 load_partial_comp_unit (per_cu
, per_objfile
, nullptr);
19600 cu
= per_objfile
->get_cu (per_cu
);
19603 pd
= cu
->find_partial_die (sect_off
);
19606 /* If we didn't find it, and not all dies have been loaded,
19607 load them all and try again. */
19609 if (pd
== NULL
&& cu
->per_cu
->load_all_dies
== 0)
19611 cu
->per_cu
->load_all_dies
= 1;
19613 /* This is nasty. When we reread the DIEs, somewhere up the call chain
19614 THIS_CU->cu may already be in use. So we can't just free it and
19615 replace its DIEs with the ones we read in. Instead, we leave those
19616 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
19617 and clobber THIS_CU->cu->partial_dies with the hash table for the new
19619 load_partial_comp_unit (cu
->per_cu
, per_objfile
, cu
);
19621 pd
= cu
->find_partial_die (sect_off
);
19625 error (_("Dwarf Error: Cannot not find DIE at %s [from module %s]\n"),
19626 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
19630 /* See if we can figure out if the class lives in a namespace. We do
19631 this by looking for a member function; its demangled name will
19632 contain namespace info, if there is any. */
19635 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
19636 struct dwarf2_cu
*cu
)
19638 /* NOTE: carlton/2003-10-07: Getting the info this way changes
19639 what template types look like, because the demangler
19640 frequently doesn't give the same name as the debug info. We
19641 could fix this by only using the demangled name to get the
19642 prefix (but see comment in read_structure_type). */
19644 struct partial_die_info
*real_pdi
;
19645 struct partial_die_info
*child_pdi
;
19647 /* If this DIE (this DIE's specification, if any) has a parent, then
19648 we should not do this. We'll prepend the parent's fully qualified
19649 name when we create the partial symbol. */
19651 real_pdi
= struct_pdi
;
19652 while (real_pdi
->has_specification
)
19654 auto res
= find_partial_die (real_pdi
->spec_offset
,
19655 real_pdi
->spec_is_dwz
, cu
);
19656 real_pdi
= res
.pdi
;
19660 if (real_pdi
->die_parent
!= NULL
)
19663 for (child_pdi
= struct_pdi
->die_child
;
19665 child_pdi
= child_pdi
->die_sibling
)
19667 if (child_pdi
->tag
== DW_TAG_subprogram
19668 && child_pdi
->linkage_name
!= NULL
)
19670 gdb::unique_xmalloc_ptr
<char> actual_class_name
19671 (cu
->language_defn
->class_name_from_physname
19672 (child_pdi
->linkage_name
));
19673 if (actual_class_name
!= NULL
)
19675 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19676 struct_pdi
->raw_name
= objfile
->intern (actual_class_name
.get ());
19677 struct_pdi
->canonical_name
= 1;
19684 /* Return true if a DIE with TAG may have the DW_AT_const_value
19688 can_have_DW_AT_const_value_p (enum dwarf_tag tag
)
19692 case DW_TAG_constant
:
19693 case DW_TAG_enumerator
:
19694 case DW_TAG_formal_parameter
:
19695 case DW_TAG_template_value_param
:
19696 case DW_TAG_variable
:
19704 partial_die_info::fixup (struct dwarf2_cu
*cu
)
19706 /* Once we've fixed up a die, there's no point in doing so again.
19707 This also avoids a memory leak if we were to call
19708 guess_partial_die_structure_name multiple times. */
19712 /* If we found a reference attribute and the DIE has no name, try
19713 to find a name in the referred to DIE. */
19715 if (raw_name
== NULL
&& has_specification
)
19717 struct partial_die_info
*spec_die
;
19719 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19720 spec_die
= res
.pdi
;
19723 spec_die
->fixup (cu
);
19725 if (spec_die
->raw_name
)
19727 raw_name
= spec_die
->raw_name
;
19728 canonical_name
= spec_die
->canonical_name
;
19730 /* Copy DW_AT_external attribute if it is set. */
19731 if (spec_die
->is_external
)
19732 is_external
= spec_die
->is_external
;
19736 if (!has_const_value
&& has_specification
19737 && can_have_DW_AT_const_value_p (tag
))
19739 struct partial_die_info
*spec_die
;
19741 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19742 spec_die
= res
.pdi
;
19745 spec_die
->fixup (cu
);
19747 if (spec_die
->has_const_value
)
19749 /* Copy DW_AT_const_value attribute if it is set. */
19750 has_const_value
= spec_die
->has_const_value
;
19754 /* Set default names for some unnamed DIEs. */
19756 if (raw_name
== NULL
&& tag
== DW_TAG_namespace
)
19758 raw_name
= CP_ANONYMOUS_NAMESPACE_STR
;
19759 canonical_name
= 1;
19762 /* If there is no parent die to provide a namespace, and there are
19763 children, see if we can determine the namespace from their linkage
19765 if (cu
->language
== language_cplus
19766 && !cu
->per_objfile
->per_bfd
->types
.empty ()
19767 && die_parent
== NULL
19769 && (tag
== DW_TAG_class_type
19770 || tag
== DW_TAG_structure_type
19771 || tag
== DW_TAG_union_type
))
19772 guess_partial_die_structure_name (this, cu
);
19774 /* GCC might emit a nameless struct or union that has a linkage
19775 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19776 if (raw_name
== NULL
19777 && (tag
== DW_TAG_class_type
19778 || tag
== DW_TAG_interface_type
19779 || tag
== DW_TAG_structure_type
19780 || tag
== DW_TAG_union_type
)
19781 && linkage_name
!= NULL
)
19783 gdb::unique_xmalloc_ptr
<char> demangled
19784 (gdb_demangle (linkage_name
, DMGL_TYPES
));
19785 if (demangled
!= nullptr)
19789 /* Strip any leading namespaces/classes, keep only the base name.
19790 DW_AT_name for named DIEs does not contain the prefixes. */
19791 base
= strrchr (demangled
.get (), ':');
19792 if (base
&& base
> demangled
.get () && base
[-1] == ':')
19795 base
= demangled
.get ();
19797 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
19798 raw_name
= objfile
->intern (base
);
19799 canonical_name
= 1;
19806 /* Read the .debug_loclists or .debug_rnglists header (they are the same format)
19807 contents from the given SECTION in the HEADER. */
19809 read_loclists_rnglists_header (struct loclists_rnglists_header
*header
,
19810 struct dwarf2_section_info
*section
)
19812 unsigned int bytes_read
;
19813 bfd
*abfd
= section
->get_bfd_owner ();
19814 const gdb_byte
*info_ptr
= section
->buffer
;
19815 header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
19816 info_ptr
+= bytes_read
;
19817 header
->version
= read_2_bytes (abfd
, info_ptr
);
19819 header
->addr_size
= read_1_byte (abfd
, info_ptr
);
19821 header
->segment_collector_size
= read_1_byte (abfd
, info_ptr
);
19823 header
->offset_entry_count
= read_4_bytes (abfd
, info_ptr
);
19826 /* Return the DW_AT_loclists_base value for the CU. */
19828 lookup_loclist_base (struct dwarf2_cu
*cu
)
19830 /* For the .dwo unit, the loclist_base points to the first offset following
19831 the header. The header consists of the following entities-
19832 1. Unit Length (4 bytes for 32 bit DWARF format, and 12 bytes for the 64
19834 2. version (2 bytes)
19835 3. address size (1 byte)
19836 4. segment selector size (1 byte)
19837 5. offset entry count (4 bytes)
19838 These sizes are derived as per the DWARFv5 standard. */
19839 if (cu
->dwo_unit
!= nullptr)
19841 if (cu
->header
.initial_length_size
== 4)
19842 return LOCLIST_HEADER_SIZE32
;
19843 return LOCLIST_HEADER_SIZE64
;
19845 return cu
->loclist_base
;
19848 /* Given a DW_FORM_loclistx value LOCLIST_INDEX, fetch the offset from the
19849 array of offsets in the .debug_loclists section. */
19851 read_loclist_index (struct dwarf2_cu
*cu
, ULONGEST loclist_index
)
19853 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19854 struct objfile
*objfile
= per_objfile
->objfile
;
19855 bfd
*abfd
= objfile
->obfd
;
19856 ULONGEST loclist_base
= lookup_loclist_base (cu
);
19857 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
19859 section
->read (objfile
);
19860 if (section
->buffer
== NULL
)
19861 complaint (_("DW_FORM_loclistx used without .debug_loclists "
19862 "section [in module %s]"), objfile_name (objfile
));
19863 struct loclists_rnglists_header header
;
19864 read_loclists_rnglists_header (&header
, section
);
19865 if (loclist_index
>= header
.offset_entry_count
)
19866 complaint (_("DW_FORM_loclistx pointing outside of "
19867 ".debug_loclists offset array [in module %s]"),
19868 objfile_name (objfile
));
19869 if (loclist_base
+ loclist_index
* cu
->header
.offset_size
19871 complaint (_("DW_FORM_loclistx pointing outside of "
19872 ".debug_loclists section [in module %s]"),
19873 objfile_name (objfile
));
19874 const gdb_byte
*info_ptr
19875 = section
->buffer
+ loclist_base
+ loclist_index
* cu
->header
.offset_size
;
19877 if (cu
->header
.offset_size
== 4)
19878 return bfd_get_32 (abfd
, info_ptr
) + loclist_base
;
19880 return bfd_get_64 (abfd
, info_ptr
) + loclist_base
;
19883 /* Given a DW_FORM_rnglistx value RNGLIST_INDEX, fetch the offset from the
19884 array of offsets in the .debug_rnglists section. */
19886 read_rnglist_index (struct dwarf2_cu
*cu
, ULONGEST rnglist_index
,
19889 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
19890 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19891 bfd
*abfd
= objfile
->obfd
;
19892 ULONGEST rnglist_header_size
=
19893 (cu
->header
.initial_length_size
== 4 ? RNGLIST_HEADER_SIZE32
19894 : RNGLIST_HEADER_SIZE64
);
19895 ULONGEST rnglist_base
=
19896 (cu
->dwo_unit
!= nullptr) ? rnglist_header_size
: cu
->ranges_base
;
19897 ULONGEST start_offset
=
19898 rnglist_base
+ rnglist_index
* cu
->header
.offset_size
;
19900 /* Get rnglists section. */
19901 struct dwarf2_section_info
*section
= cu_debug_rnglists_section (cu
, tag
);
19903 /* Read the rnglists section content. */
19904 section
->read (objfile
);
19905 if (section
->buffer
== nullptr)
19906 error (_("DW_FORM_rnglistx used without .debug_rnglists section "
19908 objfile_name (objfile
));
19910 /* Verify the rnglist index is valid. */
19911 struct loclists_rnglists_header header
;
19912 read_loclists_rnglists_header (&header
, section
);
19913 if (rnglist_index
>= header
.offset_entry_count
)
19914 error (_("DW_FORM_rnglistx index pointing outside of "
19915 ".debug_rnglists offset array [in module %s]"),
19916 objfile_name (objfile
));
19918 /* Validate that the offset is within the section's range. */
19919 if (start_offset
>= section
->size
)
19920 error (_("DW_FORM_rnglistx pointing outside of "
19921 ".debug_rnglists section [in module %s]"),
19922 objfile_name (objfile
));
19924 /* Validate that reading won't go beyond the end of the section. */
19925 if (start_offset
+ cu
->header
.offset_size
> rnglist_base
+ section
->size
)
19926 error (_("Reading DW_FORM_rnglistx index beyond end of"
19927 ".debug_rnglists section [in module %s]"),
19928 objfile_name (objfile
));
19930 const gdb_byte
*info_ptr
= section
->buffer
+ start_offset
;
19932 if (cu
->header
.offset_size
== 4)
19933 return read_4_bytes (abfd
, info_ptr
) + rnglist_base
;
19935 return read_8_bytes (abfd
, info_ptr
) + rnglist_base
;
19938 /* Process the attributes that had to be skipped in the first round. These
19939 attributes are the ones that need str_offsets_base or addr_base attributes.
19940 They could not have been processed in the first round, because at the time
19941 the values of str_offsets_base or addr_base may not have been known. */
19943 read_attribute_reprocess (const struct die_reader_specs
*reader
,
19944 struct attribute
*attr
, dwarf_tag tag
)
19946 struct dwarf2_cu
*cu
= reader
->cu
;
19947 switch (attr
->form
)
19949 case DW_FORM_addrx
:
19950 case DW_FORM_GNU_addr_index
:
19951 attr
->set_address (read_addr_index (cu
,
19952 attr
->as_unsigned_reprocess ()));
19954 case DW_FORM_loclistx
:
19955 attr
->set_address (read_loclist_index (cu
, attr
->as_unsigned ()));
19957 case DW_FORM_rnglistx
:
19958 attr
->set_address (read_rnglist_index (cu
, attr
->as_unsigned (), tag
));
19961 case DW_FORM_strx1
:
19962 case DW_FORM_strx2
:
19963 case DW_FORM_strx3
:
19964 case DW_FORM_strx4
:
19965 case DW_FORM_GNU_str_index
:
19967 unsigned int str_index
= attr
->as_unsigned_reprocess ();
19968 gdb_assert (!attr
->canonical_string_p ());
19969 if (reader
->dwo_file
!= NULL
)
19970 attr
->set_string_noncanonical (read_dwo_str_index (reader
,
19973 attr
->set_string_noncanonical (read_stub_str_index (cu
,
19978 gdb_assert_not_reached (_("Unexpected DWARF form."));
19982 /* Read an attribute value described by an attribute form. */
19984 static const gdb_byte
*
19985 read_attribute_value (const struct die_reader_specs
*reader
,
19986 struct attribute
*attr
, unsigned form
,
19987 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
19989 struct dwarf2_cu
*cu
= reader
->cu
;
19990 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
19991 struct objfile
*objfile
= per_objfile
->objfile
;
19992 bfd
*abfd
= reader
->abfd
;
19993 struct comp_unit_head
*cu_header
= &cu
->header
;
19994 unsigned int bytes_read
;
19995 struct dwarf_block
*blk
;
19997 attr
->form
= (enum dwarf_form
) form
;
20000 case DW_FORM_ref_addr
:
20001 if (cu
->header
.version
== 2)
20002 attr
->set_unsigned (cu
->header
.read_address (abfd
, info_ptr
,
20005 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
20007 info_ptr
+= bytes_read
;
20009 case DW_FORM_GNU_ref_alt
:
20010 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
20012 info_ptr
+= bytes_read
;
20016 struct gdbarch
*gdbarch
= objfile
->arch ();
20017 CORE_ADDR addr
= cu
->header
.read_address (abfd
, info_ptr
, &bytes_read
);
20018 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
);
20019 attr
->set_address (addr
);
20020 info_ptr
+= bytes_read
;
20023 case DW_FORM_block2
:
20024 blk
= dwarf_alloc_block (cu
);
20025 blk
->size
= read_2_bytes (abfd
, info_ptr
);
20027 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20028 info_ptr
+= blk
->size
;
20029 attr
->set_block (blk
);
20031 case DW_FORM_block4
:
20032 blk
= dwarf_alloc_block (cu
);
20033 blk
->size
= read_4_bytes (abfd
, info_ptr
);
20035 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20036 info_ptr
+= blk
->size
;
20037 attr
->set_block (blk
);
20039 case DW_FORM_data2
:
20040 attr
->set_unsigned (read_2_bytes (abfd
, info_ptr
));
20043 case DW_FORM_data4
:
20044 attr
->set_unsigned (read_4_bytes (abfd
, info_ptr
));
20047 case DW_FORM_data8
:
20048 attr
->set_unsigned (read_8_bytes (abfd
, info_ptr
));
20051 case DW_FORM_data16
:
20052 blk
= dwarf_alloc_block (cu
);
20054 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
20056 attr
->set_block (blk
);
20058 case DW_FORM_sec_offset
:
20059 attr
->set_unsigned (cu
->header
.read_offset (abfd
, info_ptr
,
20061 info_ptr
+= bytes_read
;
20063 case DW_FORM_loclistx
:
20065 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20067 info_ptr
+= bytes_read
;
20070 case DW_FORM_string
:
20071 attr
->set_string_noncanonical (read_direct_string (abfd
, info_ptr
,
20073 info_ptr
+= bytes_read
;
20076 if (!cu
->per_cu
->is_dwz
)
20078 attr
->set_string_noncanonical
20079 (read_indirect_string (per_objfile
,
20080 abfd
, info_ptr
, cu_header
,
20082 info_ptr
+= bytes_read
;
20086 case DW_FORM_line_strp
:
20087 if (!cu
->per_cu
->is_dwz
)
20089 attr
->set_string_noncanonical
20090 (per_objfile
->read_line_string (info_ptr
, cu_header
,
20092 info_ptr
+= bytes_read
;
20096 case DW_FORM_GNU_strp_alt
:
20098 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
20099 LONGEST str_offset
= cu_header
->read_offset (abfd
, info_ptr
,
20102 attr
->set_string_noncanonical
20103 (dwz
->read_string (objfile
, str_offset
));
20104 info_ptr
+= bytes_read
;
20107 case DW_FORM_exprloc
:
20108 case DW_FORM_block
:
20109 blk
= dwarf_alloc_block (cu
);
20110 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20111 info_ptr
+= bytes_read
;
20112 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20113 info_ptr
+= blk
->size
;
20114 attr
->set_block (blk
);
20116 case DW_FORM_block1
:
20117 blk
= dwarf_alloc_block (cu
);
20118 blk
->size
= read_1_byte (abfd
, info_ptr
);
20120 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
20121 info_ptr
+= blk
->size
;
20122 attr
->set_block (blk
);
20124 case DW_FORM_data1
:
20126 attr
->set_unsigned (read_1_byte (abfd
, info_ptr
));
20129 case DW_FORM_flag_present
:
20130 attr
->set_unsigned (1);
20132 case DW_FORM_sdata
:
20133 attr
->set_signed (read_signed_leb128 (abfd
, info_ptr
, &bytes_read
));
20134 info_ptr
+= bytes_read
;
20136 case DW_FORM_rnglistx
:
20138 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20140 info_ptr
+= bytes_read
;
20143 case DW_FORM_udata
:
20144 attr
->set_unsigned (read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
20145 info_ptr
+= bytes_read
;
20148 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
20149 + read_1_byte (abfd
, info_ptr
)));
20153 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
20154 + read_2_bytes (abfd
, info_ptr
)));
20158 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
20159 + read_4_bytes (abfd
, info_ptr
)));
20163 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
20164 + read_8_bytes (abfd
, info_ptr
)));
20167 case DW_FORM_ref_sig8
:
20168 attr
->set_signature (read_8_bytes (abfd
, info_ptr
));
20171 case DW_FORM_ref_udata
:
20172 attr
->set_unsigned ((to_underlying (cu
->header
.sect_off
)
20173 + read_unsigned_leb128 (abfd
, info_ptr
,
20175 info_ptr
+= bytes_read
;
20177 case DW_FORM_indirect
:
20178 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20179 info_ptr
+= bytes_read
;
20180 if (form
== DW_FORM_implicit_const
)
20182 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
20183 info_ptr
+= bytes_read
;
20185 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
20188 case DW_FORM_implicit_const
:
20189 attr
->set_signed (implicit_const
);
20191 case DW_FORM_addrx
:
20192 case DW_FORM_GNU_addr_index
:
20193 attr
->set_unsigned_reprocess (read_unsigned_leb128 (abfd
, info_ptr
,
20195 info_ptr
+= bytes_read
;
20198 case DW_FORM_strx1
:
20199 case DW_FORM_strx2
:
20200 case DW_FORM_strx3
:
20201 case DW_FORM_strx4
:
20202 case DW_FORM_GNU_str_index
:
20204 ULONGEST str_index
;
20205 if (form
== DW_FORM_strx1
)
20207 str_index
= read_1_byte (abfd
, info_ptr
);
20210 else if (form
== DW_FORM_strx2
)
20212 str_index
= read_2_bytes (abfd
, info_ptr
);
20215 else if (form
== DW_FORM_strx3
)
20217 str_index
= read_3_bytes (abfd
, info_ptr
);
20220 else if (form
== DW_FORM_strx4
)
20222 str_index
= read_4_bytes (abfd
, info_ptr
);
20227 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
20228 info_ptr
+= bytes_read
;
20230 attr
->set_unsigned_reprocess (str_index
);
20234 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
20235 dwarf_form_name (form
),
20236 bfd_get_filename (abfd
));
20240 if (cu
->per_cu
->is_dwz
&& attr
->form_is_ref ())
20241 attr
->form
= DW_FORM_GNU_ref_alt
;
20243 /* We have seen instances where the compiler tried to emit a byte
20244 size attribute of -1 which ended up being encoded as an unsigned
20245 0xffffffff. Although 0xffffffff is technically a valid size value,
20246 an object of this size seems pretty unlikely so we can relatively
20247 safely treat these cases as if the size attribute was invalid and
20248 treat them as zero by default. */
20249 if (attr
->name
== DW_AT_byte_size
20250 && form
== DW_FORM_data4
20251 && attr
->as_unsigned () >= 0xffffffff)
20254 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
20255 hex_string (attr
->as_unsigned ()));
20256 attr
->set_unsigned (0);
20262 /* Read an attribute described by an abbreviated attribute. */
20264 static const gdb_byte
*
20265 read_attribute (const struct die_reader_specs
*reader
,
20266 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
20267 const gdb_byte
*info_ptr
)
20269 attr
->name
= abbrev
->name
;
20270 attr
->string_is_canonical
= 0;
20271 attr
->requires_reprocessing
= 0;
20272 return read_attribute_value (reader
, attr
, abbrev
->form
,
20273 abbrev
->implicit_const
, info_ptr
);
20276 /* Return pointer to string at .debug_str offset STR_OFFSET. */
20278 static const char *
20279 read_indirect_string_at_offset (dwarf2_per_objfile
*per_objfile
,
20280 LONGEST str_offset
)
20282 return per_objfile
->per_bfd
->str
.read_string (per_objfile
->objfile
,
20283 str_offset
, "DW_FORM_strp");
20286 /* Return pointer to string at .debug_str offset as read from BUF.
20287 BUF is assumed to be in a compilation unit described by CU_HEADER.
20288 Return *BYTES_READ_PTR count of bytes read from BUF. */
20290 static const char *
20291 read_indirect_string (dwarf2_per_objfile
*per_objfile
, bfd
*abfd
,
20292 const gdb_byte
*buf
,
20293 const struct comp_unit_head
*cu_header
,
20294 unsigned int *bytes_read_ptr
)
20296 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20298 return read_indirect_string_at_offset (per_objfile
, str_offset
);
20304 dwarf2_per_objfile::read_line_string (const gdb_byte
*buf
,
20305 const struct comp_unit_head
*cu_header
,
20306 unsigned int *bytes_read_ptr
)
20308 bfd
*abfd
= objfile
->obfd
;
20309 LONGEST str_offset
= cu_header
->read_offset (abfd
, buf
, bytes_read_ptr
);
20311 return per_bfd
->line_str
.read_string (objfile
, str_offset
, "DW_FORM_line_strp");
20314 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
20315 ADDR_BASE is the DW_AT_addr_base (DW_AT_GNU_addr_base) attribute or zero.
20316 ADDR_SIZE is the size of addresses from the CU header. */
20319 read_addr_index_1 (dwarf2_per_objfile
*per_objfile
, unsigned int addr_index
,
20320 gdb::optional
<ULONGEST
> addr_base
, int addr_size
)
20322 struct objfile
*objfile
= per_objfile
->objfile
;
20323 bfd
*abfd
= objfile
->obfd
;
20324 const gdb_byte
*info_ptr
;
20325 ULONGEST addr_base_or_zero
= addr_base
.has_value () ? *addr_base
: 0;
20327 per_objfile
->per_bfd
->addr
.read (objfile
);
20328 if (per_objfile
->per_bfd
->addr
.buffer
== NULL
)
20329 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
20330 objfile_name (objfile
));
20331 if (addr_base_or_zero
+ addr_index
* addr_size
20332 >= per_objfile
->per_bfd
->addr
.size
)
20333 error (_("DW_FORM_addr_index pointing outside of "
20334 ".debug_addr section [in module %s]"),
20335 objfile_name (objfile
));
20336 info_ptr
= (per_objfile
->per_bfd
->addr
.buffer
+ addr_base_or_zero
20337 + addr_index
* addr_size
);
20338 if (addr_size
== 4)
20339 return bfd_get_32 (abfd
, info_ptr
);
20341 return bfd_get_64 (abfd
, info_ptr
);
20344 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
20347 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
20349 return read_addr_index_1 (cu
->per_objfile
, addr_index
,
20350 cu
->addr_base
, cu
->header
.addr_size
);
20353 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
20356 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
20357 unsigned int *bytes_read
)
20359 bfd
*abfd
= cu
->per_objfile
->objfile
->obfd
;
20360 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
20362 return read_addr_index (cu
, addr_index
);
20368 dwarf2_read_addr_index (dwarf2_per_cu_data
*per_cu
,
20369 dwarf2_per_objfile
*per_objfile
,
20370 unsigned int addr_index
)
20372 struct dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
20373 gdb::optional
<ULONGEST
> addr_base
;
20376 /* We need addr_base and addr_size.
20377 If we don't have PER_CU->cu, we have to get it.
20378 Nasty, but the alternative is storing the needed info in PER_CU,
20379 which at this point doesn't seem justified: it's not clear how frequently
20380 it would get used and it would increase the size of every PER_CU.
20381 Entry points like dwarf2_per_cu_addr_size do a similar thing
20382 so we're not in uncharted territory here.
20383 Alas we need to be a bit more complicated as addr_base is contained
20386 We don't need to read the entire CU(/TU).
20387 We just need the header and top level die.
20389 IWBN to use the aging mechanism to let us lazily later discard the CU.
20390 For now we skip this optimization. */
20394 addr_base
= cu
->addr_base
;
20395 addr_size
= cu
->header
.addr_size
;
20399 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
20400 addr_base
= reader
.cu
->addr_base
;
20401 addr_size
= reader
.cu
->header
.addr_size
;
20404 return read_addr_index_1 (per_objfile
, addr_index
, addr_base
, addr_size
);
20407 /* Given a DW_FORM_GNU_str_index value STR_INDEX, fetch the string.
20408 STR_SECTION, STR_OFFSETS_SECTION can be from a Fission stub or a
20411 static const char *
20412 read_str_index (struct dwarf2_cu
*cu
,
20413 struct dwarf2_section_info
*str_section
,
20414 struct dwarf2_section_info
*str_offsets_section
,
20415 ULONGEST str_offsets_base
, ULONGEST str_index
)
20417 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20418 struct objfile
*objfile
= per_objfile
->objfile
;
20419 const char *objf_name
= objfile_name (objfile
);
20420 bfd
*abfd
= objfile
->obfd
;
20421 const gdb_byte
*info_ptr
;
20422 ULONGEST str_offset
;
20423 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
20425 str_section
->read (objfile
);
20426 str_offsets_section
->read (objfile
);
20427 if (str_section
->buffer
== NULL
)
20428 error (_("%s used without %s section"
20429 " in CU at offset %s [in module %s]"),
20430 form_name
, str_section
->get_name (),
20431 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20432 if (str_offsets_section
->buffer
== NULL
)
20433 error (_("%s used without %s section"
20434 " in CU at offset %s [in module %s]"),
20435 form_name
, str_section
->get_name (),
20436 sect_offset_str (cu
->header
.sect_off
), objf_name
);
20437 info_ptr
= (str_offsets_section
->buffer
20439 + str_index
* cu
->header
.offset_size
);
20440 if (cu
->header
.offset_size
== 4)
20441 str_offset
= bfd_get_32 (abfd
, info_ptr
);
20443 str_offset
= bfd_get_64 (abfd
, info_ptr
);
20444 if (str_offset
>= str_section
->size
)
20445 error (_("Offset from %s pointing outside of"
20446 " .debug_str.dwo section in CU at offset %s [in module %s]"),
20447 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20448 return (const char *) (str_section
->buffer
+ str_offset
);
20451 /* Given a DW_FORM_GNU_str_index from a DWO file, fetch the string. */
20453 static const char *
20454 read_dwo_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
20456 ULONGEST str_offsets_base
= reader
->cu
->header
.version
>= 5
20457 ? reader
->cu
->header
.addr_size
: 0;
20458 return read_str_index (reader
->cu
,
20459 &reader
->dwo_file
->sections
.str
,
20460 &reader
->dwo_file
->sections
.str_offsets
,
20461 str_offsets_base
, str_index
);
20464 /* Given a DW_FORM_GNU_str_index from a Fission stub, fetch the string. */
20466 static const char *
20467 read_stub_str_index (struct dwarf2_cu
*cu
, ULONGEST str_index
)
20469 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
20470 const char *objf_name
= objfile_name (objfile
);
20471 static const char form_name
[] = "DW_FORM_GNU_str_index";
20472 static const char str_offsets_attr_name
[] = "DW_AT_str_offsets";
20474 if (!cu
->str_offsets_base
.has_value ())
20475 error (_("%s used in Fission stub without %s"
20476 " in CU at offset 0x%lx [in module %s]"),
20477 form_name
, str_offsets_attr_name
,
20478 (long) cu
->header
.offset_size
, objf_name
);
20480 return read_str_index (cu
,
20481 &cu
->per_objfile
->per_bfd
->str
,
20482 &cu
->per_objfile
->per_bfd
->str_offsets
,
20483 *cu
->str_offsets_base
, str_index
);
20486 /* Return the length of an LEB128 number in BUF. */
20489 leb128_size (const gdb_byte
*buf
)
20491 const gdb_byte
*begin
= buf
;
20497 if ((byte
& 128) == 0)
20498 return buf
- begin
;
20503 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
20512 cu
->language
= language_c
;
20515 case DW_LANG_C_plus_plus
:
20516 case DW_LANG_C_plus_plus_11
:
20517 case DW_LANG_C_plus_plus_14
:
20518 cu
->language
= language_cplus
;
20521 cu
->language
= language_d
;
20523 case DW_LANG_Fortran77
:
20524 case DW_LANG_Fortran90
:
20525 case DW_LANG_Fortran95
:
20526 case DW_LANG_Fortran03
:
20527 case DW_LANG_Fortran08
:
20528 cu
->language
= language_fortran
;
20531 cu
->language
= language_go
;
20533 case DW_LANG_Mips_Assembler
:
20534 cu
->language
= language_asm
;
20536 case DW_LANG_Ada83
:
20537 case DW_LANG_Ada95
:
20538 cu
->language
= language_ada
;
20540 case DW_LANG_Modula2
:
20541 cu
->language
= language_m2
;
20543 case DW_LANG_Pascal83
:
20544 cu
->language
= language_pascal
;
20547 cu
->language
= language_objc
;
20550 case DW_LANG_Rust_old
:
20551 cu
->language
= language_rust
;
20553 case DW_LANG_Cobol74
:
20554 case DW_LANG_Cobol85
:
20556 cu
->language
= language_minimal
;
20559 cu
->language_defn
= language_def (cu
->language
);
20562 /* Return the named attribute or NULL if not there. */
20564 static struct attribute
*
20565 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20570 struct attribute
*spec
= NULL
;
20572 for (i
= 0; i
< die
->num_attrs
; ++i
)
20574 if (die
->attrs
[i
].name
== name
)
20575 return &die
->attrs
[i
];
20576 if (die
->attrs
[i
].name
== DW_AT_specification
20577 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
20578 spec
= &die
->attrs
[i
];
20584 die
= follow_die_ref (die
, spec
, &cu
);
20590 /* Return the string associated with a string-typed attribute, or NULL if it
20591 is either not found or is of an incorrect type. */
20593 static const char *
20594 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20596 struct attribute
*attr
;
20597 const char *str
= NULL
;
20599 attr
= dwarf2_attr (die
, name
, cu
);
20603 str
= attr
->as_string ();
20604 if (str
== nullptr)
20605 complaint (_("string type expected for attribute %s for "
20606 "DIE at %s in module %s"),
20607 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
20608 objfile_name (cu
->per_objfile
->objfile
));
20614 /* Return the dwo name or NULL if not present. If present, it is in either
20615 DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute. */
20616 static const char *
20617 dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
20619 const char *dwo_name
= dwarf2_string_attr (die
, DW_AT_GNU_dwo_name
, cu
);
20620 if (dwo_name
== nullptr)
20621 dwo_name
= dwarf2_string_attr (die
, DW_AT_dwo_name
, cu
);
20625 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20626 and holds a non-zero value. This function should only be used for
20627 DW_FORM_flag or DW_FORM_flag_present attributes. */
20630 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
20632 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
20634 return attr
!= nullptr && attr
->as_boolean ();
20638 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
20640 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20641 which value is non-zero. However, we have to be careful with
20642 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20643 (via dwarf2_flag_true_p) follows this attribute. So we may
20644 end up accidently finding a declaration attribute that belongs
20645 to a different DIE referenced by the specification attribute,
20646 even though the given DIE does not have a declaration attribute. */
20647 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
20648 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
20651 /* Return the die giving the specification for DIE, if there is
20652 one. *SPEC_CU is the CU containing DIE on input, and the CU
20653 containing the return value on output. If there is no
20654 specification, but there is an abstract origin, that is
20657 static struct die_info
*
20658 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
20660 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
20663 if (spec_attr
== NULL
)
20664 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
20666 if (spec_attr
== NULL
)
20669 return follow_die_ref (die
, spec_attr
, spec_cu
);
20672 /* Stub for free_line_header to match void * callback types. */
20675 free_line_header_voidp (void *arg
)
20677 struct line_header
*lh
= (struct line_header
*) arg
;
20682 /* A convenience function to find the proper .debug_line section for a CU. */
20684 static struct dwarf2_section_info
*
20685 get_debug_line_section (struct dwarf2_cu
*cu
)
20687 struct dwarf2_section_info
*section
;
20688 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20690 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20692 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20693 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
20694 else if (cu
->per_cu
->is_dwz
)
20696 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
);
20698 section
= &dwz
->line
;
20701 section
= &per_objfile
->per_bfd
->line
;
20706 /* Read the statement program header starting at OFFSET in
20707 .debug_line, or .debug_line.dwo. Return a pointer
20708 to a struct line_header, allocated using xmalloc.
20709 Returns NULL if there is a problem reading the header, e.g., if it
20710 has a version we don't understand.
20712 NOTE: the strings in the include directory and file name tables of
20713 the returned object point into the dwarf line section buffer,
20714 and must not be freed. */
20716 static line_header_up
20717 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
20719 struct dwarf2_section_info
*section
;
20720 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
20722 section
= get_debug_line_section (cu
);
20723 section
->read (per_objfile
->objfile
);
20724 if (section
->buffer
== NULL
)
20726 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20727 complaint (_("missing .debug_line.dwo section"));
20729 complaint (_("missing .debug_line section"));
20733 return dwarf_decode_line_header (sect_off
, cu
->per_cu
->is_dwz
,
20734 per_objfile
, section
, &cu
->header
);
20737 /* Subroutine of dwarf_decode_lines to simplify it.
20738 Return the file name of the psymtab for the given file_entry.
20739 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20740 If space for the result is malloc'd, *NAME_HOLDER will be set.
20741 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20743 static const char *
20744 psymtab_include_file_name (const struct line_header
*lh
, const file_entry
&fe
,
20745 const dwarf2_psymtab
*pst
,
20746 const char *comp_dir
,
20747 gdb::unique_xmalloc_ptr
<char> *name_holder
)
20749 const char *include_name
= fe
.name
;
20750 const char *include_name_to_compare
= include_name
;
20751 const char *pst_filename
;
20754 const char *dir_name
= fe
.include_dir (lh
);
20756 gdb::unique_xmalloc_ptr
<char> hold_compare
;
20757 if (!IS_ABSOLUTE_PATH (include_name
)
20758 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
20760 /* Avoid creating a duplicate psymtab for PST.
20761 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20762 Before we do the comparison, however, we need to account
20763 for DIR_NAME and COMP_DIR.
20764 First prepend dir_name (if non-NULL). If we still don't
20765 have an absolute path prepend comp_dir (if non-NULL).
20766 However, the directory we record in the include-file's
20767 psymtab does not contain COMP_DIR (to match the
20768 corresponding symtab(s)).
20773 bash$ gcc -g ./hello.c
20774 include_name = "hello.c"
20776 DW_AT_comp_dir = comp_dir = "/tmp"
20777 DW_AT_name = "./hello.c"
20781 if (dir_name
!= NULL
)
20783 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
20784 include_name
, (char *) NULL
));
20785 include_name
= name_holder
->get ();
20786 include_name_to_compare
= include_name
;
20788 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
20790 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
20791 include_name
, (char *) NULL
));
20792 include_name_to_compare
= hold_compare
.get ();
20796 pst_filename
= pst
->filename
;
20797 gdb::unique_xmalloc_ptr
<char> copied_name
;
20798 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
20800 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
20801 pst_filename
, (char *) NULL
));
20802 pst_filename
= copied_name
.get ();
20805 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
20809 return include_name
;
20812 /* State machine to track the state of the line number program. */
20814 class lnp_state_machine
20817 /* Initialize a machine state for the start of a line number
20819 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
20820 bool record_lines_p
);
20822 file_entry
*current_file ()
20824 /* lh->file_names is 0-based, but the file name numbers in the
20825 statement program are 1-based. */
20826 return m_line_header
->file_name_at (m_file
);
20829 /* Record the line in the state machine. END_SEQUENCE is true if
20830 we're processing the end of a sequence. */
20831 void record_line (bool end_sequence
);
20833 /* Check ADDRESS is -1, or zero and less than UNRELOCATED_LOWPC, and if true
20834 nop-out rest of the lines in this sequence. */
20835 void check_line_address (struct dwarf2_cu
*cu
,
20836 const gdb_byte
*line_ptr
,
20837 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
20839 void handle_set_discriminator (unsigned int discriminator
)
20841 m_discriminator
= discriminator
;
20842 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
20845 /* Handle DW_LNE_set_address. */
20846 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
20849 address
+= baseaddr
;
20850 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
20853 /* Handle DW_LNS_advance_pc. */
20854 void handle_advance_pc (CORE_ADDR adjust
);
20856 /* Handle a special opcode. */
20857 void handle_special_opcode (unsigned char op_code
);
20859 /* Handle DW_LNS_advance_line. */
20860 void handle_advance_line (int line_delta
)
20862 advance_line (line_delta
);
20865 /* Handle DW_LNS_set_file. */
20866 void handle_set_file (file_name_index file
);
20868 /* Handle DW_LNS_negate_stmt. */
20869 void handle_negate_stmt ()
20871 m_is_stmt
= !m_is_stmt
;
20874 /* Handle DW_LNS_const_add_pc. */
20875 void handle_const_add_pc ();
20877 /* Handle DW_LNS_fixed_advance_pc. */
20878 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
20880 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20884 /* Handle DW_LNS_copy. */
20885 void handle_copy ()
20887 record_line (false);
20888 m_discriminator
= 0;
20891 /* Handle DW_LNE_end_sequence. */
20892 void handle_end_sequence ()
20894 m_currently_recording_lines
= true;
20898 /* Advance the line by LINE_DELTA. */
20899 void advance_line (int line_delta
)
20901 m_line
+= line_delta
;
20903 if (line_delta
!= 0)
20904 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20907 struct dwarf2_cu
*m_cu
;
20909 gdbarch
*m_gdbarch
;
20911 /* True if we're recording lines.
20912 Otherwise we're building partial symtabs and are just interested in
20913 finding include files mentioned by the line number program. */
20914 bool m_record_lines_p
;
20916 /* The line number header. */
20917 line_header
*m_line_header
;
20919 /* These are part of the standard DWARF line number state machine,
20920 and initialized according to the DWARF spec. */
20922 unsigned char m_op_index
= 0;
20923 /* The line table index of the current file. */
20924 file_name_index m_file
= 1;
20925 unsigned int m_line
= 1;
20927 /* These are initialized in the constructor. */
20929 CORE_ADDR m_address
;
20931 unsigned int m_discriminator
;
20933 /* Additional bits of state we need to track. */
20935 /* The last file that we called dwarf2_start_subfile for.
20936 This is only used for TLLs. */
20937 unsigned int m_last_file
= 0;
20938 /* The last file a line number was recorded for. */
20939 struct subfile
*m_last_subfile
= NULL
;
20941 /* The address of the last line entry. */
20942 CORE_ADDR m_last_address
;
20944 /* Set to true when a previous line at the same address (using
20945 m_last_address) had m_is_stmt true. This is reset to false when a
20946 line entry at a new address (m_address different to m_last_address) is
20948 bool m_stmt_at_address
= false;
20950 /* When true, record the lines we decode. */
20951 bool m_currently_recording_lines
= false;
20953 /* The last line number that was recorded, used to coalesce
20954 consecutive entries for the same line. This can happen, for
20955 example, when discriminators are present. PR 17276. */
20956 unsigned int m_last_line
= 0;
20957 bool m_line_has_non_zero_discriminator
= false;
20961 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
20963 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
20964 / m_line_header
->maximum_ops_per_instruction
)
20965 * m_line_header
->minimum_instruction_length
);
20966 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20967 m_op_index
= ((m_op_index
+ adjust
)
20968 % m_line_header
->maximum_ops_per_instruction
);
20972 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
20974 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
20975 unsigned char adj_opcode_d
= adj_opcode
/ m_line_header
->line_range
;
20976 unsigned char adj_opcode_r
= adj_opcode
% m_line_header
->line_range
;
20977 CORE_ADDR addr_adj
= (((m_op_index
+ adj_opcode_d
)
20978 / m_line_header
->maximum_ops_per_instruction
)
20979 * m_line_header
->minimum_instruction_length
);
20980 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20981 m_op_index
= ((m_op_index
+ adj_opcode_d
)
20982 % m_line_header
->maximum_ops_per_instruction
);
20984 int line_delta
= m_line_header
->line_base
+ adj_opcode_r
;
20985 advance_line (line_delta
);
20986 record_line (false);
20987 m_discriminator
= 0;
20991 lnp_state_machine::handle_set_file (file_name_index file
)
20995 const file_entry
*fe
= current_file ();
20997 dwarf2_debug_line_missing_file_complaint ();
20998 else if (m_record_lines_p
)
21000 const char *dir
= fe
->include_dir (m_line_header
);
21002 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21003 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
21004 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
21009 lnp_state_machine::handle_const_add_pc ()
21012 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
21015 = (((m_op_index
+ adjust
)
21016 / m_line_header
->maximum_ops_per_instruction
)
21017 * m_line_header
->minimum_instruction_length
);
21019 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21020 m_op_index
= ((m_op_index
+ adjust
)
21021 % m_line_header
->maximum_ops_per_instruction
);
21024 /* Return non-zero if we should add LINE to the line number table.
21025 LINE is the line to add, LAST_LINE is the last line that was added,
21026 LAST_SUBFILE is the subfile for LAST_LINE.
21027 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
21028 had a non-zero discriminator.
21030 We have to be careful in the presence of discriminators.
21031 E.g., for this line:
21033 for (i = 0; i < 100000; i++);
21035 clang can emit four line number entries for that one line,
21036 each with a different discriminator.
21037 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
21039 However, we want gdb to coalesce all four entries into one.
21040 Otherwise the user could stepi into the middle of the line and
21041 gdb would get confused about whether the pc really was in the
21042 middle of the line.
21044 Things are further complicated by the fact that two consecutive
21045 line number entries for the same line is a heuristic used by gcc
21046 to denote the end of the prologue. So we can't just discard duplicate
21047 entries, we have to be selective about it. The heuristic we use is
21048 that we only collapse consecutive entries for the same line if at least
21049 one of those entries has a non-zero discriminator. PR 17276.
21051 Note: Addresses in the line number state machine can never go backwards
21052 within one sequence, thus this coalescing is ok. */
21055 dwarf_record_line_p (struct dwarf2_cu
*cu
,
21056 unsigned int line
, unsigned int last_line
,
21057 int line_has_non_zero_discriminator
,
21058 struct subfile
*last_subfile
)
21060 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
21062 if (line
!= last_line
)
21064 /* Same line for the same file that we've seen already.
21065 As a last check, for pr 17276, only record the line if the line
21066 has never had a non-zero discriminator. */
21067 if (!line_has_non_zero_discriminator
)
21072 /* Use the CU's builder to record line number LINE beginning at
21073 address ADDRESS in the line table of subfile SUBFILE. */
21076 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21077 unsigned int line
, CORE_ADDR address
, bool is_stmt
,
21078 struct dwarf2_cu
*cu
)
21080 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
21082 if (dwarf_line_debug
)
21084 fprintf_unfiltered (gdb_stdlog
,
21085 "Recording line %u, file %s, address %s\n",
21086 line
, lbasename (subfile
->name
),
21087 paddress (gdbarch
, address
));
21091 cu
->get_builder ()->record_line (subfile
, line
, addr
, is_stmt
);
21094 /* Subroutine of dwarf_decode_lines_1 to simplify it.
21095 Mark the end of a set of line number records.
21096 The arguments are the same as for dwarf_record_line_1.
21097 If SUBFILE is NULL the request is ignored. */
21100 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21101 CORE_ADDR address
, struct dwarf2_cu
*cu
)
21103 if (subfile
== NULL
)
21106 if (dwarf_line_debug
)
21108 fprintf_unfiltered (gdb_stdlog
,
21109 "Finishing current line, file %s, address %s\n",
21110 lbasename (subfile
->name
),
21111 paddress (gdbarch
, address
));
21114 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, true, cu
);
21118 lnp_state_machine::record_line (bool end_sequence
)
21120 if (dwarf_line_debug
)
21122 fprintf_unfiltered (gdb_stdlog
,
21123 "Processing actual line %u: file %u,"
21124 " address %s, is_stmt %u, discrim %u%s\n",
21126 paddress (m_gdbarch
, m_address
),
21127 m_is_stmt
, m_discriminator
,
21128 (end_sequence
? "\t(end sequence)" : ""));
21131 file_entry
*fe
= current_file ();
21134 dwarf2_debug_line_missing_file_complaint ();
21135 /* For now we ignore lines not starting on an instruction boundary.
21136 But not when processing end_sequence for compatibility with the
21137 previous version of the code. */
21138 else if (m_op_index
== 0 || end_sequence
)
21140 fe
->included_p
= 1;
21141 if (m_record_lines_p
)
21143 /* When we switch files we insert an end maker in the first file,
21144 switch to the second file and add a new line entry. The
21145 problem is that the end marker inserted in the first file will
21146 discard any previous line entries at the same address. If the
21147 line entries in the first file are marked as is-stmt, while
21148 the new line in the second file is non-stmt, then this means
21149 the end marker will discard is-stmt lines so we can have a
21150 non-stmt line. This means that there are less addresses at
21151 which the user can insert a breakpoint.
21153 To improve this we track the last address in m_last_address,
21154 and whether we have seen an is-stmt at this address. Then
21155 when switching files, if we have seen a stmt at the current
21156 address, and we are switching to create a non-stmt line, then
21157 discard the new line. */
21159 = m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ();
21160 bool ignore_this_line
21161 = ((file_changed
&& !end_sequence
&& m_last_address
== m_address
21162 && !m_is_stmt
&& m_stmt_at_address
)
21163 || (!end_sequence
&& m_line
== 0));
21165 if ((file_changed
&& !ignore_this_line
) || end_sequence
)
21167 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
21168 m_currently_recording_lines
? m_cu
: nullptr);
21171 if (!end_sequence
&& !ignore_this_line
)
21173 bool is_stmt
= producer_is_codewarrior (m_cu
) || m_is_stmt
;
21175 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
21176 m_line_has_non_zero_discriminator
,
21179 buildsym_compunit
*builder
= m_cu
->get_builder ();
21180 dwarf_record_line_1 (m_gdbarch
,
21181 builder
->get_current_subfile (),
21182 m_line
, m_address
, is_stmt
,
21183 m_currently_recording_lines
? m_cu
: nullptr);
21185 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21186 m_last_line
= m_line
;
21191 /* Track whether we have seen any m_is_stmt true at m_address in case we
21192 have multiple line table entries all at m_address. */
21193 if (m_last_address
!= m_address
)
21195 m_stmt_at_address
= false;
21196 m_last_address
= m_address
;
21198 m_stmt_at_address
|= m_is_stmt
;
21201 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
21202 line_header
*lh
, bool record_lines_p
)
21206 m_record_lines_p
= record_lines_p
;
21207 m_line_header
= lh
;
21209 m_currently_recording_lines
= true;
21211 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
21212 was a line entry for it so that the backend has a chance to adjust it
21213 and also record it in case it needs it. This is currently used by MIPS
21214 code, cf. `mips_adjust_dwarf2_line'. */
21215 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
21216 m_is_stmt
= lh
->default_is_stmt
;
21217 m_discriminator
= 0;
21219 m_last_address
= m_address
;
21220 m_stmt_at_address
= false;
21224 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
21225 const gdb_byte
*line_ptr
,
21226 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
21228 /* Linkers resolve a symbolic relocation referencing a GC'd function to 0 or
21229 -1. If ADDRESS is 0, ignoring the opcode will err if the text section is
21230 located at 0x0. In this case, additionally check that if
21231 ADDRESS < UNRELOCATED_LOWPC. */
21233 if ((address
== 0 && address
< unrelocated_lowpc
)
21234 || address
== (CORE_ADDR
) -1)
21236 /* This line table is for a function which has been
21237 GCd by the linker. Ignore it. PR gdb/12528 */
21239 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21240 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
21242 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21243 line_offset
, objfile_name (objfile
));
21244 m_currently_recording_lines
= false;
21245 /* Note: m_currently_recording_lines is left as false until we see
21246 DW_LNE_end_sequence. */
21250 /* Subroutine of dwarf_decode_lines to simplify it.
21251 Process the line number information in LH.
21252 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21253 program in order to set included_p for every referenced header. */
21256 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
21257 const int decode_for_pst_p
, CORE_ADDR lowpc
)
21259 const gdb_byte
*line_ptr
, *extended_end
;
21260 const gdb_byte
*line_end
;
21261 unsigned int bytes_read
, extended_len
;
21262 unsigned char op_code
, extended_op
;
21263 CORE_ADDR baseaddr
;
21264 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21265 bfd
*abfd
= objfile
->obfd
;
21266 struct gdbarch
*gdbarch
= objfile
->arch ();
21267 /* True if we're recording line info (as opposed to building partial
21268 symtabs and just interested in finding include files mentioned by
21269 the line number program). */
21270 bool record_lines_p
= !decode_for_pst_p
;
21272 baseaddr
= objfile
->text_section_offset ();
21274 line_ptr
= lh
->statement_program_start
;
21275 line_end
= lh
->statement_program_end
;
21277 /* Read the statement sequences until there's nothing left. */
21278 while (line_ptr
< line_end
)
21280 /* The DWARF line number program state machine. Reset the state
21281 machine at the start of each sequence. */
21282 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
21283 bool end_sequence
= false;
21285 if (record_lines_p
)
21287 /* Start a subfile for the current file of the state
21289 const file_entry
*fe
= state_machine
.current_file ();
21292 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
21295 /* Decode the table. */
21296 while (line_ptr
< line_end
&& !end_sequence
)
21298 op_code
= read_1_byte (abfd
, line_ptr
);
21301 if (op_code
>= lh
->opcode_base
)
21303 /* Special opcode. */
21304 state_machine
.handle_special_opcode (op_code
);
21306 else switch (op_code
)
21308 case DW_LNS_extended_op
:
21309 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
21311 line_ptr
+= bytes_read
;
21312 extended_end
= line_ptr
+ extended_len
;
21313 extended_op
= read_1_byte (abfd
, line_ptr
);
21315 if (DW_LNE_lo_user
<= extended_op
21316 && extended_op
<= DW_LNE_hi_user
)
21318 /* Vendor extension, ignore. */
21319 line_ptr
= extended_end
;
21322 switch (extended_op
)
21324 case DW_LNE_end_sequence
:
21325 state_machine
.handle_end_sequence ();
21326 end_sequence
= true;
21328 case DW_LNE_set_address
:
21331 = cu
->header
.read_address (abfd
, line_ptr
, &bytes_read
);
21332 line_ptr
+= bytes_read
;
21334 state_machine
.check_line_address (cu
, line_ptr
,
21335 lowpc
- baseaddr
, address
);
21336 state_machine
.handle_set_address (baseaddr
, address
);
21339 case DW_LNE_define_file
:
21341 const char *cur_file
;
21342 unsigned int mod_time
, length
;
21345 cur_file
= read_direct_string (abfd
, line_ptr
,
21347 line_ptr
+= bytes_read
;
21348 dindex
= (dir_index
)
21349 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21350 line_ptr
+= bytes_read
;
21352 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21353 line_ptr
+= bytes_read
;
21355 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21356 line_ptr
+= bytes_read
;
21357 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21360 case DW_LNE_set_discriminator
:
21362 /* The discriminator is not interesting to the
21363 debugger; just ignore it. We still need to
21364 check its value though:
21365 if there are consecutive entries for the same
21366 (non-prologue) line we want to coalesce them.
21369 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21370 line_ptr
+= bytes_read
;
21372 state_machine
.handle_set_discriminator (discr
);
21376 complaint (_("mangled .debug_line section"));
21379 /* Make sure that we parsed the extended op correctly. If e.g.
21380 we expected a different address size than the producer used,
21381 we may have read the wrong number of bytes. */
21382 if (line_ptr
!= extended_end
)
21384 complaint (_("mangled .debug_line section"));
21389 state_machine
.handle_copy ();
21391 case DW_LNS_advance_pc
:
21394 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21395 line_ptr
+= bytes_read
;
21397 state_machine
.handle_advance_pc (adjust
);
21400 case DW_LNS_advance_line
:
21403 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21404 line_ptr
+= bytes_read
;
21406 state_machine
.handle_advance_line (line_delta
);
21409 case DW_LNS_set_file
:
21411 file_name_index file
21412 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21414 line_ptr
+= bytes_read
;
21416 state_machine
.handle_set_file (file
);
21419 case DW_LNS_set_column
:
21420 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21421 line_ptr
+= bytes_read
;
21423 case DW_LNS_negate_stmt
:
21424 state_machine
.handle_negate_stmt ();
21426 case DW_LNS_set_basic_block
:
21428 /* Add to the address register of the state machine the
21429 address increment value corresponding to special opcode
21430 255. I.e., this value is scaled by the minimum
21431 instruction length since special opcode 255 would have
21432 scaled the increment. */
21433 case DW_LNS_const_add_pc
:
21434 state_machine
.handle_const_add_pc ();
21436 case DW_LNS_fixed_advance_pc
:
21438 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21441 state_machine
.handle_fixed_advance_pc (addr_adj
);
21446 /* Unknown standard opcode, ignore it. */
21449 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21451 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21452 line_ptr
+= bytes_read
;
21459 dwarf2_debug_line_missing_end_sequence_complaint ();
21461 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21462 in which case we still finish recording the last line). */
21463 state_machine
.record_line (true);
21467 /* Decode the Line Number Program (LNP) for the given line_header
21468 structure and CU. The actual information extracted and the type
21469 of structures created from the LNP depends on the value of PST.
21471 1. If PST is NULL, then this procedure uses the data from the program
21472 to create all necessary symbol tables, and their linetables.
21474 2. If PST is not NULL, this procedure reads the program to determine
21475 the list of files included by the unit represented by PST, and
21476 builds all the associated partial symbol tables.
21478 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21479 It is used for relative paths in the line table.
21480 NOTE: When processing partial symtabs (pst != NULL),
21481 comp_dir == pst->dirname.
21483 NOTE: It is important that psymtabs have the same file name (via strcmp)
21484 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21485 symtab we don't use it in the name of the psymtabs we create.
21486 E.g. expand_line_sal requires this when finding psymtabs to expand.
21487 A good testcase for this is mb-inline.exp.
21489 LOWPC is the lowest address in CU (or 0 if not known).
21491 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21492 for its PC<->lines mapping information. Otherwise only the filename
21493 table is read in. */
21496 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21497 struct dwarf2_cu
*cu
, dwarf2_psymtab
*pst
,
21498 CORE_ADDR lowpc
, int decode_mapping
)
21500 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21501 const int decode_for_pst_p
= (pst
!= NULL
);
21503 if (decode_mapping
)
21504 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21506 if (decode_for_pst_p
)
21508 /* Now that we're done scanning the Line Header Program, we can
21509 create the psymtab of each included file. */
21510 for (auto &file_entry
: lh
->file_names ())
21511 if (file_entry
.included_p
== 1)
21513 gdb::unique_xmalloc_ptr
<char> name_holder
;
21514 const char *include_name
=
21515 psymtab_include_file_name (lh
, file_entry
, pst
,
21516 comp_dir
, &name_holder
);
21517 if (include_name
!= NULL
)
21518 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
21523 /* Make sure a symtab is created for every file, even files
21524 which contain only variables (i.e. no code with associated
21526 buildsym_compunit
*builder
= cu
->get_builder ();
21527 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21529 for (auto &fe
: lh
->file_names ())
21531 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21532 if (builder
->get_current_subfile ()->symtab
== NULL
)
21534 builder
->get_current_subfile ()->symtab
21535 = allocate_symtab (cust
,
21536 builder
->get_current_subfile ()->name
);
21538 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21543 /* Start a subfile for DWARF. FILENAME is the name of the file and
21544 DIRNAME the name of the source directory which contains FILENAME
21545 or NULL if not known.
21546 This routine tries to keep line numbers from identical absolute and
21547 relative file names in a common subfile.
21549 Using the `list' example from the GDB testsuite, which resides in
21550 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21551 of /srcdir/list0.c yields the following debugging information for list0.c:
21553 DW_AT_name: /srcdir/list0.c
21554 DW_AT_comp_dir: /compdir
21555 files.files[0].name: list0.h
21556 files.files[0].dir: /srcdir
21557 files.files[1].name: list0.c
21558 files.files[1].dir: /srcdir
21560 The line number information for list0.c has to end up in a single
21561 subfile, so that `break /srcdir/list0.c:1' works as expected.
21562 start_subfile will ensure that this happens provided that we pass the
21563 concatenation of files.files[1].dir and files.files[1].name as the
21567 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
21568 const char *dirname
)
21570 gdb::unique_xmalloc_ptr
<char> copy
;
21572 /* In order not to lose the line information directory,
21573 we concatenate it to the filename when it makes sense.
21574 Note that the Dwarf3 standard says (speaking of filenames in line
21575 information): ``The directory index is ignored for file names
21576 that represent full path names''. Thus ignoring dirname in the
21577 `else' branch below isn't an issue. */
21579 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
21581 copy
.reset (concat (dirname
, SLASH_STRING
, filename
, (char *) NULL
));
21582 filename
= copy
.get ();
21585 cu
->get_builder ()->start_subfile (filename
);
21588 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21589 buildsym_compunit constructor. */
21591 struct compunit_symtab
*
21592 dwarf2_cu::start_symtab (const char *name
, const char *comp_dir
,
21595 gdb_assert (m_builder
== nullptr);
21597 m_builder
.reset (new struct buildsym_compunit
21598 (this->per_objfile
->objfile
,
21599 name
, comp_dir
, language
, low_pc
));
21601 list_in_scope
= get_builder ()->get_file_symbols ();
21603 get_builder ()->record_debugformat ("DWARF 2");
21604 get_builder ()->record_producer (producer
);
21606 processing_has_namespace_info
= false;
21608 return get_builder ()->get_compunit_symtab ();
21612 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
21613 struct dwarf2_cu
*cu
)
21615 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
21616 struct comp_unit_head
*cu_header
= &cu
->header
;
21618 /* NOTE drow/2003-01-30: There used to be a comment and some special
21619 code here to turn a symbol with DW_AT_external and a
21620 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21621 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21622 with some versions of binutils) where shared libraries could have
21623 relocations against symbols in their debug information - the
21624 minimal symbol would have the right address, but the debug info
21625 would not. It's no longer necessary, because we will explicitly
21626 apply relocations when we read in the debug information now. */
21628 /* A DW_AT_location attribute with no contents indicates that a
21629 variable has been optimized away. */
21630 if (attr
->form_is_block () && attr
->as_block ()->size
== 0)
21632 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21636 /* Handle one degenerate form of location expression specially, to
21637 preserve GDB's previous behavior when section offsets are
21638 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
21639 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
21641 if (attr
->form_is_block ())
21643 struct dwarf_block
*block
= attr
->as_block ();
21645 if ((block
->data
[0] == DW_OP_addr
21646 && block
->size
== 1 + cu_header
->addr_size
)
21647 || ((block
->data
[0] == DW_OP_GNU_addr_index
21648 || block
->data
[0] == DW_OP_addrx
)
21650 == 1 + leb128_size (&block
->data
[1]))))
21652 unsigned int dummy
;
21654 if (block
->data
[0] == DW_OP_addr
)
21655 SET_SYMBOL_VALUE_ADDRESS
21656 (sym
, cu
->header
.read_address (objfile
->obfd
,
21660 SET_SYMBOL_VALUE_ADDRESS
21661 (sym
, read_addr_index_from_leb128 (cu
, block
->data
+ 1,
21663 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
21664 fixup_symbol_section (sym
, objfile
);
21665 SET_SYMBOL_VALUE_ADDRESS
21667 SYMBOL_VALUE_ADDRESS (sym
)
21668 + objfile
->section_offsets
[SYMBOL_SECTION (sym
)]);
21673 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21674 expression evaluator, and use LOC_COMPUTED only when necessary
21675 (i.e. when the value of a register or memory location is
21676 referenced, or a thread-local block, etc.). Then again, it might
21677 not be worthwhile. I'm assuming that it isn't unless performance
21678 or memory numbers show me otherwise. */
21680 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
21682 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
21683 cu
->has_loclist
= true;
21686 /* Given a pointer to a DWARF information entry, figure out if we need
21687 to make a symbol table entry for it, and if so, create a new entry
21688 and return a pointer to it.
21689 If TYPE is NULL, determine symbol type from the die, otherwise
21690 used the passed type.
21691 If SPACE is not NULL, use it to hold the new symbol. If it is
21692 NULL, allocate a new symbol on the objfile's obstack. */
21694 static struct symbol
*
21695 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
21696 struct symbol
*space
)
21698 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
21699 struct objfile
*objfile
= per_objfile
->objfile
;
21700 struct gdbarch
*gdbarch
= objfile
->arch ();
21701 struct symbol
*sym
= NULL
;
21703 struct attribute
*attr
= NULL
;
21704 struct attribute
*attr2
= NULL
;
21705 CORE_ADDR baseaddr
;
21706 struct pending
**list_to_add
= NULL
;
21708 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
21710 baseaddr
= objfile
->text_section_offset ();
21712 name
= dwarf2_name (die
, cu
);
21715 int suppress_add
= 0;
21720 sym
= new (&objfile
->objfile_obstack
) symbol
;
21721 OBJSTAT (objfile
, n_syms
++);
21723 /* Cache this symbol's name and the name's demangled form (if any). */
21724 sym
->set_language (cu
->language
, &objfile
->objfile_obstack
);
21725 /* Fortran does not have mangling standard and the mangling does differ
21726 between gfortran, iFort etc. */
21727 const char *physname
21728 = (cu
->language
== language_fortran
21729 ? dwarf2_full_name (name
, die
, cu
)
21730 : dwarf2_physname (name
, die
, cu
));
21731 const char *linkagename
= dw2_linkage_name (die
, cu
);
21733 if (linkagename
== nullptr || cu
->language
== language_ada
)
21734 sym
->set_linkage_name (physname
);
21737 sym
->set_demangled_name (physname
, &objfile
->objfile_obstack
);
21738 sym
->set_linkage_name (linkagename
);
21741 /* Default assumptions.
21742 Use the passed type or decode it from the die. */
21743 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21744 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21746 SYMBOL_TYPE (sym
) = type
;
21748 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
21749 attr
= dwarf2_attr (die
,
21750 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
21752 if (attr
!= nullptr)
21753 SYMBOL_LINE (sym
) = attr
->constant_value (0);
21755 attr
= dwarf2_attr (die
,
21756 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
21758 if (attr
!= nullptr && attr
->form_is_unsigned ())
21760 file_name_index file_index
21761 = (file_name_index
) attr
->as_unsigned ();
21762 struct file_entry
*fe
;
21764 if (cu
->line_header
!= NULL
)
21765 fe
= cu
->line_header
->file_name_at (file_index
);
21770 complaint (_("file index out of range"));
21772 symbol_set_symtab (sym
, fe
->symtab
);
21778 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
21779 if (attr
!= nullptr)
21783 addr
= attr
->as_address ();
21784 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
21785 SET_SYMBOL_VALUE_ADDRESS (sym
, addr
);
21786 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
21789 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21790 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
21791 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
21792 add_symbol_to_list (sym
, cu
->list_in_scope
);
21794 case DW_TAG_subprogram
:
21795 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21797 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21798 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21799 if ((attr2
!= nullptr && attr2
->as_boolean ())
21800 || cu
->language
== language_ada
21801 || cu
->language
== language_fortran
)
21803 /* Subprograms marked external are stored as a global symbol.
21804 Ada and Fortran subprograms, whether marked external or
21805 not, are always stored as a global symbol, because we want
21806 to be able to access them globally. For instance, we want
21807 to be able to break on a nested subprogram without having
21808 to specify the context. */
21809 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21813 list_to_add
= cu
->list_in_scope
;
21816 case DW_TAG_inlined_subroutine
:
21817 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21819 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21820 SYMBOL_INLINED (sym
) = 1;
21821 list_to_add
= cu
->list_in_scope
;
21823 case DW_TAG_template_value_param
:
21825 /* Fall through. */
21826 case DW_TAG_constant
:
21827 case DW_TAG_variable
:
21828 case DW_TAG_member
:
21829 /* Compilation with minimal debug info may result in
21830 variables with missing type entries. Change the
21831 misleading `void' type to something sensible. */
21832 if (SYMBOL_TYPE (sym
)->code () == TYPE_CODE_VOID
)
21833 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
21835 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21836 /* In the case of DW_TAG_member, we should only be called for
21837 static const members. */
21838 if (die
->tag
== DW_TAG_member
)
21840 /* dwarf2_add_field uses die_is_declaration,
21841 so we do the same. */
21842 gdb_assert (die_is_declaration (die
, cu
));
21845 if (attr
!= nullptr)
21847 dwarf2_const_value (attr
, sym
, cu
);
21848 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21851 if (attr2
!= nullptr && attr2
->as_boolean ())
21852 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21854 list_to_add
= cu
->list_in_scope
;
21858 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21859 if (attr
!= nullptr)
21861 var_decode_location (attr
, sym
, cu
);
21862 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21864 /* Fortran explicitly imports any global symbols to the local
21865 scope by DW_TAG_common_block. */
21866 if (cu
->language
== language_fortran
&& die
->parent
21867 && die
->parent
->tag
== DW_TAG_common_block
)
21870 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21871 && SYMBOL_VALUE_ADDRESS (sym
) == 0
21872 && !per_objfile
->per_bfd
->has_section_at_zero
)
21874 /* When a static variable is eliminated by the linker,
21875 the corresponding debug information is not stripped
21876 out, but the variable address is set to null;
21877 do not add such variables into symbol table. */
21879 else if (attr2
!= nullptr && attr2
->as_boolean ())
21881 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21882 && (objfile
->flags
& OBJF_MAINLINE
) == 0
21883 && per_objfile
->per_bfd
->can_copy
)
21885 /* A global static variable might be subject to
21886 copy relocation. We first check for a local
21887 minsym, though, because maybe the symbol was
21888 marked hidden, in which case this would not
21890 bound_minimal_symbol found
21891 = (lookup_minimal_symbol_linkage
21892 (sym
->linkage_name (), objfile
));
21893 if (found
.minsym
!= nullptr)
21894 sym
->maybe_copied
= 1;
21897 /* A variable with DW_AT_external is never static,
21898 but it may be block-scoped. */
21900 = ((cu
->list_in_scope
21901 == cu
->get_builder ()->get_file_symbols ())
21902 ? cu
->get_builder ()->get_global_symbols ()
21903 : cu
->list_in_scope
);
21906 list_to_add
= cu
->list_in_scope
;
21910 /* We do not know the address of this symbol.
21911 If it is an external symbol and we have type information
21912 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21913 The address of the variable will then be determined from
21914 the minimal symbol table whenever the variable is
21916 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21918 /* Fortran explicitly imports any global symbols to the local
21919 scope by DW_TAG_common_block. */
21920 if (cu
->language
== language_fortran
&& die
->parent
21921 && die
->parent
->tag
== DW_TAG_common_block
)
21923 /* SYMBOL_CLASS doesn't matter here because
21924 read_common_block is going to reset it. */
21926 list_to_add
= cu
->list_in_scope
;
21928 else if (attr2
!= nullptr && attr2
->as_boolean ()
21929 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
21931 /* A variable with DW_AT_external is never static, but it
21932 may be block-scoped. */
21934 = ((cu
->list_in_scope
21935 == cu
->get_builder ()->get_file_symbols ())
21936 ? cu
->get_builder ()->get_global_symbols ()
21937 : cu
->list_in_scope
);
21939 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21941 else if (!die_is_declaration (die
, cu
))
21943 /* Use the default LOC_OPTIMIZED_OUT class. */
21944 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
21946 list_to_add
= cu
->list_in_scope
;
21950 case DW_TAG_formal_parameter
:
21952 /* If we are inside a function, mark this as an argument. If
21953 not, we might be looking at an argument to an inlined function
21954 when we do not have enough information to show inlined frames;
21955 pretend it's a local variable in that case so that the user can
21957 struct context_stack
*curr
21958 = cu
->get_builder ()->get_current_context_stack ();
21959 if (curr
!= nullptr && curr
->name
!= nullptr)
21960 SYMBOL_IS_ARGUMENT (sym
) = 1;
21961 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21962 if (attr
!= nullptr)
21964 var_decode_location (attr
, sym
, cu
);
21966 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21967 if (attr
!= nullptr)
21969 dwarf2_const_value (attr
, sym
, cu
);
21972 list_to_add
= cu
->list_in_scope
;
21975 case DW_TAG_unspecified_parameters
:
21976 /* From varargs functions; gdb doesn't seem to have any
21977 interest in this information, so just ignore it for now.
21980 case DW_TAG_template_type_param
:
21982 /* Fall through. */
21983 case DW_TAG_class_type
:
21984 case DW_TAG_interface_type
:
21985 case DW_TAG_structure_type
:
21986 case DW_TAG_union_type
:
21987 case DW_TAG_set_type
:
21988 case DW_TAG_enumeration_type
:
21989 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21990 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
21993 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21994 really ever be static objects: otherwise, if you try
21995 to, say, break of a class's method and you're in a file
21996 which doesn't mention that class, it won't work unless
21997 the check for all static symbols in lookup_symbol_aux
21998 saves you. See the OtherFileClass tests in
21999 gdb.c++/namespace.exp. */
22003 buildsym_compunit
*builder
= cu
->get_builder ();
22005 = (cu
->list_in_scope
== builder
->get_file_symbols ()
22006 && cu
->language
== language_cplus
22007 ? builder
->get_global_symbols ()
22008 : cu
->list_in_scope
);
22010 /* The semantics of C++ state that "struct foo {
22011 ... }" also defines a typedef for "foo". */
22012 if (cu
->language
== language_cplus
22013 || cu
->language
== language_ada
22014 || cu
->language
== language_d
22015 || cu
->language
== language_rust
)
22017 /* The symbol's name is already allocated along
22018 with this objfile, so we don't need to
22019 duplicate it for the type. */
22020 if (SYMBOL_TYPE (sym
)->name () == 0)
22021 SYMBOL_TYPE (sym
)->set_name (sym
->search_name ());
22026 case DW_TAG_typedef
:
22027 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22028 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22029 list_to_add
= cu
->list_in_scope
;
22031 case DW_TAG_base_type
:
22032 case DW_TAG_subrange_type
:
22033 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22034 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22035 list_to_add
= cu
->list_in_scope
;
22037 case DW_TAG_enumerator
:
22038 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22039 if (attr
!= nullptr)
22041 dwarf2_const_value (attr
, sym
, cu
);
22044 /* NOTE: carlton/2003-11-10: See comment above in the
22045 DW_TAG_class_type, etc. block. */
22048 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
22049 && cu
->language
== language_cplus
22050 ? cu
->get_builder ()->get_global_symbols ()
22051 : cu
->list_in_scope
);
22054 case DW_TAG_imported_declaration
:
22055 case DW_TAG_namespace
:
22056 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22057 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22059 case DW_TAG_module
:
22060 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22061 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
22062 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22064 case DW_TAG_common_block
:
22065 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
22066 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
22067 add_symbol_to_list (sym
, cu
->list_in_scope
);
22070 /* Not a tag we recognize. Hopefully we aren't processing
22071 trash data, but since we must specifically ignore things
22072 we don't recognize, there is nothing else we should do at
22074 complaint (_("unsupported tag: '%s'"),
22075 dwarf_tag_name (die
->tag
));
22081 sym
->hash_next
= objfile
->template_symbols
;
22082 objfile
->template_symbols
= sym
;
22083 list_to_add
= NULL
;
22086 if (list_to_add
!= NULL
)
22087 add_symbol_to_list (sym
, list_to_add
);
22089 /* For the benefit of old versions of GCC, check for anonymous
22090 namespaces based on the demangled name. */
22091 if (!cu
->processing_has_namespace_info
22092 && cu
->language
== language_cplus
)
22093 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
22098 /* Given an attr with a DW_FORM_dataN value in host byte order,
22099 zero-extend it as appropriate for the symbol's type. The DWARF
22100 standard (v4) is not entirely clear about the meaning of using
22101 DW_FORM_dataN for a constant with a signed type, where the type is
22102 wider than the data. The conclusion of a discussion on the DWARF
22103 list was that this is unspecified. We choose to always zero-extend
22104 because that is the interpretation long in use by GCC. */
22107 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
22108 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
22110 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22111 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
22112 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
22113 LONGEST l
= attr
->constant_value (0);
22115 if (bits
< sizeof (*value
) * 8)
22117 l
&= ((LONGEST
) 1 << bits
) - 1;
22120 else if (bits
== sizeof (*value
) * 8)
22124 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
22125 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
22132 /* Read a constant value from an attribute. Either set *VALUE, or if
22133 the value does not fit in *VALUE, set *BYTES - either already
22134 allocated on the objfile obstack, or newly allocated on OBSTACK,
22135 or, set *BATON, if we translated the constant to a location
22139 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
22140 const char *name
, struct obstack
*obstack
,
22141 struct dwarf2_cu
*cu
,
22142 LONGEST
*value
, const gdb_byte
**bytes
,
22143 struct dwarf2_locexpr_baton
**baton
)
22145 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22146 struct objfile
*objfile
= per_objfile
->objfile
;
22147 struct comp_unit_head
*cu_header
= &cu
->header
;
22148 struct dwarf_block
*blk
;
22149 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
22150 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
22156 switch (attr
->form
)
22159 case DW_FORM_addrx
:
22160 case DW_FORM_GNU_addr_index
:
22164 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
22165 dwarf2_const_value_length_mismatch_complaint (name
,
22166 cu_header
->addr_size
,
22167 TYPE_LENGTH (type
));
22168 /* Symbols of this form are reasonably rare, so we just
22169 piggyback on the existing location code rather than writing
22170 a new implementation of symbol_computed_ops. */
22171 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
22172 (*baton
)->per_objfile
= per_objfile
;
22173 (*baton
)->per_cu
= cu
->per_cu
;
22174 gdb_assert ((*baton
)->per_cu
);
22176 (*baton
)->size
= 2 + cu_header
->addr_size
;
22177 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
22178 (*baton
)->data
= data
;
22180 data
[0] = DW_OP_addr
;
22181 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
22182 byte_order
, attr
->as_address ());
22183 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
22186 case DW_FORM_string
:
22189 case DW_FORM_GNU_str_index
:
22190 case DW_FORM_GNU_strp_alt
:
22191 /* The string is already allocated on the objfile obstack, point
22193 *bytes
= (const gdb_byte
*) attr
->as_string ();
22195 case DW_FORM_block1
:
22196 case DW_FORM_block2
:
22197 case DW_FORM_block4
:
22198 case DW_FORM_block
:
22199 case DW_FORM_exprloc
:
22200 case DW_FORM_data16
:
22201 blk
= attr
->as_block ();
22202 if (TYPE_LENGTH (type
) != blk
->size
)
22203 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
22204 TYPE_LENGTH (type
));
22205 *bytes
= blk
->data
;
22208 /* The DW_AT_const_value attributes are supposed to carry the
22209 symbol's value "represented as it would be on the target
22210 architecture." By the time we get here, it's already been
22211 converted to host endianness, so we just need to sign- or
22212 zero-extend it as appropriate. */
22213 case DW_FORM_data1
:
22214 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
22216 case DW_FORM_data2
:
22217 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
22219 case DW_FORM_data4
:
22220 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
22222 case DW_FORM_data8
:
22223 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
22226 case DW_FORM_sdata
:
22227 case DW_FORM_implicit_const
:
22228 *value
= attr
->as_signed ();
22231 case DW_FORM_udata
:
22232 *value
= attr
->as_unsigned ();
22236 complaint (_("unsupported const value attribute form: '%s'"),
22237 dwarf_form_name (attr
->form
));
22244 /* Copy constant value from an attribute to a symbol. */
22247 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
22248 struct dwarf2_cu
*cu
)
22250 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22252 const gdb_byte
*bytes
;
22253 struct dwarf2_locexpr_baton
*baton
;
22255 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
22256 sym
->print_name (),
22257 &objfile
->objfile_obstack
, cu
,
22258 &value
, &bytes
, &baton
);
22262 SYMBOL_LOCATION_BATON (sym
) = baton
;
22263 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
22265 else if (bytes
!= NULL
)
22267 SYMBOL_VALUE_BYTES (sym
) = bytes
;
22268 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
22272 SYMBOL_VALUE (sym
) = value
;
22273 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
22277 /* Return the type of the die in question using its DW_AT_type attribute. */
22279 static struct type
*
22280 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22282 struct attribute
*type_attr
;
22284 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
22287 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22288 /* A missing DW_AT_type represents a void type. */
22289 return objfile_type (objfile
)->builtin_void
;
22292 return lookup_die_type (die
, type_attr
, cu
);
22295 /* True iff CU's producer generates GNAT Ada auxiliary information
22296 that allows to find parallel types through that information instead
22297 of having to do expensive parallel lookups by type name. */
22300 need_gnat_info (struct dwarf2_cu
*cu
)
22302 /* Assume that the Ada compiler was GNAT, which always produces
22303 the auxiliary information. */
22304 return (cu
->language
== language_ada
);
22307 /* Return the auxiliary type of the die in question using its
22308 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
22309 attribute is not present. */
22311 static struct type
*
22312 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22314 struct attribute
*type_attr
;
22316 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22320 return lookup_die_type (die
, type_attr
, cu
);
22323 /* If DIE has a descriptive_type attribute, then set the TYPE's
22324 descriptive type accordingly. */
22327 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22328 struct dwarf2_cu
*cu
)
22330 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22332 if (descriptive_type
)
22334 ALLOCATE_GNAT_AUX_TYPE (type
);
22335 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22339 /* Return the containing type of the die in question using its
22340 DW_AT_containing_type attribute. */
22342 static struct type
*
22343 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22345 struct attribute
*type_attr
;
22346 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22348 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22350 error (_("Dwarf Error: Problem turning containing type into gdb type "
22351 "[in module %s]"), objfile_name (objfile
));
22353 return lookup_die_type (die
, type_attr
, cu
);
22356 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22358 static struct type
*
22359 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22361 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22362 struct objfile
*objfile
= per_objfile
->objfile
;
22365 std::string message
22366 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22367 objfile_name (objfile
),
22368 sect_offset_str (cu
->header
.sect_off
),
22369 sect_offset_str (die
->sect_off
));
22370 saved
= obstack_strdup (&objfile
->objfile_obstack
, message
);
22372 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22375 /* Look up the type of DIE in CU using its type attribute ATTR.
22376 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22377 DW_AT_containing_type.
22378 If there is no type substitute an error marker. */
22380 static struct type
*
22381 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22382 struct dwarf2_cu
*cu
)
22384 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22385 struct objfile
*objfile
= per_objfile
->objfile
;
22386 struct type
*this_type
;
22388 gdb_assert (attr
->name
== DW_AT_type
22389 || attr
->name
== DW_AT_GNAT_descriptive_type
22390 || attr
->name
== DW_AT_containing_type
);
22392 /* First see if we have it cached. */
22394 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22396 struct dwarf2_per_cu_data
*per_cu
;
22397 sect_offset sect_off
= attr
->get_ref_die_offset ();
22399 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1, per_objfile
);
22400 this_type
= get_die_type_at_offset (sect_off
, per_cu
, per_objfile
);
22402 else if (attr
->form_is_ref ())
22404 sect_offset sect_off
= attr
->get_ref_die_offset ();
22406 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
, per_objfile
);
22408 else if (attr
->form
== DW_FORM_ref_sig8
)
22410 ULONGEST signature
= attr
->as_signature ();
22412 return get_signatured_type (die
, signature
, cu
);
22416 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22417 " at %s [in module %s]"),
22418 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22419 objfile_name (objfile
));
22420 return build_error_marker_type (cu
, die
);
22423 /* If not cached we need to read it in. */
22425 if (this_type
== NULL
)
22427 struct die_info
*type_die
= NULL
;
22428 struct dwarf2_cu
*type_cu
= cu
;
22430 if (attr
->form_is_ref ())
22431 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22432 if (type_die
== NULL
)
22433 return build_error_marker_type (cu
, die
);
22434 /* If we find the type now, it's probably because the type came
22435 from an inter-CU reference and the type's CU got expanded before
22437 this_type
= read_type_die (type_die
, type_cu
);
22440 /* If we still don't have a type use an error marker. */
22442 if (this_type
== NULL
)
22443 return build_error_marker_type (cu
, die
);
22448 /* Return the type in DIE, CU.
22449 Returns NULL for invalid types.
22451 This first does a lookup in die_type_hash,
22452 and only reads the die in if necessary.
22454 NOTE: This can be called when reading in partial or full symbols. */
22456 static struct type
*
22457 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22459 struct type
*this_type
;
22461 this_type
= get_die_type (die
, cu
);
22465 return read_type_die_1 (die
, cu
);
22468 /* Read the type in DIE, CU.
22469 Returns NULL for invalid types. */
22471 static struct type
*
22472 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22474 struct type
*this_type
= NULL
;
22478 case DW_TAG_class_type
:
22479 case DW_TAG_interface_type
:
22480 case DW_TAG_structure_type
:
22481 case DW_TAG_union_type
:
22482 this_type
= read_structure_type (die
, cu
);
22484 case DW_TAG_enumeration_type
:
22485 this_type
= read_enumeration_type (die
, cu
);
22487 case DW_TAG_subprogram
:
22488 case DW_TAG_subroutine_type
:
22489 case DW_TAG_inlined_subroutine
:
22490 this_type
= read_subroutine_type (die
, cu
);
22492 case DW_TAG_array_type
:
22493 this_type
= read_array_type (die
, cu
);
22495 case DW_TAG_set_type
:
22496 this_type
= read_set_type (die
, cu
);
22498 case DW_TAG_pointer_type
:
22499 this_type
= read_tag_pointer_type (die
, cu
);
22501 case DW_TAG_ptr_to_member_type
:
22502 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22504 case DW_TAG_reference_type
:
22505 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22507 case DW_TAG_rvalue_reference_type
:
22508 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22510 case DW_TAG_const_type
:
22511 this_type
= read_tag_const_type (die
, cu
);
22513 case DW_TAG_volatile_type
:
22514 this_type
= read_tag_volatile_type (die
, cu
);
22516 case DW_TAG_restrict_type
:
22517 this_type
= read_tag_restrict_type (die
, cu
);
22519 case DW_TAG_string_type
:
22520 this_type
= read_tag_string_type (die
, cu
);
22522 case DW_TAG_typedef
:
22523 this_type
= read_typedef (die
, cu
);
22525 case DW_TAG_subrange_type
:
22526 this_type
= read_subrange_type (die
, cu
);
22528 case DW_TAG_base_type
:
22529 this_type
= read_base_type (die
, cu
);
22531 case DW_TAG_unspecified_type
:
22532 this_type
= read_unspecified_type (die
, cu
);
22534 case DW_TAG_namespace
:
22535 this_type
= read_namespace_type (die
, cu
);
22537 case DW_TAG_module
:
22538 this_type
= read_module_type (die
, cu
);
22540 case DW_TAG_atomic_type
:
22541 this_type
= read_tag_atomic_type (die
, cu
);
22544 complaint (_("unexpected tag in read_type_die: '%s'"),
22545 dwarf_tag_name (die
->tag
));
22552 /* See if we can figure out if the class lives in a namespace. We do
22553 this by looking for a member function; its demangled name will
22554 contain namespace info, if there is any.
22555 Return the computed name or NULL.
22556 Space for the result is allocated on the objfile's obstack.
22557 This is the full-die version of guess_partial_die_structure_name.
22558 In this case we know DIE has no useful parent. */
22560 static const char *
22561 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22563 struct die_info
*spec_die
;
22564 struct dwarf2_cu
*spec_cu
;
22565 struct die_info
*child
;
22566 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22569 spec_die
= die_specification (die
, &spec_cu
);
22570 if (spec_die
!= NULL
)
22576 for (child
= die
->child
;
22578 child
= child
->sibling
)
22580 if (child
->tag
== DW_TAG_subprogram
)
22582 const char *linkage_name
= dw2_linkage_name (child
, cu
);
22584 if (linkage_name
!= NULL
)
22586 gdb::unique_xmalloc_ptr
<char> actual_name
22587 (cu
->language_defn
->class_name_from_physname (linkage_name
));
22588 const char *name
= NULL
;
22590 if (actual_name
!= NULL
)
22592 const char *die_name
= dwarf2_name (die
, cu
);
22594 if (die_name
!= NULL
22595 && strcmp (die_name
, actual_name
.get ()) != 0)
22597 /* Strip off the class name from the full name.
22598 We want the prefix. */
22599 int die_name_len
= strlen (die_name
);
22600 int actual_name_len
= strlen (actual_name
.get ());
22601 const char *ptr
= actual_name
.get ();
22603 /* Test for '::' as a sanity check. */
22604 if (actual_name_len
> die_name_len
+ 2
22605 && ptr
[actual_name_len
- die_name_len
- 1] == ':')
22606 name
= obstack_strndup (
22607 &objfile
->per_bfd
->storage_obstack
,
22608 ptr
, actual_name_len
- die_name_len
- 2);
22619 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22620 prefix part in such case. See
22621 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22623 static const char *
22624 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22626 struct attribute
*attr
;
22629 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
22630 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
22633 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
22636 attr
= dw2_linkage_name_attr (die
, cu
);
22637 const char *attr_name
= attr
->as_string ();
22638 if (attr
== NULL
|| attr_name
== NULL
)
22641 /* dwarf2_name had to be already called. */
22642 gdb_assert (attr
->canonical_string_p ());
22644 /* Strip the base name, keep any leading namespaces/classes. */
22645 base
= strrchr (attr_name
, ':');
22646 if (base
== NULL
|| base
== attr_name
|| base
[-1] != ':')
22649 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22650 return obstack_strndup (&objfile
->per_bfd
->storage_obstack
,
22652 &base
[-1] - attr_name
);
22655 /* Return the name of the namespace/class that DIE is defined within,
22656 or "" if we can't tell. The caller should not xfree the result.
22658 For example, if we're within the method foo() in the following
22668 then determine_prefix on foo's die will return "N::C". */
22670 static const char *
22671 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22673 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
22674 struct die_info
*parent
, *spec_die
;
22675 struct dwarf2_cu
*spec_cu
;
22676 struct type
*parent_type
;
22677 const char *retval
;
22679 if (cu
->language
!= language_cplus
22680 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
22681 && cu
->language
!= language_rust
)
22684 retval
= anonymous_struct_prefix (die
, cu
);
22688 /* We have to be careful in the presence of DW_AT_specification.
22689 For example, with GCC 3.4, given the code
22693 // Definition of N::foo.
22697 then we'll have a tree of DIEs like this:
22699 1: DW_TAG_compile_unit
22700 2: DW_TAG_namespace // N
22701 3: DW_TAG_subprogram // declaration of N::foo
22702 4: DW_TAG_subprogram // definition of N::foo
22703 DW_AT_specification // refers to die #3
22705 Thus, when processing die #4, we have to pretend that we're in
22706 the context of its DW_AT_specification, namely the contex of die
22709 spec_die
= die_specification (die
, &spec_cu
);
22710 if (spec_die
== NULL
)
22711 parent
= die
->parent
;
22714 parent
= spec_die
->parent
;
22718 if (parent
== NULL
)
22720 else if (parent
->building_fullname
)
22723 const char *parent_name
;
22725 /* It has been seen on RealView 2.2 built binaries,
22726 DW_TAG_template_type_param types actually _defined_ as
22727 children of the parent class:
22730 template class <class Enum> Class{};
22731 Class<enum E> class_e;
22733 1: DW_TAG_class_type (Class)
22734 2: DW_TAG_enumeration_type (E)
22735 3: DW_TAG_enumerator (enum1:0)
22736 3: DW_TAG_enumerator (enum2:1)
22738 2: DW_TAG_template_type_param
22739 DW_AT_type DW_FORM_ref_udata (E)
22741 Besides being broken debug info, it can put GDB into an
22742 infinite loop. Consider:
22744 When we're building the full name for Class<E>, we'll start
22745 at Class, and go look over its template type parameters,
22746 finding E. We'll then try to build the full name of E, and
22747 reach here. We're now trying to build the full name of E,
22748 and look over the parent DIE for containing scope. In the
22749 broken case, if we followed the parent DIE of E, we'd again
22750 find Class, and once again go look at its template type
22751 arguments, etc., etc. Simply don't consider such parent die
22752 as source-level parent of this die (it can't be, the language
22753 doesn't allow it), and break the loop here. */
22754 name
= dwarf2_name (die
, cu
);
22755 parent_name
= dwarf2_name (parent
, cu
);
22756 complaint (_("template param type '%s' defined within parent '%s'"),
22757 name
? name
: "<unknown>",
22758 parent_name
? parent_name
: "<unknown>");
22762 switch (parent
->tag
)
22764 case DW_TAG_namespace
:
22765 parent_type
= read_type_die (parent
, cu
);
22766 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22767 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22768 Work around this problem here. */
22769 if (cu
->language
== language_cplus
22770 && strcmp (parent_type
->name (), "::") == 0)
22772 /* We give a name to even anonymous namespaces. */
22773 return parent_type
->name ();
22774 case DW_TAG_class_type
:
22775 case DW_TAG_interface_type
:
22776 case DW_TAG_structure_type
:
22777 case DW_TAG_union_type
:
22778 case DW_TAG_module
:
22779 parent_type
= read_type_die (parent
, cu
);
22780 if (parent_type
->name () != NULL
)
22781 return parent_type
->name ();
22783 /* An anonymous structure is only allowed non-static data
22784 members; no typedefs, no member functions, et cetera.
22785 So it does not need a prefix. */
22787 case DW_TAG_compile_unit
:
22788 case DW_TAG_partial_unit
:
22789 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22790 if (cu
->language
== language_cplus
22791 && !per_objfile
->per_bfd
->types
.empty ()
22792 && die
->child
!= NULL
22793 && (die
->tag
== DW_TAG_class_type
22794 || die
->tag
== DW_TAG_structure_type
22795 || die
->tag
== DW_TAG_union_type
))
22797 const char *name
= guess_full_die_structure_name (die
, cu
);
22802 case DW_TAG_subprogram
:
22803 /* Nested subroutines in Fortran get a prefix with the name
22804 of the parent's subroutine. */
22805 if (cu
->language
== language_fortran
)
22807 if ((die
->tag
== DW_TAG_subprogram
)
22808 && (dwarf2_name (parent
, cu
) != NULL
))
22809 return dwarf2_name (parent
, cu
);
22811 return determine_prefix (parent
, cu
);
22812 case DW_TAG_enumeration_type
:
22813 parent_type
= read_type_die (parent
, cu
);
22814 if (TYPE_DECLARED_CLASS (parent_type
))
22816 if (parent_type
->name () != NULL
)
22817 return parent_type
->name ();
22820 /* Fall through. */
22822 return determine_prefix (parent
, cu
);
22826 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22827 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22828 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22829 an obconcat, otherwise allocate storage for the result. The CU argument is
22830 used to determine the language and hence, the appropriate separator. */
22832 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22835 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
22836 int physname
, struct dwarf2_cu
*cu
)
22838 const char *lead
= "";
22841 if (suffix
== NULL
|| suffix
[0] == '\0'
22842 || prefix
== NULL
|| prefix
[0] == '\0')
22844 else if (cu
->language
== language_d
)
22846 /* For D, the 'main' function could be defined in any module, but it
22847 should never be prefixed. */
22848 if (strcmp (suffix
, "D main") == 0)
22856 else if (cu
->language
== language_fortran
&& physname
)
22858 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22859 DW_AT_MIPS_linkage_name is preferred and used instead. */
22867 if (prefix
== NULL
)
22869 if (suffix
== NULL
)
22876 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
22878 strcpy (retval
, lead
);
22879 strcat (retval
, prefix
);
22880 strcat (retval
, sep
);
22881 strcat (retval
, suffix
);
22886 /* We have an obstack. */
22887 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
22891 /* Get name of a die, return NULL if not found. */
22893 static const char *
22894 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
22895 struct objfile
*objfile
)
22897 if (name
&& cu
->language
== language_cplus
)
22899 gdb::unique_xmalloc_ptr
<char> canon_name
22900 = cp_canonicalize_string (name
);
22902 if (canon_name
!= nullptr)
22903 name
= objfile
->intern (canon_name
.get ());
22909 /* Get name of a die, return NULL if not found.
22910 Anonymous namespaces are converted to their magic string. */
22912 static const char *
22913 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22915 struct attribute
*attr
;
22916 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
22918 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
22919 const char *attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
22920 if (attr_name
== nullptr
22921 && die
->tag
!= DW_TAG_namespace
22922 && die
->tag
!= DW_TAG_class_type
22923 && die
->tag
!= DW_TAG_interface_type
22924 && die
->tag
!= DW_TAG_structure_type
22925 && die
->tag
!= DW_TAG_union_type
)
22930 case DW_TAG_compile_unit
:
22931 case DW_TAG_partial_unit
:
22932 /* Compilation units have a DW_AT_name that is a filename, not
22933 a source language identifier. */
22934 case DW_TAG_enumeration_type
:
22935 case DW_TAG_enumerator
:
22936 /* These tags always have simple identifiers already; no need
22937 to canonicalize them. */
22940 case DW_TAG_namespace
:
22941 if (attr_name
!= nullptr)
22943 return CP_ANONYMOUS_NAMESPACE_STR
;
22945 case DW_TAG_class_type
:
22946 case DW_TAG_interface_type
:
22947 case DW_TAG_structure_type
:
22948 case DW_TAG_union_type
:
22949 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22950 structures or unions. These were of the form "._%d" in GCC 4.1,
22951 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22952 and GCC 4.4. We work around this problem by ignoring these. */
22953 if (attr_name
!= nullptr
22954 && (startswith (attr_name
, "._")
22955 || startswith (attr_name
, "<anonymous")))
22958 /* GCC might emit a nameless typedef that has a linkage name. See
22959 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22960 if (!attr
|| attr_name
== NULL
)
22962 attr
= dw2_linkage_name_attr (die
, cu
);
22963 attr_name
= attr
== nullptr ? nullptr : attr
->as_string ();
22964 if (attr
== NULL
|| attr_name
== NULL
)
22967 /* Avoid demangling attr_name the second time on a second
22968 call for the same DIE. */
22969 if (!attr
->canonical_string_p ())
22971 gdb::unique_xmalloc_ptr
<char> demangled
22972 (gdb_demangle (attr_name
, DMGL_TYPES
));
22973 if (demangled
== nullptr)
22976 attr
->set_string_canonical (objfile
->intern (demangled
.get ()));
22977 attr_name
= attr
->as_string ();
22980 /* Strip any leading namespaces/classes, keep only the
22981 base name. DW_AT_name for named DIEs does not
22982 contain the prefixes. */
22983 const char *base
= strrchr (attr_name
, ':');
22984 if (base
&& base
> attr_name
&& base
[-1] == ':')
22995 if (!attr
->canonical_string_p ())
22996 attr
->set_string_canonical (dwarf2_canonicalize_name (attr_name
, cu
,
22998 return attr
->as_string ();
23001 /* Return the die that this die in an extension of, or NULL if there
23002 is none. *EXT_CU is the CU containing DIE on input, and the CU
23003 containing the return value on output. */
23005 static struct die_info
*
23006 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
23008 struct attribute
*attr
;
23010 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
23014 return follow_die_ref (die
, attr
, ext_cu
);
23018 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
23022 print_spaces (indent
, f
);
23023 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
23024 dwarf_tag_name (die
->tag
), die
->abbrev
,
23025 sect_offset_str (die
->sect_off
));
23027 if (die
->parent
!= NULL
)
23029 print_spaces (indent
, f
);
23030 fprintf_unfiltered (f
, " parent at offset: %s\n",
23031 sect_offset_str (die
->parent
->sect_off
));
23034 print_spaces (indent
, f
);
23035 fprintf_unfiltered (f
, " has children: %s\n",
23036 dwarf_bool_name (die
->child
!= NULL
));
23038 print_spaces (indent
, f
);
23039 fprintf_unfiltered (f
, " attributes:\n");
23041 for (i
= 0; i
< die
->num_attrs
; ++i
)
23043 print_spaces (indent
, f
);
23044 fprintf_unfiltered (f
, " %s (%s) ",
23045 dwarf_attr_name (die
->attrs
[i
].name
),
23046 dwarf_form_name (die
->attrs
[i
].form
));
23048 switch (die
->attrs
[i
].form
)
23051 case DW_FORM_addrx
:
23052 case DW_FORM_GNU_addr_index
:
23053 fprintf_unfiltered (f
, "address: ");
23054 fputs_filtered (hex_string (die
->attrs
[i
].as_address ()), f
);
23056 case DW_FORM_block2
:
23057 case DW_FORM_block4
:
23058 case DW_FORM_block
:
23059 case DW_FORM_block1
:
23060 fprintf_unfiltered (f
, "block: size %s",
23061 pulongest (die
->attrs
[i
].as_block ()->size
));
23063 case DW_FORM_exprloc
:
23064 fprintf_unfiltered (f
, "expression: size %s",
23065 pulongest (die
->attrs
[i
].as_block ()->size
));
23067 case DW_FORM_data16
:
23068 fprintf_unfiltered (f
, "constant of 16 bytes");
23070 case DW_FORM_ref_addr
:
23071 fprintf_unfiltered (f
, "ref address: ");
23072 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
23074 case DW_FORM_GNU_ref_alt
:
23075 fprintf_unfiltered (f
, "alt ref address: ");
23076 fputs_filtered (hex_string (die
->attrs
[i
].as_unsigned ()), f
);
23082 case DW_FORM_ref_udata
:
23083 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
23084 (long) (die
->attrs
[i
].as_unsigned ()));
23086 case DW_FORM_data1
:
23087 case DW_FORM_data2
:
23088 case DW_FORM_data4
:
23089 case DW_FORM_data8
:
23090 case DW_FORM_udata
:
23091 fprintf_unfiltered (f
, "constant: %s",
23092 pulongest (die
->attrs
[i
].as_unsigned ()));
23094 case DW_FORM_sec_offset
:
23095 fprintf_unfiltered (f
, "section offset: %s",
23096 pulongest (die
->attrs
[i
].as_unsigned ()));
23098 case DW_FORM_ref_sig8
:
23099 fprintf_unfiltered (f
, "signature: %s",
23100 hex_string (die
->attrs
[i
].as_signature ()));
23102 case DW_FORM_string
:
23104 case DW_FORM_line_strp
:
23106 case DW_FORM_GNU_str_index
:
23107 case DW_FORM_GNU_strp_alt
:
23108 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
23109 die
->attrs
[i
].as_string ()
23110 ? die
->attrs
[i
].as_string () : "",
23111 die
->attrs
[i
].canonical_string_p () ? "is" : "not");
23114 if (die
->attrs
[i
].as_boolean ())
23115 fprintf_unfiltered (f
, "flag: TRUE");
23117 fprintf_unfiltered (f
, "flag: FALSE");
23119 case DW_FORM_flag_present
:
23120 fprintf_unfiltered (f
, "flag: TRUE");
23122 case DW_FORM_indirect
:
23123 /* The reader will have reduced the indirect form to
23124 the "base form" so this form should not occur. */
23125 fprintf_unfiltered (f
,
23126 "unexpected attribute form: DW_FORM_indirect");
23128 case DW_FORM_sdata
:
23129 case DW_FORM_implicit_const
:
23130 fprintf_unfiltered (f
, "constant: %s",
23131 plongest (die
->attrs
[i
].as_signed ()));
23134 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
23135 die
->attrs
[i
].form
);
23138 fprintf_unfiltered (f
, "\n");
23143 dump_die_for_error (struct die_info
*die
)
23145 dump_die_shallow (gdb_stderr
, 0, die
);
23149 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
23151 int indent
= level
* 4;
23153 gdb_assert (die
!= NULL
);
23155 if (level
>= max_level
)
23158 dump_die_shallow (f
, indent
, die
);
23160 if (die
->child
!= NULL
)
23162 print_spaces (indent
, f
);
23163 fprintf_unfiltered (f
, " Children:");
23164 if (level
+ 1 < max_level
)
23166 fprintf_unfiltered (f
, "\n");
23167 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
23171 fprintf_unfiltered (f
,
23172 " [not printed, max nesting level reached]\n");
23176 if (die
->sibling
!= NULL
&& level
> 0)
23178 dump_die_1 (f
, level
, max_level
, die
->sibling
);
23182 /* This is called from the pdie macro in gdbinit.in.
23183 It's not static so gcc will keep a copy callable from gdb. */
23186 dump_die (struct die_info
*die
, int max_level
)
23188 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
23192 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
23196 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
23197 to_underlying (die
->sect_off
),
23203 /* Follow reference or signature attribute ATTR of SRC_DIE.
23204 On entry *REF_CU is the CU of SRC_DIE.
23205 On exit *REF_CU is the CU of the result. */
23207 static struct die_info
*
23208 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23209 struct dwarf2_cu
**ref_cu
)
23211 struct die_info
*die
;
23213 if (attr
->form_is_ref ())
23214 die
= follow_die_ref (src_die
, attr
, ref_cu
);
23215 else if (attr
->form
== DW_FORM_ref_sig8
)
23216 die
= follow_die_sig (src_die
, attr
, ref_cu
);
23219 dump_die_for_error (src_die
);
23220 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23221 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23227 /* Follow reference OFFSET.
23228 On entry *REF_CU is the CU of the source die referencing OFFSET.
23229 On exit *REF_CU is the CU of the result.
23230 Returns NULL if OFFSET is invalid. */
23232 static struct die_info
*
23233 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
23234 struct dwarf2_cu
**ref_cu
)
23236 struct die_info temp_die
;
23237 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
23238 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23240 gdb_assert (cu
->per_cu
!= NULL
);
23244 if (cu
->per_cu
->is_debug_types
)
23246 /* .debug_types CUs cannot reference anything outside their CU.
23247 If they need to, they have to reference a signatured type via
23248 DW_FORM_ref_sig8. */
23249 if (!cu
->header
.offset_in_cu_p (sect_off
))
23252 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
23253 || !cu
->header
.offset_in_cu_p (sect_off
))
23255 struct dwarf2_per_cu_data
*per_cu
;
23257 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
23260 /* If necessary, add it to the queue and load its DIEs. */
23261 if (maybe_queue_comp_unit (cu
, per_cu
, per_objfile
, cu
->language
))
23262 load_full_comp_unit (per_cu
, per_objfile
, per_objfile
->get_cu (per_cu
),
23263 false, cu
->language
);
23265 target_cu
= per_objfile
->get_cu (per_cu
);
23267 else if (cu
->dies
== NULL
)
23269 /* We're loading full DIEs during partial symbol reading. */
23270 gdb_assert (per_objfile
->per_bfd
->reading_partial_symbols
);
23271 load_full_comp_unit (cu
->per_cu
, per_objfile
, cu
, false,
23275 *ref_cu
= target_cu
;
23276 temp_die
.sect_off
= sect_off
;
23278 if (target_cu
!= cu
)
23279 target_cu
->ancestor
= cu
;
23281 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
23283 to_underlying (sect_off
));
23286 /* Follow reference attribute ATTR of SRC_DIE.
23287 On entry *REF_CU is the CU of SRC_DIE.
23288 On exit *REF_CU is the CU of the result. */
23290 static struct die_info
*
23291 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
23292 struct dwarf2_cu
**ref_cu
)
23294 sect_offset sect_off
= attr
->get_ref_die_offset ();
23295 struct dwarf2_cu
*cu
= *ref_cu
;
23296 struct die_info
*die
;
23298 die
= follow_die_offset (sect_off
,
23299 (attr
->form
== DW_FORM_GNU_ref_alt
23300 || cu
->per_cu
->is_dwz
),
23303 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23304 "at %s [in module %s]"),
23305 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
23306 objfile_name (cu
->per_objfile
->objfile
));
23313 struct dwarf2_locexpr_baton
23314 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
23315 dwarf2_per_cu_data
*per_cu
,
23316 dwarf2_per_objfile
*per_objfile
,
23317 gdb::function_view
<CORE_ADDR ()> get_frame_pc
,
23318 bool resolve_abstract_p
)
23320 struct die_info
*die
;
23321 struct attribute
*attr
;
23322 struct dwarf2_locexpr_baton retval
;
23323 struct objfile
*objfile
= per_objfile
->objfile
;
23325 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23327 cu
= load_cu (per_cu
, per_objfile
, false);
23331 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23332 Instead just throw an error, not much else we can do. */
23333 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23334 sect_offset_str (sect_off
), objfile_name (objfile
));
23337 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23339 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23340 sect_offset_str (sect_off
), objfile_name (objfile
));
23342 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23343 if (!attr
&& resolve_abstract_p
23344 && (per_objfile
->per_bfd
->abstract_to_concrete
.find (die
->sect_off
)
23345 != per_objfile
->per_bfd
->abstract_to_concrete
.end ()))
23347 CORE_ADDR pc
= get_frame_pc ();
23348 CORE_ADDR baseaddr
= objfile
->text_section_offset ();
23349 struct gdbarch
*gdbarch
= objfile
->arch ();
23351 for (const auto &cand_off
23352 : per_objfile
->per_bfd
->abstract_to_concrete
[die
->sect_off
])
23354 struct dwarf2_cu
*cand_cu
= cu
;
23355 struct die_info
*cand
23356 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23359 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23362 CORE_ADDR pc_low
, pc_high
;
23363 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23364 if (pc_low
== ((CORE_ADDR
) -1))
23366 pc_low
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_low
+ baseaddr
);
23367 pc_high
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_high
+ baseaddr
);
23368 if (!(pc_low
<= pc
&& pc
< pc_high
))
23372 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23379 /* DWARF: "If there is no such attribute, then there is no effect.".
23380 DATA is ignored if SIZE is 0. */
23382 retval
.data
= NULL
;
23385 else if (attr
->form_is_section_offset ())
23387 struct dwarf2_loclist_baton loclist_baton
;
23388 CORE_ADDR pc
= get_frame_pc ();
23391 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23393 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23395 retval
.size
= size
;
23399 if (!attr
->form_is_block ())
23400 error (_("Dwarf Error: DIE at %s referenced in module %s "
23401 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23402 sect_offset_str (sect_off
), objfile_name (objfile
));
23404 struct dwarf_block
*block
= attr
->as_block ();
23405 retval
.data
= block
->data
;
23406 retval
.size
= block
->size
;
23408 retval
.per_objfile
= per_objfile
;
23409 retval
.per_cu
= cu
->per_cu
;
23411 per_objfile
->age_comp_units ();
23418 struct dwarf2_locexpr_baton
23419 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23420 dwarf2_per_cu_data
*per_cu
,
23421 dwarf2_per_objfile
*per_objfile
,
23422 gdb::function_view
<CORE_ADDR ()> get_frame_pc
)
23424 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23426 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, per_objfile
,
23430 /* Write a constant of a given type as target-ordered bytes into
23433 static const gdb_byte
*
23434 write_constant_as_bytes (struct obstack
*obstack
,
23435 enum bfd_endian byte_order
,
23442 *len
= TYPE_LENGTH (type
);
23443 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23444 store_unsigned_integer (result
, *len
, byte_order
, value
);
23452 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23453 dwarf2_per_cu_data
*per_cu
,
23454 dwarf2_per_objfile
*per_objfile
,
23458 struct die_info
*die
;
23459 struct attribute
*attr
;
23460 const gdb_byte
*result
= NULL
;
23463 enum bfd_endian byte_order
;
23464 struct objfile
*objfile
= per_objfile
->objfile
;
23466 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23468 cu
= load_cu (per_cu
, per_objfile
, false);
23472 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23473 Instead just throw an error, not much else we can do. */
23474 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23475 sect_offset_str (sect_off
), objfile_name (objfile
));
23478 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23480 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23481 sect_offset_str (sect_off
), objfile_name (objfile
));
23483 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23487 byte_order
= (bfd_big_endian (objfile
->obfd
)
23488 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23490 switch (attr
->form
)
23493 case DW_FORM_addrx
:
23494 case DW_FORM_GNU_addr_index
:
23498 *len
= cu
->header
.addr_size
;
23499 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23500 store_unsigned_integer (tem
, *len
, byte_order
, attr
->as_address ());
23504 case DW_FORM_string
:
23507 case DW_FORM_GNU_str_index
:
23508 case DW_FORM_GNU_strp_alt
:
23509 /* The string is already allocated on the objfile obstack, point
23512 const char *attr_name
= attr
->as_string ();
23513 result
= (const gdb_byte
*) attr_name
;
23514 *len
= strlen (attr_name
);
23517 case DW_FORM_block1
:
23518 case DW_FORM_block2
:
23519 case DW_FORM_block4
:
23520 case DW_FORM_block
:
23521 case DW_FORM_exprloc
:
23522 case DW_FORM_data16
:
23524 struct dwarf_block
*block
= attr
->as_block ();
23525 result
= block
->data
;
23526 *len
= block
->size
;
23530 /* The DW_AT_const_value attributes are supposed to carry the
23531 symbol's value "represented as it would be on the target
23532 architecture." By the time we get here, it's already been
23533 converted to host endianness, so we just need to sign- or
23534 zero-extend it as appropriate. */
23535 case DW_FORM_data1
:
23536 type
= die_type (die
, cu
);
23537 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23538 if (result
== NULL
)
23539 result
= write_constant_as_bytes (obstack
, byte_order
,
23542 case DW_FORM_data2
:
23543 type
= die_type (die
, cu
);
23544 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23545 if (result
== NULL
)
23546 result
= write_constant_as_bytes (obstack
, byte_order
,
23549 case DW_FORM_data4
:
23550 type
= die_type (die
, cu
);
23551 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23552 if (result
== NULL
)
23553 result
= write_constant_as_bytes (obstack
, byte_order
,
23556 case DW_FORM_data8
:
23557 type
= die_type (die
, cu
);
23558 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23559 if (result
== NULL
)
23560 result
= write_constant_as_bytes (obstack
, byte_order
,
23564 case DW_FORM_sdata
:
23565 case DW_FORM_implicit_const
:
23566 type
= die_type (die
, cu
);
23567 result
= write_constant_as_bytes (obstack
, byte_order
,
23568 type
, attr
->as_signed (), len
);
23571 case DW_FORM_udata
:
23572 type
= die_type (die
, cu
);
23573 result
= write_constant_as_bytes (obstack
, byte_order
,
23574 type
, attr
->as_unsigned (), len
);
23578 complaint (_("unsupported const value attribute form: '%s'"),
23579 dwarf_form_name (attr
->form
));
23589 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
23590 dwarf2_per_cu_data
*per_cu
,
23591 dwarf2_per_objfile
*per_objfile
)
23593 struct die_info
*die
;
23595 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
23597 cu
= load_cu (per_cu
, per_objfile
, false);
23602 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23606 return die_type (die
, cu
);
23612 dwarf2_get_die_type (cu_offset die_offset
,
23613 dwarf2_per_cu_data
*per_cu
,
23614 dwarf2_per_objfile
*per_objfile
)
23616 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
23617 return get_die_type_at_offset (die_offset_sect
, per_cu
, per_objfile
);
23620 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23621 On entry *REF_CU is the CU of SRC_DIE.
23622 On exit *REF_CU is the CU of the result.
23623 Returns NULL if the referenced DIE isn't found. */
23625 static struct die_info
*
23626 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
23627 struct dwarf2_cu
**ref_cu
)
23629 struct die_info temp_die
;
23630 struct dwarf2_cu
*sig_cu
, *cu
= *ref_cu
;
23631 struct die_info
*die
;
23632 dwarf2_per_objfile
*per_objfile
= (*ref_cu
)->per_objfile
;
23635 /* While it might be nice to assert sig_type->type == NULL here,
23636 we can get here for DW_AT_imported_declaration where we need
23637 the DIE not the type. */
23639 /* If necessary, add it to the queue and load its DIEs. */
23641 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, per_objfile
,
23643 read_signatured_type (sig_type
, per_objfile
);
23645 sig_cu
= per_objfile
->get_cu (&sig_type
->per_cu
);
23646 gdb_assert (sig_cu
!= NULL
);
23647 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
23648 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
23649 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
23650 to_underlying (temp_die
.sect_off
));
23653 /* For .gdb_index version 7 keep track of included TUs.
23654 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23655 if (per_objfile
->per_bfd
->index_table
!= NULL
23656 && per_objfile
->per_bfd
->index_table
->version
<= 7)
23658 (*ref_cu
)->per_cu
->imported_symtabs_push (sig_cu
->per_cu
);
23663 sig_cu
->ancestor
= cu
;
23671 /* Follow signatured type referenced by ATTR in SRC_DIE.
23672 On entry *REF_CU is the CU of SRC_DIE.
23673 On exit *REF_CU is the CU of the result.
23674 The result is the DIE of the type.
23675 If the referenced type cannot be found an error is thrown. */
23677 static struct die_info
*
23678 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23679 struct dwarf2_cu
**ref_cu
)
23681 ULONGEST signature
= attr
->as_signature ();
23682 struct signatured_type
*sig_type
;
23683 struct die_info
*die
;
23685 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
23687 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
23688 /* sig_type will be NULL if the signatured type is missing from
23690 if (sig_type
== NULL
)
23692 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23693 " from DIE at %s [in module %s]"),
23694 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23695 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23698 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
23701 dump_die_for_error (src_die
);
23702 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23703 " from DIE at %s [in module %s]"),
23704 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23705 objfile_name ((*ref_cu
)->per_objfile
->objfile
));
23711 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23712 reading in and processing the type unit if necessary. */
23714 static struct type
*
23715 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
23716 struct dwarf2_cu
*cu
)
23718 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23719 struct signatured_type
*sig_type
;
23720 struct dwarf2_cu
*type_cu
;
23721 struct die_info
*type_die
;
23724 sig_type
= lookup_signatured_type (cu
, signature
);
23725 /* sig_type will be NULL if the signatured type is missing from
23727 if (sig_type
== NULL
)
23729 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23730 " from DIE at %s [in module %s]"),
23731 hex_string (signature
), sect_offset_str (die
->sect_off
),
23732 objfile_name (per_objfile
->objfile
));
23733 return build_error_marker_type (cu
, die
);
23736 /* If we already know the type we're done. */
23737 type
= per_objfile
->get_type_for_signatured_type (sig_type
);
23738 if (type
!= nullptr)
23742 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
23743 if (type_die
!= NULL
)
23745 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23746 is created. This is important, for example, because for c++ classes
23747 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23748 type
= read_type_die (type_die
, type_cu
);
23751 complaint (_("Dwarf Error: Cannot build signatured type %s"
23752 " referenced from DIE at %s [in module %s]"),
23753 hex_string (signature
), sect_offset_str (die
->sect_off
),
23754 objfile_name (per_objfile
->objfile
));
23755 type
= build_error_marker_type (cu
, die
);
23760 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23761 " from DIE at %s [in module %s]"),
23762 hex_string (signature
), sect_offset_str (die
->sect_off
),
23763 objfile_name (per_objfile
->objfile
));
23764 type
= build_error_marker_type (cu
, die
);
23767 per_objfile
->set_type_for_signatured_type (sig_type
, type
);
23772 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23773 reading in and processing the type unit if necessary. */
23775 static struct type
*
23776 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
23777 struct dwarf2_cu
*cu
) /* ARI: editCase function */
23779 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23780 if (attr
->form_is_ref ())
23782 struct dwarf2_cu
*type_cu
= cu
;
23783 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
23785 return read_type_die (type_die
, type_cu
);
23787 else if (attr
->form
== DW_FORM_ref_sig8
)
23789 return get_signatured_type (die
, attr
->as_signature (), cu
);
23793 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
23795 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23796 " at %s [in module %s]"),
23797 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
23798 objfile_name (per_objfile
->objfile
));
23799 return build_error_marker_type (cu
, die
);
23803 /* Load the DIEs associated with type unit PER_CU into memory. */
23806 load_full_type_unit (dwarf2_per_cu_data
*per_cu
,
23807 dwarf2_per_objfile
*per_objfile
)
23809 struct signatured_type
*sig_type
;
23811 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23812 gdb_assert (! per_cu
->type_unit_group_p ());
23814 /* We have the per_cu, but we need the signatured_type.
23815 Fortunately this is an easy translation. */
23816 gdb_assert (per_cu
->is_debug_types
);
23817 sig_type
= (struct signatured_type
*) per_cu
;
23819 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
23821 read_signatured_type (sig_type
, per_objfile
);
23823 gdb_assert (per_objfile
->get_cu (per_cu
) != nullptr);
23826 /* Read in a signatured type and build its CU and DIEs.
23827 If the type is a stub for the real type in a DWO file,
23828 read in the real type from the DWO file as well. */
23831 read_signatured_type (signatured_type
*sig_type
,
23832 dwarf2_per_objfile
*per_objfile
)
23834 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
23836 gdb_assert (per_cu
->is_debug_types
);
23837 gdb_assert (per_objfile
->get_cu (per_cu
) == nullptr);
23839 cutu_reader
reader (per_cu
, per_objfile
, nullptr, nullptr, false);
23841 if (!reader
.dummy_p
)
23843 struct dwarf2_cu
*cu
= reader
.cu
;
23844 const gdb_byte
*info_ptr
= reader
.info_ptr
;
23846 gdb_assert (cu
->die_hash
== NULL
);
23848 htab_create_alloc_ex (cu
->header
.length
/ 12,
23852 &cu
->comp_unit_obstack
,
23853 hashtab_obstack_allocate
,
23854 dummy_obstack_deallocate
);
23856 if (reader
.comp_unit_die
->has_children
)
23857 reader
.comp_unit_die
->child
23858 = read_die_and_siblings (&reader
, info_ptr
, &info_ptr
,
23859 reader
.comp_unit_die
);
23860 cu
->dies
= reader
.comp_unit_die
;
23861 /* comp_unit_die is not stored in die_hash, no need. */
23863 /* We try not to read any attributes in this function, because
23864 not all CUs needed for references have been loaded yet, and
23865 symbol table processing isn't initialized. But we have to
23866 set the CU language, or we won't be able to build types
23867 correctly. Similarly, if we do not read the producer, we can
23868 not apply producer-specific interpretation. */
23869 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
23874 sig_type
->per_cu
.tu_read
= 1;
23877 /* Decode simple location descriptions.
23878 Given a pointer to a dwarf block that defines a location, compute
23879 the location and return the value. If COMPUTED is non-null, it is
23880 set to true to indicate that decoding was successful, and false
23881 otherwise. If COMPUTED is null, then this function may emit a
23885 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
, bool *computed
)
23887 struct objfile
*objfile
= cu
->per_objfile
->objfile
;
23889 size_t size
= blk
->size
;
23890 const gdb_byte
*data
= blk
->data
;
23891 CORE_ADDR stack
[64];
23893 unsigned int bytes_read
, unsnd
;
23896 if (computed
!= nullptr)
23902 stack
[++stacki
] = 0;
23941 stack
[++stacki
] = op
- DW_OP_lit0
;
23976 stack
[++stacki
] = op
- DW_OP_reg0
;
23979 if (computed
== nullptr)
23980 dwarf2_complex_location_expr_complaint ();
23987 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
23989 stack
[++stacki
] = unsnd
;
23992 if (computed
== nullptr)
23993 dwarf2_complex_location_expr_complaint ();
24000 stack
[++stacki
] = cu
->header
.read_address (objfile
->obfd
, &data
[i
],
24005 case DW_OP_const1u
:
24006 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
24010 case DW_OP_const1s
:
24011 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
24015 case DW_OP_const2u
:
24016 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
24020 case DW_OP_const2s
:
24021 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
24025 case DW_OP_const4u
:
24026 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
24030 case DW_OP_const4s
:
24031 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
24035 case DW_OP_const8u
:
24036 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
24041 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
24047 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
24052 stack
[stacki
+ 1] = stack
[stacki
];
24057 stack
[stacki
- 1] += stack
[stacki
];
24061 case DW_OP_plus_uconst
:
24062 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
24068 stack
[stacki
- 1] -= stack
[stacki
];
24073 /* If we're not the last op, then we definitely can't encode
24074 this using GDB's address_class enum. This is valid for partial
24075 global symbols, although the variable's address will be bogus
24079 if (computed
== nullptr)
24080 dwarf2_complex_location_expr_complaint ();
24086 case DW_OP_GNU_push_tls_address
:
24087 case DW_OP_form_tls_address
:
24088 /* The top of the stack has the offset from the beginning
24089 of the thread control block at which the variable is located. */
24090 /* Nothing should follow this operator, so the top of stack would
24092 /* This is valid for partial global symbols, but the variable's
24093 address will be bogus in the psymtab. Make it always at least
24094 non-zero to not look as a variable garbage collected by linker
24095 which have DW_OP_addr 0. */
24098 if (computed
== nullptr)
24099 dwarf2_complex_location_expr_complaint ();
24106 case DW_OP_GNU_uninit
:
24107 if (computed
!= nullptr)
24112 case DW_OP_GNU_addr_index
:
24113 case DW_OP_GNU_const_index
:
24114 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
24120 if (computed
== nullptr)
24122 const char *name
= get_DW_OP_name (op
);
24125 complaint (_("unsupported stack op: '%s'"),
24128 complaint (_("unsupported stack op: '%02x'"),
24132 return (stack
[stacki
]);
24135 /* Enforce maximum stack depth of SIZE-1 to avoid writing
24136 outside of the allocated space. Also enforce minimum>0. */
24137 if (stacki
>= ARRAY_SIZE (stack
) - 1)
24139 if (computed
== nullptr)
24140 complaint (_("location description stack overflow"));
24146 if (computed
== nullptr)
24147 complaint (_("location description stack underflow"));
24152 if (computed
!= nullptr)
24154 return (stack
[stacki
]);
24157 /* memory allocation interface */
24159 static struct dwarf_block
*
24160 dwarf_alloc_block (struct dwarf2_cu
*cu
)
24162 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
24165 static struct die_info
*
24166 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
24168 struct die_info
*die
;
24169 size_t size
= sizeof (struct die_info
);
24172 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
24174 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
24175 memset (die
, 0, sizeof (struct die_info
));
24181 /* Macro support. */
24183 /* An overload of dwarf_decode_macros that finds the correct section
24184 and ensures it is read in before calling the other overload. */
24187 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
24188 int section_is_gnu
)
24190 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24191 struct objfile
*objfile
= per_objfile
->objfile
;
24192 const struct line_header
*lh
= cu
->line_header
;
24193 unsigned int offset_size
= cu
->header
.offset_size
;
24194 struct dwarf2_section_info
*section
;
24195 const char *section_name
;
24197 if (cu
->dwo_unit
!= nullptr)
24199 if (section_is_gnu
)
24201 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
24202 section_name
= ".debug_macro.dwo";
24206 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
24207 section_name
= ".debug_macinfo.dwo";
24212 if (section_is_gnu
)
24214 section
= &per_objfile
->per_bfd
->macro
;
24215 section_name
= ".debug_macro";
24219 section
= &per_objfile
->per_bfd
->macinfo
;
24220 section_name
= ".debug_macinfo";
24224 section
->read (objfile
);
24225 if (section
->buffer
== nullptr)
24227 complaint (_("missing %s section"), section_name
);
24231 buildsym_compunit
*builder
= cu
->get_builder ();
24233 struct dwarf2_section_info
*str_offsets_section
;
24234 struct dwarf2_section_info
*str_section
;
24235 ULONGEST str_offsets_base
;
24237 if (cu
->dwo_unit
!= nullptr)
24239 str_offsets_section
= &cu
->dwo_unit
->dwo_file
24240 ->sections
.str_offsets
;
24241 str_section
= &cu
->dwo_unit
->dwo_file
->sections
.str
;
24242 str_offsets_base
= cu
->header
.addr_size
;
24246 str_offsets_section
= &per_objfile
->per_bfd
->str_offsets
;
24247 str_section
= &per_objfile
->per_bfd
->str
;
24248 str_offsets_base
= *cu
->str_offsets_base
;
24251 dwarf_decode_macros (per_objfile
, builder
, section
, lh
,
24252 offset_size
, offset
, str_section
, str_offsets_section
,
24253 str_offsets_base
, section_is_gnu
);
24256 /* Return the .debug_loc section to use for CU.
24257 For DWO files use .debug_loc.dwo. */
24259 static struct dwarf2_section_info
*
24260 cu_debug_loc_section (struct dwarf2_cu
*cu
)
24262 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24266 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24268 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
24270 return (cu
->header
.version
>= 5 ? &per_objfile
->per_bfd
->loclists
24271 : &per_objfile
->per_bfd
->loc
);
24274 /* Return the .debug_rnglists section to use for CU. */
24275 static struct dwarf2_section_info
*
24276 cu_debug_rnglists_section (struct dwarf2_cu
*cu
, dwarf_tag tag
)
24278 if (cu
->header
.version
< 5)
24279 error (_(".debug_rnglists section cannot be used in DWARF %d"),
24280 cu
->header
.version
);
24281 struct dwarf2_per_objfile
*dwarf2_per_objfile
= cu
->per_objfile
;
24283 /* Make sure we read the .debug_rnglists section from the file that
24284 contains the DW_AT_ranges attribute we are reading. Normally that
24285 would be the .dwo file, if there is one. However for DW_TAG_compile_unit
24286 or DW_TAG_skeleton unit, we always want to read from objfile/linked
24288 if (cu
->dwo_unit
!= nullptr
24289 && tag
!= DW_TAG_compile_unit
24290 && tag
!= DW_TAG_skeleton_unit
)
24292 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
24294 if (sections
->rnglists
.size
> 0)
24295 return §ions
->rnglists
;
24297 error (_(".debug_rnglists section is missing from .dwo file."));
24299 return &dwarf2_per_objfile
->per_bfd
->rnglists
;
24302 /* A helper function that fills in a dwarf2_loclist_baton. */
24305 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
24306 struct dwarf2_loclist_baton
*baton
,
24307 const struct attribute
*attr
)
24309 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24310 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24312 section
->read (per_objfile
->objfile
);
24314 baton
->per_objfile
= per_objfile
;
24315 baton
->per_cu
= cu
->per_cu
;
24316 gdb_assert (baton
->per_cu
);
24317 /* We don't know how long the location list is, but make sure we
24318 don't run off the edge of the section. */
24319 baton
->size
= section
->size
- attr
->as_unsigned ();
24320 baton
->data
= section
->buffer
+ attr
->as_unsigned ();
24321 if (cu
->base_address
.has_value ())
24322 baton
->base_address
= *cu
->base_address
;
24324 baton
->base_address
= 0;
24325 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
24329 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
24330 struct dwarf2_cu
*cu
, int is_block
)
24332 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24333 struct objfile
*objfile
= per_objfile
->objfile
;
24334 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
24336 if (attr
->form_is_section_offset ()
24337 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24338 the section. If so, fall through to the complaint in the
24340 && attr
->as_unsigned () < section
->get_size (objfile
))
24342 struct dwarf2_loclist_baton
*baton
;
24344 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
24346 fill_in_loclist_baton (cu
, baton
, attr
);
24348 if (!cu
->base_address
.has_value ())
24349 complaint (_("Location list used without "
24350 "specifying the CU base address."));
24352 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24353 ? dwarf2_loclist_block_index
24354 : dwarf2_loclist_index
);
24355 SYMBOL_LOCATION_BATON (sym
) = baton
;
24359 struct dwarf2_locexpr_baton
*baton
;
24361 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
24362 baton
->per_objfile
= per_objfile
;
24363 baton
->per_cu
= cu
->per_cu
;
24364 gdb_assert (baton
->per_cu
);
24366 if (attr
->form_is_block ())
24368 /* Note that we're just copying the block's data pointer
24369 here, not the actual data. We're still pointing into the
24370 info_buffer for SYM's objfile; right now we never release
24371 that buffer, but when we do clean up properly this may
24373 struct dwarf_block
*block
= attr
->as_block ();
24374 baton
->size
= block
->size
;
24375 baton
->data
= block
->data
;
24379 dwarf2_invalid_attrib_class_complaint ("location description",
24380 sym
->natural_name ());
24384 SYMBOL_ACLASS_INDEX (sym
) = (is_block
24385 ? dwarf2_locexpr_block_index
24386 : dwarf2_locexpr_index
);
24387 SYMBOL_LOCATION_BATON (sym
) = baton
;
24393 const comp_unit_head
*
24394 dwarf2_per_cu_data::get_header () const
24396 if (!m_header_read_in
)
24398 const gdb_byte
*info_ptr
24399 = this->section
->buffer
+ to_underlying (this->sect_off
);
24401 memset (&m_header
, 0, sizeof (m_header
));
24403 read_comp_unit_head (&m_header
, info_ptr
, this->section
,
24404 rcuh_kind::COMPILE
);
24413 dwarf2_per_cu_data::addr_size () const
24415 return this->get_header ()->addr_size
;
24421 dwarf2_per_cu_data::offset_size () const
24423 return this->get_header ()->offset_size
;
24429 dwarf2_per_cu_data::ref_addr_size () const
24431 const comp_unit_head
*header
= this->get_header ();
24433 if (header
->version
== 2)
24434 return header
->addr_size
;
24436 return header
->offset_size
;
24442 dwarf2_cu::addr_type () const
24444 struct objfile
*objfile
= this->per_objfile
->objfile
;
24445 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
24446 struct type
*addr_type
= lookup_pointer_type (void_type
);
24447 int addr_size
= this->per_cu
->addr_size ();
24449 if (TYPE_LENGTH (addr_type
) == addr_size
)
24452 addr_type
= addr_sized_int_type (addr_type
->is_unsigned ());
24456 /* A helper function for dwarf2_find_containing_comp_unit that returns
24457 the index of the result, and that searches a vector. It will
24458 return a result even if the offset in question does not actually
24459 occur in any CU. This is separate so that it can be unit
24463 dwarf2_find_containing_comp_unit
24464 (sect_offset sect_off
,
24465 unsigned int offset_in_dwz
,
24466 const std::vector
<dwarf2_per_cu_data
*> &all_comp_units
)
24471 high
= all_comp_units
.size () - 1;
24474 struct dwarf2_per_cu_data
*mid_cu
;
24475 int mid
= low
+ (high
- low
) / 2;
24477 mid_cu
= all_comp_units
[mid
];
24478 if (mid_cu
->is_dwz
> offset_in_dwz
24479 || (mid_cu
->is_dwz
== offset_in_dwz
24480 && mid_cu
->sect_off
+ mid_cu
->length
> sect_off
))
24485 gdb_assert (low
== high
);
24489 /* Locate the .debug_info compilation unit from CU's objfile which contains
24490 the DIE at OFFSET. Raises an error on failure. */
24492 static struct dwarf2_per_cu_data
*
24493 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
24494 unsigned int offset_in_dwz
,
24495 dwarf2_per_objfile
*per_objfile
)
24497 int low
= dwarf2_find_containing_comp_unit
24498 (sect_off
, offset_in_dwz
, per_objfile
->per_bfd
->all_comp_units
);
24499 dwarf2_per_cu_data
*this_cu
= per_objfile
->per_bfd
->all_comp_units
[low
];
24501 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
24503 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
24504 error (_("Dwarf Error: could not find partial DIE containing "
24505 "offset %s [in module %s]"),
24506 sect_offset_str (sect_off
),
24507 bfd_get_filename (per_objfile
->objfile
->obfd
));
24509 gdb_assert (per_objfile
->per_bfd
->all_comp_units
[low
-1]->sect_off
24511 return per_objfile
->per_bfd
->all_comp_units
[low
-1];
24515 if (low
== per_objfile
->per_bfd
->all_comp_units
.size () - 1
24516 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
24517 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
24518 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
24525 namespace selftests
{
24526 namespace find_containing_comp_unit
{
24531 struct dwarf2_per_cu_data one
{};
24532 struct dwarf2_per_cu_data two
{};
24533 struct dwarf2_per_cu_data three
{};
24534 struct dwarf2_per_cu_data four
{};
24537 two
.sect_off
= sect_offset (one
.length
);
24542 four
.sect_off
= sect_offset (three
.length
);
24546 std::vector
<dwarf2_per_cu_data
*> units
;
24547 units
.push_back (&one
);
24548 units
.push_back (&two
);
24549 units
.push_back (&three
);
24550 units
.push_back (&four
);
24554 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 0, units
);
24555 SELF_CHECK (units
[result
] == &one
);
24556 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 0, units
);
24557 SELF_CHECK (units
[result
] == &one
);
24558 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 0, units
);
24559 SELF_CHECK (units
[result
] == &two
);
24561 result
= dwarf2_find_containing_comp_unit (sect_offset (0), 1, units
);
24562 SELF_CHECK (units
[result
] == &three
);
24563 result
= dwarf2_find_containing_comp_unit (sect_offset (3), 1, units
);
24564 SELF_CHECK (units
[result
] == &three
);
24565 result
= dwarf2_find_containing_comp_unit (sect_offset (5), 1, units
);
24566 SELF_CHECK (units
[result
] == &four
);
24572 #endif /* GDB_SELF_TEST */
24574 /* Initialize dwarf2_cu to read PER_CU, in the context of PER_OBJFILE. */
24576 dwarf2_cu::dwarf2_cu (dwarf2_per_cu_data
*per_cu
,
24577 dwarf2_per_objfile
*per_objfile
)
24579 per_objfile (per_objfile
),
24581 has_loclist (false),
24582 checked_producer (false),
24583 producer_is_gxx_lt_4_6 (false),
24584 producer_is_gcc_lt_4_3 (false),
24585 producer_is_icc (false),
24586 producer_is_icc_lt_14 (false),
24587 producer_is_codewarrior (false),
24588 processing_has_namespace_info (false)
24592 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
24595 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
24596 enum language pretend_language
)
24598 struct attribute
*attr
;
24600 /* Set the language we're debugging. */
24601 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
24602 if (attr
!= nullptr)
24603 set_cu_language (attr
->constant_value (0), cu
);
24606 cu
->language
= pretend_language
;
24607 cu
->language_defn
= language_def (cu
->language
);
24610 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
24616 dwarf2_per_objfile::get_cu (dwarf2_per_cu_data
*per_cu
)
24618 auto it
= m_dwarf2_cus
.find (per_cu
);
24619 if (it
== m_dwarf2_cus
.end ())
24628 dwarf2_per_objfile::set_cu (dwarf2_per_cu_data
*per_cu
, dwarf2_cu
*cu
)
24630 gdb_assert (this->get_cu (per_cu
) == nullptr);
24632 m_dwarf2_cus
[per_cu
] = cu
;
24638 dwarf2_per_objfile::age_comp_units ()
24640 /* Start by clearing all marks. */
24641 for (auto pair
: m_dwarf2_cus
)
24642 pair
.second
->mark
= false;
24644 /* Traverse all CUs, mark them and their dependencies if used recently
24646 for (auto pair
: m_dwarf2_cus
)
24648 dwarf2_cu
*cu
= pair
.second
;
24651 if (cu
->last_used
<= dwarf_max_cache_age
)
24655 /* Delete all CUs still not marked. */
24656 for (auto it
= m_dwarf2_cus
.begin (); it
!= m_dwarf2_cus
.end ();)
24658 dwarf2_cu
*cu
= it
->second
;
24663 it
= m_dwarf2_cus
.erase (it
);
24673 dwarf2_per_objfile::remove_cu (dwarf2_per_cu_data
*per_cu
)
24675 auto it
= m_dwarf2_cus
.find (per_cu
);
24676 if (it
== m_dwarf2_cus
.end ())
24681 m_dwarf2_cus
.erase (it
);
24684 dwarf2_per_objfile::~dwarf2_per_objfile ()
24689 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
24690 We store these in a hash table separate from the DIEs, and preserve them
24691 when the DIEs are flushed out of cache.
24693 The CU "per_cu" pointer is needed because offset alone is not enough to
24694 uniquely identify the type. A file may have multiple .debug_types sections,
24695 or the type may come from a DWO file. Furthermore, while it's more logical
24696 to use per_cu->section+offset, with Fission the section with the data is in
24697 the DWO file but we don't know that section at the point we need it.
24698 We have to use something in dwarf2_per_cu_data (or the pointer to it)
24699 because we can enter the lookup routine, get_die_type_at_offset, from
24700 outside this file, and thus won't necessarily have PER_CU->cu.
24701 Fortunately, PER_CU is stable for the life of the objfile. */
24703 struct dwarf2_per_cu_offset_and_type
24705 const struct dwarf2_per_cu_data
*per_cu
;
24706 sect_offset sect_off
;
24710 /* Hash function for a dwarf2_per_cu_offset_and_type. */
24713 per_cu_offset_and_type_hash (const void *item
)
24715 const struct dwarf2_per_cu_offset_and_type
*ofs
24716 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
24718 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
24721 /* Equality function for a dwarf2_per_cu_offset_and_type. */
24724 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
24726 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
24727 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
24728 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
24729 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
24731 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
24732 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
24735 /* Set the type associated with DIE to TYPE. Save it in CU's hash
24736 table if necessary. For convenience, return TYPE.
24738 The DIEs reading must have careful ordering to:
24739 * Not cause infinite loops trying to read in DIEs as a prerequisite for
24740 reading current DIE.
24741 * Not trying to dereference contents of still incompletely read in types
24742 while reading in other DIEs.
24743 * Enable referencing still incompletely read in types just by a pointer to
24744 the type without accessing its fields.
24746 Therefore caller should follow these rules:
24747 * Try to fetch any prerequisite types we may need to build this DIE type
24748 before building the type and calling set_die_type.
24749 * After building type call set_die_type for current DIE as soon as
24750 possible before fetching more types to complete the current type.
24751 * Make the type as complete as possible before fetching more types. */
24753 static struct type
*
24754 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
24755 bool skip_data_location
)
24757 dwarf2_per_objfile
*per_objfile
= cu
->per_objfile
;
24758 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
24759 struct objfile
*objfile
= per_objfile
->objfile
;
24760 struct attribute
*attr
;
24761 struct dynamic_prop prop
;
24763 /* For Ada types, make sure that the gnat-specific data is always
24764 initialized (if not already set). There are a few types where
24765 we should not be doing so, because the type-specific area is
24766 already used to hold some other piece of info (eg: TYPE_CODE_FLT
24767 where the type-specific area is used to store the floatformat).
24768 But this is not a problem, because the gnat-specific information
24769 is actually not needed for these types. */
24770 if (need_gnat_info (cu
)
24771 && type
->code () != TYPE_CODE_FUNC
24772 && type
->code () != TYPE_CODE_FLT
24773 && type
->code () != TYPE_CODE_METHODPTR
24774 && type
->code () != TYPE_CODE_MEMBERPTR
24775 && type
->code () != TYPE_CODE_METHOD
24776 && !HAVE_GNAT_AUX_INFO (type
))
24777 INIT_GNAT_SPECIFIC (type
);
24779 /* Read DW_AT_allocated and set in type. */
24780 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
24783 struct type
*prop_type
= cu
->addr_sized_int_type (false);
24784 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24785 type
->add_dyn_prop (DYN_PROP_ALLOCATED
, prop
);
24788 /* Read DW_AT_associated and set in type. */
24789 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
24792 struct type
*prop_type
= cu
->addr_sized_int_type (false);
24793 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
24794 type
->add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
);
24797 /* Read DW_AT_data_location and set in type. */
24798 if (!skip_data_location
)
24800 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
24801 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, cu
->addr_type ()))
24802 type
->add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
);
24805 if (per_objfile
->die_type_hash
== NULL
)
24806 per_objfile
->die_type_hash
24807 = htab_up (htab_create_alloc (127,
24808 per_cu_offset_and_type_hash
,
24809 per_cu_offset_and_type_eq
,
24810 NULL
, xcalloc
, xfree
));
24812 ofs
.per_cu
= cu
->per_cu
;
24813 ofs
.sect_off
= die
->sect_off
;
24815 slot
= (struct dwarf2_per_cu_offset_and_type
**)
24816 htab_find_slot (per_objfile
->die_type_hash
.get (), &ofs
, INSERT
);
24818 complaint (_("A problem internal to GDB: DIE %s has type already set"),
24819 sect_offset_str (die
->sect_off
));
24820 *slot
= XOBNEW (&objfile
->objfile_obstack
,
24821 struct dwarf2_per_cu_offset_and_type
);
24826 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
24827 or return NULL if the die does not have a saved type. */
24829 static struct type
*
24830 get_die_type_at_offset (sect_offset sect_off
,
24831 dwarf2_per_cu_data
*per_cu
,
24832 dwarf2_per_objfile
*per_objfile
)
24834 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
24836 if (per_objfile
->die_type_hash
== NULL
)
24839 ofs
.per_cu
= per_cu
;
24840 ofs
.sect_off
= sect_off
;
24841 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
24842 htab_find (per_objfile
->die_type_hash
.get (), &ofs
));
24849 /* Look up the type for DIE in CU in die_type_hash,
24850 or return NULL if DIE does not have a saved type. */
24852 static struct type
*
24853 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
24855 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
, cu
->per_objfile
);
24858 /* Add a dependence relationship from CU to REF_PER_CU. */
24861 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
24862 struct dwarf2_per_cu_data
*ref_per_cu
)
24866 if (cu
->dependencies
== NULL
)
24868 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
24869 NULL
, &cu
->comp_unit_obstack
,
24870 hashtab_obstack_allocate
,
24871 dummy_obstack_deallocate
);
24873 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
24875 *slot
= ref_per_cu
;
24878 /* Subroutine of dwarf2_mark to pass to htab_traverse.
24879 Set the mark field in every compilation unit in the
24880 cache that we must keep because we are keeping CU.
24882 DATA is the dwarf2_per_objfile object in which to look up CUs. */
24885 dwarf2_mark_helper (void **slot
, void *data
)
24887 dwarf2_per_cu_data
*per_cu
= (dwarf2_per_cu_data
*) *slot
;
24888 dwarf2_per_objfile
*per_objfile
= (dwarf2_per_objfile
*) data
;
24889 dwarf2_cu
*cu
= per_objfile
->get_cu (per_cu
);
24891 /* cu->dependencies references may not yet have been ever read if QUIT aborts
24892 reading of the chain. As such dependencies remain valid it is not much
24893 useful to track and undo them during QUIT cleanups. */
24902 if (cu
->dependencies
!= nullptr)
24903 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, per_objfile
);
24908 /* Set the mark field in CU and in every other compilation unit in the
24909 cache that we must keep because we are keeping CU. */
24912 dwarf2_mark (struct dwarf2_cu
*cu
)
24919 if (cu
->dependencies
!= nullptr)
24920 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, cu
->per_objfile
);
24923 /* Trivial hash function for partial_die_info: the hash value of a DIE
24924 is its offset in .debug_info for this objfile. */
24927 partial_die_hash (const void *item
)
24929 const struct partial_die_info
*part_die
24930 = (const struct partial_die_info
*) item
;
24932 return to_underlying (part_die
->sect_off
);
24935 /* Trivial comparison function for partial_die_info structures: two DIEs
24936 are equal if they have the same offset. */
24939 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
24941 const struct partial_die_info
*part_die_lhs
24942 = (const struct partial_die_info
*) item_lhs
;
24943 const struct partial_die_info
*part_die_rhs
24944 = (const struct partial_die_info
*) item_rhs
;
24946 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
24949 struct cmd_list_element
*set_dwarf_cmdlist
;
24950 struct cmd_list_element
*show_dwarf_cmdlist
;
24953 show_check_physname (struct ui_file
*file
, int from_tty
,
24954 struct cmd_list_element
*c
, const char *value
)
24956 fprintf_filtered (file
,
24957 _("Whether to check \"physname\" is %s.\n"),
24961 void _initialize_dwarf2_read ();
24963 _initialize_dwarf2_read ()
24965 add_basic_prefix_cmd ("dwarf", class_maintenance
, _("\
24966 Set DWARF specific variables.\n\
24967 Configure DWARF variables such as the cache size."),
24968 &set_dwarf_cmdlist
, "maintenance set dwarf ",
24969 0/*allow-unknown*/, &maintenance_set_cmdlist
);
24971 add_show_prefix_cmd ("dwarf", class_maintenance
, _("\
24972 Show DWARF specific variables.\n\
24973 Show DWARF variables such as the cache size."),
24974 &show_dwarf_cmdlist
, "maintenance show dwarf ",
24975 0/*allow-unknown*/, &maintenance_show_cmdlist
);
24977 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
24978 &dwarf_max_cache_age
, _("\
24979 Set the upper bound on the age of cached DWARF compilation units."), _("\
24980 Show the upper bound on the age of cached DWARF compilation units."), _("\
24981 A higher limit means that cached compilation units will be stored\n\
24982 in memory longer, and more total memory will be used. Zero disables\n\
24983 caching, which can slow down startup."),
24985 show_dwarf_max_cache_age
,
24986 &set_dwarf_cmdlist
,
24987 &show_dwarf_cmdlist
);
24989 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
24990 Set debugging of the DWARF reader."), _("\
24991 Show debugging of the DWARF reader."), _("\
24992 When enabled (non-zero), debugging messages are printed during DWARF\n\
24993 reading and symtab expansion. A value of 1 (one) provides basic\n\
24994 information. A value greater than 1 provides more verbose information."),
24997 &setdebuglist
, &showdebuglist
);
24999 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
25000 Set debugging of the DWARF DIE reader."), _("\
25001 Show debugging of the DWARF DIE reader."), _("\
25002 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25003 The value is the maximum depth to print."),
25006 &setdebuglist
, &showdebuglist
);
25008 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
25009 Set debugging of the dwarf line reader."), _("\
25010 Show debugging of the dwarf line reader."), _("\
25011 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25012 A value of 1 (one) provides basic information.\n\
25013 A value greater than 1 provides more verbose information."),
25016 &setdebuglist
, &showdebuglist
);
25018 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
25019 Set cross-checking of \"physname\" code against demangler."), _("\
25020 Show cross-checking of \"physname\" code against demangler."), _("\
25021 When enabled, GDB's internal \"physname\" code is checked against\n\
25023 NULL
, show_check_physname
,
25024 &setdebuglist
, &showdebuglist
);
25026 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25027 no_class
, &use_deprecated_index_sections
, _("\
25028 Set whether to use deprecated gdb_index sections."), _("\
25029 Show whether to use deprecated gdb_index sections."), _("\
25030 When enabled, deprecated .gdb_index sections are used anyway.\n\
25031 Normally they are ignored either because of a missing feature or\n\
25032 performance issue.\n\
25033 Warning: This option must be enabled before gdb reads the file."),
25036 &setlist
, &showlist
);
25038 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25039 &dwarf2_locexpr_funcs
);
25040 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25041 &dwarf2_loclist_funcs
);
25043 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25044 &dwarf2_block_frame_base_locexpr_funcs
);
25045 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25046 &dwarf2_block_frame_base_loclist_funcs
);
25049 selftests::register_test ("dw2_expand_symtabs_matching",
25050 selftests::dw2_expand_symtabs_matching::run_test
);
25051 selftests::register_test ("dwarf2_find_containing_comp_unit",
25052 selftests::find_containing_comp_unit::run_test
);