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 "dwarf2read.h"
33 #include "dwarf-index-cache.h"
34 #include "dwarf-index-common.h"
43 #include "gdb-demangle.h"
44 #include "filenames.h" /* for DOSish file names */
47 #include "complaints.h"
48 #include "dwarf2expr.h"
49 #include "dwarf2loc.h"
50 #include "cp-support.h"
56 #include "typeprint.h"
61 #include "gdbcore.h" /* for gnutarget */
62 #include "gdb/gdb-index.h"
67 #include "namespace.h"
68 #include "gdbsupport/function-view.h"
69 #include "gdbsupport/gdb_optional.h"
70 #include "gdbsupport/underlying.h"
71 #include "gdbsupport/hash_enum.h"
72 #include "filename-seen-cache.h"
76 #include <unordered_map>
77 #include "gdbsupport/selftest.h"
78 #include "rust-lang.h"
79 #include "gdbsupport/pathstuff.h"
81 /* When == 1, print basic high level tracing messages.
82 When > 1, be more verbose.
83 This is in contrast to the low level DIE reading of dwarf_die_debug. */
84 static unsigned int dwarf_read_debug
= 0;
86 /* When non-zero, dump DIEs after they are read in. */
87 static unsigned int dwarf_die_debug
= 0;
89 /* When non-zero, dump line number entries as they are read in. */
90 static unsigned int dwarf_line_debug
= 0;
92 /* When true, cross-check physname against demangler. */
93 static bool check_physname
= false;
95 /* When true, do not reject deprecated .gdb_index sections. */
96 static bool use_deprecated_index_sections
= false;
98 static const struct objfile_key
<dwarf2_per_objfile
> dwarf2_objfile_data_key
;
100 /* The "aclass" indices for various kinds of computed DWARF symbols. */
102 static int dwarf2_locexpr_index
;
103 static int dwarf2_loclist_index
;
104 static int dwarf2_locexpr_block_index
;
105 static int dwarf2_loclist_block_index
;
107 /* An index into a (C++) symbol name component in a symbol name as
108 recorded in the mapped_index's symbol table. For each C++ symbol
109 in the symbol table, we record one entry for the start of each
110 component in the symbol in a table of name components, and then
111 sort the table, in order to be able to binary search symbol names,
112 ignoring leading namespaces, both completion and regular look up.
113 For example, for symbol "A::B::C", we'll have an entry that points
114 to "A::B::C", another that points to "B::C", and another for "C".
115 Note that function symbols in GDB index have no parameter
116 information, just the function/method names. You can convert a
117 name_component to a "const char *" using the
118 'mapped_index::symbol_name_at(offset_type)' method. */
120 struct name_component
122 /* Offset in the symbol name where the component starts. Stored as
123 a (32-bit) offset instead of a pointer to save memory and improve
124 locality on 64-bit architectures. */
125 offset_type name_offset
;
127 /* The symbol's index in the symbol and constant pool tables of a
132 /* Base class containing bits shared by both .gdb_index and
133 .debug_name indexes. */
135 struct mapped_index_base
137 mapped_index_base () = default;
138 DISABLE_COPY_AND_ASSIGN (mapped_index_base
);
140 /* The name_component table (a sorted vector). See name_component's
141 description above. */
142 std::vector
<name_component
> name_components
;
144 /* How NAME_COMPONENTS is sorted. */
145 enum case_sensitivity name_components_casing
;
147 /* Return the number of names in the symbol table. */
148 virtual size_t symbol_name_count () const = 0;
150 /* Get the name of the symbol at IDX in the symbol table. */
151 virtual const char *symbol_name_at (offset_type idx
) const = 0;
153 /* Return whether the name at IDX in the symbol table should be
155 virtual bool symbol_name_slot_invalid (offset_type idx
) const
160 /* Build the symbol name component sorted vector, if we haven't
162 void build_name_components ();
164 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
165 possible matches for LN_NO_PARAMS in the name component
167 std::pair
<std::vector
<name_component
>::const_iterator
,
168 std::vector
<name_component
>::const_iterator
>
169 find_name_components_bounds (const lookup_name_info
&ln_no_params
,
170 enum language lang
) const;
172 /* Prevent deleting/destroying via a base class pointer. */
174 ~mapped_index_base() = default;
177 /* A description of the mapped index. The file format is described in
178 a comment by the code that writes the index. */
179 struct mapped_index final
: public mapped_index_base
181 /* A slot/bucket in the symbol table hash. */
182 struct symbol_table_slot
184 const offset_type name
;
185 const offset_type vec
;
188 /* Index data format version. */
191 /* The address table data. */
192 gdb::array_view
<const gdb_byte
> address_table
;
194 /* The symbol table, implemented as a hash table. */
195 gdb::array_view
<symbol_table_slot
> symbol_table
;
197 /* A pointer to the constant pool. */
198 const char *constant_pool
= nullptr;
200 bool symbol_name_slot_invalid (offset_type idx
) const override
202 const auto &bucket
= this->symbol_table
[idx
];
203 return bucket
.name
== 0 && bucket
.vec
== 0;
206 /* Convenience method to get at the name of the symbol at IDX in the
208 const char *symbol_name_at (offset_type idx
) const override
209 { return this->constant_pool
+ MAYBE_SWAP (this->symbol_table
[idx
].name
); }
211 size_t symbol_name_count () const override
212 { return this->symbol_table
.size (); }
215 /* A description of the mapped .debug_names.
216 Uninitialized map has CU_COUNT 0. */
217 struct mapped_debug_names final
: public mapped_index_base
219 mapped_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile_
)
220 : dwarf2_per_objfile (dwarf2_per_objfile_
)
223 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
224 bfd_endian dwarf5_byte_order
;
225 bool dwarf5_is_dwarf64
;
226 bool augmentation_is_gdb
;
228 uint32_t cu_count
= 0;
229 uint32_t tu_count
, bucket_count
, name_count
;
230 const gdb_byte
*cu_table_reordered
, *tu_table_reordered
;
231 const uint32_t *bucket_table_reordered
, *hash_table_reordered
;
232 const gdb_byte
*name_table_string_offs_reordered
;
233 const gdb_byte
*name_table_entry_offs_reordered
;
234 const gdb_byte
*entry_pool
;
241 /* Attribute name DW_IDX_*. */
244 /* Attribute form DW_FORM_*. */
247 /* Value if FORM is DW_FORM_implicit_const. */
248 LONGEST implicit_const
;
250 std::vector
<attr
> attr_vec
;
253 std::unordered_map
<ULONGEST
, index_val
> abbrev_map
;
255 const char *namei_to_name (uint32_t namei
) const;
257 /* Implementation of the mapped_index_base virtual interface, for
258 the name_components cache. */
260 const char *symbol_name_at (offset_type idx
) const override
261 { return namei_to_name (idx
); }
263 size_t symbol_name_count () const override
264 { return this->name_count
; }
267 /* See dwarf2read.h. */
270 get_dwarf2_per_objfile (struct objfile
*objfile
)
272 return dwarf2_objfile_data_key
.get (objfile
);
275 /* Default names of the debugging sections. */
277 /* Note that if the debugging section has been compressed, it might
278 have a name like .zdebug_info. */
280 static const struct dwarf2_debug_sections dwarf2_elf_names
=
282 { ".debug_info", ".zdebug_info" },
283 { ".debug_abbrev", ".zdebug_abbrev" },
284 { ".debug_line", ".zdebug_line" },
285 { ".debug_loc", ".zdebug_loc" },
286 { ".debug_loclists", ".zdebug_loclists" },
287 { ".debug_macinfo", ".zdebug_macinfo" },
288 { ".debug_macro", ".zdebug_macro" },
289 { ".debug_str", ".zdebug_str" },
290 { ".debug_line_str", ".zdebug_line_str" },
291 { ".debug_ranges", ".zdebug_ranges" },
292 { ".debug_rnglists", ".zdebug_rnglists" },
293 { ".debug_types", ".zdebug_types" },
294 { ".debug_addr", ".zdebug_addr" },
295 { ".debug_frame", ".zdebug_frame" },
296 { ".eh_frame", NULL
},
297 { ".gdb_index", ".zgdb_index" },
298 { ".debug_names", ".zdebug_names" },
299 { ".debug_aranges", ".zdebug_aranges" },
303 /* List of DWO/DWP sections. */
305 static const struct dwop_section_names
307 struct dwarf2_section_names abbrev_dwo
;
308 struct dwarf2_section_names info_dwo
;
309 struct dwarf2_section_names line_dwo
;
310 struct dwarf2_section_names loc_dwo
;
311 struct dwarf2_section_names loclists_dwo
;
312 struct dwarf2_section_names macinfo_dwo
;
313 struct dwarf2_section_names macro_dwo
;
314 struct dwarf2_section_names str_dwo
;
315 struct dwarf2_section_names str_offsets_dwo
;
316 struct dwarf2_section_names types_dwo
;
317 struct dwarf2_section_names cu_index
;
318 struct dwarf2_section_names tu_index
;
322 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
323 { ".debug_info.dwo", ".zdebug_info.dwo" },
324 { ".debug_line.dwo", ".zdebug_line.dwo" },
325 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
326 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
327 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
328 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
329 { ".debug_str.dwo", ".zdebug_str.dwo" },
330 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
331 { ".debug_types.dwo", ".zdebug_types.dwo" },
332 { ".debug_cu_index", ".zdebug_cu_index" },
333 { ".debug_tu_index", ".zdebug_tu_index" },
336 /* local data types */
338 /* The data in a compilation unit header, after target2host
339 translation, looks like this. */
340 struct comp_unit_head
344 unsigned char addr_size
;
345 unsigned char signed_addr_p
;
346 sect_offset abbrev_sect_off
;
348 /* Size of file offsets; either 4 or 8. */
349 unsigned int offset_size
;
351 /* Size of the length field; either 4 or 12. */
352 unsigned int initial_length_size
;
354 enum dwarf_unit_type unit_type
;
356 /* Offset to the first byte of this compilation unit header in the
357 .debug_info section, for resolving relative reference dies. */
358 sect_offset sect_off
;
360 /* Offset to first die in this cu from the start of the cu.
361 This will be the first byte following the compilation unit header. */
362 cu_offset first_die_cu_offset
;
365 /* 64-bit signature of this unit. For type units, it denotes the signature of
366 the type (DW_UT_type in DWARF 4, additionally DW_UT_split_type in DWARF 5).
367 Also used in DWARF 5, to denote the dwo id when the unit type is
368 DW_UT_skeleton or DW_UT_split_compile. */
371 /* For types, offset in the type's DIE of the type defined by this TU. */
372 cu_offset type_cu_offset_in_tu
;
375 /* Type used for delaying computation of method physnames.
376 See comments for compute_delayed_physnames. */
377 struct delayed_method_info
379 /* The type to which the method is attached, i.e., its parent class. */
382 /* The index of the method in the type's function fieldlists. */
385 /* The index of the method in the fieldlist. */
388 /* The name of the DIE. */
391 /* The DIE associated with this method. */
392 struct die_info
*die
;
395 /* Internal state when decoding a particular compilation unit. */
398 explicit dwarf2_cu (struct dwarf2_per_cu_data
*per_cu
);
401 DISABLE_COPY_AND_ASSIGN (dwarf2_cu
);
403 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
404 Create the set of symtabs used by this TU, or if this TU is sharing
405 symtabs with another TU and the symtabs have already been created
406 then restore those symtabs in the line header.
407 We don't need the pc/line-number mapping for type units. */
408 void setup_type_unit_groups (struct die_info
*die
);
410 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
411 buildsym_compunit constructor. */
412 struct compunit_symtab
*start_symtab (const char *name
,
413 const char *comp_dir
,
416 /* Reset the builder. */
417 void reset_builder () { m_builder
.reset (); }
419 /* The header of the compilation unit. */
420 struct comp_unit_head header
{};
422 /* Base address of this compilation unit. */
423 CORE_ADDR base_address
= 0;
425 /* Non-zero if base_address has been set. */
428 /* The language we are debugging. */
429 enum language language
= language_unknown
;
430 const struct language_defn
*language_defn
= nullptr;
432 const char *producer
= nullptr;
435 /* The symtab builder for this CU. This is only non-NULL when full
436 symbols are being read. */
437 std::unique_ptr
<buildsym_compunit
> m_builder
;
440 /* The generic symbol table building routines have separate lists for
441 file scope symbols and all all other scopes (local scopes). So
442 we need to select the right one to pass to add_symbol_to_list().
443 We do it by keeping a pointer to the correct list in list_in_scope.
445 FIXME: The original dwarf code just treated the file scope as the
446 first local scope, and all other local scopes as nested local
447 scopes, and worked fine. Check to see if we really need to
448 distinguish these in buildsym.c. */
449 struct pending
**list_in_scope
= nullptr;
451 /* Hash table holding all the loaded partial DIEs
452 with partial_die->offset.SECT_OFF as hash. */
453 htab_t partial_dies
= nullptr;
455 /* Storage for things with the same lifetime as this read-in compilation
456 unit, including partial DIEs. */
457 auto_obstack comp_unit_obstack
;
459 /* When multiple dwarf2_cu structures are living in memory, this field
460 chains them all together, so that they can be released efficiently.
461 We will probably also want a generation counter so that most-recently-used
462 compilation units are cached... */
463 struct dwarf2_per_cu_data
*read_in_chain
= nullptr;
465 /* Backlink to our per_cu entry. */
466 struct dwarf2_per_cu_data
*per_cu
;
468 /* How many compilation units ago was this CU last referenced? */
471 /* A hash table of DIE cu_offset for following references with
472 die_info->offset.sect_off as hash. */
473 htab_t die_hash
= nullptr;
475 /* Full DIEs if read in. */
476 struct die_info
*dies
= nullptr;
478 /* A set of pointers to dwarf2_per_cu_data objects for compilation
479 units referenced by this one. Only set during full symbol processing;
480 partial symbol tables do not have dependencies. */
481 htab_t dependencies
= nullptr;
483 /* Header data from the line table, during full symbol processing. */
484 struct line_header
*line_header
= nullptr;
485 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
486 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
487 this is the DW_TAG_compile_unit die for this CU. We'll hold on
488 to the line header as long as this DIE is being processed. See
489 process_die_scope. */
490 die_info
*line_header_die_owner
= nullptr;
492 /* A list of methods which need to have physnames computed
493 after all type information has been read. */
494 std::vector
<delayed_method_info
> method_list
;
496 /* To be copied to symtab->call_site_htab. */
497 htab_t call_site_htab
= nullptr;
499 /* Non-NULL if this CU came from a DWO file.
500 There is an invariant here that is important to remember:
501 Except for attributes copied from the top level DIE in the "main"
502 (or "stub") file in preparation for reading the DWO file
503 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
504 Either there isn't a DWO file (in which case this is NULL and the point
505 is moot), or there is and either we're not going to read it (in which
506 case this is NULL) or there is and we are reading it (in which case this
508 struct dwo_unit
*dwo_unit
= nullptr;
510 /* The DW_AT_addr_base attribute if present, zero otherwise
511 (zero is a valid value though).
512 Note this value comes from the Fission stub CU/TU's DIE. */
513 ULONGEST addr_base
= 0;
515 /* The DW_AT_ranges_base attribute if present, zero otherwise
516 (zero is a valid value though).
517 Note this value comes from the Fission stub CU/TU's DIE.
518 Also note that the value is zero in the non-DWO case so this value can
519 be used without needing to know whether DWO files are in use or not.
520 N.B. This does not apply to DW_AT_ranges appearing in
521 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
522 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
523 DW_AT_ranges_base *would* have to be applied, and we'd have to care
524 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
525 ULONGEST ranges_base
= 0;
527 /* When reading debug info generated by older versions of rustc, we
528 have to rewrite some union types to be struct types with a
529 variant part. This rewriting must be done after the CU is fully
530 read in, because otherwise at the point of rewriting some struct
531 type might not have been fully processed. So, we keep a list of
532 all such types here and process them after expansion. */
533 std::vector
<struct type
*> rust_unions
;
535 /* Mark used when releasing cached dies. */
538 /* This CU references .debug_loc. See the symtab->locations_valid field.
539 This test is imperfect as there may exist optimized debug code not using
540 any location list and still facing inlining issues if handled as
541 unoptimized code. For a future better test see GCC PR other/32998. */
542 bool has_loclist
: 1;
544 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is true
545 if all the producer_is_* fields are valid. This information is cached
546 because profiling CU expansion showed excessive time spent in
547 producer_is_gxx_lt_4_6. */
548 bool checked_producer
: 1;
549 bool producer_is_gxx_lt_4_6
: 1;
550 bool producer_is_gcc_lt_4_3
: 1;
551 bool producer_is_icc
: 1;
552 bool producer_is_icc_lt_14
: 1;
553 bool producer_is_codewarrior
: 1;
555 /* When true, the file that we're processing is known to have
556 debugging info for C++ namespaces. GCC 3.3.x did not produce
557 this information, but later versions do. */
559 bool processing_has_namespace_info
: 1;
561 struct partial_die_info
*find_partial_die (sect_offset sect_off
);
563 /* If this CU was inherited by another CU (via specification,
564 abstract_origin, etc), this is the ancestor CU. */
567 /* Get the buildsym_compunit for this CU. */
568 buildsym_compunit
*get_builder ()
570 /* If this CU has a builder associated with it, use that. */
571 if (m_builder
!= nullptr)
572 return m_builder
.get ();
574 /* Otherwise, search ancestors for a valid builder. */
575 if (ancestor
!= nullptr)
576 return ancestor
->get_builder ();
582 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
583 This includes type_unit_group and quick_file_names. */
585 struct stmt_list_hash
587 /* The DWO unit this table is from or NULL if there is none. */
588 struct dwo_unit
*dwo_unit
;
590 /* Offset in .debug_line or .debug_line.dwo. */
591 sect_offset line_sect_off
;
594 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
595 an object of this type. */
597 struct type_unit_group
599 /* dwarf2read.c's main "handle" on a TU symtab.
600 To simplify things we create an artificial CU that "includes" all the
601 type units using this stmt_list so that the rest of the code still has
602 a "per_cu" handle on the symtab.
603 This PER_CU is recognized by having no section. */
604 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
605 struct dwarf2_per_cu_data per_cu
;
607 /* The TUs that share this DW_AT_stmt_list entry.
608 This is added to while parsing type units to build partial symtabs,
609 and is deleted afterwards and not used again. */
610 std::vector
<signatured_type
*> *tus
;
612 /* The compunit symtab.
613 Type units in a group needn't all be defined in the same source file,
614 so we create an essentially anonymous symtab as the compunit symtab. */
615 struct compunit_symtab
*compunit_symtab
;
617 /* The data used to construct the hash key. */
618 struct stmt_list_hash hash
;
620 /* The number of symtabs from the line header.
621 The value here must match line_header.num_file_names. */
622 unsigned int num_symtabs
;
624 /* The symbol tables for this TU (obtained from the files listed in
626 WARNING: The order of entries here must match the order of entries
627 in the line header. After the first TU using this type_unit_group, the
628 line header for the subsequent TUs is recreated from this. This is done
629 because we need to use the same symtabs for each TU using the same
630 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
631 there's no guarantee the line header doesn't have duplicate entries. */
632 struct symtab
**symtabs
;
635 /* These sections are what may appear in a (real or virtual) DWO file. */
639 struct dwarf2_section_info abbrev
;
640 struct dwarf2_section_info line
;
641 struct dwarf2_section_info loc
;
642 struct dwarf2_section_info loclists
;
643 struct dwarf2_section_info macinfo
;
644 struct dwarf2_section_info macro
;
645 struct dwarf2_section_info str
;
646 struct dwarf2_section_info str_offsets
;
647 /* In the case of a virtual DWO file, these two are unused. */
648 struct dwarf2_section_info info
;
649 std::vector
<dwarf2_section_info
> types
;
652 /* CUs/TUs in DWP/DWO files. */
656 /* Backlink to the containing struct dwo_file. */
657 struct dwo_file
*dwo_file
;
659 /* The "id" that distinguishes this CU/TU.
660 .debug_info calls this "dwo_id", .debug_types calls this "signature".
661 Since signatures came first, we stick with it for consistency. */
664 /* The section this CU/TU lives in, in the DWO file. */
665 struct dwarf2_section_info
*section
;
667 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
668 sect_offset sect_off
;
671 /* For types, offset in the type's DIE of the type defined by this TU. */
672 cu_offset type_offset_in_tu
;
675 /* include/dwarf2.h defines the DWP section codes.
676 It defines a max value but it doesn't define a min value, which we
677 use for error checking, so provide one. */
679 enum dwp_v2_section_ids
684 /* Data for one DWO file.
686 This includes virtual DWO files (a virtual DWO file is a DWO file as it
687 appears in a DWP file). DWP files don't really have DWO files per se -
688 comdat folding of types "loses" the DWO file they came from, and from
689 a high level view DWP files appear to contain a mass of random types.
690 However, to maintain consistency with the non-DWP case we pretend DWP
691 files contain virtual DWO files, and we assign each TU with one virtual
692 DWO file (generally based on the line and abbrev section offsets -
693 a heuristic that seems to work in practice). */
697 dwo_file () = default;
698 DISABLE_COPY_AND_ASSIGN (dwo_file
);
700 /* The DW_AT_GNU_dwo_name attribute.
701 For virtual DWO files the name is constructed from the section offsets
702 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
703 from related CU+TUs. */
704 const char *dwo_name
= nullptr;
706 /* The DW_AT_comp_dir attribute. */
707 const char *comp_dir
= nullptr;
709 /* The bfd, when the file is open. Otherwise this is NULL.
710 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
711 gdb_bfd_ref_ptr dbfd
;
713 /* The sections that make up this DWO file.
714 Remember that for virtual DWO files in DWP V2, these are virtual
715 sections (for lack of a better name). */
716 struct dwo_sections sections
{};
718 /* The CUs in the file.
719 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
720 an extension to handle LLVM's Link Time Optimization output (where
721 multiple source files may be compiled into a single object/dwo pair). */
724 /* Table of TUs in the file.
725 Each element is a struct dwo_unit. */
729 /* These sections are what may appear in a DWP file. */
733 /* These are used by both DWP version 1 and 2. */
734 struct dwarf2_section_info str
;
735 struct dwarf2_section_info cu_index
;
736 struct dwarf2_section_info tu_index
;
738 /* These are only used by DWP version 2 files.
739 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
740 sections are referenced by section number, and are not recorded here.
741 In DWP version 2 there is at most one copy of all these sections, each
742 section being (effectively) comprised of the concatenation of all of the
743 individual sections that exist in the version 1 format.
744 To keep the code simple we treat each of these concatenated pieces as a
745 section itself (a virtual section?). */
746 struct dwarf2_section_info abbrev
;
747 struct dwarf2_section_info info
;
748 struct dwarf2_section_info line
;
749 struct dwarf2_section_info loc
;
750 struct dwarf2_section_info macinfo
;
751 struct dwarf2_section_info macro
;
752 struct dwarf2_section_info str_offsets
;
753 struct dwarf2_section_info types
;
756 /* These sections are what may appear in a virtual DWO file in DWP version 1.
757 A virtual DWO file is a DWO file as it appears in a DWP file. */
759 struct virtual_v1_dwo_sections
761 struct dwarf2_section_info abbrev
;
762 struct dwarf2_section_info line
;
763 struct dwarf2_section_info loc
;
764 struct dwarf2_section_info macinfo
;
765 struct dwarf2_section_info macro
;
766 struct dwarf2_section_info str_offsets
;
767 /* Each DWP hash table entry records one CU or one TU.
768 That is recorded here, and copied to dwo_unit.section. */
769 struct dwarf2_section_info info_or_types
;
772 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
773 In version 2, the sections of the DWO files are concatenated together
774 and stored in one section of that name. Thus each ELF section contains
775 several "virtual" sections. */
777 struct virtual_v2_dwo_sections
779 bfd_size_type abbrev_offset
;
780 bfd_size_type abbrev_size
;
782 bfd_size_type line_offset
;
783 bfd_size_type line_size
;
785 bfd_size_type loc_offset
;
786 bfd_size_type loc_size
;
788 bfd_size_type macinfo_offset
;
789 bfd_size_type macinfo_size
;
791 bfd_size_type macro_offset
;
792 bfd_size_type macro_size
;
794 bfd_size_type str_offsets_offset
;
795 bfd_size_type str_offsets_size
;
797 /* Each DWP hash table entry records one CU or one TU.
798 That is recorded here, and copied to dwo_unit.section. */
799 bfd_size_type info_or_types_offset
;
800 bfd_size_type info_or_types_size
;
803 /* Contents of DWP hash tables. */
805 struct dwp_hash_table
807 uint32_t version
, nr_columns
;
808 uint32_t nr_units
, nr_slots
;
809 const gdb_byte
*hash_table
, *unit_table
;
814 const gdb_byte
*indices
;
818 /* This is indexed by column number and gives the id of the section
820 #define MAX_NR_V2_DWO_SECTIONS \
821 (1 /* .debug_info or .debug_types */ \
822 + 1 /* .debug_abbrev */ \
823 + 1 /* .debug_line */ \
824 + 1 /* .debug_loc */ \
825 + 1 /* .debug_str_offsets */ \
826 + 1 /* .debug_macro or .debug_macinfo */)
827 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
828 const gdb_byte
*offsets
;
829 const gdb_byte
*sizes
;
834 /* Data for one DWP file. */
838 dwp_file (const char *name_
, gdb_bfd_ref_ptr
&&abfd
)
840 dbfd (std::move (abfd
))
844 /* Name of the file. */
847 /* File format version. */
851 gdb_bfd_ref_ptr dbfd
;
853 /* Section info for this file. */
854 struct dwp_sections sections
{};
856 /* Table of CUs in the file. */
857 const struct dwp_hash_table
*cus
= nullptr;
859 /* Table of TUs in the file. */
860 const struct dwp_hash_table
*tus
= nullptr;
862 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
863 htab_t loaded_cus
{};
864 htab_t loaded_tus
{};
866 /* Table to map ELF section numbers to their sections.
867 This is only needed for the DWP V1 file format. */
868 unsigned int num_sections
= 0;
869 asection
**elf_sections
= nullptr;
872 /* Struct used to pass misc. parameters to read_die_and_children, et
873 al. which are used for both .debug_info and .debug_types dies.
874 All parameters here are unchanging for the life of the call. This
875 struct exists to abstract away the constant parameters of die reading. */
877 struct die_reader_specs
879 /* The bfd of die_section. */
882 /* The CU of the DIE we are parsing. */
883 struct dwarf2_cu
*cu
;
885 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
886 struct dwo_file
*dwo_file
;
888 /* The section the die comes from.
889 This is either .debug_info or .debug_types, or the .dwo variants. */
890 struct dwarf2_section_info
*die_section
;
892 /* die_section->buffer. */
893 const gdb_byte
*buffer
;
895 /* The end of the buffer. */
896 const gdb_byte
*buffer_end
;
898 /* The value of the DW_AT_comp_dir attribute. */
899 const char *comp_dir
;
901 /* The abbreviation table to use when reading the DIEs. */
902 struct abbrev_table
*abbrev_table
;
905 /* Type of function passed to init_cutu_and_read_dies, et.al. */
906 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
907 const gdb_byte
*info_ptr
,
908 struct die_info
*comp_unit_die
,
912 /* dir_index is 1-based in DWARF 4 and before, and is 0-based in DWARF 5 and
914 typedef int dir_index
;
916 /* file_name_index is 1-based in DWARF 4 and before, and is 0-based in DWARF 5
918 typedef int file_name_index
;
922 file_entry () = default;
924 file_entry (const char *name_
, dir_index d_index_
,
925 unsigned int mod_time_
, unsigned int length_
)
928 mod_time (mod_time_
),
932 /* Return the include directory at D_INDEX stored in LH. Returns
933 NULL if D_INDEX is out of bounds. */
934 const char *include_dir (const line_header
*lh
) const;
936 /* The file name. Note this is an observing pointer. The memory is
937 owned by debug_line_buffer. */
940 /* The directory index (1-based). */
941 dir_index d_index
{};
943 unsigned int mod_time
{};
945 unsigned int length
{};
947 /* True if referenced by the Line Number Program. */
950 /* The associated symbol table, if any. */
951 struct symtab
*symtab
{};
954 /* The line number information for a compilation unit (found in the
955 .debug_line section) begins with a "statement program header",
956 which contains the following information. */
963 /* Add an entry to the include directory table. */
964 void add_include_dir (const char *include_dir
);
966 /* Add an entry to the file name table. */
967 void add_file_name (const char *name
, dir_index d_index
,
968 unsigned int mod_time
, unsigned int length
);
970 /* Return the include dir at INDEX (0-based in DWARF 5 and 1-based before).
971 Returns NULL if INDEX is out of bounds. */
972 const char *include_dir_at (dir_index index
) const
978 vec_index
= index
- 1;
979 if (vec_index
< 0 || vec_index
>= m_include_dirs
.size ())
981 return m_include_dirs
[vec_index
];
984 bool is_valid_file_index (int file_index
)
987 return 0 <= file_index
&& file_index
< file_names_size ();
988 return 1 <= file_index
&& file_index
<= file_names_size ();
991 /* Return the file name at INDEX (0-based in DWARF 5 and 1-based before).
992 Returns NULL if INDEX is out of bounds. */
993 file_entry
*file_name_at (file_name_index index
)
999 vec_index
= index
- 1;
1000 if (vec_index
< 0 || vec_index
>= m_file_names
.size ())
1002 return &m_file_names
[vec_index
];
1005 /* The indexes are 0-based in DWARF 5 and 1-based in DWARF 4. Therefore,
1006 this method should only be used to iterate through all file entries in an
1007 index-agnostic manner. */
1008 std::vector
<file_entry
> &file_names ()
1009 { return m_file_names
; }
1011 /* Offset of line number information in .debug_line section. */
1012 sect_offset sect_off
{};
1014 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1015 unsigned offset_in_dwz
: 1; /* Can't initialize bitfields in-class. */
1017 unsigned int total_length
{};
1018 unsigned short version
{};
1019 unsigned int header_length
{};
1020 unsigned char minimum_instruction_length
{};
1021 unsigned char maximum_ops_per_instruction
{};
1022 unsigned char default_is_stmt
{};
1024 unsigned char line_range
{};
1025 unsigned char opcode_base
{};
1027 /* standard_opcode_lengths[i] is the number of operands for the
1028 standard opcode whose value is i. This means that
1029 standard_opcode_lengths[0] is unused, and the last meaningful
1030 element is standard_opcode_lengths[opcode_base - 1]. */
1031 std::unique_ptr
<unsigned char[]> standard_opcode_lengths
;
1033 int file_names_size ()
1034 { return m_file_names
.size(); }
1036 /* The start and end of the statement program following this
1037 header. These point into dwarf2_per_objfile->line_buffer. */
1038 const gdb_byte
*statement_program_start
{}, *statement_program_end
{};
1041 /* The include_directories table. Note these are observing
1042 pointers. The memory is owned by debug_line_buffer. */
1043 std::vector
<const char *> m_include_dirs
;
1045 /* The file_names table. This is private because the meaning of indexes
1046 differs among DWARF versions (The first valid index is 1 in DWARF 4 and
1047 before, and is 0 in DWARF 5 and later). So the client should use
1048 file_name_at method for access. */
1049 std::vector
<file_entry
> m_file_names
;
1052 typedef std::unique_ptr
<line_header
> line_header_up
;
1055 file_entry::include_dir (const line_header
*lh
) const
1057 return lh
->include_dir_at (d_index
);
1060 /* When we construct a partial symbol table entry we only
1061 need this much information. */
1062 struct partial_die_info
: public allocate_on_obstack
1064 partial_die_info (sect_offset sect_off
, struct abbrev_info
*abbrev
);
1066 /* Disable assign but still keep copy ctor, which is needed
1067 load_partial_dies. */
1068 partial_die_info
& operator=(const partial_die_info
& rhs
) = delete;
1070 /* Adjust the partial die before generating a symbol for it. This
1071 function may set the is_external flag or change the DIE's
1073 void fixup (struct dwarf2_cu
*cu
);
1075 /* Read a minimal amount of information into the minimal die
1077 const gdb_byte
*read (const struct die_reader_specs
*reader
,
1078 const struct abbrev_info
&abbrev
,
1079 const gdb_byte
*info_ptr
);
1081 /* Offset of this DIE. */
1082 const sect_offset sect_off
;
1084 /* DWARF-2 tag for this DIE. */
1085 const ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1087 /* Assorted flags describing the data found in this DIE. */
1088 const unsigned int has_children
: 1;
1090 unsigned int is_external
: 1;
1091 unsigned int is_declaration
: 1;
1092 unsigned int has_type
: 1;
1093 unsigned int has_specification
: 1;
1094 unsigned int has_pc_info
: 1;
1095 unsigned int may_be_inlined
: 1;
1097 /* This DIE has been marked DW_AT_main_subprogram. */
1098 unsigned int main_subprogram
: 1;
1100 /* Flag set if the SCOPE field of this structure has been
1102 unsigned int scope_set
: 1;
1104 /* Flag set if the DIE has a byte_size attribute. */
1105 unsigned int has_byte_size
: 1;
1107 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1108 unsigned int has_const_value
: 1;
1110 /* Flag set if any of the DIE's children are template arguments. */
1111 unsigned int has_template_arguments
: 1;
1113 /* Flag set if fixup has been called on this die. */
1114 unsigned int fixup_called
: 1;
1116 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1117 unsigned int is_dwz
: 1;
1119 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1120 unsigned int spec_is_dwz
: 1;
1122 /* The name of this DIE. Normally the value of DW_AT_name, but
1123 sometimes a default name for unnamed DIEs. */
1124 const char *name
= nullptr;
1126 /* The linkage name, if present. */
1127 const char *linkage_name
= nullptr;
1129 /* The scope to prepend to our children. This is generally
1130 allocated on the comp_unit_obstack, so will disappear
1131 when this compilation unit leaves the cache. */
1132 const char *scope
= nullptr;
1134 /* Some data associated with the partial DIE. The tag determines
1135 which field is live. */
1138 /* The location description associated with this DIE, if any. */
1139 struct dwarf_block
*locdesc
;
1140 /* The offset of an import, for DW_TAG_imported_unit. */
1141 sect_offset sect_off
;
1144 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1145 CORE_ADDR lowpc
= 0;
1146 CORE_ADDR highpc
= 0;
1148 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1149 DW_AT_sibling, if any. */
1150 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1151 could return DW_AT_sibling values to its caller load_partial_dies. */
1152 const gdb_byte
*sibling
= nullptr;
1154 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1155 DW_AT_specification (or DW_AT_abstract_origin or
1156 DW_AT_extension). */
1157 sect_offset spec_offset
{};
1159 /* Pointers to this DIE's parent, first child, and next sibling,
1161 struct partial_die_info
*die_parent
= nullptr;
1162 struct partial_die_info
*die_child
= nullptr;
1163 struct partial_die_info
*die_sibling
= nullptr;
1165 friend struct partial_die_info
*
1166 dwarf2_cu::find_partial_die (sect_offset sect_off
);
1169 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1170 partial_die_info (sect_offset sect_off
)
1171 : partial_die_info (sect_off
, DW_TAG_padding
, 0)
1175 partial_die_info (sect_offset sect_off_
, enum dwarf_tag tag_
,
1177 : sect_off (sect_off_
), tag (tag_
), has_children (has_children_
)
1182 has_specification
= 0;
1185 main_subprogram
= 0;
1188 has_const_value
= 0;
1189 has_template_arguments
= 0;
1196 /* This data structure holds the information of an abbrev. */
1199 unsigned int number
; /* number identifying abbrev */
1200 enum dwarf_tag tag
; /* dwarf tag */
1201 unsigned short has_children
; /* boolean */
1202 unsigned short num_attrs
; /* number of attributes */
1203 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1204 struct abbrev_info
*next
; /* next in chain */
1209 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1210 ENUM_BITFIELD(dwarf_form
) form
: 16;
1212 /* It is valid only if FORM is DW_FORM_implicit_const. */
1213 LONGEST implicit_const
;
1216 /* Size of abbrev_table.abbrev_hash_table. */
1217 #define ABBREV_HASH_SIZE 121
1219 /* Top level data structure to contain an abbreviation table. */
1223 explicit abbrev_table (sect_offset off
)
1227 XOBNEWVEC (&abbrev_obstack
, struct abbrev_info
*, ABBREV_HASH_SIZE
);
1228 memset (m_abbrevs
, 0, ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
1231 DISABLE_COPY_AND_ASSIGN (abbrev_table
);
1233 /* Allocate space for a struct abbrev_info object in
1235 struct abbrev_info
*alloc_abbrev ();
1237 /* Add an abbreviation to the table. */
1238 void add_abbrev (unsigned int abbrev_number
, struct abbrev_info
*abbrev
);
1240 /* Look up an abbrev in the table.
1241 Returns NULL if the abbrev is not found. */
1243 struct abbrev_info
*lookup_abbrev (unsigned int abbrev_number
);
1246 /* Where the abbrev table came from.
1247 This is used as a sanity check when the table is used. */
1248 const sect_offset sect_off
;
1250 /* Storage for the abbrev table. */
1251 auto_obstack abbrev_obstack
;
1255 /* Hash table of abbrevs.
1256 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1257 It could be statically allocated, but the previous code didn't so we
1259 struct abbrev_info
**m_abbrevs
;
1262 typedef std::unique_ptr
<struct abbrev_table
> abbrev_table_up
;
1264 /* Attributes have a name and a value. */
1267 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1268 ENUM_BITFIELD(dwarf_form
) form
: 15;
1270 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1271 field should be in u.str (existing only for DW_STRING) but it is kept
1272 here for better struct attribute alignment. */
1273 unsigned int string_is_canonical
: 1;
1278 struct dwarf_block
*blk
;
1287 /* This data structure holds a complete die structure. */
1290 /* DWARF-2 tag for this DIE. */
1291 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1293 /* Number of attributes */
1294 unsigned char num_attrs
;
1296 /* True if we're presently building the full type name for the
1297 type derived from this DIE. */
1298 unsigned char building_fullname
: 1;
1300 /* True if this die is in process. PR 16581. */
1301 unsigned char in_process
: 1;
1304 unsigned int abbrev
;
1306 /* Offset in .debug_info or .debug_types section. */
1307 sect_offset sect_off
;
1309 /* The dies in a compilation unit form an n-ary tree. PARENT
1310 points to this die's parent; CHILD points to the first child of
1311 this node; and all the children of a given node are chained
1312 together via their SIBLING fields. */
1313 struct die_info
*child
; /* Its first child, if any. */
1314 struct die_info
*sibling
; /* Its next sibling, if any. */
1315 struct die_info
*parent
; /* Its parent, if any. */
1317 /* An array of attributes, with NUM_ATTRS elements. There may be
1318 zero, but it's not common and zero-sized arrays are not
1319 sufficiently portable C. */
1320 struct attribute attrs
[1];
1323 /* Get at parts of an attribute structure. */
1325 #define DW_STRING(attr) ((attr)->u.str)
1326 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1327 #define DW_UNSND(attr) ((attr)->u.unsnd)
1328 #define DW_BLOCK(attr) ((attr)->u.blk)
1329 #define DW_SND(attr) ((attr)->u.snd)
1330 #define DW_ADDR(attr) ((attr)->u.addr)
1331 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1333 /* Blocks are a bunch of untyped bytes. */
1338 /* Valid only if SIZE is not zero. */
1339 const gdb_byte
*data
;
1342 #ifndef ATTR_ALLOC_CHUNK
1343 #define ATTR_ALLOC_CHUNK 4
1346 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1347 but this would require a corresponding change in unpack_field_as_long
1349 static int bits_per_byte
= 8;
1351 /* When reading a variant or variant part, we track a bit more
1352 information about the field, and store it in an object of this
1355 struct variant_field
1357 /* If we see a DW_TAG_variant, then this will be the discriminant
1359 ULONGEST discriminant_value
;
1360 /* If we see a DW_TAG_variant, then this will be set if this is the
1362 bool default_branch
;
1363 /* While reading a DW_TAG_variant_part, this will be set if this
1364 field is the discriminant. */
1365 bool is_discriminant
;
1370 int accessibility
= 0;
1372 /* Extra information to describe a variant or variant part. */
1373 struct variant_field variant
{};
1374 struct field field
{};
1379 const char *name
= nullptr;
1380 std::vector
<struct fn_field
> fnfields
;
1383 /* The routines that read and process dies for a C struct or C++ class
1384 pass lists of data member fields and lists of member function fields
1385 in an instance of a field_info structure, as defined below. */
1388 /* List of data member and baseclasses fields. */
1389 std::vector
<struct nextfield
> fields
;
1390 std::vector
<struct nextfield
> baseclasses
;
1392 /* Number of fields (including baseclasses). */
1395 /* Set if the accessibility of one of the fields is not public. */
1396 int non_public_fields
= 0;
1398 /* Member function fieldlist array, contains name of possibly overloaded
1399 member function, number of overloaded member functions and a pointer
1400 to the head of the member function field chain. */
1401 std::vector
<struct fnfieldlist
> fnfieldlists
;
1403 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1404 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1405 std::vector
<struct decl_field
> typedef_field_list
;
1407 /* Nested types defined by this class and the number of elements in this
1409 std::vector
<struct decl_field
> nested_types_list
;
1412 /* One item on the queue of compilation units to read in full symbols
1414 struct dwarf2_queue_item
1416 struct dwarf2_per_cu_data
*per_cu
;
1417 enum language pretend_language
;
1418 struct dwarf2_queue_item
*next
;
1421 /* The current queue. */
1422 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1424 /* Loaded secondary compilation units are kept in memory until they
1425 have not been referenced for the processing of this many
1426 compilation units. Set this to zero to disable caching. Cache
1427 sizes of up to at least twenty will improve startup time for
1428 typical inter-CU-reference binaries, at an obvious memory cost. */
1429 static int dwarf_max_cache_age
= 5;
1431 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1432 struct cmd_list_element
*c
, const char *value
)
1434 fprintf_filtered (file
, _("The upper bound on the age of cached "
1435 "DWARF compilation units is %s.\n"),
1439 /* local function prototypes */
1441 static const char *get_section_name (const struct dwarf2_section_info
*);
1443 static const char *get_section_file_name (const struct dwarf2_section_info
*);
1445 static void dwarf2_find_base_address (struct die_info
*die
,
1446 struct dwarf2_cu
*cu
);
1448 static struct partial_symtab
*create_partial_symtab
1449 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1451 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1452 const gdb_byte
*info_ptr
,
1453 struct die_info
*type_unit_die
,
1454 int has_children
, void *data
);
1456 static void dwarf2_build_psymtabs_hard
1457 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1459 static void scan_partial_symbols (struct partial_die_info
*,
1460 CORE_ADDR
*, CORE_ADDR
*,
1461 int, struct dwarf2_cu
*);
1463 static void add_partial_symbol (struct partial_die_info
*,
1464 struct dwarf2_cu
*);
1466 static void add_partial_namespace (struct partial_die_info
*pdi
,
1467 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1468 int set_addrmap
, struct dwarf2_cu
*cu
);
1470 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1471 CORE_ADDR
*highpc
, int set_addrmap
,
1472 struct dwarf2_cu
*cu
);
1474 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1475 struct dwarf2_cu
*cu
);
1477 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1478 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1479 int need_pc
, struct dwarf2_cu
*cu
);
1481 static void dwarf2_read_symtab (struct partial_symtab
*,
1484 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1486 static abbrev_table_up abbrev_table_read_table
1487 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, struct dwarf2_section_info
*,
1490 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1492 static struct partial_die_info
*load_partial_dies
1493 (const struct die_reader_specs
*, const gdb_byte
*, int);
1495 /* A pair of partial_die_info and compilation unit. */
1496 struct cu_partial_die_info
1498 /* The compilation unit of the partial_die_info. */
1499 struct dwarf2_cu
*cu
;
1500 /* A partial_die_info. */
1501 struct partial_die_info
*pdi
;
1503 cu_partial_die_info (struct dwarf2_cu
*cu
, struct partial_die_info
*pdi
)
1509 cu_partial_die_info () = delete;
1512 static const struct cu_partial_die_info
find_partial_die (sect_offset
, int,
1513 struct dwarf2_cu
*);
1515 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1516 struct attribute
*, struct attr_abbrev
*,
1519 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1521 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1523 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1525 /* Read the next three bytes (little-endian order) as an unsigned integer. */
1526 static unsigned int read_3_bytes (bfd
*, const gdb_byte
*);
1528 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1530 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1532 static CORE_ADDR
read_address (bfd
*, const gdb_byte
*ptr
, struct dwarf2_cu
*,
1535 static LONGEST
read_initial_length (bfd
*, const gdb_byte
*, unsigned int *);
1537 static LONGEST read_checked_initial_length_and_offset
1538 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1539 unsigned int *, unsigned int *);
1541 static LONGEST
read_offset (bfd
*, const gdb_byte
*,
1542 const struct comp_unit_head
*,
1545 static LONGEST
read_offset_1 (bfd
*, const gdb_byte
*, unsigned int);
1547 static sect_offset read_abbrev_offset
1548 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1549 struct dwarf2_section_info
*, sect_offset
);
1551 static const gdb_byte
*read_n_bytes (bfd
*, const gdb_byte
*, unsigned int);
1553 static const char *read_direct_string (bfd
*, const gdb_byte
*, unsigned int *);
1555 static const char *read_indirect_string
1556 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*, const gdb_byte
*,
1557 const struct comp_unit_head
*, unsigned int *);
1559 static const char *read_indirect_line_string
1560 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*, const gdb_byte
*,
1561 const struct comp_unit_head
*, unsigned int *);
1563 static const char *read_indirect_string_at_offset
1564 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
1565 LONGEST str_offset
);
1567 static const char *read_indirect_string_from_dwz
1568 (struct objfile
*objfile
, struct dwz_file
*, LONGEST
);
1570 static LONGEST
read_signed_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1572 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1576 static const char *read_str_index (const struct die_reader_specs
*reader
,
1577 ULONGEST str_index
);
1579 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1581 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1582 struct dwarf2_cu
*);
1584 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1587 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1588 struct dwarf2_cu
*cu
);
1590 static const char *dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
1592 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1593 struct dwarf2_cu
*cu
);
1595 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1597 static struct die_info
*die_specification (struct die_info
*die
,
1598 struct dwarf2_cu
**);
1600 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1601 struct dwarf2_cu
*cu
);
1603 static void dwarf_decode_lines (struct line_header
*, const char *,
1604 struct dwarf2_cu
*, struct partial_symtab
*,
1605 CORE_ADDR
, int decode_mapping
);
1607 static void dwarf2_start_subfile (struct dwarf2_cu
*, const char *,
1610 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1611 struct dwarf2_cu
*, struct symbol
* = NULL
);
1613 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1614 struct dwarf2_cu
*);
1616 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1619 struct obstack
*obstack
,
1620 struct dwarf2_cu
*cu
, LONGEST
*value
,
1621 const gdb_byte
**bytes
,
1622 struct dwarf2_locexpr_baton
**baton
);
1624 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1626 static int need_gnat_info (struct dwarf2_cu
*);
1628 static struct type
*die_descriptive_type (struct die_info
*,
1629 struct dwarf2_cu
*);
1631 static void set_descriptive_type (struct type
*, struct die_info
*,
1632 struct dwarf2_cu
*);
1634 static struct type
*die_containing_type (struct die_info
*,
1635 struct dwarf2_cu
*);
1637 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1638 struct dwarf2_cu
*);
1640 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1642 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1644 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1646 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1647 const char *suffix
, int physname
,
1648 struct dwarf2_cu
*cu
);
1650 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1652 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1654 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1656 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1658 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1660 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1662 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1663 struct dwarf2_cu
*, struct partial_symtab
*);
1665 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1666 values. Keep the items ordered with increasing constraints compliance. */
1669 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1670 PC_BOUNDS_NOT_PRESENT
,
1672 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1673 were present but they do not form a valid range of PC addresses. */
1676 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1679 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1683 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1684 CORE_ADDR
*, CORE_ADDR
*,
1686 struct partial_symtab
*);
1688 static void get_scope_pc_bounds (struct die_info
*,
1689 CORE_ADDR
*, CORE_ADDR
*,
1690 struct dwarf2_cu
*);
1692 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1693 CORE_ADDR
, struct dwarf2_cu
*);
1695 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1696 struct dwarf2_cu
*);
1698 static void dwarf2_attach_fields_to_type (struct field_info
*,
1699 struct type
*, struct dwarf2_cu
*);
1701 static void dwarf2_add_member_fn (struct field_info
*,
1702 struct die_info
*, struct type
*,
1703 struct dwarf2_cu
*);
1705 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1707 struct dwarf2_cu
*);
1709 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1711 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1713 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1715 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1717 static struct using_direct
**using_directives (struct dwarf2_cu
*cu
);
1719 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1721 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1723 static struct type
*read_module_type (struct die_info
*die
,
1724 struct dwarf2_cu
*cu
);
1726 static const char *namespace_name (struct die_info
*die
,
1727 int *is_anonymous
, struct dwarf2_cu
*);
1729 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1731 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1733 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1734 struct dwarf2_cu
*);
1736 static struct die_info
*read_die_and_siblings_1
1737 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1740 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1741 const gdb_byte
*info_ptr
,
1742 const gdb_byte
**new_info_ptr
,
1743 struct die_info
*parent
);
1745 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1746 struct die_info
**, const gdb_byte
*,
1749 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1750 struct die_info
**, const gdb_byte
*,
1753 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1755 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1758 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1760 static const char *dwarf2_full_name (const char *name
,
1761 struct die_info
*die
,
1762 struct dwarf2_cu
*cu
);
1764 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1765 struct dwarf2_cu
*cu
);
1767 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1768 struct dwarf2_cu
**);
1770 static const char *dwarf_tag_name (unsigned int);
1772 static const char *dwarf_attr_name (unsigned int);
1774 static const char *dwarf_unit_type_name (int unit_type
);
1776 static const char *dwarf_form_name (unsigned int);
1778 static const char *dwarf_bool_name (unsigned int);
1780 static const char *dwarf_type_encoding_name (unsigned int);
1782 static struct die_info
*sibling_die (struct die_info
*);
1784 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1786 static void dump_die_for_error (struct die_info
*);
1788 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1791 /*static*/ void dump_die (struct die_info
*, int max_level
);
1793 static void store_in_ref_table (struct die_info
*,
1794 struct dwarf2_cu
*);
1796 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
1798 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
1800 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1801 const struct attribute
*,
1802 struct dwarf2_cu
**);
1804 static struct die_info
*follow_die_ref (struct die_info
*,
1805 const struct attribute
*,
1806 struct dwarf2_cu
**);
1808 static struct die_info
*follow_die_sig (struct die_info
*,
1809 const struct attribute
*,
1810 struct dwarf2_cu
**);
1812 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1813 struct dwarf2_cu
*);
1815 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1816 const struct attribute
*,
1817 struct dwarf2_cu
*);
1819 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1821 static void read_signatured_type (struct signatured_type
*);
1823 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1824 struct die_info
*die
, struct dwarf2_cu
*cu
,
1825 struct dynamic_prop
*prop
, struct type
*type
);
1827 /* memory allocation interface */
1829 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1831 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1833 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1835 static int attr_form_is_block (const struct attribute
*);
1837 static int attr_form_is_section_offset (const struct attribute
*);
1839 static int attr_form_is_constant (const struct attribute
*);
1841 static int attr_form_is_ref (const struct attribute
*);
1843 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1844 struct dwarf2_loclist_baton
*baton
,
1845 const struct attribute
*attr
);
1847 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1849 struct dwarf2_cu
*cu
,
1852 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1853 const gdb_byte
*info_ptr
,
1854 struct abbrev_info
*abbrev
);
1856 static hashval_t
partial_die_hash (const void *item
);
1858 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1860 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1861 (sect_offset sect_off
, unsigned int offset_in_dwz
,
1862 struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1864 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1865 struct die_info
*comp_unit_die
,
1866 enum language pretend_language
);
1868 static void age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1870 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1872 static struct type
*set_die_type (struct die_info
*, struct type
*,
1873 struct dwarf2_cu
*);
1875 static void create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1877 static int create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1879 static void load_full_comp_unit (struct dwarf2_per_cu_data
*, bool,
1882 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1885 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1888 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1889 struct dwarf2_per_cu_data
*);
1891 static void dwarf2_mark (struct dwarf2_cu
*);
1893 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1895 static struct type
*get_die_type_at_offset (sect_offset
,
1896 struct dwarf2_per_cu_data
*);
1898 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1900 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1901 enum language pretend_language
);
1903 static void process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1905 static struct type
*dwarf2_per_cu_addr_type (struct dwarf2_per_cu_data
*per_cu
);
1906 static struct type
*dwarf2_per_cu_addr_sized_int_type
1907 (struct dwarf2_per_cu_data
*per_cu
, bool unsigned_p
);
1908 static struct type
*dwarf2_per_cu_int_type
1909 (struct dwarf2_per_cu_data
*per_cu
, int size_in_bytes
,
1912 /* Class, the destructor of which frees all allocated queue entries. This
1913 will only have work to do if an error was thrown while processing the
1914 dwarf. If no error was thrown then the queue entries should have all
1915 been processed, and freed, as we went along. */
1917 class dwarf2_queue_guard
1920 dwarf2_queue_guard () = default;
1922 /* Free any entries remaining on the queue. There should only be
1923 entries left if we hit an error while processing the dwarf. */
1924 ~dwarf2_queue_guard ()
1926 struct dwarf2_queue_item
*item
, *last
;
1928 item
= dwarf2_queue
;
1931 /* Anything still marked queued is likely to be in an
1932 inconsistent state, so discard it. */
1933 if (item
->per_cu
->queued
)
1935 if (item
->per_cu
->cu
!= NULL
)
1936 free_one_cached_comp_unit (item
->per_cu
);
1937 item
->per_cu
->queued
= 0;
1945 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
1949 /* The return type of find_file_and_directory. Note, the enclosed
1950 string pointers are only valid while this object is valid. */
1952 struct file_and_directory
1954 /* The filename. This is never NULL. */
1957 /* The compilation directory. NULL if not known. If we needed to
1958 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1959 points directly to the DW_AT_comp_dir string attribute owned by
1960 the obstack that owns the DIE. */
1961 const char *comp_dir
;
1963 /* If we needed to build a new string for comp_dir, this is what
1964 owns the storage. */
1965 std::string comp_dir_storage
;
1968 static file_and_directory
find_file_and_directory (struct die_info
*die
,
1969 struct dwarf2_cu
*cu
);
1971 static char *file_full_name (int file
, struct line_header
*lh
,
1972 const char *comp_dir
);
1974 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
1975 enum class rcuh_kind
{ COMPILE
, TYPE
};
1977 static const gdb_byte
*read_and_check_comp_unit_head
1978 (struct dwarf2_per_objfile
* dwarf2_per_objfile
,
1979 struct comp_unit_head
*header
,
1980 struct dwarf2_section_info
*section
,
1981 struct dwarf2_section_info
*abbrev_section
, const gdb_byte
*info_ptr
,
1982 rcuh_kind section_kind
);
1984 static void init_cutu_and_read_dies
1985 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
1986 int use_existing_cu
, int keep
, bool skip_partial
,
1987 die_reader_func_ftype
*die_reader_func
, void *data
);
1989 static void init_cutu_and_read_dies_simple
1990 (struct dwarf2_per_cu_data
*this_cu
,
1991 die_reader_func_ftype
*die_reader_func
, void *data
);
1993 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1995 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1997 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1998 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1999 struct dwp_file
*dwp_file
, const char *comp_dir
,
2000 ULONGEST signature
, int is_debug_types
);
2002 static struct dwp_file
*get_dwp_file
2003 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2005 static struct dwo_unit
*lookup_dwo_comp_unit
2006 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
2008 static struct dwo_unit
*lookup_dwo_type_unit
2009 (struct signatured_type
*, const char *, const char *);
2011 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
2013 /* A unique pointer to a dwo_file. */
2015 typedef std::unique_ptr
<struct dwo_file
> dwo_file_up
;
2017 static void process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2019 static void check_producer (struct dwarf2_cu
*cu
);
2021 static void free_line_header_voidp (void *arg
);
2023 /* Various complaints about symbol reading that don't abort the process. */
2026 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2028 complaint (_("statement list doesn't fit in .debug_line section"));
2032 dwarf2_debug_line_missing_file_complaint (void)
2034 complaint (_(".debug_line section has line data without a file"));
2038 dwarf2_debug_line_missing_end_sequence_complaint (void)
2040 complaint (_(".debug_line section has line "
2041 "program sequence without an end"));
2045 dwarf2_complex_location_expr_complaint (void)
2047 complaint (_("location expression too complex"));
2051 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
2054 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
2059 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
2061 complaint (_("debug info runs off end of %s section"
2063 get_section_name (section
),
2064 get_section_file_name (section
));
2068 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
2070 complaint (_("macro debug info contains a "
2071 "malformed macro definition:\n`%s'"),
2076 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
2078 complaint (_("invalid attribute class or form for '%s' in '%s'"),
2082 /* Hash function for line_header_hash. */
2085 line_header_hash (const struct line_header
*ofs
)
2087 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
2090 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2093 line_header_hash_voidp (const void *item
)
2095 const struct line_header
*ofs
= (const struct line_header
*) item
;
2097 return line_header_hash (ofs
);
2100 /* Equality function for line_header_hash. */
2103 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
2105 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
2106 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
2108 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
2109 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
2114 /* Read the given attribute value as an address, taking the attribute's
2115 form into account. */
2118 attr_value_as_address (struct attribute
*attr
)
2122 if (attr
->form
!= DW_FORM_addr
&& attr
->form
!= DW_FORM_addrx
2123 && attr
->form
!= DW_FORM_GNU_addr_index
)
2125 /* Aside from a few clearly defined exceptions, attributes that
2126 contain an address must always be in DW_FORM_addr form.
2127 Unfortunately, some compilers happen to be violating this
2128 requirement by encoding addresses using other forms, such
2129 as DW_FORM_data4 for example. For those broken compilers,
2130 we try to do our best, without any guarantee of success,
2131 to interpret the address correctly. It would also be nice
2132 to generate a complaint, but that would require us to maintain
2133 a list of legitimate cases where a non-address form is allowed,
2134 as well as update callers to pass in at least the CU's DWARF
2135 version. This is more overhead than what we're willing to
2136 expand for a pretty rare case. */
2137 addr
= DW_UNSND (attr
);
2140 addr
= DW_ADDR (attr
);
2145 /* See declaration. */
2147 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile
*objfile_
,
2148 const dwarf2_debug_sections
*names
,
2150 : objfile (objfile_
),
2151 can_copy (can_copy_
)
2154 names
= &dwarf2_elf_names
;
2156 bfd
*obfd
= objfile
->obfd
;
2158 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2159 locate_sections (obfd
, sec
, *names
);
2162 dwarf2_per_objfile::~dwarf2_per_objfile ()
2164 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
2165 free_cached_comp_units ();
2167 if (quick_file_names_table
)
2168 htab_delete (quick_file_names_table
);
2170 if (line_header_hash
)
2171 htab_delete (line_header_hash
);
2173 for (dwarf2_per_cu_data
*per_cu
: all_comp_units
)
2174 per_cu
->imported_symtabs_free ();
2176 for (signatured_type
*sig_type
: all_type_units
)
2177 sig_type
->per_cu
.imported_symtabs_free ();
2179 /* Everything else should be on the objfile obstack. */
2182 /* See declaration. */
2185 dwarf2_per_objfile::free_cached_comp_units ()
2187 dwarf2_per_cu_data
*per_cu
= read_in_chain
;
2188 dwarf2_per_cu_data
**last_chain
= &read_in_chain
;
2189 while (per_cu
!= NULL
)
2191 dwarf2_per_cu_data
*next_cu
= per_cu
->cu
->read_in_chain
;
2194 *last_chain
= next_cu
;
2199 /* A helper class that calls free_cached_comp_units on
2202 class free_cached_comp_units
2206 explicit free_cached_comp_units (dwarf2_per_objfile
*per_objfile
)
2207 : m_per_objfile (per_objfile
)
2211 ~free_cached_comp_units ()
2213 m_per_objfile
->free_cached_comp_units ();
2216 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units
);
2220 dwarf2_per_objfile
*m_per_objfile
;
2223 /* Try to locate the sections we need for DWARF 2 debugging
2224 information and return true if we have enough to do something.
2225 NAMES points to the dwarf2 section names, or is NULL if the standard
2226 ELF names are used. CAN_COPY is true for formats where symbol
2227 interposition is possible and so symbol values must follow copy
2228 relocation rules. */
2231 dwarf2_has_info (struct objfile
*objfile
,
2232 const struct dwarf2_debug_sections
*names
,
2235 if (objfile
->flags
& OBJF_READNEVER
)
2238 struct dwarf2_per_objfile
*dwarf2_per_objfile
2239 = get_dwarf2_per_objfile (objfile
);
2241 if (dwarf2_per_objfile
== NULL
)
2242 dwarf2_per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
,
2246 return (!dwarf2_per_objfile
->info
.is_virtual
2247 && dwarf2_per_objfile
->info
.s
.section
!= NULL
2248 && !dwarf2_per_objfile
->abbrev
.is_virtual
2249 && dwarf2_per_objfile
->abbrev
.s
.section
!= NULL
);
2252 /* Return the containing section of virtual section SECTION. */
2254 static struct dwarf2_section_info
*
2255 get_containing_section (const struct dwarf2_section_info
*section
)
2257 gdb_assert (section
->is_virtual
);
2258 return section
->s
.containing_section
;
2261 /* Return the bfd owner of SECTION. */
2264 get_section_bfd_owner (const struct dwarf2_section_info
*section
)
2266 if (section
->is_virtual
)
2268 section
= get_containing_section (section
);
2269 gdb_assert (!section
->is_virtual
);
2271 return section
->s
.section
->owner
;
2274 /* Return the bfd section of SECTION.
2275 Returns NULL if the section is not present. */
2278 get_section_bfd_section (const struct dwarf2_section_info
*section
)
2280 if (section
->is_virtual
)
2282 section
= get_containing_section (section
);
2283 gdb_assert (!section
->is_virtual
);
2285 return section
->s
.section
;
2288 /* Return the name of SECTION. */
2291 get_section_name (const struct dwarf2_section_info
*section
)
2293 asection
*sectp
= get_section_bfd_section (section
);
2295 gdb_assert (sectp
!= NULL
);
2296 return bfd_section_name (sectp
);
2299 /* Return the name of the file SECTION is in. */
2302 get_section_file_name (const struct dwarf2_section_info
*section
)
2304 bfd
*abfd
= get_section_bfd_owner (section
);
2306 return bfd_get_filename (abfd
);
2309 /* Return the id of SECTION.
2310 Returns 0 if SECTION doesn't exist. */
2313 get_section_id (const struct dwarf2_section_info
*section
)
2315 asection
*sectp
= get_section_bfd_section (section
);
2322 /* Return the flags of SECTION.
2323 SECTION (or containing section if this is a virtual section) must exist. */
2326 get_section_flags (const struct dwarf2_section_info
*section
)
2328 asection
*sectp
= get_section_bfd_section (section
);
2330 gdb_assert (sectp
!= NULL
);
2331 return bfd_section_flags (sectp
);
2334 /* When loading sections, we look either for uncompressed section or for
2335 compressed section names. */
2338 section_is_p (const char *section_name
,
2339 const struct dwarf2_section_names
*names
)
2341 if (names
->normal
!= NULL
2342 && strcmp (section_name
, names
->normal
) == 0)
2344 if (names
->compressed
!= NULL
2345 && strcmp (section_name
, names
->compressed
) == 0)
2350 /* See declaration. */
2353 dwarf2_per_objfile::locate_sections (bfd
*abfd
, asection
*sectp
,
2354 const dwarf2_debug_sections
&names
)
2356 flagword aflag
= bfd_section_flags (sectp
);
2358 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2361 else if (elf_section_data (sectp
)->this_hdr
.sh_size
2362 > bfd_get_file_size (abfd
))
2364 bfd_size_type size
= elf_section_data (sectp
)->this_hdr
.sh_size
;
2365 warning (_("Discarding section %s which has a section size (%s"
2366 ") larger than the file size [in module %s]"),
2367 bfd_section_name (sectp
), phex_nz (size
, sizeof (size
)),
2368 bfd_get_filename (abfd
));
2370 else if (section_is_p (sectp
->name
, &names
.info
))
2372 this->info
.s
.section
= sectp
;
2373 this->info
.size
= bfd_section_size (sectp
);
2375 else if (section_is_p (sectp
->name
, &names
.abbrev
))
2377 this->abbrev
.s
.section
= sectp
;
2378 this->abbrev
.size
= bfd_section_size (sectp
);
2380 else if (section_is_p (sectp
->name
, &names
.line
))
2382 this->line
.s
.section
= sectp
;
2383 this->line
.size
= bfd_section_size (sectp
);
2385 else if (section_is_p (sectp
->name
, &names
.loc
))
2387 this->loc
.s
.section
= sectp
;
2388 this->loc
.size
= bfd_section_size (sectp
);
2390 else if (section_is_p (sectp
->name
, &names
.loclists
))
2392 this->loclists
.s
.section
= sectp
;
2393 this->loclists
.size
= bfd_section_size (sectp
);
2395 else if (section_is_p (sectp
->name
, &names
.macinfo
))
2397 this->macinfo
.s
.section
= sectp
;
2398 this->macinfo
.size
= bfd_section_size (sectp
);
2400 else if (section_is_p (sectp
->name
, &names
.macro
))
2402 this->macro
.s
.section
= sectp
;
2403 this->macro
.size
= bfd_section_size (sectp
);
2405 else if (section_is_p (sectp
->name
, &names
.str
))
2407 this->str
.s
.section
= sectp
;
2408 this->str
.size
= bfd_section_size (sectp
);
2410 else if (section_is_p (sectp
->name
, &names
.line_str
))
2412 this->line_str
.s
.section
= sectp
;
2413 this->line_str
.size
= bfd_section_size (sectp
);
2415 else if (section_is_p (sectp
->name
, &names
.addr
))
2417 this->addr
.s
.section
= sectp
;
2418 this->addr
.size
= bfd_section_size (sectp
);
2420 else if (section_is_p (sectp
->name
, &names
.frame
))
2422 this->frame
.s
.section
= sectp
;
2423 this->frame
.size
= bfd_section_size (sectp
);
2425 else if (section_is_p (sectp
->name
, &names
.eh_frame
))
2427 this->eh_frame
.s
.section
= sectp
;
2428 this->eh_frame
.size
= bfd_section_size (sectp
);
2430 else if (section_is_p (sectp
->name
, &names
.ranges
))
2432 this->ranges
.s
.section
= sectp
;
2433 this->ranges
.size
= bfd_section_size (sectp
);
2435 else if (section_is_p (sectp
->name
, &names
.rnglists
))
2437 this->rnglists
.s
.section
= sectp
;
2438 this->rnglists
.size
= bfd_section_size (sectp
);
2440 else if (section_is_p (sectp
->name
, &names
.types
))
2442 struct dwarf2_section_info type_section
;
2444 memset (&type_section
, 0, sizeof (type_section
));
2445 type_section
.s
.section
= sectp
;
2446 type_section
.size
= bfd_section_size (sectp
);
2448 this->types
.push_back (type_section
);
2450 else if (section_is_p (sectp
->name
, &names
.gdb_index
))
2452 this->gdb_index
.s
.section
= sectp
;
2453 this->gdb_index
.size
= bfd_section_size (sectp
);
2455 else if (section_is_p (sectp
->name
, &names
.debug_names
))
2457 this->debug_names
.s
.section
= sectp
;
2458 this->debug_names
.size
= bfd_section_size (sectp
);
2460 else if (section_is_p (sectp
->name
, &names
.debug_aranges
))
2462 this->debug_aranges
.s
.section
= sectp
;
2463 this->debug_aranges
.size
= bfd_section_size (sectp
);
2466 if ((bfd_section_flags (sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2467 && bfd_section_vma (sectp
) == 0)
2468 this->has_section_at_zero
= true;
2471 /* A helper function that decides whether a section is empty,
2475 dwarf2_section_empty_p (const struct dwarf2_section_info
*section
)
2477 if (section
->is_virtual
)
2478 return section
->size
== 0;
2479 return section
->s
.section
== NULL
|| section
->size
== 0;
2482 /* See dwarf2read.h. */
2485 dwarf2_read_section (struct objfile
*objfile
, dwarf2_section_info
*info
)
2489 gdb_byte
*buf
, *retbuf
;
2493 info
->buffer
= NULL
;
2494 info
->readin
= true;
2496 if (dwarf2_section_empty_p (info
))
2499 sectp
= get_section_bfd_section (info
);
2501 /* If this is a virtual section we need to read in the real one first. */
2502 if (info
->is_virtual
)
2504 struct dwarf2_section_info
*containing_section
=
2505 get_containing_section (info
);
2507 gdb_assert (sectp
!= NULL
);
2508 if ((sectp
->flags
& SEC_RELOC
) != 0)
2510 error (_("Dwarf Error: DWP format V2 with relocations is not"
2511 " supported in section %s [in module %s]"),
2512 get_section_name (info
), get_section_file_name (info
));
2514 dwarf2_read_section (objfile
, containing_section
);
2515 /* Other code should have already caught virtual sections that don't
2517 gdb_assert (info
->virtual_offset
+ info
->size
2518 <= containing_section
->size
);
2519 /* If the real section is empty or there was a problem reading the
2520 section we shouldn't get here. */
2521 gdb_assert (containing_section
->buffer
!= NULL
);
2522 info
->buffer
= containing_section
->buffer
+ info
->virtual_offset
;
2526 /* If the section has relocations, we must read it ourselves.
2527 Otherwise we attach it to the BFD. */
2528 if ((sectp
->flags
& SEC_RELOC
) == 0)
2530 info
->buffer
= gdb_bfd_map_section (sectp
, &info
->size
);
2534 buf
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
2537 /* When debugging .o files, we may need to apply relocations; see
2538 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2539 We never compress sections in .o files, so we only need to
2540 try this when the section is not compressed. */
2541 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
2544 info
->buffer
= retbuf
;
2548 abfd
= get_section_bfd_owner (info
);
2549 gdb_assert (abfd
!= NULL
);
2551 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
2552 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
2554 error (_("Dwarf Error: Can't read DWARF data"
2555 " in section %s [in module %s]"),
2556 bfd_section_name (sectp
), bfd_get_filename (abfd
));
2560 /* A helper function that returns the size of a section in a safe way.
2561 If you are positive that the section has been read before using the
2562 size, then it is safe to refer to the dwarf2_section_info object's
2563 "size" field directly. In other cases, you must call this
2564 function, because for compressed sections the size field is not set
2565 correctly until the section has been read. */
2567 static bfd_size_type
2568 dwarf2_section_size (struct objfile
*objfile
,
2569 struct dwarf2_section_info
*info
)
2572 dwarf2_read_section (objfile
, info
);
2576 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2580 dwarf2_get_section_info (struct objfile
*objfile
,
2581 enum dwarf2_section_enum sect
,
2582 asection
**sectp
, const gdb_byte
**bufp
,
2583 bfd_size_type
*sizep
)
2585 struct dwarf2_per_objfile
*data
= dwarf2_objfile_data_key
.get (objfile
);
2586 struct dwarf2_section_info
*info
;
2588 /* We may see an objfile without any DWARF, in which case we just
2599 case DWARF2_DEBUG_FRAME
:
2600 info
= &data
->frame
;
2602 case DWARF2_EH_FRAME
:
2603 info
= &data
->eh_frame
;
2606 gdb_assert_not_reached ("unexpected section");
2609 dwarf2_read_section (objfile
, info
);
2611 *sectp
= get_section_bfd_section (info
);
2612 *bufp
= info
->buffer
;
2613 *sizep
= info
->size
;
2616 /* A helper function to find the sections for a .dwz file. */
2619 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2621 struct dwz_file
*dwz_file
= (struct dwz_file
*) arg
;
2623 /* Note that we only support the standard ELF names, because .dwz
2624 is ELF-only (at the time of writing). */
2625 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2627 dwz_file
->abbrev
.s
.section
= sectp
;
2628 dwz_file
->abbrev
.size
= bfd_section_size (sectp
);
2630 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2632 dwz_file
->info
.s
.section
= sectp
;
2633 dwz_file
->info
.size
= bfd_section_size (sectp
);
2635 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2637 dwz_file
->str
.s
.section
= sectp
;
2638 dwz_file
->str
.size
= bfd_section_size (sectp
);
2640 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2642 dwz_file
->line
.s
.section
= sectp
;
2643 dwz_file
->line
.size
= bfd_section_size (sectp
);
2645 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2647 dwz_file
->macro
.s
.section
= sectp
;
2648 dwz_file
->macro
.size
= bfd_section_size (sectp
);
2650 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2652 dwz_file
->gdb_index
.s
.section
= sectp
;
2653 dwz_file
->gdb_index
.size
= bfd_section_size (sectp
);
2655 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.debug_names
))
2657 dwz_file
->debug_names
.s
.section
= sectp
;
2658 dwz_file
->debug_names
.size
= bfd_section_size (sectp
);
2662 /* See dwarf2read.h. */
2665 dwarf2_get_dwz_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
2667 const char *filename
;
2668 bfd_size_type buildid_len_arg
;
2672 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2673 return dwarf2_per_objfile
->dwz_file
.get ();
2675 bfd_set_error (bfd_error_no_error
);
2676 gdb::unique_xmalloc_ptr
<char> data
2677 (bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2678 &buildid_len_arg
, &buildid
));
2681 if (bfd_get_error () == bfd_error_no_error
)
2683 error (_("could not read '.gnu_debugaltlink' section: %s"),
2684 bfd_errmsg (bfd_get_error ()));
2687 gdb::unique_xmalloc_ptr
<bfd_byte
> buildid_holder (buildid
);
2689 buildid_len
= (size_t) buildid_len_arg
;
2691 filename
= data
.get ();
2693 std::string abs_storage
;
2694 if (!IS_ABSOLUTE_PATH (filename
))
2696 gdb::unique_xmalloc_ptr
<char> abs
2697 = gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2699 abs_storage
= ldirname (abs
.get ()) + SLASH_STRING
+ filename
;
2700 filename
= abs_storage
.c_str ();
2703 /* First try the file name given in the section. If that doesn't
2704 work, try to use the build-id instead. */
2705 gdb_bfd_ref_ptr
dwz_bfd (gdb_bfd_open (filename
, gnutarget
, -1));
2706 if (dwz_bfd
!= NULL
)
2708 if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2709 dwz_bfd
.reset (nullptr);
2712 if (dwz_bfd
== NULL
)
2713 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2715 if (dwz_bfd
== NULL
)
2716 error (_("could not find '.gnu_debugaltlink' file for %s"),
2717 objfile_name (dwarf2_per_objfile
->objfile
));
2719 std::unique_ptr
<struct dwz_file
> result
2720 (new struct dwz_file (std::move (dwz_bfd
)));
2722 bfd_map_over_sections (result
->dwz_bfd
.get (), locate_dwz_sections
,
2725 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
,
2726 result
->dwz_bfd
.get ());
2727 dwarf2_per_objfile
->dwz_file
= std::move (result
);
2728 return dwarf2_per_objfile
->dwz_file
.get ();
2731 /* DWARF quick_symbols_functions support. */
2733 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2734 unique line tables, so we maintain a separate table of all .debug_line
2735 derived entries to support the sharing.
2736 All the quick functions need is the list of file names. We discard the
2737 line_header when we're done and don't need to record it here. */
2738 struct quick_file_names
2740 /* The data used to construct the hash key. */
2741 struct stmt_list_hash hash
;
2743 /* The number of entries in file_names, real_names. */
2744 unsigned int num_file_names
;
2746 /* The file names from the line table, after being run through
2748 const char **file_names
;
2750 /* The file names from the line table after being run through
2751 gdb_realpath. These are computed lazily. */
2752 const char **real_names
;
2755 /* When using the index (and thus not using psymtabs), each CU has an
2756 object of this type. This is used to hold information needed by
2757 the various "quick" methods. */
2758 struct dwarf2_per_cu_quick_data
2760 /* The file table. This can be NULL if there was no file table
2761 or it's currently not read in.
2762 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2763 struct quick_file_names
*file_names
;
2765 /* The corresponding symbol table. This is NULL if symbols for this
2766 CU have not yet been read. */
2767 struct compunit_symtab
*compunit_symtab
;
2769 /* A temporary mark bit used when iterating over all CUs in
2770 expand_symtabs_matching. */
2771 unsigned int mark
: 1;
2773 /* True if we've tried to read the file table and found there isn't one.
2774 There will be no point in trying to read it again next time. */
2775 unsigned int no_file_data
: 1;
2778 /* Utility hash function for a stmt_list_hash. */
2781 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2785 if (stmt_list_hash
->dwo_unit
!= NULL
)
2786 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2787 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2791 /* Utility equality function for a stmt_list_hash. */
2794 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2795 const struct stmt_list_hash
*rhs
)
2797 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2799 if (lhs
->dwo_unit
!= NULL
2800 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2803 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2806 /* Hash function for a quick_file_names. */
2809 hash_file_name_entry (const void *e
)
2811 const struct quick_file_names
*file_data
2812 = (const struct quick_file_names
*) e
;
2814 return hash_stmt_list_entry (&file_data
->hash
);
2817 /* Equality function for a quick_file_names. */
2820 eq_file_name_entry (const void *a
, const void *b
)
2822 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2823 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2825 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2828 /* Delete function for a quick_file_names. */
2831 delete_file_name_entry (void *e
)
2833 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2836 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2838 xfree ((void*) file_data
->file_names
[i
]);
2839 if (file_data
->real_names
)
2840 xfree ((void*) file_data
->real_names
[i
]);
2843 /* The space for the struct itself lives on objfile_obstack,
2844 so we don't free it here. */
2847 /* Create a quick_file_names hash table. */
2850 create_quick_file_names_table (unsigned int nr_initial_entries
)
2852 return htab_create_alloc (nr_initial_entries
,
2853 hash_file_name_entry
, eq_file_name_entry
,
2854 delete_file_name_entry
, xcalloc
, xfree
);
2857 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2858 have to be created afterwards. You should call age_cached_comp_units after
2859 processing PER_CU->CU. dw2_setup must have been already called. */
2862 load_cu (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2864 if (per_cu
->is_debug_types
)
2865 load_full_type_unit (per_cu
);
2867 load_full_comp_unit (per_cu
, skip_partial
, language_minimal
);
2869 if (per_cu
->cu
== NULL
)
2870 return; /* Dummy CU. */
2872 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2875 /* Read in the symbols for PER_CU. */
2878 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2880 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
2882 /* Skip type_unit_groups, reading the type units they contain
2883 is handled elsewhere. */
2884 if (IS_TYPE_UNIT_GROUP (per_cu
))
2887 /* The destructor of dwarf2_queue_guard frees any entries left on
2888 the queue. After this point we're guaranteed to leave this function
2889 with the dwarf queue empty. */
2890 dwarf2_queue_guard q_guard
;
2892 if (dwarf2_per_objfile
->using_index
2893 ? per_cu
->v
.quick
->compunit_symtab
== NULL
2894 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2896 queue_comp_unit (per_cu
, language_minimal
);
2897 load_cu (per_cu
, skip_partial
);
2899 /* If we just loaded a CU from a DWO, and we're working with an index
2900 that may badly handle TUs, load all the TUs in that DWO as well.
2901 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2902 if (!per_cu
->is_debug_types
2903 && per_cu
->cu
!= NULL
2904 && per_cu
->cu
->dwo_unit
!= NULL
2905 && dwarf2_per_objfile
->index_table
!= NULL
2906 && dwarf2_per_objfile
->index_table
->version
<= 7
2907 /* DWP files aren't supported yet. */
2908 && get_dwp_file (dwarf2_per_objfile
) == NULL
)
2909 queue_and_load_all_dwo_tus (per_cu
);
2912 process_queue (dwarf2_per_objfile
);
2914 /* Age the cache, releasing compilation units that have not
2915 been used recently. */
2916 age_cached_comp_units (dwarf2_per_objfile
);
2919 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2920 the objfile from which this CU came. Returns the resulting symbol
2923 static struct compunit_symtab
*
2924 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2926 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
2928 gdb_assert (dwarf2_per_objfile
->using_index
);
2929 if (!per_cu
->v
.quick
->compunit_symtab
)
2931 free_cached_comp_units
freer (dwarf2_per_objfile
);
2932 scoped_restore decrementer
= increment_reading_symtab ();
2933 dw2_do_instantiate_symtab (per_cu
, skip_partial
);
2934 process_cu_includes (dwarf2_per_objfile
);
2937 return per_cu
->v
.quick
->compunit_symtab
;
2940 /* See declaration. */
2942 dwarf2_per_cu_data
*
2943 dwarf2_per_objfile::get_cutu (int index
)
2945 if (index
>= this->all_comp_units
.size ())
2947 index
-= this->all_comp_units
.size ();
2948 gdb_assert (index
< this->all_type_units
.size ());
2949 return &this->all_type_units
[index
]->per_cu
;
2952 return this->all_comp_units
[index
];
2955 /* See declaration. */
2957 dwarf2_per_cu_data
*
2958 dwarf2_per_objfile::get_cu (int index
)
2960 gdb_assert (index
>= 0 && index
< this->all_comp_units
.size ());
2962 return this->all_comp_units
[index
];
2965 /* See declaration. */
2968 dwarf2_per_objfile::get_tu (int index
)
2970 gdb_assert (index
>= 0 && index
< this->all_type_units
.size ());
2972 return this->all_type_units
[index
];
2975 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2976 objfile_obstack, and constructed with the specified field
2979 static dwarf2_per_cu_data
*
2980 create_cu_from_index_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2981 struct dwarf2_section_info
*section
,
2983 sect_offset sect_off
, ULONGEST length
)
2985 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2986 dwarf2_per_cu_data
*the_cu
2987 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2988 struct dwarf2_per_cu_data
);
2989 the_cu
->sect_off
= sect_off
;
2990 the_cu
->length
= length
;
2991 the_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
2992 the_cu
->section
= section
;
2993 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2994 struct dwarf2_per_cu_quick_data
);
2995 the_cu
->is_dwz
= is_dwz
;
2999 /* A helper for create_cus_from_index that handles a given list of
3003 create_cus_from_index_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3004 const gdb_byte
*cu_list
, offset_type n_elements
,
3005 struct dwarf2_section_info
*section
,
3008 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
3010 gdb_static_assert (sizeof (ULONGEST
) >= 8);
3012 sect_offset sect_off
3013 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
3014 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
3017 dwarf2_per_cu_data
*per_cu
3018 = create_cu_from_index_list (dwarf2_per_objfile
, section
, is_dwz
,
3020 dwarf2_per_objfile
->all_comp_units
.push_back (per_cu
);
3024 /* Read the CU list from the mapped index, and use it to create all
3025 the CU objects for this objfile. */
3028 create_cus_from_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3029 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
3030 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
3032 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
3033 dwarf2_per_objfile
->all_comp_units
.reserve
3034 ((cu_list_elements
+ dwz_elements
) / 2);
3036 create_cus_from_index_list (dwarf2_per_objfile
, cu_list
, cu_list_elements
,
3037 &dwarf2_per_objfile
->info
, 0);
3039 if (dwz_elements
== 0)
3042 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
3043 create_cus_from_index_list (dwarf2_per_objfile
, dwz_list
, dwz_elements
,
3047 /* Create the signatured type hash table from the index. */
3050 create_signatured_type_table_from_index
3051 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3052 struct dwarf2_section_info
*section
,
3053 const gdb_byte
*bytes
,
3054 offset_type elements
)
3056 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3058 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
3059 dwarf2_per_objfile
->all_type_units
.reserve (elements
/ 3);
3061 htab_t sig_types_hash
= allocate_signatured_type_table (objfile
);
3063 for (offset_type i
= 0; i
< elements
; i
+= 3)
3065 struct signatured_type
*sig_type
;
3068 cu_offset type_offset_in_tu
;
3070 gdb_static_assert (sizeof (ULONGEST
) >= 8);
3071 sect_offset sect_off
3072 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
3074 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
3076 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
3079 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3080 struct signatured_type
);
3081 sig_type
->signature
= signature
;
3082 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
3083 sig_type
->per_cu
.is_debug_types
= 1;
3084 sig_type
->per_cu
.section
= section
;
3085 sig_type
->per_cu
.sect_off
= sect_off
;
3086 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
3087 sig_type
->per_cu
.v
.quick
3088 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3089 struct dwarf2_per_cu_quick_data
);
3091 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
3094 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
3097 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
3100 /* Create the signatured type hash table from .debug_names. */
3103 create_signatured_type_table_from_debug_names
3104 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3105 const mapped_debug_names
&map
,
3106 struct dwarf2_section_info
*section
,
3107 struct dwarf2_section_info
*abbrev_section
)
3109 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3111 dwarf2_read_section (objfile
, section
);
3112 dwarf2_read_section (objfile
, abbrev_section
);
3114 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
3115 dwarf2_per_objfile
->all_type_units
.reserve (map
.tu_count
);
3117 htab_t sig_types_hash
= allocate_signatured_type_table (objfile
);
3119 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
3121 struct signatured_type
*sig_type
;
3124 sect_offset sect_off
3125 = (sect_offset
) (extract_unsigned_integer
3126 (map
.tu_table_reordered
+ i
* map
.offset_size
,
3128 map
.dwarf5_byte_order
));
3130 comp_unit_head cu_header
;
3131 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
3133 section
->buffer
+ to_underlying (sect_off
),
3136 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3137 struct signatured_type
);
3138 sig_type
->signature
= cu_header
.signature
;
3139 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
3140 sig_type
->per_cu
.is_debug_types
= 1;
3141 sig_type
->per_cu
.section
= section
;
3142 sig_type
->per_cu
.sect_off
= sect_off
;
3143 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
3144 sig_type
->per_cu
.v
.quick
3145 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3146 struct dwarf2_per_cu_quick_data
);
3148 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
3151 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
3154 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
3157 /* Read the address map data from the mapped index, and use it to
3158 populate the objfile's psymtabs_addrmap. */
3161 create_addrmap_from_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3162 struct mapped_index
*index
)
3164 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3165 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3166 const gdb_byte
*iter
, *end
;
3167 struct addrmap
*mutable_map
;
3170 auto_obstack temp_obstack
;
3172 mutable_map
= addrmap_create_mutable (&temp_obstack
);
3174 iter
= index
->address_table
.data ();
3175 end
= iter
+ index
->address_table
.size ();
3177 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3181 ULONGEST hi
, lo
, cu_index
;
3182 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3184 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3186 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
3191 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
3192 hex_string (lo
), hex_string (hi
));
3196 if (cu_index
>= dwarf2_per_objfile
->all_comp_units
.size ())
3198 complaint (_(".gdb_index address table has invalid CU number %u"),
3199 (unsigned) cu_index
);
3203 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
3204 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
3205 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
3206 dwarf2_per_objfile
->get_cu (cu_index
));
3209 objfile
->partial_symtabs
->psymtabs_addrmap
3210 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
3213 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3214 populate the objfile's psymtabs_addrmap. */
3217 create_addrmap_from_aranges (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3218 struct dwarf2_section_info
*section
)
3220 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3221 bfd
*abfd
= objfile
->obfd
;
3222 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3223 const CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
3224 SECT_OFF_TEXT (objfile
));
3226 auto_obstack temp_obstack
;
3227 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
3229 std::unordered_map
<sect_offset
,
3230 dwarf2_per_cu_data
*,
3231 gdb::hash_enum
<sect_offset
>>
3232 debug_info_offset_to_per_cu
;
3233 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
3235 const auto insertpair
3236 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
, per_cu
);
3237 if (!insertpair
.second
)
3239 warning (_("Section .debug_aranges in %s has duplicate "
3240 "debug_info_offset %s, ignoring .debug_aranges."),
3241 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
3246 dwarf2_read_section (objfile
, section
);
3248 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
3250 const gdb_byte
*addr
= section
->buffer
;
3252 while (addr
< section
->buffer
+ section
->size
)
3254 const gdb_byte
*const entry_addr
= addr
;
3255 unsigned int bytes_read
;
3257 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
3261 const gdb_byte
*const entry_end
= addr
+ entry_length
;
3262 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
3263 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
3264 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
3266 warning (_("Section .debug_aranges in %s entry at offset %s "
3267 "length %s exceeds section length %s, "
3268 "ignoring .debug_aranges."),
3269 objfile_name (objfile
),
3270 plongest (entry_addr
- section
->buffer
),
3271 plongest (bytes_read
+ entry_length
),
3272 pulongest (section
->size
));
3276 /* The version number. */
3277 const uint16_t version
= read_2_bytes (abfd
, addr
);
3281 warning (_("Section .debug_aranges in %s entry at offset %s "
3282 "has unsupported version %d, ignoring .debug_aranges."),
3283 objfile_name (objfile
),
3284 plongest (entry_addr
- section
->buffer
), version
);
3288 const uint64_t debug_info_offset
3289 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
3290 addr
+= offset_size
;
3291 const auto per_cu_it
3292 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
3293 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
3295 warning (_("Section .debug_aranges in %s entry at offset %s "
3296 "debug_info_offset %s does not exists, "
3297 "ignoring .debug_aranges."),
3298 objfile_name (objfile
),
3299 plongest (entry_addr
- section
->buffer
),
3300 pulongest (debug_info_offset
));
3303 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
3305 const uint8_t address_size
= *addr
++;
3306 if (address_size
< 1 || address_size
> 8)
3308 warning (_("Section .debug_aranges in %s entry at offset %s "
3309 "address_size %u is invalid, ignoring .debug_aranges."),
3310 objfile_name (objfile
),
3311 plongest (entry_addr
- section
->buffer
), address_size
);
3315 const uint8_t segment_selector_size
= *addr
++;
3316 if (segment_selector_size
!= 0)
3318 warning (_("Section .debug_aranges in %s entry at offset %s "
3319 "segment_selector_size %u is not supported, "
3320 "ignoring .debug_aranges."),
3321 objfile_name (objfile
),
3322 plongest (entry_addr
- section
->buffer
),
3323 segment_selector_size
);
3327 /* Must pad to an alignment boundary that is twice the address
3328 size. It is undocumented by the DWARF standard but GCC does
3330 for (size_t padding
= ((-(addr
- section
->buffer
))
3331 & (2 * address_size
- 1));
3332 padding
> 0; padding
--)
3335 warning (_("Section .debug_aranges in %s entry at offset %s "
3336 "padding is not zero, ignoring .debug_aranges."),
3337 objfile_name (objfile
),
3338 plongest (entry_addr
- section
->buffer
));
3344 if (addr
+ 2 * address_size
> entry_end
)
3346 warning (_("Section .debug_aranges in %s entry at offset %s "
3347 "address list is not properly terminated, "
3348 "ignoring .debug_aranges."),
3349 objfile_name (objfile
),
3350 plongest (entry_addr
- section
->buffer
));
3353 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
3355 addr
+= address_size
;
3356 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
3358 addr
+= address_size
;
3359 if (start
== 0 && length
== 0)
3361 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3363 /* Symbol was eliminated due to a COMDAT group. */
3366 ULONGEST end
= start
+ length
;
3367 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
3369 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
3371 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
3375 objfile
->partial_symtabs
->psymtabs_addrmap
3376 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
3379 /* Find a slot in the mapped index INDEX for the object named NAME.
3380 If NAME is found, set *VEC_OUT to point to the CU vector in the
3381 constant pool and return true. If NAME cannot be found, return
3385 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
3386 offset_type
**vec_out
)
3389 offset_type slot
, step
;
3390 int (*cmp
) (const char *, const char *);
3392 gdb::unique_xmalloc_ptr
<char> without_params
;
3393 if (current_language
->la_language
== language_cplus
3394 || current_language
->la_language
== language_fortran
3395 || current_language
->la_language
== language_d
)
3397 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3400 if (strchr (name
, '(') != NULL
)
3402 without_params
= cp_remove_params (name
);
3404 if (without_params
!= NULL
)
3405 name
= without_params
.get ();
3409 /* Index version 4 did not support case insensitive searches. But the
3410 indices for case insensitive languages are built in lowercase, therefore
3411 simulate our NAME being searched is also lowercased. */
3412 hash
= mapped_index_string_hash ((index
->version
== 4
3413 && case_sensitivity
== case_sensitive_off
3414 ? 5 : index
->version
),
3417 slot
= hash
& (index
->symbol_table
.size () - 1);
3418 step
= ((hash
* 17) & (index
->symbol_table
.size () - 1)) | 1;
3419 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
3425 const auto &bucket
= index
->symbol_table
[slot
];
3426 if (bucket
.name
== 0 && bucket
.vec
== 0)
3429 str
= index
->constant_pool
+ MAYBE_SWAP (bucket
.name
);
3430 if (!cmp (name
, str
))
3432 *vec_out
= (offset_type
*) (index
->constant_pool
3433 + MAYBE_SWAP (bucket
.vec
));
3437 slot
= (slot
+ step
) & (index
->symbol_table
.size () - 1);
3441 /* A helper function that reads the .gdb_index from BUFFER and fills
3442 in MAP. FILENAME is the name of the file containing the data;
3443 it is used for error reporting. DEPRECATED_OK is true if it is
3444 ok to use deprecated sections.
3446 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3447 out parameters that are filled in with information about the CU and
3448 TU lists in the section.
3450 Returns true if all went well, false otherwise. */
3453 read_gdb_index_from_buffer (struct objfile
*objfile
,
3454 const char *filename
,
3456 gdb::array_view
<const gdb_byte
> buffer
,
3457 struct mapped_index
*map
,
3458 const gdb_byte
**cu_list
,
3459 offset_type
*cu_list_elements
,
3460 const gdb_byte
**types_list
,
3461 offset_type
*types_list_elements
)
3463 const gdb_byte
*addr
= &buffer
[0];
3465 /* Version check. */
3466 offset_type version
= MAYBE_SWAP (*(offset_type
*) addr
);
3467 /* Versions earlier than 3 emitted every copy of a psymbol. This
3468 causes the index to behave very poorly for certain requests. Version 3
3469 contained incomplete addrmap. So, it seems better to just ignore such
3473 static int warning_printed
= 0;
3474 if (!warning_printed
)
3476 warning (_("Skipping obsolete .gdb_index section in %s."),
3478 warning_printed
= 1;
3482 /* Index version 4 uses a different hash function than index version
3485 Versions earlier than 6 did not emit psymbols for inlined
3486 functions. Using these files will cause GDB not to be able to
3487 set breakpoints on inlined functions by name, so we ignore these
3488 indices unless the user has done
3489 "set use-deprecated-index-sections on". */
3490 if (version
< 6 && !deprecated_ok
)
3492 static int warning_printed
= 0;
3493 if (!warning_printed
)
3496 Skipping deprecated .gdb_index section in %s.\n\
3497 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3498 to use the section anyway."),
3500 warning_printed
= 1;
3504 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3505 of the TU (for symbols coming from TUs),
3506 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3507 Plus gold-generated indices can have duplicate entries for global symbols,
3508 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3509 These are just performance bugs, and we can't distinguish gdb-generated
3510 indices from gold-generated ones, so issue no warning here. */
3512 /* Indexes with higher version than the one supported by GDB may be no
3513 longer backward compatible. */
3517 map
->version
= version
;
3519 offset_type
*metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3522 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3523 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3527 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3528 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3529 - MAYBE_SWAP (metadata
[i
]))
3533 const gdb_byte
*address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3534 const gdb_byte
*address_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3536 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
3539 const gdb_byte
*symbol_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3540 const gdb_byte
*symbol_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3542 = gdb::array_view
<mapped_index::symbol_table_slot
>
3543 ((mapped_index::symbol_table_slot
*) symbol_table
,
3544 (mapped_index::symbol_table_slot
*) symbol_table_end
);
3547 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3552 /* Callback types for dwarf2_read_gdb_index. */
3554 typedef gdb::function_view
3555 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_objfile
*)>
3556 get_gdb_index_contents_ftype
;
3557 typedef gdb::function_view
3558 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
3559 get_gdb_index_contents_dwz_ftype
;
3561 /* Read .gdb_index. If everything went ok, initialize the "quick"
3562 elements of all the CUs and return 1. Otherwise, return 0. */
3565 dwarf2_read_gdb_index
3566 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3567 get_gdb_index_contents_ftype get_gdb_index_contents
,
3568 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
3570 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3571 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3572 struct dwz_file
*dwz
;
3573 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3575 gdb::array_view
<const gdb_byte
> main_index_contents
3576 = get_gdb_index_contents (objfile
, dwarf2_per_objfile
);
3578 if (main_index_contents
.empty ())
3581 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
3582 if (!read_gdb_index_from_buffer (objfile
, objfile_name (objfile
),
3583 use_deprecated_index_sections
,
3584 main_index_contents
, map
.get (), &cu_list
,
3585 &cu_list_elements
, &types_list
,
3586 &types_list_elements
))
3589 /* Don't use the index if it's empty. */
3590 if (map
->symbol_table
.empty ())
3593 /* If there is a .dwz file, read it so we can get its CU list as
3595 dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
3598 struct mapped_index dwz_map
;
3599 const gdb_byte
*dwz_types_ignore
;
3600 offset_type dwz_types_elements_ignore
;
3602 gdb::array_view
<const gdb_byte
> dwz_index_content
3603 = get_gdb_index_contents_dwz (objfile
, dwz
);
3605 if (dwz_index_content
.empty ())
3608 if (!read_gdb_index_from_buffer (objfile
,
3609 bfd_get_filename (dwz
->dwz_bfd
.get ()),
3610 1, dwz_index_content
, &dwz_map
,
3611 &dwz_list
, &dwz_list_elements
,
3613 &dwz_types_elements_ignore
))
3615 warning (_("could not read '.gdb_index' section from %s; skipping"),
3616 bfd_get_filename (dwz
->dwz_bfd
.get ()));
3621 create_cus_from_index (dwarf2_per_objfile
, cu_list
, cu_list_elements
,
3622 dwz_list
, dwz_list_elements
);
3624 if (types_list_elements
)
3626 /* We can only handle a single .debug_types when we have an
3628 if (dwarf2_per_objfile
->types
.size () != 1)
3631 dwarf2_section_info
*section
= &dwarf2_per_objfile
->types
[0];
3633 create_signatured_type_table_from_index (dwarf2_per_objfile
, section
,
3634 types_list
, types_list_elements
);
3637 create_addrmap_from_index (dwarf2_per_objfile
, map
.get ());
3639 dwarf2_per_objfile
->index_table
= std::move (map
);
3640 dwarf2_per_objfile
->using_index
= 1;
3641 dwarf2_per_objfile
->quick_file_names_table
=
3642 create_quick_file_names_table (dwarf2_per_objfile
->all_comp_units
.size ());
3647 /* die_reader_func for dw2_get_file_names. */
3650 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3651 const gdb_byte
*info_ptr
,
3652 struct die_info
*comp_unit_die
,
3656 struct dwarf2_cu
*cu
= reader
->cu
;
3657 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3658 struct dwarf2_per_objfile
*dwarf2_per_objfile
3659 = cu
->per_cu
->dwarf2_per_objfile
;
3660 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3661 struct dwarf2_per_cu_data
*lh_cu
;
3662 struct attribute
*attr
;
3664 struct quick_file_names
*qfn
;
3666 gdb_assert (! this_cu
->is_debug_types
);
3668 /* Our callers never want to match partial units -- instead they
3669 will match the enclosing full CU. */
3670 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3672 this_cu
->v
.quick
->no_file_data
= 1;
3680 sect_offset line_offset
{};
3682 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3683 if (attr
!= nullptr)
3685 struct quick_file_names find_entry
;
3687 line_offset
= (sect_offset
) DW_UNSND (attr
);
3689 /* We may have already read in this line header (TU line header sharing).
3690 If we have we're done. */
3691 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3692 find_entry
.hash
.line_sect_off
= line_offset
;
3693 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
3694 &find_entry
, INSERT
);
3697 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3701 lh
= dwarf_decode_line_header (line_offset
, cu
);
3705 lh_cu
->v
.quick
->no_file_data
= 1;
3709 qfn
= XOBNEW (&objfile
->objfile_obstack
, struct quick_file_names
);
3710 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3711 qfn
->hash
.line_sect_off
= line_offset
;
3712 gdb_assert (slot
!= NULL
);
3715 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3718 if (strcmp (fnd
.name
, "<unknown>") != 0)
3721 qfn
->num_file_names
= offset
+ lh
->file_names_size ();
3723 XOBNEWVEC (&objfile
->objfile_obstack
, const char *, qfn
->num_file_names
);
3725 qfn
->file_names
[0] = xstrdup (fnd
.name
);
3726 for (int i
= 0; i
< lh
->file_names_size (); ++i
)
3727 qfn
->file_names
[i
+ offset
] = file_full_name (i
+ 1, lh
.get (), fnd
.comp_dir
);
3728 qfn
->real_names
= NULL
;
3730 lh_cu
->v
.quick
->file_names
= qfn
;
3733 /* A helper for the "quick" functions which attempts to read the line
3734 table for THIS_CU. */
3736 static struct quick_file_names
*
3737 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
3739 /* This should never be called for TUs. */
3740 gdb_assert (! this_cu
->is_debug_types
);
3741 /* Nor type unit groups. */
3742 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
3744 if (this_cu
->v
.quick
->file_names
!= NULL
)
3745 return this_cu
->v
.quick
->file_names
;
3746 /* If we know there is no line data, no point in looking again. */
3747 if (this_cu
->v
.quick
->no_file_data
)
3750 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
3752 if (this_cu
->v
.quick
->no_file_data
)
3754 return this_cu
->v
.quick
->file_names
;
3757 /* A helper for the "quick" functions which computes and caches the
3758 real path for a given file name from the line table. */
3761 dw2_get_real_path (struct objfile
*objfile
,
3762 struct quick_file_names
*qfn
, int index
)
3764 if (qfn
->real_names
== NULL
)
3765 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3766 qfn
->num_file_names
, const char *);
3768 if (qfn
->real_names
[index
] == NULL
)
3769 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3771 return qfn
->real_names
[index
];
3774 static struct symtab
*
3775 dw2_find_last_source_symtab (struct objfile
*objfile
)
3777 struct dwarf2_per_objfile
*dwarf2_per_objfile
3778 = get_dwarf2_per_objfile (objfile
);
3779 dwarf2_per_cu_data
*dwarf_cu
= dwarf2_per_objfile
->all_comp_units
.back ();
3780 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, false);
3785 return compunit_primary_filetab (cust
);
3788 /* Traversal function for dw2_forget_cached_source_info. */
3791 dw2_free_cached_file_names (void **slot
, void *info
)
3793 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3795 if (file_data
->real_names
)
3799 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3801 xfree ((void*) file_data
->real_names
[i
]);
3802 file_data
->real_names
[i
] = NULL
;
3810 dw2_forget_cached_source_info (struct objfile
*objfile
)
3812 struct dwarf2_per_objfile
*dwarf2_per_objfile
3813 = get_dwarf2_per_objfile (objfile
);
3815 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
3816 dw2_free_cached_file_names
, NULL
);
3819 /* Helper function for dw2_map_symtabs_matching_filename that expands
3820 the symtabs and calls the iterator. */
3823 dw2_map_expand_apply (struct objfile
*objfile
,
3824 struct dwarf2_per_cu_data
*per_cu
,
3825 const char *name
, const char *real_path
,
3826 gdb::function_view
<bool (symtab
*)> callback
)
3828 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3830 /* Don't visit already-expanded CUs. */
3831 if (per_cu
->v
.quick
->compunit_symtab
)
3834 /* This may expand more than one symtab, and we want to iterate over
3836 dw2_instantiate_symtab (per_cu
, false);
3838 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
3839 last_made
, callback
);
3842 /* Implementation of the map_symtabs_matching_filename method. */
3845 dw2_map_symtabs_matching_filename
3846 (struct objfile
*objfile
, const char *name
, const char *real_path
,
3847 gdb::function_view
<bool (symtab
*)> callback
)
3849 const char *name_basename
= lbasename (name
);
3850 struct dwarf2_per_objfile
*dwarf2_per_objfile
3851 = get_dwarf2_per_objfile (objfile
);
3853 /* The rule is CUs specify all the files, including those used by
3854 any TU, so there's no need to scan TUs here. */
3856 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
3858 /* We only need to look at symtabs not already expanded. */
3859 if (per_cu
->v
.quick
->compunit_symtab
)
3862 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
3863 if (file_data
== NULL
)
3866 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3868 const char *this_name
= file_data
->file_names
[j
];
3869 const char *this_real_name
;
3871 if (compare_filenames_for_search (this_name
, name
))
3873 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3879 /* Before we invoke realpath, which can get expensive when many
3880 files are involved, do a quick comparison of the basenames. */
3881 if (! basenames_may_differ
3882 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3885 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3886 if (compare_filenames_for_search (this_real_name
, name
))
3888 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3894 if (real_path
!= NULL
)
3896 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3897 gdb_assert (IS_ABSOLUTE_PATH (name
));
3898 if (this_real_name
!= NULL
3899 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3901 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3913 /* Struct used to manage iterating over all CUs looking for a symbol. */
3915 struct dw2_symtab_iterator
3917 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3918 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
3919 /* If set, only look for symbols that match that block. Valid values are
3920 GLOBAL_BLOCK and STATIC_BLOCK. */
3921 gdb::optional
<block_enum
> block_index
;
3922 /* The kind of symbol we're looking for. */
3924 /* The list of CUs from the index entry of the symbol,
3925 or NULL if not found. */
3927 /* The next element in VEC to look at. */
3929 /* The number of elements in VEC, or zero if there is no match. */
3931 /* Have we seen a global version of the symbol?
3932 If so we can ignore all further global instances.
3933 This is to work around gold/15646, inefficient gold-generated
3938 /* Initialize the index symtab iterator ITER. */
3941 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3942 struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3943 gdb::optional
<block_enum
> block_index
,
3947 iter
->dwarf2_per_objfile
= dwarf2_per_objfile
;
3948 iter
->block_index
= block_index
;
3949 iter
->domain
= domain
;
3951 iter
->global_seen
= 0;
3953 mapped_index
*index
= dwarf2_per_objfile
->index_table
.get ();
3955 /* index is NULL if OBJF_READNOW. */
3956 if (index
!= NULL
&& find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3957 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3965 /* Return the next matching CU or NULL if there are no more. */
3967 static struct dwarf2_per_cu_data
*
3968 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3970 struct dwarf2_per_objfile
*dwarf2_per_objfile
= iter
->dwarf2_per_objfile
;
3972 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3974 offset_type cu_index_and_attrs
=
3975 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3976 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3977 gdb_index_symbol_kind symbol_kind
=
3978 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3979 /* Only check the symbol attributes if they're present.
3980 Indices prior to version 7 don't record them,
3981 and indices >= 7 may elide them for certain symbols
3982 (gold does this). */
3984 (dwarf2_per_objfile
->index_table
->version
>= 7
3985 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3987 /* Don't crash on bad data. */
3988 if (cu_index
>= (dwarf2_per_objfile
->all_comp_units
.size ()
3989 + dwarf2_per_objfile
->all_type_units
.size ()))
3991 complaint (_(".gdb_index entry has bad CU index"
3993 objfile_name (dwarf2_per_objfile
->objfile
));
3997 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (cu_index
);
3999 /* Skip if already read in. */
4000 if (per_cu
->v
.quick
->compunit_symtab
)
4003 /* Check static vs global. */
4006 bool is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
4008 if (iter
->block_index
.has_value ())
4010 bool want_static
= *iter
->block_index
== STATIC_BLOCK
;
4012 if (is_static
!= want_static
)
4016 /* Work around gold/15646. */
4017 if (!is_static
&& iter
->global_seen
)
4020 iter
->global_seen
= 1;
4023 /* Only check the symbol's kind if it has one. */
4026 switch (iter
->domain
)
4029 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
4030 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
4031 /* Some types are also in VAR_DOMAIN. */
4032 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4036 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4040 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4044 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4059 static struct compunit_symtab
*
4060 dw2_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
4061 const char *name
, domain_enum domain
)
4063 struct compunit_symtab
*stab_best
= NULL
;
4064 struct dwarf2_per_objfile
*dwarf2_per_objfile
4065 = get_dwarf2_per_objfile (objfile
);
4067 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
4069 struct dw2_symtab_iterator iter
;
4070 struct dwarf2_per_cu_data
*per_cu
;
4072 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, block_index
, domain
, name
);
4074 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
4076 struct symbol
*sym
, *with_opaque
= NULL
;
4077 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
, false);
4078 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
4079 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
4081 sym
= block_find_symbol (block
, name
, domain
,
4082 block_find_non_opaque_type_preferred
,
4085 /* Some caution must be observed with overloaded functions
4086 and methods, since the index will not contain any overload
4087 information (but NAME might contain it). */
4090 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
4092 if (with_opaque
!= NULL
4093 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
4096 /* Keep looking through other CUs. */
4103 dw2_print_stats (struct objfile
*objfile
)
4105 struct dwarf2_per_objfile
*dwarf2_per_objfile
4106 = get_dwarf2_per_objfile (objfile
);
4107 int total
= (dwarf2_per_objfile
->all_comp_units
.size ()
4108 + dwarf2_per_objfile
->all_type_units
.size ());
4111 for (int i
= 0; i
< total
; ++i
)
4113 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
4115 if (!per_cu
->v
.quick
->compunit_symtab
)
4118 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
4119 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
4122 /* This dumps minimal information about the index.
4123 It is called via "mt print objfiles".
4124 One use is to verify .gdb_index has been loaded by the
4125 gdb.dwarf2/gdb-index.exp testcase. */
4128 dw2_dump (struct objfile
*objfile
)
4130 struct dwarf2_per_objfile
*dwarf2_per_objfile
4131 = get_dwarf2_per_objfile (objfile
);
4133 gdb_assert (dwarf2_per_objfile
->using_index
);
4134 printf_filtered (".gdb_index:");
4135 if (dwarf2_per_objfile
->index_table
!= NULL
)
4137 printf_filtered (" version %d\n",
4138 dwarf2_per_objfile
->index_table
->version
);
4141 printf_filtered (" faked for \"readnow\"\n");
4142 printf_filtered ("\n");
4146 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
4147 const char *func_name
)
4149 struct dwarf2_per_objfile
*dwarf2_per_objfile
4150 = get_dwarf2_per_objfile (objfile
);
4152 struct dw2_symtab_iterator iter
;
4153 struct dwarf2_per_cu_data
*per_cu
;
4155 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, {}, VAR_DOMAIN
, func_name
);
4157 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
4158 dw2_instantiate_symtab (per_cu
, false);
4163 dw2_expand_all_symtabs (struct objfile
*objfile
)
4165 struct dwarf2_per_objfile
*dwarf2_per_objfile
4166 = get_dwarf2_per_objfile (objfile
);
4167 int total_units
= (dwarf2_per_objfile
->all_comp_units
.size ()
4168 + dwarf2_per_objfile
->all_type_units
.size ());
4170 for (int i
= 0; i
< total_units
; ++i
)
4172 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
4174 /* We don't want to directly expand a partial CU, because if we
4175 read it with the wrong language, then assertion failures can
4176 be triggered later on. See PR symtab/23010. So, tell
4177 dw2_instantiate_symtab to skip partial CUs -- any important
4178 partial CU will be read via DW_TAG_imported_unit anyway. */
4179 dw2_instantiate_symtab (per_cu
, true);
4184 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
4185 const char *fullname
)
4187 struct dwarf2_per_objfile
*dwarf2_per_objfile
4188 = get_dwarf2_per_objfile (objfile
);
4190 /* We don't need to consider type units here.
4191 This is only called for examining code, e.g. expand_line_sal.
4192 There can be an order of magnitude (or more) more type units
4193 than comp units, and we avoid them if we can. */
4195 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
4197 /* We only need to look at symtabs not already expanded. */
4198 if (per_cu
->v
.quick
->compunit_symtab
)
4201 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
4202 if (file_data
== NULL
)
4205 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4207 const char *this_fullname
= file_data
->file_names
[j
];
4209 if (filename_cmp (this_fullname
, fullname
) == 0)
4211 dw2_instantiate_symtab (per_cu
, false);
4219 dw2_map_matching_symbols
4220 (struct objfile
*objfile
,
4221 const lookup_name_info
&name
, domain_enum domain
,
4223 gdb::function_view
<symbol_found_callback_ftype
> callback
,
4224 symbol_compare_ftype
*ordered_compare
)
4226 /* Currently unimplemented; used for Ada. The function can be called if the
4227 current language is Ada for a non-Ada objfile using GNU index. As Ada
4228 does not look for non-Ada symbols this function should just return. */
4231 /* Starting from a search name, return the string that finds the upper
4232 bound of all strings that start with SEARCH_NAME in a sorted name
4233 list. Returns the empty string to indicate that the upper bound is
4234 the end of the list. */
4237 make_sort_after_prefix_name (const char *search_name
)
4239 /* When looking to complete "func", we find the upper bound of all
4240 symbols that start with "func" by looking for where we'd insert
4241 the closest string that would follow "func" in lexicographical
4242 order. Usually, that's "func"-with-last-character-incremented,
4243 i.e. "fund". Mind non-ASCII characters, though. Usually those
4244 will be UTF-8 multi-byte sequences, but we can't be certain.
4245 Especially mind the 0xff character, which is a valid character in
4246 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4247 rule out compilers allowing it in identifiers. Note that
4248 conveniently, strcmp/strcasecmp are specified to compare
4249 characters interpreted as unsigned char. So what we do is treat
4250 the whole string as a base 256 number composed of a sequence of
4251 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4252 to 0, and carries 1 to the following more-significant position.
4253 If the very first character in SEARCH_NAME ends up incremented
4254 and carries/overflows, then the upper bound is the end of the
4255 list. The string after the empty string is also the empty
4258 Some examples of this operation:
4260 SEARCH_NAME => "+1" RESULT
4264 "\xff" "a" "\xff" => "\xff" "b"
4269 Then, with these symbols for example:
4275 completing "func" looks for symbols between "func" and
4276 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4277 which finds "func" and "func1", but not "fund".
4281 funcÿ (Latin1 'ÿ' [0xff])
4285 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4286 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4290 ÿÿ (Latin1 'ÿ' [0xff])
4293 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4294 the end of the list.
4296 std::string after
= search_name
;
4297 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
4299 if (!after
.empty ())
4300 after
.back () = (unsigned char) after
.back () + 1;
4304 /* See declaration. */
4306 std::pair
<std::vector
<name_component
>::const_iterator
,
4307 std::vector
<name_component
>::const_iterator
>
4308 mapped_index_base::find_name_components_bounds
4309 (const lookup_name_info
&lookup_name_without_params
, language lang
) const
4312 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4314 const char *lang_name
4315 = lookup_name_without_params
.language_lookup_name (lang
).c_str ();
4317 /* Comparison function object for lower_bound that matches against a
4318 given symbol name. */
4319 auto lookup_compare_lower
= [&] (const name_component
&elem
,
4322 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4323 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4324 return name_cmp (elem_name
, name
) < 0;
4327 /* Comparison function object for upper_bound that matches against a
4328 given symbol name. */
4329 auto lookup_compare_upper
= [&] (const char *name
,
4330 const name_component
&elem
)
4332 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4333 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4334 return name_cmp (name
, elem_name
) < 0;
4337 auto begin
= this->name_components
.begin ();
4338 auto end
= this->name_components
.end ();
4340 /* Find the lower bound. */
4343 if (lookup_name_without_params
.completion_mode () && lang_name
[0] == '\0')
4346 return std::lower_bound (begin
, end
, lang_name
, lookup_compare_lower
);
4349 /* Find the upper bound. */
4352 if (lookup_name_without_params
.completion_mode ())
4354 /* In completion mode, we want UPPER to point past all
4355 symbols names that have the same prefix. I.e., with
4356 these symbols, and completing "func":
4358 function << lower bound
4360 other_function << upper bound
4362 We find the upper bound by looking for the insertion
4363 point of "func"-with-last-character-incremented,
4365 std::string after
= make_sort_after_prefix_name (lang_name
);
4368 return std::lower_bound (lower
, end
, after
.c_str (),
4369 lookup_compare_lower
);
4372 return std::upper_bound (lower
, end
, lang_name
, lookup_compare_upper
);
4375 return {lower
, upper
};
4378 /* See declaration. */
4381 mapped_index_base::build_name_components ()
4383 if (!this->name_components
.empty ())
4386 this->name_components_casing
= case_sensitivity
;
4388 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4390 /* The code below only knows how to break apart components of C++
4391 symbol names (and other languages that use '::' as
4392 namespace/module separator) and Ada symbol names. */
4393 auto count
= this->symbol_name_count ();
4394 for (offset_type idx
= 0; idx
< count
; idx
++)
4396 if (this->symbol_name_slot_invalid (idx
))
4399 const char *name
= this->symbol_name_at (idx
);
4401 /* Add each name component to the name component table. */
4402 unsigned int previous_len
= 0;
4404 if (strstr (name
, "::") != nullptr)
4406 for (unsigned int current_len
= cp_find_first_component (name
);
4407 name
[current_len
] != '\0';
4408 current_len
+= cp_find_first_component (name
+ current_len
))
4410 gdb_assert (name
[current_len
] == ':');
4411 this->name_components
.push_back ({previous_len
, idx
});
4412 /* Skip the '::'. */
4414 previous_len
= current_len
;
4419 /* Handle the Ada encoded (aka mangled) form here. */
4420 for (const char *iter
= strstr (name
, "__");
4422 iter
= strstr (iter
, "__"))
4424 this->name_components
.push_back ({previous_len
, idx
});
4426 previous_len
= iter
- name
;
4430 this->name_components
.push_back ({previous_len
, idx
});
4433 /* Sort name_components elements by name. */
4434 auto name_comp_compare
= [&] (const name_component
&left
,
4435 const name_component
&right
)
4437 const char *left_qualified
= this->symbol_name_at (left
.idx
);
4438 const char *right_qualified
= this->symbol_name_at (right
.idx
);
4440 const char *left_name
= left_qualified
+ left
.name_offset
;
4441 const char *right_name
= right_qualified
+ right
.name_offset
;
4443 return name_cmp (left_name
, right_name
) < 0;
4446 std::sort (this->name_components
.begin (),
4447 this->name_components
.end (),
4451 /* Helper for dw2_expand_symtabs_matching that works with a
4452 mapped_index_base instead of the containing objfile. This is split
4453 to a separate function in order to be able to unit test the
4454 name_components matching using a mock mapped_index_base. For each
4455 symbol name that matches, calls MATCH_CALLBACK, passing it the
4456 symbol's index in the mapped_index_base symbol table. */
4459 dw2_expand_symtabs_matching_symbol
4460 (mapped_index_base
&index
,
4461 const lookup_name_info
&lookup_name_in
,
4462 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4463 enum search_domain kind
,
4464 gdb::function_view
<bool (offset_type
)> match_callback
)
4466 lookup_name_info lookup_name_without_params
4467 = lookup_name_in
.make_ignore_params ();
4469 /* Build the symbol name component sorted vector, if we haven't
4471 index
.build_name_components ();
4473 /* The same symbol may appear more than once in the range though.
4474 E.g., if we're looking for symbols that complete "w", and we have
4475 a symbol named "w1::w2", we'll find the two name components for
4476 that same symbol in the range. To be sure we only call the
4477 callback once per symbol, we first collect the symbol name
4478 indexes that matched in a temporary vector and ignore
4480 std::vector
<offset_type
> matches
;
4482 struct name_and_matcher
4484 symbol_name_matcher_ftype
*matcher
;
4485 const std::string
&name
;
4487 bool operator== (const name_and_matcher
&other
) const
4489 return matcher
== other
.matcher
&& name
== other
.name
;
4493 /* A vector holding all the different symbol name matchers, for all
4495 std::vector
<name_and_matcher
> matchers
;
4497 for (int i
= 0; i
< nr_languages
; i
++)
4499 enum language lang_e
= (enum language
) i
;
4501 const language_defn
*lang
= language_def (lang_e
);
4502 symbol_name_matcher_ftype
*name_matcher
4503 = get_symbol_name_matcher (lang
, lookup_name_without_params
);
4505 name_and_matcher key
{
4507 lookup_name_without_params
.language_lookup_name (lang_e
)
4510 /* Don't insert the same comparison routine more than once.
4511 Note that we do this linear walk. This is not a problem in
4512 practice because the number of supported languages is
4514 if (std::find (matchers
.begin (), matchers
.end (), key
)
4517 matchers
.push_back (std::move (key
));
4520 = index
.find_name_components_bounds (lookup_name_without_params
,
4523 /* Now for each symbol name in range, check to see if we have a name
4524 match, and if so, call the MATCH_CALLBACK callback. */
4526 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
4528 const char *qualified
= index
.symbol_name_at (bounds
.first
->idx
);
4530 if (!name_matcher (qualified
, lookup_name_without_params
, NULL
)
4531 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
4534 matches
.push_back (bounds
.first
->idx
);
4538 std::sort (matches
.begin (), matches
.end ());
4540 /* Finally call the callback, once per match. */
4542 for (offset_type idx
: matches
)
4546 if (!match_callback (idx
))
4552 /* Above we use a type wider than idx's for 'prev', since 0 and
4553 (offset_type)-1 are both possible values. */
4554 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
4559 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
4561 /* A mock .gdb_index/.debug_names-like name index table, enough to
4562 exercise dw2_expand_symtabs_matching_symbol, which works with the
4563 mapped_index_base interface. Builds an index from the symbol list
4564 passed as parameter to the constructor. */
4565 class mock_mapped_index
: public mapped_index_base
4568 mock_mapped_index (gdb::array_view
<const char *> symbols
)
4569 : m_symbol_table (symbols
)
4572 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
4574 /* Return the number of names in the symbol table. */
4575 size_t symbol_name_count () const override
4577 return m_symbol_table
.size ();
4580 /* Get the name of the symbol at IDX in the symbol table. */
4581 const char *symbol_name_at (offset_type idx
) const override
4583 return m_symbol_table
[idx
];
4587 gdb::array_view
<const char *> m_symbol_table
;
4590 /* Convenience function that converts a NULL pointer to a "<null>"
4591 string, to pass to print routines. */
4594 string_or_null (const char *str
)
4596 return str
!= NULL
? str
: "<null>";
4599 /* Check if a lookup_name_info built from
4600 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4601 index. EXPECTED_LIST is the list of expected matches, in expected
4602 matching order. If no match expected, then an empty list is
4603 specified. Returns true on success. On failure prints a warning
4604 indicating the file:line that failed, and returns false. */
4607 check_match (const char *file
, int line
,
4608 mock_mapped_index
&mock_index
,
4609 const char *name
, symbol_name_match_type match_type
,
4610 bool completion_mode
,
4611 std::initializer_list
<const char *> expected_list
)
4613 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4615 bool matched
= true;
4617 auto mismatch
= [&] (const char *expected_str
,
4620 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4621 "expected=\"%s\", got=\"%s\"\n"),
4623 (match_type
== symbol_name_match_type::FULL
4625 name
, string_or_null (expected_str
), string_or_null (got
));
4629 auto expected_it
= expected_list
.begin ();
4630 auto expected_end
= expected_list
.end ();
4632 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
4634 [&] (offset_type idx
)
4636 const char *matched_name
= mock_index
.symbol_name_at (idx
);
4637 const char *expected_str
4638 = expected_it
== expected_end
? NULL
: *expected_it
++;
4640 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4641 mismatch (expected_str
, matched_name
);
4645 const char *expected_str
4646 = expected_it
== expected_end
? NULL
: *expected_it
++;
4647 if (expected_str
!= NULL
)
4648 mismatch (expected_str
, NULL
);
4653 /* The symbols added to the mock mapped_index for testing (in
4655 static const char *test_symbols
[] = {
4664 "ns2::tmpl<int>::foo2",
4665 "(anonymous namespace)::A::B::C",
4667 /* These are used to check that the increment-last-char in the
4668 matching algorithm for completion doesn't match "t1_fund" when
4669 completing "t1_func". */
4675 /* A UTF-8 name with multi-byte sequences to make sure that
4676 cp-name-parser understands this as a single identifier ("função"
4677 is "function" in PT). */
4680 /* \377 (0xff) is Latin1 'ÿ'. */
4683 /* \377 (0xff) is Latin1 'ÿ'. */
4687 /* A name with all sorts of complications. Starts with "z" to make
4688 it easier for the completion tests below. */
4689 #define Z_SYM_NAME \
4690 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4691 "::tuple<(anonymous namespace)::ui*, " \
4692 "std::default_delete<(anonymous namespace)::ui>, void>"
4697 /* Returns true if the mapped_index_base::find_name_component_bounds
4698 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4699 in completion mode. */
4702 check_find_bounds_finds (mapped_index_base
&index
,
4703 const char *search_name
,
4704 gdb::array_view
<const char *> expected_syms
)
4706 lookup_name_info
lookup_name (search_name
,
4707 symbol_name_match_type::FULL
, true);
4709 auto bounds
= index
.find_name_components_bounds (lookup_name
,
4712 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
4713 if (distance
!= expected_syms
.size ())
4716 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
4718 auto nc_elem
= bounds
.first
+ exp_elem
;
4719 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
);
4720 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
4727 /* Test the lower-level mapped_index::find_name_component_bounds
4731 test_mapped_index_find_name_component_bounds ()
4733 mock_mapped_index
mock_index (test_symbols
);
4735 mock_index
.build_name_components ();
4737 /* Test the lower-level mapped_index::find_name_component_bounds
4738 method in completion mode. */
4740 static const char *expected_syms
[] = {
4745 SELF_CHECK (check_find_bounds_finds (mock_index
,
4746 "t1_func", expected_syms
));
4749 /* Check that the increment-last-char in the name matching algorithm
4750 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4752 static const char *expected_syms1
[] = {
4756 SELF_CHECK (check_find_bounds_finds (mock_index
,
4757 "\377", expected_syms1
));
4759 static const char *expected_syms2
[] = {
4762 SELF_CHECK (check_find_bounds_finds (mock_index
,
4763 "\377\377", expected_syms2
));
4767 /* Test dw2_expand_symtabs_matching_symbol. */
4770 test_dw2_expand_symtabs_matching_symbol ()
4772 mock_mapped_index
mock_index (test_symbols
);
4774 /* We let all tests run until the end even if some fails, for debug
4776 bool any_mismatch
= false;
4778 /* Create the expected symbols list (an initializer_list). Needed
4779 because lists have commas, and we need to pass them to CHECK,
4780 which is a macro. */
4781 #define EXPECT(...) { __VA_ARGS__ }
4783 /* Wrapper for check_match that passes down the current
4784 __FILE__/__LINE__. */
4785 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4786 any_mismatch |= !check_match (__FILE__, __LINE__, \
4788 NAME, MATCH_TYPE, COMPLETION_MODE, \
4791 /* Identity checks. */
4792 for (const char *sym
: test_symbols
)
4794 /* Should be able to match all existing symbols. */
4795 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4798 /* Should be able to match all existing symbols with
4800 std::string with_params
= std::string (sym
) + "(int)";
4801 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4804 /* Should be able to match all existing symbols with
4805 parameters and qualifiers. */
4806 with_params
= std::string (sym
) + " ( int ) const";
4807 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4810 /* This should really find sym, but cp-name-parser.y doesn't
4811 know about lvalue/rvalue qualifiers yet. */
4812 with_params
= std::string (sym
) + " ( int ) &&";
4813 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4817 /* Check that the name matching algorithm for completion doesn't get
4818 confused with Latin1 'ÿ' / 0xff. */
4820 static const char str
[] = "\377";
4821 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4822 EXPECT ("\377", "\377\377123"));
4825 /* Check that the increment-last-char in the matching algorithm for
4826 completion doesn't match "t1_fund" when completing "t1_func". */
4828 static const char str
[] = "t1_func";
4829 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4830 EXPECT ("t1_func", "t1_func1"));
4833 /* Check that completion mode works at each prefix of the expected
4836 static const char str
[] = "function(int)";
4837 size_t len
= strlen (str
);
4840 for (size_t i
= 1; i
< len
; i
++)
4842 lookup
.assign (str
, i
);
4843 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4844 EXPECT ("function"));
4848 /* While "w" is a prefix of both components, the match function
4849 should still only be called once. */
4851 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4853 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4857 /* Same, with a "complicated" symbol. */
4859 static const char str
[] = Z_SYM_NAME
;
4860 size_t len
= strlen (str
);
4863 for (size_t i
= 1; i
< len
; i
++)
4865 lookup
.assign (str
, i
);
4866 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4867 EXPECT (Z_SYM_NAME
));
4871 /* In FULL mode, an incomplete symbol doesn't match. */
4873 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4877 /* A complete symbol with parameters matches any overload, since the
4878 index has no overload info. */
4880 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4881 EXPECT ("std::zfunction", "std::zfunction2"));
4882 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4883 EXPECT ("std::zfunction", "std::zfunction2"));
4884 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4885 EXPECT ("std::zfunction", "std::zfunction2"));
4888 /* Check that whitespace is ignored appropriately. A symbol with a
4889 template argument list. */
4891 static const char expected
[] = "ns::foo<int>";
4892 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4894 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4898 /* Check that whitespace is ignored appropriately. A symbol with a
4899 template argument list that includes a pointer. */
4901 static const char expected
[] = "ns::foo<char*>";
4902 /* Try both completion and non-completion modes. */
4903 static const bool completion_mode
[2] = {false, true};
4904 for (size_t i
= 0; i
< 2; i
++)
4906 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4907 completion_mode
[i
], EXPECT (expected
));
4908 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4909 completion_mode
[i
], EXPECT (expected
));
4911 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4912 completion_mode
[i
], EXPECT (expected
));
4913 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4914 completion_mode
[i
], EXPECT (expected
));
4919 /* Check method qualifiers are ignored. */
4920 static const char expected
[] = "ns::foo<char*>";
4921 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4922 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4923 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4924 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4925 CHECK_MATCH ("foo < char * > ( int ) const",
4926 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4927 CHECK_MATCH ("foo < char * > ( int ) &&",
4928 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4931 /* Test lookup names that don't match anything. */
4933 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4936 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4940 /* Some wild matching tests, exercising "(anonymous namespace)",
4941 which should not be confused with a parameter list. */
4943 static const char *syms
[] = {
4947 "A :: B :: C ( int )",
4952 for (const char *s
: syms
)
4954 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4955 EXPECT ("(anonymous namespace)::A::B::C"));
4960 static const char expected
[] = "ns2::tmpl<int>::foo2";
4961 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4963 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4967 SELF_CHECK (!any_mismatch
);
4976 test_mapped_index_find_name_component_bounds ();
4977 test_dw2_expand_symtabs_matching_symbol ();
4980 }} // namespace selftests::dw2_expand_symtabs_matching
4982 #endif /* GDB_SELF_TEST */
4984 /* If FILE_MATCHER is NULL or if PER_CU has
4985 dwarf2_per_cu_quick_data::MARK set (see
4986 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4987 EXPANSION_NOTIFY on it. */
4990 dw2_expand_symtabs_matching_one
4991 (struct dwarf2_per_cu_data
*per_cu
,
4992 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4993 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4995 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4997 bool symtab_was_null
4998 = (per_cu
->v
.quick
->compunit_symtab
== NULL
);
5000 dw2_instantiate_symtab (per_cu
, false);
5002 if (expansion_notify
!= NULL
5004 && per_cu
->v
.quick
->compunit_symtab
!= NULL
)
5005 expansion_notify (per_cu
->v
.quick
->compunit_symtab
);
5009 /* Helper for dw2_expand_matching symtabs. Called on each symbol
5010 matched, to expand corresponding CUs that were marked. IDX is the
5011 index of the symbol name that matched. */
5014 dw2_expand_marked_cus
5015 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, offset_type idx
,
5016 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5017 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5020 offset_type
*vec
, vec_len
, vec_idx
;
5021 bool global_seen
= false;
5022 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
5024 vec
= (offset_type
*) (index
.constant_pool
5025 + MAYBE_SWAP (index
.symbol_table
[idx
].vec
));
5026 vec_len
= MAYBE_SWAP (vec
[0]);
5027 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
5029 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
5030 /* This value is only valid for index versions >= 7. */
5031 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
5032 gdb_index_symbol_kind symbol_kind
=
5033 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
5034 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
5035 /* Only check the symbol attributes if they're present.
5036 Indices prior to version 7 don't record them,
5037 and indices >= 7 may elide them for certain symbols
5038 (gold does this). */
5041 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
5043 /* Work around gold/15646. */
5046 if (!is_static
&& global_seen
)
5052 /* Only check the symbol's kind if it has one. */
5057 case VARIABLES_DOMAIN
:
5058 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
5061 case FUNCTIONS_DOMAIN
:
5062 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
5066 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
5069 case MODULES_DOMAIN
:
5070 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
5078 /* Don't crash on bad data. */
5079 if (cu_index
>= (dwarf2_per_objfile
->all_comp_units
.size ()
5080 + dwarf2_per_objfile
->all_type_units
.size ()))
5082 complaint (_(".gdb_index entry has bad CU index"
5084 objfile_name (dwarf2_per_objfile
->objfile
));
5088 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (cu_index
);
5089 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
5094 /* If FILE_MATCHER is non-NULL, set all the
5095 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5096 that match FILE_MATCHER. */
5099 dw_expand_symtabs_matching_file_matcher
5100 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5101 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
5103 if (file_matcher
== NULL
)
5106 objfile
*const objfile
= dwarf2_per_objfile
->objfile
;
5108 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
5110 NULL
, xcalloc
, xfree
));
5111 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
5113 NULL
, xcalloc
, xfree
));
5115 /* The rule is CUs specify all the files, including those used by
5116 any TU, so there's no need to scan TUs here. */
5118 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5122 per_cu
->v
.quick
->mark
= 0;
5124 /* We only need to look at symtabs not already expanded. */
5125 if (per_cu
->v
.quick
->compunit_symtab
)
5128 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
5129 if (file_data
== NULL
)
5132 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
5134 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
5136 per_cu
->v
.quick
->mark
= 1;
5140 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5142 const char *this_real_name
;
5144 if (file_matcher (file_data
->file_names
[j
], false))
5146 per_cu
->v
.quick
->mark
= 1;
5150 /* Before we invoke realpath, which can get expensive when many
5151 files are involved, do a quick comparison of the basenames. */
5152 if (!basenames_may_differ
5153 && !file_matcher (lbasename (file_data
->file_names
[j
]),
5157 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
5158 if (file_matcher (this_real_name
, false))
5160 per_cu
->v
.quick
->mark
= 1;
5165 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
5166 ? visited_found
.get ()
5167 : visited_not_found
.get (),
5174 dw2_expand_symtabs_matching
5175 (struct objfile
*objfile
,
5176 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5177 const lookup_name_info
&lookup_name
,
5178 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5179 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5180 enum search_domain kind
)
5182 struct dwarf2_per_objfile
*dwarf2_per_objfile
5183 = get_dwarf2_per_objfile (objfile
);
5185 /* index_table is NULL if OBJF_READNOW. */
5186 if (!dwarf2_per_objfile
->index_table
)
5189 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
5191 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
5193 dw2_expand_symtabs_matching_symbol (index
, lookup_name
,
5195 kind
, [&] (offset_type idx
)
5197 dw2_expand_marked_cus (dwarf2_per_objfile
, idx
, file_matcher
,
5198 expansion_notify
, kind
);
5203 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5206 static struct compunit_symtab
*
5207 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
5212 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
5213 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
5216 if (cust
->includes
== NULL
)
5219 for (i
= 0; cust
->includes
[i
]; ++i
)
5221 struct compunit_symtab
*s
= cust
->includes
[i
];
5223 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
5231 static struct compunit_symtab
*
5232 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
5233 struct bound_minimal_symbol msymbol
,
5235 struct obj_section
*section
,
5238 struct dwarf2_per_cu_data
*data
;
5239 struct compunit_symtab
*result
;
5241 if (!objfile
->partial_symtabs
->psymtabs_addrmap
)
5244 CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
5245 SECT_OFF_TEXT (objfile
));
5246 data
= (struct dwarf2_per_cu_data
*) addrmap_find
5247 (objfile
->partial_symtabs
->psymtabs_addrmap
, pc
- baseaddr
);
5251 if (warn_if_readin
&& data
->v
.quick
->compunit_symtab
)
5252 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5253 paddress (get_objfile_arch (objfile
), pc
));
5256 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data
,
5259 gdb_assert (result
!= NULL
);
5264 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
5265 void *data
, int need_fullname
)
5267 struct dwarf2_per_objfile
*dwarf2_per_objfile
5268 = get_dwarf2_per_objfile (objfile
);
5270 if (!dwarf2_per_objfile
->filenames_cache
)
5272 dwarf2_per_objfile
->filenames_cache
.emplace ();
5274 htab_up
visited (htab_create_alloc (10,
5275 htab_hash_pointer
, htab_eq_pointer
,
5276 NULL
, xcalloc
, xfree
));
5278 /* The rule is CUs specify all the files, including those used
5279 by any TU, so there's no need to scan TUs here. We can
5280 ignore file names coming from already-expanded CUs. */
5282 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5284 if (per_cu
->v
.quick
->compunit_symtab
)
5286 void **slot
= htab_find_slot (visited
.get (),
5287 per_cu
->v
.quick
->file_names
,
5290 *slot
= per_cu
->v
.quick
->file_names
;
5294 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5296 /* We only need to look at symtabs not already expanded. */
5297 if (per_cu
->v
.quick
->compunit_symtab
)
5300 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
5301 if (file_data
== NULL
)
5304 void **slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
5307 /* Already visited. */
5312 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5314 const char *filename
= file_data
->file_names
[j
];
5315 dwarf2_per_objfile
->filenames_cache
->seen (filename
);
5320 dwarf2_per_objfile
->filenames_cache
->traverse ([&] (const char *filename
)
5322 gdb::unique_xmalloc_ptr
<char> this_real_name
;
5325 this_real_name
= gdb_realpath (filename
);
5326 (*fun
) (filename
, this_real_name
.get (), data
);
5331 dw2_has_symbols (struct objfile
*objfile
)
5336 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
5339 dw2_find_last_source_symtab
,
5340 dw2_forget_cached_source_info
,
5341 dw2_map_symtabs_matching_filename
,
5345 dw2_expand_symtabs_for_function
,
5346 dw2_expand_all_symtabs
,
5347 dw2_expand_symtabs_with_fullname
,
5348 dw2_map_matching_symbols
,
5349 dw2_expand_symtabs_matching
,
5350 dw2_find_pc_sect_compunit_symtab
,
5352 dw2_map_symbol_filenames
5355 /* DWARF-5 debug_names reader. */
5357 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5358 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
5360 /* A helper function that reads the .debug_names section in SECTION
5361 and fills in MAP. FILENAME is the name of the file containing the
5362 section; it is used for error reporting.
5364 Returns true if all went well, false otherwise. */
5367 read_debug_names_from_section (struct objfile
*objfile
,
5368 const char *filename
,
5369 struct dwarf2_section_info
*section
,
5370 mapped_debug_names
&map
)
5372 if (dwarf2_section_empty_p (section
))
5375 /* Older elfutils strip versions could keep the section in the main
5376 executable while splitting it for the separate debug info file. */
5377 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
5380 dwarf2_read_section (objfile
, section
);
5382 map
.dwarf5_byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
5384 const gdb_byte
*addr
= section
->buffer
;
5386 bfd
*const abfd
= get_section_bfd_owner (section
);
5388 unsigned int bytes_read
;
5389 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
5392 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
5393 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
5394 if (bytes_read
+ length
!= section
->size
)
5396 /* There may be multiple per-CU indices. */
5397 warning (_("Section .debug_names in %s length %s does not match "
5398 "section length %s, ignoring .debug_names."),
5399 filename
, plongest (bytes_read
+ length
),
5400 pulongest (section
->size
));
5404 /* The version number. */
5405 uint16_t version
= read_2_bytes (abfd
, addr
);
5409 warning (_("Section .debug_names in %s has unsupported version %d, "
5410 "ignoring .debug_names."),
5416 uint16_t padding
= read_2_bytes (abfd
, addr
);
5420 warning (_("Section .debug_names in %s has unsupported padding %d, "
5421 "ignoring .debug_names."),
5426 /* comp_unit_count - The number of CUs in the CU list. */
5427 map
.cu_count
= read_4_bytes (abfd
, addr
);
5430 /* local_type_unit_count - The number of TUs in the local TU
5432 map
.tu_count
= read_4_bytes (abfd
, addr
);
5435 /* foreign_type_unit_count - The number of TUs in the foreign TU
5437 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
5439 if (foreign_tu_count
!= 0)
5441 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5442 "ignoring .debug_names."),
5443 filename
, static_cast<unsigned long> (foreign_tu_count
));
5447 /* bucket_count - The number of hash buckets in the hash lookup
5449 map
.bucket_count
= read_4_bytes (abfd
, addr
);
5452 /* name_count - The number of unique names in the index. */
5453 map
.name_count
= read_4_bytes (abfd
, addr
);
5456 /* abbrev_table_size - The size in bytes of the abbreviations
5458 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
5461 /* augmentation_string_size - The size in bytes of the augmentation
5462 string. This value is rounded up to a multiple of 4. */
5463 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
5465 map
.augmentation_is_gdb
= ((augmentation_string_size
5466 == sizeof (dwarf5_augmentation
))
5467 && memcmp (addr
, dwarf5_augmentation
,
5468 sizeof (dwarf5_augmentation
)) == 0);
5469 augmentation_string_size
+= (-augmentation_string_size
) & 3;
5470 addr
+= augmentation_string_size
;
5473 map
.cu_table_reordered
= addr
;
5474 addr
+= map
.cu_count
* map
.offset_size
;
5476 /* List of Local TUs */
5477 map
.tu_table_reordered
= addr
;
5478 addr
+= map
.tu_count
* map
.offset_size
;
5480 /* Hash Lookup Table */
5481 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5482 addr
+= map
.bucket_count
* 4;
5483 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5484 addr
+= map
.name_count
* 4;
5487 map
.name_table_string_offs_reordered
= addr
;
5488 addr
+= map
.name_count
* map
.offset_size
;
5489 map
.name_table_entry_offs_reordered
= addr
;
5490 addr
+= map
.name_count
* map
.offset_size
;
5492 const gdb_byte
*abbrev_table_start
= addr
;
5495 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5500 const auto insertpair
5501 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
5502 if (!insertpair
.second
)
5504 warning (_("Section .debug_names in %s has duplicate index %s, "
5505 "ignoring .debug_names."),
5506 filename
, pulongest (index_num
));
5509 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
5510 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5515 mapped_debug_names::index_val::attr attr
;
5516 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5518 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5520 if (attr
.form
== DW_FORM_implicit_const
)
5522 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
5526 if (attr
.dw_idx
== 0 && attr
.form
== 0)
5528 indexval
.attr_vec
.push_back (std::move (attr
));
5531 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
5533 warning (_("Section .debug_names in %s has abbreviation_table "
5534 "of size %s vs. written as %u, ignoring .debug_names."),
5535 filename
, plongest (addr
- abbrev_table_start
),
5539 map
.entry_pool
= addr
;
5544 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5548 create_cus_from_debug_names_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5549 const mapped_debug_names
&map
,
5550 dwarf2_section_info
§ion
,
5553 sect_offset sect_off_prev
;
5554 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
5556 sect_offset sect_off_next
;
5557 if (i
< map
.cu_count
)
5560 = (sect_offset
) (extract_unsigned_integer
5561 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5563 map
.dwarf5_byte_order
));
5566 sect_off_next
= (sect_offset
) section
.size
;
5569 const ULONGEST length
= sect_off_next
- sect_off_prev
;
5570 dwarf2_per_cu_data
*per_cu
5571 = create_cu_from_index_list (dwarf2_per_objfile
, §ion
, is_dwz
,
5572 sect_off_prev
, length
);
5573 dwarf2_per_objfile
->all_comp_units
.push_back (per_cu
);
5575 sect_off_prev
= sect_off_next
;
5579 /* Read the CU list from the mapped index, and use it to create all
5580 the CU objects for this dwarf2_per_objfile. */
5583 create_cus_from_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5584 const mapped_debug_names
&map
,
5585 const mapped_debug_names
&dwz_map
)
5587 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
5588 dwarf2_per_objfile
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
5590 create_cus_from_debug_names_list (dwarf2_per_objfile
, map
,
5591 dwarf2_per_objfile
->info
,
5592 false /* is_dwz */);
5594 if (dwz_map
.cu_count
== 0)
5597 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5598 create_cus_from_debug_names_list (dwarf2_per_objfile
, dwz_map
, dwz
->info
,
5602 /* Read .debug_names. If everything went ok, initialize the "quick"
5603 elements of all the CUs and return true. Otherwise, return false. */
5606 dwarf2_read_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
5608 std::unique_ptr
<mapped_debug_names
> map
5609 (new mapped_debug_names (dwarf2_per_objfile
));
5610 mapped_debug_names
dwz_map (dwarf2_per_objfile
);
5611 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5613 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
5614 &dwarf2_per_objfile
->debug_names
,
5618 /* Don't use the index if it's empty. */
5619 if (map
->name_count
== 0)
5622 /* If there is a .dwz file, read it so we can get its CU list as
5624 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5627 if (!read_debug_names_from_section (objfile
,
5628 bfd_get_filename (dwz
->dwz_bfd
.get ()),
5629 &dwz
->debug_names
, dwz_map
))
5631 warning (_("could not read '.debug_names' section from %s; skipping"),
5632 bfd_get_filename (dwz
->dwz_bfd
.get ()));
5637 create_cus_from_debug_names (dwarf2_per_objfile
, *map
, dwz_map
);
5639 if (map
->tu_count
!= 0)
5641 /* We can only handle a single .debug_types when we have an
5643 if (dwarf2_per_objfile
->types
.size () != 1)
5646 dwarf2_section_info
*section
= &dwarf2_per_objfile
->types
[0];
5648 create_signatured_type_table_from_debug_names
5649 (dwarf2_per_objfile
, *map
, section
, &dwarf2_per_objfile
->abbrev
);
5652 create_addrmap_from_aranges (dwarf2_per_objfile
,
5653 &dwarf2_per_objfile
->debug_aranges
);
5655 dwarf2_per_objfile
->debug_names_table
= std::move (map
);
5656 dwarf2_per_objfile
->using_index
= 1;
5657 dwarf2_per_objfile
->quick_file_names_table
=
5658 create_quick_file_names_table (dwarf2_per_objfile
->all_comp_units
.size ());
5663 /* Type used to manage iterating over all CUs looking for a symbol for
5666 class dw2_debug_names_iterator
5669 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5670 gdb::optional
<block_enum
> block_index
,
5673 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5674 m_addr (find_vec_in_debug_names (map
, name
))
5677 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5678 search_domain search
, uint32_t namei
)
5681 m_addr (find_vec_in_debug_names (map
, namei
))
5684 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5685 block_enum block_index
, domain_enum domain
,
5687 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5688 m_addr (find_vec_in_debug_names (map
, namei
))
5691 /* Return the next matching CU or NULL if there are no more. */
5692 dwarf2_per_cu_data
*next ();
5695 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5697 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5700 /* The internalized form of .debug_names. */
5701 const mapped_debug_names
&m_map
;
5703 /* If set, only look for symbols that match that block. Valid values are
5704 GLOBAL_BLOCK and STATIC_BLOCK. */
5705 const gdb::optional
<block_enum
> m_block_index
;
5707 /* The kind of symbol we're looking for. */
5708 const domain_enum m_domain
= UNDEF_DOMAIN
;
5709 const search_domain m_search
= ALL_DOMAIN
;
5711 /* The list of CUs from the index entry of the symbol, or NULL if
5713 const gdb_byte
*m_addr
;
5717 mapped_debug_names::namei_to_name (uint32_t namei
) const
5719 const ULONGEST namei_string_offs
5720 = extract_unsigned_integer ((name_table_string_offs_reordered
5721 + namei
* offset_size
),
5724 return read_indirect_string_at_offset
5725 (dwarf2_per_objfile
, dwarf2_per_objfile
->objfile
->obfd
, namei_string_offs
);
5728 /* Find a slot in .debug_names for the object named NAME. If NAME is
5729 found, return pointer to its pool data. If NAME cannot be found,
5733 dw2_debug_names_iterator::find_vec_in_debug_names
5734 (const mapped_debug_names
&map
, const char *name
)
5736 int (*cmp
) (const char *, const char *);
5738 gdb::unique_xmalloc_ptr
<char> without_params
;
5739 if (current_language
->la_language
== language_cplus
5740 || current_language
->la_language
== language_fortran
5741 || current_language
->la_language
== language_d
)
5743 /* NAME is already canonical. Drop any qualifiers as
5744 .debug_names does not contain any. */
5746 if (strchr (name
, '(') != NULL
)
5748 without_params
= cp_remove_params (name
);
5749 if (without_params
!= NULL
)
5750 name
= without_params
.get ();
5754 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
5756 const uint32_t full_hash
= dwarf5_djb_hash (name
);
5758 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5759 (map
.bucket_table_reordered
5760 + (full_hash
% map
.bucket_count
)), 4,
5761 map
.dwarf5_byte_order
);
5765 if (namei
>= map
.name_count
)
5767 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5769 namei
, map
.name_count
,
5770 objfile_name (map
.dwarf2_per_objfile
->objfile
));
5776 const uint32_t namei_full_hash
5777 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5778 (map
.hash_table_reordered
+ namei
), 4,
5779 map
.dwarf5_byte_order
);
5780 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
5783 if (full_hash
== namei_full_hash
)
5785 const char *const namei_string
= map
.namei_to_name (namei
);
5787 #if 0 /* An expensive sanity check. */
5788 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
5790 complaint (_("Wrong .debug_names hash for string at index %u "
5792 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
5797 if (cmp (namei_string
, name
) == 0)
5799 const ULONGEST namei_entry_offs
5800 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5801 + namei
* map
.offset_size
),
5802 map
.offset_size
, map
.dwarf5_byte_order
);
5803 return map
.entry_pool
+ namei_entry_offs
;
5808 if (namei
>= map
.name_count
)
5814 dw2_debug_names_iterator::find_vec_in_debug_names
5815 (const mapped_debug_names
&map
, uint32_t namei
)
5817 if (namei
>= map
.name_count
)
5819 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5821 namei
, map
.name_count
,
5822 objfile_name (map
.dwarf2_per_objfile
->objfile
));
5826 const ULONGEST namei_entry_offs
5827 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5828 + namei
* map
.offset_size
),
5829 map
.offset_size
, map
.dwarf5_byte_order
);
5830 return map
.entry_pool
+ namei_entry_offs
;
5833 /* See dw2_debug_names_iterator. */
5835 dwarf2_per_cu_data
*
5836 dw2_debug_names_iterator::next ()
5841 struct dwarf2_per_objfile
*dwarf2_per_objfile
= m_map
.dwarf2_per_objfile
;
5842 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5843 bfd
*const abfd
= objfile
->obfd
;
5847 unsigned int bytes_read
;
5848 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5849 m_addr
+= bytes_read
;
5853 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5854 if (indexval_it
== m_map
.abbrev_map
.cend ())
5856 complaint (_("Wrong .debug_names undefined abbrev code %s "
5858 pulongest (abbrev
), objfile_name (objfile
));
5861 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5862 enum class symbol_linkage
{
5866 } symbol_linkage_
= symbol_linkage::unknown
;
5867 dwarf2_per_cu_data
*per_cu
= NULL
;
5868 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5873 case DW_FORM_implicit_const
:
5874 ull
= attr
.implicit_const
;
5876 case DW_FORM_flag_present
:
5880 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5881 m_addr
+= bytes_read
;
5884 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5885 dwarf_form_name (attr
.form
),
5886 objfile_name (objfile
));
5889 switch (attr
.dw_idx
)
5891 case DW_IDX_compile_unit
:
5892 /* Don't crash on bad data. */
5893 if (ull
>= dwarf2_per_objfile
->all_comp_units
.size ())
5895 complaint (_(".debug_names entry has bad CU index %s"
5898 objfile_name (dwarf2_per_objfile
->objfile
));
5901 per_cu
= dwarf2_per_objfile
->get_cutu (ull
);
5903 case DW_IDX_type_unit
:
5904 /* Don't crash on bad data. */
5905 if (ull
>= dwarf2_per_objfile
->all_type_units
.size ())
5907 complaint (_(".debug_names entry has bad TU index %s"
5910 objfile_name (dwarf2_per_objfile
->objfile
));
5913 per_cu
= &dwarf2_per_objfile
->get_tu (ull
)->per_cu
;
5915 case DW_IDX_GNU_internal
:
5916 if (!m_map
.augmentation_is_gdb
)
5918 symbol_linkage_
= symbol_linkage::static_
;
5920 case DW_IDX_GNU_external
:
5921 if (!m_map
.augmentation_is_gdb
)
5923 symbol_linkage_
= symbol_linkage::extern_
;
5928 /* Skip if already read in. */
5929 if (per_cu
->v
.quick
->compunit_symtab
)
5932 /* Check static vs global. */
5933 if (symbol_linkage_
!= symbol_linkage::unknown
&& m_block_index
.has_value ())
5935 const bool want_static
= *m_block_index
== STATIC_BLOCK
;
5936 const bool symbol_is_static
=
5937 symbol_linkage_
== symbol_linkage::static_
;
5938 if (want_static
!= symbol_is_static
)
5942 /* Match dw2_symtab_iter_next, symbol_kind
5943 and debug_names::psymbol_tag. */
5947 switch (indexval
.dwarf_tag
)
5949 case DW_TAG_variable
:
5950 case DW_TAG_subprogram
:
5951 /* Some types are also in VAR_DOMAIN. */
5952 case DW_TAG_typedef
:
5953 case DW_TAG_structure_type
:
5960 switch (indexval
.dwarf_tag
)
5962 case DW_TAG_typedef
:
5963 case DW_TAG_structure_type
:
5970 switch (indexval
.dwarf_tag
)
5973 case DW_TAG_variable
:
5980 switch (indexval
.dwarf_tag
)
5992 /* Match dw2_expand_symtabs_matching, symbol_kind and
5993 debug_names::psymbol_tag. */
5996 case VARIABLES_DOMAIN
:
5997 switch (indexval
.dwarf_tag
)
5999 case DW_TAG_variable
:
6005 case FUNCTIONS_DOMAIN
:
6006 switch (indexval
.dwarf_tag
)
6008 case DW_TAG_subprogram
:
6015 switch (indexval
.dwarf_tag
)
6017 case DW_TAG_typedef
:
6018 case DW_TAG_structure_type
:
6024 case MODULES_DOMAIN
:
6025 switch (indexval
.dwarf_tag
)
6039 static struct compunit_symtab
*
6040 dw2_debug_names_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
6041 const char *name
, domain_enum domain
)
6043 struct dwarf2_per_objfile
*dwarf2_per_objfile
6044 = get_dwarf2_per_objfile (objfile
);
6046 const auto &mapp
= dwarf2_per_objfile
->debug_names_table
;
6049 /* index is NULL if OBJF_READNOW. */
6052 const auto &map
= *mapp
;
6054 dw2_debug_names_iterator
iter (map
, block_index
, domain
, name
);
6056 struct compunit_symtab
*stab_best
= NULL
;
6057 struct dwarf2_per_cu_data
*per_cu
;
6058 while ((per_cu
= iter
.next ()) != NULL
)
6060 struct symbol
*sym
, *with_opaque
= NULL
;
6061 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
, false);
6062 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
6063 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
6065 sym
= block_find_symbol (block
, name
, domain
,
6066 block_find_non_opaque_type_preferred
,
6069 /* Some caution must be observed with overloaded functions and
6070 methods, since the index will not contain any overload
6071 information (but NAME might contain it). */
6074 && strcmp_iw (sym
->search_name (), name
) == 0)
6076 if (with_opaque
!= NULL
6077 && strcmp_iw (with_opaque
->search_name (), name
) == 0)
6080 /* Keep looking through other CUs. */
6086 /* This dumps minimal information about .debug_names. It is called
6087 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
6088 uses this to verify that .debug_names has been loaded. */
6091 dw2_debug_names_dump (struct objfile
*objfile
)
6093 struct dwarf2_per_objfile
*dwarf2_per_objfile
6094 = get_dwarf2_per_objfile (objfile
);
6096 gdb_assert (dwarf2_per_objfile
->using_index
);
6097 printf_filtered (".debug_names:");
6098 if (dwarf2_per_objfile
->debug_names_table
)
6099 printf_filtered (" exists\n");
6101 printf_filtered (" faked for \"readnow\"\n");
6102 printf_filtered ("\n");
6106 dw2_debug_names_expand_symtabs_for_function (struct objfile
*objfile
,
6107 const char *func_name
)
6109 struct dwarf2_per_objfile
*dwarf2_per_objfile
6110 = get_dwarf2_per_objfile (objfile
);
6112 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
6113 if (dwarf2_per_objfile
->debug_names_table
)
6115 const mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6117 dw2_debug_names_iterator
iter (map
, {}, VAR_DOMAIN
, func_name
);
6119 struct dwarf2_per_cu_data
*per_cu
;
6120 while ((per_cu
= iter
.next ()) != NULL
)
6121 dw2_instantiate_symtab (per_cu
, false);
6126 dw2_debug_names_map_matching_symbols
6127 (struct objfile
*objfile
,
6128 const lookup_name_info
&name
, domain_enum domain
,
6130 gdb::function_view
<symbol_found_callback_ftype
> callback
,
6131 symbol_compare_ftype
*ordered_compare
)
6133 struct dwarf2_per_objfile
*dwarf2_per_objfile
6134 = get_dwarf2_per_objfile (objfile
);
6136 /* debug_names_table is NULL if OBJF_READNOW. */
6137 if (!dwarf2_per_objfile
->debug_names_table
)
6140 mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6141 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
6143 const char *match_name
= name
.ada ().lookup_name ().c_str ();
6144 auto matcher
= [&] (const char *symname
)
6146 if (ordered_compare
== nullptr)
6148 return ordered_compare (symname
, match_name
) == 0;
6151 dw2_expand_symtabs_matching_symbol (map
, name
, matcher
, ALL_DOMAIN
,
6152 [&] (offset_type namei
)
6154 /* The name was matched, now expand corresponding CUs that were
6156 dw2_debug_names_iterator
iter (map
, block_kind
, domain
, namei
);
6158 struct dwarf2_per_cu_data
*per_cu
;
6159 while ((per_cu
= iter
.next ()) != NULL
)
6160 dw2_expand_symtabs_matching_one (per_cu
, nullptr, nullptr);
6164 /* It's a shame we couldn't do this inside the
6165 dw2_expand_symtabs_matching_symbol callback, but that skips CUs
6166 that have already been expanded. Instead, this loop matches what
6167 the psymtab code does. */
6168 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
6170 struct compunit_symtab
*cust
= per_cu
->v
.quick
->compunit_symtab
;
6171 if (cust
!= nullptr)
6173 const struct block
*block
6174 = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
6175 if (!iterate_over_symbols_terminated (block
, name
,
6183 dw2_debug_names_expand_symtabs_matching
6184 (struct objfile
*objfile
,
6185 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
6186 const lookup_name_info
&lookup_name
,
6187 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
6188 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
6189 enum search_domain kind
)
6191 struct dwarf2_per_objfile
*dwarf2_per_objfile
6192 = get_dwarf2_per_objfile (objfile
);
6194 /* debug_names_table is NULL if OBJF_READNOW. */
6195 if (!dwarf2_per_objfile
->debug_names_table
)
6198 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
6200 mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6202 dw2_expand_symtabs_matching_symbol (map
, lookup_name
,
6204 kind
, [&] (offset_type namei
)
6206 /* The name was matched, now expand corresponding CUs that were
6208 dw2_debug_names_iterator
iter (map
, kind
, namei
);
6210 struct dwarf2_per_cu_data
*per_cu
;
6211 while ((per_cu
= iter
.next ()) != NULL
)
6212 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
6218 const struct quick_symbol_functions dwarf2_debug_names_functions
=
6221 dw2_find_last_source_symtab
,
6222 dw2_forget_cached_source_info
,
6223 dw2_map_symtabs_matching_filename
,
6224 dw2_debug_names_lookup_symbol
,
6226 dw2_debug_names_dump
,
6227 dw2_debug_names_expand_symtabs_for_function
,
6228 dw2_expand_all_symtabs
,
6229 dw2_expand_symtabs_with_fullname
,
6230 dw2_debug_names_map_matching_symbols
,
6231 dw2_debug_names_expand_symtabs_matching
,
6232 dw2_find_pc_sect_compunit_symtab
,
6234 dw2_map_symbol_filenames
6237 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
6238 to either a dwarf2_per_objfile or dwz_file object. */
6240 template <typename T
>
6241 static gdb::array_view
<const gdb_byte
>
6242 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
6244 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
6246 if (dwarf2_section_empty_p (section
))
6249 /* Older elfutils strip versions could keep the section in the main
6250 executable while splitting it for the separate debug info file. */
6251 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
6254 dwarf2_read_section (obj
, section
);
6256 /* dwarf2_section_info::size is a bfd_size_type, while
6257 gdb::array_view works with size_t. On 32-bit hosts, with
6258 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6259 is 32-bit. So we need an explicit narrowing conversion here.
6260 This is fine, because it's impossible to allocate or mmap an
6261 array/buffer larger than what size_t can represent. */
6262 return gdb::make_array_view (section
->buffer
, section
->size
);
6265 /* Lookup the index cache for the contents of the index associated to
6268 static gdb::array_view
<const gdb_byte
>
6269 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_objfile
*dwarf2_obj
)
6271 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
6272 if (build_id
== nullptr)
6275 return global_index_cache
.lookup_gdb_index (build_id
,
6276 &dwarf2_obj
->index_cache_res
);
6279 /* Same as the above, but for DWZ. */
6281 static gdb::array_view
<const gdb_byte
>
6282 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
6284 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
6285 if (build_id
== nullptr)
6288 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
6291 /* See symfile.h. */
6294 dwarf2_initialize_objfile (struct objfile
*objfile
, dw_index_kind
*index_kind
)
6296 struct dwarf2_per_objfile
*dwarf2_per_objfile
6297 = get_dwarf2_per_objfile (objfile
);
6299 /* If we're about to read full symbols, don't bother with the
6300 indices. In this case we also don't care if some other debug
6301 format is making psymtabs, because they are all about to be
6303 if ((objfile
->flags
& OBJF_READNOW
))
6305 dwarf2_per_objfile
->using_index
= 1;
6306 create_all_comp_units (dwarf2_per_objfile
);
6307 create_all_type_units (dwarf2_per_objfile
);
6308 dwarf2_per_objfile
->quick_file_names_table
6309 = create_quick_file_names_table
6310 (dwarf2_per_objfile
->all_comp_units
.size ());
6312 for (int i
= 0; i
< (dwarf2_per_objfile
->all_comp_units
.size ()
6313 + dwarf2_per_objfile
->all_type_units
.size ()); ++i
)
6315 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
6317 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6318 struct dwarf2_per_cu_quick_data
);
6321 /* Return 1 so that gdb sees the "quick" functions. However,
6322 these functions will be no-ops because we will have expanded
6324 *index_kind
= dw_index_kind::GDB_INDEX
;
6328 if (dwarf2_read_debug_names (dwarf2_per_objfile
))
6330 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6334 if (dwarf2_read_gdb_index (dwarf2_per_objfile
,
6335 get_gdb_index_contents_from_section
<struct dwarf2_per_objfile
>,
6336 get_gdb_index_contents_from_section
<dwz_file
>))
6338 *index_kind
= dw_index_kind::GDB_INDEX
;
6342 /* ... otherwise, try to find the index in the index cache. */
6343 if (dwarf2_read_gdb_index (dwarf2_per_objfile
,
6344 get_gdb_index_contents_from_cache
,
6345 get_gdb_index_contents_from_cache_dwz
))
6347 global_index_cache
.hit ();
6348 *index_kind
= dw_index_kind::GDB_INDEX
;
6352 global_index_cache
.miss ();
6358 /* Build a partial symbol table. */
6361 dwarf2_build_psymtabs (struct objfile
*objfile
)
6363 struct dwarf2_per_objfile
*dwarf2_per_objfile
6364 = get_dwarf2_per_objfile (objfile
);
6366 init_psymbol_list (objfile
, 1024);
6370 /* This isn't really ideal: all the data we allocate on the
6371 objfile's obstack is still uselessly kept around. However,
6372 freeing it seems unsafe. */
6373 psymtab_discarder
psymtabs (objfile
);
6374 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
);
6377 /* (maybe) store an index in the cache. */
6378 global_index_cache
.store (dwarf2_per_objfile
);
6380 catch (const gdb_exception_error
&except
)
6382 exception_print (gdb_stderr
, except
);
6386 /* Return the total length of the CU described by HEADER. */
6389 get_cu_length (const struct comp_unit_head
*header
)
6391 return header
->initial_length_size
+ header
->length
;
6394 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6397 offset_in_cu_p (const comp_unit_head
*cu_header
, sect_offset sect_off
)
6399 sect_offset bottom
= cu_header
->sect_off
;
6400 sect_offset top
= cu_header
->sect_off
+ get_cu_length (cu_header
);
6402 return sect_off
>= bottom
&& sect_off
< top
;
6405 /* Find the base address of the compilation unit for range lists and
6406 location lists. It will normally be specified by DW_AT_low_pc.
6407 In DWARF-3 draft 4, the base address could be overridden by
6408 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6409 compilation units with discontinuous ranges. */
6412 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
6414 struct attribute
*attr
;
6417 cu
->base_address
= 0;
6419 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
6420 if (attr
!= nullptr)
6422 cu
->base_address
= attr_value_as_address (attr
);
6427 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6428 if (attr
!= nullptr)
6430 cu
->base_address
= attr_value_as_address (attr
);
6436 /* Read in the comp unit header information from the debug_info at info_ptr.
6437 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6438 NOTE: This leaves members offset, first_die_offset to be filled in
6441 static const gdb_byte
*
6442 read_comp_unit_head (struct comp_unit_head
*cu_header
,
6443 const gdb_byte
*info_ptr
,
6444 struct dwarf2_section_info
*section
,
6445 rcuh_kind section_kind
)
6448 unsigned int bytes_read
;
6449 const char *filename
= get_section_file_name (section
);
6450 bfd
*abfd
= get_section_bfd_owner (section
);
6452 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
6453 cu_header
->initial_length_size
= bytes_read
;
6454 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
6455 info_ptr
+= bytes_read
;
6456 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
6457 if (cu_header
->version
< 2 || cu_header
->version
> 5)
6458 error (_("Dwarf Error: wrong version in compilation unit header "
6459 "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6460 cu_header
->version
, filename
);
6462 if (cu_header
->version
< 5)
6463 switch (section_kind
)
6465 case rcuh_kind::COMPILE
:
6466 cu_header
->unit_type
= DW_UT_compile
;
6468 case rcuh_kind::TYPE
:
6469 cu_header
->unit_type
= DW_UT_type
;
6472 internal_error (__FILE__
, __LINE__
,
6473 _("read_comp_unit_head: invalid section_kind"));
6477 cu_header
->unit_type
= static_cast<enum dwarf_unit_type
>
6478 (read_1_byte (abfd
, info_ptr
));
6480 switch (cu_header
->unit_type
)
6484 case DW_UT_skeleton
:
6485 case DW_UT_split_compile
:
6486 if (section_kind
!= rcuh_kind::COMPILE
)
6487 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6488 "(is %s, should be %s) [in module %s]"),
6489 dwarf_unit_type_name (cu_header
->unit_type
),
6490 dwarf_unit_type_name (DW_UT_type
), filename
);
6493 case DW_UT_split_type
:
6494 section_kind
= rcuh_kind::TYPE
;
6497 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6498 "(is %#04x, should be one of: %s, %s, %s, %s or %s) "
6499 "[in module %s]"), cu_header
->unit_type
,
6500 dwarf_unit_type_name (DW_UT_compile
),
6501 dwarf_unit_type_name (DW_UT_skeleton
),
6502 dwarf_unit_type_name (DW_UT_split_compile
),
6503 dwarf_unit_type_name (DW_UT_type
),
6504 dwarf_unit_type_name (DW_UT_split_type
), filename
);
6507 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
6510 cu_header
->abbrev_sect_off
= (sect_offset
) read_offset (abfd
, info_ptr
,
6513 info_ptr
+= bytes_read
;
6514 if (cu_header
->version
< 5)
6516 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
6519 signed_addr
= bfd_get_sign_extend_vma (abfd
);
6520 if (signed_addr
< 0)
6521 internal_error (__FILE__
, __LINE__
,
6522 _("read_comp_unit_head: dwarf from non elf file"));
6523 cu_header
->signed_addr_p
= signed_addr
;
6525 bool header_has_signature
= section_kind
== rcuh_kind::TYPE
6526 || cu_header
->unit_type
== DW_UT_skeleton
6527 || cu_header
->unit_type
== DW_UT_split_compile
;
6529 if (header_has_signature
)
6531 cu_header
->signature
= read_8_bytes (abfd
, info_ptr
);
6535 if (section_kind
== rcuh_kind::TYPE
)
6537 LONGEST type_offset
;
6538 type_offset
= read_offset (abfd
, info_ptr
, cu_header
, &bytes_read
);
6539 info_ptr
+= bytes_read
;
6540 cu_header
->type_cu_offset_in_tu
= (cu_offset
) type_offset
;
6541 if (to_underlying (cu_header
->type_cu_offset_in_tu
) != type_offset
)
6542 error (_("Dwarf Error: Too big type_offset in compilation unit "
6543 "header (is %s) [in module %s]"), plongest (type_offset
),
6550 /* Helper function that returns the proper abbrev section for
6553 static struct dwarf2_section_info
*
6554 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
6556 struct dwarf2_section_info
*abbrev
;
6557 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
6559 if (this_cu
->is_dwz
)
6560 abbrev
= &dwarf2_get_dwz_file (dwarf2_per_objfile
)->abbrev
;
6562 abbrev
= &dwarf2_per_objfile
->abbrev
;
6567 /* Subroutine of read_and_check_comp_unit_head and
6568 read_and_check_type_unit_head to simplify them.
6569 Perform various error checking on the header. */
6572 error_check_comp_unit_head (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6573 struct comp_unit_head
*header
,
6574 struct dwarf2_section_info
*section
,
6575 struct dwarf2_section_info
*abbrev_section
)
6577 const char *filename
= get_section_file_name (section
);
6579 if (to_underlying (header
->abbrev_sect_off
)
6580 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
6581 error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6582 "(offset %s + 6) [in module %s]"),
6583 sect_offset_str (header
->abbrev_sect_off
),
6584 sect_offset_str (header
->sect_off
),
6587 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6588 avoid potential 32-bit overflow. */
6589 if (((ULONGEST
) header
->sect_off
+ get_cu_length (header
))
6591 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6592 "(offset %s + 0) [in module %s]"),
6593 header
->length
, sect_offset_str (header
->sect_off
),
6597 /* Read in a CU/TU header and perform some basic error checking.
6598 The contents of the header are stored in HEADER.
6599 The result is a pointer to the start of the first DIE. */
6601 static const gdb_byte
*
6602 read_and_check_comp_unit_head (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6603 struct comp_unit_head
*header
,
6604 struct dwarf2_section_info
*section
,
6605 struct dwarf2_section_info
*abbrev_section
,
6606 const gdb_byte
*info_ptr
,
6607 rcuh_kind section_kind
)
6609 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
6611 header
->sect_off
= (sect_offset
) (beg_of_comp_unit
- section
->buffer
);
6613 info_ptr
= read_comp_unit_head (header
, info_ptr
, section
, section_kind
);
6615 header
->first_die_cu_offset
= (cu_offset
) (info_ptr
- beg_of_comp_unit
);
6617 error_check_comp_unit_head (dwarf2_per_objfile
, header
, section
,
6623 /* Fetch the abbreviation table offset from a comp or type unit header. */
6626 read_abbrev_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6627 struct dwarf2_section_info
*section
,
6628 sect_offset sect_off
)
6630 bfd
*abfd
= get_section_bfd_owner (section
);
6631 const gdb_byte
*info_ptr
;
6632 unsigned int initial_length_size
, offset_size
;
6635 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
6636 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
6637 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6638 offset_size
= initial_length_size
== 4 ? 4 : 8;
6639 info_ptr
+= initial_length_size
;
6641 version
= read_2_bytes (abfd
, info_ptr
);
6645 /* Skip unit type and address size. */
6649 return (sect_offset
) read_offset_1 (abfd
, info_ptr
, offset_size
);
6652 /* Allocate a new partial symtab for file named NAME and mark this new
6653 partial symtab as being an include of PST. */
6656 dwarf2_create_include_psymtab (const char *name
, struct partial_symtab
*pst
,
6657 struct objfile
*objfile
)
6659 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
6661 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
6663 /* It shares objfile->objfile_obstack. */
6664 subpst
->dirname
= pst
->dirname
;
6667 subpst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (1);
6668 subpst
->dependencies
[0] = pst
;
6669 subpst
->number_of_dependencies
= 1;
6671 subpst
->read_symtab
= pst
->read_symtab
;
6673 /* No private part is necessary for include psymtabs. This property
6674 can be used to differentiate between such include psymtabs and
6675 the regular ones. */
6676 subpst
->read_symtab_private
= NULL
;
6679 /* Read the Line Number Program data and extract the list of files
6680 included by the source file represented by PST. Build an include
6681 partial symtab for each of these included files. */
6684 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
6685 struct die_info
*die
,
6686 struct partial_symtab
*pst
)
6689 struct attribute
*attr
;
6691 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6692 if (attr
!= nullptr)
6693 lh
= dwarf_decode_line_header ((sect_offset
) DW_UNSND (attr
), cu
);
6695 return; /* No linetable, so no includes. */
6697 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6698 that we pass in the raw text_low here; that is ok because we're
6699 only decoding the line table to make include partial symtabs, and
6700 so the addresses aren't really used. */
6701 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
6702 pst
->raw_text_low (), 1);
6706 hash_signatured_type (const void *item
)
6708 const struct signatured_type
*sig_type
6709 = (const struct signatured_type
*) item
;
6711 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6712 return sig_type
->signature
;
6716 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6718 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6719 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6721 return lhs
->signature
== rhs
->signature
;
6724 /* Allocate a hash table for signatured types. */
6727 allocate_signatured_type_table (struct objfile
*objfile
)
6729 return htab_create_alloc_ex (41,
6730 hash_signatured_type
,
6733 &objfile
->objfile_obstack
,
6734 hashtab_obstack_allocate
,
6735 dummy_obstack_deallocate
);
6738 /* A helper function to add a signatured type CU to a table. */
6741 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6743 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6744 std::vector
<signatured_type
*> *all_type_units
6745 = (std::vector
<signatured_type
*> *) datum
;
6747 all_type_units
->push_back (sigt
);
6752 /* A helper for create_debug_types_hash_table. Read types from SECTION
6753 and fill them into TYPES_HTAB. It will process only type units,
6754 therefore DW_UT_type. */
6757 create_debug_type_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6758 struct dwo_file
*dwo_file
,
6759 dwarf2_section_info
*section
, htab_t
&types_htab
,
6760 rcuh_kind section_kind
)
6762 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6763 struct dwarf2_section_info
*abbrev_section
;
6765 const gdb_byte
*info_ptr
, *end_ptr
;
6767 abbrev_section
= (dwo_file
!= NULL
6768 ? &dwo_file
->sections
.abbrev
6769 : &dwarf2_per_objfile
->abbrev
);
6771 if (dwarf_read_debug
)
6772 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
6773 get_section_name (section
),
6774 get_section_file_name (abbrev_section
));
6776 dwarf2_read_section (objfile
, section
);
6777 info_ptr
= section
->buffer
;
6779 if (info_ptr
== NULL
)
6782 /* We can't set abfd until now because the section may be empty or
6783 not present, in which case the bfd is unknown. */
6784 abfd
= get_section_bfd_owner (section
);
6786 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6787 because we don't need to read any dies: the signature is in the
6790 end_ptr
= info_ptr
+ section
->size
;
6791 while (info_ptr
< end_ptr
)
6793 struct signatured_type
*sig_type
;
6794 struct dwo_unit
*dwo_tu
;
6796 const gdb_byte
*ptr
= info_ptr
;
6797 struct comp_unit_head header
;
6798 unsigned int length
;
6800 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
6802 /* Initialize it due to a false compiler warning. */
6803 header
.signature
= -1;
6804 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
6806 /* We need to read the type's signature in order to build the hash
6807 table, but we don't need anything else just yet. */
6809 ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
, &header
, section
,
6810 abbrev_section
, ptr
, section_kind
);
6812 length
= get_cu_length (&header
);
6814 /* Skip dummy type units. */
6815 if (ptr
>= info_ptr
+ length
6816 || peek_abbrev_code (abfd
, ptr
) == 0
6817 || header
.unit_type
!= DW_UT_type
)
6823 if (types_htab
== NULL
)
6826 types_htab
= allocate_dwo_unit_table (objfile
);
6828 types_htab
= allocate_signatured_type_table (objfile
);
6834 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6836 dwo_tu
->dwo_file
= dwo_file
;
6837 dwo_tu
->signature
= header
.signature
;
6838 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6839 dwo_tu
->section
= section
;
6840 dwo_tu
->sect_off
= sect_off
;
6841 dwo_tu
->length
= length
;
6845 /* N.B.: type_offset is not usable if this type uses a DWO file.
6846 The real type_offset is in the DWO file. */
6848 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6849 struct signatured_type
);
6850 sig_type
->signature
= header
.signature
;
6851 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6852 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
6853 sig_type
->per_cu
.is_debug_types
= 1;
6854 sig_type
->per_cu
.section
= section
;
6855 sig_type
->per_cu
.sect_off
= sect_off
;
6856 sig_type
->per_cu
.length
= length
;
6859 slot
= htab_find_slot (types_htab
,
6860 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
6862 gdb_assert (slot
!= NULL
);
6865 sect_offset dup_sect_off
;
6869 const struct dwo_unit
*dup_tu
6870 = (const struct dwo_unit
*) *slot
;
6872 dup_sect_off
= dup_tu
->sect_off
;
6876 const struct signatured_type
*dup_tu
6877 = (const struct signatured_type
*) *slot
;
6879 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
6882 complaint (_("debug type entry at offset %s is duplicate to"
6883 " the entry at offset %s, signature %s"),
6884 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
6885 hex_string (header
.signature
));
6887 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
6889 if (dwarf_read_debug
> 1)
6890 fprintf_unfiltered (gdb_stdlog
, " offset %s, signature %s\n",
6891 sect_offset_str (sect_off
),
6892 hex_string (header
.signature
));
6898 /* Create the hash table of all entries in the .debug_types
6899 (or .debug_types.dwo) section(s).
6900 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6901 otherwise it is NULL.
6903 The result is a pointer to the hash table or NULL if there are no types.
6905 Note: This function processes DWO files only, not DWP files. */
6908 create_debug_types_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6909 struct dwo_file
*dwo_file
,
6910 gdb::array_view
<dwarf2_section_info
> type_sections
,
6913 for (dwarf2_section_info
§ion
: type_sections
)
6914 create_debug_type_hash_table (dwarf2_per_objfile
, dwo_file
, §ion
,
6915 types_htab
, rcuh_kind::TYPE
);
6918 /* Create the hash table of all entries in the .debug_types section,
6919 and initialize all_type_units.
6920 The result is zero if there is an error (e.g. missing .debug_types section),
6921 otherwise non-zero. */
6924 create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
6926 htab_t types_htab
= NULL
;
6928 create_debug_type_hash_table (dwarf2_per_objfile
, NULL
,
6929 &dwarf2_per_objfile
->info
, types_htab
,
6930 rcuh_kind::COMPILE
);
6931 create_debug_types_hash_table (dwarf2_per_objfile
, NULL
,
6932 dwarf2_per_objfile
->types
, types_htab
);
6933 if (types_htab
== NULL
)
6935 dwarf2_per_objfile
->signatured_types
= NULL
;
6939 dwarf2_per_objfile
->signatured_types
= types_htab
;
6941 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
6942 dwarf2_per_objfile
->all_type_units
.reserve (htab_elements (types_htab
));
6944 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
,
6945 &dwarf2_per_objfile
->all_type_units
);
6950 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6951 If SLOT is non-NULL, it is the entry to use in the hash table.
6952 Otherwise we find one. */
6954 static struct signatured_type
*
6955 add_type_unit (struct dwarf2_per_objfile
*dwarf2_per_objfile
, ULONGEST sig
,
6958 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6960 if (dwarf2_per_objfile
->all_type_units
.size ()
6961 == dwarf2_per_objfile
->all_type_units
.capacity ())
6962 ++dwarf2_per_objfile
->tu_stats
.nr_all_type_units_reallocs
;
6964 signatured_type
*sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6965 struct signatured_type
);
6967 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
6968 sig_type
->signature
= sig
;
6969 sig_type
->per_cu
.is_debug_types
= 1;
6970 if (dwarf2_per_objfile
->using_index
)
6972 sig_type
->per_cu
.v
.quick
=
6973 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6974 struct dwarf2_per_cu_quick_data
);
6979 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
6982 gdb_assert (*slot
== NULL
);
6984 /* The rest of sig_type must be filled in by the caller. */
6988 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6989 Fill in SIG_ENTRY with DWO_ENTRY. */
6992 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6993 struct signatured_type
*sig_entry
,
6994 struct dwo_unit
*dwo_entry
)
6996 /* Make sure we're not clobbering something we don't expect to. */
6997 gdb_assert (! sig_entry
->per_cu
.queued
);
6998 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
6999 if (dwarf2_per_objfile
->using_index
)
7001 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
7002 gdb_assert (sig_entry
->per_cu
.v
.quick
->compunit_symtab
== NULL
);
7005 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
7006 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
7007 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
7008 gdb_assert (sig_entry
->type_unit_group
== NULL
);
7009 gdb_assert (sig_entry
->dwo_unit
== NULL
);
7011 sig_entry
->per_cu
.section
= dwo_entry
->section
;
7012 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
7013 sig_entry
->per_cu
.length
= dwo_entry
->length
;
7014 sig_entry
->per_cu
.reading_dwo_directly
= 1;
7015 sig_entry
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
7016 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
7017 sig_entry
->dwo_unit
= dwo_entry
;
7020 /* Subroutine of lookup_signatured_type.
7021 If we haven't read the TU yet, create the signatured_type data structure
7022 for a TU to be read in directly from a DWO file, bypassing the stub.
7023 This is the "Stay in DWO Optimization": When there is no DWP file and we're
7024 using .gdb_index, then when reading a CU we want to stay in the DWO file
7025 containing that CU. Otherwise we could end up reading several other DWO
7026 files (due to comdat folding) to process the transitive closure of all the
7027 mentioned TUs, and that can be slow. The current DWO file will have every
7028 type signature that it needs.
7029 We only do this for .gdb_index because in the psymtab case we already have
7030 to read all the DWOs to build the type unit groups. */
7032 static struct signatured_type
*
7033 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7035 struct dwarf2_per_objfile
*dwarf2_per_objfile
7036 = cu
->per_cu
->dwarf2_per_objfile
;
7037 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7038 struct dwo_file
*dwo_file
;
7039 struct dwo_unit find_dwo_entry
, *dwo_entry
;
7040 struct signatured_type find_sig_entry
, *sig_entry
;
7043 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
7045 /* If TU skeletons have been removed then we may not have read in any
7047 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7049 dwarf2_per_objfile
->signatured_types
7050 = allocate_signatured_type_table (objfile
);
7053 /* We only ever need to read in one copy of a signatured type.
7054 Use the global signatured_types array to do our own comdat-folding
7055 of types. If this is the first time we're reading this TU, and
7056 the TU has an entry in .gdb_index, replace the recorded data from
7057 .gdb_index with this TU. */
7059 find_sig_entry
.signature
= sig
;
7060 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
7061 &find_sig_entry
, INSERT
);
7062 sig_entry
= (struct signatured_type
*) *slot
;
7064 /* We can get here with the TU already read, *or* in the process of being
7065 read. Don't reassign the global entry to point to this DWO if that's
7066 the case. Also note that if the TU is already being read, it may not
7067 have come from a DWO, the program may be a mix of Fission-compiled
7068 code and non-Fission-compiled code. */
7070 /* Have we already tried to read this TU?
7071 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7072 needn't exist in the global table yet). */
7073 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
7076 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
7077 dwo_unit of the TU itself. */
7078 dwo_file
= cu
->dwo_unit
->dwo_file
;
7080 /* Ok, this is the first time we're reading this TU. */
7081 if (dwo_file
->tus
== NULL
)
7083 find_dwo_entry
.signature
= sig
;
7084 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_entry
);
7085 if (dwo_entry
== NULL
)
7088 /* If the global table doesn't have an entry for this TU, add one. */
7089 if (sig_entry
== NULL
)
7090 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
7092 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
7093 sig_entry
->per_cu
.tu_read
= 1;
7097 /* Subroutine of lookup_signatured_type.
7098 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7099 then try the DWP file. If the TU stub (skeleton) has been removed then
7100 it won't be in .gdb_index. */
7102 static struct signatured_type
*
7103 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7105 struct dwarf2_per_objfile
*dwarf2_per_objfile
7106 = cu
->per_cu
->dwarf2_per_objfile
;
7107 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7108 struct dwp_file
*dwp_file
= get_dwp_file (dwarf2_per_objfile
);
7109 struct dwo_unit
*dwo_entry
;
7110 struct signatured_type find_sig_entry
, *sig_entry
;
7113 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
7114 gdb_assert (dwp_file
!= NULL
);
7116 /* If TU skeletons have been removed then we may not have read in any
7118 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7120 dwarf2_per_objfile
->signatured_types
7121 = allocate_signatured_type_table (objfile
);
7124 find_sig_entry
.signature
= sig
;
7125 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
7126 &find_sig_entry
, INSERT
);
7127 sig_entry
= (struct signatured_type
*) *slot
;
7129 /* Have we already tried to read this TU?
7130 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7131 needn't exist in the global table yet). */
7132 if (sig_entry
!= NULL
)
7135 if (dwp_file
->tus
== NULL
)
7137 dwo_entry
= lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, NULL
,
7138 sig
, 1 /* is_debug_types */);
7139 if (dwo_entry
== NULL
)
7142 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
7143 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
7148 /* Lookup a signature based type for DW_FORM_ref_sig8.
7149 Returns NULL if signature SIG is not present in the table.
7150 It is up to the caller to complain about this. */
7152 static struct signatured_type
*
7153 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7155 struct dwarf2_per_objfile
*dwarf2_per_objfile
7156 = cu
->per_cu
->dwarf2_per_objfile
;
7159 && dwarf2_per_objfile
->using_index
)
7161 /* We're in a DWO/DWP file, and we're using .gdb_index.
7162 These cases require special processing. */
7163 if (get_dwp_file (dwarf2_per_objfile
) == NULL
)
7164 return lookup_dwo_signatured_type (cu
, sig
);
7166 return lookup_dwp_signatured_type (cu
, sig
);
7170 struct signatured_type find_entry
, *entry
;
7172 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7174 find_entry
.signature
= sig
;
7175 entry
= ((struct signatured_type
*)
7176 htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
));
7181 /* Low level DIE reading support. */
7183 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7186 init_cu_die_reader (struct die_reader_specs
*reader
,
7187 struct dwarf2_cu
*cu
,
7188 struct dwarf2_section_info
*section
,
7189 struct dwo_file
*dwo_file
,
7190 struct abbrev_table
*abbrev_table
)
7192 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
7193 reader
->abfd
= get_section_bfd_owner (section
);
7195 reader
->dwo_file
= dwo_file
;
7196 reader
->die_section
= section
;
7197 reader
->buffer
= section
->buffer
;
7198 reader
->buffer_end
= section
->buffer
+ section
->size
;
7199 reader
->comp_dir
= NULL
;
7200 reader
->abbrev_table
= abbrev_table
;
7203 /* Subroutine of init_cutu_and_read_dies to simplify it.
7204 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7205 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7208 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7209 from it to the DIE in the DWO. If NULL we are skipping the stub.
7210 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7211 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7212 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7213 STUB_COMP_DIR may be non-NULL.
7214 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7215 are filled in with the info of the DIE from the DWO file.
7216 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7217 from the dwo. Since *RESULT_READER references this abbrev table, it must be
7218 kept around for at least as long as *RESULT_READER.
7220 The result is non-zero if a valid (non-dummy) DIE was found. */
7223 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
7224 struct dwo_unit
*dwo_unit
,
7225 struct die_info
*stub_comp_unit_die
,
7226 const char *stub_comp_dir
,
7227 struct die_reader_specs
*result_reader
,
7228 const gdb_byte
**result_info_ptr
,
7229 struct die_info
**result_comp_unit_die
,
7230 int *result_has_children
,
7231 abbrev_table_up
*result_dwo_abbrev_table
)
7233 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7234 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7235 struct dwarf2_cu
*cu
= this_cu
->cu
;
7237 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7238 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
7239 int i
,num_extra_attrs
;
7240 struct dwarf2_section_info
*dwo_abbrev_section
;
7241 struct attribute
*attr
;
7242 struct die_info
*comp_unit_die
;
7244 /* At most one of these may be provided. */
7245 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
7247 /* These attributes aren't processed until later:
7248 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7249 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7250 referenced later. However, these attributes are found in the stub
7251 which we won't have later. In order to not impose this complication
7252 on the rest of the code, we read them here and copy them to the
7261 if (stub_comp_unit_die
!= NULL
)
7263 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7265 if (! this_cu
->is_debug_types
)
7266 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
7267 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
7268 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
7269 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
7270 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
7272 /* There should be a DW_AT_addr_base attribute here (if needed).
7273 We need the value before we can process DW_FORM_GNU_addr_index
7274 or DW_FORM_addrx. */
7276 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
7277 if (attr
!= nullptr)
7278 cu
->addr_base
= DW_UNSND (attr
);
7280 /* There should be a DW_AT_ranges_base attribute here (if needed).
7281 We need the value before we can process DW_AT_ranges. */
7282 cu
->ranges_base
= 0;
7283 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
7284 if (attr
!= nullptr)
7285 cu
->ranges_base
= DW_UNSND (attr
);
7287 else if (stub_comp_dir
!= NULL
)
7289 /* Reconstruct the comp_dir attribute to simplify the code below. */
7290 comp_dir
= XOBNEW (&cu
->comp_unit_obstack
, struct attribute
);
7291 comp_dir
->name
= DW_AT_comp_dir
;
7292 comp_dir
->form
= DW_FORM_string
;
7293 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
7294 DW_STRING (comp_dir
) = stub_comp_dir
;
7297 /* Set up for reading the DWO CU/TU. */
7298 cu
->dwo_unit
= dwo_unit
;
7299 dwarf2_section_info
*section
= dwo_unit
->section
;
7300 dwarf2_read_section (objfile
, section
);
7301 abfd
= get_section_bfd_owner (section
);
7302 begin_info_ptr
= info_ptr
= (section
->buffer
7303 + to_underlying (dwo_unit
->sect_off
));
7304 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
7306 if (this_cu
->is_debug_types
)
7308 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
7310 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7311 &cu
->header
, section
,
7313 info_ptr
, rcuh_kind::TYPE
);
7314 /* This is not an assert because it can be caused by bad debug info. */
7315 if (sig_type
->signature
!= cu
->header
.signature
)
7317 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7318 " TU at offset %s [in module %s]"),
7319 hex_string (sig_type
->signature
),
7320 hex_string (cu
->header
.signature
),
7321 sect_offset_str (dwo_unit
->sect_off
),
7322 bfd_get_filename (abfd
));
7324 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7325 /* For DWOs coming from DWP files, we don't know the CU length
7326 nor the type's offset in the TU until now. */
7327 dwo_unit
->length
= get_cu_length (&cu
->header
);
7328 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
7330 /* Establish the type offset that can be used to lookup the type.
7331 For DWO files, we don't know it until now. */
7332 sig_type
->type_offset_in_section
7333 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
7337 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7338 &cu
->header
, section
,
7340 info_ptr
, rcuh_kind::COMPILE
);
7341 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7342 /* For DWOs coming from DWP files, we don't know the CU length
7344 dwo_unit
->length
= get_cu_length (&cu
->header
);
7347 *result_dwo_abbrev_table
7348 = abbrev_table_read_table (dwarf2_per_objfile
, dwo_abbrev_section
,
7349 cu
->header
.abbrev_sect_off
);
7350 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
7351 result_dwo_abbrev_table
->get ());
7353 /* Read in the die, but leave space to copy over the attributes
7354 from the stub. This has the benefit of simplifying the rest of
7355 the code - all the work to maintain the illusion of a single
7356 DW_TAG_{compile,type}_unit DIE is done here. */
7357 num_extra_attrs
= ((stmt_list
!= NULL
)
7361 + (comp_dir
!= NULL
));
7362 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
7363 result_has_children
, num_extra_attrs
);
7365 /* Copy over the attributes from the stub to the DIE we just read in. */
7366 comp_unit_die
= *result_comp_unit_die
;
7367 i
= comp_unit_die
->num_attrs
;
7368 if (stmt_list
!= NULL
)
7369 comp_unit_die
->attrs
[i
++] = *stmt_list
;
7371 comp_unit_die
->attrs
[i
++] = *low_pc
;
7372 if (high_pc
!= NULL
)
7373 comp_unit_die
->attrs
[i
++] = *high_pc
;
7375 comp_unit_die
->attrs
[i
++] = *ranges
;
7376 if (comp_dir
!= NULL
)
7377 comp_unit_die
->attrs
[i
++] = *comp_dir
;
7378 comp_unit_die
->num_attrs
+= num_extra_attrs
;
7380 if (dwarf_die_debug
)
7382 fprintf_unfiltered (gdb_stdlog
,
7383 "Read die from %s@0x%x of %s:\n",
7384 get_section_name (section
),
7385 (unsigned) (begin_info_ptr
- section
->buffer
),
7386 bfd_get_filename (abfd
));
7387 dump_die (comp_unit_die
, dwarf_die_debug
);
7390 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7391 TUs by skipping the stub and going directly to the entry in the DWO file.
7392 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7393 to get it via circuitous means. Blech. */
7394 if (comp_dir
!= NULL
)
7395 result_reader
->comp_dir
= DW_STRING (comp_dir
);
7397 /* Skip dummy compilation units. */
7398 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
7399 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7402 *result_info_ptr
= info_ptr
;
7406 /* Return the signature of the compile unit, if found. In DWARF 4 and before,
7407 the signature is in the DW_AT_GNU_dwo_id attribute. In DWARF 5 and later, the
7408 signature is part of the header. */
7409 static gdb::optional
<ULONGEST
>
7410 lookup_dwo_id (struct dwarf2_cu
*cu
, struct die_info
* comp_unit_die
)
7412 if (cu
->header
.version
>= 5)
7413 return cu
->header
.signature
;
7414 struct attribute
*attr
;
7415 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
7416 if (attr
== nullptr)
7417 return gdb::optional
<ULONGEST
> ();
7418 return DW_UNSND (attr
);
7421 /* Subroutine of init_cutu_and_read_dies to simplify it.
7422 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7423 Returns NULL if the specified DWO unit cannot be found. */
7425 static struct dwo_unit
*
7426 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
7427 struct die_info
*comp_unit_die
)
7429 struct dwarf2_cu
*cu
= this_cu
->cu
;
7430 struct dwo_unit
*dwo_unit
;
7431 const char *comp_dir
, *dwo_name
;
7433 gdb_assert (cu
!= NULL
);
7435 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7436 dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7437 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7439 if (this_cu
->is_debug_types
)
7441 struct signatured_type
*sig_type
;
7443 /* Since this_cu is the first member of struct signatured_type,
7444 we can go from a pointer to one to a pointer to the other. */
7445 sig_type
= (struct signatured_type
*) this_cu
;
7446 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
7450 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
7451 if (!signature
.has_value ())
7452 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7454 dwo_name
, objfile_name (this_cu
->dwarf2_per_objfile
->objfile
));
7455 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
7462 /* Subroutine of init_cutu_and_read_dies to simplify it.
7463 See it for a description of the parameters.
7464 Read a TU directly from a DWO file, bypassing the stub. */
7467 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
7468 int use_existing_cu
, int keep
,
7469 die_reader_func_ftype
*die_reader_func
,
7472 std::unique_ptr
<dwarf2_cu
> new_cu
;
7473 struct signatured_type
*sig_type
;
7474 struct die_reader_specs reader
;
7475 const gdb_byte
*info_ptr
;
7476 struct die_info
*comp_unit_die
;
7478 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7480 /* Verify we can do the following downcast, and that we have the
7482 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
7483 sig_type
= (struct signatured_type
*) this_cu
;
7484 gdb_assert (sig_type
->dwo_unit
!= NULL
);
7486 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
7488 gdb_assert (this_cu
->cu
->dwo_unit
== sig_type
->dwo_unit
);
7489 /* There's no need to do the rereading_dwo_cu handling that
7490 init_cutu_and_read_dies does since we don't read the stub. */
7494 /* If !use_existing_cu, this_cu->cu must be NULL. */
7495 gdb_assert (this_cu
->cu
== NULL
);
7496 new_cu
.reset (new dwarf2_cu (this_cu
));
7499 /* A future optimization, if needed, would be to use an existing
7500 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7501 could share abbrev tables. */
7503 /* The abbreviation table used by READER, this must live at least as long as
7505 abbrev_table_up dwo_abbrev_table
;
7507 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
7508 NULL
/* stub_comp_unit_die */,
7509 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
7511 &comp_unit_die
, &has_children
,
7512 &dwo_abbrev_table
) == 0)
7518 /* All the "real" work is done here. */
7519 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7521 /* This duplicates the code in init_cutu_and_read_dies,
7522 but the alternative is making the latter more complex.
7523 This function is only for the special case of using DWO files directly:
7524 no point in overly complicating the general case just to handle this. */
7525 if (new_cu
!= NULL
&& keep
)
7527 /* Link this CU into read_in_chain. */
7528 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
7529 dwarf2_per_objfile
->read_in_chain
= this_cu
;
7530 /* The chain owns it now. */
7535 /* Initialize a CU (or TU) and read its DIEs.
7536 If the CU defers to a DWO file, read the DWO file as well.
7538 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7539 Otherwise the table specified in the comp unit header is read in and used.
7540 This is an optimization for when we already have the abbrev table.
7542 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7543 Otherwise, a new CU is allocated with xmalloc.
7545 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7546 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7548 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7549 linker) then DIE_READER_FUNC will not get called. */
7552 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
7553 struct abbrev_table
*abbrev_table
,
7554 int use_existing_cu
, int keep
,
7556 die_reader_func_ftype
*die_reader_func
,
7559 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7560 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7561 struct dwarf2_section_info
*section
= this_cu
->section
;
7562 bfd
*abfd
= get_section_bfd_owner (section
);
7563 struct dwarf2_cu
*cu
;
7564 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7565 struct die_reader_specs reader
;
7566 struct die_info
*comp_unit_die
;
7568 struct signatured_type
*sig_type
= NULL
;
7569 struct dwarf2_section_info
*abbrev_section
;
7570 /* Non-zero if CU currently points to a DWO file and we need to
7571 reread it. When this happens we need to reread the skeleton die
7572 before we can reread the DWO file (this only applies to CUs, not TUs). */
7573 int rereading_dwo_cu
= 0;
7575 if (dwarf_die_debug
)
7576 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7577 this_cu
->is_debug_types
? "type" : "comp",
7578 sect_offset_str (this_cu
->sect_off
));
7580 if (use_existing_cu
)
7583 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7584 file (instead of going through the stub), short-circuit all of this. */
7585 if (this_cu
->reading_dwo_directly
)
7587 /* Narrow down the scope of possibilities to have to understand. */
7588 gdb_assert (this_cu
->is_debug_types
);
7589 gdb_assert (abbrev_table
== NULL
);
7590 init_tu_and_read_dwo_dies (this_cu
, use_existing_cu
, keep
,
7591 die_reader_func
, data
);
7595 /* This is cheap if the section is already read in. */
7596 dwarf2_read_section (objfile
, section
);
7598 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7600 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
7602 std::unique_ptr
<dwarf2_cu
> new_cu
;
7603 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
7606 /* If this CU is from a DWO file we need to start over, we need to
7607 refetch the attributes from the skeleton CU.
7608 This could be optimized by retrieving those attributes from when we
7609 were here the first time: the previous comp_unit_die was stored in
7610 comp_unit_obstack. But there's no data yet that we need this
7612 if (cu
->dwo_unit
!= NULL
)
7613 rereading_dwo_cu
= 1;
7617 /* If !use_existing_cu, this_cu->cu must be NULL. */
7618 gdb_assert (this_cu
->cu
== NULL
);
7619 new_cu
.reset (new dwarf2_cu (this_cu
));
7623 /* Get the header. */
7624 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
7626 /* We already have the header, there's no need to read it in again. */
7627 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
7631 if (this_cu
->is_debug_types
)
7633 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7634 &cu
->header
, section
,
7635 abbrev_section
, info_ptr
,
7638 /* Since per_cu is the first member of struct signatured_type,
7639 we can go from a pointer to one to a pointer to the other. */
7640 sig_type
= (struct signatured_type
*) this_cu
;
7641 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
7642 gdb_assert (sig_type
->type_offset_in_tu
7643 == cu
->header
.type_cu_offset_in_tu
);
7644 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7646 /* LENGTH has not been set yet for type units if we're
7647 using .gdb_index. */
7648 this_cu
->length
= get_cu_length (&cu
->header
);
7650 /* Establish the type offset that can be used to lookup the type. */
7651 sig_type
->type_offset_in_section
=
7652 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
7654 this_cu
->dwarf_version
= cu
->header
.version
;
7658 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7659 &cu
->header
, section
,
7662 rcuh_kind::COMPILE
);
7664 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7665 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
7666 this_cu
->dwarf_version
= cu
->header
.version
;
7670 /* Skip dummy compilation units. */
7671 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7672 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7675 /* If we don't have them yet, read the abbrevs for this compilation unit.
7676 And if we need to read them now, make sure they're freed when we're
7677 done (own the table through ABBREV_TABLE_HOLDER). */
7678 abbrev_table_up abbrev_table_holder
;
7679 if (abbrev_table
!= NULL
)
7680 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
7684 = abbrev_table_read_table (dwarf2_per_objfile
, abbrev_section
,
7685 cu
->header
.abbrev_sect_off
);
7686 abbrev_table
= abbrev_table_holder
.get ();
7689 /* Read the top level CU/TU die. */
7690 init_cu_die_reader (&reader
, cu
, section
, NULL
, abbrev_table
);
7691 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
7693 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
7696 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7697 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7698 table from the DWO file and pass the ownership over to us. It will be
7699 referenced from READER, so we must make sure to free it after we're done
7702 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7703 DWO CU, that this test will fail (the attribute will not be present). */
7704 const char *dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7705 abbrev_table_up dwo_abbrev_table
;
7706 if (dwo_name
!= nullptr)
7708 struct dwo_unit
*dwo_unit
;
7709 struct die_info
*dwo_comp_unit_die
;
7713 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7714 " has children (offset %s) [in module %s]"),
7715 sect_offset_str (this_cu
->sect_off
),
7716 bfd_get_filename (abfd
));
7718 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
7719 if (dwo_unit
!= NULL
)
7721 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
7722 comp_unit_die
, NULL
,
7724 &dwo_comp_unit_die
, &has_children
,
7725 &dwo_abbrev_table
) == 0)
7730 comp_unit_die
= dwo_comp_unit_die
;
7734 /* Yikes, we couldn't find the rest of the DIE, we only have
7735 the stub. A complaint has already been logged. There's
7736 not much more we can do except pass on the stub DIE to
7737 die_reader_func. We don't want to throw an error on bad
7742 /* All of the above is setup for this call. Yikes. */
7743 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7745 /* Done, clean up. */
7746 if (new_cu
!= NULL
&& keep
)
7748 /* Link this CU into read_in_chain. */
7749 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
7750 dwarf2_per_objfile
->read_in_chain
= this_cu
;
7751 /* The chain owns it now. */
7756 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7757 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7758 to have already done the lookup to find the DWO file).
7760 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7761 THIS_CU->is_debug_types, but nothing else.
7763 We fill in THIS_CU->length.
7765 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7766 linker) then DIE_READER_FUNC will not get called.
7768 THIS_CU->cu is always freed when done.
7769 This is done in order to not leave THIS_CU->cu in a state where we have
7770 to care whether it refers to the "main" CU or the DWO CU. */
7773 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
7774 struct dwo_file
*dwo_file
,
7775 die_reader_func_ftype
*die_reader_func
,
7778 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7779 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7780 struct dwarf2_section_info
*section
= this_cu
->section
;
7781 bfd
*abfd
= get_section_bfd_owner (section
);
7782 struct dwarf2_section_info
*abbrev_section
;
7783 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7784 struct die_reader_specs reader
;
7785 struct die_info
*comp_unit_die
;
7788 if (dwarf_die_debug
)
7789 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7790 this_cu
->is_debug_types
? "type" : "comp",
7791 sect_offset_str (this_cu
->sect_off
));
7793 gdb_assert (this_cu
->cu
== NULL
);
7795 abbrev_section
= (dwo_file
!= NULL
7796 ? &dwo_file
->sections
.abbrev
7797 : get_abbrev_section_for_cu (this_cu
));
7799 /* This is cheap if the section is already read in. */
7800 dwarf2_read_section (objfile
, section
);
7802 struct dwarf2_cu
cu (this_cu
);
7804 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7805 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7806 &cu
.header
, section
,
7807 abbrev_section
, info_ptr
,
7808 (this_cu
->is_debug_types
7810 : rcuh_kind::COMPILE
));
7812 this_cu
->length
= get_cu_length (&cu
.header
);
7814 /* Skip dummy compilation units. */
7815 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7816 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7819 abbrev_table_up abbrev_table
7820 = abbrev_table_read_table (dwarf2_per_objfile
, abbrev_section
,
7821 cu
.header
.abbrev_sect_off
);
7823 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
, abbrev_table
.get ());
7824 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
7826 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7829 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7830 does not lookup the specified DWO file.
7831 This cannot be used to read DWO files.
7833 THIS_CU->cu is always freed when done.
7834 This is done in order to not leave THIS_CU->cu in a state where we have
7835 to care whether it refers to the "main" CU or the DWO CU.
7836 We can revisit this if the data shows there's a performance issue. */
7839 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
7840 die_reader_func_ftype
*die_reader_func
,
7843 init_cutu_and_read_dies_no_follow (this_cu
, NULL
, die_reader_func
, data
);
7846 /* Type Unit Groups.
7848 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7849 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7850 so that all types coming from the same compilation (.o file) are grouped
7851 together. A future step could be to put the types in the same symtab as
7852 the CU the types ultimately came from. */
7855 hash_type_unit_group (const void *item
)
7857 const struct type_unit_group
*tu_group
7858 = (const struct type_unit_group
*) item
;
7860 return hash_stmt_list_entry (&tu_group
->hash
);
7864 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
7866 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
7867 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
7869 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
7872 /* Allocate a hash table for type unit groups. */
7875 allocate_type_unit_groups_table (struct objfile
*objfile
)
7877 return htab_create_alloc_ex (3,
7878 hash_type_unit_group
,
7881 &objfile
->objfile_obstack
,
7882 hashtab_obstack_allocate
,
7883 dummy_obstack_deallocate
);
7886 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7887 partial symtabs. We combine several TUs per psymtab to not let the size
7888 of any one psymtab grow too big. */
7889 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7890 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7892 /* Helper routine for get_type_unit_group.
7893 Create the type_unit_group object used to hold one or more TUs. */
7895 static struct type_unit_group
*
7896 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
7898 struct dwarf2_per_objfile
*dwarf2_per_objfile
7899 = cu
->per_cu
->dwarf2_per_objfile
;
7900 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7901 struct dwarf2_per_cu_data
*per_cu
;
7902 struct type_unit_group
*tu_group
;
7904 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7905 struct type_unit_group
);
7906 per_cu
= &tu_group
->per_cu
;
7907 per_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
7909 if (dwarf2_per_objfile
->using_index
)
7911 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7912 struct dwarf2_per_cu_quick_data
);
7916 unsigned int line_offset
= to_underlying (line_offset_struct
);
7917 struct partial_symtab
*pst
;
7920 /* Give the symtab a useful name for debug purposes. */
7921 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
7922 name
= string_printf ("<type_units_%d>",
7923 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
7925 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
7927 pst
= create_partial_symtab (per_cu
, name
.c_str ());
7931 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
7932 tu_group
->hash
.line_sect_off
= line_offset_struct
;
7937 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7938 STMT_LIST is a DW_AT_stmt_list attribute. */
7940 static struct type_unit_group
*
7941 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
7943 struct dwarf2_per_objfile
*dwarf2_per_objfile
7944 = cu
->per_cu
->dwarf2_per_objfile
;
7945 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
7946 struct type_unit_group
*tu_group
;
7948 unsigned int line_offset
;
7949 struct type_unit_group type_unit_group_for_lookup
;
7951 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
7953 dwarf2_per_objfile
->type_unit_groups
=
7954 allocate_type_unit_groups_table (dwarf2_per_objfile
->objfile
);
7957 /* Do we need to create a new group, or can we use an existing one? */
7961 line_offset
= DW_UNSND (stmt_list
);
7962 ++tu_stats
->nr_symtab_sharers
;
7966 /* Ugh, no stmt_list. Rare, but we have to handle it.
7967 We can do various things here like create one group per TU or
7968 spread them over multiple groups to split up the expansion work.
7969 To avoid worst case scenarios (too many groups or too large groups)
7970 we, umm, group them in bunches. */
7971 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7972 | (tu_stats
->nr_stmt_less_type_units
7973 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
7974 ++tu_stats
->nr_stmt_less_type_units
;
7977 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
7978 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
7979 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
7980 &type_unit_group_for_lookup
, INSERT
);
7983 tu_group
= (struct type_unit_group
*) *slot
;
7984 gdb_assert (tu_group
!= NULL
);
7988 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
7989 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
7991 ++tu_stats
->nr_symtabs
;
7997 /* Partial symbol tables. */
7999 /* Create a psymtab named NAME and assign it to PER_CU.
8001 The caller must fill in the following details:
8002 dirname, textlow, texthigh. */
8004 static struct partial_symtab
*
8005 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
8007 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
8008 struct partial_symtab
*pst
;
8010 pst
= start_psymtab_common (objfile
, name
, 0);
8012 pst
->psymtabs_addrmap_supported
= 1;
8014 /* This is the glue that links PST into GDB's symbol API. */
8015 pst
->read_symtab_private
= per_cu
;
8016 pst
->read_symtab
= dwarf2_read_symtab
;
8017 per_cu
->v
.psymtab
= pst
;
8022 /* The DATA object passed to process_psymtab_comp_unit_reader has this
8025 struct process_psymtab_comp_unit_data
8027 /* True if we are reading a DW_TAG_partial_unit. */
8029 int want_partial_unit
;
8031 /* The "pretend" language that is used if the CU doesn't declare a
8034 enum language pretend_language
;
8037 /* die_reader_func for process_psymtab_comp_unit. */
8040 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
8041 const gdb_byte
*info_ptr
,
8042 struct die_info
*comp_unit_die
,
8046 struct dwarf2_cu
*cu
= reader
->cu
;
8047 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
8048 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8049 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
8051 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
8052 struct partial_symtab
*pst
;
8053 enum pc_bounds_kind cu_bounds_kind
;
8054 const char *filename
;
8055 struct process_psymtab_comp_unit_data
*info
8056 = (struct process_psymtab_comp_unit_data
*) data
;
8058 if (comp_unit_die
->tag
== DW_TAG_partial_unit
&& !info
->want_partial_unit
)
8061 gdb_assert (! per_cu
->is_debug_types
);
8063 prepare_one_comp_unit (cu
, comp_unit_die
, info
->pretend_language
);
8065 /* Allocate a new partial symbol table structure. */
8066 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
8067 if (filename
== NULL
)
8070 pst
= create_partial_symtab (per_cu
, filename
);
8072 /* This must be done before calling dwarf2_build_include_psymtabs. */
8073 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
8075 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8077 dwarf2_find_base_address (comp_unit_die
, cu
);
8079 /* Possibly set the default values of LOWPC and HIGHPC from
8081 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
8082 &best_highpc
, cu
, pst
);
8083 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
8086 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
8089 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
8091 /* Store the contiguous range if it is not empty; it can be
8092 empty for CUs with no code. */
8093 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
8097 /* Check if comp unit has_children.
8098 If so, read the rest of the partial symbols from this comp unit.
8099 If not, there's no more debug_info for this comp unit. */
8102 struct partial_die_info
*first_die
;
8103 CORE_ADDR lowpc
, highpc
;
8105 lowpc
= ((CORE_ADDR
) -1);
8106 highpc
= ((CORE_ADDR
) 0);
8108 first_die
= load_partial_dies (reader
, info_ptr
, 1);
8110 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
8111 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
8113 /* If we didn't find a lowpc, set it to highpc to avoid
8114 complaints from `maint check'. */
8115 if (lowpc
== ((CORE_ADDR
) -1))
8118 /* If the compilation unit didn't have an explicit address range,
8119 then use the information extracted from its child dies. */
8120 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
8123 best_highpc
= highpc
;
8126 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
8127 best_lowpc
+ baseaddr
)
8129 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
8130 best_highpc
+ baseaddr
)
8133 end_psymtab_common (objfile
, pst
);
8135 if (!cu
->per_cu
->imported_symtabs_empty ())
8138 int len
= cu
->per_cu
->imported_symtabs_size ();
8140 /* Fill in 'dependencies' here; we fill in 'users' in a
8142 pst
->number_of_dependencies
= len
;
8144 = objfile
->partial_symtabs
->allocate_dependencies (len
);
8145 for (i
= 0; i
< len
; ++i
)
8147 pst
->dependencies
[i
]
8148 = cu
->per_cu
->imported_symtabs
->at (i
)->v
.psymtab
;
8151 cu
->per_cu
->imported_symtabs_free ();
8154 /* Get the list of files included in the current compilation unit,
8155 and build a psymtab for each of them. */
8156 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
8158 if (dwarf_read_debug
)
8159 fprintf_unfiltered (gdb_stdlog
,
8160 "Psymtab for %s unit @%s: %s - %s"
8161 ", %d global, %d static syms\n",
8162 per_cu
->is_debug_types
? "type" : "comp",
8163 sect_offset_str (per_cu
->sect_off
),
8164 paddress (gdbarch
, pst
->text_low (objfile
)),
8165 paddress (gdbarch
, pst
->text_high (objfile
)),
8166 pst
->n_global_syms
, pst
->n_static_syms
);
8169 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8170 Process compilation unit THIS_CU for a psymtab. */
8173 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
8174 int want_partial_unit
,
8175 enum language pretend_language
)
8177 /* If this compilation unit was already read in, free the
8178 cached copy in order to read it in again. This is
8179 necessary because we skipped some symbols when we first
8180 read in the compilation unit (see load_partial_dies).
8181 This problem could be avoided, but the benefit is unclear. */
8182 if (this_cu
->cu
!= NULL
)
8183 free_one_cached_comp_unit (this_cu
);
8185 if (this_cu
->is_debug_types
)
8186 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0, false,
8187 build_type_psymtabs_reader
, NULL
);
8190 process_psymtab_comp_unit_data info
;
8191 info
.want_partial_unit
= want_partial_unit
;
8192 info
.pretend_language
= pretend_language
;
8193 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0, false,
8194 process_psymtab_comp_unit_reader
, &info
);
8197 /* Age out any secondary CUs. */
8198 age_cached_comp_units (this_cu
->dwarf2_per_objfile
);
8201 /* Reader function for build_type_psymtabs. */
8204 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
8205 const gdb_byte
*info_ptr
,
8206 struct die_info
*type_unit_die
,
8210 struct dwarf2_per_objfile
*dwarf2_per_objfile
8211 = reader
->cu
->per_cu
->dwarf2_per_objfile
;
8212 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8213 struct dwarf2_cu
*cu
= reader
->cu
;
8214 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
8215 struct signatured_type
*sig_type
;
8216 struct type_unit_group
*tu_group
;
8217 struct attribute
*attr
;
8218 struct partial_die_info
*first_die
;
8219 CORE_ADDR lowpc
, highpc
;
8220 struct partial_symtab
*pst
;
8222 gdb_assert (data
== NULL
);
8223 gdb_assert (per_cu
->is_debug_types
);
8224 sig_type
= (struct signatured_type
*) per_cu
;
8229 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
8230 tu_group
= get_type_unit_group (cu
, attr
);
8232 if (tu_group
->tus
== nullptr)
8233 tu_group
->tus
= new std::vector
<signatured_type
*>;
8234 tu_group
->tus
->push_back (sig_type
);
8236 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
8237 pst
= create_partial_symtab (per_cu
, "");
8240 first_die
= load_partial_dies (reader
, info_ptr
, 1);
8242 lowpc
= (CORE_ADDR
) -1;
8243 highpc
= (CORE_ADDR
) 0;
8244 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
8246 end_psymtab_common (objfile
, pst
);
8249 /* Struct used to sort TUs by their abbreviation table offset. */
8251 struct tu_abbrev_offset
8253 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
8254 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
8257 signatured_type
*sig_type
;
8258 sect_offset abbrev_offset
;
8261 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
8264 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset
&a
,
8265 const struct tu_abbrev_offset
&b
)
8267 return a
.abbrev_offset
< b
.abbrev_offset
;
8270 /* Efficiently read all the type units.
8271 This does the bulk of the work for build_type_psymtabs.
8273 The efficiency is because we sort TUs by the abbrev table they use and
8274 only read each abbrev table once. In one program there are 200K TUs
8275 sharing 8K abbrev tables.
8277 The main purpose of this function is to support building the
8278 dwarf2_per_objfile->type_unit_groups table.
8279 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8280 can collapse the search space by grouping them by stmt_list.
8281 The savings can be significant, in the same program from above the 200K TUs
8282 share 8K stmt_list tables.
8284 FUNC is expected to call get_type_unit_group, which will create the
8285 struct type_unit_group if necessary and add it to
8286 dwarf2_per_objfile->type_unit_groups. */
8289 build_type_psymtabs_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8291 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
8292 abbrev_table_up abbrev_table
;
8293 sect_offset abbrev_offset
;
8295 /* It's up to the caller to not call us multiple times. */
8296 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
8298 if (dwarf2_per_objfile
->all_type_units
.empty ())
8301 /* TUs typically share abbrev tables, and there can be way more TUs than
8302 abbrev tables. Sort by abbrev table to reduce the number of times we
8303 read each abbrev table in.
8304 Alternatives are to punt or to maintain a cache of abbrev tables.
8305 This is simpler and efficient enough for now.
8307 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8308 symtab to use). Typically TUs with the same abbrev offset have the same
8309 stmt_list value too so in practice this should work well.
8311 The basic algorithm here is:
8313 sort TUs by abbrev table
8314 for each TU with same abbrev table:
8315 read abbrev table if first user
8316 read TU top level DIE
8317 [IWBN if DWO skeletons had DW_AT_stmt_list]
8320 if (dwarf_read_debug
)
8321 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
8323 /* Sort in a separate table to maintain the order of all_type_units
8324 for .gdb_index: TU indices directly index all_type_units. */
8325 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
8326 sorted_by_abbrev
.reserve (dwarf2_per_objfile
->all_type_units
.size ());
8328 for (signatured_type
*sig_type
: dwarf2_per_objfile
->all_type_units
)
8329 sorted_by_abbrev
.emplace_back
8330 (sig_type
, read_abbrev_offset (dwarf2_per_objfile
,
8331 sig_type
->per_cu
.section
,
8332 sig_type
->per_cu
.sect_off
));
8334 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end (),
8335 sort_tu_by_abbrev_offset
);
8337 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
8339 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
8341 /* Switch to the next abbrev table if necessary. */
8342 if (abbrev_table
== NULL
8343 || tu
.abbrev_offset
!= abbrev_offset
)
8345 abbrev_offset
= tu
.abbrev_offset
;
8347 abbrev_table_read_table (dwarf2_per_objfile
,
8348 &dwarf2_per_objfile
->abbrev
,
8350 ++tu_stats
->nr_uniq_abbrev_tables
;
8353 init_cutu_and_read_dies (&tu
.sig_type
->per_cu
, abbrev_table
.get (),
8354 0, 0, false, build_type_psymtabs_reader
, NULL
);
8358 /* Print collected type unit statistics. */
8361 print_tu_stats (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8363 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
8365 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
8366 fprintf_unfiltered (gdb_stdlog
, " %zu TUs\n",
8367 dwarf2_per_objfile
->all_type_units
.size ());
8368 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
8369 tu_stats
->nr_uniq_abbrev_tables
);
8370 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
8371 tu_stats
->nr_symtabs
);
8372 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
8373 tu_stats
->nr_symtab_sharers
);
8374 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
8375 tu_stats
->nr_stmt_less_type_units
);
8376 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
8377 tu_stats
->nr_all_type_units_reallocs
);
8380 /* Traversal function for build_type_psymtabs. */
8383 build_type_psymtab_dependencies (void **slot
, void *info
)
8385 struct dwarf2_per_objfile
*dwarf2_per_objfile
8386 = (struct dwarf2_per_objfile
*) info
;
8387 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8388 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
8389 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
8390 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8391 int len
= (tu_group
->tus
== nullptr) ? 0 : tu_group
->tus
->size ();
8394 gdb_assert (len
> 0);
8395 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
8397 pst
->number_of_dependencies
= len
;
8398 pst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (len
);
8399 for (i
= 0; i
< len
; ++i
)
8401 struct signatured_type
*iter
= tu_group
->tus
->at (i
);
8402 gdb_assert (iter
->per_cu
.is_debug_types
);
8403 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
8404 iter
->type_unit_group
= tu_group
;
8407 delete tu_group
->tus
;
8408 tu_group
->tus
= nullptr;
8413 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8414 Build partial symbol tables for the .debug_types comp-units. */
8417 build_type_psymtabs (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8419 if (! create_all_type_units (dwarf2_per_objfile
))
8422 build_type_psymtabs_1 (dwarf2_per_objfile
);
8425 /* Traversal function for process_skeletonless_type_unit.
8426 Read a TU in a DWO file and build partial symbols for it. */
8429 process_skeletonless_type_unit (void **slot
, void *info
)
8431 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
8432 struct dwarf2_per_objfile
*dwarf2_per_objfile
8433 = (struct dwarf2_per_objfile
*) info
;
8434 struct signatured_type find_entry
, *entry
;
8436 /* If this TU doesn't exist in the global table, add it and read it in. */
8438 if (dwarf2_per_objfile
->signatured_types
== NULL
)
8440 dwarf2_per_objfile
->signatured_types
8441 = allocate_signatured_type_table (dwarf2_per_objfile
->objfile
);
8444 find_entry
.signature
= dwo_unit
->signature
;
8445 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
, &find_entry
,
8447 /* If we've already seen this type there's nothing to do. What's happening
8448 is we're doing our own version of comdat-folding here. */
8452 /* This does the job that create_all_type_units would have done for
8454 entry
= add_type_unit (dwarf2_per_objfile
, dwo_unit
->signature
, slot
);
8455 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, entry
, dwo_unit
);
8458 /* This does the job that build_type_psymtabs_1 would have done. */
8459 init_cutu_and_read_dies (&entry
->per_cu
, NULL
, 0, 0, false,
8460 build_type_psymtabs_reader
, NULL
);
8465 /* Traversal function for process_skeletonless_type_units. */
8468 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
8470 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
8472 if (dwo_file
->tus
!= NULL
)
8474 htab_traverse_noresize (dwo_file
->tus
,
8475 process_skeletonless_type_unit
, info
);
8481 /* Scan all TUs of DWO files, verifying we've processed them.
8482 This is needed in case a TU was emitted without its skeleton.
8483 Note: This can't be done until we know what all the DWO files are. */
8486 process_skeletonless_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8488 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8489 if (get_dwp_file (dwarf2_per_objfile
) == NULL
8490 && dwarf2_per_objfile
->dwo_files
!= NULL
)
8492 htab_traverse_noresize (dwarf2_per_objfile
->dwo_files
.get (),
8493 process_dwo_file_for_skeletonless_type_units
,
8494 dwarf2_per_objfile
);
8498 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8501 set_partial_user (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8503 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
8505 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8510 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
8512 /* Set the 'user' field only if it is not already set. */
8513 if (pst
->dependencies
[j
]->user
== NULL
)
8514 pst
->dependencies
[j
]->user
= pst
;
8519 /* Build the partial symbol table by doing a quick pass through the
8520 .debug_info and .debug_abbrev sections. */
8523 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8525 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8527 if (dwarf_read_debug
)
8529 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
8530 objfile_name (objfile
));
8533 dwarf2_per_objfile
->reading_partial_symbols
= 1;
8535 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
8537 /* Any cached compilation units will be linked by the per-objfile
8538 read_in_chain. Make sure to free them when we're done. */
8539 free_cached_comp_units
freer (dwarf2_per_objfile
);
8541 build_type_psymtabs (dwarf2_per_objfile
);
8543 create_all_comp_units (dwarf2_per_objfile
);
8545 /* Create a temporary address map on a temporary obstack. We later
8546 copy this to the final obstack. */
8547 auto_obstack temp_obstack
;
8549 scoped_restore save_psymtabs_addrmap
8550 = make_scoped_restore (&objfile
->partial_symtabs
->psymtabs_addrmap
,
8551 addrmap_create_mutable (&temp_obstack
));
8553 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
8554 process_psymtab_comp_unit (per_cu
, 0, language_minimal
);
8556 /* This has to wait until we read the CUs, we need the list of DWOs. */
8557 process_skeletonless_type_units (dwarf2_per_objfile
);
8559 /* Now that all TUs have been processed we can fill in the dependencies. */
8560 if (dwarf2_per_objfile
->type_unit_groups
!= NULL
)
8562 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
8563 build_type_psymtab_dependencies
, dwarf2_per_objfile
);
8566 if (dwarf_read_debug
)
8567 print_tu_stats (dwarf2_per_objfile
);
8569 set_partial_user (dwarf2_per_objfile
);
8571 objfile
->partial_symtabs
->psymtabs_addrmap
8572 = addrmap_create_fixed (objfile
->partial_symtabs
->psymtabs_addrmap
,
8573 objfile
->partial_symtabs
->obstack ());
8574 /* At this point we want to keep the address map. */
8575 save_psymtabs_addrmap
.release ();
8577 if (dwarf_read_debug
)
8578 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
8579 objfile_name (objfile
));
8582 /* die_reader_func for load_partial_comp_unit. */
8585 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
8586 const gdb_byte
*info_ptr
,
8587 struct die_info
*comp_unit_die
,
8591 struct dwarf2_cu
*cu
= reader
->cu
;
8593 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
8595 /* Check if comp unit has_children.
8596 If so, read the rest of the partial symbols from this comp unit.
8597 If not, there's no more debug_info for this comp unit. */
8599 load_partial_dies (reader
, info_ptr
, 0);
8602 /* Load the partial DIEs for a secondary CU into memory.
8603 This is also used when rereading a primary CU with load_all_dies. */
8606 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
8608 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1, false,
8609 load_partial_comp_unit_reader
, NULL
);
8613 read_comp_units_from_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
8614 struct dwarf2_section_info
*section
,
8615 struct dwarf2_section_info
*abbrev_section
,
8616 unsigned int is_dwz
)
8618 const gdb_byte
*info_ptr
;
8619 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8621 if (dwarf_read_debug
)
8622 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
8623 get_section_name (section
),
8624 get_section_file_name (section
));
8626 dwarf2_read_section (objfile
, section
);
8628 info_ptr
= section
->buffer
;
8630 while (info_ptr
< section
->buffer
+ section
->size
)
8632 struct dwarf2_per_cu_data
*this_cu
;
8634 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
8636 comp_unit_head cu_header
;
8637 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
8638 abbrev_section
, info_ptr
,
8639 rcuh_kind::COMPILE
);
8641 /* Save the compilation unit for later lookup. */
8642 if (cu_header
.unit_type
!= DW_UT_type
)
8644 this_cu
= XOBNEW (&objfile
->objfile_obstack
,
8645 struct dwarf2_per_cu_data
);
8646 memset (this_cu
, 0, sizeof (*this_cu
));
8650 auto sig_type
= XOBNEW (&objfile
->objfile_obstack
,
8651 struct signatured_type
);
8652 memset (sig_type
, 0, sizeof (*sig_type
));
8653 sig_type
->signature
= cu_header
.signature
;
8654 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
8655 this_cu
= &sig_type
->per_cu
;
8657 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
8658 this_cu
->sect_off
= sect_off
;
8659 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
8660 this_cu
->is_dwz
= is_dwz
;
8661 this_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
8662 this_cu
->section
= section
;
8664 dwarf2_per_objfile
->all_comp_units
.push_back (this_cu
);
8666 info_ptr
= info_ptr
+ this_cu
->length
;
8670 /* Create a list of all compilation units in OBJFILE.
8671 This is only done for -readnow and building partial symtabs. */
8674 create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8676 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
8677 read_comp_units_from_section (dwarf2_per_objfile
, &dwarf2_per_objfile
->info
,
8678 &dwarf2_per_objfile
->abbrev
, 0);
8680 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
8682 read_comp_units_from_section (dwarf2_per_objfile
, &dwz
->info
, &dwz
->abbrev
,
8686 /* Process all loaded DIEs for compilation unit CU, starting at
8687 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8688 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8689 DW_AT_ranges). See the comments of add_partial_subprogram on how
8690 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8693 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
8694 CORE_ADDR
*highpc
, int set_addrmap
,
8695 struct dwarf2_cu
*cu
)
8697 struct partial_die_info
*pdi
;
8699 /* Now, march along the PDI's, descending into ones which have
8700 interesting children but skipping the children of the other ones,
8701 until we reach the end of the compilation unit. */
8709 /* Anonymous namespaces or modules have no name but have interesting
8710 children, so we need to look at them. Ditto for anonymous
8713 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
8714 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
8715 || pdi
->tag
== DW_TAG_imported_unit
8716 || pdi
->tag
== DW_TAG_inlined_subroutine
)
8720 case DW_TAG_subprogram
:
8721 case DW_TAG_inlined_subroutine
:
8722 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8724 case DW_TAG_constant
:
8725 case DW_TAG_variable
:
8726 case DW_TAG_typedef
:
8727 case DW_TAG_union_type
:
8728 if (!pdi
->is_declaration
)
8730 add_partial_symbol (pdi
, cu
);
8733 case DW_TAG_class_type
:
8734 case DW_TAG_interface_type
:
8735 case DW_TAG_structure_type
:
8736 if (!pdi
->is_declaration
)
8738 add_partial_symbol (pdi
, cu
);
8740 if ((cu
->language
== language_rust
8741 || cu
->language
== language_cplus
) && pdi
->has_children
)
8742 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8745 case DW_TAG_enumeration_type
:
8746 if (!pdi
->is_declaration
)
8747 add_partial_enumeration (pdi
, cu
);
8749 case DW_TAG_base_type
:
8750 case DW_TAG_subrange_type
:
8751 /* File scope base type definitions are added to the partial
8753 add_partial_symbol (pdi
, cu
);
8755 case DW_TAG_namespace
:
8756 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8759 if (!pdi
->is_declaration
)
8760 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8762 case DW_TAG_imported_unit
:
8764 struct dwarf2_per_cu_data
*per_cu
;
8766 /* For now we don't handle imported units in type units. */
8767 if (cu
->per_cu
->is_debug_types
)
8769 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8770 " supported in type units [in module %s]"),
8771 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
8774 per_cu
= dwarf2_find_containing_comp_unit
8775 (pdi
->d
.sect_off
, pdi
->is_dwz
,
8776 cu
->per_cu
->dwarf2_per_objfile
);
8778 /* Go read the partial unit, if needed. */
8779 if (per_cu
->v
.psymtab
== NULL
)
8780 process_psymtab_comp_unit (per_cu
, 1, cu
->language
);
8782 cu
->per_cu
->imported_symtabs_push (per_cu
);
8785 case DW_TAG_imported_declaration
:
8786 add_partial_symbol (pdi
, cu
);
8793 /* If the die has a sibling, skip to the sibling. */
8795 pdi
= pdi
->die_sibling
;
8799 /* Functions used to compute the fully scoped name of a partial DIE.
8801 Normally, this is simple. For C++, the parent DIE's fully scoped
8802 name is concatenated with "::" and the partial DIE's name.
8803 Enumerators are an exception; they use the scope of their parent
8804 enumeration type, i.e. the name of the enumeration type is not
8805 prepended to the enumerator.
8807 There are two complexities. One is DW_AT_specification; in this
8808 case "parent" means the parent of the target of the specification,
8809 instead of the direct parent of the DIE. The other is compilers
8810 which do not emit DW_TAG_namespace; in this case we try to guess
8811 the fully qualified name of structure types from their members'
8812 linkage names. This must be done using the DIE's children rather
8813 than the children of any DW_AT_specification target. We only need
8814 to do this for structures at the top level, i.e. if the target of
8815 any DW_AT_specification (if any; otherwise the DIE itself) does not
8818 /* Compute the scope prefix associated with PDI's parent, in
8819 compilation unit CU. The result will be allocated on CU's
8820 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8821 field. NULL is returned if no prefix is necessary. */
8823 partial_die_parent_scope (struct partial_die_info
*pdi
,
8824 struct dwarf2_cu
*cu
)
8826 const char *grandparent_scope
;
8827 struct partial_die_info
*parent
, *real_pdi
;
8829 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8830 then this means the parent of the specification DIE. */
8833 while (real_pdi
->has_specification
)
8835 auto res
= find_partial_die (real_pdi
->spec_offset
,
8836 real_pdi
->spec_is_dwz
, cu
);
8841 parent
= real_pdi
->die_parent
;
8845 if (parent
->scope_set
)
8846 return parent
->scope
;
8850 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
8852 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8853 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8854 Work around this problem here. */
8855 if (cu
->language
== language_cplus
8856 && parent
->tag
== DW_TAG_namespace
8857 && strcmp (parent
->name
, "::") == 0
8858 && grandparent_scope
== NULL
)
8860 parent
->scope
= NULL
;
8861 parent
->scope_set
= 1;
8865 /* Nested subroutines in Fortran get a prefix. */
8866 if (pdi
->tag
== DW_TAG_enumerator
)
8867 /* Enumerators should not get the name of the enumeration as a prefix. */
8868 parent
->scope
= grandparent_scope
;
8869 else if (parent
->tag
== DW_TAG_namespace
8870 || parent
->tag
== DW_TAG_module
8871 || parent
->tag
== DW_TAG_structure_type
8872 || parent
->tag
== DW_TAG_class_type
8873 || parent
->tag
== DW_TAG_interface_type
8874 || parent
->tag
== DW_TAG_union_type
8875 || parent
->tag
== DW_TAG_enumeration_type
8876 || (cu
->language
== language_fortran
8877 && parent
->tag
== DW_TAG_subprogram
8878 && pdi
->tag
== DW_TAG_subprogram
))
8880 if (grandparent_scope
== NULL
)
8881 parent
->scope
= parent
->name
;
8883 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
8885 parent
->name
, 0, cu
);
8889 /* FIXME drow/2004-04-01: What should we be doing with
8890 function-local names? For partial symbols, we should probably be
8892 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8893 dwarf_tag_name (parent
->tag
),
8894 sect_offset_str (pdi
->sect_off
));
8895 parent
->scope
= grandparent_scope
;
8898 parent
->scope_set
= 1;
8899 return parent
->scope
;
8902 /* Return the fully scoped name associated with PDI, from compilation unit
8903 CU. The result will be allocated with malloc. */
8905 static gdb::unique_xmalloc_ptr
<char>
8906 partial_die_full_name (struct partial_die_info
*pdi
,
8907 struct dwarf2_cu
*cu
)
8909 const char *parent_scope
;
8911 /* If this is a template instantiation, we can not work out the
8912 template arguments from partial DIEs. So, unfortunately, we have
8913 to go through the full DIEs. At least any work we do building
8914 types here will be reused if full symbols are loaded later. */
8915 if (pdi
->has_template_arguments
)
8919 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
8921 struct die_info
*die
;
8922 struct attribute attr
;
8923 struct dwarf2_cu
*ref_cu
= cu
;
8925 /* DW_FORM_ref_addr is using section offset. */
8926 attr
.name
= (enum dwarf_attribute
) 0;
8927 attr
.form
= DW_FORM_ref_addr
;
8928 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
8929 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
8931 return make_unique_xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
8935 parent_scope
= partial_die_parent_scope (pdi
, cu
);
8936 if (parent_scope
== NULL
)
8939 return gdb::unique_xmalloc_ptr
<char> (typename_concat (NULL
, parent_scope
,
8944 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
8946 struct dwarf2_per_objfile
*dwarf2_per_objfile
8947 = cu
->per_cu
->dwarf2_per_objfile
;
8948 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8949 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8951 const char *actual_name
= NULL
;
8954 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8956 gdb::unique_xmalloc_ptr
<char> built_actual_name
8957 = partial_die_full_name (pdi
, cu
);
8958 if (built_actual_name
!= NULL
)
8959 actual_name
= built_actual_name
.get ();
8961 if (actual_name
== NULL
)
8962 actual_name
= pdi
->name
;
8966 case DW_TAG_inlined_subroutine
:
8967 case DW_TAG_subprogram
:
8968 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
8970 if (pdi
->is_external
8971 || cu
->language
== language_ada
8972 || (cu
->language
== language_fortran
8973 && pdi
->die_parent
!= NULL
8974 && pdi
->die_parent
->tag
== DW_TAG_subprogram
))
8976 /* Normally, only "external" DIEs are part of the global scope.
8977 But in Ada and Fortran, we want to be able to access nested
8978 procedures globally. So all Ada and Fortran subprograms are
8979 stored in the global scope. */
8980 add_psymbol_to_list (actual_name
,
8981 built_actual_name
!= NULL
,
8982 VAR_DOMAIN
, LOC_BLOCK
,
8983 SECT_OFF_TEXT (objfile
),
8984 psymbol_placement::GLOBAL
,
8986 cu
->language
, objfile
);
8990 add_psymbol_to_list (actual_name
,
8991 built_actual_name
!= NULL
,
8992 VAR_DOMAIN
, LOC_BLOCK
,
8993 SECT_OFF_TEXT (objfile
),
8994 psymbol_placement::STATIC
,
8995 addr
, cu
->language
, objfile
);
8998 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8999 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
9001 case DW_TAG_constant
:
9002 add_psymbol_to_list (actual_name
,
9003 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
9004 -1, (pdi
->is_external
9005 ? psymbol_placement::GLOBAL
9006 : psymbol_placement::STATIC
),
9007 0, cu
->language
, objfile
);
9009 case DW_TAG_variable
:
9011 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
9015 && !dwarf2_per_objfile
->has_section_at_zero
)
9017 /* A global or static variable may also have been stripped
9018 out by the linker if unused, in which case its address
9019 will be nullified; do not add such variables into partial
9020 symbol table then. */
9022 else if (pdi
->is_external
)
9025 Don't enter into the minimal symbol tables as there is
9026 a minimal symbol table entry from the ELF symbols already.
9027 Enter into partial symbol table if it has a location
9028 descriptor or a type.
9029 If the location descriptor is missing, new_symbol will create
9030 a LOC_UNRESOLVED symbol, the address of the variable will then
9031 be determined from the minimal symbol table whenever the variable
9033 The address for the partial symbol table entry is not
9034 used by GDB, but it comes in handy for debugging partial symbol
9037 if (pdi
->d
.locdesc
|| pdi
->has_type
)
9038 add_psymbol_to_list (actual_name
,
9039 built_actual_name
!= NULL
,
9040 VAR_DOMAIN
, LOC_STATIC
,
9041 SECT_OFF_TEXT (objfile
),
9042 psymbol_placement::GLOBAL
,
9043 addr
, cu
->language
, objfile
);
9047 int has_loc
= pdi
->d
.locdesc
!= NULL
;
9049 /* Static Variable. Skip symbols whose value we cannot know (those
9050 without location descriptors or constant values). */
9051 if (!has_loc
&& !pdi
->has_const_value
)
9054 add_psymbol_to_list (actual_name
,
9055 built_actual_name
!= NULL
,
9056 VAR_DOMAIN
, LOC_STATIC
,
9057 SECT_OFF_TEXT (objfile
),
9058 psymbol_placement::STATIC
,
9060 cu
->language
, objfile
);
9063 case DW_TAG_typedef
:
9064 case DW_TAG_base_type
:
9065 case DW_TAG_subrange_type
:
9066 add_psymbol_to_list (actual_name
,
9067 built_actual_name
!= NULL
,
9068 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
9069 psymbol_placement::STATIC
,
9070 0, cu
->language
, objfile
);
9072 case DW_TAG_imported_declaration
:
9073 case DW_TAG_namespace
:
9074 add_psymbol_to_list (actual_name
,
9075 built_actual_name
!= NULL
,
9076 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
9077 psymbol_placement::GLOBAL
,
9078 0, cu
->language
, objfile
);
9081 /* With Fortran 77 there might be a "BLOCK DATA" module
9082 available without any name. If so, we skip the module as it
9083 doesn't bring any value. */
9084 if (actual_name
!= nullptr)
9085 add_psymbol_to_list (actual_name
,
9086 built_actual_name
!= NULL
,
9087 MODULE_DOMAIN
, LOC_TYPEDEF
, -1,
9088 psymbol_placement::GLOBAL
,
9089 0, cu
->language
, objfile
);
9091 case DW_TAG_class_type
:
9092 case DW_TAG_interface_type
:
9093 case DW_TAG_structure_type
:
9094 case DW_TAG_union_type
:
9095 case DW_TAG_enumeration_type
:
9096 /* Skip external references. The DWARF standard says in the section
9097 about "Structure, Union, and Class Type Entries": "An incomplete
9098 structure, union or class type is represented by a structure,
9099 union or class entry that does not have a byte size attribute
9100 and that has a DW_AT_declaration attribute." */
9101 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
9104 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9105 static vs. global. */
9106 add_psymbol_to_list (actual_name
,
9107 built_actual_name
!= NULL
,
9108 STRUCT_DOMAIN
, LOC_TYPEDEF
, -1,
9109 cu
->language
== language_cplus
9110 ? psymbol_placement::GLOBAL
9111 : psymbol_placement::STATIC
,
9112 0, cu
->language
, objfile
);
9115 case DW_TAG_enumerator
:
9116 add_psymbol_to_list (actual_name
,
9117 built_actual_name
!= NULL
,
9118 VAR_DOMAIN
, LOC_CONST
, -1,
9119 cu
->language
== language_cplus
9120 ? psymbol_placement::GLOBAL
9121 : psymbol_placement::STATIC
,
9122 0, cu
->language
, objfile
);
9129 /* Read a partial die corresponding to a namespace; also, add a symbol
9130 corresponding to that namespace to the symbol table. NAMESPACE is
9131 the name of the enclosing namespace. */
9134 add_partial_namespace (struct partial_die_info
*pdi
,
9135 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9136 int set_addrmap
, struct dwarf2_cu
*cu
)
9138 /* Add a symbol for the namespace. */
9140 add_partial_symbol (pdi
, cu
);
9142 /* Now scan partial symbols in that namespace. */
9144 if (pdi
->has_children
)
9145 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
9148 /* Read a partial die corresponding to a Fortran module. */
9151 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
9152 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
9154 /* Add a symbol for the namespace. */
9156 add_partial_symbol (pdi
, cu
);
9158 /* Now scan partial symbols in that module. */
9160 if (pdi
->has_children
)
9161 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
9164 /* Read a partial die corresponding to a subprogram or an inlined
9165 subprogram and create a partial symbol for that subprogram.
9166 When the CU language allows it, this routine also defines a partial
9167 symbol for each nested subprogram that this subprogram contains.
9168 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9169 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9171 PDI may also be a lexical block, in which case we simply search
9172 recursively for subprograms defined inside that lexical block.
9173 Again, this is only performed when the CU language allows this
9174 type of definitions. */
9177 add_partial_subprogram (struct partial_die_info
*pdi
,
9178 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9179 int set_addrmap
, struct dwarf2_cu
*cu
)
9181 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
9183 if (pdi
->has_pc_info
)
9185 if (pdi
->lowpc
< *lowpc
)
9186 *lowpc
= pdi
->lowpc
;
9187 if (pdi
->highpc
> *highpc
)
9188 *highpc
= pdi
->highpc
;
9191 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9192 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9194 CORE_ADDR this_highpc
;
9195 CORE_ADDR this_lowpc
;
9197 baseaddr
= ANOFFSET (objfile
->section_offsets
,
9198 SECT_OFF_TEXT (objfile
));
9200 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
9201 pdi
->lowpc
+ baseaddr
)
9204 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
9205 pdi
->highpc
+ baseaddr
)
9207 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
9208 this_lowpc
, this_highpc
- 1,
9209 cu
->per_cu
->v
.psymtab
);
9213 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
9215 if (!pdi
->is_declaration
)
9216 /* Ignore subprogram DIEs that do not have a name, they are
9217 illegal. Do not emit a complaint at this point, we will
9218 do so when we convert this psymtab into a symtab. */
9220 add_partial_symbol (pdi
, cu
);
9224 if (! pdi
->has_children
)
9227 if (cu
->language
== language_ada
|| cu
->language
== language_fortran
)
9229 pdi
= pdi
->die_child
;
9233 if (pdi
->tag
== DW_TAG_subprogram
9234 || pdi
->tag
== DW_TAG_inlined_subroutine
9235 || pdi
->tag
== DW_TAG_lexical_block
)
9236 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
9237 pdi
= pdi
->die_sibling
;
9242 /* Read a partial die corresponding to an enumeration type. */
9245 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
9246 struct dwarf2_cu
*cu
)
9248 struct partial_die_info
*pdi
;
9250 if (enum_pdi
->name
!= NULL
)
9251 add_partial_symbol (enum_pdi
, cu
);
9253 pdi
= enum_pdi
->die_child
;
9256 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
9257 complaint (_("malformed enumerator DIE ignored"));
9259 add_partial_symbol (pdi
, cu
);
9260 pdi
= pdi
->die_sibling
;
9264 /* Return the initial uleb128 in the die at INFO_PTR. */
9267 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
9269 unsigned int bytes_read
;
9271 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9274 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9275 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
9277 Return the corresponding abbrev, or NULL if the number is zero (indicating
9278 an empty DIE). In either case *BYTES_READ will be set to the length of
9279 the initial number. */
9281 static struct abbrev_info
*
9282 peek_die_abbrev (const die_reader_specs
&reader
,
9283 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
9285 dwarf2_cu
*cu
= reader
.cu
;
9286 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
9287 unsigned int abbrev_number
9288 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
9290 if (abbrev_number
== 0)
9293 abbrev_info
*abbrev
= reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
9296 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9297 " at offset %s [in module %s]"),
9298 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
9299 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
9305 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9306 Returns a pointer to the end of a series of DIEs, terminated by an empty
9307 DIE. Any children of the skipped DIEs will also be skipped. */
9309 static const gdb_byte
*
9310 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
9314 unsigned int bytes_read
;
9315 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
9318 return info_ptr
+ bytes_read
;
9320 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
9324 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9325 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9326 abbrev corresponding to that skipped uleb128 should be passed in
9327 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9330 static const gdb_byte
*
9331 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
9332 struct abbrev_info
*abbrev
)
9334 unsigned int bytes_read
;
9335 struct attribute attr
;
9336 bfd
*abfd
= reader
->abfd
;
9337 struct dwarf2_cu
*cu
= reader
->cu
;
9338 const gdb_byte
*buffer
= reader
->buffer
;
9339 const gdb_byte
*buffer_end
= reader
->buffer_end
;
9340 unsigned int form
, i
;
9342 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
9344 /* The only abbrev we care about is DW_AT_sibling. */
9345 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
9347 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
9348 if (attr
.form
== DW_FORM_ref_addr
)
9349 complaint (_("ignoring absolute DW_AT_sibling"));
9352 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
9353 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
9355 if (sibling_ptr
< info_ptr
)
9356 complaint (_("DW_AT_sibling points backwards"));
9357 else if (sibling_ptr
> reader
->buffer_end
)
9358 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
9364 /* If it isn't DW_AT_sibling, skip this attribute. */
9365 form
= abbrev
->attrs
[i
].form
;
9369 case DW_FORM_ref_addr
:
9370 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9371 and later it is offset sized. */
9372 if (cu
->header
.version
== 2)
9373 info_ptr
+= cu
->header
.addr_size
;
9375 info_ptr
+= cu
->header
.offset_size
;
9377 case DW_FORM_GNU_ref_alt
:
9378 info_ptr
+= cu
->header
.offset_size
;
9381 info_ptr
+= cu
->header
.addr_size
;
9389 case DW_FORM_flag_present
:
9390 case DW_FORM_implicit_const
:
9407 case DW_FORM_ref_sig8
:
9410 case DW_FORM_data16
:
9413 case DW_FORM_string
:
9414 read_direct_string (abfd
, info_ptr
, &bytes_read
);
9415 info_ptr
+= bytes_read
;
9417 case DW_FORM_sec_offset
:
9419 case DW_FORM_GNU_strp_alt
:
9420 info_ptr
+= cu
->header
.offset_size
;
9422 case DW_FORM_exprloc
:
9424 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9425 info_ptr
+= bytes_read
;
9427 case DW_FORM_block1
:
9428 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
9430 case DW_FORM_block2
:
9431 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
9433 case DW_FORM_block4
:
9434 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
9440 case DW_FORM_ref_udata
:
9441 case DW_FORM_GNU_addr_index
:
9442 case DW_FORM_GNU_str_index
:
9443 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
9445 case DW_FORM_indirect
:
9446 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9447 info_ptr
+= bytes_read
;
9448 /* We need to continue parsing from here, so just go back to
9450 goto skip_attribute
;
9453 error (_("Dwarf Error: Cannot handle %s "
9454 "in DWARF reader [in module %s]"),
9455 dwarf_form_name (form
),
9456 bfd_get_filename (abfd
));
9460 if (abbrev
->has_children
)
9461 return skip_children (reader
, info_ptr
);
9466 /* Locate ORIG_PDI's sibling.
9467 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9469 static const gdb_byte
*
9470 locate_pdi_sibling (const struct die_reader_specs
*reader
,
9471 struct partial_die_info
*orig_pdi
,
9472 const gdb_byte
*info_ptr
)
9474 /* Do we know the sibling already? */
9476 if (orig_pdi
->sibling
)
9477 return orig_pdi
->sibling
;
9479 /* Are there any children to deal with? */
9481 if (!orig_pdi
->has_children
)
9484 /* Skip the children the long way. */
9486 return skip_children (reader
, info_ptr
);
9489 /* Expand this partial symbol table into a full symbol table. SELF is
9493 dwarf2_read_symtab (struct partial_symtab
*self
,
9494 struct objfile
*objfile
)
9496 struct dwarf2_per_objfile
*dwarf2_per_objfile
9497 = get_dwarf2_per_objfile (objfile
);
9501 warning (_("bug: psymtab for %s is already read in."),
9508 printf_filtered (_("Reading in symbols for %s..."),
9510 gdb_flush (gdb_stdout
);
9513 /* If this psymtab is constructed from a debug-only objfile, the
9514 has_section_at_zero flag will not necessarily be correct. We
9515 can get the correct value for this flag by looking at the data
9516 associated with the (presumably stripped) associated objfile. */
9517 if (objfile
->separate_debug_objfile_backlink
)
9519 struct dwarf2_per_objfile
*dpo_backlink
9520 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
9522 dwarf2_per_objfile
->has_section_at_zero
9523 = dpo_backlink
->has_section_at_zero
;
9526 dwarf2_per_objfile
->reading_partial_symbols
= 0;
9528 psymtab_to_symtab_1 (self
);
9530 /* Finish up the debug error message. */
9532 printf_filtered (_("done.\n"));
9535 process_cu_includes (dwarf2_per_objfile
);
9538 /* Reading in full CUs. */
9540 /* Add PER_CU to the queue. */
9543 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
9544 enum language pretend_language
)
9546 struct dwarf2_queue_item
*item
;
9549 item
= XNEW (struct dwarf2_queue_item
);
9550 item
->per_cu
= per_cu
;
9551 item
->pretend_language
= pretend_language
;
9554 if (dwarf2_queue
== NULL
)
9555 dwarf2_queue
= item
;
9557 dwarf2_queue_tail
->next
= item
;
9559 dwarf2_queue_tail
= item
;
9562 /* If PER_CU is not yet queued, add it to the queue.
9563 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9565 The result is non-zero if PER_CU was queued, otherwise the result is zero
9566 meaning either PER_CU is already queued or it is already loaded.
9568 N.B. There is an invariant here that if a CU is queued then it is loaded.
9569 The caller is required to load PER_CU if we return non-zero. */
9572 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
9573 struct dwarf2_per_cu_data
*per_cu
,
9574 enum language pretend_language
)
9576 /* We may arrive here during partial symbol reading, if we need full
9577 DIEs to process an unusual case (e.g. template arguments). Do
9578 not queue PER_CU, just tell our caller to load its DIEs. */
9579 if (per_cu
->dwarf2_per_objfile
->reading_partial_symbols
)
9581 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
9586 /* Mark the dependence relation so that we don't flush PER_CU
9588 if (dependent_cu
!= NULL
)
9589 dwarf2_add_dependence (dependent_cu
, per_cu
);
9591 /* If it's already on the queue, we have nothing to do. */
9595 /* If the compilation unit is already loaded, just mark it as
9597 if (per_cu
->cu
!= NULL
)
9599 per_cu
->cu
->last_used
= 0;
9603 /* Add it to the queue. */
9604 queue_comp_unit (per_cu
, pretend_language
);
9609 /* Process the queue. */
9612 process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
9614 struct dwarf2_queue_item
*item
, *next_item
;
9616 if (dwarf_read_debug
)
9618 fprintf_unfiltered (gdb_stdlog
,
9619 "Expanding one or more symtabs of objfile %s ...\n",
9620 objfile_name (dwarf2_per_objfile
->objfile
));
9623 /* The queue starts out with one item, but following a DIE reference
9624 may load a new CU, adding it to the end of the queue. */
9625 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
9627 if ((dwarf2_per_objfile
->using_index
9628 ? !item
->per_cu
->v
.quick
->compunit_symtab
9629 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
9630 /* Skip dummy CUs. */
9631 && item
->per_cu
->cu
!= NULL
)
9633 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
9634 unsigned int debug_print_threshold
;
9637 if (per_cu
->is_debug_types
)
9639 struct signatured_type
*sig_type
=
9640 (struct signatured_type
*) per_cu
;
9642 sprintf (buf
, "TU %s at offset %s",
9643 hex_string (sig_type
->signature
),
9644 sect_offset_str (per_cu
->sect_off
));
9645 /* There can be 100s of TUs.
9646 Only print them in verbose mode. */
9647 debug_print_threshold
= 2;
9651 sprintf (buf
, "CU at offset %s",
9652 sect_offset_str (per_cu
->sect_off
));
9653 debug_print_threshold
= 1;
9656 if (dwarf_read_debug
>= debug_print_threshold
)
9657 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
9659 if (per_cu
->is_debug_types
)
9660 process_full_type_unit (per_cu
, item
->pretend_language
);
9662 process_full_comp_unit (per_cu
, item
->pretend_language
);
9664 if (dwarf_read_debug
>= debug_print_threshold
)
9665 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
9668 item
->per_cu
->queued
= 0;
9669 next_item
= item
->next
;
9673 dwarf2_queue_tail
= NULL
;
9675 if (dwarf_read_debug
)
9677 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
9678 objfile_name (dwarf2_per_objfile
->objfile
));
9682 /* Read in full symbols for PST, and anything it depends on. */
9685 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
9687 struct dwarf2_per_cu_data
*per_cu
;
9693 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
9694 if (!pst
->dependencies
[i
]->readin
9695 && pst
->dependencies
[i
]->user
== NULL
)
9697 /* Inform about additional files that need to be read in. */
9700 /* FIXME: i18n: Need to make this a single string. */
9701 fputs_filtered (" ", gdb_stdout
);
9703 fputs_filtered ("and ", gdb_stdout
);
9705 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
9706 wrap_here (""); /* Flush output. */
9707 gdb_flush (gdb_stdout
);
9709 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
9712 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
9716 /* It's an include file, no symbols to read for it.
9717 Everything is in the parent symtab. */
9722 dw2_do_instantiate_symtab (per_cu
, false);
9725 /* Trivial hash function for die_info: the hash value of a DIE
9726 is its offset in .debug_info for this objfile. */
9729 die_hash (const void *item
)
9731 const struct die_info
*die
= (const struct die_info
*) item
;
9733 return to_underlying (die
->sect_off
);
9736 /* Trivial comparison function for die_info structures: two DIEs
9737 are equal if they have the same offset. */
9740 die_eq (const void *item_lhs
, const void *item_rhs
)
9742 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
9743 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
9745 return die_lhs
->sect_off
== die_rhs
->sect_off
;
9748 /* die_reader_func for load_full_comp_unit.
9749 This is identical to read_signatured_type_reader,
9750 but is kept separate for now. */
9753 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
9754 const gdb_byte
*info_ptr
,
9755 struct die_info
*comp_unit_die
,
9759 struct dwarf2_cu
*cu
= reader
->cu
;
9760 enum language
*language_ptr
= (enum language
*) data
;
9762 gdb_assert (cu
->die_hash
== NULL
);
9764 htab_create_alloc_ex (cu
->header
.length
/ 12,
9768 &cu
->comp_unit_obstack
,
9769 hashtab_obstack_allocate
,
9770 dummy_obstack_deallocate
);
9773 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
9774 &info_ptr
, comp_unit_die
);
9775 cu
->dies
= comp_unit_die
;
9776 /* comp_unit_die is not stored in die_hash, no need. */
9778 /* We try not to read any attributes in this function, because not
9779 all CUs needed for references have been loaded yet, and symbol
9780 table processing isn't initialized. But we have to set the CU language,
9781 or we won't be able to build types correctly.
9782 Similarly, if we do not read the producer, we can not apply
9783 producer-specific interpretation. */
9784 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
9787 /* Load the DIEs associated with PER_CU into memory. */
9790 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
9792 enum language pretend_language
)
9794 gdb_assert (! this_cu
->is_debug_types
);
9796 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1, skip_partial
,
9797 load_full_comp_unit_reader
, &pretend_language
);
9800 /* Add a DIE to the delayed physname list. */
9803 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
9804 const char *name
, struct die_info
*die
,
9805 struct dwarf2_cu
*cu
)
9807 struct delayed_method_info mi
;
9809 mi
.fnfield_index
= fnfield_index
;
9813 cu
->method_list
.push_back (mi
);
9816 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9817 "const" / "volatile". If so, decrements LEN by the length of the
9818 modifier and return true. Otherwise return false. */
9822 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
9824 size_t mod_len
= sizeof (mod
) - 1;
9825 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
9833 /* Compute the physnames of any methods on the CU's method list.
9835 The computation of method physnames is delayed in order to avoid the
9836 (bad) condition that one of the method's formal parameters is of an as yet
9840 compute_delayed_physnames (struct dwarf2_cu
*cu
)
9842 /* Only C++ delays computing physnames. */
9843 if (cu
->method_list
.empty ())
9845 gdb_assert (cu
->language
== language_cplus
);
9847 for (const delayed_method_info
&mi
: cu
->method_list
)
9849 const char *physname
;
9850 struct fn_fieldlist
*fn_flp
9851 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
9852 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
9853 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
9854 = physname
? physname
: "";
9856 /* Since there's no tag to indicate whether a method is a
9857 const/volatile overload, extract that information out of the
9859 if (physname
!= NULL
)
9861 size_t len
= strlen (physname
);
9865 if (physname
[len
] == ')') /* shortcut */
9867 else if (check_modifier (physname
, len
, " const"))
9868 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
9869 else if (check_modifier (physname
, len
, " volatile"))
9870 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
9877 /* The list is no longer needed. */
9878 cu
->method_list
.clear ();
9881 /* Go objects should be embedded in a DW_TAG_module DIE,
9882 and it's not clear if/how imported objects will appear.
9883 To keep Go support simple until that's worked out,
9884 go back through what we've read and create something usable.
9885 We could do this while processing each DIE, and feels kinda cleaner,
9886 but that way is more invasive.
9887 This is to, for example, allow the user to type "p var" or "b main"
9888 without having to specify the package name, and allow lookups
9889 of module.object to work in contexts that use the expression
9893 fixup_go_packaging (struct dwarf2_cu
*cu
)
9895 gdb::unique_xmalloc_ptr
<char> package_name
;
9896 struct pending
*list
;
9899 for (list
= *cu
->get_builder ()->get_global_symbols ();
9903 for (i
= 0; i
< list
->nsyms
; ++i
)
9905 struct symbol
*sym
= list
->symbol
[i
];
9907 if (sym
->language () == language_go
9908 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
9910 gdb::unique_xmalloc_ptr
<char> this_package_name
9911 (go_symbol_package_name (sym
));
9913 if (this_package_name
== NULL
)
9915 if (package_name
== NULL
)
9916 package_name
= std::move (this_package_name
);
9919 struct objfile
*objfile
9920 = cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9921 if (strcmp (package_name
.get (), this_package_name
.get ()) != 0)
9922 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9923 (symbol_symtab (sym
) != NULL
9924 ? symtab_to_filename_for_display
9925 (symbol_symtab (sym
))
9926 : objfile_name (objfile
)),
9927 this_package_name
.get (), package_name
.get ());
9933 if (package_name
!= NULL
)
9935 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9936 const char *saved_package_name
9937 = obstack_strdup (&objfile
->per_bfd
->storage_obstack
, package_name
.get ());
9938 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9939 saved_package_name
);
9942 sym
= allocate_symbol (objfile
);
9943 sym
->set_language (language_go
, &objfile
->objfile_obstack
);
9944 sym
->compute_and_set_names (saved_package_name
, false, objfile
->per_bfd
);
9945 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9946 e.g., "main" finds the "main" module and not C's main(). */
9947 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9948 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9949 SYMBOL_TYPE (sym
) = type
;
9951 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
9955 /* Allocate a fully-qualified name consisting of the two parts on the
9959 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
9961 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
9964 /* A helper that allocates a struct discriminant_info to attach to a
9967 static struct discriminant_info
*
9968 alloc_discriminant_info (struct type
*type
, int discriminant_index
,
9971 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
9972 gdb_assert (discriminant_index
== -1
9973 || (discriminant_index
>= 0
9974 && discriminant_index
< TYPE_NFIELDS (type
)));
9975 gdb_assert (default_index
== -1
9976 || (default_index
>= 0 && default_index
< TYPE_NFIELDS (type
)));
9978 TYPE_FLAG_DISCRIMINATED_UNION (type
) = 1;
9980 struct discriminant_info
*disc
9981 = ((struct discriminant_info
*)
9983 offsetof (struct discriminant_info
, discriminants
)
9984 + TYPE_NFIELDS (type
) * sizeof (disc
->discriminants
[0])));
9985 disc
->default_index
= default_index
;
9986 disc
->discriminant_index
= discriminant_index
;
9988 struct dynamic_prop prop
;
9989 prop
.kind
= PROP_UNDEFINED
;
9990 prop
.data
.baton
= disc
;
9992 add_dyn_prop (DYN_PROP_DISCRIMINATED
, prop
, type
);
9997 /* Some versions of rustc emitted enums in an unusual way.
9999 Ordinary enums were emitted as unions. The first element of each
10000 structure in the union was named "RUST$ENUM$DISR". This element
10001 held the discriminant.
10003 These versions of Rust also implemented the "non-zero"
10004 optimization. When the enum had two values, and one is empty and
10005 the other holds a pointer that cannot be zero, the pointer is used
10006 as the discriminant, with a zero value meaning the empty variant.
10007 Here, the union's first member is of the form
10008 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
10009 where the fieldnos are the indices of the fields that should be
10010 traversed in order to find the field (which may be several fields deep)
10011 and the variantname is the name of the variant of the case when the
10014 This function recognizes whether TYPE is of one of these forms,
10015 and, if so, smashes it to be a variant type. */
10018 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
10020 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
10022 /* We don't need to deal with empty enums. */
10023 if (TYPE_NFIELDS (type
) == 0)
10026 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
10027 if (TYPE_NFIELDS (type
) == 1
10028 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
10030 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
10032 /* Decode the field name to find the offset of the
10034 ULONGEST bit_offset
= 0;
10035 struct type
*field_type
= TYPE_FIELD_TYPE (type
, 0);
10036 while (name
[0] >= '0' && name
[0] <= '9')
10039 unsigned long index
= strtoul (name
, &tail
, 10);
10042 || index
>= TYPE_NFIELDS (field_type
)
10043 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
10044 != FIELD_LOC_KIND_BITPOS
))
10046 complaint (_("Could not parse Rust enum encoding string \"%s\""
10048 TYPE_FIELD_NAME (type
, 0),
10049 objfile_name (objfile
));
10054 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
10055 field_type
= TYPE_FIELD_TYPE (field_type
, index
);
10058 /* Make a union to hold the variants. */
10059 struct type
*union_type
= alloc_type (objfile
);
10060 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
10061 TYPE_NFIELDS (union_type
) = 3;
10062 TYPE_FIELDS (union_type
)
10063 = (struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
));
10064 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
10065 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
10067 /* Put the discriminant must at index 0. */
10068 TYPE_FIELD_TYPE (union_type
, 0) = field_type
;
10069 TYPE_FIELD_ARTIFICIAL (union_type
, 0) = 1;
10070 TYPE_FIELD_NAME (union_type
, 0) = "<<discriminant>>";
10071 SET_FIELD_BITPOS (TYPE_FIELD (union_type
, 0), bit_offset
);
10073 /* The order of fields doesn't really matter, so put the real
10074 field at index 1 and the data-less field at index 2. */
10075 struct discriminant_info
*disc
10076 = alloc_discriminant_info (union_type
, 0, 1);
10077 TYPE_FIELD (union_type
, 1) = TYPE_FIELD (type
, 0);
10078 TYPE_FIELD_NAME (union_type
, 1)
10079 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type
, 1)));
10080 TYPE_NAME (TYPE_FIELD_TYPE (union_type
, 1))
10081 = rust_fully_qualify (&objfile
->objfile_obstack
, TYPE_NAME (type
),
10082 TYPE_FIELD_NAME (union_type
, 1));
10084 const char *dataless_name
10085 = rust_fully_qualify (&objfile
->objfile_obstack
, TYPE_NAME (type
),
10087 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
10089 TYPE_FIELD_TYPE (union_type
, 2) = dataless_type
;
10090 /* NAME points into the original discriminant name, which
10091 already has the correct lifetime. */
10092 TYPE_FIELD_NAME (union_type
, 2) = name
;
10093 SET_FIELD_BITPOS (TYPE_FIELD (union_type
, 2), 0);
10094 disc
->discriminants
[2] = 0;
10096 /* Smash this type to be a structure type. We have to do this
10097 because the type has already been recorded. */
10098 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10099 TYPE_NFIELDS (type
) = 1;
10101 = (struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
));
10103 /* Install the variant part. */
10104 TYPE_FIELD_TYPE (type
, 0) = union_type
;
10105 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10106 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10108 /* A union with a single anonymous field is probably an old-style
10109 univariant enum. */
10110 else if (TYPE_NFIELDS (type
) == 1 && streq (TYPE_FIELD_NAME (type
, 0), ""))
10112 /* Smash this type to be a structure type. We have to do this
10113 because the type has already been recorded. */
10114 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10116 /* Make a union to hold the variants. */
10117 struct type
*union_type
= alloc_type (objfile
);
10118 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
10119 TYPE_NFIELDS (union_type
) = TYPE_NFIELDS (type
);
10120 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
10121 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
10122 TYPE_FIELDS (union_type
) = TYPE_FIELDS (type
);
10124 struct type
*field_type
= TYPE_FIELD_TYPE (union_type
, 0);
10125 const char *variant_name
10126 = rust_last_path_segment (TYPE_NAME (field_type
));
10127 TYPE_FIELD_NAME (union_type
, 0) = variant_name
;
10128 TYPE_NAME (field_type
)
10129 = rust_fully_qualify (&objfile
->objfile_obstack
,
10130 TYPE_NAME (type
), variant_name
);
10132 /* Install the union in the outer struct type. */
10133 TYPE_NFIELDS (type
) = 1;
10135 = (struct field
*) TYPE_ZALLOC (union_type
, sizeof (struct field
));
10136 TYPE_FIELD_TYPE (type
, 0) = union_type
;
10137 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10138 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10140 alloc_discriminant_info (union_type
, -1, 0);
10144 struct type
*disr_type
= nullptr;
10145 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
10147 disr_type
= TYPE_FIELD_TYPE (type
, i
);
10149 if (TYPE_CODE (disr_type
) != TYPE_CODE_STRUCT
)
10151 /* All fields of a true enum will be structs. */
10154 else if (TYPE_NFIELDS (disr_type
) == 0)
10156 /* Could be data-less variant, so keep going. */
10157 disr_type
= nullptr;
10159 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
10160 "RUST$ENUM$DISR") != 0)
10162 /* Not a Rust enum. */
10172 /* If we got here without a discriminant, then it's probably
10174 if (disr_type
== nullptr)
10177 /* Smash this type to be a structure type. We have to do this
10178 because the type has already been recorded. */
10179 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10181 /* Make a union to hold the variants. */
10182 struct field
*disr_field
= &TYPE_FIELD (disr_type
, 0);
10183 struct type
*union_type
= alloc_type (objfile
);
10184 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
10185 TYPE_NFIELDS (union_type
) = 1 + TYPE_NFIELDS (type
);
10186 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
10187 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
10188 TYPE_FIELDS (union_type
)
10189 = (struct field
*) TYPE_ZALLOC (union_type
,
10190 (TYPE_NFIELDS (union_type
)
10191 * sizeof (struct field
)));
10193 memcpy (TYPE_FIELDS (union_type
) + 1, TYPE_FIELDS (type
),
10194 TYPE_NFIELDS (type
) * sizeof (struct field
));
10196 /* Install the discriminant at index 0 in the union. */
10197 TYPE_FIELD (union_type
, 0) = *disr_field
;
10198 TYPE_FIELD_ARTIFICIAL (union_type
, 0) = 1;
10199 TYPE_FIELD_NAME (union_type
, 0) = "<<discriminant>>";
10201 /* Install the union in the outer struct type. */
10202 TYPE_FIELD_TYPE (type
, 0) = union_type
;
10203 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10204 TYPE_NFIELDS (type
) = 1;
10206 /* Set the size and offset of the union type. */
10207 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10209 /* We need a way to find the correct discriminant given a
10210 variant name. For convenience we build a map here. */
10211 struct type
*enum_type
= FIELD_TYPE (*disr_field
);
10212 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
10213 for (int i
= 0; i
< TYPE_NFIELDS (enum_type
); ++i
)
10215 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
10218 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
10219 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
10223 int n_fields
= TYPE_NFIELDS (union_type
);
10224 struct discriminant_info
*disc
10225 = alloc_discriminant_info (union_type
, 0, -1);
10226 /* Skip the discriminant here. */
10227 for (int i
= 1; i
< n_fields
; ++i
)
10229 /* Find the final word in the name of this variant's type.
10230 That name can be used to look up the correct
10232 const char *variant_name
10233 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type
,
10236 auto iter
= discriminant_map
.find (variant_name
);
10237 if (iter
!= discriminant_map
.end ())
10238 disc
->discriminants
[i
] = iter
->second
;
10240 /* Remove the discriminant field, if it exists. */
10241 struct type
*sub_type
= TYPE_FIELD_TYPE (union_type
, i
);
10242 if (TYPE_NFIELDS (sub_type
) > 0)
10244 --TYPE_NFIELDS (sub_type
);
10245 ++TYPE_FIELDS (sub_type
);
10247 TYPE_FIELD_NAME (union_type
, i
) = variant_name
;
10248 TYPE_NAME (sub_type
)
10249 = rust_fully_qualify (&objfile
->objfile_obstack
,
10250 TYPE_NAME (type
), variant_name
);
10255 /* Rewrite some Rust unions to be structures with variants parts. */
10258 rust_union_quirks (struct dwarf2_cu
*cu
)
10260 gdb_assert (cu
->language
== language_rust
);
10261 for (type
*type_
: cu
->rust_unions
)
10262 quirk_rust_enum (type_
, cu
->per_cu
->dwarf2_per_objfile
->objfile
);
10263 /* We don't need this any more. */
10264 cu
->rust_unions
.clear ();
10267 /* Return the symtab for PER_CU. This works properly regardless of
10268 whether we're using the index or psymtabs. */
10270 static struct compunit_symtab
*
10271 get_compunit_symtab (struct dwarf2_per_cu_data
*per_cu
)
10273 return (per_cu
->dwarf2_per_objfile
->using_index
10274 ? per_cu
->v
.quick
->compunit_symtab
10275 : per_cu
->v
.psymtab
->compunit_symtab
);
10278 /* A helper function for computing the list of all symbol tables
10279 included by PER_CU. */
10282 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
10283 htab_t all_children
, htab_t all_type_symtabs
,
10284 struct dwarf2_per_cu_data
*per_cu
,
10285 struct compunit_symtab
*immediate_parent
)
10288 struct compunit_symtab
*cust
;
10290 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
10293 /* This inclusion and its children have been processed. */
10298 /* Only add a CU if it has a symbol table. */
10299 cust
= get_compunit_symtab (per_cu
);
10302 /* If this is a type unit only add its symbol table if we haven't
10303 seen it yet (type unit per_cu's can share symtabs). */
10304 if (per_cu
->is_debug_types
)
10306 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
10310 result
->push_back (cust
);
10311 if (cust
->user
== NULL
)
10312 cust
->user
= immediate_parent
;
10317 result
->push_back (cust
);
10318 if (cust
->user
== NULL
)
10319 cust
->user
= immediate_parent
;
10323 if (!per_cu
->imported_symtabs_empty ())
10324 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
10326 recursively_compute_inclusions (result
, all_children
,
10327 all_type_symtabs
, ptr
, cust
);
10331 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10335 compute_compunit_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
10337 gdb_assert (! per_cu
->is_debug_types
);
10339 if (!per_cu
->imported_symtabs_empty ())
10342 std::vector
<compunit_symtab
*> result_symtabs
;
10343 htab_t all_children
, all_type_symtabs
;
10344 struct compunit_symtab
*cust
= get_compunit_symtab (per_cu
);
10346 /* If we don't have a symtab, we can just skip this case. */
10350 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
10351 NULL
, xcalloc
, xfree
);
10352 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
10353 NULL
, xcalloc
, xfree
);
10355 for (dwarf2_per_cu_data
*ptr
: *per_cu
->imported_symtabs
)
10357 recursively_compute_inclusions (&result_symtabs
, all_children
,
10358 all_type_symtabs
, ptr
, cust
);
10361 /* Now we have a transitive closure of all the included symtabs. */
10362 len
= result_symtabs
.size ();
10364 = XOBNEWVEC (&per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
,
10365 struct compunit_symtab
*, len
+ 1);
10366 memcpy (cust
->includes
, result_symtabs
.data (),
10367 len
* sizeof (compunit_symtab
*));
10368 cust
->includes
[len
] = NULL
;
10370 htab_delete (all_children
);
10371 htab_delete (all_type_symtabs
);
10375 /* Compute the 'includes' field for the symtabs of all the CUs we just
10379 process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
10381 for (dwarf2_per_cu_data
*iter
: dwarf2_per_objfile
->just_read_cus
)
10383 if (! iter
->is_debug_types
)
10384 compute_compunit_symtab_includes (iter
);
10387 dwarf2_per_objfile
->just_read_cus
.clear ();
10390 /* Generate full symbol information for PER_CU, whose DIEs have
10391 already been loaded into memory. */
10394 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
10395 enum language pretend_language
)
10397 struct dwarf2_cu
*cu
= per_cu
->cu
;
10398 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
10399 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10400 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10401 CORE_ADDR lowpc
, highpc
;
10402 struct compunit_symtab
*cust
;
10403 CORE_ADDR baseaddr
;
10404 struct block
*static_block
;
10407 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10409 /* Clear the list here in case something was left over. */
10410 cu
->method_list
.clear ();
10412 cu
->language
= pretend_language
;
10413 cu
->language_defn
= language_def (cu
->language
);
10415 /* Do line number decoding in read_file_scope () */
10416 process_die (cu
->dies
, cu
);
10418 /* For now fudge the Go package. */
10419 if (cu
->language
== language_go
)
10420 fixup_go_packaging (cu
);
10422 /* Now that we have processed all the DIEs in the CU, all the types
10423 should be complete, and it should now be safe to compute all of the
10425 compute_delayed_physnames (cu
);
10427 if (cu
->language
== language_rust
)
10428 rust_union_quirks (cu
);
10430 /* Some compilers don't define a DW_AT_high_pc attribute for the
10431 compilation unit. If the DW_AT_high_pc is missing, synthesize
10432 it, by scanning the DIE's below the compilation unit. */
10433 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
10435 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
10436 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
10438 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10439 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10440 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10441 addrmap to help ensure it has an accurate map of pc values belonging to
10443 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
10445 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
10446 SECT_OFF_TEXT (objfile
),
10451 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
10453 /* Set symtab language to language from DW_AT_language. If the
10454 compilation is from a C file generated by language preprocessors, do
10455 not set the language if it was already deduced by start_subfile. */
10456 if (!(cu
->language
== language_c
10457 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
10458 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10460 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10461 produce DW_AT_location with location lists but it can be possibly
10462 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10463 there were bugs in prologue debug info, fixed later in GCC-4.5
10464 by "unwind info for epilogues" patch (which is not directly related).
10466 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10467 needed, it would be wrong due to missing DW_AT_producer there.
10469 Still one can confuse GDB by using non-standard GCC compilation
10470 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10472 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
10473 cust
->locations_valid
= 1;
10475 if (gcc_4_minor
>= 5)
10476 cust
->epilogue_unwind_valid
= 1;
10478 cust
->call_site_htab
= cu
->call_site_htab
;
10481 if (dwarf2_per_objfile
->using_index
)
10482 per_cu
->v
.quick
->compunit_symtab
= cust
;
10485 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
10486 pst
->compunit_symtab
= cust
;
10490 /* Push it for inclusion processing later. */
10491 dwarf2_per_objfile
->just_read_cus
.push_back (per_cu
);
10493 /* Not needed any more. */
10494 cu
->reset_builder ();
10497 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10498 already been loaded into memory. */
10501 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
10502 enum language pretend_language
)
10504 struct dwarf2_cu
*cu
= per_cu
->cu
;
10505 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
10506 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10507 struct compunit_symtab
*cust
;
10508 struct signatured_type
*sig_type
;
10510 gdb_assert (per_cu
->is_debug_types
);
10511 sig_type
= (struct signatured_type
*) per_cu
;
10513 /* Clear the list here in case something was left over. */
10514 cu
->method_list
.clear ();
10516 cu
->language
= pretend_language
;
10517 cu
->language_defn
= language_def (cu
->language
);
10519 /* The symbol tables are set up in read_type_unit_scope. */
10520 process_die (cu
->dies
, cu
);
10522 /* For now fudge the Go package. */
10523 if (cu
->language
== language_go
)
10524 fixup_go_packaging (cu
);
10526 /* Now that we have processed all the DIEs in the CU, all the types
10527 should be complete, and it should now be safe to compute all of the
10529 compute_delayed_physnames (cu
);
10531 if (cu
->language
== language_rust
)
10532 rust_union_quirks (cu
);
10534 /* TUs share symbol tables.
10535 If this is the first TU to use this symtab, complete the construction
10536 of it with end_expandable_symtab. Otherwise, complete the addition of
10537 this TU's symbols to the existing symtab. */
10538 if (sig_type
->type_unit_group
->compunit_symtab
== NULL
)
10540 buildsym_compunit
*builder
= cu
->get_builder ();
10541 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
10542 sig_type
->type_unit_group
->compunit_symtab
= cust
;
10546 /* Set symtab language to language from DW_AT_language. If the
10547 compilation is from a C file generated by language preprocessors,
10548 do not set the language if it was already deduced by
10550 if (!(cu
->language
== language_c
10551 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
10552 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10557 cu
->get_builder ()->augment_type_symtab ();
10558 cust
= sig_type
->type_unit_group
->compunit_symtab
;
10561 if (dwarf2_per_objfile
->using_index
)
10562 per_cu
->v
.quick
->compunit_symtab
= cust
;
10565 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
10566 pst
->compunit_symtab
= cust
;
10570 /* Not needed any more. */
10571 cu
->reset_builder ();
10574 /* Process an imported unit DIE. */
10577 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10579 struct attribute
*attr
;
10581 /* For now we don't handle imported units in type units. */
10582 if (cu
->per_cu
->is_debug_types
)
10584 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10585 " supported in type units [in module %s]"),
10586 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
10589 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10592 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
10593 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
10594 dwarf2_per_cu_data
*per_cu
10595 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
,
10596 cu
->per_cu
->dwarf2_per_objfile
);
10598 /* If necessary, add it to the queue and load its DIEs. */
10599 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
10600 load_full_comp_unit (per_cu
, false, cu
->language
);
10602 cu
->per_cu
->imported_symtabs_push (per_cu
);
10606 /* RAII object that represents a process_die scope: i.e.,
10607 starts/finishes processing a DIE. */
10608 class process_die_scope
10611 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
10612 : m_die (die
), m_cu (cu
)
10614 /* We should only be processing DIEs not already in process. */
10615 gdb_assert (!m_die
->in_process
);
10616 m_die
->in_process
= true;
10619 ~process_die_scope ()
10621 m_die
->in_process
= false;
10623 /* If we're done processing the DIE for the CU that owns the line
10624 header, we don't need the line header anymore. */
10625 if (m_cu
->line_header_die_owner
== m_die
)
10627 delete m_cu
->line_header
;
10628 m_cu
->line_header
= NULL
;
10629 m_cu
->line_header_die_owner
= NULL
;
10638 /* Process a die and its children. */
10641 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10643 process_die_scope
scope (die
, cu
);
10647 case DW_TAG_padding
:
10649 case DW_TAG_compile_unit
:
10650 case DW_TAG_partial_unit
:
10651 read_file_scope (die
, cu
);
10653 case DW_TAG_type_unit
:
10654 read_type_unit_scope (die
, cu
);
10656 case DW_TAG_subprogram
:
10657 /* Nested subprograms in Fortran get a prefix. */
10658 if (cu
->language
== language_fortran
10659 && die
->parent
!= NULL
10660 && die
->parent
->tag
== DW_TAG_subprogram
)
10661 cu
->processing_has_namespace_info
= true;
10662 /* Fall through. */
10663 case DW_TAG_inlined_subroutine
:
10664 read_func_scope (die
, cu
);
10666 case DW_TAG_lexical_block
:
10667 case DW_TAG_try_block
:
10668 case DW_TAG_catch_block
:
10669 read_lexical_block_scope (die
, cu
);
10671 case DW_TAG_call_site
:
10672 case DW_TAG_GNU_call_site
:
10673 read_call_site_scope (die
, cu
);
10675 case DW_TAG_class_type
:
10676 case DW_TAG_interface_type
:
10677 case DW_TAG_structure_type
:
10678 case DW_TAG_union_type
:
10679 process_structure_scope (die
, cu
);
10681 case DW_TAG_enumeration_type
:
10682 process_enumeration_scope (die
, cu
);
10685 /* These dies have a type, but processing them does not create
10686 a symbol or recurse to process the children. Therefore we can
10687 read them on-demand through read_type_die. */
10688 case DW_TAG_subroutine_type
:
10689 case DW_TAG_set_type
:
10690 case DW_TAG_array_type
:
10691 case DW_TAG_pointer_type
:
10692 case DW_TAG_ptr_to_member_type
:
10693 case DW_TAG_reference_type
:
10694 case DW_TAG_rvalue_reference_type
:
10695 case DW_TAG_string_type
:
10698 case DW_TAG_base_type
:
10699 case DW_TAG_subrange_type
:
10700 case DW_TAG_typedef
:
10701 /* Add a typedef symbol for the type definition, if it has a
10703 new_symbol (die
, read_type_die (die
, cu
), cu
);
10705 case DW_TAG_common_block
:
10706 read_common_block (die
, cu
);
10708 case DW_TAG_common_inclusion
:
10710 case DW_TAG_namespace
:
10711 cu
->processing_has_namespace_info
= true;
10712 read_namespace (die
, cu
);
10714 case DW_TAG_module
:
10715 cu
->processing_has_namespace_info
= true;
10716 read_module (die
, cu
);
10718 case DW_TAG_imported_declaration
:
10719 cu
->processing_has_namespace_info
= true;
10720 if (read_namespace_alias (die
, cu
))
10722 /* The declaration is not a global namespace alias. */
10723 /* Fall through. */
10724 case DW_TAG_imported_module
:
10725 cu
->processing_has_namespace_info
= true;
10726 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
10727 || cu
->language
!= language_fortran
))
10728 complaint (_("Tag '%s' has unexpected children"),
10729 dwarf_tag_name (die
->tag
));
10730 read_import_statement (die
, cu
);
10733 case DW_TAG_imported_unit
:
10734 process_imported_unit_die (die
, cu
);
10737 case DW_TAG_variable
:
10738 read_variable (die
, cu
);
10742 new_symbol (die
, NULL
, cu
);
10747 /* DWARF name computation. */
10749 /* A helper function for dwarf2_compute_name which determines whether DIE
10750 needs to have the name of the scope prepended to the name listed in the
10754 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
10756 struct attribute
*attr
;
10760 case DW_TAG_namespace
:
10761 case DW_TAG_typedef
:
10762 case DW_TAG_class_type
:
10763 case DW_TAG_interface_type
:
10764 case DW_TAG_structure_type
:
10765 case DW_TAG_union_type
:
10766 case DW_TAG_enumeration_type
:
10767 case DW_TAG_enumerator
:
10768 case DW_TAG_subprogram
:
10769 case DW_TAG_inlined_subroutine
:
10770 case DW_TAG_member
:
10771 case DW_TAG_imported_declaration
:
10774 case DW_TAG_variable
:
10775 case DW_TAG_constant
:
10776 /* We only need to prefix "globally" visible variables. These include
10777 any variable marked with DW_AT_external or any variable that
10778 lives in a namespace. [Variables in anonymous namespaces
10779 require prefixing, but they are not DW_AT_external.] */
10781 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
10783 struct dwarf2_cu
*spec_cu
= cu
;
10785 return die_needs_namespace (die_specification (die
, &spec_cu
),
10789 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
10790 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
10791 && die
->parent
->tag
!= DW_TAG_module
)
10793 /* A variable in a lexical block of some kind does not need a
10794 namespace, even though in C++ such variables may be external
10795 and have a mangled name. */
10796 if (die
->parent
->tag
== DW_TAG_lexical_block
10797 || die
->parent
->tag
== DW_TAG_try_block
10798 || die
->parent
->tag
== DW_TAG_catch_block
10799 || die
->parent
->tag
== DW_TAG_subprogram
)
10808 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10809 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10810 defined for the given DIE. */
10812 static struct attribute
*
10813 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
10815 struct attribute
*attr
;
10817 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
10819 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10824 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10825 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10826 defined for the given DIE. */
10828 static const char *
10829 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10831 const char *linkage_name
;
10833 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
10834 if (linkage_name
== NULL
)
10835 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10837 return linkage_name
;
10840 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10841 compute the physname for the object, which include a method's:
10842 - formal parameters (C++),
10843 - receiver type (Go),
10845 The term "physname" is a bit confusing.
10846 For C++, for example, it is the demangled name.
10847 For Go, for example, it's the mangled name.
10849 For Ada, return the DIE's linkage name rather than the fully qualified
10850 name. PHYSNAME is ignored..
10852 The result is allocated on the objfile_obstack and canonicalized. */
10854 static const char *
10855 dwarf2_compute_name (const char *name
,
10856 struct die_info
*die
, struct dwarf2_cu
*cu
,
10859 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
10862 name
= dwarf2_name (die
, cu
);
10864 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10865 but otherwise compute it by typename_concat inside GDB.
10866 FIXME: Actually this is not really true, or at least not always true.
10867 It's all very confusing. compute_and_set_names doesn't try to demangle
10868 Fortran names because there is no mangling standard. So new_symbol
10869 will set the demangled name to the result of dwarf2_full_name, and it is
10870 the demangled name that GDB uses if it exists. */
10871 if (cu
->language
== language_ada
10872 || (cu
->language
== language_fortran
&& physname
))
10874 /* For Ada unit, we prefer the linkage name over the name, as
10875 the former contains the exported name, which the user expects
10876 to be able to reference. Ideally, we want the user to be able
10877 to reference this entity using either natural or linkage name,
10878 but we haven't started looking at this enhancement yet. */
10879 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10881 if (linkage_name
!= NULL
)
10882 return linkage_name
;
10885 /* These are the only languages we know how to qualify names in. */
10887 && (cu
->language
== language_cplus
10888 || cu
->language
== language_fortran
|| cu
->language
== language_d
10889 || cu
->language
== language_rust
))
10891 if (die_needs_namespace (die
, cu
))
10893 const char *prefix
;
10894 const char *canonical_name
= NULL
;
10898 prefix
= determine_prefix (die
, cu
);
10899 if (*prefix
!= '\0')
10901 gdb::unique_xmalloc_ptr
<char> prefixed_name
10902 (typename_concat (NULL
, prefix
, name
, physname
, cu
));
10904 buf
.puts (prefixed_name
.get ());
10909 /* Template parameters may be specified in the DIE's DW_AT_name, or
10910 as children with DW_TAG_template_type_param or
10911 DW_TAG_value_type_param. If the latter, add them to the name
10912 here. If the name already has template parameters, then
10913 skip this step; some versions of GCC emit both, and
10914 it is more efficient to use the pre-computed name.
10916 Something to keep in mind about this process: it is very
10917 unlikely, or in some cases downright impossible, to produce
10918 something that will match the mangled name of a function.
10919 If the definition of the function has the same debug info,
10920 we should be able to match up with it anyway. But fallbacks
10921 using the minimal symbol, for instance to find a method
10922 implemented in a stripped copy of libstdc++, will not work.
10923 If we do not have debug info for the definition, we will have to
10924 match them up some other way.
10926 When we do name matching there is a related problem with function
10927 templates; two instantiated function templates are allowed to
10928 differ only by their return types, which we do not add here. */
10930 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
10932 struct attribute
*attr
;
10933 struct die_info
*child
;
10936 die
->building_fullname
= 1;
10938 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
10942 const gdb_byte
*bytes
;
10943 struct dwarf2_locexpr_baton
*baton
;
10946 if (child
->tag
!= DW_TAG_template_type_param
10947 && child
->tag
!= DW_TAG_template_value_param
)
10958 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10961 complaint (_("template parameter missing DW_AT_type"));
10962 buf
.puts ("UNKNOWN_TYPE");
10965 type
= die_type (child
, cu
);
10967 if (child
->tag
== DW_TAG_template_type_param
)
10969 c_print_type (type
, "", &buf
, -1, 0, cu
->language
,
10970 &type_print_raw_options
);
10974 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10977 complaint (_("template parameter missing "
10978 "DW_AT_const_value"));
10979 buf
.puts ("UNKNOWN_VALUE");
10983 dwarf2_const_value_attr (attr
, type
, name
,
10984 &cu
->comp_unit_obstack
, cu
,
10985 &value
, &bytes
, &baton
);
10987 if (TYPE_NOSIGN (type
))
10988 /* GDB prints characters as NUMBER 'CHAR'. If that's
10989 changed, this can use value_print instead. */
10990 c_printchar (value
, type
, &buf
);
10993 struct value_print_options opts
;
10996 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
11000 else if (bytes
!= NULL
)
11002 v
= allocate_value (type
);
11003 memcpy (value_contents_writeable (v
), bytes
,
11004 TYPE_LENGTH (type
));
11007 v
= value_from_longest (type
, value
);
11009 /* Specify decimal so that we do not depend on
11011 get_formatted_print_options (&opts
, 'd');
11013 value_print (v
, &buf
, &opts
);
11018 die
->building_fullname
= 0;
11022 /* Close the argument list, with a space if necessary
11023 (nested templates). */
11024 if (!buf
.empty () && buf
.string ().back () == '>')
11031 /* For C++ methods, append formal parameter type
11032 information, if PHYSNAME. */
11034 if (physname
&& die
->tag
== DW_TAG_subprogram
11035 && cu
->language
== language_cplus
)
11037 struct type
*type
= read_type_die (die
, cu
);
11039 c_type_print_args (type
, &buf
, 1, cu
->language
,
11040 &type_print_raw_options
);
11042 if (cu
->language
== language_cplus
)
11044 /* Assume that an artificial first parameter is
11045 "this", but do not crash if it is not. RealView
11046 marks unnamed (and thus unused) parameters as
11047 artificial; there is no way to differentiate
11049 if (TYPE_NFIELDS (type
) > 0
11050 && TYPE_FIELD_ARTIFICIAL (type
, 0)
11051 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
11052 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
11054 buf
.puts (" const");
11058 const std::string
&intermediate_name
= buf
.string ();
11060 if (cu
->language
== language_cplus
)
11062 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
11063 &objfile
->per_bfd
->storage_obstack
);
11065 /* If we only computed INTERMEDIATE_NAME, or if
11066 INTERMEDIATE_NAME is already canonical, then we need to
11067 copy it to the appropriate obstack. */
11068 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
11069 name
= obstack_strdup (&objfile
->per_bfd
->storage_obstack
,
11070 intermediate_name
);
11072 name
= canonical_name
;
11079 /* Return the fully qualified name of DIE, based on its DW_AT_name.
11080 If scope qualifiers are appropriate they will be added. The result
11081 will be allocated on the storage_obstack, or NULL if the DIE does
11082 not have a name. NAME may either be from a previous call to
11083 dwarf2_name or NULL.
11085 The output string will be canonicalized (if C++). */
11087 static const char *
11088 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
11090 return dwarf2_compute_name (name
, die
, cu
, 0);
11093 /* Construct a physname for the given DIE in CU. NAME may either be
11094 from a previous call to dwarf2_name or NULL. The result will be
11095 allocated on the objfile_objstack or NULL if the DIE does not have a
11098 The output string will be canonicalized (if C++). */
11100 static const char *
11101 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
11103 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
11104 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
11107 /* In this case dwarf2_compute_name is just a shortcut not building anything
11109 if (!die_needs_namespace (die
, cu
))
11110 return dwarf2_compute_name (name
, die
, cu
, 1);
11112 mangled
= dw2_linkage_name (die
, cu
);
11114 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
11115 See https://github.com/rust-lang/rust/issues/32925. */
11116 if (cu
->language
== language_rust
&& mangled
!= NULL
11117 && strchr (mangled
, '{') != NULL
)
11120 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11122 gdb::unique_xmalloc_ptr
<char> demangled
;
11123 if (mangled
!= NULL
)
11126 if (language_def (cu
->language
)->la_store_sym_names_in_linkage_form_p
)
11128 /* Do nothing (do not demangle the symbol name). */
11130 else if (cu
->language
== language_go
)
11132 /* This is a lie, but we already lie to the caller new_symbol.
11133 new_symbol assumes we return the mangled name.
11134 This just undoes that lie until things are cleaned up. */
11138 /* Use DMGL_RET_DROP for C++ template functions to suppress
11139 their return type. It is easier for GDB users to search
11140 for such functions as `name(params)' than `long name(params)'.
11141 In such case the minimal symbol names do not match the full
11142 symbol names but for template functions there is never a need
11143 to look up their definition from their declaration so
11144 the only disadvantage remains the minimal symbol variant
11145 `long name(params)' does not have the proper inferior type. */
11146 demangled
.reset (gdb_demangle (mangled
,
11147 (DMGL_PARAMS
| DMGL_ANSI
11148 | DMGL_RET_DROP
)));
11151 canon
= demangled
.get ();
11159 if (canon
== NULL
|| check_physname
)
11161 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
11163 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
11165 /* It may not mean a bug in GDB. The compiler could also
11166 compute DW_AT_linkage_name incorrectly. But in such case
11167 GDB would need to be bug-to-bug compatible. */
11169 complaint (_("Computed physname <%s> does not match demangled <%s> "
11170 "(from linkage <%s>) - DIE at %s [in module %s]"),
11171 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
11172 objfile_name (objfile
));
11174 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11175 is available here - over computed PHYSNAME. It is safer
11176 against both buggy GDB and buggy compilers. */
11190 retval
= obstack_strdup (&objfile
->per_bfd
->storage_obstack
, retval
);
11195 /* Inspect DIE in CU for a namespace alias. If one exists, record
11196 a new symbol for it.
11198 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11201 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
11203 struct attribute
*attr
;
11205 /* If the die does not have a name, this is not a namespace
11207 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
11211 struct die_info
*d
= die
;
11212 struct dwarf2_cu
*imported_cu
= cu
;
11214 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11215 keep inspecting DIEs until we hit the underlying import. */
11216 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11217 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
11219 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
11223 d
= follow_die_ref (d
, attr
, &imported_cu
);
11224 if (d
->tag
!= DW_TAG_imported_declaration
)
11228 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
11230 complaint (_("DIE at %s has too many recursively imported "
11231 "declarations"), sect_offset_str (d
->sect_off
));
11238 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
11240 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
11241 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
11243 /* This declaration is a global namespace alias. Add
11244 a symbol for it whose type is the aliased namespace. */
11245 new_symbol (die
, type
, cu
);
11254 /* Return the using directives repository (global or local?) to use in the
11255 current context for CU.
11257 For Ada, imported declarations can materialize renamings, which *may* be
11258 global. However it is impossible (for now?) in DWARF to distinguish
11259 "external" imported declarations and "static" ones. As all imported
11260 declarations seem to be static in all other languages, make them all CU-wide
11261 global only in Ada. */
11263 static struct using_direct
**
11264 using_directives (struct dwarf2_cu
*cu
)
11266 if (cu
->language
== language_ada
11267 && cu
->get_builder ()->outermost_context_p ())
11268 return cu
->get_builder ()->get_global_using_directives ();
11270 return cu
->get_builder ()->get_local_using_directives ();
11273 /* Read the import statement specified by the given die and record it. */
11276 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
11278 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
11279 struct attribute
*import_attr
;
11280 struct die_info
*imported_die
, *child_die
;
11281 struct dwarf2_cu
*imported_cu
;
11282 const char *imported_name
;
11283 const char *imported_name_prefix
;
11284 const char *canonical_name
;
11285 const char *import_alias
;
11286 const char *imported_declaration
= NULL
;
11287 const char *import_prefix
;
11288 std::vector
<const char *> excludes
;
11290 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
11291 if (import_attr
== NULL
)
11293 complaint (_("Tag '%s' has no DW_AT_import"),
11294 dwarf_tag_name (die
->tag
));
11299 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
11300 imported_name
= dwarf2_name (imported_die
, imported_cu
);
11301 if (imported_name
== NULL
)
11303 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11305 The import in the following code:
11319 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11320 <52> DW_AT_decl_file : 1
11321 <53> DW_AT_decl_line : 6
11322 <54> DW_AT_import : <0x75>
11323 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11324 <59> DW_AT_name : B
11325 <5b> DW_AT_decl_file : 1
11326 <5c> DW_AT_decl_line : 2
11327 <5d> DW_AT_type : <0x6e>
11329 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11330 <76> DW_AT_byte_size : 4
11331 <77> DW_AT_encoding : 5 (signed)
11333 imports the wrong die ( 0x75 instead of 0x58 ).
11334 This case will be ignored until the gcc bug is fixed. */
11338 /* Figure out the local name after import. */
11339 import_alias
= dwarf2_name (die
, cu
);
11341 /* Figure out where the statement is being imported to. */
11342 import_prefix
= determine_prefix (die
, cu
);
11344 /* Figure out what the scope of the imported die is and prepend it
11345 to the name of the imported die. */
11346 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
11348 if (imported_die
->tag
!= DW_TAG_namespace
11349 && imported_die
->tag
!= DW_TAG_module
)
11351 imported_declaration
= imported_name
;
11352 canonical_name
= imported_name_prefix
;
11354 else if (strlen (imported_name_prefix
) > 0)
11355 canonical_name
= obconcat (&objfile
->objfile_obstack
,
11356 imported_name_prefix
,
11357 (cu
->language
== language_d
? "." : "::"),
11358 imported_name
, (char *) NULL
);
11360 canonical_name
= imported_name
;
11362 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
11363 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
11364 child_die
= sibling_die (child_die
))
11366 /* DWARF-4: A Fortran use statement with a “rename list” may be
11367 represented by an imported module entry with an import attribute
11368 referring to the module and owned entries corresponding to those
11369 entities that are renamed as part of being imported. */
11371 if (child_die
->tag
!= DW_TAG_imported_declaration
)
11373 complaint (_("child DW_TAG_imported_declaration expected "
11374 "- DIE at %s [in module %s]"),
11375 sect_offset_str (child_die
->sect_off
),
11376 objfile_name (objfile
));
11380 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
11381 if (import_attr
== NULL
)
11383 complaint (_("Tag '%s' has no DW_AT_import"),
11384 dwarf_tag_name (child_die
->tag
));
11389 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
11391 imported_name
= dwarf2_name (imported_die
, imported_cu
);
11392 if (imported_name
== NULL
)
11394 complaint (_("child DW_TAG_imported_declaration has unknown "
11395 "imported name - DIE at %s [in module %s]"),
11396 sect_offset_str (child_die
->sect_off
),
11397 objfile_name (objfile
));
11401 excludes
.push_back (imported_name
);
11403 process_die (child_die
, cu
);
11406 add_using_directive (using_directives (cu
),
11410 imported_declaration
,
11413 &objfile
->objfile_obstack
);
11416 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11417 types, but gives them a size of zero. Starting with version 14,
11418 ICC is compatible with GCC. */
11421 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
11423 if (!cu
->checked_producer
)
11424 check_producer (cu
);
11426 return cu
->producer_is_icc_lt_14
;
11429 /* ICC generates a DW_AT_type for C void functions. This was observed on
11430 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11431 which says that void functions should not have a DW_AT_type. */
11434 producer_is_icc (struct dwarf2_cu
*cu
)
11436 if (!cu
->checked_producer
)
11437 check_producer (cu
);
11439 return cu
->producer_is_icc
;
11442 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11443 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11444 this, it was first present in GCC release 4.3.0. */
11447 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
11449 if (!cu
->checked_producer
)
11450 check_producer (cu
);
11452 return cu
->producer_is_gcc_lt_4_3
;
11455 static file_and_directory
11456 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
11458 file_and_directory res
;
11460 /* Find the filename. Do not use dwarf2_name here, since the filename
11461 is not a source language identifier. */
11462 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
11463 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
11465 if (res
.comp_dir
== NULL
11466 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
11467 && IS_ABSOLUTE_PATH (res
.name
))
11469 res
.comp_dir_storage
= ldirname (res
.name
);
11470 if (!res
.comp_dir_storage
.empty ())
11471 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
11473 if (res
.comp_dir
!= NULL
)
11475 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11476 directory, get rid of it. */
11477 const char *cp
= strchr (res
.comp_dir
, ':');
11479 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
11480 res
.comp_dir
= cp
+ 1;
11483 if (res
.name
== NULL
)
11484 res
.name
= "<unknown>";
11489 /* Handle DW_AT_stmt_list for a compilation unit.
11490 DIE is the DW_TAG_compile_unit die for CU.
11491 COMP_DIR is the compilation directory. LOWPC is passed to
11492 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11495 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
11496 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
11498 struct dwarf2_per_objfile
*dwarf2_per_objfile
11499 = cu
->per_cu
->dwarf2_per_objfile
;
11500 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11501 struct attribute
*attr
;
11502 struct line_header line_header_local
;
11503 hashval_t line_header_local_hash
;
11505 int decode_mapping
;
11507 gdb_assert (! cu
->per_cu
->is_debug_types
);
11509 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
11513 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
11515 /* The line header hash table is only created if needed (it exists to
11516 prevent redundant reading of the line table for partial_units).
11517 If we're given a partial_unit, we'll need it. If we're given a
11518 compile_unit, then use the line header hash table if it's already
11519 created, but don't create one just yet. */
11521 if (dwarf2_per_objfile
->line_header_hash
== NULL
11522 && die
->tag
== DW_TAG_partial_unit
)
11524 dwarf2_per_objfile
->line_header_hash
11525 = htab_create_alloc_ex (127, line_header_hash_voidp
,
11526 line_header_eq_voidp
,
11527 free_line_header_voidp
,
11528 &objfile
->objfile_obstack
,
11529 hashtab_obstack_allocate
,
11530 dummy_obstack_deallocate
);
11533 line_header_local
.sect_off
= line_offset
;
11534 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
11535 line_header_local_hash
= line_header_hash (&line_header_local
);
11536 if (dwarf2_per_objfile
->line_header_hash
!= NULL
)
11538 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
11539 &line_header_local
,
11540 line_header_local_hash
, NO_INSERT
);
11542 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11543 is not present in *SLOT (since if there is something in *SLOT then
11544 it will be for a partial_unit). */
11545 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
11547 gdb_assert (*slot
!= NULL
);
11548 cu
->line_header
= (struct line_header
*) *slot
;
11553 /* dwarf_decode_line_header does not yet provide sufficient information.
11554 We always have to call also dwarf_decode_lines for it. */
11555 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
11559 cu
->line_header
= lh
.release ();
11560 cu
->line_header_die_owner
= die
;
11562 if (dwarf2_per_objfile
->line_header_hash
== NULL
)
11566 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
11567 &line_header_local
,
11568 line_header_local_hash
, INSERT
);
11569 gdb_assert (slot
!= NULL
);
11571 if (slot
!= NULL
&& *slot
== NULL
)
11573 /* This newly decoded line number information unit will be owned
11574 by line_header_hash hash table. */
11575 *slot
= cu
->line_header
;
11576 cu
->line_header_die_owner
= NULL
;
11580 /* We cannot free any current entry in (*slot) as that struct line_header
11581 may be already used by multiple CUs. Create only temporary decoded
11582 line_header for this CU - it may happen at most once for each line
11583 number information unit. And if we're not using line_header_hash
11584 then this is what we want as well. */
11585 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
11587 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
11588 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
11593 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11596 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11598 struct dwarf2_per_objfile
*dwarf2_per_objfile
11599 = cu
->per_cu
->dwarf2_per_objfile
;
11600 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11601 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11602 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
11603 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
11604 struct attribute
*attr
;
11605 struct die_info
*child_die
;
11606 CORE_ADDR baseaddr
;
11608 prepare_one_comp_unit (cu
, die
, cu
->language
);
11609 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11611 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
11613 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11614 from finish_block. */
11615 if (lowpc
== ((CORE_ADDR
) -1))
11617 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11619 file_and_directory fnd
= find_file_and_directory (die
, cu
);
11621 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11622 standardised yet. As a workaround for the language detection we fall
11623 back to the DW_AT_producer string. */
11624 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
11625 cu
->language
= language_opencl
;
11627 /* Similar hack for Go. */
11628 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
11629 set_cu_language (DW_LANG_Go
, cu
);
11631 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
11633 /* Decode line number information if present. We do this before
11634 processing child DIEs, so that the line header table is available
11635 for DW_AT_decl_file. */
11636 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
11638 /* Process all dies in compilation unit. */
11639 if (die
->child
!= NULL
)
11641 child_die
= die
->child
;
11642 while (child_die
&& child_die
->tag
)
11644 process_die (child_die
, cu
);
11645 child_die
= sibling_die (child_die
);
11649 /* Decode macro information, if present. Dwarf 2 macro information
11650 refers to information in the line number info statement program
11651 header, so we can only read it if we've read the header
11653 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
11655 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
11656 if (attr
&& cu
->line_header
)
11658 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
11659 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11661 dwarf_decode_macros (cu
, DW_UNSND (attr
), 1);
11665 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
11666 if (attr
&& cu
->line_header
)
11668 unsigned int macro_offset
= DW_UNSND (attr
);
11670 dwarf_decode_macros (cu
, macro_offset
, 0);
11676 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
11678 struct type_unit_group
*tu_group
;
11680 struct attribute
*attr
;
11682 struct signatured_type
*sig_type
;
11684 gdb_assert (per_cu
->is_debug_types
);
11685 sig_type
= (struct signatured_type
*) per_cu
;
11687 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
11689 /* If we're using .gdb_index (includes -readnow) then
11690 per_cu->type_unit_group may not have been set up yet. */
11691 if (sig_type
->type_unit_group
== NULL
)
11692 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
11693 tu_group
= sig_type
->type_unit_group
;
11695 /* If we've already processed this stmt_list there's no real need to
11696 do it again, we could fake it and just recreate the part we need
11697 (file name,index -> symtab mapping). If data shows this optimization
11698 is useful we can do it then. */
11699 first_time
= tu_group
->compunit_symtab
== NULL
;
11701 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11706 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
11707 lh
= dwarf_decode_line_header (line_offset
, this);
11712 start_symtab ("", NULL
, 0);
11715 gdb_assert (tu_group
->symtabs
== NULL
);
11716 gdb_assert (m_builder
== nullptr);
11717 struct compunit_symtab
*cust
= tu_group
->compunit_symtab
;
11718 m_builder
.reset (new struct buildsym_compunit
11719 (COMPUNIT_OBJFILE (cust
), "",
11720 COMPUNIT_DIRNAME (cust
),
11721 compunit_language (cust
),
11727 line_header
= lh
.release ();
11728 line_header_die_owner
= die
;
11732 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
11734 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11735 still initializing it, and our caller (a few levels up)
11736 process_full_type_unit still needs to know if this is the first
11739 tu_group
->num_symtabs
= line_header
->file_names_size ();
11740 tu_group
->symtabs
= XNEWVEC (struct symtab
*,
11741 line_header
->file_names_size ());
11743 auto &file_names
= line_header
->file_names ();
11744 for (i
= 0; i
< file_names
.size (); ++i
)
11746 file_entry
&fe
= file_names
[i
];
11747 dwarf2_start_subfile (this, fe
.name
,
11748 fe
.include_dir (line_header
));
11749 buildsym_compunit
*b
= get_builder ();
11750 if (b
->get_current_subfile ()->symtab
== NULL
)
11752 /* NOTE: start_subfile will recognize when it's been
11753 passed a file it has already seen. So we can't
11754 assume there's a simple mapping from
11755 cu->line_header->file_names to subfiles, plus
11756 cu->line_header->file_names may contain dups. */
11757 b
->get_current_subfile ()->symtab
11758 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
11761 fe
.symtab
= b
->get_current_subfile ()->symtab
;
11762 tu_group
->symtabs
[i
] = fe
.symtab
;
11767 gdb_assert (m_builder
== nullptr);
11768 struct compunit_symtab
*cust
= tu_group
->compunit_symtab
;
11769 m_builder
.reset (new struct buildsym_compunit
11770 (COMPUNIT_OBJFILE (cust
), "",
11771 COMPUNIT_DIRNAME (cust
),
11772 compunit_language (cust
),
11775 auto &file_names
= line_header
->file_names ();
11776 for (i
= 0; i
< file_names
.size (); ++i
)
11778 file_entry
&fe
= file_names
[i
];
11779 fe
.symtab
= tu_group
->symtabs
[i
];
11783 /* The main symtab is allocated last. Type units don't have DW_AT_name
11784 so they don't have a "real" (so to speak) symtab anyway.
11785 There is later code that will assign the main symtab to all symbols
11786 that don't have one. We need to handle the case of a symbol with a
11787 missing symtab (DW_AT_decl_file) anyway. */
11790 /* Process DW_TAG_type_unit.
11791 For TUs we want to skip the first top level sibling if it's not the
11792 actual type being defined by this TU. In this case the first top
11793 level sibling is there to provide context only. */
11796 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11798 struct die_info
*child_die
;
11800 prepare_one_comp_unit (cu
, die
, language_minimal
);
11802 /* Initialize (or reinitialize) the machinery for building symtabs.
11803 We do this before processing child DIEs, so that the line header table
11804 is available for DW_AT_decl_file. */
11805 cu
->setup_type_unit_groups (die
);
11807 if (die
->child
!= NULL
)
11809 child_die
= die
->child
;
11810 while (child_die
&& child_die
->tag
)
11812 process_die (child_die
, cu
);
11813 child_die
= sibling_die (child_die
);
11820 http://gcc.gnu.org/wiki/DebugFission
11821 http://gcc.gnu.org/wiki/DebugFissionDWP
11823 To simplify handling of both DWO files ("object" files with the DWARF info)
11824 and DWP files (a file with the DWOs packaged up into one file), we treat
11825 DWP files as having a collection of virtual DWO files. */
11828 hash_dwo_file (const void *item
)
11830 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
11833 hash
= htab_hash_string (dwo_file
->dwo_name
);
11834 if (dwo_file
->comp_dir
!= NULL
)
11835 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11840 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11842 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11843 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11845 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11847 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11848 return lhs
->comp_dir
== rhs
->comp_dir
;
11849 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11852 /* Allocate a hash table for DWO files. */
11855 allocate_dwo_file_hash_table (struct objfile
*objfile
)
11857 auto delete_dwo_file
= [] (void *item
)
11859 struct dwo_file
*dwo_file
= (struct dwo_file
*) item
;
11864 return htab_up (htab_create_alloc_ex (41,
11868 &objfile
->objfile_obstack
,
11869 hashtab_obstack_allocate
,
11870 dummy_obstack_deallocate
));
11873 /* Lookup DWO file DWO_NAME. */
11876 lookup_dwo_file_slot (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11877 const char *dwo_name
,
11878 const char *comp_dir
)
11880 struct dwo_file find_entry
;
11883 if (dwarf2_per_objfile
->dwo_files
== NULL
)
11884 dwarf2_per_objfile
->dwo_files
11885 = allocate_dwo_file_hash_table (dwarf2_per_objfile
->objfile
);
11887 find_entry
.dwo_name
= dwo_name
;
11888 find_entry
.comp_dir
= comp_dir
;
11889 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
.get (), &find_entry
,
11896 hash_dwo_unit (const void *item
)
11898 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11900 /* This drops the top 32 bits of the id, but is ok for a hash. */
11901 return dwo_unit
->signature
;
11905 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11907 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11908 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11910 /* The signature is assumed to be unique within the DWO file.
11911 So while object file CU dwo_id's always have the value zero,
11912 that's OK, assuming each object file DWO file has only one CU,
11913 and that's the rule for now. */
11914 return lhs
->signature
== rhs
->signature
;
11917 /* Allocate a hash table for DWO CUs,TUs.
11918 There is one of these tables for each of CUs,TUs for each DWO file. */
11921 allocate_dwo_unit_table (struct objfile
*objfile
)
11923 /* Start out with a pretty small number.
11924 Generally DWO files contain only one CU and maybe some TUs. */
11925 return htab_create_alloc_ex (3,
11929 &objfile
->objfile_obstack
,
11930 hashtab_obstack_allocate
,
11931 dummy_obstack_deallocate
);
11934 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11936 struct create_dwo_cu_data
11938 struct dwo_file
*dwo_file
;
11939 struct dwo_unit dwo_unit
;
11942 /* die_reader_func for create_dwo_cu. */
11945 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
11946 const gdb_byte
*info_ptr
,
11947 struct die_info
*comp_unit_die
,
11951 struct dwarf2_cu
*cu
= reader
->cu
;
11952 sect_offset sect_off
= cu
->per_cu
->sect_off
;
11953 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
11954 struct create_dwo_cu_data
*data
= (struct create_dwo_cu_data
*) datap
;
11955 struct dwo_file
*dwo_file
= data
->dwo_file
;
11956 struct dwo_unit
*dwo_unit
= &data
->dwo_unit
;
11958 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
11959 if (!signature
.has_value ())
11961 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11962 " its dwo_id [in module %s]"),
11963 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
11967 dwo_unit
->dwo_file
= dwo_file
;
11968 dwo_unit
->signature
= *signature
;
11969 dwo_unit
->section
= section
;
11970 dwo_unit
->sect_off
= sect_off
;
11971 dwo_unit
->length
= cu
->per_cu
->length
;
11973 if (dwarf_read_debug
)
11974 fprintf_unfiltered (gdb_stdlog
, " offset %s, dwo_id %s\n",
11975 sect_offset_str (sect_off
),
11976 hex_string (dwo_unit
->signature
));
11979 /* Create the dwo_units for the CUs in a DWO_FILE.
11980 Note: This function processes DWO files only, not DWP files. */
11983 create_cus_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11984 struct dwo_file
&dwo_file
, dwarf2_section_info
§ion
,
11987 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11988 const gdb_byte
*info_ptr
, *end_ptr
;
11990 dwarf2_read_section (objfile
, §ion
);
11991 info_ptr
= section
.buffer
;
11993 if (info_ptr
== NULL
)
11996 if (dwarf_read_debug
)
11998 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
11999 get_section_name (§ion
),
12000 get_section_file_name (§ion
));
12003 end_ptr
= info_ptr
+ section
.size
;
12004 while (info_ptr
< end_ptr
)
12006 struct dwarf2_per_cu_data per_cu
;
12007 struct create_dwo_cu_data create_dwo_cu_data
;
12008 struct dwo_unit
*dwo_unit
;
12010 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
12012 memset (&create_dwo_cu_data
.dwo_unit
, 0,
12013 sizeof (create_dwo_cu_data
.dwo_unit
));
12014 memset (&per_cu
, 0, sizeof (per_cu
));
12015 per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
12016 per_cu
.is_debug_types
= 0;
12017 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
12018 per_cu
.section
= §ion
;
12019 create_dwo_cu_data
.dwo_file
= &dwo_file
;
12021 init_cutu_and_read_dies_no_follow (
12022 &per_cu
, &dwo_file
, create_dwo_cu_reader
, &create_dwo_cu_data
);
12023 info_ptr
+= per_cu
.length
;
12025 // If the unit could not be parsed, skip it.
12026 if (create_dwo_cu_data
.dwo_unit
.dwo_file
== NULL
)
12029 if (cus_htab
== NULL
)
12030 cus_htab
= allocate_dwo_unit_table (objfile
);
12032 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12033 *dwo_unit
= create_dwo_cu_data
.dwo_unit
;
12034 slot
= htab_find_slot (cus_htab
, dwo_unit
, INSERT
);
12035 gdb_assert (slot
!= NULL
);
12038 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
12039 sect_offset dup_sect_off
= dup_cu
->sect_off
;
12041 complaint (_("debug cu entry at offset %s is duplicate to"
12042 " the entry at offset %s, signature %s"),
12043 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
12044 hex_string (dwo_unit
->signature
));
12046 *slot
= (void *)dwo_unit
;
12050 /* DWP file .debug_{cu,tu}_index section format:
12051 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
12055 Both index sections have the same format, and serve to map a 64-bit
12056 signature to a set of section numbers. Each section begins with a header,
12057 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
12058 indexes, and a pool of 32-bit section numbers. The index sections will be
12059 aligned at 8-byte boundaries in the file.
12061 The index section header consists of:
12063 V, 32 bit version number
12065 N, 32 bit number of compilation units or type units in the index
12066 M, 32 bit number of slots in the hash table
12068 Numbers are recorded using the byte order of the application binary.
12070 The hash table begins at offset 16 in the section, and consists of an array
12071 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
12072 order of the application binary). Unused slots in the hash table are 0.
12073 (We rely on the extreme unlikeliness of a signature being exactly 0.)
12075 The parallel table begins immediately after the hash table
12076 (at offset 16 + 8 * M from the beginning of the section), and consists of an
12077 array of 32-bit indexes (using the byte order of the application binary),
12078 corresponding 1-1 with slots in the hash table. Each entry in the parallel
12079 table contains a 32-bit index into the pool of section numbers. For unused
12080 hash table slots, the corresponding entry in the parallel table will be 0.
12082 The pool of section numbers begins immediately following the hash table
12083 (at offset 16 + 12 * M from the beginning of the section). The pool of
12084 section numbers consists of an array of 32-bit words (using the byte order
12085 of the application binary). Each item in the array is indexed starting
12086 from 0. The hash table entry provides the index of the first section
12087 number in the set. Additional section numbers in the set follow, and the
12088 set is terminated by a 0 entry (section number 0 is not used in ELF).
12090 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12091 section must be the first entry in the set, and the .debug_abbrev.dwo must
12092 be the second entry. Other members of the set may follow in any order.
12098 DWP Version 2 combines all the .debug_info, etc. sections into one,
12099 and the entries in the index tables are now offsets into these sections.
12100 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
12103 Index Section Contents:
12105 Hash Table of Signatures dwp_hash_table.hash_table
12106 Parallel Table of Indices dwp_hash_table.unit_table
12107 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
12108 Table of Section Sizes dwp_hash_table.v2.sizes
12110 The index section header consists of:
12112 V, 32 bit version number
12113 L, 32 bit number of columns in the table of section offsets
12114 N, 32 bit number of compilation units or type units in the index
12115 M, 32 bit number of slots in the hash table
12117 Numbers are recorded using the byte order of the application binary.
12119 The hash table has the same format as version 1.
12120 The parallel table of indices has the same format as version 1,
12121 except that the entries are origin-1 indices into the table of sections
12122 offsets and the table of section sizes.
12124 The table of offsets begins immediately following the parallel table
12125 (at offset 16 + 12 * M from the beginning of the section). The table is
12126 a two-dimensional array of 32-bit words (using the byte order of the
12127 application binary), with L columns and N+1 rows, in row-major order.
12128 Each row in the array is indexed starting from 0. The first row provides
12129 a key to the remaining rows: each column in this row provides an identifier
12130 for a debug section, and the offsets in the same column of subsequent rows
12131 refer to that section. The section identifiers are:
12133 DW_SECT_INFO 1 .debug_info.dwo
12134 DW_SECT_TYPES 2 .debug_types.dwo
12135 DW_SECT_ABBREV 3 .debug_abbrev.dwo
12136 DW_SECT_LINE 4 .debug_line.dwo
12137 DW_SECT_LOC 5 .debug_loc.dwo
12138 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
12139 DW_SECT_MACINFO 7 .debug_macinfo.dwo
12140 DW_SECT_MACRO 8 .debug_macro.dwo
12142 The offsets provided by the CU and TU index sections are the base offsets
12143 for the contributions made by each CU or TU to the corresponding section
12144 in the package file. Each CU and TU header contains an abbrev_offset
12145 field, used to find the abbreviations table for that CU or TU within the
12146 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12147 be interpreted as relative to the base offset given in the index section.
12148 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12149 should be interpreted as relative to the base offset for .debug_line.dwo,
12150 and offsets into other debug sections obtained from DWARF attributes should
12151 also be interpreted as relative to the corresponding base offset.
12153 The table of sizes begins immediately following the table of offsets.
12154 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12155 with L columns and N rows, in row-major order. Each row in the array is
12156 indexed starting from 1 (row 0 is shared by the two tables).
12160 Hash table lookup is handled the same in version 1 and 2:
12162 We assume that N and M will not exceed 2^32 - 1.
12163 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12165 Given a 64-bit compilation unit signature or a type signature S, an entry
12166 in the hash table is located as follows:
12168 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12169 the low-order k bits all set to 1.
12171 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12173 3) If the hash table entry at index H matches the signature, use that
12174 entry. If the hash table entry at index H is unused (all zeroes),
12175 terminate the search: the signature is not present in the table.
12177 4) Let H = (H + H') modulo M. Repeat at Step 3.
12179 Because M > N and H' and M are relatively prime, the search is guaranteed
12180 to stop at an unused slot or find the match. */
12182 /* Create a hash table to map DWO IDs to their CU/TU entry in
12183 .debug_{info,types}.dwo in DWP_FILE.
12184 Returns NULL if there isn't one.
12185 Note: This function processes DWP files only, not DWO files. */
12187 static struct dwp_hash_table
*
12188 create_dwp_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12189 struct dwp_file
*dwp_file
, int is_debug_types
)
12191 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12192 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12193 const gdb_byte
*index_ptr
, *index_end
;
12194 struct dwarf2_section_info
*index
;
12195 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
12196 struct dwp_hash_table
*htab
;
12198 if (is_debug_types
)
12199 index
= &dwp_file
->sections
.tu_index
;
12201 index
= &dwp_file
->sections
.cu_index
;
12203 if (dwarf2_section_empty_p (index
))
12205 dwarf2_read_section (objfile
, index
);
12207 index_ptr
= index
->buffer
;
12208 index_end
= index_ptr
+ index
->size
;
12210 version
= read_4_bytes (dbfd
, index_ptr
);
12213 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
12217 nr_units
= read_4_bytes (dbfd
, index_ptr
);
12219 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
12222 if (version
!= 1 && version
!= 2)
12224 error (_("Dwarf Error: unsupported DWP file version (%s)"
12225 " [in module %s]"),
12226 pulongest (version
), dwp_file
->name
);
12228 if (nr_slots
!= (nr_slots
& -nr_slots
))
12230 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12231 " is not power of 2 [in module %s]"),
12232 pulongest (nr_slots
), dwp_file
->name
);
12235 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
12236 htab
->version
= version
;
12237 htab
->nr_columns
= nr_columns
;
12238 htab
->nr_units
= nr_units
;
12239 htab
->nr_slots
= nr_slots
;
12240 htab
->hash_table
= index_ptr
;
12241 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
12243 /* Exit early if the table is empty. */
12244 if (nr_slots
== 0 || nr_units
== 0
12245 || (version
== 2 && nr_columns
== 0))
12247 /* All must be zero. */
12248 if (nr_slots
!= 0 || nr_units
!= 0
12249 || (version
== 2 && nr_columns
!= 0))
12251 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12252 " all zero [in modules %s]"),
12260 htab
->section_pool
.v1
.indices
=
12261 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
12262 /* It's harder to decide whether the section is too small in v1.
12263 V1 is deprecated anyway so we punt. */
12267 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
12268 int *ids
= htab
->section_pool
.v2
.section_ids
;
12269 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
12270 /* Reverse map for error checking. */
12271 int ids_seen
[DW_SECT_MAX
+ 1];
12274 if (nr_columns
< 2)
12276 error (_("Dwarf Error: bad DWP hash table, too few columns"
12277 " in section table [in module %s]"),
12280 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
12282 error (_("Dwarf Error: bad DWP hash table, too many columns"
12283 " in section table [in module %s]"),
12286 memset (ids
, 255, sizeof_ids
);
12287 memset (ids_seen
, 255, sizeof (ids_seen
));
12288 for (i
= 0; i
< nr_columns
; ++i
)
12290 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
12292 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
12294 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12295 " in section table [in module %s]"),
12296 id
, dwp_file
->name
);
12298 if (ids_seen
[id
] != -1)
12300 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12301 " id %d in section table [in module %s]"),
12302 id
, dwp_file
->name
);
12307 /* Must have exactly one info or types section. */
12308 if (((ids_seen
[DW_SECT_INFO
] != -1)
12309 + (ids_seen
[DW_SECT_TYPES
] != -1))
12312 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12313 " DWO info/types section [in module %s]"),
12316 /* Must have an abbrev section. */
12317 if (ids_seen
[DW_SECT_ABBREV
] == -1)
12319 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12320 " section [in module %s]"),
12323 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
12324 htab
->section_pool
.v2
.sizes
=
12325 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
12326 * nr_units
* nr_columns
);
12327 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
12328 * nr_units
* nr_columns
))
12331 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12332 " [in module %s]"),
12340 /* Update SECTIONS with the data from SECTP.
12342 This function is like the other "locate" section routines that are
12343 passed to bfd_map_over_sections, but in this context the sections to
12344 read comes from the DWP V1 hash table, not the full ELF section table.
12346 The result is non-zero for success, or zero if an error was found. */
12349 locate_v1_virtual_dwo_sections (asection
*sectp
,
12350 struct virtual_v1_dwo_sections
*sections
)
12352 const struct dwop_section_names
*names
= &dwop_section_names
;
12354 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12356 /* There can be only one. */
12357 if (sections
->abbrev
.s
.section
!= NULL
)
12359 sections
->abbrev
.s
.section
= sectp
;
12360 sections
->abbrev
.size
= bfd_section_size (sectp
);
12362 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
12363 || section_is_p (sectp
->name
, &names
->types_dwo
))
12365 /* There can be only one. */
12366 if (sections
->info_or_types
.s
.section
!= NULL
)
12368 sections
->info_or_types
.s
.section
= sectp
;
12369 sections
->info_or_types
.size
= bfd_section_size (sectp
);
12371 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12373 /* There can be only one. */
12374 if (sections
->line
.s
.section
!= NULL
)
12376 sections
->line
.s
.section
= sectp
;
12377 sections
->line
.size
= bfd_section_size (sectp
);
12379 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12381 /* There can be only one. */
12382 if (sections
->loc
.s
.section
!= NULL
)
12384 sections
->loc
.s
.section
= sectp
;
12385 sections
->loc
.size
= bfd_section_size (sectp
);
12387 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12389 /* There can be only one. */
12390 if (sections
->macinfo
.s
.section
!= NULL
)
12392 sections
->macinfo
.s
.section
= sectp
;
12393 sections
->macinfo
.size
= bfd_section_size (sectp
);
12395 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12397 /* There can be only one. */
12398 if (sections
->macro
.s
.section
!= NULL
)
12400 sections
->macro
.s
.section
= sectp
;
12401 sections
->macro
.size
= bfd_section_size (sectp
);
12403 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12405 /* There can be only one. */
12406 if (sections
->str_offsets
.s
.section
!= NULL
)
12408 sections
->str_offsets
.s
.section
= sectp
;
12409 sections
->str_offsets
.size
= bfd_section_size (sectp
);
12413 /* No other kind of section is valid. */
12420 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12421 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12422 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12423 This is for DWP version 1 files. */
12425 static struct dwo_unit
*
12426 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12427 struct dwp_file
*dwp_file
,
12428 uint32_t unit_index
,
12429 const char *comp_dir
,
12430 ULONGEST signature
, int is_debug_types
)
12432 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12433 const struct dwp_hash_table
*dwp_htab
=
12434 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12435 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12436 const char *kind
= is_debug_types
? "TU" : "CU";
12437 struct dwo_file
*dwo_file
;
12438 struct dwo_unit
*dwo_unit
;
12439 struct virtual_v1_dwo_sections sections
;
12440 void **dwo_file_slot
;
12443 gdb_assert (dwp_file
->version
== 1);
12445 if (dwarf_read_debug
)
12447 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
12449 pulongest (unit_index
), hex_string (signature
),
12453 /* Fetch the sections of this DWO unit.
12454 Put a limit on the number of sections we look for so that bad data
12455 doesn't cause us to loop forever. */
12457 #define MAX_NR_V1_DWO_SECTIONS \
12458 (1 /* .debug_info or .debug_types */ \
12459 + 1 /* .debug_abbrev */ \
12460 + 1 /* .debug_line */ \
12461 + 1 /* .debug_loc */ \
12462 + 1 /* .debug_str_offsets */ \
12463 + 1 /* .debug_macro or .debug_macinfo */ \
12464 + 1 /* trailing zero */)
12466 memset (§ions
, 0, sizeof (sections
));
12468 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
12471 uint32_t section_nr
=
12472 read_4_bytes (dbfd
,
12473 dwp_htab
->section_pool
.v1
.indices
12474 + (unit_index
+ i
) * sizeof (uint32_t));
12476 if (section_nr
== 0)
12478 if (section_nr
>= dwp_file
->num_sections
)
12480 error (_("Dwarf Error: bad DWP hash table, section number too large"
12481 " [in module %s]"),
12485 sectp
= dwp_file
->elf_sections
[section_nr
];
12486 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
12488 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12489 " [in module %s]"),
12495 || dwarf2_section_empty_p (§ions
.info_or_types
)
12496 || dwarf2_section_empty_p (§ions
.abbrev
))
12498 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12499 " [in module %s]"),
12502 if (i
== MAX_NR_V1_DWO_SECTIONS
)
12504 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12505 " [in module %s]"),
12509 /* It's easier for the rest of the code if we fake a struct dwo_file and
12510 have dwo_unit "live" in that. At least for now.
12512 The DWP file can be made up of a random collection of CUs and TUs.
12513 However, for each CU + set of TUs that came from the same original DWO
12514 file, we can combine them back into a virtual DWO file to save space
12515 (fewer struct dwo_file objects to allocate). Remember that for really
12516 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12518 std::string virtual_dwo_name
=
12519 string_printf ("virtual-dwo/%d-%d-%d-%d",
12520 get_section_id (§ions
.abbrev
),
12521 get_section_id (§ions
.line
),
12522 get_section_id (§ions
.loc
),
12523 get_section_id (§ions
.str_offsets
));
12524 /* Can we use an existing virtual DWO file? */
12525 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
12526 virtual_dwo_name
.c_str (),
12528 /* Create one if necessary. */
12529 if (*dwo_file_slot
== NULL
)
12531 if (dwarf_read_debug
)
12533 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12534 virtual_dwo_name
.c_str ());
12536 dwo_file
= new struct dwo_file
;
12537 dwo_file
->dwo_name
= obstack_strdup (&objfile
->objfile_obstack
,
12539 dwo_file
->comp_dir
= comp_dir
;
12540 dwo_file
->sections
.abbrev
= sections
.abbrev
;
12541 dwo_file
->sections
.line
= sections
.line
;
12542 dwo_file
->sections
.loc
= sections
.loc
;
12543 dwo_file
->sections
.macinfo
= sections
.macinfo
;
12544 dwo_file
->sections
.macro
= sections
.macro
;
12545 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
12546 /* The "str" section is global to the entire DWP file. */
12547 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12548 /* The info or types section is assigned below to dwo_unit,
12549 there's no need to record it in dwo_file.
12550 Also, we can't simply record type sections in dwo_file because
12551 we record a pointer into the vector in dwo_unit. As we collect more
12552 types we'll grow the vector and eventually have to reallocate space
12553 for it, invalidating all copies of pointers into the previous
12555 *dwo_file_slot
= dwo_file
;
12559 if (dwarf_read_debug
)
12561 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12562 virtual_dwo_name
.c_str ());
12564 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12567 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12568 dwo_unit
->dwo_file
= dwo_file
;
12569 dwo_unit
->signature
= signature
;
12570 dwo_unit
->section
=
12571 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
12572 *dwo_unit
->section
= sections
.info_or_types
;
12573 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12578 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12579 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12580 piece within that section used by a TU/CU, return a virtual section
12581 of just that piece. */
12583 static struct dwarf2_section_info
12584 create_dwp_v2_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12585 struct dwarf2_section_info
*section
,
12586 bfd_size_type offset
, bfd_size_type size
)
12588 struct dwarf2_section_info result
;
12591 gdb_assert (section
!= NULL
);
12592 gdb_assert (!section
->is_virtual
);
12594 memset (&result
, 0, sizeof (result
));
12595 result
.s
.containing_section
= section
;
12596 result
.is_virtual
= true;
12601 sectp
= get_section_bfd_section (section
);
12603 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12604 bounds of the real section. This is a pretty-rare event, so just
12605 flag an error (easier) instead of a warning and trying to cope. */
12607 || offset
+ size
> bfd_section_size (sectp
))
12609 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12610 " in section %s [in module %s]"),
12611 sectp
? bfd_section_name (sectp
) : "<unknown>",
12612 objfile_name (dwarf2_per_objfile
->objfile
));
12615 result
.virtual_offset
= offset
;
12616 result
.size
= size
;
12620 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12621 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12622 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12623 This is for DWP version 2 files. */
12625 static struct dwo_unit
*
12626 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12627 struct dwp_file
*dwp_file
,
12628 uint32_t unit_index
,
12629 const char *comp_dir
,
12630 ULONGEST signature
, int is_debug_types
)
12632 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12633 const struct dwp_hash_table
*dwp_htab
=
12634 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12635 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12636 const char *kind
= is_debug_types
? "TU" : "CU";
12637 struct dwo_file
*dwo_file
;
12638 struct dwo_unit
*dwo_unit
;
12639 struct virtual_v2_dwo_sections sections
;
12640 void **dwo_file_slot
;
12643 gdb_assert (dwp_file
->version
== 2);
12645 if (dwarf_read_debug
)
12647 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
12649 pulongest (unit_index
), hex_string (signature
),
12653 /* Fetch the section offsets of this DWO unit. */
12655 memset (§ions
, 0, sizeof (sections
));
12657 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12659 uint32_t offset
= read_4_bytes (dbfd
,
12660 dwp_htab
->section_pool
.v2
.offsets
12661 + (((unit_index
- 1) * dwp_htab
->nr_columns
12663 * sizeof (uint32_t)));
12664 uint32_t size
= read_4_bytes (dbfd
,
12665 dwp_htab
->section_pool
.v2
.sizes
12666 + (((unit_index
- 1) * dwp_htab
->nr_columns
12668 * sizeof (uint32_t)));
12670 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
12673 case DW_SECT_TYPES
:
12674 sections
.info_or_types_offset
= offset
;
12675 sections
.info_or_types_size
= size
;
12677 case DW_SECT_ABBREV
:
12678 sections
.abbrev_offset
= offset
;
12679 sections
.abbrev_size
= size
;
12682 sections
.line_offset
= offset
;
12683 sections
.line_size
= size
;
12686 sections
.loc_offset
= offset
;
12687 sections
.loc_size
= size
;
12689 case DW_SECT_STR_OFFSETS
:
12690 sections
.str_offsets_offset
= offset
;
12691 sections
.str_offsets_size
= size
;
12693 case DW_SECT_MACINFO
:
12694 sections
.macinfo_offset
= offset
;
12695 sections
.macinfo_size
= size
;
12697 case DW_SECT_MACRO
:
12698 sections
.macro_offset
= offset
;
12699 sections
.macro_size
= size
;
12704 /* It's easier for the rest of the code if we fake a struct dwo_file and
12705 have dwo_unit "live" in that. At least for now.
12707 The DWP file can be made up of a random collection of CUs and TUs.
12708 However, for each CU + set of TUs that came from the same original DWO
12709 file, we can combine them back into a virtual DWO file to save space
12710 (fewer struct dwo_file objects to allocate). Remember that for really
12711 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12713 std::string virtual_dwo_name
=
12714 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12715 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12716 (long) (sections
.line_size
? sections
.line_offset
: 0),
12717 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
12718 (long) (sections
.str_offsets_size
12719 ? sections
.str_offsets_offset
: 0));
12720 /* Can we use an existing virtual DWO file? */
12721 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
12722 virtual_dwo_name
.c_str (),
12724 /* Create one if necessary. */
12725 if (*dwo_file_slot
== NULL
)
12727 if (dwarf_read_debug
)
12729 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12730 virtual_dwo_name
.c_str ());
12732 dwo_file
= new struct dwo_file
;
12733 dwo_file
->dwo_name
= obstack_strdup (&objfile
->objfile_obstack
,
12735 dwo_file
->comp_dir
= comp_dir
;
12736 dwo_file
->sections
.abbrev
=
12737 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.abbrev
,
12738 sections
.abbrev_offset
, sections
.abbrev_size
);
12739 dwo_file
->sections
.line
=
12740 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.line
,
12741 sections
.line_offset
, sections
.line_size
);
12742 dwo_file
->sections
.loc
=
12743 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.loc
,
12744 sections
.loc_offset
, sections
.loc_size
);
12745 dwo_file
->sections
.macinfo
=
12746 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macinfo
,
12747 sections
.macinfo_offset
, sections
.macinfo_size
);
12748 dwo_file
->sections
.macro
=
12749 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macro
,
12750 sections
.macro_offset
, sections
.macro_size
);
12751 dwo_file
->sections
.str_offsets
=
12752 create_dwp_v2_section (dwarf2_per_objfile
,
12753 &dwp_file
->sections
.str_offsets
,
12754 sections
.str_offsets_offset
,
12755 sections
.str_offsets_size
);
12756 /* The "str" section is global to the entire DWP file. */
12757 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12758 /* The info or types section is assigned below to dwo_unit,
12759 there's no need to record it in dwo_file.
12760 Also, we can't simply record type sections in dwo_file because
12761 we record a pointer into the vector in dwo_unit. As we collect more
12762 types we'll grow the vector and eventually have to reallocate space
12763 for it, invalidating all copies of pointers into the previous
12765 *dwo_file_slot
= dwo_file
;
12769 if (dwarf_read_debug
)
12771 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12772 virtual_dwo_name
.c_str ());
12774 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12777 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12778 dwo_unit
->dwo_file
= dwo_file
;
12779 dwo_unit
->signature
= signature
;
12780 dwo_unit
->section
=
12781 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
12782 *dwo_unit
->section
= create_dwp_v2_section (dwarf2_per_objfile
,
12784 ? &dwp_file
->sections
.types
12785 : &dwp_file
->sections
.info
,
12786 sections
.info_or_types_offset
,
12787 sections
.info_or_types_size
);
12788 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12793 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12794 Returns NULL if the signature isn't found. */
12796 static struct dwo_unit
*
12797 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12798 struct dwp_file
*dwp_file
, const char *comp_dir
,
12799 ULONGEST signature
, int is_debug_types
)
12801 const struct dwp_hash_table
*dwp_htab
=
12802 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12803 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12804 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12805 uint32_t hash
= signature
& mask
;
12806 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12809 struct dwo_unit find_dwo_cu
;
12811 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12812 find_dwo_cu
.signature
= signature
;
12813 slot
= htab_find_slot (is_debug_types
12814 ? dwp_file
->loaded_tus
12815 : dwp_file
->loaded_cus
,
12816 &find_dwo_cu
, INSERT
);
12819 return (struct dwo_unit
*) *slot
;
12821 /* Use a for loop so that we don't loop forever on bad debug info. */
12822 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12824 ULONGEST signature_in_table
;
12826 signature_in_table
=
12827 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12828 if (signature_in_table
== signature
)
12830 uint32_t unit_index
=
12831 read_4_bytes (dbfd
,
12832 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12834 if (dwp_file
->version
== 1)
12836 *slot
= create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
,
12837 dwp_file
, unit_index
,
12838 comp_dir
, signature
,
12843 *slot
= create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
,
12844 dwp_file
, unit_index
,
12845 comp_dir
, signature
,
12848 return (struct dwo_unit
*) *slot
;
12850 if (signature_in_table
== 0)
12852 hash
= (hash
+ hash2
) & mask
;
12855 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12856 " [in module %s]"),
12860 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12861 Open the file specified by FILE_NAME and hand it off to BFD for
12862 preliminary analysis. Return a newly initialized bfd *, which
12863 includes a canonicalized copy of FILE_NAME.
12864 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12865 SEARCH_CWD is true if the current directory is to be searched.
12866 It will be searched before debug-file-directory.
12867 If successful, the file is added to the bfd include table of the
12868 objfile's bfd (see gdb_bfd_record_inclusion).
12869 If unable to find/open the file, return NULL.
12870 NOTE: This function is derived from symfile_bfd_open. */
12872 static gdb_bfd_ref_ptr
12873 try_open_dwop_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12874 const char *file_name
, int is_dwp
, int search_cwd
)
12877 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12878 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12879 to debug_file_directory. */
12880 const char *search_path
;
12881 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12883 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12886 if (*debug_file_directory
!= '\0')
12888 search_path_holder
.reset (concat (".", dirname_separator_string
,
12889 debug_file_directory
,
12891 search_path
= search_path_holder
.get ();
12897 search_path
= debug_file_directory
;
12899 openp_flags flags
= OPF_RETURN_REALPATH
;
12901 flags
|= OPF_SEARCH_IN_PATH
;
12903 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12904 desc
= openp (search_path
, flags
, file_name
,
12905 O_RDONLY
| O_BINARY
, &absolute_name
);
12909 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12911 if (sym_bfd
== NULL
)
12913 bfd_set_cacheable (sym_bfd
.get (), 1);
12915 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12918 /* Success. Record the bfd as having been included by the objfile's bfd.
12919 This is important because things like demangled_names_hash lives in the
12920 objfile's per_bfd space and may have references to things like symbol
12921 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12922 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12927 /* Try to open DWO file FILE_NAME.
12928 COMP_DIR is the DW_AT_comp_dir attribute.
12929 The result is the bfd handle of the file.
12930 If there is a problem finding or opening the file, return NULL.
12931 Upon success, the canonicalized path of the file is stored in the bfd,
12932 same as symfile_bfd_open. */
12934 static gdb_bfd_ref_ptr
12935 open_dwo_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12936 const char *file_name
, const char *comp_dir
)
12938 if (IS_ABSOLUTE_PATH (file_name
))
12939 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12940 0 /*is_dwp*/, 0 /*search_cwd*/);
12942 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12944 if (comp_dir
!= NULL
)
12946 gdb::unique_xmalloc_ptr
<char> path_to_try
12947 (concat (comp_dir
, SLASH_STRING
, file_name
, (char *) NULL
));
12949 /* NOTE: If comp_dir is a relative path, this will also try the
12950 search path, which seems useful. */
12951 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
,
12952 path_to_try
.get (),
12954 1 /*search_cwd*/));
12959 /* That didn't work, try debug-file-directory, which, despite its name,
12960 is a list of paths. */
12962 if (*debug_file_directory
== '\0')
12965 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12966 0 /*is_dwp*/, 1 /*search_cwd*/);
12969 /* This function is mapped across the sections and remembers the offset and
12970 size of each of the DWO debugging sections we are interested in. */
12973 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
12975 struct dwo_sections
*dwo_sections
= (struct dwo_sections
*) dwo_sections_ptr
;
12976 const struct dwop_section_names
*names
= &dwop_section_names
;
12978 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12980 dwo_sections
->abbrev
.s
.section
= sectp
;
12981 dwo_sections
->abbrev
.size
= bfd_section_size (sectp
);
12983 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12985 dwo_sections
->info
.s
.section
= sectp
;
12986 dwo_sections
->info
.size
= bfd_section_size (sectp
);
12988 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12990 dwo_sections
->line
.s
.section
= sectp
;
12991 dwo_sections
->line
.size
= bfd_section_size (sectp
);
12993 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12995 dwo_sections
->loc
.s
.section
= sectp
;
12996 dwo_sections
->loc
.size
= bfd_section_size (sectp
);
12998 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
13000 dwo_sections
->macinfo
.s
.section
= sectp
;
13001 dwo_sections
->macinfo
.size
= bfd_section_size (sectp
);
13003 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
13005 dwo_sections
->macro
.s
.section
= sectp
;
13006 dwo_sections
->macro
.size
= bfd_section_size (sectp
);
13008 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
13010 dwo_sections
->str
.s
.section
= sectp
;
13011 dwo_sections
->str
.size
= bfd_section_size (sectp
);
13013 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
13015 dwo_sections
->str_offsets
.s
.section
= sectp
;
13016 dwo_sections
->str_offsets
.size
= bfd_section_size (sectp
);
13018 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
13020 struct dwarf2_section_info type_section
;
13022 memset (&type_section
, 0, sizeof (type_section
));
13023 type_section
.s
.section
= sectp
;
13024 type_section
.size
= bfd_section_size (sectp
);
13025 dwo_sections
->types
.push_back (type_section
);
13029 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
13030 by PER_CU. This is for the non-DWP case.
13031 The result is NULL if DWO_NAME can't be found. */
13033 static struct dwo_file
*
13034 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
13035 const char *dwo_name
, const char *comp_dir
)
13037 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
13039 gdb_bfd_ref_ptr dbfd
= open_dwo_file (dwarf2_per_objfile
, dwo_name
, comp_dir
);
13042 if (dwarf_read_debug
)
13043 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
13047 dwo_file_up
dwo_file (new struct dwo_file
);
13048 dwo_file
->dwo_name
= dwo_name
;
13049 dwo_file
->comp_dir
= comp_dir
;
13050 dwo_file
->dbfd
= std::move (dbfd
);
13052 bfd_map_over_sections (dwo_file
->dbfd
.get (), dwarf2_locate_dwo_sections
,
13053 &dwo_file
->sections
);
13055 create_cus_hash_table (dwarf2_per_objfile
, *dwo_file
, dwo_file
->sections
.info
,
13058 create_debug_types_hash_table (dwarf2_per_objfile
, dwo_file
.get (),
13059 dwo_file
->sections
.types
, dwo_file
->tus
);
13061 if (dwarf_read_debug
)
13062 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
13064 return dwo_file
.release ();
13067 /* This function is mapped across the sections and remembers the offset and
13068 size of each of the DWP debugging sections common to version 1 and 2 that
13069 we are interested in. */
13072 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
13073 void *dwp_file_ptr
)
13075 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
13076 const struct dwop_section_names
*names
= &dwop_section_names
;
13077 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
13079 /* Record the ELF section number for later lookup: this is what the
13080 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13081 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
13082 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
13084 /* Look for specific sections that we need. */
13085 if (section_is_p (sectp
->name
, &names
->str_dwo
))
13087 dwp_file
->sections
.str
.s
.section
= sectp
;
13088 dwp_file
->sections
.str
.size
= bfd_section_size (sectp
);
13090 else if (section_is_p (sectp
->name
, &names
->cu_index
))
13092 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
13093 dwp_file
->sections
.cu_index
.size
= bfd_section_size (sectp
);
13095 else if (section_is_p (sectp
->name
, &names
->tu_index
))
13097 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
13098 dwp_file
->sections
.tu_index
.size
= bfd_section_size (sectp
);
13102 /* This function is mapped across the sections and remembers the offset and
13103 size of each of the DWP version 2 debugging sections that we are interested
13104 in. This is split into a separate function because we don't know if we
13105 have version 1 or 2 until we parse the cu_index/tu_index sections. */
13108 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
13110 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
13111 const struct dwop_section_names
*names
= &dwop_section_names
;
13112 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
13114 /* Record the ELF section number for later lookup: this is what the
13115 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13116 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
13117 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
13119 /* Look for specific sections that we need. */
13120 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
13122 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
13123 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
13125 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
13127 dwp_file
->sections
.info
.s
.section
= sectp
;
13128 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
13130 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
13132 dwp_file
->sections
.line
.s
.section
= sectp
;
13133 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
13135 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
13137 dwp_file
->sections
.loc
.s
.section
= sectp
;
13138 dwp_file
->sections
.loc
.size
= bfd_section_size (sectp
);
13140 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
13142 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
13143 dwp_file
->sections
.macinfo
.size
= bfd_section_size (sectp
);
13145 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
13147 dwp_file
->sections
.macro
.s
.section
= sectp
;
13148 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
13150 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
13152 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
13153 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
13155 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
13157 dwp_file
->sections
.types
.s
.section
= sectp
;
13158 dwp_file
->sections
.types
.size
= bfd_section_size (sectp
);
13162 /* Hash function for dwp_file loaded CUs/TUs. */
13165 hash_dwp_loaded_cutus (const void *item
)
13167 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
13169 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13170 return dwo_unit
->signature
;
13173 /* Equality function for dwp_file loaded CUs/TUs. */
13176 eq_dwp_loaded_cutus (const void *a
, const void *b
)
13178 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
13179 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
13181 return dua
->signature
== dub
->signature
;
13184 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13187 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
13189 return htab_create_alloc_ex (3,
13190 hash_dwp_loaded_cutus
,
13191 eq_dwp_loaded_cutus
,
13193 &objfile
->objfile_obstack
,
13194 hashtab_obstack_allocate
,
13195 dummy_obstack_deallocate
);
13198 /* Try to open DWP file FILE_NAME.
13199 The result is the bfd handle of the file.
13200 If there is a problem finding or opening the file, return NULL.
13201 Upon success, the canonicalized path of the file is stored in the bfd,
13202 same as symfile_bfd_open. */
13204 static gdb_bfd_ref_ptr
13205 open_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
13206 const char *file_name
)
13208 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
, file_name
,
13210 1 /*search_cwd*/));
13214 /* Work around upstream bug 15652.
13215 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13216 [Whether that's a "bug" is debatable, but it is getting in our way.]
13217 We have no real idea where the dwp file is, because gdb's realpath-ing
13218 of the executable's path may have discarded the needed info.
13219 [IWBN if the dwp file name was recorded in the executable, akin to
13220 .gnu_debuglink, but that doesn't exist yet.]
13221 Strip the directory from FILE_NAME and search again. */
13222 if (*debug_file_directory
!= '\0')
13224 /* Don't implicitly search the current directory here.
13225 If the user wants to search "." to handle this case,
13226 it must be added to debug-file-directory. */
13227 return try_open_dwop_file (dwarf2_per_objfile
,
13228 lbasename (file_name
), 1 /*is_dwp*/,
13235 /* Initialize the use of the DWP file for the current objfile.
13236 By convention the name of the DWP file is ${objfile}.dwp.
13237 The result is NULL if it can't be found. */
13239 static std::unique_ptr
<struct dwp_file
>
13240 open_and_init_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
13242 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13244 /* Try to find first .dwp for the binary file before any symbolic links
13247 /* If the objfile is a debug file, find the name of the real binary
13248 file and get the name of dwp file from there. */
13249 std::string dwp_name
;
13250 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
13252 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
13253 const char *backlink_basename
= lbasename (backlink
->original_name
);
13255 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
13258 dwp_name
= objfile
->original_name
;
13260 dwp_name
+= ".dwp";
13262 gdb_bfd_ref_ptr
dbfd (open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ()));
13264 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
13266 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13267 dwp_name
= objfile_name (objfile
);
13268 dwp_name
+= ".dwp";
13269 dbfd
= open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ());
13274 if (dwarf_read_debug
)
13275 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
.c_str ());
13276 return std::unique_ptr
<dwp_file
> ();
13279 const char *name
= bfd_get_filename (dbfd
.get ());
13280 std::unique_ptr
<struct dwp_file
> dwp_file
13281 (new struct dwp_file (name
, std::move (dbfd
)));
13283 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
13284 dwp_file
->elf_sections
=
13285 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
13286 dwp_file
->num_sections
, asection
*);
13288 bfd_map_over_sections (dwp_file
->dbfd
.get (),
13289 dwarf2_locate_common_dwp_sections
,
13292 dwp_file
->cus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
.get (),
13295 dwp_file
->tus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
.get (),
13298 /* The DWP file version is stored in the hash table. Oh well. */
13299 if (dwp_file
->cus
&& dwp_file
->tus
13300 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
13302 /* Technically speaking, we should try to limp along, but this is
13303 pretty bizarre. We use pulongest here because that's the established
13304 portability solution (e.g, we cannot use %u for uint32_t). */
13305 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13306 " TU version %s [in DWP file %s]"),
13307 pulongest (dwp_file
->cus
->version
),
13308 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
13312 dwp_file
->version
= dwp_file
->cus
->version
;
13313 else if (dwp_file
->tus
)
13314 dwp_file
->version
= dwp_file
->tus
->version
;
13316 dwp_file
->version
= 2;
13318 if (dwp_file
->version
== 2)
13319 bfd_map_over_sections (dwp_file
->dbfd
.get (),
13320 dwarf2_locate_v2_dwp_sections
,
13323 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table (objfile
);
13324 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table (objfile
);
13326 if (dwarf_read_debug
)
13328 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
13329 fprintf_unfiltered (gdb_stdlog
,
13330 " %s CUs, %s TUs\n",
13331 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
13332 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
13338 /* Wrapper around open_and_init_dwp_file, only open it once. */
13340 static struct dwp_file
*
13341 get_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
13343 if (! dwarf2_per_objfile
->dwp_checked
)
13345 dwarf2_per_objfile
->dwp_file
13346 = open_and_init_dwp_file (dwarf2_per_objfile
);
13347 dwarf2_per_objfile
->dwp_checked
= 1;
13349 return dwarf2_per_objfile
->dwp_file
.get ();
13352 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13353 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13354 or in the DWP file for the objfile, referenced by THIS_UNIT.
13355 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13356 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13358 This is called, for example, when wanting to read a variable with a
13359 complex location. Therefore we don't want to do file i/o for every call.
13360 Therefore we don't want to look for a DWO file on every call.
13361 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13362 then we check if we've already seen DWO_NAME, and only THEN do we check
13365 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13366 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13368 static struct dwo_unit
*
13369 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
13370 const char *dwo_name
, const char *comp_dir
,
13371 ULONGEST signature
, int is_debug_types
)
13373 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_unit
->dwarf2_per_objfile
;
13374 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13375 const char *kind
= is_debug_types
? "TU" : "CU";
13376 void **dwo_file_slot
;
13377 struct dwo_file
*dwo_file
;
13378 struct dwp_file
*dwp_file
;
13380 /* First see if there's a DWP file.
13381 If we have a DWP file but didn't find the DWO inside it, don't
13382 look for the original DWO file. It makes gdb behave differently
13383 depending on whether one is debugging in the build tree. */
13385 dwp_file
= get_dwp_file (dwarf2_per_objfile
);
13386 if (dwp_file
!= NULL
)
13388 const struct dwp_hash_table
*dwp_htab
=
13389 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
13391 if (dwp_htab
!= NULL
)
13393 struct dwo_unit
*dwo_cutu
=
13394 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, comp_dir
,
13395 signature
, is_debug_types
);
13397 if (dwo_cutu
!= NULL
)
13399 if (dwarf_read_debug
)
13401 fprintf_unfiltered (gdb_stdlog
,
13402 "Virtual DWO %s %s found: @%s\n",
13403 kind
, hex_string (signature
),
13404 host_address_to_string (dwo_cutu
));
13412 /* No DWP file, look for the DWO file. */
13414 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
13415 dwo_name
, comp_dir
);
13416 if (*dwo_file_slot
== NULL
)
13418 /* Read in the file and build a table of the CUs/TUs it contains. */
13419 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
13421 /* NOTE: This will be NULL if unable to open the file. */
13422 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
13424 if (dwo_file
!= NULL
)
13426 struct dwo_unit
*dwo_cutu
= NULL
;
13428 if (is_debug_types
&& dwo_file
->tus
)
13430 struct dwo_unit find_dwo_cutu
;
13432 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13433 find_dwo_cutu
.signature
= signature
;
13435 = (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_cutu
);
13437 else if (!is_debug_types
&& dwo_file
->cus
)
13439 struct dwo_unit find_dwo_cutu
;
13441 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13442 find_dwo_cutu
.signature
= signature
;
13443 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
,
13447 if (dwo_cutu
!= NULL
)
13449 if (dwarf_read_debug
)
13451 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
13452 kind
, dwo_name
, hex_string (signature
),
13453 host_address_to_string (dwo_cutu
));
13460 /* We didn't find it. This could mean a dwo_id mismatch, or
13461 someone deleted the DWO/DWP file, or the search path isn't set up
13462 correctly to find the file. */
13464 if (dwarf_read_debug
)
13466 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
13467 kind
, dwo_name
, hex_string (signature
));
13470 /* This is a warning and not a complaint because it can be caused by
13471 pilot error (e.g., user accidentally deleting the DWO). */
13473 /* Print the name of the DWP file if we looked there, helps the user
13474 better diagnose the problem. */
13475 std::string dwp_text
;
13477 if (dwp_file
!= NULL
)
13478 dwp_text
= string_printf (" [in DWP file %s]",
13479 lbasename (dwp_file
->name
));
13481 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13482 " [in module %s]"),
13483 kind
, dwo_name
, hex_string (signature
),
13485 this_unit
->is_debug_types
? "TU" : "CU",
13486 sect_offset_str (this_unit
->sect_off
), objfile_name (objfile
));
13491 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13492 See lookup_dwo_cutu_unit for details. */
13494 static struct dwo_unit
*
13495 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
13496 const char *dwo_name
, const char *comp_dir
,
13497 ULONGEST signature
)
13499 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
13502 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13503 See lookup_dwo_cutu_unit for details. */
13505 static struct dwo_unit
*
13506 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
13507 const char *dwo_name
, const char *comp_dir
)
13509 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
13512 /* Traversal function for queue_and_load_all_dwo_tus. */
13515 queue_and_load_dwo_tu (void **slot
, void *info
)
13517 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
13518 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
13519 ULONGEST signature
= dwo_unit
->signature
;
13520 struct signatured_type
*sig_type
=
13521 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
13523 if (sig_type
!= NULL
)
13525 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
13527 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13528 a real dependency of PER_CU on SIG_TYPE. That is detected later
13529 while processing PER_CU. */
13530 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
13531 load_full_type_unit (sig_cu
);
13532 per_cu
->imported_symtabs_push (sig_cu
);
13538 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13539 The DWO may have the only definition of the type, though it may not be
13540 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13541 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13544 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
13546 struct dwo_unit
*dwo_unit
;
13547 struct dwo_file
*dwo_file
;
13549 gdb_assert (!per_cu
->is_debug_types
);
13550 gdb_assert (get_dwp_file (per_cu
->dwarf2_per_objfile
) == NULL
);
13551 gdb_assert (per_cu
->cu
!= NULL
);
13553 dwo_unit
= per_cu
->cu
->dwo_unit
;
13554 gdb_assert (dwo_unit
!= NULL
);
13556 dwo_file
= dwo_unit
->dwo_file
;
13557 if (dwo_file
->tus
!= NULL
)
13558 htab_traverse_noresize (dwo_file
->tus
, queue_and_load_dwo_tu
, per_cu
);
13561 /* Read in various DIEs. */
13563 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13564 Inherit only the children of the DW_AT_abstract_origin DIE not being
13565 already referenced by DW_AT_abstract_origin from the children of the
13569 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
13571 struct die_info
*child_die
;
13572 sect_offset
*offsetp
;
13573 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13574 struct die_info
*origin_die
;
13575 /* Iterator of the ORIGIN_DIE children. */
13576 struct die_info
*origin_child_die
;
13577 struct attribute
*attr
;
13578 struct dwarf2_cu
*origin_cu
;
13579 struct pending
**origin_previous_list_in_scope
;
13581 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13585 /* Note that following die references may follow to a die in a
13589 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
13591 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13593 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
13594 origin_cu
->list_in_scope
= cu
->list_in_scope
;
13596 if (die
->tag
!= origin_die
->tag
13597 && !(die
->tag
== DW_TAG_inlined_subroutine
13598 && origin_die
->tag
== DW_TAG_subprogram
))
13599 complaint (_("DIE %s and its abstract origin %s have different tags"),
13600 sect_offset_str (die
->sect_off
),
13601 sect_offset_str (origin_die
->sect_off
));
13603 std::vector
<sect_offset
> offsets
;
13605 for (child_die
= die
->child
;
13606 child_die
&& child_die
->tag
;
13607 child_die
= sibling_die (child_die
))
13609 struct die_info
*child_origin_die
;
13610 struct dwarf2_cu
*child_origin_cu
;
13612 /* We are trying to process concrete instance entries:
13613 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13614 it's not relevant to our analysis here. i.e. detecting DIEs that are
13615 present in the abstract instance but not referenced in the concrete
13617 if (child_die
->tag
== DW_TAG_call_site
13618 || child_die
->tag
== DW_TAG_GNU_call_site
)
13621 /* For each CHILD_DIE, find the corresponding child of
13622 ORIGIN_DIE. If there is more than one layer of
13623 DW_AT_abstract_origin, follow them all; there shouldn't be,
13624 but GCC versions at least through 4.4 generate this (GCC PR
13626 child_origin_die
= child_die
;
13627 child_origin_cu
= cu
;
13630 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
13634 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
13638 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13639 counterpart may exist. */
13640 if (child_origin_die
!= child_die
)
13642 if (child_die
->tag
!= child_origin_die
->tag
13643 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13644 && child_origin_die
->tag
== DW_TAG_subprogram
))
13645 complaint (_("Child DIE %s and its abstract origin %s have "
13647 sect_offset_str (child_die
->sect_off
),
13648 sect_offset_str (child_origin_die
->sect_off
));
13649 if (child_origin_die
->parent
!= origin_die
)
13650 complaint (_("Child DIE %s and its abstract origin %s have "
13651 "different parents"),
13652 sect_offset_str (child_die
->sect_off
),
13653 sect_offset_str (child_origin_die
->sect_off
));
13655 offsets
.push_back (child_origin_die
->sect_off
);
13658 std::sort (offsets
.begin (), offsets
.end ());
13659 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13660 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13661 if (offsetp
[-1] == *offsetp
)
13662 complaint (_("Multiple children of DIE %s refer "
13663 "to DIE %s as their abstract origin"),
13664 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
13666 offsetp
= offsets
.data ();
13667 origin_child_die
= origin_die
->child
;
13668 while (origin_child_die
&& origin_child_die
->tag
)
13670 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13671 while (offsetp
< offsets_end
13672 && *offsetp
< origin_child_die
->sect_off
)
13674 if (offsetp
>= offsets_end
13675 || *offsetp
> origin_child_die
->sect_off
)
13677 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13678 Check whether we're already processing ORIGIN_CHILD_DIE.
13679 This can happen with mutually referenced abstract_origins.
13681 if (!origin_child_die
->in_process
)
13682 process_die (origin_child_die
, origin_cu
);
13684 origin_child_die
= sibling_die (origin_child_die
);
13686 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13688 if (cu
!= origin_cu
)
13689 compute_delayed_physnames (origin_cu
);
13693 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13695 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13696 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13697 struct context_stack
*newobj
;
13700 struct die_info
*child_die
;
13701 struct attribute
*attr
, *call_line
, *call_file
;
13703 CORE_ADDR baseaddr
;
13704 struct block
*block
;
13705 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13706 std::vector
<struct symbol
*> template_args
;
13707 struct template_symbol
*templ_func
= NULL
;
13711 /* If we do not have call site information, we can't show the
13712 caller of this inlined function. That's too confusing, so
13713 only use the scope for local variables. */
13714 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13715 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13716 if (call_line
== NULL
|| call_file
== NULL
)
13718 read_lexical_block_scope (die
, cu
);
13723 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13725 name
= dwarf2_name (die
, cu
);
13727 /* Ignore functions with missing or empty names. These are actually
13728 illegal according to the DWARF standard. */
13731 complaint (_("missing name for subprogram DIE at %s"),
13732 sect_offset_str (die
->sect_off
));
13736 /* Ignore functions with missing or invalid low and high pc attributes. */
13737 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13738 <= PC_BOUNDS_INVALID
)
13740 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13741 if (!attr
|| !DW_UNSND (attr
))
13742 complaint (_("cannot get low and high bounds "
13743 "for subprogram DIE at %s"),
13744 sect_offset_str (die
->sect_off
));
13748 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13749 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13751 /* If we have any template arguments, then we must allocate a
13752 different sort of symbol. */
13753 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
13755 if (child_die
->tag
== DW_TAG_template_type_param
13756 || child_die
->tag
== DW_TAG_template_value_param
)
13758 templ_func
= allocate_template_symbol (objfile
);
13759 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13764 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13765 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13766 (struct symbol
*) templ_func
);
13768 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13769 set_objfile_main_name (objfile
, newobj
->name
->linkage_name (),
13772 /* If there is a location expression for DW_AT_frame_base, record
13774 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13775 if (attr
!= nullptr)
13776 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13778 /* If there is a location for the static link, record it. */
13779 newobj
->static_link
= NULL
;
13780 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13781 if (attr
!= nullptr)
13783 newobj
->static_link
13784 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13785 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
13786 dwarf2_per_cu_addr_type (cu
->per_cu
));
13789 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13791 if (die
->child
!= NULL
)
13793 child_die
= die
->child
;
13794 while (child_die
&& child_die
->tag
)
13796 if (child_die
->tag
== DW_TAG_template_type_param
13797 || child_die
->tag
== DW_TAG_template_value_param
)
13799 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13802 template_args
.push_back (arg
);
13805 process_die (child_die
, cu
);
13806 child_die
= sibling_die (child_die
);
13810 inherit_abstract_dies (die
, cu
);
13812 /* If we have a DW_AT_specification, we might need to import using
13813 directives from the context of the specification DIE. See the
13814 comment in determine_prefix. */
13815 if (cu
->language
== language_cplus
13816 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13818 struct dwarf2_cu
*spec_cu
= cu
;
13819 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13823 child_die
= spec_die
->child
;
13824 while (child_die
&& child_die
->tag
)
13826 if (child_die
->tag
== DW_TAG_imported_module
)
13827 process_die (child_die
, spec_cu
);
13828 child_die
= sibling_die (child_die
);
13831 /* In some cases, GCC generates specification DIEs that
13832 themselves contain DW_AT_specification attributes. */
13833 spec_die
= die_specification (spec_die
, &spec_cu
);
13837 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13838 /* Make a block for the local symbols within. */
13839 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13840 cstk
.static_link
, lowpc
, highpc
);
13842 /* For C++, set the block's scope. */
13843 if ((cu
->language
== language_cplus
13844 || cu
->language
== language_fortran
13845 || cu
->language
== language_d
13846 || cu
->language
== language_rust
)
13847 && cu
->processing_has_namespace_info
)
13848 block_set_scope (block
, determine_prefix (die
, cu
),
13849 &objfile
->objfile_obstack
);
13851 /* If we have address ranges, record them. */
13852 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13854 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13856 /* Attach template arguments to function. */
13857 if (!template_args
.empty ())
13859 gdb_assert (templ_func
!= NULL
);
13861 templ_func
->n_template_arguments
= template_args
.size ();
13862 templ_func
->template_arguments
13863 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13864 templ_func
->n_template_arguments
);
13865 memcpy (templ_func
->template_arguments
,
13866 template_args
.data (),
13867 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13869 /* Make sure that the symtab is set on the new symbols. Even
13870 though they don't appear in this symtab directly, other parts
13871 of gdb assume that symbols do, and this is reasonably
13873 for (symbol
*sym
: template_args
)
13874 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13877 /* In C++, we can have functions nested inside functions (e.g., when
13878 a function declares a class that has methods). This means that
13879 when we finish processing a function scope, we may need to go
13880 back to building a containing block's symbol lists. */
13881 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13882 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13884 /* If we've finished processing a top-level function, subsequent
13885 symbols go in the file symbol list. */
13886 if (cu
->get_builder ()->outermost_context_p ())
13887 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13890 /* Process all the DIES contained within a lexical block scope. Start
13891 a new scope, process the dies, and then close the scope. */
13894 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13896 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13897 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13898 CORE_ADDR lowpc
, highpc
;
13899 struct die_info
*child_die
;
13900 CORE_ADDR baseaddr
;
13902 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13904 /* Ignore blocks with missing or invalid low and high pc attributes. */
13905 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13906 as multiple lexical blocks? Handling children in a sane way would
13907 be nasty. Might be easier to properly extend generic blocks to
13908 describe ranges. */
13909 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13911 case PC_BOUNDS_NOT_PRESENT
:
13912 /* DW_TAG_lexical_block has no attributes, process its children as if
13913 there was no wrapping by that DW_TAG_lexical_block.
13914 GCC does no longer produces such DWARF since GCC r224161. */
13915 for (child_die
= die
->child
;
13916 child_die
!= NULL
&& child_die
->tag
;
13917 child_die
= sibling_die (child_die
))
13918 process_die (child_die
, cu
);
13920 case PC_BOUNDS_INVALID
:
13923 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13924 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13926 cu
->get_builder ()->push_context (0, lowpc
);
13927 if (die
->child
!= NULL
)
13929 child_die
= die
->child
;
13930 while (child_die
&& child_die
->tag
)
13932 process_die (child_die
, cu
);
13933 child_die
= sibling_die (child_die
);
13936 inherit_abstract_dies (die
, cu
);
13937 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13939 if (*cu
->get_builder ()->get_local_symbols () != NULL
13940 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13942 struct block
*block
13943 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13944 cstk
.start_addr
, highpc
);
13946 /* Note that recording ranges after traversing children, as we
13947 do here, means that recording a parent's ranges entails
13948 walking across all its children's ranges as they appear in
13949 the address map, which is quadratic behavior.
13951 It would be nicer to record the parent's ranges before
13952 traversing its children, simply overriding whatever you find
13953 there. But since we don't even decide whether to create a
13954 block until after we've traversed its children, that's hard
13956 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13958 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13959 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13962 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13965 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13967 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13968 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13969 CORE_ADDR pc
, baseaddr
;
13970 struct attribute
*attr
;
13971 struct call_site
*call_site
, call_site_local
;
13974 struct die_info
*child_die
;
13976 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13978 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13981 /* This was a pre-DWARF-5 GNU extension alias
13982 for DW_AT_call_return_pc. */
13983 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13987 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13988 "DIE %s [in module %s]"),
13989 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13992 pc
= attr_value_as_address (attr
) + baseaddr
;
13993 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13995 if (cu
->call_site_htab
== NULL
)
13996 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13997 NULL
, &objfile
->objfile_obstack
,
13998 hashtab_obstack_allocate
, NULL
);
13999 call_site_local
.pc
= pc
;
14000 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
14003 complaint (_("Duplicate PC %s for DW_TAG_call_site "
14004 "DIE %s [in module %s]"),
14005 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
14006 objfile_name (objfile
));
14010 /* Count parameters at the caller. */
14013 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
14014 child_die
= sibling_die (child_die
))
14016 if (child_die
->tag
!= DW_TAG_call_site_parameter
14017 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14019 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
14020 "DW_TAG_call_site child DIE %s [in module %s]"),
14021 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
14022 objfile_name (objfile
));
14030 = ((struct call_site
*)
14031 obstack_alloc (&objfile
->objfile_obstack
,
14032 sizeof (*call_site
)
14033 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
14035 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
14036 call_site
->pc
= pc
;
14038 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
14039 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
14041 struct die_info
*func_die
;
14043 /* Skip also over DW_TAG_inlined_subroutine. */
14044 for (func_die
= die
->parent
;
14045 func_die
&& func_die
->tag
!= DW_TAG_subprogram
14046 && func_die
->tag
!= DW_TAG_subroutine_type
;
14047 func_die
= func_die
->parent
);
14049 /* DW_AT_call_all_calls is a superset
14050 of DW_AT_call_all_tail_calls. */
14052 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
14053 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
14054 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
14055 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
14057 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
14058 not complete. But keep CALL_SITE for look ups via call_site_htab,
14059 both the initial caller containing the real return address PC and
14060 the final callee containing the current PC of a chain of tail
14061 calls do not need to have the tail call list complete. But any
14062 function candidate for a virtual tail call frame searched via
14063 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14064 determined unambiguously. */
14068 struct type
*func_type
= NULL
;
14071 func_type
= get_die_type (func_die
, cu
);
14072 if (func_type
!= NULL
)
14074 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
14076 /* Enlist this call site to the function. */
14077 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
14078 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
14081 complaint (_("Cannot find function owning DW_TAG_call_site "
14082 "DIE %s [in module %s]"),
14083 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14087 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
14089 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
14091 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
14094 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
14095 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14097 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
14098 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
14099 /* Keep NULL DWARF_BLOCK. */;
14100 else if (attr_form_is_block (attr
))
14102 struct dwarf2_locexpr_baton
*dlbaton
;
14104 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
14105 dlbaton
->data
= DW_BLOCK (attr
)->data
;
14106 dlbaton
->size
= DW_BLOCK (attr
)->size
;
14107 dlbaton
->per_cu
= cu
->per_cu
;
14109 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
14111 else if (attr_form_is_ref (attr
))
14113 struct dwarf2_cu
*target_cu
= cu
;
14114 struct die_info
*target_die
;
14116 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14117 gdb_assert (target_cu
->per_cu
->dwarf2_per_objfile
->objfile
== objfile
);
14118 if (die_is_declaration (target_die
, target_cu
))
14120 const char *target_physname
;
14122 /* Prefer the mangled name; otherwise compute the demangled one. */
14123 target_physname
= dw2_linkage_name (target_die
, target_cu
);
14124 if (target_physname
== NULL
)
14125 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
14126 if (target_physname
== NULL
)
14127 complaint (_("DW_AT_call_target target DIE has invalid "
14128 "physname, for referencing DIE %s [in module %s]"),
14129 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14131 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
14137 /* DW_AT_entry_pc should be preferred. */
14138 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
14139 <= PC_BOUNDS_INVALID
)
14140 complaint (_("DW_AT_call_target target DIE has invalid "
14141 "low pc, for referencing DIE %s [in module %s]"),
14142 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14145 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
14146 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
14151 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14152 "block nor reference, for DIE %s [in module %s]"),
14153 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14155 call_site
->per_cu
= cu
->per_cu
;
14157 for (child_die
= die
->child
;
14158 child_die
&& child_die
->tag
;
14159 child_die
= sibling_die (child_die
))
14161 struct call_site_parameter
*parameter
;
14162 struct attribute
*loc
, *origin
;
14164 if (child_die
->tag
!= DW_TAG_call_site_parameter
14165 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14167 /* Already printed the complaint above. */
14171 gdb_assert (call_site
->parameter_count
< nparams
);
14172 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
14174 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14175 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14176 register is contained in DW_AT_call_value. */
14178 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
14179 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
14180 if (origin
== NULL
)
14182 /* This was a pre-DWARF-5 GNU extension alias
14183 for DW_AT_call_parameter. */
14184 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
14186 if (loc
== NULL
&& origin
!= NULL
&& attr_form_is_ref (origin
))
14188 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
14190 sect_offset sect_off
14191 = (sect_offset
) dwarf2_get_ref_die_offset (origin
);
14192 if (!offset_in_cu_p (&cu
->header
, sect_off
))
14194 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14195 binding can be done only inside one CU. Such referenced DIE
14196 therefore cannot be even moved to DW_TAG_partial_unit. */
14197 complaint (_("DW_AT_call_parameter offset is not in CU for "
14198 "DW_TAG_call_site child DIE %s [in module %s]"),
14199 sect_offset_str (child_die
->sect_off
),
14200 objfile_name (objfile
));
14203 parameter
->u
.param_cu_off
14204 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
14206 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
14208 complaint (_("No DW_FORM_block* DW_AT_location for "
14209 "DW_TAG_call_site child DIE %s [in module %s]"),
14210 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
14215 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
14216 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
14217 if (parameter
->u
.dwarf_reg
!= -1)
14218 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
14219 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
14220 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
14221 ¶meter
->u
.fb_offset
))
14222 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
14225 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14226 "for DW_FORM_block* DW_AT_location is supported for "
14227 "DW_TAG_call_site child DIE %s "
14229 sect_offset_str (child_die
->sect_off
),
14230 objfile_name (objfile
));
14235 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
14237 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
14238 if (!attr_form_is_block (attr
))
14240 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14241 "DW_TAG_call_site child DIE %s [in module %s]"),
14242 sect_offset_str (child_die
->sect_off
),
14243 objfile_name (objfile
));
14246 parameter
->value
= DW_BLOCK (attr
)->data
;
14247 parameter
->value_size
= DW_BLOCK (attr
)->size
;
14249 /* Parameters are not pre-cleared by memset above. */
14250 parameter
->data_value
= NULL
;
14251 parameter
->data_value_size
= 0;
14252 call_site
->parameter_count
++;
14254 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
14256 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
14257 if (attr
!= nullptr)
14259 if (!attr_form_is_block (attr
))
14260 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14261 "DW_TAG_call_site child DIE %s [in module %s]"),
14262 sect_offset_str (child_die
->sect_off
),
14263 objfile_name (objfile
));
14266 parameter
->data_value
= DW_BLOCK (attr
)->data
;
14267 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
14273 /* Helper function for read_variable. If DIE represents a virtual
14274 table, then return the type of the concrete object that is
14275 associated with the virtual table. Otherwise, return NULL. */
14277 static struct type
*
14278 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14280 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
14284 /* Find the type DIE. */
14285 struct die_info
*type_die
= NULL
;
14286 struct dwarf2_cu
*type_cu
= cu
;
14288 if (attr_form_is_ref (attr
))
14289 type_die
= follow_die_ref (die
, attr
, &type_cu
);
14290 if (type_die
== NULL
)
14293 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
14295 return die_containing_type (type_die
, type_cu
);
14298 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14301 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
14303 struct rust_vtable_symbol
*storage
= NULL
;
14305 if (cu
->language
== language_rust
)
14307 struct type
*containing_type
= rust_containing_type (die
, cu
);
14309 if (containing_type
!= NULL
)
14311 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14313 storage
= new (&objfile
->objfile_obstack
) rust_vtable_symbol ();
14314 initialize_objfile_symbol (storage
);
14315 storage
->concrete_type
= containing_type
;
14316 storage
->subclass
= SYMBOL_RUST_VTABLE
;
14320 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
14321 struct attribute
*abstract_origin
14322 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14323 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
14324 if (res
== NULL
&& loc
&& abstract_origin
)
14326 /* We have a variable without a name, but with a location and an abstract
14327 origin. This may be a concrete instance of an abstract variable
14328 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14330 struct dwarf2_cu
*origin_cu
= cu
;
14331 struct die_info
*origin_die
14332 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
14333 dwarf2_per_objfile
*dpo
= cu
->per_cu
->dwarf2_per_objfile
;
14334 dpo
->abstract_to_concrete
[origin_die
->sect_off
].push_back (die
->sect_off
);
14338 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14339 reading .debug_rnglists.
14340 Callback's type should be:
14341 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14342 Return true if the attributes are present and valid, otherwise,
14345 template <typename Callback
>
14347 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
14348 Callback
&&callback
)
14350 struct dwarf2_per_objfile
*dwarf2_per_objfile
14351 = cu
->per_cu
->dwarf2_per_objfile
;
14352 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14353 bfd
*obfd
= objfile
->obfd
;
14354 /* Base address selection entry. */
14357 const gdb_byte
*buffer
;
14358 CORE_ADDR baseaddr
;
14359 bool overflow
= false;
14361 found_base
= cu
->base_known
;
14362 base
= cu
->base_address
;
14364 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->rnglists
);
14365 if (offset
>= dwarf2_per_objfile
->rnglists
.size
)
14367 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14371 buffer
= dwarf2_per_objfile
->rnglists
.buffer
+ offset
;
14373 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14377 /* Initialize it due to a false compiler warning. */
14378 CORE_ADDR range_beginning
= 0, range_end
= 0;
14379 const gdb_byte
*buf_end
= (dwarf2_per_objfile
->rnglists
.buffer
14380 + dwarf2_per_objfile
->rnglists
.size
);
14381 unsigned int bytes_read
;
14383 if (buffer
== buf_end
)
14388 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
14391 case DW_RLE_end_of_list
:
14393 case DW_RLE_base_address
:
14394 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14399 base
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14401 buffer
+= bytes_read
;
14403 case DW_RLE_start_length
:
14404 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14409 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14410 buffer
+= bytes_read
;
14411 range_end
= (range_beginning
14412 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14413 buffer
+= bytes_read
;
14414 if (buffer
> buf_end
)
14420 case DW_RLE_offset_pair
:
14421 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14422 buffer
+= bytes_read
;
14423 if (buffer
> buf_end
)
14428 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14429 buffer
+= bytes_read
;
14430 if (buffer
> buf_end
)
14436 case DW_RLE_start_end
:
14437 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
14442 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14443 buffer
+= bytes_read
;
14444 range_end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14445 buffer
+= bytes_read
;
14448 complaint (_("Invalid .debug_rnglists data (no base address)"));
14451 if (rlet
== DW_RLE_end_of_list
|| overflow
)
14453 if (rlet
== DW_RLE_base_address
)
14458 /* We have no valid base address for the ranges
14460 complaint (_("Invalid .debug_rnglists data (no base address)"));
14464 if (range_beginning
> range_end
)
14466 /* Inverted range entries are invalid. */
14467 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14471 /* Empty range entries have no effect. */
14472 if (range_beginning
== range_end
)
14475 range_beginning
+= base
;
14478 /* A not-uncommon case of bad debug info.
14479 Don't pollute the addrmap with bad data. */
14480 if (range_beginning
+ baseaddr
== 0
14481 && !dwarf2_per_objfile
->has_section_at_zero
)
14483 complaint (_(".debug_rnglists entry has start address of zero"
14484 " [in module %s]"), objfile_name (objfile
));
14488 callback (range_beginning
, range_end
);
14493 complaint (_("Offset %d is not terminated "
14494 "for DW_AT_ranges attribute"),
14502 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14503 Callback's type should be:
14504 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14505 Return 1 if the attributes are present and valid, otherwise, return 0. */
14507 template <typename Callback
>
14509 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
,
14510 Callback
&&callback
)
14512 struct dwarf2_per_objfile
*dwarf2_per_objfile
14513 = cu
->per_cu
->dwarf2_per_objfile
;
14514 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14515 struct comp_unit_head
*cu_header
= &cu
->header
;
14516 bfd
*obfd
= objfile
->obfd
;
14517 unsigned int addr_size
= cu_header
->addr_size
;
14518 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
14519 /* Base address selection entry. */
14522 unsigned int dummy
;
14523 const gdb_byte
*buffer
;
14524 CORE_ADDR baseaddr
;
14526 if (cu_header
->version
>= 5)
14527 return dwarf2_rnglists_process (offset
, cu
, callback
);
14529 found_base
= cu
->base_known
;
14530 base
= cu
->base_address
;
14532 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
14533 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
14535 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14539 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
14541 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14545 CORE_ADDR range_beginning
, range_end
;
14547 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
14548 buffer
+= addr_size
;
14549 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
14550 buffer
+= addr_size
;
14551 offset
+= 2 * addr_size
;
14553 /* An end of list marker is a pair of zero addresses. */
14554 if (range_beginning
== 0 && range_end
== 0)
14555 /* Found the end of list entry. */
14558 /* Each base address selection entry is a pair of 2 values.
14559 The first is the largest possible address, the second is
14560 the base address. Check for a base address here. */
14561 if ((range_beginning
& mask
) == mask
)
14563 /* If we found the largest possible address, then we already
14564 have the base address in range_end. */
14572 /* We have no valid base address for the ranges
14574 complaint (_("Invalid .debug_ranges data (no base address)"));
14578 if (range_beginning
> range_end
)
14580 /* Inverted range entries are invalid. */
14581 complaint (_("Invalid .debug_ranges data (inverted range)"));
14585 /* Empty range entries have no effect. */
14586 if (range_beginning
== range_end
)
14589 range_beginning
+= base
;
14592 /* A not-uncommon case of bad debug info.
14593 Don't pollute the addrmap with bad data. */
14594 if (range_beginning
+ baseaddr
== 0
14595 && !dwarf2_per_objfile
->has_section_at_zero
)
14597 complaint (_(".debug_ranges entry has start address of zero"
14598 " [in module %s]"), objfile_name (objfile
));
14602 callback (range_beginning
, range_end
);
14608 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14609 Return 1 if the attributes are present and valid, otherwise, return 0.
14610 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14613 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14614 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14615 struct partial_symtab
*ranges_pst
)
14617 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14618 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14619 const CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
14620 SECT_OFF_TEXT (objfile
));
14623 CORE_ADDR high
= 0;
14626 retval
= dwarf2_ranges_process (offset
, cu
,
14627 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14629 if (ranges_pst
!= NULL
)
14634 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14635 range_beginning
+ baseaddr
)
14637 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14638 range_end
+ baseaddr
)
14640 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
14641 lowpc
, highpc
- 1, ranges_pst
);
14644 /* FIXME: This is recording everything as a low-high
14645 segment of consecutive addresses. We should have a
14646 data structure for discontiguous block ranges
14650 low
= range_beginning
;
14656 if (range_beginning
< low
)
14657 low
= range_beginning
;
14658 if (range_end
> high
)
14666 /* If the first entry is an end-of-list marker, the range
14667 describes an empty scope, i.e. no instructions. */
14673 *high_return
= high
;
14677 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14678 definition for the return value. *LOWPC and *HIGHPC are set iff
14679 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14681 static enum pc_bounds_kind
14682 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14683 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14684 struct partial_symtab
*pst
)
14686 struct dwarf2_per_objfile
*dwarf2_per_objfile
14687 = cu
->per_cu
->dwarf2_per_objfile
;
14688 struct attribute
*attr
;
14689 struct attribute
*attr_high
;
14691 CORE_ADDR high
= 0;
14692 enum pc_bounds_kind ret
;
14694 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14697 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14698 if (attr
!= nullptr)
14700 low
= attr_value_as_address (attr
);
14701 high
= attr_value_as_address (attr_high
);
14702 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
14706 /* Found high w/o low attribute. */
14707 return PC_BOUNDS_INVALID
;
14709 /* Found consecutive range of addresses. */
14710 ret
= PC_BOUNDS_HIGH_LOW
;
14714 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14717 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14718 We take advantage of the fact that DW_AT_ranges does not appear
14719 in DW_TAG_compile_unit of DWO files. */
14720 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
14721 unsigned int ranges_offset
= (DW_UNSND (attr
)
14722 + (need_ranges_base
14726 /* Value of the DW_AT_ranges attribute is the offset in the
14727 .debug_ranges section. */
14728 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
14729 return PC_BOUNDS_INVALID
;
14730 /* Found discontinuous range of addresses. */
14731 ret
= PC_BOUNDS_RANGES
;
14734 return PC_BOUNDS_NOT_PRESENT
;
14737 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14739 return PC_BOUNDS_INVALID
;
14741 /* When using the GNU linker, .gnu.linkonce. sections are used to
14742 eliminate duplicate copies of functions and vtables and such.
14743 The linker will arbitrarily choose one and discard the others.
14744 The AT_*_pc values for such functions refer to local labels in
14745 these sections. If the section from that file was discarded, the
14746 labels are not in the output, so the relocs get a value of 0.
14747 If this is a discarded function, mark the pc bounds as invalid,
14748 so that GDB will ignore it. */
14749 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
14750 return PC_BOUNDS_INVALID
;
14758 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14759 its low and high PC addresses. Do nothing if these addresses could not
14760 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14761 and HIGHPC to the high address if greater than HIGHPC. */
14764 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14765 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14766 struct dwarf2_cu
*cu
)
14768 CORE_ADDR low
, high
;
14769 struct die_info
*child
= die
->child
;
14771 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14773 *lowpc
= std::min (*lowpc
, low
);
14774 *highpc
= std::max (*highpc
, high
);
14777 /* If the language does not allow nested subprograms (either inside
14778 subprograms or lexical blocks), we're done. */
14779 if (cu
->language
!= language_ada
)
14782 /* Check all the children of the given DIE. If it contains nested
14783 subprograms, then check their pc bounds. Likewise, we need to
14784 check lexical blocks as well, as they may also contain subprogram
14786 while (child
&& child
->tag
)
14788 if (child
->tag
== DW_TAG_subprogram
14789 || child
->tag
== DW_TAG_lexical_block
)
14790 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14791 child
= sibling_die (child
);
14795 /* Get the low and high pc's represented by the scope DIE, and store
14796 them in *LOWPC and *HIGHPC. If the correct values can't be
14797 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14800 get_scope_pc_bounds (struct die_info
*die
,
14801 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14802 struct dwarf2_cu
*cu
)
14804 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14805 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14806 CORE_ADDR current_low
, current_high
;
14808 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14809 >= PC_BOUNDS_RANGES
)
14811 best_low
= current_low
;
14812 best_high
= current_high
;
14816 struct die_info
*child
= die
->child
;
14818 while (child
&& child
->tag
)
14820 switch (child
->tag
) {
14821 case DW_TAG_subprogram
:
14822 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14824 case DW_TAG_namespace
:
14825 case DW_TAG_module
:
14826 /* FIXME: carlton/2004-01-16: Should we do this for
14827 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14828 that current GCC's always emit the DIEs corresponding
14829 to definitions of methods of classes as children of a
14830 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14831 the DIEs giving the declarations, which could be
14832 anywhere). But I don't see any reason why the
14833 standards says that they have to be there. */
14834 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14836 if (current_low
!= ((CORE_ADDR
) -1))
14838 best_low
= std::min (best_low
, current_low
);
14839 best_high
= std::max (best_high
, current_high
);
14847 child
= sibling_die (child
);
14852 *highpc
= best_high
;
14855 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14859 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14860 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14862 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14863 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14864 struct attribute
*attr
;
14865 struct attribute
*attr_high
;
14867 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14870 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14871 if (attr
!= nullptr)
14873 CORE_ADDR low
= attr_value_as_address (attr
);
14874 CORE_ADDR high
= attr_value_as_address (attr_high
);
14876 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
14879 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14880 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14881 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14885 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14886 if (attr
!= nullptr)
14888 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14889 We take advantage of the fact that DW_AT_ranges does not appear
14890 in DW_TAG_compile_unit of DWO files. */
14891 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
14893 /* The value of the DW_AT_ranges attribute is the offset of the
14894 address range list in the .debug_ranges section. */
14895 unsigned long offset
= (DW_UNSND (attr
)
14896 + (need_ranges_base
? cu
->ranges_base
: 0));
14898 std::vector
<blockrange
> blockvec
;
14899 dwarf2_ranges_process (offset
, cu
,
14900 [&] (CORE_ADDR start
, CORE_ADDR end
)
14904 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14905 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14906 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14907 blockvec
.emplace_back (start
, end
);
14910 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14914 /* Check whether the producer field indicates either of GCC < 4.6, or the
14915 Intel C/C++ compiler, and cache the result in CU. */
14918 check_producer (struct dwarf2_cu
*cu
)
14922 if (cu
->producer
== NULL
)
14924 /* For unknown compilers expect their behavior is DWARF version
14927 GCC started to support .debug_types sections by -gdwarf-4 since
14928 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14929 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14930 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14931 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14933 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14935 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14936 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14938 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14940 cu
->producer_is_icc
= true;
14941 cu
->producer_is_icc_lt_14
= major
< 14;
14943 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14944 cu
->producer_is_codewarrior
= true;
14947 /* For other non-GCC compilers, expect their behavior is DWARF version
14951 cu
->checked_producer
= true;
14954 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14955 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14956 during 4.6.0 experimental. */
14959 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14961 if (!cu
->checked_producer
)
14962 check_producer (cu
);
14964 return cu
->producer_is_gxx_lt_4_6
;
14968 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14969 with incorrect is_stmt attributes. */
14972 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14974 if (!cu
->checked_producer
)
14975 check_producer (cu
);
14977 return cu
->producer_is_codewarrior
;
14980 /* Return the default accessibility type if it is not overridden by
14981 DW_AT_accessibility. */
14983 static enum dwarf_access_attribute
14984 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14986 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14988 /* The default DWARF 2 accessibility for members is public, the default
14989 accessibility for inheritance is private. */
14991 if (die
->tag
!= DW_TAG_inheritance
)
14992 return DW_ACCESS_public
;
14994 return DW_ACCESS_private
;
14998 /* DWARF 3+ defines the default accessibility a different way. The same
14999 rules apply now for DW_TAG_inheritance as for the members and it only
15000 depends on the container kind. */
15002 if (die
->parent
->tag
== DW_TAG_class_type
)
15003 return DW_ACCESS_private
;
15005 return DW_ACCESS_public
;
15009 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
15010 offset. If the attribute was not found return 0, otherwise return
15011 1. If it was found but could not properly be handled, set *OFFSET
15015 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
15018 struct attribute
*attr
;
15020 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
15025 /* Note that we do not check for a section offset first here.
15026 This is because DW_AT_data_member_location is new in DWARF 4,
15027 so if we see it, we can assume that a constant form is really
15028 a constant and not a section offset. */
15029 if (attr_form_is_constant (attr
))
15030 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
15031 else if (attr_form_is_section_offset (attr
))
15032 dwarf2_complex_location_expr_complaint ();
15033 else if (attr_form_is_block (attr
))
15034 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
15036 dwarf2_complex_location_expr_complaint ();
15044 /* Add an aggregate field to the field list. */
15047 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
15048 struct dwarf2_cu
*cu
)
15050 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15051 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15052 struct nextfield
*new_field
;
15053 struct attribute
*attr
;
15055 const char *fieldname
= "";
15057 if (die
->tag
== DW_TAG_inheritance
)
15059 fip
->baseclasses
.emplace_back ();
15060 new_field
= &fip
->baseclasses
.back ();
15064 fip
->fields
.emplace_back ();
15065 new_field
= &fip
->fields
.back ();
15070 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15071 if (attr
!= nullptr)
15072 new_field
->accessibility
= DW_UNSND (attr
);
15074 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
15075 if (new_field
->accessibility
!= DW_ACCESS_public
)
15076 fip
->non_public_fields
= 1;
15078 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15079 if (attr
!= nullptr)
15080 new_field
->virtuality
= DW_UNSND (attr
);
15082 new_field
->virtuality
= DW_VIRTUALITY_none
;
15084 fp
= &new_field
->field
;
15086 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
15090 /* Data member other than a C++ static data member. */
15092 /* Get type of field. */
15093 fp
->type
= die_type (die
, cu
);
15095 SET_FIELD_BITPOS (*fp
, 0);
15097 /* Get bit size of field (zero if none). */
15098 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
15099 if (attr
!= nullptr)
15101 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
15105 FIELD_BITSIZE (*fp
) = 0;
15108 /* Get bit offset of field. */
15109 if (handle_data_member_location (die
, cu
, &offset
))
15110 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
15111 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
15112 if (attr
!= nullptr)
15114 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
15116 /* For big endian bits, the DW_AT_bit_offset gives the
15117 additional bit offset from the MSB of the containing
15118 anonymous object to the MSB of the field. We don't
15119 have to do anything special since we don't need to
15120 know the size of the anonymous object. */
15121 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
15125 /* For little endian bits, compute the bit offset to the
15126 MSB of the anonymous object, subtract off the number of
15127 bits from the MSB of the field to the MSB of the
15128 object, and then subtract off the number of bits of
15129 the field itself. The result is the bit offset of
15130 the LSB of the field. */
15131 int anonymous_size
;
15132 int bit_offset
= DW_UNSND (attr
);
15134 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15135 if (attr
!= nullptr)
15137 /* The size of the anonymous object containing
15138 the bit field is explicit, so use the
15139 indicated size (in bytes). */
15140 anonymous_size
= DW_UNSND (attr
);
15144 /* The size of the anonymous object containing
15145 the bit field must be inferred from the type
15146 attribute of the data member containing the
15148 anonymous_size
= TYPE_LENGTH (fp
->type
);
15150 SET_FIELD_BITPOS (*fp
,
15151 (FIELD_BITPOS (*fp
)
15152 + anonymous_size
* bits_per_byte
15153 - bit_offset
- FIELD_BITSIZE (*fp
)));
15156 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
15158 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15159 + dwarf2_get_attr_constant_value (attr
, 0)));
15161 /* Get name of field. */
15162 fieldname
= dwarf2_name (die
, cu
);
15163 if (fieldname
== NULL
)
15166 /* The name is already allocated along with this objfile, so we don't
15167 need to duplicate it for the type. */
15168 fp
->name
= fieldname
;
15170 /* Change accessibility for artificial fields (e.g. virtual table
15171 pointer or virtual base class pointer) to private. */
15172 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
15174 FIELD_ARTIFICIAL (*fp
) = 1;
15175 new_field
->accessibility
= DW_ACCESS_private
;
15176 fip
->non_public_fields
= 1;
15179 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
15181 /* C++ static member. */
15183 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15184 is a declaration, but all versions of G++ as of this writing
15185 (so through at least 3.2.1) incorrectly generate
15186 DW_TAG_variable tags. */
15188 const char *physname
;
15190 /* Get name of field. */
15191 fieldname
= dwarf2_name (die
, cu
);
15192 if (fieldname
== NULL
)
15195 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15197 /* Only create a symbol if this is an external value.
15198 new_symbol checks this and puts the value in the global symbol
15199 table, which we want. If it is not external, new_symbol
15200 will try to put the value in cu->list_in_scope which is wrong. */
15201 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
15203 /* A static const member, not much different than an enum as far as
15204 we're concerned, except that we can support more types. */
15205 new_symbol (die
, NULL
, cu
);
15208 /* Get physical name. */
15209 physname
= dwarf2_physname (fieldname
, die
, cu
);
15211 /* The name is already allocated along with this objfile, so we don't
15212 need to duplicate it for the type. */
15213 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
15214 FIELD_TYPE (*fp
) = die_type (die
, cu
);
15215 FIELD_NAME (*fp
) = fieldname
;
15217 else if (die
->tag
== DW_TAG_inheritance
)
15221 /* C++ base class field. */
15222 if (handle_data_member_location (die
, cu
, &offset
))
15223 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
15224 FIELD_BITSIZE (*fp
) = 0;
15225 FIELD_TYPE (*fp
) = die_type (die
, cu
);
15226 FIELD_NAME (*fp
) = TYPE_NAME (fp
->type
);
15228 else if (die
->tag
== DW_TAG_variant_part
)
15230 /* process_structure_scope will treat this DIE as a union. */
15231 process_structure_scope (die
, cu
);
15233 /* The variant part is relative to the start of the enclosing
15235 SET_FIELD_BITPOS (*fp
, 0);
15236 fp
->type
= get_die_type (die
, cu
);
15237 fp
->artificial
= 1;
15238 fp
->name
= "<<variant>>";
15240 /* Normally a DW_TAG_variant_part won't have a size, but our
15241 representation requires one, so set it to the maximum of the
15242 child sizes, being sure to account for the offset at which
15243 each child is seen. */
15244 if (TYPE_LENGTH (fp
->type
) == 0)
15247 for (int i
= 0; i
< TYPE_NFIELDS (fp
->type
); ++i
)
15249 unsigned len
= ((TYPE_FIELD_BITPOS (fp
->type
, i
) + 7) / 8
15250 + TYPE_LENGTH (TYPE_FIELD_TYPE (fp
->type
, i
)));
15254 TYPE_LENGTH (fp
->type
) = max
;
15258 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15261 /* Can the type given by DIE define another type? */
15264 type_can_define_types (const struct die_info
*die
)
15268 case DW_TAG_typedef
:
15269 case DW_TAG_class_type
:
15270 case DW_TAG_structure_type
:
15271 case DW_TAG_union_type
:
15272 case DW_TAG_enumeration_type
:
15280 /* Add a type definition defined in the scope of the FIP's class. */
15283 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
15284 struct dwarf2_cu
*cu
)
15286 struct decl_field fp
;
15287 memset (&fp
, 0, sizeof (fp
));
15289 gdb_assert (type_can_define_types (die
));
15291 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15292 fp
.name
= dwarf2_name (die
, cu
);
15293 fp
.type
= read_type_die (die
, cu
);
15295 /* Save accessibility. */
15296 enum dwarf_access_attribute accessibility
;
15297 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15299 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
15301 accessibility
= dwarf2_default_access_attribute (die
, cu
);
15302 switch (accessibility
)
15304 case DW_ACCESS_public
:
15305 /* The assumed value if neither private nor protected. */
15307 case DW_ACCESS_private
:
15310 case DW_ACCESS_protected
:
15311 fp
.is_protected
= 1;
15314 complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility
);
15317 if (die
->tag
== DW_TAG_typedef
)
15318 fip
->typedef_field_list
.push_back (fp
);
15320 fip
->nested_types_list
.push_back (fp
);
15323 /* Create the vector of fields, and attach it to the type. */
15326 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
15327 struct dwarf2_cu
*cu
)
15329 int nfields
= fip
->nfields
;
15331 /* Record the field count, allocate space for the array of fields,
15332 and create blank accessibility bitfields if necessary. */
15333 TYPE_NFIELDS (type
) = nfields
;
15334 TYPE_FIELDS (type
) = (struct field
*)
15335 TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
);
15337 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
15339 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15341 TYPE_FIELD_PRIVATE_BITS (type
) =
15342 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15343 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
15345 TYPE_FIELD_PROTECTED_BITS (type
) =
15346 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15347 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
15349 TYPE_FIELD_IGNORE_BITS (type
) =
15350 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15351 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
15354 /* If the type has baseclasses, allocate and clear a bit vector for
15355 TYPE_FIELD_VIRTUAL_BITS. */
15356 if (!fip
->baseclasses
.empty () && cu
->language
!= language_ada
)
15358 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
15359 unsigned char *pointer
;
15361 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15362 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
15363 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
15364 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
15365 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
15368 if (TYPE_FLAG_DISCRIMINATED_UNION (type
))
15370 struct discriminant_info
*di
= alloc_discriminant_info (type
, -1, -1);
15372 for (int index
= 0; index
< nfields
; ++index
)
15374 struct nextfield
&field
= fip
->fields
[index
];
15376 if (field
.variant
.is_discriminant
)
15377 di
->discriminant_index
= index
;
15378 else if (field
.variant
.default_branch
)
15379 di
->default_index
= index
;
15381 di
->discriminants
[index
] = field
.variant
.discriminant_value
;
15385 /* Copy the saved-up fields into the field vector. */
15386 for (int i
= 0; i
< nfields
; ++i
)
15388 struct nextfield
&field
15389 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
15390 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
15392 TYPE_FIELD (type
, i
) = field
.field
;
15393 switch (field
.accessibility
)
15395 case DW_ACCESS_private
:
15396 if (cu
->language
!= language_ada
)
15397 SET_TYPE_FIELD_PRIVATE (type
, i
);
15400 case DW_ACCESS_protected
:
15401 if (cu
->language
!= language_ada
)
15402 SET_TYPE_FIELD_PROTECTED (type
, i
);
15405 case DW_ACCESS_public
:
15409 /* Unknown accessibility. Complain and treat it as public. */
15411 complaint (_("unsupported accessibility %d"),
15412 field
.accessibility
);
15416 if (i
< fip
->baseclasses
.size ())
15418 switch (field
.virtuality
)
15420 case DW_VIRTUALITY_virtual
:
15421 case DW_VIRTUALITY_pure_virtual
:
15422 if (cu
->language
== language_ada
)
15423 error (_("unexpected virtuality in component of Ada type"));
15424 SET_TYPE_FIELD_VIRTUAL (type
, i
);
15431 /* Return true if this member function is a constructor, false
15435 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15437 const char *fieldname
;
15438 const char *type_name
;
15441 if (die
->parent
== NULL
)
15444 if (die
->parent
->tag
!= DW_TAG_structure_type
15445 && die
->parent
->tag
!= DW_TAG_union_type
15446 && die
->parent
->tag
!= DW_TAG_class_type
)
15449 fieldname
= dwarf2_name (die
, cu
);
15450 type_name
= dwarf2_name (die
->parent
, cu
);
15451 if (fieldname
== NULL
|| type_name
== NULL
)
15454 len
= strlen (fieldname
);
15455 return (strncmp (fieldname
, type_name
, len
) == 0
15456 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15459 /* Check if the given VALUE is a recognized enum
15460 dwarf_defaulted_attribute constant according to DWARF5 spec,
15464 is_valid_DW_AT_defaulted (ULONGEST value
)
15468 case DW_DEFAULTED_no
:
15469 case DW_DEFAULTED_in_class
:
15470 case DW_DEFAULTED_out_of_class
:
15474 complaint (_("unrecognized DW_AT_defaulted value (%s)"), pulongest (value
));
15478 /* Add a member function to the proper fieldlist. */
15481 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15482 struct type
*type
, struct dwarf2_cu
*cu
)
15484 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15485 struct attribute
*attr
;
15487 struct fnfieldlist
*flp
= nullptr;
15488 struct fn_field
*fnp
;
15489 const char *fieldname
;
15490 struct type
*this_type
;
15491 enum dwarf_access_attribute accessibility
;
15493 if (cu
->language
== language_ada
)
15494 error (_("unexpected member function in Ada type"));
15496 /* Get name of member function. */
15497 fieldname
= dwarf2_name (die
, cu
);
15498 if (fieldname
== NULL
)
15501 /* Look up member function name in fieldlist. */
15502 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15504 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15506 flp
= &fip
->fnfieldlists
[i
];
15511 /* Create a new fnfieldlist if necessary. */
15512 if (flp
== nullptr)
15514 fip
->fnfieldlists
.emplace_back ();
15515 flp
= &fip
->fnfieldlists
.back ();
15516 flp
->name
= fieldname
;
15517 i
= fip
->fnfieldlists
.size () - 1;
15520 /* Create a new member function field and add it to the vector of
15522 flp
->fnfields
.emplace_back ();
15523 fnp
= &flp
->fnfields
.back ();
15525 /* Delay processing of the physname until later. */
15526 if (cu
->language
== language_cplus
)
15527 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15531 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15532 fnp
->physname
= physname
? physname
: "";
15535 fnp
->type
= alloc_type (objfile
);
15536 this_type
= read_type_die (die
, cu
);
15537 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
15539 int nparams
= TYPE_NFIELDS (this_type
);
15541 /* TYPE is the domain of this method, and THIS_TYPE is the type
15542 of the method itself (TYPE_CODE_METHOD). */
15543 smash_to_method_type (fnp
->type
, type
,
15544 TYPE_TARGET_TYPE (this_type
),
15545 TYPE_FIELDS (this_type
),
15546 TYPE_NFIELDS (this_type
),
15547 TYPE_VARARGS (this_type
));
15549 /* Handle static member functions.
15550 Dwarf2 has no clean way to discern C++ static and non-static
15551 member functions. G++ helps GDB by marking the first
15552 parameter for non-static member functions (which is the this
15553 pointer) as artificial. We obtain this information from
15554 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15555 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15556 fnp
->voffset
= VOFFSET_STATIC
;
15559 complaint (_("member function type missing for '%s'"),
15560 dwarf2_full_name (fieldname
, die
, cu
));
15562 /* Get fcontext from DW_AT_containing_type if present. */
15563 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15564 fnp
->fcontext
= die_containing_type (die
, cu
);
15566 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15567 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15569 /* Get accessibility. */
15570 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15571 if (attr
!= nullptr)
15572 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
15574 accessibility
= dwarf2_default_access_attribute (die
, cu
);
15575 switch (accessibility
)
15577 case DW_ACCESS_private
:
15578 fnp
->is_private
= 1;
15580 case DW_ACCESS_protected
:
15581 fnp
->is_protected
= 1;
15585 /* Check for artificial methods. */
15586 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15587 if (attr
&& DW_UNSND (attr
) != 0)
15588 fnp
->is_artificial
= 1;
15590 /* Check for defaulted methods. */
15591 attr
= dwarf2_attr (die
, DW_AT_defaulted
, cu
);
15592 if (attr
!= nullptr && is_valid_DW_AT_defaulted (DW_UNSND (attr
)))
15593 fnp
->defaulted
= (enum dwarf_defaulted_attribute
) DW_UNSND (attr
);
15595 /* Check for deleted methods. */
15596 attr
= dwarf2_attr (die
, DW_AT_deleted
, cu
);
15597 if (attr
!= nullptr && DW_UNSND (attr
) != 0)
15598 fnp
->is_deleted
= 1;
15600 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15602 /* Get index in virtual function table if it is a virtual member
15603 function. For older versions of GCC, this is an offset in the
15604 appropriate virtual table, as specified by DW_AT_containing_type.
15605 For everyone else, it is an expression to be evaluated relative
15606 to the object address. */
15608 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15609 if (attr
!= nullptr)
15611 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
15613 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
15615 /* Old-style GCC. */
15616 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
15618 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
15619 || (DW_BLOCK (attr
)->size
> 1
15620 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
15621 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
15623 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
15624 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15625 dwarf2_complex_location_expr_complaint ();
15627 fnp
->voffset
/= cu
->header
.addr_size
;
15631 dwarf2_complex_location_expr_complaint ();
15633 if (!fnp
->fcontext
)
15635 /* If there is no `this' field and no DW_AT_containing_type,
15636 we cannot actually find a base class context for the
15638 if (TYPE_NFIELDS (this_type
) == 0
15639 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15641 complaint (_("cannot determine context for virtual member "
15642 "function \"%s\" (offset %s)"),
15643 fieldname
, sect_offset_str (die
->sect_off
));
15648 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
15652 else if (attr_form_is_section_offset (attr
))
15654 dwarf2_complex_location_expr_complaint ();
15658 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15664 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15665 if (attr
&& DW_UNSND (attr
))
15667 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15668 complaint (_("Member function \"%s\" (offset %s) is virtual "
15669 "but the vtable offset is not specified"),
15670 fieldname
, sect_offset_str (die
->sect_off
));
15671 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15672 TYPE_CPLUS_DYNAMIC (type
) = 1;
15677 /* Create the vector of member function fields, and attach it to the type. */
15680 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15681 struct dwarf2_cu
*cu
)
15683 if (cu
->language
== language_ada
)
15684 error (_("unexpected member functions in Ada type"));
15686 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15687 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15689 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15691 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15693 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15694 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15696 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15697 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15698 fn_flp
->fn_fields
= (struct fn_field
*)
15699 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15701 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15702 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15705 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15708 /* Returns non-zero if NAME is the name of a vtable member in CU's
15709 language, zero otherwise. */
15711 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15713 static const char vptr
[] = "_vptr";
15715 /* Look for the C++ form of the vtable. */
15716 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15722 /* GCC outputs unnamed structures that are really pointers to member
15723 functions, with the ABI-specified layout. If TYPE describes
15724 such a structure, smash it into a member function type.
15726 GCC shouldn't do this; it should just output pointer to member DIEs.
15727 This is GCC PR debug/28767. */
15730 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15732 struct type
*pfn_type
, *self_type
, *new_type
;
15734 /* Check for a structure with no name and two children. */
15735 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
15738 /* Check for __pfn and __delta members. */
15739 if (TYPE_FIELD_NAME (type
, 0) == NULL
15740 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15741 || TYPE_FIELD_NAME (type
, 1) == NULL
15742 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15745 /* Find the type of the method. */
15746 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
15747 if (pfn_type
== NULL
15748 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
15749 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
15752 /* Look for the "this" argument. */
15753 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15754 if (TYPE_NFIELDS (pfn_type
) == 0
15755 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15756 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
15759 self_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
15760 new_type
= alloc_type (objfile
);
15761 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15762 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
15763 TYPE_VARARGS (pfn_type
));
15764 smash_to_methodptr_type (type
, new_type
);
15767 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15768 appropriate error checking and issuing complaints if there is a
15772 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
15774 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
15776 if (attr
== nullptr)
15779 if (!attr_form_is_constant (attr
))
15781 complaint (_("DW_AT_alignment must have constant form"
15782 " - DIE at %s [in module %s]"),
15783 sect_offset_str (die
->sect_off
),
15784 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15789 if (attr
->form
== DW_FORM_sdata
)
15791 LONGEST val
= DW_SND (attr
);
15794 complaint (_("DW_AT_alignment value must not be negative"
15795 " - DIE at %s [in module %s]"),
15796 sect_offset_str (die
->sect_off
),
15797 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15803 align
= DW_UNSND (attr
);
15807 complaint (_("DW_AT_alignment value must not be zero"
15808 " - DIE at %s [in module %s]"),
15809 sect_offset_str (die
->sect_off
),
15810 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15813 if ((align
& (align
- 1)) != 0)
15815 complaint (_("DW_AT_alignment value must be a power of 2"
15816 " - DIE at %s [in module %s]"),
15817 sect_offset_str (die
->sect_off
),
15818 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15825 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15826 the alignment for TYPE. */
15829 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
15832 if (!set_type_align (type
, get_alignment (cu
, die
)))
15833 complaint (_("DW_AT_alignment value too large"
15834 " - DIE at %s [in module %s]"),
15835 sect_offset_str (die
->sect_off
),
15836 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15839 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15840 constant for a type, according to DWARF5 spec, Table 5.5. */
15843 is_valid_DW_AT_calling_convention_for_type (ULONGEST value
)
15848 case DW_CC_pass_by_reference
:
15849 case DW_CC_pass_by_value
:
15853 complaint (_("unrecognized DW_AT_calling_convention value "
15854 "(%s) for a type"), pulongest (value
));
15859 /* Check if the given VALUE is a valid enum dwarf_calling_convention
15860 constant for a subroutine, according to DWARF5 spec, Table 3.3, and
15861 also according to GNU-specific values (see include/dwarf2.h). */
15864 is_valid_DW_AT_calling_convention_for_subroutine (ULONGEST value
)
15869 case DW_CC_program
:
15873 case DW_CC_GNU_renesas_sh
:
15874 case DW_CC_GNU_borland_fastcall_i386
:
15875 case DW_CC_GDB_IBM_OpenCL
:
15879 complaint (_("unrecognized DW_AT_calling_convention value "
15880 "(%s) for a subroutine"), pulongest (value
));
15885 /* Called when we find the DIE that starts a structure or union scope
15886 (definition) to create a type for the structure or union. Fill in
15887 the type's name and general properties; the members will not be
15888 processed until process_structure_scope. A symbol table entry for
15889 the type will also not be done until process_structure_scope (assuming
15890 the type has a name).
15892 NOTE: we need to call these functions regardless of whether or not the
15893 DIE has a DW_AT_name attribute, since it might be an anonymous
15894 structure or union. This gets the type entered into our set of
15895 user defined types. */
15897 static struct type
*
15898 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15900 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15902 struct attribute
*attr
;
15905 /* If the definition of this type lives in .debug_types, read that type.
15906 Don't follow DW_AT_specification though, that will take us back up
15907 the chain and we want to go down. */
15908 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
15909 if (attr
!= nullptr)
15911 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15913 /* The type's CU may not be the same as CU.
15914 Ensure TYPE is recorded with CU in die_type_hash. */
15915 return set_die_type (die
, type
, cu
);
15918 type
= alloc_type (objfile
);
15919 INIT_CPLUS_SPECIFIC (type
);
15921 name
= dwarf2_name (die
, cu
);
15924 if (cu
->language
== language_cplus
15925 || cu
->language
== language_d
15926 || cu
->language
== language_rust
)
15928 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
15930 /* dwarf2_full_name might have already finished building the DIE's
15931 type. If so, there is no need to continue. */
15932 if (get_die_type (die
, cu
) != NULL
)
15933 return get_die_type (die
, cu
);
15935 TYPE_NAME (type
) = full_name
;
15939 /* The name is already allocated along with this objfile, so
15940 we don't need to duplicate it for the type. */
15941 TYPE_NAME (type
) = name
;
15945 if (die
->tag
== DW_TAG_structure_type
)
15947 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15949 else if (die
->tag
== DW_TAG_union_type
)
15951 TYPE_CODE (type
) = TYPE_CODE_UNION
;
15953 else if (die
->tag
== DW_TAG_variant_part
)
15955 TYPE_CODE (type
) = TYPE_CODE_UNION
;
15956 TYPE_FLAG_DISCRIMINATED_UNION (type
) = 1;
15960 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15963 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
15964 TYPE_DECLARED_CLASS (type
) = 1;
15966 /* Store the calling convention in the type if it's available in
15967 the die. Otherwise the calling convention remains set to
15968 the default value DW_CC_normal. */
15969 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
15970 if (attr
!= nullptr
15971 && is_valid_DW_AT_calling_convention_for_type (DW_UNSND (attr
)))
15973 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15974 TYPE_CPLUS_CALLING_CONVENTION (type
)
15975 = (enum dwarf_calling_convention
) (DW_UNSND (attr
));
15978 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15979 if (attr
!= nullptr)
15981 if (attr_form_is_constant (attr
))
15982 TYPE_LENGTH (type
) = DW_UNSND (attr
);
15985 /* For the moment, dynamic type sizes are not supported
15986 by GDB's struct type. The actual size is determined
15987 on-demand when resolving the type of a given object,
15988 so set the type's length to zero for now. Otherwise,
15989 we record an expression as the length, and that expression
15990 could lead to a very large value, which could eventually
15991 lead to us trying to allocate that much memory when creating
15992 a value of that type. */
15993 TYPE_LENGTH (type
) = 0;
15998 TYPE_LENGTH (type
) = 0;
16001 maybe_set_alignment (cu
, die
, type
);
16003 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
16005 /* ICC<14 does not output the required DW_AT_declaration on
16006 incomplete types, but gives them a size of zero. */
16007 TYPE_STUB (type
) = 1;
16010 TYPE_STUB_SUPPORTED (type
) = 1;
16012 if (die_is_declaration (die
, cu
))
16013 TYPE_STUB (type
) = 1;
16014 else if (attr
== NULL
&& die
->child
== NULL
16015 && producer_is_realview (cu
->producer
))
16016 /* RealView does not output the required DW_AT_declaration
16017 on incomplete types. */
16018 TYPE_STUB (type
) = 1;
16020 /* We need to add the type field to the die immediately so we don't
16021 infinitely recurse when dealing with pointers to the structure
16022 type within the structure itself. */
16023 set_die_type (die
, type
, cu
);
16025 /* set_die_type should be already done. */
16026 set_descriptive_type (type
, die
, cu
);
16031 /* A helper for process_structure_scope that handles a single member
16035 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
16036 struct field_info
*fi
,
16037 std::vector
<struct symbol
*> *template_args
,
16038 struct dwarf2_cu
*cu
)
16040 if (child_die
->tag
== DW_TAG_member
16041 || child_die
->tag
== DW_TAG_variable
16042 || child_die
->tag
== DW_TAG_variant_part
)
16044 /* NOTE: carlton/2002-11-05: A C++ static data member
16045 should be a DW_TAG_member that is a declaration, but
16046 all versions of G++ as of this writing (so through at
16047 least 3.2.1) incorrectly generate DW_TAG_variable
16048 tags for them instead. */
16049 dwarf2_add_field (fi
, child_die
, cu
);
16051 else if (child_die
->tag
== DW_TAG_subprogram
)
16053 /* Rust doesn't have member functions in the C++ sense.
16054 However, it does emit ordinary functions as children
16055 of a struct DIE. */
16056 if (cu
->language
== language_rust
)
16057 read_func_scope (child_die
, cu
);
16060 /* C++ member function. */
16061 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
16064 else if (child_die
->tag
== DW_TAG_inheritance
)
16066 /* C++ base class field. */
16067 dwarf2_add_field (fi
, child_die
, cu
);
16069 else if (type_can_define_types (child_die
))
16070 dwarf2_add_type_defn (fi
, child_die
, cu
);
16071 else if (child_die
->tag
== DW_TAG_template_type_param
16072 || child_die
->tag
== DW_TAG_template_value_param
)
16074 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
16077 template_args
->push_back (arg
);
16079 else if (child_die
->tag
== DW_TAG_variant
)
16081 /* In a variant we want to get the discriminant and also add a
16082 field for our sole member child. */
16083 struct attribute
*discr
= dwarf2_attr (child_die
, DW_AT_discr_value
, cu
);
16085 for (die_info
*variant_child
= child_die
->child
;
16086 variant_child
!= NULL
;
16087 variant_child
= sibling_die (variant_child
))
16089 if (variant_child
->tag
== DW_TAG_member
)
16091 handle_struct_member_die (variant_child
, type
, fi
,
16092 template_args
, cu
);
16093 /* Only handle the one. */
16098 /* We don't handle this but we might as well report it if we see
16100 if (dwarf2_attr (child_die
, DW_AT_discr_list
, cu
) != nullptr)
16101 complaint (_("DW_AT_discr_list is not supported yet"
16102 " - DIE at %s [in module %s]"),
16103 sect_offset_str (child_die
->sect_off
),
16104 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
16106 /* The first field was just added, so we can stash the
16107 discriminant there. */
16108 gdb_assert (!fi
->fields
.empty ());
16110 fi
->fields
.back ().variant
.default_branch
= true;
16112 fi
->fields
.back ().variant
.discriminant_value
= DW_UNSND (discr
);
16116 /* Finish creating a structure or union type, including filling in
16117 its members and creating a symbol for it. */
16120 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16122 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16123 struct die_info
*child_die
;
16126 type
= get_die_type (die
, cu
);
16128 type
= read_structure_type (die
, cu
);
16130 /* When reading a DW_TAG_variant_part, we need to notice when we
16131 read the discriminant member, so we can record it later in the
16132 discriminant_info. */
16133 bool is_variant_part
= TYPE_FLAG_DISCRIMINATED_UNION (type
);
16134 sect_offset discr_offset
{};
16135 bool has_template_parameters
= false;
16137 if (is_variant_part
)
16139 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
16142 /* Maybe it's a univariant form, an extension we support.
16143 In this case arrange not to check the offset. */
16144 is_variant_part
= false;
16146 else if (attr_form_is_ref (discr
))
16148 struct dwarf2_cu
*target_cu
= cu
;
16149 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
16151 discr_offset
= target_die
->sect_off
;
16155 complaint (_("DW_AT_discr does not have DIE reference form"
16156 " - DIE at %s [in module %s]"),
16157 sect_offset_str (die
->sect_off
),
16158 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
16159 is_variant_part
= false;
16163 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
16165 struct field_info fi
;
16166 std::vector
<struct symbol
*> template_args
;
16168 child_die
= die
->child
;
16170 while (child_die
&& child_die
->tag
)
16172 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
16174 if (is_variant_part
&& discr_offset
== child_die
->sect_off
)
16175 fi
.fields
.back ().variant
.is_discriminant
= true;
16177 child_die
= sibling_die (child_die
);
16180 /* Attach template arguments to type. */
16181 if (!template_args
.empty ())
16183 has_template_parameters
= true;
16184 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16185 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
16186 TYPE_TEMPLATE_ARGUMENTS (type
)
16187 = XOBNEWVEC (&objfile
->objfile_obstack
,
16189 TYPE_N_TEMPLATE_ARGUMENTS (type
));
16190 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
16191 template_args
.data (),
16192 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
16193 * sizeof (struct symbol
*)));
16196 /* Attach fields and member functions to the type. */
16198 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
16199 if (!fi
.fnfieldlists
.empty ())
16201 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
16203 /* Get the type which refers to the base class (possibly this
16204 class itself) which contains the vtable pointer for the current
16205 class from the DW_AT_containing_type attribute. This use of
16206 DW_AT_containing_type is a GNU extension. */
16208 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
16210 struct type
*t
= die_containing_type (die
, cu
);
16212 set_type_vptr_basetype (type
, t
);
16217 /* Our own class provides vtbl ptr. */
16218 for (i
= TYPE_NFIELDS (t
) - 1;
16219 i
>= TYPE_N_BASECLASSES (t
);
16222 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
16224 if (is_vtable_name (fieldname
, cu
))
16226 set_type_vptr_fieldno (type
, i
);
16231 /* Complain if virtual function table field not found. */
16232 if (i
< TYPE_N_BASECLASSES (t
))
16233 complaint (_("virtual function table pointer "
16234 "not found when defining class '%s'"),
16235 TYPE_NAME (type
) ? TYPE_NAME (type
) : "");
16239 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
16242 else if (cu
->producer
16243 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
16245 /* The IBM XLC compiler does not provide direct indication
16246 of the containing type, but the vtable pointer is
16247 always named __vfp. */
16251 for (i
= TYPE_NFIELDS (type
) - 1;
16252 i
>= TYPE_N_BASECLASSES (type
);
16255 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
16257 set_type_vptr_fieldno (type
, i
);
16258 set_type_vptr_basetype (type
, type
);
16265 /* Copy fi.typedef_field_list linked list elements content into the
16266 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16267 if (!fi
.typedef_field_list
.empty ())
16269 int count
= fi
.typedef_field_list
.size ();
16271 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16272 TYPE_TYPEDEF_FIELD_ARRAY (type
)
16273 = ((struct decl_field
*)
16275 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
16276 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
16278 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
16279 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
16282 /* Copy fi.nested_types_list linked list elements content into the
16283 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16284 if (!fi
.nested_types_list
.empty () && cu
->language
!= language_ada
)
16286 int count
= fi
.nested_types_list
.size ();
16288 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16289 TYPE_NESTED_TYPES_ARRAY (type
)
16290 = ((struct decl_field
*)
16291 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
16292 TYPE_NESTED_TYPES_COUNT (type
) = count
;
16294 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
16295 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
16299 quirk_gcc_member_function_pointer (type
, objfile
);
16300 if (cu
->language
== language_rust
&& die
->tag
== DW_TAG_union_type
)
16301 cu
->rust_unions
.push_back (type
);
16303 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16304 snapshots) has been known to create a die giving a declaration
16305 for a class that has, as a child, a die giving a definition for a
16306 nested class. So we have to process our children even if the
16307 current die is a declaration. Normally, of course, a declaration
16308 won't have any children at all. */
16310 child_die
= die
->child
;
16312 while (child_die
!= NULL
&& child_die
->tag
)
16314 if (child_die
->tag
== DW_TAG_member
16315 || child_die
->tag
== DW_TAG_variable
16316 || child_die
->tag
== DW_TAG_inheritance
16317 || child_die
->tag
== DW_TAG_template_value_param
16318 || child_die
->tag
== DW_TAG_template_type_param
)
16323 process_die (child_die
, cu
);
16325 child_die
= sibling_die (child_die
);
16328 /* Do not consider external references. According to the DWARF standard,
16329 these DIEs are identified by the fact that they have no byte_size
16330 attribute, and a declaration attribute. */
16331 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16332 || !die_is_declaration (die
, cu
))
16334 struct symbol
*sym
= new_symbol (die
, type
, cu
);
16336 if (has_template_parameters
)
16338 struct symtab
*symtab
;
16339 if (sym
!= nullptr)
16340 symtab
= symbol_symtab (sym
);
16341 else if (cu
->line_header
!= nullptr)
16343 /* Any related symtab will do. */
16345 = cu
->line_header
->file_names ()[0].symtab
;
16350 complaint (_("could not find suitable "
16351 "symtab for template parameter"
16352 " - DIE at %s [in module %s]"),
16353 sect_offset_str (die
->sect_off
),
16354 objfile_name (objfile
));
16357 if (symtab
!= nullptr)
16359 /* Make sure that the symtab is set on the new symbols.
16360 Even though they don't appear in this symtab directly,
16361 other parts of gdb assume that symbols do, and this is
16362 reasonably true. */
16363 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
16364 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
16370 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16371 update TYPE using some information only available in DIE's children. */
16374 update_enumeration_type_from_children (struct die_info
*die
,
16376 struct dwarf2_cu
*cu
)
16378 struct die_info
*child_die
;
16379 int unsigned_enum
= 1;
16383 auto_obstack obstack
;
16385 for (child_die
= die
->child
;
16386 child_die
!= NULL
&& child_die
->tag
;
16387 child_die
= sibling_die (child_die
))
16389 struct attribute
*attr
;
16391 const gdb_byte
*bytes
;
16392 struct dwarf2_locexpr_baton
*baton
;
16395 if (child_die
->tag
!= DW_TAG_enumerator
)
16398 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16402 name
= dwarf2_name (child_die
, cu
);
16404 name
= "<anonymous enumerator>";
16406 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16407 &value
, &bytes
, &baton
);
16413 else if ((mask
& value
) != 0)
16418 /* If we already know that the enum type is neither unsigned, nor
16419 a flag type, no need to look at the rest of the enumerates. */
16420 if (!unsigned_enum
&& !flag_enum
)
16425 TYPE_UNSIGNED (type
) = 1;
16427 TYPE_FLAG_ENUM (type
) = 1;
16430 /* Given a DW_AT_enumeration_type die, set its type. We do not
16431 complete the type's fields yet, or create any symbols. */
16433 static struct type
*
16434 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16436 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16438 struct attribute
*attr
;
16441 /* If the definition of this type lives in .debug_types, read that type.
16442 Don't follow DW_AT_specification though, that will take us back up
16443 the chain and we want to go down. */
16444 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
16445 if (attr
!= nullptr)
16447 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16449 /* The type's CU may not be the same as CU.
16450 Ensure TYPE is recorded with CU in die_type_hash. */
16451 return set_die_type (die
, type
, cu
);
16454 type
= alloc_type (objfile
);
16456 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
16457 name
= dwarf2_full_name (NULL
, die
, cu
);
16459 TYPE_NAME (type
) = name
;
16461 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16464 struct type
*underlying_type
= die_type (die
, cu
);
16466 TYPE_TARGET_TYPE (type
) = underlying_type
;
16469 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16470 if (attr
!= nullptr)
16472 TYPE_LENGTH (type
) = DW_UNSND (attr
);
16476 TYPE_LENGTH (type
) = 0;
16479 maybe_set_alignment (cu
, die
, type
);
16481 /* The enumeration DIE can be incomplete. In Ada, any type can be
16482 declared as private in the package spec, and then defined only
16483 inside the package body. Such types are known as Taft Amendment
16484 Types. When another package uses such a type, an incomplete DIE
16485 may be generated by the compiler. */
16486 if (die_is_declaration (die
, cu
))
16487 TYPE_STUB (type
) = 1;
16489 /* Finish the creation of this type by using the enum's children.
16490 We must call this even when the underlying type has been provided
16491 so that we can determine if we're looking at a "flag" enum. */
16492 update_enumeration_type_from_children (die
, type
, cu
);
16494 /* If this type has an underlying type that is not a stub, then we
16495 may use its attributes. We always use the "unsigned" attribute
16496 in this situation, because ordinarily we guess whether the type
16497 is unsigned -- but the guess can be wrong and the underlying type
16498 can tell us the reality. However, we defer to a local size
16499 attribute if one exists, because this lets the compiler override
16500 the underlying type if needed. */
16501 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_STUB (TYPE_TARGET_TYPE (type
)))
16503 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
));
16504 if (TYPE_LENGTH (type
) == 0)
16505 TYPE_LENGTH (type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
16506 if (TYPE_RAW_ALIGN (type
) == 0
16507 && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type
)) != 0)
16508 set_type_align (type
, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type
)));
16511 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
16513 return set_die_type (die
, type
, cu
);
16516 /* Given a pointer to a die which begins an enumeration, process all
16517 the dies that define the members of the enumeration, and create the
16518 symbol for the enumeration type.
16520 NOTE: We reverse the order of the element list. */
16523 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16525 struct type
*this_type
;
16527 this_type
= get_die_type (die
, cu
);
16528 if (this_type
== NULL
)
16529 this_type
= read_enumeration_type (die
, cu
);
16531 if (die
->child
!= NULL
)
16533 struct die_info
*child_die
;
16534 struct symbol
*sym
;
16535 std::vector
<struct field
> fields
;
16538 child_die
= die
->child
;
16539 while (child_die
&& child_die
->tag
)
16541 if (child_die
->tag
!= DW_TAG_enumerator
)
16543 process_die (child_die
, cu
);
16547 name
= dwarf2_name (child_die
, cu
);
16550 sym
= new_symbol (child_die
, this_type
, cu
);
16552 fields
.emplace_back ();
16553 struct field
&field
= fields
.back ();
16555 FIELD_NAME (field
) = sym
->linkage_name ();
16556 FIELD_TYPE (field
) = NULL
;
16557 SET_FIELD_ENUMVAL (field
, SYMBOL_VALUE (sym
));
16558 FIELD_BITSIZE (field
) = 0;
16562 child_die
= sibling_die (child_die
);
16565 if (!fields
.empty ())
16567 TYPE_NFIELDS (this_type
) = fields
.size ();
16568 TYPE_FIELDS (this_type
) = (struct field
*)
16569 TYPE_ALLOC (this_type
, sizeof (struct field
) * fields
.size ());
16570 memcpy (TYPE_FIELDS (this_type
), fields
.data (),
16571 sizeof (struct field
) * fields
.size ());
16575 /* If we are reading an enum from a .debug_types unit, and the enum
16576 is a declaration, and the enum is not the signatured type in the
16577 unit, then we do not want to add a symbol for it. Adding a
16578 symbol would in some cases obscure the true definition of the
16579 enum, giving users an incomplete type when the definition is
16580 actually available. Note that we do not want to do this for all
16581 enums which are just declarations, because C++0x allows forward
16582 enum declarations. */
16583 if (cu
->per_cu
->is_debug_types
16584 && die_is_declaration (die
, cu
))
16586 struct signatured_type
*sig_type
;
16588 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16589 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16590 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16594 new_symbol (die
, this_type
, cu
);
16597 /* Extract all information from a DW_TAG_array_type DIE and put it in
16598 the DIE's type field. For now, this only handles one dimensional
16601 static struct type
*
16602 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16604 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16605 struct die_info
*child_die
;
16607 struct type
*element_type
, *range_type
, *index_type
;
16608 struct attribute
*attr
;
16610 struct dynamic_prop
*byte_stride_prop
= NULL
;
16611 unsigned int bit_stride
= 0;
16613 element_type
= die_type (die
, cu
);
16615 /* The die_type call above may have already set the type for this DIE. */
16616 type
= get_die_type (die
, cu
);
16620 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
16624 struct type
*prop_type
16625 = dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
16628 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
16629 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
16633 complaint (_("unable to read array DW_AT_byte_stride "
16634 " - DIE at %s [in module %s]"),
16635 sect_offset_str (die
->sect_off
),
16636 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
16637 /* Ignore this attribute. We will likely not be able to print
16638 arrays of this type correctly, but there is little we can do
16639 to help if we cannot read the attribute's value. */
16640 byte_stride_prop
= NULL
;
16644 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
16646 bit_stride
= DW_UNSND (attr
);
16648 /* Irix 6.2 native cc creates array types without children for
16649 arrays with unspecified length. */
16650 if (die
->child
== NULL
)
16652 index_type
= objfile_type (objfile
)->builtin_int
;
16653 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
16654 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
16655 byte_stride_prop
, bit_stride
);
16656 return set_die_type (die
, type
, cu
);
16659 std::vector
<struct type
*> range_types
;
16660 child_die
= die
->child
;
16661 while (child_die
&& child_die
->tag
)
16663 if (child_die
->tag
== DW_TAG_subrange_type
)
16665 struct type
*child_type
= read_type_die (child_die
, cu
);
16667 if (child_type
!= NULL
)
16669 /* The range type was succesfully read. Save it for the
16670 array type creation. */
16671 range_types
.push_back (child_type
);
16674 child_die
= sibling_die (child_die
);
16677 /* Dwarf2 dimensions are output from left to right, create the
16678 necessary array types in backwards order. */
16680 type
= element_type
;
16682 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
16686 while (i
< range_types
.size ())
16687 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
16688 byte_stride_prop
, bit_stride
);
16692 size_t ndim
= range_types
.size ();
16694 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
16695 byte_stride_prop
, bit_stride
);
16698 /* Understand Dwarf2 support for vector types (like they occur on
16699 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16700 array type. This is not part of the Dwarf2/3 standard yet, but a
16701 custom vendor extension. The main difference between a regular
16702 array and the vector variant is that vectors are passed by value
16704 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
16705 if (attr
!= nullptr)
16706 make_vector_type (type
);
16708 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16709 implementation may choose to implement triple vectors using this
16711 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16712 if (attr
!= nullptr)
16714 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
16715 TYPE_LENGTH (type
) = DW_UNSND (attr
);
16717 complaint (_("DW_AT_byte_size for array type smaller "
16718 "than the total size of elements"));
16721 name
= dwarf2_name (die
, cu
);
16723 TYPE_NAME (type
) = name
;
16725 maybe_set_alignment (cu
, die
, type
);
16727 /* Install the type in the die. */
16728 set_die_type (die
, type
, cu
);
16730 /* set_die_type should be already done. */
16731 set_descriptive_type (type
, die
, cu
);
16736 static enum dwarf_array_dim_ordering
16737 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
16739 struct attribute
*attr
;
16741 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
16743 if (attr
!= nullptr)
16744 return (enum dwarf_array_dim_ordering
) DW_SND (attr
);
16746 /* GNU F77 is a special case, as at 08/2004 array type info is the
16747 opposite order to the dwarf2 specification, but data is still
16748 laid out as per normal fortran.
16750 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16751 version checking. */
16753 if (cu
->language
== language_fortran
16754 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
16756 return DW_ORD_row_major
;
16759 switch (cu
->language_defn
->la_array_ordering
)
16761 case array_column_major
:
16762 return DW_ORD_col_major
;
16763 case array_row_major
:
16765 return DW_ORD_row_major
;
16769 /* Extract all information from a DW_TAG_set_type DIE and put it in
16770 the DIE's type field. */
16772 static struct type
*
16773 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16775 struct type
*domain_type
, *set_type
;
16776 struct attribute
*attr
;
16778 domain_type
= die_type (die
, cu
);
16780 /* The die_type call above may have already set the type for this DIE. */
16781 set_type
= get_die_type (die
, cu
);
16785 set_type
= create_set_type (NULL
, domain_type
);
16787 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16788 if (attr
!= nullptr)
16789 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
16791 maybe_set_alignment (cu
, die
, set_type
);
16793 return set_die_type (die
, set_type
, cu
);
16796 /* A helper for read_common_block that creates a locexpr baton.
16797 SYM is the symbol which we are marking as computed.
16798 COMMON_DIE is the DIE for the common block.
16799 COMMON_LOC is the location expression attribute for the common
16801 MEMBER_LOC is the location expression attribute for the particular
16802 member of the common block that we are processing.
16803 CU is the CU from which the above come. */
16806 mark_common_block_symbol_computed (struct symbol
*sym
,
16807 struct die_info
*common_die
,
16808 struct attribute
*common_loc
,
16809 struct attribute
*member_loc
,
16810 struct dwarf2_cu
*cu
)
16812 struct dwarf2_per_objfile
*dwarf2_per_objfile
16813 = cu
->per_cu
->dwarf2_per_objfile
;
16814 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16815 struct dwarf2_locexpr_baton
*baton
;
16817 unsigned int cu_off
;
16818 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
16819 LONGEST offset
= 0;
16821 gdb_assert (common_loc
&& member_loc
);
16822 gdb_assert (attr_form_is_block (common_loc
));
16823 gdb_assert (attr_form_is_block (member_loc
)
16824 || attr_form_is_constant (member_loc
));
16826 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
16827 baton
->per_cu
= cu
->per_cu
;
16828 gdb_assert (baton
->per_cu
);
16830 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16832 if (attr_form_is_constant (member_loc
))
16834 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
16835 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
16838 baton
->size
+= DW_BLOCK (member_loc
)->size
;
16840 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
16843 *ptr
++ = DW_OP_call4
;
16844 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
16845 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
16848 if (attr_form_is_constant (member_loc
))
16850 *ptr
++ = DW_OP_addr
;
16851 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
16852 ptr
+= cu
->header
.addr_size
;
16856 /* We have to copy the data here, because DW_OP_call4 will only
16857 use a DW_AT_location attribute. */
16858 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
16859 ptr
+= DW_BLOCK (member_loc
)->size
;
16862 *ptr
++ = DW_OP_plus
;
16863 gdb_assert (ptr
- baton
->data
== baton
->size
);
16865 SYMBOL_LOCATION_BATON (sym
) = baton
;
16866 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
16869 /* Create appropriate locally-scoped variables for all the
16870 DW_TAG_common_block entries. Also create a struct common_block
16871 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16872 is used to separate the common blocks name namespace from regular
16876 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
16878 struct attribute
*attr
;
16880 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16881 if (attr
!= nullptr)
16883 /* Support the .debug_loc offsets. */
16884 if (attr_form_is_block (attr
))
16888 else if (attr_form_is_section_offset (attr
))
16890 dwarf2_complex_location_expr_complaint ();
16895 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16896 "common block member");
16901 if (die
->child
!= NULL
)
16903 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16904 struct die_info
*child_die
;
16905 size_t n_entries
= 0, size
;
16906 struct common_block
*common_block
;
16907 struct symbol
*sym
;
16909 for (child_die
= die
->child
;
16910 child_die
&& child_die
->tag
;
16911 child_die
= sibling_die (child_die
))
16914 size
= (sizeof (struct common_block
)
16915 + (n_entries
- 1) * sizeof (struct symbol
*));
16917 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
16919 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
16920 common_block
->n_entries
= 0;
16922 for (child_die
= die
->child
;
16923 child_die
&& child_die
->tag
;
16924 child_die
= sibling_die (child_die
))
16926 /* Create the symbol in the DW_TAG_common_block block in the current
16928 sym
= new_symbol (child_die
, NULL
, cu
);
16931 struct attribute
*member_loc
;
16933 common_block
->contents
[common_block
->n_entries
++] = sym
;
16935 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
16939 /* GDB has handled this for a long time, but it is
16940 not specified by DWARF. It seems to have been
16941 emitted by gfortran at least as recently as:
16942 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16943 complaint (_("Variable in common block has "
16944 "DW_AT_data_member_location "
16945 "- DIE at %s [in module %s]"),
16946 sect_offset_str (child_die
->sect_off
),
16947 objfile_name (objfile
));
16949 if (attr_form_is_section_offset (member_loc
))
16950 dwarf2_complex_location_expr_complaint ();
16951 else if (attr_form_is_constant (member_loc
)
16952 || attr_form_is_block (member_loc
))
16954 if (attr
!= nullptr)
16955 mark_common_block_symbol_computed (sym
, die
, attr
,
16959 dwarf2_complex_location_expr_complaint ();
16964 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
16965 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
16969 /* Create a type for a C++ namespace. */
16971 static struct type
*
16972 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16974 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16975 const char *previous_prefix
, *name
;
16979 /* For extensions, reuse the type of the original namespace. */
16980 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
16982 struct die_info
*ext_die
;
16983 struct dwarf2_cu
*ext_cu
= cu
;
16985 ext_die
= dwarf2_extension (die
, &ext_cu
);
16986 type
= read_type_die (ext_die
, ext_cu
);
16988 /* EXT_CU may not be the same as CU.
16989 Ensure TYPE is recorded with CU in die_type_hash. */
16990 return set_die_type (die
, type
, cu
);
16993 name
= namespace_name (die
, &is_anonymous
, cu
);
16995 /* Now build the name of the current namespace. */
16997 previous_prefix
= determine_prefix (die
, cu
);
16998 if (previous_prefix
[0] != '\0')
16999 name
= typename_concat (&objfile
->objfile_obstack
,
17000 previous_prefix
, name
, 0, cu
);
17002 /* Create the type. */
17003 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
17005 return set_die_type (die
, type
, cu
);
17008 /* Read a namespace scope. */
17011 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
17013 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17016 /* Add a symbol associated to this if we haven't seen the namespace
17017 before. Also, add a using directive if it's an anonymous
17020 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
17024 type
= read_type_die (die
, cu
);
17025 new_symbol (die
, type
, cu
);
17027 namespace_name (die
, &is_anonymous
, cu
);
17030 const char *previous_prefix
= determine_prefix (die
, cu
);
17032 std::vector
<const char *> excludes
;
17033 add_using_directive (using_directives (cu
),
17034 previous_prefix
, TYPE_NAME (type
), NULL
,
17035 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
17039 if (die
->child
!= NULL
)
17041 struct die_info
*child_die
= die
->child
;
17043 while (child_die
&& child_die
->tag
)
17045 process_die (child_die
, cu
);
17046 child_die
= sibling_die (child_die
);
17051 /* Read a Fortran module as type. This DIE can be only a declaration used for
17052 imported module. Still we need that type as local Fortran "use ... only"
17053 declaration imports depend on the created type in determine_prefix. */
17055 static struct type
*
17056 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17058 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17059 const char *module_name
;
17062 module_name
= dwarf2_name (die
, cu
);
17063 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
17065 return set_die_type (die
, type
, cu
);
17068 /* Read a Fortran module. */
17071 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
17073 struct die_info
*child_die
= die
->child
;
17076 type
= read_type_die (die
, cu
);
17077 new_symbol (die
, type
, cu
);
17079 while (child_die
&& child_die
->tag
)
17081 process_die (child_die
, cu
);
17082 child_die
= sibling_die (child_die
);
17086 /* Return the name of the namespace represented by DIE. Set
17087 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
17090 static const char *
17091 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
17093 struct die_info
*current_die
;
17094 const char *name
= NULL
;
17096 /* Loop through the extensions until we find a name. */
17098 for (current_die
= die
;
17099 current_die
!= NULL
;
17100 current_die
= dwarf2_extension (die
, &cu
))
17102 /* We don't use dwarf2_name here so that we can detect the absence
17103 of a name -> anonymous namespace. */
17104 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
17110 /* Is it an anonymous namespace? */
17112 *is_anonymous
= (name
== NULL
);
17114 name
= CP_ANONYMOUS_NAMESPACE_STR
;
17119 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17120 the user defined type vector. */
17122 static struct type
*
17123 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17125 struct gdbarch
*gdbarch
17126 = get_objfile_arch (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
17127 struct comp_unit_head
*cu_header
= &cu
->header
;
17129 struct attribute
*attr_byte_size
;
17130 struct attribute
*attr_address_class
;
17131 int byte_size
, addr_class
;
17132 struct type
*target_type
;
17134 target_type
= die_type (die
, cu
);
17136 /* The die_type call above may have already set the type for this DIE. */
17137 type
= get_die_type (die
, cu
);
17141 type
= lookup_pointer_type (target_type
);
17143 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17144 if (attr_byte_size
)
17145 byte_size
= DW_UNSND (attr_byte_size
);
17147 byte_size
= cu_header
->addr_size
;
17149 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
17150 if (attr_address_class
)
17151 addr_class
= DW_UNSND (attr_address_class
);
17153 addr_class
= DW_ADDR_none
;
17155 ULONGEST alignment
= get_alignment (cu
, die
);
17157 /* If the pointer size, alignment, or address class is different
17158 than the default, create a type variant marked as such and set
17159 the length accordingly. */
17160 if (TYPE_LENGTH (type
) != byte_size
17161 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
17162 && alignment
!= TYPE_RAW_ALIGN (type
))
17163 || addr_class
!= DW_ADDR_none
)
17165 if (gdbarch_address_class_type_flags_p (gdbarch
))
17169 type_flags
= gdbarch_address_class_type_flags
17170 (gdbarch
, byte_size
, addr_class
);
17171 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17173 type
= make_type_with_address_space (type
, type_flags
);
17175 else if (TYPE_LENGTH (type
) != byte_size
)
17177 complaint (_("invalid pointer size %d"), byte_size
);
17179 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17181 complaint (_("Invalid DW_AT_alignment"
17182 " - DIE at %s [in module %s]"),
17183 sect_offset_str (die
->sect_off
),
17184 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17188 /* Should we also complain about unhandled address classes? */
17192 TYPE_LENGTH (type
) = byte_size
;
17193 set_type_align (type
, alignment
);
17194 return set_die_type (die
, type
, cu
);
17197 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17198 the user defined type vector. */
17200 static struct type
*
17201 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17204 struct type
*to_type
;
17205 struct type
*domain
;
17207 to_type
= die_type (die
, cu
);
17208 domain
= die_containing_type (die
, cu
);
17210 /* The calls above may have already set the type for this DIE. */
17211 type
= get_die_type (die
, cu
);
17215 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
17216 type
= lookup_methodptr_type (to_type
);
17217 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
17219 struct type
*new_type
17220 = alloc_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
17222 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17223 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
17224 TYPE_VARARGS (to_type
));
17225 type
= lookup_methodptr_type (new_type
);
17228 type
= lookup_memberptr_type (to_type
, domain
);
17230 return set_die_type (die
, type
, cu
);
17233 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17234 the user defined type vector. */
17236 static struct type
*
17237 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17238 enum type_code refcode
)
17240 struct comp_unit_head
*cu_header
= &cu
->header
;
17241 struct type
*type
, *target_type
;
17242 struct attribute
*attr
;
17244 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17246 target_type
= die_type (die
, cu
);
17248 /* The die_type call above may have already set the type for this DIE. */
17249 type
= get_die_type (die
, cu
);
17253 type
= lookup_reference_type (target_type
, refcode
);
17254 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17255 if (attr
!= nullptr)
17257 TYPE_LENGTH (type
) = DW_UNSND (attr
);
17261 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17263 maybe_set_alignment (cu
, die
, type
);
17264 return set_die_type (die
, type
, cu
);
17267 /* Add the given cv-qualifiers to the element type of the array. GCC
17268 outputs DWARF type qualifiers that apply to an array, not the
17269 element type. But GDB relies on the array element type to carry
17270 the cv-qualifiers. This mimics section 6.7.3 of the C99
17273 static struct type
*
17274 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17275 struct type
*base_type
, int cnst
, int voltl
)
17277 struct type
*el_type
, *inner_array
;
17279 base_type
= copy_type (base_type
);
17280 inner_array
= base_type
;
17282 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
17284 TYPE_TARGET_TYPE (inner_array
) =
17285 copy_type (TYPE_TARGET_TYPE (inner_array
));
17286 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17289 el_type
= TYPE_TARGET_TYPE (inner_array
);
17290 cnst
|= TYPE_CONST (el_type
);
17291 voltl
|= TYPE_VOLATILE (el_type
);
17292 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17294 return set_die_type (die
, base_type
, cu
);
17297 static struct type
*
17298 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17300 struct type
*base_type
, *cv_type
;
17302 base_type
= die_type (die
, cu
);
17304 /* The die_type call above may have already set the type for this DIE. */
17305 cv_type
= get_die_type (die
, cu
);
17309 /* In case the const qualifier is applied to an array type, the element type
17310 is so qualified, not the array type (section 6.7.3 of C99). */
17311 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
17312 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17314 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17315 return set_die_type (die
, cv_type
, cu
);
17318 static struct type
*
17319 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17321 struct type
*base_type
, *cv_type
;
17323 base_type
= die_type (die
, cu
);
17325 /* The die_type call above may have already set the type for this DIE. */
17326 cv_type
= get_die_type (die
, cu
);
17330 /* In case the volatile qualifier is applied to an array type, the
17331 element type is so qualified, not the array type (section 6.7.3
17333 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
17334 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17336 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17337 return set_die_type (die
, cv_type
, cu
);
17340 /* Handle DW_TAG_restrict_type. */
17342 static struct type
*
17343 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17345 struct type
*base_type
, *cv_type
;
17347 base_type
= die_type (die
, cu
);
17349 /* The die_type call above may have already set the type for this DIE. */
17350 cv_type
= get_die_type (die
, cu
);
17354 cv_type
= make_restrict_type (base_type
);
17355 return set_die_type (die
, cv_type
, cu
);
17358 /* Handle DW_TAG_atomic_type. */
17360 static struct type
*
17361 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17363 struct type
*base_type
, *cv_type
;
17365 base_type
= die_type (die
, cu
);
17367 /* The die_type call above may have already set the type for this DIE. */
17368 cv_type
= get_die_type (die
, cu
);
17372 cv_type
= make_atomic_type (base_type
);
17373 return set_die_type (die
, cv_type
, cu
);
17376 /* Extract all information from a DW_TAG_string_type DIE and add to
17377 the user defined type vector. It isn't really a user defined type,
17378 but it behaves like one, with other DIE's using an AT_user_def_type
17379 attribute to reference it. */
17381 static struct type
*
17382 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17384 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17385 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17386 struct type
*type
, *range_type
, *index_type
, *char_type
;
17387 struct attribute
*attr
;
17388 struct dynamic_prop prop
;
17389 bool length_is_constant
= true;
17392 /* There are a couple of places where bit sizes might be made use of
17393 when parsing a DW_TAG_string_type, however, no producer that we know
17394 of make use of these. Handling bit sizes that are a multiple of the
17395 byte size is easy enough, but what about other bit sizes? Lets deal
17396 with that problem when we have to. Warn about these attributes being
17397 unsupported, then parse the type and ignore them like we always
17399 if (dwarf2_attr (die
, DW_AT_bit_size
, cu
) != nullptr
17400 || dwarf2_attr (die
, DW_AT_string_length_bit_size
, cu
) != nullptr)
17402 static bool warning_printed
= false;
17403 if (!warning_printed
)
17405 warning (_("DW_AT_bit_size and DW_AT_string_length_bit_size not "
17406 "currently supported on DW_TAG_string_type."));
17407 warning_printed
= true;
17411 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17412 if (attr
!= nullptr && !attr_form_is_constant (attr
))
17414 /* The string length describes the location at which the length of
17415 the string can be found. The size of the length field can be
17416 specified with one of the attributes below. */
17417 struct type
*prop_type
;
17418 struct attribute
*len
17419 = dwarf2_attr (die
, DW_AT_string_length_byte_size
, cu
);
17420 if (len
== nullptr)
17421 len
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17422 if (len
!= nullptr && attr_form_is_constant (len
))
17424 /* Pass 0 as the default as we know this attribute is constant
17425 and the default value will not be returned. */
17426 LONGEST sz
= dwarf2_get_attr_constant_value (len
, 0);
17427 prop_type
= dwarf2_per_cu_int_type (cu
->per_cu
, sz
, true);
17431 /* If the size is not specified then we assume it is the size of
17432 an address on this target. */
17433 prop_type
= dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, true);
17436 /* Convert the attribute into a dynamic property. */
17437 if (!attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
17440 length_is_constant
= false;
17442 else if (attr
!= nullptr)
17444 /* This DW_AT_string_length just contains the length with no
17445 indirection. There's no need to create a dynamic property in this
17446 case. Pass 0 for the default value as we know it will not be
17447 returned in this case. */
17448 length
= dwarf2_get_attr_constant_value (attr
, 0);
17450 else if ((attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
)) != nullptr)
17452 /* We don't currently support non-constant byte sizes for strings. */
17453 length
= dwarf2_get_attr_constant_value (attr
, 1);
17457 /* Use 1 as a fallback length if we have nothing else. */
17461 index_type
= objfile_type (objfile
)->builtin_int
;
17462 if (length_is_constant
)
17463 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17466 struct dynamic_prop low_bound
;
17468 low_bound
.kind
= PROP_CONST
;
17469 low_bound
.data
.const_val
= 1;
17470 range_type
= create_range_type (NULL
, index_type
, &low_bound
, &prop
, 0);
17472 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17473 type
= create_string_type (NULL
, char_type
, range_type
);
17475 return set_die_type (die
, type
, cu
);
17478 /* Assuming that DIE corresponds to a function, returns nonzero
17479 if the function is prototyped. */
17482 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17484 struct attribute
*attr
;
17486 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17487 if (attr
&& (DW_UNSND (attr
) != 0))
17490 /* The DWARF standard implies that the DW_AT_prototyped attribute
17491 is only meaningful for C, but the concept also extends to other
17492 languages that allow unprototyped functions (Eg: Objective C).
17493 For all other languages, assume that functions are always
17495 if (cu
->language
!= language_c
17496 && cu
->language
!= language_objc
17497 && cu
->language
!= language_opencl
)
17500 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17501 prototyped and unprototyped functions; default to prototyped,
17502 since that is more common in modern code (and RealView warns
17503 about unprototyped functions). */
17504 if (producer_is_realview (cu
->producer
))
17510 /* Handle DIES due to C code like:
17514 int (*funcp)(int a, long l);
17518 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17520 static struct type
*
17521 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17523 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17524 struct type
*type
; /* Type that this function returns. */
17525 struct type
*ftype
; /* Function that returns above type. */
17526 struct attribute
*attr
;
17528 type
= die_type (die
, cu
);
17530 /* The die_type call above may have already set the type for this DIE. */
17531 ftype
= get_die_type (die
, cu
);
17535 ftype
= lookup_function_type (type
);
17537 if (prototyped_function_p (die
, cu
))
17538 TYPE_PROTOTYPED (ftype
) = 1;
17540 /* Store the calling convention in the type if it's available in
17541 the subroutine die. Otherwise set the calling convention to
17542 the default value DW_CC_normal. */
17543 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
17544 if (attr
!= nullptr
17545 && is_valid_DW_AT_calling_convention_for_subroutine (DW_UNSND (attr
)))
17546 TYPE_CALLING_CONVENTION (ftype
)
17547 = (enum dwarf_calling_convention
) (DW_UNSND (attr
));
17548 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
17549 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
17551 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
17553 /* Record whether the function returns normally to its caller or not
17554 if the DWARF producer set that information. */
17555 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
17556 if (attr
&& (DW_UNSND (attr
) != 0))
17557 TYPE_NO_RETURN (ftype
) = 1;
17559 /* We need to add the subroutine type to the die immediately so
17560 we don't infinitely recurse when dealing with parameters
17561 declared as the same subroutine type. */
17562 set_die_type (die
, ftype
, cu
);
17564 if (die
->child
!= NULL
)
17566 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
17567 struct die_info
*child_die
;
17568 int nparams
, iparams
;
17570 /* Count the number of parameters.
17571 FIXME: GDB currently ignores vararg functions, but knows about
17572 vararg member functions. */
17574 child_die
= die
->child
;
17575 while (child_die
&& child_die
->tag
)
17577 if (child_die
->tag
== DW_TAG_formal_parameter
)
17579 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
17580 TYPE_VARARGS (ftype
) = 1;
17581 child_die
= sibling_die (child_die
);
17584 /* Allocate storage for parameters and fill them in. */
17585 TYPE_NFIELDS (ftype
) = nparams
;
17586 TYPE_FIELDS (ftype
) = (struct field
*)
17587 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
17589 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17590 even if we error out during the parameters reading below. */
17591 for (iparams
= 0; iparams
< nparams
; iparams
++)
17592 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
17595 child_die
= die
->child
;
17596 while (child_die
&& child_die
->tag
)
17598 if (child_die
->tag
== DW_TAG_formal_parameter
)
17600 struct type
*arg_type
;
17602 /* DWARF version 2 has no clean way to discern C++
17603 static and non-static member functions. G++ helps
17604 GDB by marking the first parameter for non-static
17605 member functions (which is the this pointer) as
17606 artificial. We pass this information to
17607 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17609 DWARF version 3 added DW_AT_object_pointer, which GCC
17610 4.5 does not yet generate. */
17611 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
17612 if (attr
!= nullptr)
17613 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
17615 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
17616 arg_type
= die_type (child_die
, cu
);
17618 /* RealView does not mark THIS as const, which the testsuite
17619 expects. GCC marks THIS as const in method definitions,
17620 but not in the class specifications (GCC PR 43053). */
17621 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
17622 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
17625 struct dwarf2_cu
*arg_cu
= cu
;
17626 const char *name
= dwarf2_name (child_die
, cu
);
17628 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
17629 if (attr
!= nullptr)
17631 /* If the compiler emits this, use it. */
17632 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
17635 else if (name
&& strcmp (name
, "this") == 0)
17636 /* Function definitions will have the argument names. */
17638 else if (name
== NULL
&& iparams
== 0)
17639 /* Declarations may not have the names, so like
17640 elsewhere in GDB, assume an artificial first
17641 argument is "this". */
17645 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
17649 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
17652 child_die
= sibling_die (child_die
);
17659 static struct type
*
17660 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
17662 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17663 const char *name
= NULL
;
17664 struct type
*this_type
, *target_type
;
17666 name
= dwarf2_full_name (NULL
, die
, cu
);
17667 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
17668 TYPE_TARGET_STUB (this_type
) = 1;
17669 set_die_type (die
, this_type
, cu
);
17670 target_type
= die_type (die
, cu
);
17671 if (target_type
!= this_type
)
17672 TYPE_TARGET_TYPE (this_type
) = target_type
;
17675 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17676 spec and cause infinite loops in GDB. */
17677 complaint (_("Self-referential DW_TAG_typedef "
17678 "- DIE at %s [in module %s]"),
17679 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
17680 TYPE_TARGET_TYPE (this_type
) = NULL
;
17685 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17686 (which may be different from NAME) to the architecture back-end to allow
17687 it to guess the correct format if necessary. */
17689 static struct type
*
17690 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
17691 const char *name_hint
, enum bfd_endian byte_order
)
17693 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17694 const struct floatformat
**format
;
17697 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
17699 type
= init_float_type (objfile
, bits
, name
, format
, byte_order
);
17701 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17706 /* Allocate an integer type of size BITS and name NAME. */
17708 static struct type
*
17709 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
17710 int bits
, int unsigned_p
, const char *name
)
17714 /* Versions of Intel's C Compiler generate an integer type called "void"
17715 instead of using DW_TAG_unspecified_type. This has been seen on
17716 at least versions 14, 17, and 18. */
17717 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
17718 && strcmp (name
, "void") == 0)
17719 type
= objfile_type (objfile
)->builtin_void
;
17721 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
17726 /* Initialise and return a floating point type of size BITS suitable for
17727 use as a component of a complex number. The NAME_HINT is passed through
17728 when initialising the floating point type and is the name of the complex
17731 As DWARF doesn't currently provide an explicit name for the components
17732 of a complex number, but it can be helpful to have these components
17733 named, we try to select a suitable name based on the size of the
17735 static struct type
*
17736 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
17737 struct objfile
*objfile
,
17738 int bits
, const char *name_hint
,
17739 enum bfd_endian byte_order
)
17741 gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17742 struct type
*tt
= nullptr;
17744 /* Try to find a suitable floating point builtin type of size BITS.
17745 We're going to use the name of this type as the name for the complex
17746 target type that we are about to create. */
17747 switch (cu
->language
)
17749 case language_fortran
:
17753 tt
= builtin_f_type (gdbarch
)->builtin_real
;
17756 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
17758 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17760 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
17768 tt
= builtin_type (gdbarch
)->builtin_float
;
17771 tt
= builtin_type (gdbarch
)->builtin_double
;
17773 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17775 tt
= builtin_type (gdbarch
)->builtin_long_double
;
17781 /* If the type we found doesn't match the size we were looking for, then
17782 pretend we didn't find a type at all, the complex target type we
17783 create will then be nameless. */
17784 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
17787 const char *name
= (tt
== nullptr) ? nullptr : TYPE_NAME (tt
);
17788 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
, byte_order
);
17791 /* Find a representation of a given base type and install
17792 it in the TYPE field of the die. */
17794 static struct type
*
17795 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17797 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17799 struct attribute
*attr
;
17800 int encoding
= 0, bits
= 0;
17804 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
17805 if (attr
!= nullptr)
17806 encoding
= DW_UNSND (attr
);
17807 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17808 if (attr
!= nullptr)
17809 bits
= DW_UNSND (attr
) * TARGET_CHAR_BIT
;
17810 name
= dwarf2_name (die
, cu
);
17812 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17814 arch
= get_objfile_arch (objfile
);
17815 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
17817 attr
= dwarf2_attr (die
, DW_AT_endianity
, cu
);
17820 int endianity
= DW_UNSND (attr
);
17825 byte_order
= BFD_ENDIAN_BIG
;
17827 case DW_END_little
:
17828 byte_order
= BFD_ENDIAN_LITTLE
;
17831 complaint (_("DW_AT_endianity has unrecognized value %d"), endianity
);
17838 case DW_ATE_address
:
17839 /* Turn DW_ATE_address into a void * pointer. */
17840 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
17841 type
= init_pointer_type (objfile
, bits
, name
, type
);
17843 case DW_ATE_boolean
:
17844 type
= init_boolean_type (objfile
, bits
, 1, name
);
17846 case DW_ATE_complex_float
:
17847 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
,
17849 type
= init_complex_type (objfile
, name
, type
);
17851 case DW_ATE_decimal_float
:
17852 type
= init_decfloat_type (objfile
, bits
, name
);
17855 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
, byte_order
);
17857 case DW_ATE_signed
:
17858 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
17860 case DW_ATE_unsigned
:
17861 if (cu
->language
== language_fortran
17863 && startswith (name
, "character("))
17864 type
= init_character_type (objfile
, bits
, 1, name
);
17866 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17868 case DW_ATE_signed_char
:
17869 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17870 || cu
->language
== language_pascal
17871 || cu
->language
== language_fortran
)
17872 type
= init_character_type (objfile
, bits
, 0, name
);
17874 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
17876 case DW_ATE_unsigned_char
:
17877 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17878 || cu
->language
== language_pascal
17879 || cu
->language
== language_fortran
17880 || cu
->language
== language_rust
)
17881 type
= init_character_type (objfile
, bits
, 1, name
);
17883 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17888 type
= builtin_type (arch
)->builtin_char16
;
17889 else if (bits
== 32)
17890 type
= builtin_type (arch
)->builtin_char32
;
17893 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17895 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17897 return set_die_type (die
, type
, cu
);
17902 complaint (_("unsupported DW_AT_encoding: '%s'"),
17903 dwarf_type_encoding_name (encoding
));
17904 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17908 if (name
&& strcmp (name
, "char") == 0)
17909 TYPE_NOSIGN (type
) = 1;
17911 maybe_set_alignment (cu
, die
, type
);
17913 TYPE_ENDIANITY_NOT_DEFAULT (type
) = gdbarch_byte_order (arch
) != byte_order
;
17915 return set_die_type (die
, type
, cu
);
17918 /* Parse dwarf attribute if it's a block, reference or constant and put the
17919 resulting value of the attribute into struct bound_prop.
17920 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17923 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
17924 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
17925 struct type
*default_type
)
17927 struct dwarf2_property_baton
*baton
;
17928 struct obstack
*obstack
17929 = &cu
->per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
;
17931 gdb_assert (default_type
!= NULL
);
17933 if (attr
== NULL
|| prop
== NULL
)
17936 if (attr_form_is_block (attr
))
17938 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17939 baton
->property_type
= default_type
;
17940 baton
->locexpr
.per_cu
= cu
->per_cu
;
17941 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
17942 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
17943 switch (attr
->name
)
17945 case DW_AT_string_length
:
17946 baton
->locexpr
.is_reference
= true;
17949 baton
->locexpr
.is_reference
= false;
17952 prop
->data
.baton
= baton
;
17953 prop
->kind
= PROP_LOCEXPR
;
17954 gdb_assert (prop
->data
.baton
!= NULL
);
17956 else if (attr_form_is_ref (attr
))
17958 struct dwarf2_cu
*target_cu
= cu
;
17959 struct die_info
*target_die
;
17960 struct attribute
*target_attr
;
17962 target_die
= follow_die_ref (die
, attr
, &target_cu
);
17963 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
17964 if (target_attr
== NULL
)
17965 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
17967 if (target_attr
== NULL
)
17970 switch (target_attr
->name
)
17972 case DW_AT_location
:
17973 if (attr_form_is_section_offset (target_attr
))
17975 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17976 baton
->property_type
= die_type (target_die
, target_cu
);
17977 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
17978 prop
->data
.baton
= baton
;
17979 prop
->kind
= PROP_LOCLIST
;
17980 gdb_assert (prop
->data
.baton
!= NULL
);
17982 else if (attr_form_is_block (target_attr
))
17984 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17985 baton
->property_type
= die_type (target_die
, target_cu
);
17986 baton
->locexpr
.per_cu
= cu
->per_cu
;
17987 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
17988 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
17989 baton
->locexpr
.is_reference
= true;
17990 prop
->data
.baton
= baton
;
17991 prop
->kind
= PROP_LOCEXPR
;
17992 gdb_assert (prop
->data
.baton
!= NULL
);
17996 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17997 "dynamic property");
18001 case DW_AT_data_member_location
:
18005 if (!handle_data_member_location (target_die
, target_cu
,
18009 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
18010 baton
->property_type
= read_type_die (target_die
->parent
,
18012 baton
->offset_info
.offset
= offset
;
18013 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
18014 prop
->data
.baton
= baton
;
18015 prop
->kind
= PROP_ADDR_OFFSET
;
18020 else if (attr_form_is_constant (attr
))
18022 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
18023 prop
->kind
= PROP_CONST
;
18027 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
18028 dwarf2_name (die
, cu
));
18035 /* Find an integer type SIZE_IN_BYTES bytes in size and return it.
18036 UNSIGNED_P controls if the integer is unsigned or not. */
18038 static struct type
*
18039 dwarf2_per_cu_int_type (struct dwarf2_per_cu_data
*per_cu
,
18040 int size_in_bytes
, bool unsigned_p
)
18042 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
18043 struct type
*int_type
;
18045 /* Helper macro to examine the various builtin types. */
18046 #define TRY_TYPE(F) \
18047 int_type = (unsigned_p \
18048 ? objfile_type (objfile)->builtin_unsigned_ ## F \
18049 : objfile_type (objfile)->builtin_ ## F); \
18050 if (int_type != NULL && TYPE_LENGTH (int_type) == size_in_bytes) \
18057 TRY_TYPE (long_long
);
18061 gdb_assert_not_reached ("unable to find suitable integer type");
18064 /* Find an integer type the same size as the address size given in the
18065 compilation unit header for PER_CU. UNSIGNED_P controls if the integer
18066 is unsigned or not. */
18068 static struct type
*
18069 dwarf2_per_cu_addr_sized_int_type (struct dwarf2_per_cu_data
*per_cu
,
18072 int addr_size
= dwarf2_per_cu_addr_size (per_cu
);
18073 return dwarf2_per_cu_int_type (per_cu
, addr_size
, unsigned_p
);
18076 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
18077 present (which is valid) then compute the default type based on the
18078 compilation units address size. */
18080 static struct type
*
18081 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18083 struct type
*index_type
= die_type (die
, cu
);
18085 /* Dwarf-2 specifications explicitly allows to create subrange types
18086 without specifying a base type.
18087 In that case, the base type must be set to the type of
18088 the lower bound, upper bound or count, in that order, if any of these
18089 three attributes references an object that has a type.
18090 If no base type is found, the Dwarf-2 specifications say that
18091 a signed integer type of size equal to the size of an address should
18093 For the following C code: `extern char gdb_int [];'
18094 GCC produces an empty range DIE.
18095 FIXME: muller/2010-05-28: Possible references to object for low bound,
18096 high bound or count are not yet handled by this code. */
18097 if (TYPE_CODE (index_type
) == TYPE_CODE_VOID
)
18098 index_type
= dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
18103 /* Read the given DW_AT_subrange DIE. */
18105 static struct type
*
18106 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18108 struct type
*base_type
, *orig_base_type
;
18109 struct type
*range_type
;
18110 struct attribute
*attr
;
18111 struct dynamic_prop low
, high
;
18112 int low_default_is_valid
;
18113 int high_bound_is_count
= 0;
18115 ULONGEST negative_mask
;
18117 orig_base_type
= read_subrange_index_type (die
, cu
);
18119 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
18120 whereas the real type might be. So, we use ORIG_BASE_TYPE when
18121 creating the range type, but we use the result of check_typedef
18122 when examining properties of the type. */
18123 base_type
= check_typedef (orig_base_type
);
18125 /* The die_type call above may have already set the type for this DIE. */
18126 range_type
= get_die_type (die
, cu
);
18130 low
.kind
= PROP_CONST
;
18131 high
.kind
= PROP_CONST
;
18132 high
.data
.const_val
= 0;
18134 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
18135 omitting DW_AT_lower_bound. */
18136 switch (cu
->language
)
18139 case language_cplus
:
18140 low
.data
.const_val
= 0;
18141 low_default_is_valid
= 1;
18143 case language_fortran
:
18144 low
.data
.const_val
= 1;
18145 low_default_is_valid
= 1;
18148 case language_objc
:
18149 case language_rust
:
18150 low
.data
.const_val
= 0;
18151 low_default_is_valid
= (cu
->header
.version
>= 4);
18155 case language_pascal
:
18156 low
.data
.const_val
= 1;
18157 low_default_is_valid
= (cu
->header
.version
>= 4);
18160 low
.data
.const_val
= 0;
18161 low_default_is_valid
= 0;
18165 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
18166 if (attr
!= nullptr)
18167 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
18168 else if (!low_default_is_valid
)
18169 complaint (_("Missing DW_AT_lower_bound "
18170 "- DIE at %s [in module %s]"),
18171 sect_offset_str (die
->sect_off
),
18172 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
18174 struct attribute
*attr_ub
, *attr_count
;
18175 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
18176 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18178 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
18179 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
18181 /* If bounds are constant do the final calculation here. */
18182 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
18183 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
18185 high_bound_is_count
= 1;
18189 if (attr_ub
!= NULL
)
18190 complaint (_("Unresolved DW_AT_upper_bound "
18191 "- DIE at %s [in module %s]"),
18192 sect_offset_str (die
->sect_off
),
18193 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
18194 if (attr_count
!= NULL
)
18195 complaint (_("Unresolved DW_AT_count "
18196 "- DIE at %s [in module %s]"),
18197 sect_offset_str (die
->sect_off
),
18198 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
18203 struct attribute
*bias_attr
= dwarf2_attr (die
, DW_AT_GNU_bias
, cu
);
18204 if (bias_attr
!= nullptr && attr_form_is_constant (bias_attr
))
18205 bias
= dwarf2_get_attr_constant_value (bias_attr
, 0);
18207 /* Normally, the DWARF producers are expected to use a signed
18208 constant form (Eg. DW_FORM_sdata) to express negative bounds.
18209 But this is unfortunately not always the case, as witnessed
18210 with GCC, for instance, where the ambiguous DW_FORM_dataN form
18211 is used instead. To work around that ambiguity, we treat
18212 the bounds as signed, and thus sign-extend their values, when
18213 the base type is signed. */
18215 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
18216 if (low
.kind
== PROP_CONST
18217 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
18218 low
.data
.const_val
|= negative_mask
;
18219 if (high
.kind
== PROP_CONST
18220 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
18221 high
.data
.const_val
|= negative_mask
;
18223 /* Check for bit and byte strides. */
18224 struct dynamic_prop byte_stride_prop
;
18225 attribute
*attr_byte_stride
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
18226 if (attr_byte_stride
!= nullptr)
18228 struct type
*prop_type
18229 = dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
18230 attr_to_dynamic_prop (attr_byte_stride
, die
, cu
, &byte_stride_prop
,
18234 struct dynamic_prop bit_stride_prop
;
18235 attribute
*attr_bit_stride
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
18236 if (attr_bit_stride
!= nullptr)
18238 /* It only makes sense to have either a bit or byte stride. */
18239 if (attr_byte_stride
!= nullptr)
18241 complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
18242 "- DIE at %s [in module %s]"),
18243 sect_offset_str (die
->sect_off
),
18244 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
18245 attr_bit_stride
= nullptr;
18249 struct type
*prop_type
18250 = dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
18251 attr_to_dynamic_prop (attr_bit_stride
, die
, cu
, &bit_stride_prop
,
18256 if (attr_byte_stride
!= nullptr
18257 || attr_bit_stride
!= nullptr)
18259 bool byte_stride_p
= (attr_byte_stride
!= nullptr);
18260 struct dynamic_prop
*stride
18261 = byte_stride_p
? &byte_stride_prop
: &bit_stride_prop
;
18264 = create_range_type_with_stride (NULL
, orig_base_type
, &low
,
18265 &high
, bias
, stride
, byte_stride_p
);
18268 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
, bias
);
18270 if (high_bound_is_count
)
18271 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
18273 /* Ada expects an empty array on no boundary attributes. */
18274 if (attr
== NULL
&& cu
->language
!= language_ada
)
18275 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
18277 name
= dwarf2_name (die
, cu
);
18279 TYPE_NAME (range_type
) = name
;
18281 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18282 if (attr
!= nullptr)
18283 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
18285 maybe_set_alignment (cu
, die
, range_type
);
18287 set_die_type (die
, range_type
, cu
);
18289 /* set_die_type should be already done. */
18290 set_descriptive_type (range_type
, die
, cu
);
18295 static struct type
*
18296 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18300 type
= init_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
, TYPE_CODE_VOID
,0,
18302 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
18304 /* In Ada, an unspecified type is typically used when the description
18305 of the type is deferred to a different unit. When encountering
18306 such a type, we treat it as a stub, and try to resolve it later on,
18308 if (cu
->language
== language_ada
)
18309 TYPE_STUB (type
) = 1;
18311 return set_die_type (die
, type
, cu
);
18314 /* Read a single die and all its descendents. Set the die's sibling
18315 field to NULL; set other fields in the die correctly, and set all
18316 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
18317 location of the info_ptr after reading all of those dies. PARENT
18318 is the parent of the die in question. */
18320 static struct die_info
*
18321 read_die_and_children (const struct die_reader_specs
*reader
,
18322 const gdb_byte
*info_ptr
,
18323 const gdb_byte
**new_info_ptr
,
18324 struct die_info
*parent
)
18326 struct die_info
*die
;
18327 const gdb_byte
*cur_ptr
;
18330 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
18333 *new_info_ptr
= cur_ptr
;
18336 store_in_ref_table (die
, reader
->cu
);
18339 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
18343 *new_info_ptr
= cur_ptr
;
18346 die
->sibling
= NULL
;
18347 die
->parent
= parent
;
18351 /* Read a die, all of its descendents, and all of its siblings; set
18352 all of the fields of all of the dies correctly. Arguments are as
18353 in read_die_and_children. */
18355 static struct die_info
*
18356 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
18357 const gdb_byte
*info_ptr
,
18358 const gdb_byte
**new_info_ptr
,
18359 struct die_info
*parent
)
18361 struct die_info
*first_die
, *last_sibling
;
18362 const gdb_byte
*cur_ptr
;
18364 cur_ptr
= info_ptr
;
18365 first_die
= last_sibling
= NULL
;
18369 struct die_info
*die
18370 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
18374 *new_info_ptr
= cur_ptr
;
18381 last_sibling
->sibling
= die
;
18383 last_sibling
= die
;
18387 /* Read a die, all of its descendents, and all of its siblings; set
18388 all of the fields of all of the dies correctly. Arguments are as
18389 in read_die_and_children.
18390 This the main entry point for reading a DIE and all its children. */
18392 static struct die_info
*
18393 read_die_and_siblings (const struct die_reader_specs
*reader
,
18394 const gdb_byte
*info_ptr
,
18395 const gdb_byte
**new_info_ptr
,
18396 struct die_info
*parent
)
18398 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
18399 new_info_ptr
, parent
);
18401 if (dwarf_die_debug
)
18403 fprintf_unfiltered (gdb_stdlog
,
18404 "Read die from %s@0x%x of %s:\n",
18405 get_section_name (reader
->die_section
),
18406 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18407 bfd_get_filename (reader
->abfd
));
18408 dump_die (die
, dwarf_die_debug
);
18414 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18416 The caller is responsible for filling in the extra attributes
18417 and updating (*DIEP)->num_attrs.
18418 Set DIEP to point to a newly allocated die with its information,
18419 except for its child, sibling, and parent fields.
18420 Set HAS_CHILDREN to tell whether the die has children or not. */
18422 static const gdb_byte
*
18423 read_full_die_1 (const struct die_reader_specs
*reader
,
18424 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18425 int *has_children
, int num_extra_attrs
)
18427 unsigned int abbrev_number
, bytes_read
, i
;
18428 struct abbrev_info
*abbrev
;
18429 struct die_info
*die
;
18430 struct dwarf2_cu
*cu
= reader
->cu
;
18431 bfd
*abfd
= reader
->abfd
;
18433 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
18434 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18435 info_ptr
+= bytes_read
;
18436 if (!abbrev_number
)
18443 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
18445 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18447 bfd_get_filename (abfd
));
18449 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
18450 die
->sect_off
= sect_off
;
18451 die
->tag
= abbrev
->tag
;
18452 die
->abbrev
= abbrev_number
;
18454 /* Make the result usable.
18455 The caller needs to update num_attrs after adding the extra
18457 die
->num_attrs
= abbrev
->num_attrs
;
18459 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18460 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
18464 *has_children
= abbrev
->has_children
;
18468 /* Read a die and all its attributes.
18469 Set DIEP to point to a newly allocated die with its information,
18470 except for its child, sibling, and parent fields.
18471 Set HAS_CHILDREN to tell whether the die has children or not. */
18473 static const gdb_byte
*
18474 read_full_die (const struct die_reader_specs
*reader
,
18475 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18478 const gdb_byte
*result
;
18480 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
18482 if (dwarf_die_debug
)
18484 fprintf_unfiltered (gdb_stdlog
,
18485 "Read die from %s@0x%x of %s:\n",
18486 get_section_name (reader
->die_section
),
18487 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18488 bfd_get_filename (reader
->abfd
));
18489 dump_die (*diep
, dwarf_die_debug
);
18495 /* Abbreviation tables.
18497 In DWARF version 2, the description of the debugging information is
18498 stored in a separate .debug_abbrev section. Before we read any
18499 dies from a section we read in all abbreviations and install them
18500 in a hash table. */
18502 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18504 struct abbrev_info
*
18505 abbrev_table::alloc_abbrev ()
18507 struct abbrev_info
*abbrev
;
18509 abbrev
= XOBNEW (&abbrev_obstack
, struct abbrev_info
);
18510 memset (abbrev
, 0, sizeof (struct abbrev_info
));
18515 /* Add an abbreviation to the table. */
18518 abbrev_table::add_abbrev (unsigned int abbrev_number
,
18519 struct abbrev_info
*abbrev
)
18521 unsigned int hash_number
;
18523 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
18524 abbrev
->next
= m_abbrevs
[hash_number
];
18525 m_abbrevs
[hash_number
] = abbrev
;
18528 /* Look up an abbrev in the table.
18529 Returns NULL if the abbrev is not found. */
18531 struct abbrev_info
*
18532 abbrev_table::lookup_abbrev (unsigned int abbrev_number
)
18534 unsigned int hash_number
;
18535 struct abbrev_info
*abbrev
;
18537 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
18538 abbrev
= m_abbrevs
[hash_number
];
18542 if (abbrev
->number
== abbrev_number
)
18544 abbrev
= abbrev
->next
;
18549 /* Read in an abbrev table. */
18551 static abbrev_table_up
18552 abbrev_table_read_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
18553 struct dwarf2_section_info
*section
,
18554 sect_offset sect_off
)
18556 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18557 bfd
*abfd
= get_section_bfd_owner (section
);
18558 const gdb_byte
*abbrev_ptr
;
18559 struct abbrev_info
*cur_abbrev
;
18560 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
18561 unsigned int abbrev_form
;
18562 struct attr_abbrev
*cur_attrs
;
18563 unsigned int allocated_attrs
;
18565 abbrev_table_up
abbrev_table (new struct abbrev_table (sect_off
));
18567 dwarf2_read_section (objfile
, section
);
18568 abbrev_ptr
= section
->buffer
+ to_underlying (sect_off
);
18569 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18570 abbrev_ptr
+= bytes_read
;
18572 allocated_attrs
= ATTR_ALLOC_CHUNK
;
18573 cur_attrs
= XNEWVEC (struct attr_abbrev
, allocated_attrs
);
18575 /* Loop until we reach an abbrev number of 0. */
18576 while (abbrev_number
)
18578 cur_abbrev
= abbrev_table
->alloc_abbrev ();
18580 /* read in abbrev header */
18581 cur_abbrev
->number
= abbrev_number
;
18583 = (enum dwarf_tag
) read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18584 abbrev_ptr
+= bytes_read
;
18585 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
18588 /* now read in declarations */
18591 LONGEST implicit_const
;
18593 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18594 abbrev_ptr
+= bytes_read
;
18595 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18596 abbrev_ptr
+= bytes_read
;
18597 if (abbrev_form
== DW_FORM_implicit_const
)
18599 implicit_const
= read_signed_leb128 (abfd
, abbrev_ptr
,
18601 abbrev_ptr
+= bytes_read
;
18605 /* Initialize it due to a false compiler warning. */
18606 implicit_const
= -1;
18609 if (abbrev_name
== 0)
18612 if (cur_abbrev
->num_attrs
== allocated_attrs
)
18614 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
18616 = XRESIZEVEC (struct attr_abbrev
, cur_attrs
, allocated_attrs
);
18619 cur_attrs
[cur_abbrev
->num_attrs
].name
18620 = (enum dwarf_attribute
) abbrev_name
;
18621 cur_attrs
[cur_abbrev
->num_attrs
].form
18622 = (enum dwarf_form
) abbrev_form
;
18623 cur_attrs
[cur_abbrev
->num_attrs
].implicit_const
= implicit_const
;
18624 ++cur_abbrev
->num_attrs
;
18627 cur_abbrev
->attrs
=
18628 XOBNEWVEC (&abbrev_table
->abbrev_obstack
, struct attr_abbrev
,
18629 cur_abbrev
->num_attrs
);
18630 memcpy (cur_abbrev
->attrs
, cur_attrs
,
18631 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
18633 abbrev_table
->add_abbrev (abbrev_number
, cur_abbrev
);
18635 /* Get next abbreviation.
18636 Under Irix6 the abbreviations for a compilation unit are not
18637 always properly terminated with an abbrev number of 0.
18638 Exit loop if we encounter an abbreviation which we have
18639 already read (which means we are about to read the abbreviations
18640 for the next compile unit) or if the end of the abbreviation
18641 table is reached. */
18642 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
18644 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18645 abbrev_ptr
+= bytes_read
;
18646 if (abbrev_table
->lookup_abbrev (abbrev_number
) != NULL
)
18651 return abbrev_table
;
18654 /* Returns nonzero if TAG represents a type that we might generate a partial
18658 is_type_tag_for_partial (int tag
)
18663 /* Some types that would be reasonable to generate partial symbols for,
18664 that we don't at present. */
18665 case DW_TAG_array_type
:
18666 case DW_TAG_file_type
:
18667 case DW_TAG_ptr_to_member_type
:
18668 case DW_TAG_set_type
:
18669 case DW_TAG_string_type
:
18670 case DW_TAG_subroutine_type
:
18672 case DW_TAG_base_type
:
18673 case DW_TAG_class_type
:
18674 case DW_TAG_interface_type
:
18675 case DW_TAG_enumeration_type
:
18676 case DW_TAG_structure_type
:
18677 case DW_TAG_subrange_type
:
18678 case DW_TAG_typedef
:
18679 case DW_TAG_union_type
:
18686 /* Load all DIEs that are interesting for partial symbols into memory. */
18688 static struct partial_die_info
*
18689 load_partial_dies (const struct die_reader_specs
*reader
,
18690 const gdb_byte
*info_ptr
, int building_psymtab
)
18692 struct dwarf2_cu
*cu
= reader
->cu
;
18693 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
18694 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
18695 unsigned int bytes_read
;
18696 unsigned int load_all
= 0;
18697 int nesting_level
= 1;
18702 gdb_assert (cu
->per_cu
!= NULL
);
18703 if (cu
->per_cu
->load_all_dies
)
18707 = htab_create_alloc_ex (cu
->header
.length
/ 12,
18711 &cu
->comp_unit_obstack
,
18712 hashtab_obstack_allocate
,
18713 dummy_obstack_deallocate
);
18717 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
18719 /* A NULL abbrev means the end of a series of children. */
18720 if (abbrev
== NULL
)
18722 if (--nesting_level
== 0)
18725 info_ptr
+= bytes_read
;
18726 last_die
= parent_die
;
18727 parent_die
= parent_die
->die_parent
;
18731 /* Check for template arguments. We never save these; if
18732 they're seen, we just mark the parent, and go on our way. */
18733 if (parent_die
!= NULL
18734 && cu
->language
== language_cplus
18735 && (abbrev
->tag
== DW_TAG_template_type_param
18736 || abbrev
->tag
== DW_TAG_template_value_param
))
18738 parent_die
->has_template_arguments
= 1;
18742 /* We don't need a partial DIE for the template argument. */
18743 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18748 /* We only recurse into c++ subprograms looking for template arguments.
18749 Skip their other children. */
18751 && cu
->language
== language_cplus
18752 && parent_die
!= NULL
18753 && parent_die
->tag
== DW_TAG_subprogram
)
18755 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18759 /* Check whether this DIE is interesting enough to save. Normally
18760 we would not be interested in members here, but there may be
18761 later variables referencing them via DW_AT_specification (for
18762 static members). */
18764 && !is_type_tag_for_partial (abbrev
->tag
)
18765 && abbrev
->tag
!= DW_TAG_constant
18766 && abbrev
->tag
!= DW_TAG_enumerator
18767 && abbrev
->tag
!= DW_TAG_subprogram
18768 && abbrev
->tag
!= DW_TAG_inlined_subroutine
18769 && abbrev
->tag
!= DW_TAG_lexical_block
18770 && abbrev
->tag
!= DW_TAG_variable
18771 && abbrev
->tag
!= DW_TAG_namespace
18772 && abbrev
->tag
!= DW_TAG_module
18773 && abbrev
->tag
!= DW_TAG_member
18774 && abbrev
->tag
!= DW_TAG_imported_unit
18775 && abbrev
->tag
!= DW_TAG_imported_declaration
)
18777 /* Otherwise we skip to the next sibling, if any. */
18778 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18782 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
18785 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
18787 /* This two-pass algorithm for processing partial symbols has a
18788 high cost in cache pressure. Thus, handle some simple cases
18789 here which cover the majority of C partial symbols. DIEs
18790 which neither have specification tags in them, nor could have
18791 specification tags elsewhere pointing at them, can simply be
18792 processed and discarded.
18794 This segment is also optional; scan_partial_symbols and
18795 add_partial_symbol will handle these DIEs if we chain
18796 them in normally. When compilers which do not emit large
18797 quantities of duplicate debug information are more common,
18798 this code can probably be removed. */
18800 /* Any complete simple types at the top level (pretty much all
18801 of them, for a language without namespaces), can be processed
18803 if (parent_die
== NULL
18804 && pdi
.has_specification
== 0
18805 && pdi
.is_declaration
== 0
18806 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
18807 || pdi
.tag
== DW_TAG_base_type
18808 || pdi
.tag
== DW_TAG_subrange_type
))
18810 if (building_psymtab
&& pdi
.name
!= NULL
)
18811 add_psymbol_to_list (pdi
.name
, false,
18812 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
18813 psymbol_placement::STATIC
,
18814 0, cu
->language
, objfile
);
18815 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18819 /* The exception for DW_TAG_typedef with has_children above is
18820 a workaround of GCC PR debug/47510. In the case of this complaint
18821 type_name_or_error will error on such types later.
18823 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18824 it could not find the child DIEs referenced later, this is checked
18825 above. In correct DWARF DW_TAG_typedef should have no children. */
18827 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
18828 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18829 "- DIE at %s [in module %s]"),
18830 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
18832 /* If we're at the second level, and we're an enumerator, and
18833 our parent has no specification (meaning possibly lives in a
18834 namespace elsewhere), then we can add the partial symbol now
18835 instead of queueing it. */
18836 if (pdi
.tag
== DW_TAG_enumerator
18837 && parent_die
!= NULL
18838 && parent_die
->die_parent
== NULL
18839 && parent_die
->tag
== DW_TAG_enumeration_type
18840 && parent_die
->has_specification
== 0)
18842 if (pdi
.name
== NULL
)
18843 complaint (_("malformed enumerator DIE ignored"));
18844 else if (building_psymtab
)
18845 add_psymbol_to_list (pdi
.name
, false,
18846 VAR_DOMAIN
, LOC_CONST
, -1,
18847 cu
->language
== language_cplus
18848 ? psymbol_placement::GLOBAL
18849 : psymbol_placement::STATIC
,
18850 0, cu
->language
, objfile
);
18852 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18856 struct partial_die_info
*part_die
18857 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
18859 /* We'll save this DIE so link it in. */
18860 part_die
->die_parent
= parent_die
;
18861 part_die
->die_sibling
= NULL
;
18862 part_die
->die_child
= NULL
;
18864 if (last_die
&& last_die
== parent_die
)
18865 last_die
->die_child
= part_die
;
18867 last_die
->die_sibling
= part_die
;
18869 last_die
= part_die
;
18871 if (first_die
== NULL
)
18872 first_die
= part_die
;
18874 /* Maybe add the DIE to the hash table. Not all DIEs that we
18875 find interesting need to be in the hash table, because we
18876 also have the parent/sibling/child chains; only those that we
18877 might refer to by offset later during partial symbol reading.
18879 For now this means things that might have be the target of a
18880 DW_AT_specification, DW_AT_abstract_origin, or
18881 DW_AT_extension. DW_AT_extension will refer only to
18882 namespaces; DW_AT_abstract_origin refers to functions (and
18883 many things under the function DIE, but we do not recurse
18884 into function DIEs during partial symbol reading) and
18885 possibly variables as well; DW_AT_specification refers to
18886 declarations. Declarations ought to have the DW_AT_declaration
18887 flag. It happens that GCC forgets to put it in sometimes, but
18888 only for functions, not for types.
18890 Adding more things than necessary to the hash table is harmless
18891 except for the performance cost. Adding too few will result in
18892 wasted time in find_partial_die, when we reread the compilation
18893 unit with load_all_dies set. */
18896 || abbrev
->tag
== DW_TAG_constant
18897 || abbrev
->tag
== DW_TAG_subprogram
18898 || abbrev
->tag
== DW_TAG_variable
18899 || abbrev
->tag
== DW_TAG_namespace
18900 || part_die
->is_declaration
)
18904 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
18905 to_underlying (part_die
->sect_off
),
18910 /* For some DIEs we want to follow their children (if any). For C
18911 we have no reason to follow the children of structures; for other
18912 languages we have to, so that we can get at method physnames
18913 to infer fully qualified class names, for DW_AT_specification,
18914 and for C++ template arguments. For C++, we also look one level
18915 inside functions to find template arguments (if the name of the
18916 function does not already contain the template arguments).
18918 For Ada and Fortran, we need to scan the children of subprograms
18919 and lexical blocks as well because these languages allow the
18920 definition of nested entities that could be interesting for the
18921 debugger, such as nested subprograms for instance. */
18922 if (last_die
->has_children
18924 || last_die
->tag
== DW_TAG_namespace
18925 || last_die
->tag
== DW_TAG_module
18926 || last_die
->tag
== DW_TAG_enumeration_type
18927 || (cu
->language
== language_cplus
18928 && last_die
->tag
== DW_TAG_subprogram
18929 && (last_die
->name
== NULL
18930 || strchr (last_die
->name
, '<') == NULL
))
18931 || (cu
->language
!= language_c
18932 && (last_die
->tag
== DW_TAG_class_type
18933 || last_die
->tag
== DW_TAG_interface_type
18934 || last_die
->tag
== DW_TAG_structure_type
18935 || last_die
->tag
== DW_TAG_union_type
))
18936 || ((cu
->language
== language_ada
18937 || cu
->language
== language_fortran
)
18938 && (last_die
->tag
== DW_TAG_subprogram
18939 || last_die
->tag
== DW_TAG_lexical_block
))))
18942 parent_die
= last_die
;
18946 /* Otherwise we skip to the next sibling, if any. */
18947 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
18949 /* Back to the top, do it again. */
18953 partial_die_info::partial_die_info (sect_offset sect_off_
,
18954 struct abbrev_info
*abbrev
)
18955 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
18959 /* Read a minimal amount of information into the minimal die structure.
18960 INFO_PTR should point just after the initial uleb128 of a DIE. */
18963 partial_die_info::read (const struct die_reader_specs
*reader
,
18964 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
18966 struct dwarf2_cu
*cu
= reader
->cu
;
18967 struct dwarf2_per_objfile
*dwarf2_per_objfile
18968 = cu
->per_cu
->dwarf2_per_objfile
;
18970 int has_low_pc_attr
= 0;
18971 int has_high_pc_attr
= 0;
18972 int high_pc_relative
= 0;
18974 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
18976 struct attribute attr
;
18978 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
18980 /* Store the data if it is of an attribute we want to keep in a
18981 partial symbol table. */
18987 case DW_TAG_compile_unit
:
18988 case DW_TAG_partial_unit
:
18989 case DW_TAG_type_unit
:
18990 /* Compilation units have a DW_AT_name that is a filename, not
18991 a source language identifier. */
18992 case DW_TAG_enumeration_type
:
18993 case DW_TAG_enumerator
:
18994 /* These tags always have simple identifiers already; no need
18995 to canonicalize them. */
18996 name
= DW_STRING (&attr
);
19000 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19003 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
19004 &objfile
->per_bfd
->storage_obstack
);
19009 case DW_AT_linkage_name
:
19010 case DW_AT_MIPS_linkage_name
:
19011 /* Note that both forms of linkage name might appear. We
19012 assume they will be the same, and we only store the last
19014 linkage_name
= DW_STRING (&attr
);
19017 has_low_pc_attr
= 1;
19018 lowpc
= attr_value_as_address (&attr
);
19020 case DW_AT_high_pc
:
19021 has_high_pc_attr
= 1;
19022 highpc
= attr_value_as_address (&attr
);
19023 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
19024 high_pc_relative
= 1;
19026 case DW_AT_location
:
19027 /* Support the .debug_loc offsets. */
19028 if (attr_form_is_block (&attr
))
19030 d
.locdesc
= DW_BLOCK (&attr
);
19032 else if (attr_form_is_section_offset (&attr
))
19034 dwarf2_complex_location_expr_complaint ();
19038 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
19039 "partial symbol information");
19042 case DW_AT_external
:
19043 is_external
= DW_UNSND (&attr
);
19045 case DW_AT_declaration
:
19046 is_declaration
= DW_UNSND (&attr
);
19051 case DW_AT_abstract_origin
:
19052 case DW_AT_specification
:
19053 case DW_AT_extension
:
19054 has_specification
= 1;
19055 spec_offset
= dwarf2_get_ref_die_offset (&attr
);
19056 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19057 || cu
->per_cu
->is_dwz
);
19059 case DW_AT_sibling
:
19060 /* Ignore absolute siblings, they might point outside of
19061 the current compile unit. */
19062 if (attr
.form
== DW_FORM_ref_addr
)
19063 complaint (_("ignoring absolute DW_AT_sibling"));
19066 const gdb_byte
*buffer
= reader
->buffer
;
19067 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
19068 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
19070 if (sibling_ptr
< info_ptr
)
19071 complaint (_("DW_AT_sibling points backwards"));
19072 else if (sibling_ptr
> reader
->buffer_end
)
19073 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
19075 sibling
= sibling_ptr
;
19078 case DW_AT_byte_size
:
19081 case DW_AT_const_value
:
19082 has_const_value
= 1;
19084 case DW_AT_calling_convention
:
19085 /* DWARF doesn't provide a way to identify a program's source-level
19086 entry point. DW_AT_calling_convention attributes are only meant
19087 to describe functions' calling conventions.
19089 However, because it's a necessary piece of information in
19090 Fortran, and before DWARF 4 DW_CC_program was the only
19091 piece of debugging information whose definition refers to
19092 a 'main program' at all, several compilers marked Fortran
19093 main programs with DW_CC_program --- even when those
19094 functions use the standard calling conventions.
19096 Although DWARF now specifies a way to provide this
19097 information, we support this practice for backward
19099 if (DW_UNSND (&attr
) == DW_CC_program
19100 && cu
->language
== language_fortran
)
19101 main_subprogram
= 1;
19104 if (DW_UNSND (&attr
) == DW_INL_inlined
19105 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
19106 may_be_inlined
= 1;
19110 if (tag
== DW_TAG_imported_unit
)
19112 d
.sect_off
= dwarf2_get_ref_die_offset (&attr
);
19113 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
19114 || cu
->per_cu
->is_dwz
);
19118 case DW_AT_main_subprogram
:
19119 main_subprogram
= DW_UNSND (&attr
);
19124 /* It would be nice to reuse dwarf2_get_pc_bounds here,
19125 but that requires a full DIE, so instead we just
19127 int need_ranges_base
= tag
!= DW_TAG_compile_unit
;
19128 unsigned int ranges_offset
= (DW_UNSND (&attr
)
19129 + (need_ranges_base
19133 /* Value of the DW_AT_ranges attribute is the offset in the
19134 .debug_ranges section. */
19135 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
19146 /* For Ada, if both the name and the linkage name appear, we prefer
19147 the latter. This lets "catch exception" work better, regardless
19148 of the order in which the name and linkage name were emitted.
19149 Really, though, this is just a workaround for the fact that gdb
19150 doesn't store both the name and the linkage name. */
19151 if (cu
->language
== language_ada
&& linkage_name
!= nullptr)
19152 name
= linkage_name
;
19154 if (high_pc_relative
)
19157 if (has_low_pc_attr
&& has_high_pc_attr
)
19159 /* When using the GNU linker, .gnu.linkonce. sections are used to
19160 eliminate duplicate copies of functions and vtables and such.
19161 The linker will arbitrarily choose one and discard the others.
19162 The AT_*_pc values for such functions refer to local labels in
19163 these sections. If the section from that file was discarded, the
19164 labels are not in the output, so the relocs get a value of 0.
19165 If this is a discarded function, mark the pc bounds as invalid,
19166 so that GDB will ignore it. */
19167 if (lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
19169 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19170 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
19172 complaint (_("DW_AT_low_pc %s is zero "
19173 "for DIE at %s [in module %s]"),
19174 paddress (gdbarch
, lowpc
),
19175 sect_offset_str (sect_off
),
19176 objfile_name (objfile
));
19178 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
19179 else if (lowpc
>= highpc
)
19181 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19182 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
19184 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
19185 "for DIE at %s [in module %s]"),
19186 paddress (gdbarch
, lowpc
),
19187 paddress (gdbarch
, highpc
),
19188 sect_offset_str (sect_off
),
19189 objfile_name (objfile
));
19198 /* Find a cached partial DIE at OFFSET in CU. */
19200 struct partial_die_info
*
19201 dwarf2_cu::find_partial_die (sect_offset sect_off
)
19203 struct partial_die_info
*lookup_die
= NULL
;
19204 struct partial_die_info
part_die (sect_off
);
19206 lookup_die
= ((struct partial_die_info
*)
19207 htab_find_with_hash (partial_dies
, &part_die
,
19208 to_underlying (sect_off
)));
19213 /* Find a partial DIE at OFFSET, which may or may not be in CU,
19214 except in the case of .debug_types DIEs which do not reference
19215 outside their CU (they do however referencing other types via
19216 DW_FORM_ref_sig8). */
19218 static const struct cu_partial_die_info
19219 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
19221 struct dwarf2_per_objfile
*dwarf2_per_objfile
19222 = cu
->per_cu
->dwarf2_per_objfile
;
19223 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19224 struct dwarf2_per_cu_data
*per_cu
= NULL
;
19225 struct partial_die_info
*pd
= NULL
;
19227 if (offset_in_dwz
== cu
->per_cu
->is_dwz
19228 && offset_in_cu_p (&cu
->header
, sect_off
))
19230 pd
= cu
->find_partial_die (sect_off
);
19233 /* We missed recording what we needed.
19234 Load all dies and try again. */
19235 per_cu
= cu
->per_cu
;
19239 /* TUs don't reference other CUs/TUs (except via type signatures). */
19240 if (cu
->per_cu
->is_debug_types
)
19242 error (_("Dwarf Error: Type Unit at offset %s contains"
19243 " external reference to offset %s [in module %s].\n"),
19244 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
19245 bfd_get_filename (objfile
->obfd
));
19247 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
19248 dwarf2_per_objfile
);
19250 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
19251 load_partial_comp_unit (per_cu
);
19253 per_cu
->cu
->last_used
= 0;
19254 pd
= per_cu
->cu
->find_partial_die (sect_off
);
19257 /* If we didn't find it, and not all dies have been loaded,
19258 load them all and try again. */
19260 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
19262 per_cu
->load_all_dies
= 1;
19264 /* This is nasty. When we reread the DIEs, somewhere up the call chain
19265 THIS_CU->cu may already be in use. So we can't just free it and
19266 replace its DIEs with the ones we read in. Instead, we leave those
19267 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
19268 and clobber THIS_CU->cu->partial_dies with the hash table for the new
19270 load_partial_comp_unit (per_cu
);
19272 pd
= per_cu
->cu
->find_partial_die (sect_off
);
19276 internal_error (__FILE__
, __LINE__
,
19277 _("could not find partial DIE %s "
19278 "in cache [from module %s]\n"),
19279 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
19280 return { per_cu
->cu
, pd
};
19283 /* See if we can figure out if the class lives in a namespace. We do
19284 this by looking for a member function; its demangled name will
19285 contain namespace info, if there is any. */
19288 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
19289 struct dwarf2_cu
*cu
)
19291 /* NOTE: carlton/2003-10-07: Getting the info this way changes
19292 what template types look like, because the demangler
19293 frequently doesn't give the same name as the debug info. We
19294 could fix this by only using the demangled name to get the
19295 prefix (but see comment in read_structure_type). */
19297 struct partial_die_info
*real_pdi
;
19298 struct partial_die_info
*child_pdi
;
19300 /* If this DIE (this DIE's specification, if any) has a parent, then
19301 we should not do this. We'll prepend the parent's fully qualified
19302 name when we create the partial symbol. */
19304 real_pdi
= struct_pdi
;
19305 while (real_pdi
->has_specification
)
19307 auto res
= find_partial_die (real_pdi
->spec_offset
,
19308 real_pdi
->spec_is_dwz
, cu
);
19309 real_pdi
= res
.pdi
;
19313 if (real_pdi
->die_parent
!= NULL
)
19316 for (child_pdi
= struct_pdi
->die_child
;
19318 child_pdi
= child_pdi
->die_sibling
)
19320 if (child_pdi
->tag
== DW_TAG_subprogram
19321 && child_pdi
->linkage_name
!= NULL
)
19323 gdb::unique_xmalloc_ptr
<char> actual_class_name
19324 (language_class_name_from_physname (cu
->language_defn
,
19325 child_pdi
->linkage_name
));
19326 if (actual_class_name
!= NULL
)
19328 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
19330 = obstack_strdup (&objfile
->per_bfd
->storage_obstack
,
19331 actual_class_name
.get ());
19339 partial_die_info::fixup (struct dwarf2_cu
*cu
)
19341 /* Once we've fixed up a die, there's no point in doing so again.
19342 This also avoids a memory leak if we were to call
19343 guess_partial_die_structure_name multiple times. */
19347 /* If we found a reference attribute and the DIE has no name, try
19348 to find a name in the referred to DIE. */
19350 if (name
== NULL
&& has_specification
)
19352 struct partial_die_info
*spec_die
;
19354 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19355 spec_die
= res
.pdi
;
19358 spec_die
->fixup (cu
);
19360 if (spec_die
->name
)
19362 name
= spec_die
->name
;
19364 /* Copy DW_AT_external attribute if it is set. */
19365 if (spec_die
->is_external
)
19366 is_external
= spec_die
->is_external
;
19370 /* Set default names for some unnamed DIEs. */
19372 if (name
== NULL
&& tag
== DW_TAG_namespace
)
19373 name
= CP_ANONYMOUS_NAMESPACE_STR
;
19375 /* If there is no parent die to provide a namespace, and there are
19376 children, see if we can determine the namespace from their linkage
19378 if (cu
->language
== language_cplus
19379 && !cu
->per_cu
->dwarf2_per_objfile
->types
.empty ()
19380 && die_parent
== NULL
19382 && (tag
== DW_TAG_class_type
19383 || tag
== DW_TAG_structure_type
19384 || tag
== DW_TAG_union_type
))
19385 guess_partial_die_structure_name (this, cu
);
19387 /* GCC might emit a nameless struct or union that has a linkage
19388 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19390 && (tag
== DW_TAG_class_type
19391 || tag
== DW_TAG_interface_type
19392 || tag
== DW_TAG_structure_type
19393 || tag
== DW_TAG_union_type
)
19394 && linkage_name
!= NULL
)
19396 gdb::unique_xmalloc_ptr
<char> demangled
19397 (gdb_demangle (linkage_name
, DMGL_TYPES
));
19398 if (demangled
!= nullptr)
19402 /* Strip any leading namespaces/classes, keep only the base name.
19403 DW_AT_name for named DIEs does not contain the prefixes. */
19404 base
= strrchr (demangled
.get (), ':');
19405 if (base
&& base
> demangled
.get () && base
[-1] == ':')
19408 base
= demangled
.get ();
19410 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
19411 name
= obstack_strdup (&objfile
->per_bfd
->storage_obstack
, base
);
19418 /* Read an attribute value described by an attribute form. */
19420 static const gdb_byte
*
19421 read_attribute_value (const struct die_reader_specs
*reader
,
19422 struct attribute
*attr
, unsigned form
,
19423 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
19425 struct dwarf2_cu
*cu
= reader
->cu
;
19426 struct dwarf2_per_objfile
*dwarf2_per_objfile
19427 = cu
->per_cu
->dwarf2_per_objfile
;
19428 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19429 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
19430 bfd
*abfd
= reader
->abfd
;
19431 struct comp_unit_head
*cu_header
= &cu
->header
;
19432 unsigned int bytes_read
;
19433 struct dwarf_block
*blk
;
19435 attr
->form
= (enum dwarf_form
) form
;
19438 case DW_FORM_ref_addr
:
19439 if (cu
->header
.version
== 2)
19440 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
19442 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
19443 &cu
->header
, &bytes_read
);
19444 info_ptr
+= bytes_read
;
19446 case DW_FORM_GNU_ref_alt
:
19447 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
19448 info_ptr
+= bytes_read
;
19451 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
19452 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
19453 info_ptr
+= bytes_read
;
19455 case DW_FORM_block2
:
19456 blk
= dwarf_alloc_block (cu
);
19457 blk
->size
= read_2_bytes (abfd
, info_ptr
);
19459 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19460 info_ptr
+= blk
->size
;
19461 DW_BLOCK (attr
) = blk
;
19463 case DW_FORM_block4
:
19464 blk
= dwarf_alloc_block (cu
);
19465 blk
->size
= read_4_bytes (abfd
, info_ptr
);
19467 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19468 info_ptr
+= blk
->size
;
19469 DW_BLOCK (attr
) = blk
;
19471 case DW_FORM_data2
:
19472 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
19475 case DW_FORM_data4
:
19476 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
19479 case DW_FORM_data8
:
19480 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
19483 case DW_FORM_data16
:
19484 blk
= dwarf_alloc_block (cu
);
19486 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
19488 DW_BLOCK (attr
) = blk
;
19490 case DW_FORM_sec_offset
:
19491 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
19492 info_ptr
+= bytes_read
;
19494 case DW_FORM_string
:
19495 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
19496 DW_STRING_IS_CANONICAL (attr
) = 0;
19497 info_ptr
+= bytes_read
;
19500 if (!cu
->per_cu
->is_dwz
)
19502 DW_STRING (attr
) = read_indirect_string (dwarf2_per_objfile
,
19503 abfd
, info_ptr
, cu_header
,
19505 DW_STRING_IS_CANONICAL (attr
) = 0;
19506 info_ptr
+= bytes_read
;
19510 case DW_FORM_line_strp
:
19511 if (!cu
->per_cu
->is_dwz
)
19513 DW_STRING (attr
) = read_indirect_line_string (dwarf2_per_objfile
,
19515 cu_header
, &bytes_read
);
19516 DW_STRING_IS_CANONICAL (attr
) = 0;
19517 info_ptr
+= bytes_read
;
19521 case DW_FORM_GNU_strp_alt
:
19523 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
19524 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
19527 DW_STRING (attr
) = read_indirect_string_from_dwz (objfile
,
19529 DW_STRING_IS_CANONICAL (attr
) = 0;
19530 info_ptr
+= bytes_read
;
19533 case DW_FORM_exprloc
:
19534 case DW_FORM_block
:
19535 blk
= dwarf_alloc_block (cu
);
19536 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19537 info_ptr
+= bytes_read
;
19538 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19539 info_ptr
+= blk
->size
;
19540 DW_BLOCK (attr
) = blk
;
19542 case DW_FORM_block1
:
19543 blk
= dwarf_alloc_block (cu
);
19544 blk
->size
= read_1_byte (abfd
, info_ptr
);
19546 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19547 info_ptr
+= blk
->size
;
19548 DW_BLOCK (attr
) = blk
;
19550 case DW_FORM_data1
:
19551 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
19555 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
19558 case DW_FORM_flag_present
:
19559 DW_UNSND (attr
) = 1;
19561 case DW_FORM_sdata
:
19562 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19563 info_ptr
+= bytes_read
;
19565 case DW_FORM_udata
:
19566 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19567 info_ptr
+= bytes_read
;
19570 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19571 + read_1_byte (abfd
, info_ptr
));
19575 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19576 + read_2_bytes (abfd
, info_ptr
));
19580 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19581 + read_4_bytes (abfd
, info_ptr
));
19585 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19586 + read_8_bytes (abfd
, info_ptr
));
19589 case DW_FORM_ref_sig8
:
19590 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
19593 case DW_FORM_ref_udata
:
19594 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19595 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
19596 info_ptr
+= bytes_read
;
19598 case DW_FORM_indirect
:
19599 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19600 info_ptr
+= bytes_read
;
19601 if (form
== DW_FORM_implicit_const
)
19603 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19604 info_ptr
+= bytes_read
;
19606 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
19609 case DW_FORM_implicit_const
:
19610 DW_SND (attr
) = implicit_const
;
19612 case DW_FORM_addrx
:
19613 case DW_FORM_GNU_addr_index
:
19614 if (reader
->dwo_file
== NULL
)
19616 /* For now flag a hard error.
19617 Later we can turn this into a complaint. */
19618 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19619 dwarf_form_name (form
),
19620 bfd_get_filename (abfd
));
19622 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
19623 info_ptr
+= bytes_read
;
19626 case DW_FORM_strx1
:
19627 case DW_FORM_strx2
:
19628 case DW_FORM_strx3
:
19629 case DW_FORM_strx4
:
19630 case DW_FORM_GNU_str_index
:
19631 if (reader
->dwo_file
== NULL
)
19633 /* For now flag a hard error.
19634 Later we can turn this into a complaint if warranted. */
19635 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19636 dwarf_form_name (form
),
19637 bfd_get_filename (abfd
));
19640 ULONGEST str_index
;
19641 if (form
== DW_FORM_strx1
)
19643 str_index
= read_1_byte (abfd
, info_ptr
);
19646 else if (form
== DW_FORM_strx2
)
19648 str_index
= read_2_bytes (abfd
, info_ptr
);
19651 else if (form
== DW_FORM_strx3
)
19653 str_index
= read_3_bytes (abfd
, info_ptr
);
19656 else if (form
== DW_FORM_strx4
)
19658 str_index
= read_4_bytes (abfd
, info_ptr
);
19663 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19664 info_ptr
+= bytes_read
;
19666 DW_STRING (attr
) = read_str_index (reader
, str_index
);
19667 DW_STRING_IS_CANONICAL (attr
) = 0;
19671 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19672 dwarf_form_name (form
),
19673 bfd_get_filename (abfd
));
19677 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
19678 attr
->form
= DW_FORM_GNU_ref_alt
;
19680 /* We have seen instances where the compiler tried to emit a byte
19681 size attribute of -1 which ended up being encoded as an unsigned
19682 0xffffffff. Although 0xffffffff is technically a valid size value,
19683 an object of this size seems pretty unlikely so we can relatively
19684 safely treat these cases as if the size attribute was invalid and
19685 treat them as zero by default. */
19686 if (attr
->name
== DW_AT_byte_size
19687 && form
== DW_FORM_data4
19688 && DW_UNSND (attr
) >= 0xffffffff)
19691 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19692 hex_string (DW_UNSND (attr
)));
19693 DW_UNSND (attr
) = 0;
19699 /* Read an attribute described by an abbreviated attribute. */
19701 static const gdb_byte
*
19702 read_attribute (const struct die_reader_specs
*reader
,
19703 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
19704 const gdb_byte
*info_ptr
)
19706 attr
->name
= abbrev
->name
;
19707 return read_attribute_value (reader
, attr
, abbrev
->form
,
19708 abbrev
->implicit_const
, info_ptr
);
19711 /* Read dwarf information from a buffer. */
19713 static unsigned int
19714 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
19716 return bfd_get_8 (abfd
, buf
);
19720 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
19722 return bfd_get_signed_8 (abfd
, buf
);
19725 static unsigned int
19726 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19728 return bfd_get_16 (abfd
, buf
);
19732 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19734 return bfd_get_signed_16 (abfd
, buf
);
19737 static unsigned int
19738 read_3_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19740 unsigned int result
= 0;
19741 for (int i
= 0; i
< 3; ++i
)
19743 unsigned char byte
= bfd_get_8 (abfd
, buf
);
19745 result
|= ((unsigned int) byte
<< (i
* 8));
19750 static unsigned int
19751 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19753 return bfd_get_32 (abfd
, buf
);
19757 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19759 return bfd_get_signed_32 (abfd
, buf
);
19763 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19765 return bfd_get_64 (abfd
, buf
);
19769 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
19770 unsigned int *bytes_read
)
19772 struct comp_unit_head
*cu_header
= &cu
->header
;
19773 CORE_ADDR retval
= 0;
19775 if (cu_header
->signed_addr_p
)
19777 switch (cu_header
->addr_size
)
19780 retval
= bfd_get_signed_16 (abfd
, buf
);
19783 retval
= bfd_get_signed_32 (abfd
, buf
);
19786 retval
= bfd_get_signed_64 (abfd
, buf
);
19789 internal_error (__FILE__
, __LINE__
,
19790 _("read_address: bad switch, signed [in module %s]"),
19791 bfd_get_filename (abfd
));
19796 switch (cu_header
->addr_size
)
19799 retval
= bfd_get_16 (abfd
, buf
);
19802 retval
= bfd_get_32 (abfd
, buf
);
19805 retval
= bfd_get_64 (abfd
, buf
);
19808 internal_error (__FILE__
, __LINE__
,
19809 _("read_address: bad switch, "
19810 "unsigned [in module %s]"),
19811 bfd_get_filename (abfd
));
19815 *bytes_read
= cu_header
->addr_size
;
19819 /* Read the initial length from a section. The (draft) DWARF 3
19820 specification allows the initial length to take up either 4 bytes
19821 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19822 bytes describe the length and all offsets will be 8 bytes in length
19825 An older, non-standard 64-bit format is also handled by this
19826 function. The older format in question stores the initial length
19827 as an 8-byte quantity without an escape value. Lengths greater
19828 than 2^32 aren't very common which means that the initial 4 bytes
19829 is almost always zero. Since a length value of zero doesn't make
19830 sense for the 32-bit format, this initial zero can be considered to
19831 be an escape value which indicates the presence of the older 64-bit
19832 format. As written, the code can't detect (old format) lengths
19833 greater than 4GB. If it becomes necessary to handle lengths
19834 somewhat larger than 4GB, we could allow other small values (such
19835 as the non-sensical values of 1, 2, and 3) to also be used as
19836 escape values indicating the presence of the old format.
19838 The value returned via bytes_read should be used to increment the
19839 relevant pointer after calling read_initial_length().
19841 [ Note: read_initial_length() and read_offset() are based on the
19842 document entitled "DWARF Debugging Information Format", revision
19843 3, draft 8, dated November 19, 2001. This document was obtained
19846 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19848 This document is only a draft and is subject to change. (So beware.)
19850 Details regarding the older, non-standard 64-bit format were
19851 determined empirically by examining 64-bit ELF files produced by
19852 the SGI toolchain on an IRIX 6.5 machine.
19854 - Kevin, July 16, 2002
19858 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
19860 LONGEST length
= bfd_get_32 (abfd
, buf
);
19862 if (length
== 0xffffffff)
19864 length
= bfd_get_64 (abfd
, buf
+ 4);
19867 else if (length
== 0)
19869 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19870 length
= bfd_get_64 (abfd
, buf
);
19881 /* Cover function for read_initial_length.
19882 Returns the length of the object at BUF, and stores the size of the
19883 initial length in *BYTES_READ and stores the size that offsets will be in
19885 If the initial length size is not equivalent to that specified in
19886 CU_HEADER then issue a complaint.
19887 This is useful when reading non-comp-unit headers. */
19890 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
19891 const struct comp_unit_head
*cu_header
,
19892 unsigned int *bytes_read
,
19893 unsigned int *offset_size
)
19895 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
19897 gdb_assert (cu_header
->initial_length_size
== 4
19898 || cu_header
->initial_length_size
== 8
19899 || cu_header
->initial_length_size
== 12);
19901 if (cu_header
->initial_length_size
!= *bytes_read
)
19902 complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19904 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
19908 /* Read an offset from the data stream. The size of the offset is
19909 given by cu_header->offset_size. */
19912 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
19913 const struct comp_unit_head
*cu_header
,
19914 unsigned int *bytes_read
)
19916 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
19918 *bytes_read
= cu_header
->offset_size
;
19922 /* Read an offset from the data stream. */
19925 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
19927 LONGEST retval
= 0;
19929 switch (offset_size
)
19932 retval
= bfd_get_32 (abfd
, buf
);
19935 retval
= bfd_get_64 (abfd
, buf
);
19938 internal_error (__FILE__
, __LINE__
,
19939 _("read_offset_1: bad switch [in module %s]"),
19940 bfd_get_filename (abfd
));
19946 static const gdb_byte
*
19947 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
19949 /* If the size of a host char is 8 bits, we can return a pointer
19950 to the buffer, otherwise we have to copy the data to a buffer
19951 allocated on the temporary obstack. */
19952 gdb_assert (HOST_CHAR_BIT
== 8);
19956 static const char *
19957 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
19958 unsigned int *bytes_read_ptr
)
19960 /* If the size of a host char is 8 bits, we can return a pointer
19961 to the string, otherwise we have to copy the string to a buffer
19962 allocated on the temporary obstack. */
19963 gdb_assert (HOST_CHAR_BIT
== 8);
19966 *bytes_read_ptr
= 1;
19969 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
19970 return (const char *) buf
;
19973 /* Return pointer to string at section SECT offset STR_OFFSET with error
19974 reporting strings FORM_NAME and SECT_NAME. */
19976 static const char *
19977 read_indirect_string_at_offset_from (struct objfile
*objfile
,
19978 bfd
*abfd
, LONGEST str_offset
,
19979 struct dwarf2_section_info
*sect
,
19980 const char *form_name
,
19981 const char *sect_name
)
19983 dwarf2_read_section (objfile
, sect
);
19984 if (sect
->buffer
== NULL
)
19985 error (_("%s used without %s section [in module %s]"),
19986 form_name
, sect_name
, bfd_get_filename (abfd
));
19987 if (str_offset
>= sect
->size
)
19988 error (_("%s pointing outside of %s section [in module %s]"),
19989 form_name
, sect_name
, bfd_get_filename (abfd
));
19990 gdb_assert (HOST_CHAR_BIT
== 8);
19991 if (sect
->buffer
[str_offset
] == '\0')
19993 return (const char *) (sect
->buffer
+ str_offset
);
19996 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19998 static const char *
19999 read_indirect_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
20000 bfd
*abfd
, LONGEST str_offset
)
20002 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
20004 &dwarf2_per_objfile
->str
,
20005 "DW_FORM_strp", ".debug_str");
20008 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
20010 static const char *
20011 read_indirect_line_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
20012 bfd
*abfd
, LONGEST str_offset
)
20014 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
20016 &dwarf2_per_objfile
->line_str
,
20017 "DW_FORM_line_strp",
20018 ".debug_line_str");
20021 /* Read a string at offset STR_OFFSET in the .debug_str section from
20022 the .dwz file DWZ. Throw an error if the offset is too large. If
20023 the string consists of a single NUL byte, return NULL; otherwise
20024 return a pointer to the string. */
20026 static const char *
20027 read_indirect_string_from_dwz (struct objfile
*objfile
, struct dwz_file
*dwz
,
20028 LONGEST str_offset
)
20030 dwarf2_read_section (objfile
, &dwz
->str
);
20032 if (dwz
->str
.buffer
== NULL
)
20033 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
20034 "section [in module %s]"),
20035 bfd_get_filename (dwz
->dwz_bfd
.get ()));
20036 if (str_offset
>= dwz
->str
.size
)
20037 error (_("DW_FORM_GNU_strp_alt pointing outside of "
20038 ".debug_str section [in module %s]"),
20039 bfd_get_filename (dwz
->dwz_bfd
.get ()));
20040 gdb_assert (HOST_CHAR_BIT
== 8);
20041 if (dwz
->str
.buffer
[str_offset
] == '\0')
20043 return (const char *) (dwz
->str
.buffer
+ str_offset
);
20046 /* Return pointer to string at .debug_str offset as read from BUF.
20047 BUF is assumed to be in a compilation unit described by CU_HEADER.
20048 Return *BYTES_READ_PTR count of bytes read from BUF. */
20050 static const char *
20051 read_indirect_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
20052 const gdb_byte
*buf
,
20053 const struct comp_unit_head
*cu_header
,
20054 unsigned int *bytes_read_ptr
)
20056 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
20058 return read_indirect_string_at_offset (dwarf2_per_objfile
, abfd
, str_offset
);
20061 /* Return pointer to string at .debug_line_str offset as read from BUF.
20062 BUF is assumed to be in a compilation unit described by CU_HEADER.
20063 Return *BYTES_READ_PTR count of bytes read from BUF. */
20065 static const char *
20066 read_indirect_line_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
20067 bfd
*abfd
, const gdb_byte
*buf
,
20068 const struct comp_unit_head
*cu_header
,
20069 unsigned int *bytes_read_ptr
)
20071 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
20073 return read_indirect_line_string_at_offset (dwarf2_per_objfile
, abfd
,
20078 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
20079 unsigned int *bytes_read_ptr
)
20082 unsigned int num_read
;
20084 unsigned char byte
;
20091 byte
= bfd_get_8 (abfd
, buf
);
20094 result
|= ((ULONGEST
) (byte
& 127) << shift
);
20095 if ((byte
& 128) == 0)
20101 *bytes_read_ptr
= num_read
;
20106 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
20107 unsigned int *bytes_read_ptr
)
20110 int shift
, num_read
;
20111 unsigned char byte
;
20118 byte
= bfd_get_8 (abfd
, buf
);
20121 result
|= ((ULONGEST
) (byte
& 127) << shift
);
20123 if ((byte
& 128) == 0)
20128 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
20129 result
|= -(((ULONGEST
) 1) << shift
);
20130 *bytes_read_ptr
= num_read
;
20134 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
20135 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
20136 ADDR_SIZE is the size of addresses from the CU header. */
20139 read_addr_index_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
20140 unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
20142 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
20143 bfd
*abfd
= objfile
->obfd
;
20144 const gdb_byte
*info_ptr
;
20146 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
20147 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
20148 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
20149 objfile_name (objfile
));
20150 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
20151 error (_("DW_FORM_addr_index pointing outside of "
20152 ".debug_addr section [in module %s]"),
20153 objfile_name (objfile
));
20154 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
20155 + addr_base
+ addr_index
* addr_size
);
20156 if (addr_size
== 4)
20157 return bfd_get_32 (abfd
, info_ptr
);
20159 return bfd_get_64 (abfd
, info_ptr
);
20162 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
20165 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
20167 return read_addr_index_1 (cu
->per_cu
->dwarf2_per_objfile
, addr_index
,
20168 cu
->addr_base
, cu
->header
.addr_size
);
20171 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
20174 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
20175 unsigned int *bytes_read
)
20177 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
20178 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
20180 return read_addr_index (cu
, addr_index
);
20183 /* Data structure to pass results from dwarf2_read_addr_index_reader
20184 back to dwarf2_read_addr_index. */
20186 struct dwarf2_read_addr_index_data
20188 ULONGEST addr_base
;
20192 /* die_reader_func for dwarf2_read_addr_index. */
20195 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
20196 const gdb_byte
*info_ptr
,
20197 struct die_info
*comp_unit_die
,
20201 struct dwarf2_cu
*cu
= reader
->cu
;
20202 struct dwarf2_read_addr_index_data
*aidata
=
20203 (struct dwarf2_read_addr_index_data
*) data
;
20205 aidata
->addr_base
= cu
->addr_base
;
20206 aidata
->addr_size
= cu
->header
.addr_size
;
20209 /* Given an index in .debug_addr, fetch the value.
20210 NOTE: This can be called during dwarf expression evaluation,
20211 long after the debug information has been read, and thus per_cu->cu
20212 may no longer exist. */
20215 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
20216 unsigned int addr_index
)
20218 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
20219 struct dwarf2_cu
*cu
= per_cu
->cu
;
20220 ULONGEST addr_base
;
20223 /* We need addr_base and addr_size.
20224 If we don't have PER_CU->cu, we have to get it.
20225 Nasty, but the alternative is storing the needed info in PER_CU,
20226 which at this point doesn't seem justified: it's not clear how frequently
20227 it would get used and it would increase the size of every PER_CU.
20228 Entry points like dwarf2_per_cu_addr_size do a similar thing
20229 so we're not in uncharted territory here.
20230 Alas we need to be a bit more complicated as addr_base is contained
20233 We don't need to read the entire CU(/TU).
20234 We just need the header and top level die.
20236 IWBN to use the aging mechanism to let us lazily later discard the CU.
20237 For now we skip this optimization. */
20241 addr_base
= cu
->addr_base
;
20242 addr_size
= cu
->header
.addr_size
;
20246 struct dwarf2_read_addr_index_data aidata
;
20248 /* Note: We can't use init_cutu_and_read_dies_simple here,
20249 we need addr_base. */
20250 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0, false,
20251 dwarf2_read_addr_index_reader
, &aidata
);
20252 addr_base
= aidata
.addr_base
;
20253 addr_size
= aidata
.addr_size
;
20256 return read_addr_index_1 (dwarf2_per_objfile
, addr_index
, addr_base
,
20260 /* Given a DW_FORM_GNU_str_index or DW_FORM_strx, fetch the string.
20261 This is only used by the Fission support. */
20263 static const char *
20264 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
20266 struct dwarf2_cu
*cu
= reader
->cu
;
20267 struct dwarf2_per_objfile
*dwarf2_per_objfile
20268 = cu
->per_cu
->dwarf2_per_objfile
;
20269 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
20270 const char *objf_name
= objfile_name (objfile
);
20271 bfd
*abfd
= objfile
->obfd
;
20272 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
20273 struct dwarf2_section_info
*str_offsets_section
=
20274 &reader
->dwo_file
->sections
.str_offsets
;
20275 const gdb_byte
*info_ptr
;
20276 ULONGEST str_offset
;
20277 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
20279 dwarf2_read_section (objfile
, str_section
);
20280 dwarf2_read_section (objfile
, str_offsets_section
);
20281 if (str_section
->buffer
== NULL
)
20282 error (_("%s used without .debug_str.dwo section"
20283 " in CU at offset %s [in module %s]"),
20284 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20285 if (str_offsets_section
->buffer
== NULL
)
20286 error (_("%s used without .debug_str_offsets.dwo section"
20287 " in CU at offset %s [in module %s]"),
20288 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20289 if (str_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
20290 error (_("%s pointing outside of .debug_str_offsets.dwo"
20291 " section in CU at offset %s [in module %s]"),
20292 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20293 info_ptr
= (str_offsets_section
->buffer
20294 + str_index
* cu
->header
.offset_size
);
20295 if (cu
->header
.offset_size
== 4)
20296 str_offset
= bfd_get_32 (abfd
, info_ptr
);
20298 str_offset
= bfd_get_64 (abfd
, info_ptr
);
20299 if (str_offset
>= str_section
->size
)
20300 error (_("Offset from %s pointing outside of"
20301 " .debug_str.dwo section in CU at offset %s [in module %s]"),
20302 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20303 return (const char *) (str_section
->buffer
+ str_offset
);
20306 /* Return the length of an LEB128 number in BUF. */
20309 leb128_size (const gdb_byte
*buf
)
20311 const gdb_byte
*begin
= buf
;
20317 if ((byte
& 128) == 0)
20318 return buf
- begin
;
20323 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
20332 cu
->language
= language_c
;
20335 case DW_LANG_C_plus_plus
:
20336 case DW_LANG_C_plus_plus_11
:
20337 case DW_LANG_C_plus_plus_14
:
20338 cu
->language
= language_cplus
;
20341 cu
->language
= language_d
;
20343 case DW_LANG_Fortran77
:
20344 case DW_LANG_Fortran90
:
20345 case DW_LANG_Fortran95
:
20346 case DW_LANG_Fortran03
:
20347 case DW_LANG_Fortran08
:
20348 cu
->language
= language_fortran
;
20351 cu
->language
= language_go
;
20353 case DW_LANG_Mips_Assembler
:
20354 cu
->language
= language_asm
;
20356 case DW_LANG_Ada83
:
20357 case DW_LANG_Ada95
:
20358 cu
->language
= language_ada
;
20360 case DW_LANG_Modula2
:
20361 cu
->language
= language_m2
;
20363 case DW_LANG_Pascal83
:
20364 cu
->language
= language_pascal
;
20367 cu
->language
= language_objc
;
20370 case DW_LANG_Rust_old
:
20371 cu
->language
= language_rust
;
20373 case DW_LANG_Cobol74
:
20374 case DW_LANG_Cobol85
:
20376 cu
->language
= language_minimal
;
20379 cu
->language_defn
= language_def (cu
->language
);
20382 /* Return the named attribute or NULL if not there. */
20384 static struct attribute
*
20385 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20390 struct attribute
*spec
= NULL
;
20392 for (i
= 0; i
< die
->num_attrs
; ++i
)
20394 if (die
->attrs
[i
].name
== name
)
20395 return &die
->attrs
[i
];
20396 if (die
->attrs
[i
].name
== DW_AT_specification
20397 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
20398 spec
= &die
->attrs
[i
];
20404 die
= follow_die_ref (die
, spec
, &cu
);
20410 /* Return the named attribute or NULL if not there,
20411 but do not follow DW_AT_specification, etc.
20412 This is for use in contexts where we're reading .debug_types dies.
20413 Following DW_AT_specification, DW_AT_abstract_origin will take us
20414 back up the chain, and we want to go down. */
20416 static struct attribute
*
20417 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
20421 for (i
= 0; i
< die
->num_attrs
; ++i
)
20422 if (die
->attrs
[i
].name
== name
)
20423 return &die
->attrs
[i
];
20428 /* Return the string associated with a string-typed attribute, or NULL if it
20429 is either not found or is of an incorrect type. */
20431 static const char *
20432 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20434 struct attribute
*attr
;
20435 const char *str
= NULL
;
20437 attr
= dwarf2_attr (die
, name
, cu
);
20441 if (attr
->form
== DW_FORM_strp
|| attr
->form
== DW_FORM_line_strp
20442 || attr
->form
== DW_FORM_string
20443 || attr
->form
== DW_FORM_strx
20444 || attr
->form
== DW_FORM_strx1
20445 || attr
->form
== DW_FORM_strx2
20446 || attr
->form
== DW_FORM_strx3
20447 || attr
->form
== DW_FORM_strx4
20448 || attr
->form
== DW_FORM_GNU_str_index
20449 || attr
->form
== DW_FORM_GNU_strp_alt
)
20450 str
= DW_STRING (attr
);
20452 complaint (_("string type expected for attribute %s for "
20453 "DIE at %s in module %s"),
20454 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
20455 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
20461 /* Return the dwo name or NULL if not present. If present, it is in either
20462 DW_AT_GNU_dwo_name or DW_AT_dwo_name attribute. */
20463 static const char *
20464 dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
20466 const char *dwo_name
= dwarf2_string_attr (die
, DW_AT_GNU_dwo_name
, cu
);
20467 if (dwo_name
== nullptr)
20468 dwo_name
= dwarf2_string_attr (die
, DW_AT_dwo_name
, cu
);
20472 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20473 and holds a non-zero value. This function should only be used for
20474 DW_FORM_flag or DW_FORM_flag_present attributes. */
20477 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
20479 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
20481 return (attr
&& DW_UNSND (attr
));
20485 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
20487 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20488 which value is non-zero. However, we have to be careful with
20489 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20490 (via dwarf2_flag_true_p) follows this attribute. So we may
20491 end up accidently finding a declaration attribute that belongs
20492 to a different DIE referenced by the specification attribute,
20493 even though the given DIE does not have a declaration attribute. */
20494 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
20495 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
20498 /* Return the die giving the specification for DIE, if there is
20499 one. *SPEC_CU is the CU containing DIE on input, and the CU
20500 containing the return value on output. If there is no
20501 specification, but there is an abstract origin, that is
20504 static struct die_info
*
20505 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
20507 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
20510 if (spec_attr
== NULL
)
20511 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
20513 if (spec_attr
== NULL
)
20516 return follow_die_ref (die
, spec_attr
, spec_cu
);
20519 /* Stub for free_line_header to match void * callback types. */
20522 free_line_header_voidp (void *arg
)
20524 struct line_header
*lh
= (struct line_header
*) arg
;
20530 line_header::add_include_dir (const char *include_dir
)
20532 if (dwarf_line_debug
>= 2)
20536 new_size
= m_include_dirs
.size ();
20538 new_size
= m_include_dirs
.size () + 1;
20539 fprintf_unfiltered (gdb_stdlog
, "Adding dir %zu: %s\n",
20540 new_size
, include_dir
);
20542 m_include_dirs
.push_back (include_dir
);
20546 line_header::add_file_name (const char *name
,
20548 unsigned int mod_time
,
20549 unsigned int length
)
20551 if (dwarf_line_debug
>= 2)
20555 new_size
= file_names_size ();
20557 new_size
= file_names_size () + 1;
20558 fprintf_unfiltered (gdb_stdlog
, "Adding file %zu: %s\n",
20561 m_file_names
.emplace_back (name
, d_index
, mod_time
, length
);
20564 /* A convenience function to find the proper .debug_line section for a CU. */
20566 static struct dwarf2_section_info
*
20567 get_debug_line_section (struct dwarf2_cu
*cu
)
20569 struct dwarf2_section_info
*section
;
20570 struct dwarf2_per_objfile
*dwarf2_per_objfile
20571 = cu
->per_cu
->dwarf2_per_objfile
;
20573 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20575 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20576 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
20577 else if (cu
->per_cu
->is_dwz
)
20579 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
20581 section
= &dwz
->line
;
20584 section
= &dwarf2_per_objfile
->line
;
20589 /* Read directory or file name entry format, starting with byte of
20590 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20591 entries count and the entries themselves in the described entry
20595 read_formatted_entries (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
20596 bfd
*abfd
, const gdb_byte
**bufp
,
20597 struct line_header
*lh
,
20598 const struct comp_unit_head
*cu_header
,
20599 void (*callback
) (struct line_header
*lh
,
20602 unsigned int mod_time
,
20603 unsigned int length
))
20605 gdb_byte format_count
, formati
;
20606 ULONGEST data_count
, datai
;
20607 const gdb_byte
*buf
= *bufp
;
20608 const gdb_byte
*format_header_data
;
20609 unsigned int bytes_read
;
20611 format_count
= read_1_byte (abfd
, buf
);
20613 format_header_data
= buf
;
20614 for (formati
= 0; formati
< format_count
; formati
++)
20616 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20618 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20622 data_count
= read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20624 for (datai
= 0; datai
< data_count
; datai
++)
20626 const gdb_byte
*format
= format_header_data
;
20627 struct file_entry fe
;
20629 for (formati
= 0; formati
< format_count
; formati
++)
20631 ULONGEST content_type
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
20632 format
+= bytes_read
;
20634 ULONGEST form
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
20635 format
+= bytes_read
;
20637 gdb::optional
<const char *> string
;
20638 gdb::optional
<unsigned int> uint
;
20642 case DW_FORM_string
:
20643 string
.emplace (read_direct_string (abfd
, buf
, &bytes_read
));
20647 case DW_FORM_line_strp
:
20648 string
.emplace (read_indirect_line_string (dwarf2_per_objfile
,
20655 case DW_FORM_data1
:
20656 uint
.emplace (read_1_byte (abfd
, buf
));
20660 case DW_FORM_data2
:
20661 uint
.emplace (read_2_bytes (abfd
, buf
));
20665 case DW_FORM_data4
:
20666 uint
.emplace (read_4_bytes (abfd
, buf
));
20670 case DW_FORM_data8
:
20671 uint
.emplace (read_8_bytes (abfd
, buf
));
20675 case DW_FORM_data16
:
20676 /* This is used for MD5, but file_entry does not record MD5s. */
20680 case DW_FORM_udata
:
20681 uint
.emplace (read_unsigned_leb128 (abfd
, buf
, &bytes_read
));
20685 case DW_FORM_block
:
20686 /* It is valid only for DW_LNCT_timestamp which is ignored by
20691 switch (content_type
)
20694 if (string
.has_value ())
20697 case DW_LNCT_directory_index
:
20698 if (uint
.has_value ())
20699 fe
.d_index
= (dir_index
) *uint
;
20701 case DW_LNCT_timestamp
:
20702 if (uint
.has_value ())
20703 fe
.mod_time
= *uint
;
20706 if (uint
.has_value ())
20712 complaint (_("Unknown format content type %s"),
20713 pulongest (content_type
));
20717 callback (lh
, fe
.name
, fe
.d_index
, fe
.mod_time
, fe
.length
);
20723 /* Read the statement program header starting at OFFSET in
20724 .debug_line, or .debug_line.dwo. Return a pointer
20725 to a struct line_header, allocated using xmalloc.
20726 Returns NULL if there is a problem reading the header, e.g., if it
20727 has a version we don't understand.
20729 NOTE: the strings in the include directory and file name tables of
20730 the returned object point into the dwarf line section buffer,
20731 and must not be freed. */
20733 static line_header_up
20734 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
20736 const gdb_byte
*line_ptr
;
20737 unsigned int bytes_read
, offset_size
;
20739 const char *cur_dir
, *cur_file
;
20740 struct dwarf2_section_info
*section
;
20742 struct dwarf2_per_objfile
*dwarf2_per_objfile
20743 = cu
->per_cu
->dwarf2_per_objfile
;
20745 section
= get_debug_line_section (cu
);
20746 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
20747 if (section
->buffer
== NULL
)
20749 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20750 complaint (_("missing .debug_line.dwo section"));
20752 complaint (_("missing .debug_line section"));
20756 /* We can't do this until we know the section is non-empty.
20757 Only then do we know we have such a section. */
20758 abfd
= get_section_bfd_owner (section
);
20760 /* Make sure that at least there's room for the total_length field.
20761 That could be 12 bytes long, but we're just going to fudge that. */
20762 if (to_underlying (sect_off
) + 4 >= section
->size
)
20764 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20768 line_header_up
lh (new line_header ());
20770 lh
->sect_off
= sect_off
;
20771 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
20773 line_ptr
= section
->buffer
+ to_underlying (sect_off
);
20775 /* Read in the header. */
20777 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
20778 &bytes_read
, &offset_size
);
20779 line_ptr
+= bytes_read
;
20781 const gdb_byte
*start_here
= line_ptr
;
20783 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
20785 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20788 lh
->statement_program_end
= start_here
+ lh
->total_length
;
20789 lh
->version
= read_2_bytes (abfd
, line_ptr
);
20791 if (lh
->version
> 5)
20793 /* This is a version we don't understand. The format could have
20794 changed in ways we don't handle properly so just punt. */
20795 complaint (_("unsupported version in .debug_line section"));
20798 if (lh
->version
>= 5)
20800 gdb_byte segment_selector_size
;
20802 /* Skip address size. */
20803 read_1_byte (abfd
, line_ptr
);
20806 segment_selector_size
= read_1_byte (abfd
, line_ptr
);
20808 if (segment_selector_size
!= 0)
20810 complaint (_("unsupported segment selector size %u "
20811 "in .debug_line section"),
20812 segment_selector_size
);
20816 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
20817 line_ptr
+= offset_size
;
20818 lh
->statement_program_start
= line_ptr
+ lh
->header_length
;
20819 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
20821 if (lh
->version
>= 4)
20823 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
20827 lh
->maximum_ops_per_instruction
= 1;
20829 if (lh
->maximum_ops_per_instruction
== 0)
20831 lh
->maximum_ops_per_instruction
= 1;
20832 complaint (_("invalid maximum_ops_per_instruction "
20833 "in `.debug_line' section"));
20836 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
20838 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
20840 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
20842 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
20844 lh
->standard_opcode_lengths
.reset (new unsigned char[lh
->opcode_base
]);
20846 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
20847 for (i
= 1; i
< lh
->opcode_base
; ++i
)
20849 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
20853 if (lh
->version
>= 5)
20855 /* Read directory table. */
20856 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
20858 [] (struct line_header
*header
, const char *name
,
20859 dir_index d_index
, unsigned int mod_time
,
20860 unsigned int length
)
20862 header
->add_include_dir (name
);
20865 /* Read file name table. */
20866 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
20868 [] (struct line_header
*header
, const char *name
,
20869 dir_index d_index
, unsigned int mod_time
,
20870 unsigned int length
)
20872 header
->add_file_name (name
, d_index
, mod_time
, length
);
20877 /* Read directory table. */
20878 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
20880 line_ptr
+= bytes_read
;
20881 lh
->add_include_dir (cur_dir
);
20883 line_ptr
+= bytes_read
;
20885 /* Read file name table. */
20886 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
20888 unsigned int mod_time
, length
;
20891 line_ptr
+= bytes_read
;
20892 d_index
= (dir_index
) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20893 line_ptr
+= bytes_read
;
20894 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20895 line_ptr
+= bytes_read
;
20896 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20897 line_ptr
+= bytes_read
;
20899 lh
->add_file_name (cur_file
, d_index
, mod_time
, length
);
20901 line_ptr
+= bytes_read
;
20904 if (line_ptr
> (section
->buffer
+ section
->size
))
20905 complaint (_("line number info header doesn't "
20906 "fit in `.debug_line' section"));
20911 /* Subroutine of dwarf_decode_lines to simplify it.
20912 Return the file name of the psymtab for the given file_entry.
20913 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20914 If space for the result is malloc'd, *NAME_HOLDER will be set.
20915 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20917 static const char *
20918 psymtab_include_file_name (const struct line_header
*lh
, const file_entry
&fe
,
20919 const struct partial_symtab
*pst
,
20920 const char *comp_dir
,
20921 gdb::unique_xmalloc_ptr
<char> *name_holder
)
20923 const char *include_name
= fe
.name
;
20924 const char *include_name_to_compare
= include_name
;
20925 const char *pst_filename
;
20928 const char *dir_name
= fe
.include_dir (lh
);
20930 gdb::unique_xmalloc_ptr
<char> hold_compare
;
20931 if (!IS_ABSOLUTE_PATH (include_name
)
20932 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
20934 /* Avoid creating a duplicate psymtab for PST.
20935 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20936 Before we do the comparison, however, we need to account
20937 for DIR_NAME and COMP_DIR.
20938 First prepend dir_name (if non-NULL). If we still don't
20939 have an absolute path prepend comp_dir (if non-NULL).
20940 However, the directory we record in the include-file's
20941 psymtab does not contain COMP_DIR (to match the
20942 corresponding symtab(s)).
20947 bash$ gcc -g ./hello.c
20948 include_name = "hello.c"
20950 DW_AT_comp_dir = comp_dir = "/tmp"
20951 DW_AT_name = "./hello.c"
20955 if (dir_name
!= NULL
)
20957 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
20958 include_name
, (char *) NULL
));
20959 include_name
= name_holder
->get ();
20960 include_name_to_compare
= include_name
;
20962 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
20964 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
20965 include_name
, (char *) NULL
));
20966 include_name_to_compare
= hold_compare
.get ();
20970 pst_filename
= pst
->filename
;
20971 gdb::unique_xmalloc_ptr
<char> copied_name
;
20972 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
20974 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
20975 pst_filename
, (char *) NULL
));
20976 pst_filename
= copied_name
.get ();
20979 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
20983 return include_name
;
20986 /* State machine to track the state of the line number program. */
20988 class lnp_state_machine
20991 /* Initialize a machine state for the start of a line number
20993 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
20994 bool record_lines_p
);
20996 file_entry
*current_file ()
20998 /* lh->file_names is 0-based, but the file name numbers in the
20999 statement program are 1-based. */
21000 return m_line_header
->file_name_at (m_file
);
21003 /* Record the line in the state machine. END_SEQUENCE is true if
21004 we're processing the end of a sequence. */
21005 void record_line (bool end_sequence
);
21007 /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
21008 nop-out rest of the lines in this sequence. */
21009 void check_line_address (struct dwarf2_cu
*cu
,
21010 const gdb_byte
*line_ptr
,
21011 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
21013 void handle_set_discriminator (unsigned int discriminator
)
21015 m_discriminator
= discriminator
;
21016 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
21019 /* Handle DW_LNE_set_address. */
21020 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
21023 address
+= baseaddr
;
21024 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
21027 /* Handle DW_LNS_advance_pc. */
21028 void handle_advance_pc (CORE_ADDR adjust
);
21030 /* Handle a special opcode. */
21031 void handle_special_opcode (unsigned char op_code
);
21033 /* Handle DW_LNS_advance_line. */
21034 void handle_advance_line (int line_delta
)
21036 advance_line (line_delta
);
21039 /* Handle DW_LNS_set_file. */
21040 void handle_set_file (file_name_index file
);
21042 /* Handle DW_LNS_negate_stmt. */
21043 void handle_negate_stmt ()
21045 m_is_stmt
= !m_is_stmt
;
21048 /* Handle DW_LNS_const_add_pc. */
21049 void handle_const_add_pc ();
21051 /* Handle DW_LNS_fixed_advance_pc. */
21052 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
21054 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21058 /* Handle DW_LNS_copy. */
21059 void handle_copy ()
21061 record_line (false);
21062 m_discriminator
= 0;
21065 /* Handle DW_LNE_end_sequence. */
21066 void handle_end_sequence ()
21068 m_currently_recording_lines
= true;
21072 /* Advance the line by LINE_DELTA. */
21073 void advance_line (int line_delta
)
21075 m_line
+= line_delta
;
21077 if (line_delta
!= 0)
21078 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
21081 struct dwarf2_cu
*m_cu
;
21083 gdbarch
*m_gdbarch
;
21085 /* True if we're recording lines.
21086 Otherwise we're building partial symtabs and are just interested in
21087 finding include files mentioned by the line number program. */
21088 bool m_record_lines_p
;
21090 /* The line number header. */
21091 line_header
*m_line_header
;
21093 /* These are part of the standard DWARF line number state machine,
21094 and initialized according to the DWARF spec. */
21096 unsigned char m_op_index
= 0;
21097 /* The line table index of the current file. */
21098 file_name_index m_file
= 1;
21099 unsigned int m_line
= 1;
21101 /* These are initialized in the constructor. */
21103 CORE_ADDR m_address
;
21105 unsigned int m_discriminator
;
21107 /* Additional bits of state we need to track. */
21109 /* The last file that we called dwarf2_start_subfile for.
21110 This is only used for TLLs. */
21111 unsigned int m_last_file
= 0;
21112 /* The last file a line number was recorded for. */
21113 struct subfile
*m_last_subfile
= NULL
;
21115 /* When true, record the lines we decode. */
21116 bool m_currently_recording_lines
= false;
21118 /* The last line number that was recorded, used to coalesce
21119 consecutive entries for the same line. This can happen, for
21120 example, when discriminators are present. PR 17276. */
21121 unsigned int m_last_line
= 0;
21122 bool m_line_has_non_zero_discriminator
= false;
21126 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
21128 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
21129 / m_line_header
->maximum_ops_per_instruction
)
21130 * m_line_header
->minimum_instruction_length
);
21131 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21132 m_op_index
= ((m_op_index
+ adjust
)
21133 % m_line_header
->maximum_ops_per_instruction
);
21137 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
21139 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
21140 CORE_ADDR addr_adj
= (((m_op_index
21141 + (adj_opcode
/ m_line_header
->line_range
))
21142 / m_line_header
->maximum_ops_per_instruction
)
21143 * m_line_header
->minimum_instruction_length
);
21144 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21145 m_op_index
= ((m_op_index
+ (adj_opcode
/ m_line_header
->line_range
))
21146 % m_line_header
->maximum_ops_per_instruction
);
21148 int line_delta
= (m_line_header
->line_base
21149 + (adj_opcode
% m_line_header
->line_range
));
21150 advance_line (line_delta
);
21151 record_line (false);
21152 m_discriminator
= 0;
21156 lnp_state_machine::handle_set_file (file_name_index file
)
21160 const file_entry
*fe
= current_file ();
21162 dwarf2_debug_line_missing_file_complaint ();
21163 else if (m_record_lines_p
)
21165 const char *dir
= fe
->include_dir (m_line_header
);
21167 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21168 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
21169 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
21174 lnp_state_machine::handle_const_add_pc ()
21177 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
21180 = (((m_op_index
+ adjust
)
21181 / m_line_header
->maximum_ops_per_instruction
)
21182 * m_line_header
->minimum_instruction_length
);
21184 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
21185 m_op_index
= ((m_op_index
+ adjust
)
21186 % m_line_header
->maximum_ops_per_instruction
);
21189 /* Return non-zero if we should add LINE to the line number table.
21190 LINE is the line to add, LAST_LINE is the last line that was added,
21191 LAST_SUBFILE is the subfile for LAST_LINE.
21192 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
21193 had a non-zero discriminator.
21195 We have to be careful in the presence of discriminators.
21196 E.g., for this line:
21198 for (i = 0; i < 100000; i++);
21200 clang can emit four line number entries for that one line,
21201 each with a different discriminator.
21202 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
21204 However, we want gdb to coalesce all four entries into one.
21205 Otherwise the user could stepi into the middle of the line and
21206 gdb would get confused about whether the pc really was in the
21207 middle of the line.
21209 Things are further complicated by the fact that two consecutive
21210 line number entries for the same line is a heuristic used by gcc
21211 to denote the end of the prologue. So we can't just discard duplicate
21212 entries, we have to be selective about it. The heuristic we use is
21213 that we only collapse consecutive entries for the same line if at least
21214 one of those entries has a non-zero discriminator. PR 17276.
21216 Note: Addresses in the line number state machine can never go backwards
21217 within one sequence, thus this coalescing is ok. */
21220 dwarf_record_line_p (struct dwarf2_cu
*cu
,
21221 unsigned int line
, unsigned int last_line
,
21222 int line_has_non_zero_discriminator
,
21223 struct subfile
*last_subfile
)
21225 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
21227 if (line
!= last_line
)
21229 /* Same line for the same file that we've seen already.
21230 As a last check, for pr 17276, only record the line if the line
21231 has never had a non-zero discriminator. */
21232 if (!line_has_non_zero_discriminator
)
21237 /* Use the CU's builder to record line number LINE beginning at
21238 address ADDRESS in the line table of subfile SUBFILE. */
21241 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21242 unsigned int line
, CORE_ADDR address
,
21243 struct dwarf2_cu
*cu
)
21245 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
21247 if (dwarf_line_debug
)
21249 fprintf_unfiltered (gdb_stdlog
,
21250 "Recording line %u, file %s, address %s\n",
21251 line
, lbasename (subfile
->name
),
21252 paddress (gdbarch
, address
));
21256 cu
->get_builder ()->record_line (subfile
, line
, addr
);
21259 /* Subroutine of dwarf_decode_lines_1 to simplify it.
21260 Mark the end of a set of line number records.
21261 The arguments are the same as for dwarf_record_line_1.
21262 If SUBFILE is NULL the request is ignored. */
21265 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21266 CORE_ADDR address
, struct dwarf2_cu
*cu
)
21268 if (subfile
== NULL
)
21271 if (dwarf_line_debug
)
21273 fprintf_unfiltered (gdb_stdlog
,
21274 "Finishing current line, file %s, address %s\n",
21275 lbasename (subfile
->name
),
21276 paddress (gdbarch
, address
));
21279 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, cu
);
21283 lnp_state_machine::record_line (bool end_sequence
)
21285 if (dwarf_line_debug
)
21287 fprintf_unfiltered (gdb_stdlog
,
21288 "Processing actual line %u: file %u,"
21289 " address %s, is_stmt %u, discrim %u\n",
21291 paddress (m_gdbarch
, m_address
),
21292 m_is_stmt
, m_discriminator
);
21295 file_entry
*fe
= current_file ();
21298 dwarf2_debug_line_missing_file_complaint ();
21299 /* For now we ignore lines not starting on an instruction boundary.
21300 But not when processing end_sequence for compatibility with the
21301 previous version of the code. */
21302 else if (m_op_index
== 0 || end_sequence
)
21304 fe
->included_p
= 1;
21305 if (m_record_lines_p
&& (producer_is_codewarrior (m_cu
) || m_is_stmt
))
21307 if (m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ()
21310 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
21311 m_currently_recording_lines
? m_cu
: nullptr);
21316 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
21317 m_line_has_non_zero_discriminator
,
21320 buildsym_compunit
*builder
= m_cu
->get_builder ();
21321 dwarf_record_line_1 (m_gdbarch
,
21322 builder
->get_current_subfile (),
21324 m_currently_recording_lines
? m_cu
: nullptr);
21326 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21327 m_last_line
= m_line
;
21333 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
21334 line_header
*lh
, bool record_lines_p
)
21338 m_record_lines_p
= record_lines_p
;
21339 m_line_header
= lh
;
21341 m_currently_recording_lines
= true;
21343 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
21344 was a line entry for it so that the backend has a chance to adjust it
21345 and also record it in case it needs it. This is currently used by MIPS
21346 code, cf. `mips_adjust_dwarf2_line'. */
21347 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
21348 m_is_stmt
= lh
->default_is_stmt
;
21349 m_discriminator
= 0;
21353 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
21354 const gdb_byte
*line_ptr
,
21355 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
21357 /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
21358 the pc range of the CU. However, we restrict the test to only ADDRESS
21359 values of zero to preserve GDB's previous behaviour which is to handle
21360 the specific case of a function being GC'd by the linker. */
21362 if (address
== 0 && address
< unrelocated_lowpc
)
21364 /* This line table is for a function which has been
21365 GCd by the linker. Ignore it. PR gdb/12528 */
21367 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21368 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
21370 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21371 line_offset
, objfile_name (objfile
));
21372 m_currently_recording_lines
= false;
21373 /* Note: m_currently_recording_lines is left as false until we see
21374 DW_LNE_end_sequence. */
21378 /* Subroutine of dwarf_decode_lines to simplify it.
21379 Process the line number information in LH.
21380 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21381 program in order to set included_p for every referenced header. */
21384 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
21385 const int decode_for_pst_p
, CORE_ADDR lowpc
)
21387 const gdb_byte
*line_ptr
, *extended_end
;
21388 const gdb_byte
*line_end
;
21389 unsigned int bytes_read
, extended_len
;
21390 unsigned char op_code
, extended_op
;
21391 CORE_ADDR baseaddr
;
21392 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21393 bfd
*abfd
= objfile
->obfd
;
21394 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
21395 /* True if we're recording line info (as opposed to building partial
21396 symtabs and just interested in finding include files mentioned by
21397 the line number program). */
21398 bool record_lines_p
= !decode_for_pst_p
;
21400 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21402 line_ptr
= lh
->statement_program_start
;
21403 line_end
= lh
->statement_program_end
;
21405 /* Read the statement sequences until there's nothing left. */
21406 while (line_ptr
< line_end
)
21408 /* The DWARF line number program state machine. Reset the state
21409 machine at the start of each sequence. */
21410 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
21411 bool end_sequence
= false;
21413 if (record_lines_p
)
21415 /* Start a subfile for the current file of the state
21417 const file_entry
*fe
= state_machine
.current_file ();
21420 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
21423 /* Decode the table. */
21424 while (line_ptr
< line_end
&& !end_sequence
)
21426 op_code
= read_1_byte (abfd
, line_ptr
);
21429 if (op_code
>= lh
->opcode_base
)
21431 /* Special opcode. */
21432 state_machine
.handle_special_opcode (op_code
);
21434 else switch (op_code
)
21436 case DW_LNS_extended_op
:
21437 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
21439 line_ptr
+= bytes_read
;
21440 extended_end
= line_ptr
+ extended_len
;
21441 extended_op
= read_1_byte (abfd
, line_ptr
);
21443 switch (extended_op
)
21445 case DW_LNE_end_sequence
:
21446 state_machine
.handle_end_sequence ();
21447 end_sequence
= true;
21449 case DW_LNE_set_address
:
21452 = read_address (abfd
, line_ptr
, cu
, &bytes_read
);
21453 line_ptr
+= bytes_read
;
21455 state_machine
.check_line_address (cu
, line_ptr
,
21456 lowpc
- baseaddr
, address
);
21457 state_machine
.handle_set_address (baseaddr
, address
);
21460 case DW_LNE_define_file
:
21462 const char *cur_file
;
21463 unsigned int mod_time
, length
;
21466 cur_file
= read_direct_string (abfd
, line_ptr
,
21468 line_ptr
+= bytes_read
;
21469 dindex
= (dir_index
)
21470 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21471 line_ptr
+= bytes_read
;
21473 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21474 line_ptr
+= bytes_read
;
21476 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21477 line_ptr
+= bytes_read
;
21478 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21481 case DW_LNE_set_discriminator
:
21483 /* The discriminator is not interesting to the
21484 debugger; just ignore it. We still need to
21485 check its value though:
21486 if there are consecutive entries for the same
21487 (non-prologue) line we want to coalesce them.
21490 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21491 line_ptr
+= bytes_read
;
21493 state_machine
.handle_set_discriminator (discr
);
21497 complaint (_("mangled .debug_line section"));
21500 /* Make sure that we parsed the extended op correctly. If e.g.
21501 we expected a different address size than the producer used,
21502 we may have read the wrong number of bytes. */
21503 if (line_ptr
!= extended_end
)
21505 complaint (_("mangled .debug_line section"));
21510 state_machine
.handle_copy ();
21512 case DW_LNS_advance_pc
:
21515 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21516 line_ptr
+= bytes_read
;
21518 state_machine
.handle_advance_pc (adjust
);
21521 case DW_LNS_advance_line
:
21524 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21525 line_ptr
+= bytes_read
;
21527 state_machine
.handle_advance_line (line_delta
);
21530 case DW_LNS_set_file
:
21532 file_name_index file
21533 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21535 line_ptr
+= bytes_read
;
21537 state_machine
.handle_set_file (file
);
21540 case DW_LNS_set_column
:
21541 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21542 line_ptr
+= bytes_read
;
21544 case DW_LNS_negate_stmt
:
21545 state_machine
.handle_negate_stmt ();
21547 case DW_LNS_set_basic_block
:
21549 /* Add to the address register of the state machine the
21550 address increment value corresponding to special opcode
21551 255. I.e., this value is scaled by the minimum
21552 instruction length since special opcode 255 would have
21553 scaled the increment. */
21554 case DW_LNS_const_add_pc
:
21555 state_machine
.handle_const_add_pc ();
21557 case DW_LNS_fixed_advance_pc
:
21559 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21562 state_machine
.handle_fixed_advance_pc (addr_adj
);
21567 /* Unknown standard opcode, ignore it. */
21570 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21572 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21573 line_ptr
+= bytes_read
;
21580 dwarf2_debug_line_missing_end_sequence_complaint ();
21582 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21583 in which case we still finish recording the last line). */
21584 state_machine
.record_line (true);
21588 /* Decode the Line Number Program (LNP) for the given line_header
21589 structure and CU. The actual information extracted and the type
21590 of structures created from the LNP depends on the value of PST.
21592 1. If PST is NULL, then this procedure uses the data from the program
21593 to create all necessary symbol tables, and their linetables.
21595 2. If PST is not NULL, this procedure reads the program to determine
21596 the list of files included by the unit represented by PST, and
21597 builds all the associated partial symbol tables.
21599 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21600 It is used for relative paths in the line table.
21601 NOTE: When processing partial symtabs (pst != NULL),
21602 comp_dir == pst->dirname.
21604 NOTE: It is important that psymtabs have the same file name (via strcmp)
21605 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21606 symtab we don't use it in the name of the psymtabs we create.
21607 E.g. expand_line_sal requires this when finding psymtabs to expand.
21608 A good testcase for this is mb-inline.exp.
21610 LOWPC is the lowest address in CU (or 0 if not known).
21612 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21613 for its PC<->lines mapping information. Otherwise only the filename
21614 table is read in. */
21617 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21618 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
21619 CORE_ADDR lowpc
, int decode_mapping
)
21621 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21622 const int decode_for_pst_p
= (pst
!= NULL
);
21624 if (decode_mapping
)
21625 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21627 if (decode_for_pst_p
)
21629 /* Now that we're done scanning the Line Header Program, we can
21630 create the psymtab of each included file. */
21631 for (auto &file_entry
: lh
->file_names ())
21632 if (file_entry
.included_p
== 1)
21634 gdb::unique_xmalloc_ptr
<char> name_holder
;
21635 const char *include_name
=
21636 psymtab_include_file_name (lh
, file_entry
, pst
,
21637 comp_dir
, &name_holder
);
21638 if (include_name
!= NULL
)
21639 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
21644 /* Make sure a symtab is created for every file, even files
21645 which contain only variables (i.e. no code with associated
21647 buildsym_compunit
*builder
= cu
->get_builder ();
21648 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21650 for (auto &fe
: lh
->file_names ())
21652 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21653 if (builder
->get_current_subfile ()->symtab
== NULL
)
21655 builder
->get_current_subfile ()->symtab
21656 = allocate_symtab (cust
,
21657 builder
->get_current_subfile ()->name
);
21659 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21664 /* Start a subfile for DWARF. FILENAME is the name of the file and
21665 DIRNAME the name of the source directory which contains FILENAME
21666 or NULL if not known.
21667 This routine tries to keep line numbers from identical absolute and
21668 relative file names in a common subfile.
21670 Using the `list' example from the GDB testsuite, which resides in
21671 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21672 of /srcdir/list0.c yields the following debugging information for list0.c:
21674 DW_AT_name: /srcdir/list0.c
21675 DW_AT_comp_dir: /compdir
21676 files.files[0].name: list0.h
21677 files.files[0].dir: /srcdir
21678 files.files[1].name: list0.c
21679 files.files[1].dir: /srcdir
21681 The line number information for list0.c has to end up in a single
21682 subfile, so that `break /srcdir/list0.c:1' works as expected.
21683 start_subfile will ensure that this happens provided that we pass the
21684 concatenation of files.files[1].dir and files.files[1].name as the
21688 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
21689 const char *dirname
)
21691 gdb::unique_xmalloc_ptr
<char> copy
;
21693 /* In order not to lose the line information directory,
21694 we concatenate it to the filename when it makes sense.
21695 Note that the Dwarf3 standard says (speaking of filenames in line
21696 information): ``The directory index is ignored for file names
21697 that represent full path names''. Thus ignoring dirname in the
21698 `else' branch below isn't an issue. */
21700 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
21702 copy
.reset (concat (dirname
, SLASH_STRING
, filename
, (char *) NULL
));
21703 filename
= copy
.get ();
21706 cu
->get_builder ()->start_subfile (filename
);
21709 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21710 buildsym_compunit constructor. */
21712 struct compunit_symtab
*
21713 dwarf2_cu::start_symtab (const char *name
, const char *comp_dir
,
21716 gdb_assert (m_builder
== nullptr);
21718 m_builder
.reset (new struct buildsym_compunit
21719 (per_cu
->dwarf2_per_objfile
->objfile
,
21720 name
, comp_dir
, language
, low_pc
));
21722 list_in_scope
= get_builder ()->get_file_symbols ();
21724 get_builder ()->record_debugformat ("DWARF 2");
21725 get_builder ()->record_producer (producer
);
21727 processing_has_namespace_info
= false;
21729 return get_builder ()->get_compunit_symtab ();
21733 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
21734 struct dwarf2_cu
*cu
)
21736 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21737 struct comp_unit_head
*cu_header
= &cu
->header
;
21739 /* NOTE drow/2003-01-30: There used to be a comment and some special
21740 code here to turn a symbol with DW_AT_external and a
21741 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21742 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21743 with some versions of binutils) where shared libraries could have
21744 relocations against symbols in their debug information - the
21745 minimal symbol would have the right address, but the debug info
21746 would not. It's no longer necessary, because we will explicitly
21747 apply relocations when we read in the debug information now. */
21749 /* A DW_AT_location attribute with no contents indicates that a
21750 variable has been optimized away. */
21751 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
21753 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21757 /* Handle one degenerate form of location expression specially, to
21758 preserve GDB's previous behavior when section offsets are
21759 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
21760 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
21762 if (attr_form_is_block (attr
)
21763 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
21764 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
21765 || ((DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
21766 || DW_BLOCK (attr
)->data
[0] == DW_OP_addrx
)
21767 && (DW_BLOCK (attr
)->size
21768 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
21770 unsigned int dummy
;
21772 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
21773 SET_SYMBOL_VALUE_ADDRESS (sym
,
21774 read_address (objfile
->obfd
,
21775 DW_BLOCK (attr
)->data
+ 1,
21778 SET_SYMBOL_VALUE_ADDRESS
21779 (sym
, read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1,
21781 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
21782 fixup_symbol_section (sym
, objfile
);
21783 SET_SYMBOL_VALUE_ADDRESS (sym
,
21784 SYMBOL_VALUE_ADDRESS (sym
)
21785 + ANOFFSET (objfile
->section_offsets
,
21786 SYMBOL_SECTION (sym
)));
21790 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21791 expression evaluator, and use LOC_COMPUTED only when necessary
21792 (i.e. when the value of a register or memory location is
21793 referenced, or a thread-local block, etc.). Then again, it might
21794 not be worthwhile. I'm assuming that it isn't unless performance
21795 or memory numbers show me otherwise. */
21797 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
21799 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
21800 cu
->has_loclist
= true;
21803 /* Given a pointer to a DWARF information entry, figure out if we need
21804 to make a symbol table entry for it, and if so, create a new entry
21805 and return a pointer to it.
21806 If TYPE is NULL, determine symbol type from the die, otherwise
21807 used the passed type.
21808 If SPACE is not NULL, use it to hold the new symbol. If it is
21809 NULL, allocate a new symbol on the objfile's obstack. */
21811 static struct symbol
*
21812 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
21813 struct symbol
*space
)
21815 struct dwarf2_per_objfile
*dwarf2_per_objfile
21816 = cu
->per_cu
->dwarf2_per_objfile
;
21817 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21818 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
21819 struct symbol
*sym
= NULL
;
21821 struct attribute
*attr
= NULL
;
21822 struct attribute
*attr2
= NULL
;
21823 CORE_ADDR baseaddr
;
21824 struct pending
**list_to_add
= NULL
;
21826 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
21828 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21830 name
= dwarf2_name (die
, cu
);
21833 const char *linkagename
;
21834 int suppress_add
= 0;
21839 sym
= allocate_symbol (objfile
);
21840 OBJSTAT (objfile
, n_syms
++);
21842 /* Cache this symbol's name and the name's demangled form (if any). */
21843 sym
->set_language (cu
->language
, &objfile
->objfile_obstack
);
21844 linkagename
= dwarf2_physname (name
, die
, cu
);
21845 sym
->compute_and_set_names (linkagename
, false, objfile
->per_bfd
);
21847 /* Fortran does not have mangling standard and the mangling does differ
21848 between gfortran, iFort etc. */
21849 if (cu
->language
== language_fortran
21850 && symbol_get_demangled_name (sym
) == NULL
)
21851 symbol_set_demangled_name (sym
,
21852 dwarf2_full_name (name
, die
, cu
),
21855 /* Default assumptions.
21856 Use the passed type or decode it from the die. */
21857 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21858 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21860 SYMBOL_TYPE (sym
) = type
;
21862 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
21863 attr
= dwarf2_attr (die
,
21864 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
21866 if (attr
!= nullptr)
21868 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
21871 attr
= dwarf2_attr (die
,
21872 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
21874 if (attr
!= nullptr)
21876 file_name_index file_index
= (file_name_index
) DW_UNSND (attr
);
21877 struct file_entry
*fe
;
21879 if (cu
->line_header
!= NULL
)
21880 fe
= cu
->line_header
->file_name_at (file_index
);
21885 complaint (_("file index out of range"));
21887 symbol_set_symtab (sym
, fe
->symtab
);
21893 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
21894 if (attr
!= nullptr)
21898 addr
= attr_value_as_address (attr
);
21899 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
21900 SET_SYMBOL_VALUE_ADDRESS (sym
, addr
);
21902 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
21903 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
21904 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
21905 add_symbol_to_list (sym
, cu
->list_in_scope
);
21907 case DW_TAG_subprogram
:
21908 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21910 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21911 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21912 if ((attr2
&& (DW_UNSND (attr2
) != 0))
21913 || cu
->language
== language_ada
21914 || cu
->language
== language_fortran
)
21916 /* Subprograms marked external are stored as a global symbol.
21917 Ada and Fortran subprograms, whether marked external or
21918 not, are always stored as a global symbol, because we want
21919 to be able to access them globally. For instance, we want
21920 to be able to break on a nested subprogram without having
21921 to specify the context. */
21922 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21926 list_to_add
= cu
->list_in_scope
;
21929 case DW_TAG_inlined_subroutine
:
21930 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21932 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21933 SYMBOL_INLINED (sym
) = 1;
21934 list_to_add
= cu
->list_in_scope
;
21936 case DW_TAG_template_value_param
:
21938 /* Fall through. */
21939 case DW_TAG_constant
:
21940 case DW_TAG_variable
:
21941 case DW_TAG_member
:
21942 /* Compilation with minimal debug info may result in
21943 variables with missing type entries. Change the
21944 misleading `void' type to something sensible. */
21945 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
21946 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
21948 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21949 /* In the case of DW_TAG_member, we should only be called for
21950 static const members. */
21951 if (die
->tag
== DW_TAG_member
)
21953 /* dwarf2_add_field uses die_is_declaration,
21954 so we do the same. */
21955 gdb_assert (die_is_declaration (die
, cu
));
21958 if (attr
!= nullptr)
21960 dwarf2_const_value (attr
, sym
, cu
);
21961 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21964 if (attr2
&& (DW_UNSND (attr2
) != 0))
21965 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21967 list_to_add
= cu
->list_in_scope
;
21971 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21972 if (attr
!= nullptr)
21974 var_decode_location (attr
, sym
, cu
);
21975 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21977 /* Fortran explicitly imports any global symbols to the local
21978 scope by DW_TAG_common_block. */
21979 if (cu
->language
== language_fortran
&& die
->parent
21980 && die
->parent
->tag
== DW_TAG_common_block
)
21983 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21984 && SYMBOL_VALUE_ADDRESS (sym
) == 0
21985 && !dwarf2_per_objfile
->has_section_at_zero
)
21987 /* When a static variable is eliminated by the linker,
21988 the corresponding debug information is not stripped
21989 out, but the variable address is set to null;
21990 do not add such variables into symbol table. */
21992 else if (attr2
&& (DW_UNSND (attr2
) != 0))
21994 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21995 && (objfile
->flags
& OBJF_MAINLINE
) == 0
21996 && dwarf2_per_objfile
->can_copy
)
21998 /* A global static variable might be subject to
21999 copy relocation. We first check for a local
22000 minsym, though, because maybe the symbol was
22001 marked hidden, in which case this would not
22003 bound_minimal_symbol found
22004 = (lookup_minimal_symbol_linkage
22005 (sym
->linkage_name (), objfile
));
22006 if (found
.minsym
!= nullptr)
22007 sym
->maybe_copied
= 1;
22010 /* A variable with DW_AT_external is never static,
22011 but it may be block-scoped. */
22013 = ((cu
->list_in_scope
22014 == cu
->get_builder ()->get_file_symbols ())
22015 ? cu
->get_builder ()->get_global_symbols ()
22016 : cu
->list_in_scope
);
22019 list_to_add
= cu
->list_in_scope
;
22023 /* We do not know the address of this symbol.
22024 If it is an external symbol and we have type information
22025 for it, enter the symbol as a LOC_UNRESOLVED symbol.
22026 The address of the variable will then be determined from
22027 the minimal symbol table whenever the variable is
22029 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
22031 /* Fortran explicitly imports any global symbols to the local
22032 scope by DW_TAG_common_block. */
22033 if (cu
->language
== language_fortran
&& die
->parent
22034 && die
->parent
->tag
== DW_TAG_common_block
)
22036 /* SYMBOL_CLASS doesn't matter here because
22037 read_common_block is going to reset it. */
22039 list_to_add
= cu
->list_in_scope
;
22041 else if (attr2
&& (DW_UNSND (attr2
) != 0)
22042 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
22044 /* A variable with DW_AT_external is never static, but it
22045 may be block-scoped. */
22047 = ((cu
->list_in_scope
22048 == cu
->get_builder ()->get_file_symbols ())
22049 ? cu
->get_builder ()->get_global_symbols ()
22050 : cu
->list_in_scope
);
22052 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
22054 else if (!die_is_declaration (die
, cu
))
22056 /* Use the default LOC_OPTIMIZED_OUT class. */
22057 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
22059 list_to_add
= cu
->list_in_scope
;
22063 case DW_TAG_formal_parameter
:
22065 /* If we are inside a function, mark this as an argument. If
22066 not, we might be looking at an argument to an inlined function
22067 when we do not have enough information to show inlined frames;
22068 pretend it's a local variable in that case so that the user can
22070 struct context_stack
*curr
22071 = cu
->get_builder ()->get_current_context_stack ();
22072 if (curr
!= nullptr && curr
->name
!= nullptr)
22073 SYMBOL_IS_ARGUMENT (sym
) = 1;
22074 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
22075 if (attr
!= nullptr)
22077 var_decode_location (attr
, sym
, cu
);
22079 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22080 if (attr
!= nullptr)
22082 dwarf2_const_value (attr
, sym
, cu
);
22085 list_to_add
= cu
->list_in_scope
;
22088 case DW_TAG_unspecified_parameters
:
22089 /* From varargs functions; gdb doesn't seem to have any
22090 interest in this information, so just ignore it for now.
22093 case DW_TAG_template_type_param
:
22095 /* Fall through. */
22096 case DW_TAG_class_type
:
22097 case DW_TAG_interface_type
:
22098 case DW_TAG_structure_type
:
22099 case DW_TAG_union_type
:
22100 case DW_TAG_set_type
:
22101 case DW_TAG_enumeration_type
:
22102 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22103 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
22106 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
22107 really ever be static objects: otherwise, if you try
22108 to, say, break of a class's method and you're in a file
22109 which doesn't mention that class, it won't work unless
22110 the check for all static symbols in lookup_symbol_aux
22111 saves you. See the OtherFileClass tests in
22112 gdb.c++/namespace.exp. */
22116 buildsym_compunit
*builder
= cu
->get_builder ();
22118 = (cu
->list_in_scope
== builder
->get_file_symbols ()
22119 && cu
->language
== language_cplus
22120 ? builder
->get_global_symbols ()
22121 : cu
->list_in_scope
);
22123 /* The semantics of C++ state that "struct foo {
22124 ... }" also defines a typedef for "foo". */
22125 if (cu
->language
== language_cplus
22126 || cu
->language
== language_ada
22127 || cu
->language
== language_d
22128 || cu
->language
== language_rust
)
22130 /* The symbol's name is already allocated along
22131 with this objfile, so we don't need to
22132 duplicate it for the type. */
22133 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
22134 TYPE_NAME (SYMBOL_TYPE (sym
)) = sym
->search_name ();
22139 case DW_TAG_typedef
:
22140 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22141 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22142 list_to_add
= cu
->list_in_scope
;
22144 case DW_TAG_base_type
:
22145 case DW_TAG_subrange_type
:
22146 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22147 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
22148 list_to_add
= cu
->list_in_scope
;
22150 case DW_TAG_enumerator
:
22151 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
22152 if (attr
!= nullptr)
22154 dwarf2_const_value (attr
, sym
, cu
);
22157 /* NOTE: carlton/2003-11-10: See comment above in the
22158 DW_TAG_class_type, etc. block. */
22161 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
22162 && cu
->language
== language_cplus
22163 ? cu
->get_builder ()->get_global_symbols ()
22164 : cu
->list_in_scope
);
22167 case DW_TAG_imported_declaration
:
22168 case DW_TAG_namespace
:
22169 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22170 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22172 case DW_TAG_module
:
22173 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
22174 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
22175 list_to_add
= cu
->get_builder ()->get_global_symbols ();
22177 case DW_TAG_common_block
:
22178 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
22179 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
22180 add_symbol_to_list (sym
, cu
->list_in_scope
);
22183 /* Not a tag we recognize. Hopefully we aren't processing
22184 trash data, but since we must specifically ignore things
22185 we don't recognize, there is nothing else we should do at
22187 complaint (_("unsupported tag: '%s'"),
22188 dwarf_tag_name (die
->tag
));
22194 sym
->hash_next
= objfile
->template_symbols
;
22195 objfile
->template_symbols
= sym
;
22196 list_to_add
= NULL
;
22199 if (list_to_add
!= NULL
)
22200 add_symbol_to_list (sym
, list_to_add
);
22202 /* For the benefit of old versions of GCC, check for anonymous
22203 namespaces based on the demangled name. */
22204 if (!cu
->processing_has_namespace_info
22205 && cu
->language
== language_cplus
)
22206 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
22211 /* Given an attr with a DW_FORM_dataN value in host byte order,
22212 zero-extend it as appropriate for the symbol's type. The DWARF
22213 standard (v4) is not entirely clear about the meaning of using
22214 DW_FORM_dataN for a constant with a signed type, where the type is
22215 wider than the data. The conclusion of a discussion on the DWARF
22216 list was that this is unspecified. We choose to always zero-extend
22217 because that is the interpretation long in use by GCC. */
22220 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
22221 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
22223 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22224 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
22225 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
22226 LONGEST l
= DW_UNSND (attr
);
22228 if (bits
< sizeof (*value
) * 8)
22230 l
&= ((LONGEST
) 1 << bits
) - 1;
22233 else if (bits
== sizeof (*value
) * 8)
22237 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
22238 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
22245 /* Read a constant value from an attribute. Either set *VALUE, or if
22246 the value does not fit in *VALUE, set *BYTES - either already
22247 allocated on the objfile obstack, or newly allocated on OBSTACK,
22248 or, set *BATON, if we translated the constant to a location
22252 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
22253 const char *name
, struct obstack
*obstack
,
22254 struct dwarf2_cu
*cu
,
22255 LONGEST
*value
, const gdb_byte
**bytes
,
22256 struct dwarf2_locexpr_baton
**baton
)
22258 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22259 struct comp_unit_head
*cu_header
= &cu
->header
;
22260 struct dwarf_block
*blk
;
22261 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
22262 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
22268 switch (attr
->form
)
22271 case DW_FORM_addrx
:
22272 case DW_FORM_GNU_addr_index
:
22276 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
22277 dwarf2_const_value_length_mismatch_complaint (name
,
22278 cu_header
->addr_size
,
22279 TYPE_LENGTH (type
));
22280 /* Symbols of this form are reasonably rare, so we just
22281 piggyback on the existing location code rather than writing
22282 a new implementation of symbol_computed_ops. */
22283 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
22284 (*baton
)->per_cu
= cu
->per_cu
;
22285 gdb_assert ((*baton
)->per_cu
);
22287 (*baton
)->size
= 2 + cu_header
->addr_size
;
22288 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
22289 (*baton
)->data
= data
;
22291 data
[0] = DW_OP_addr
;
22292 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
22293 byte_order
, DW_ADDR (attr
));
22294 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
22297 case DW_FORM_string
:
22300 case DW_FORM_GNU_str_index
:
22301 case DW_FORM_GNU_strp_alt
:
22302 /* DW_STRING is already allocated on the objfile obstack, point
22304 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
22306 case DW_FORM_block1
:
22307 case DW_FORM_block2
:
22308 case DW_FORM_block4
:
22309 case DW_FORM_block
:
22310 case DW_FORM_exprloc
:
22311 case DW_FORM_data16
:
22312 blk
= DW_BLOCK (attr
);
22313 if (TYPE_LENGTH (type
) != blk
->size
)
22314 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
22315 TYPE_LENGTH (type
));
22316 *bytes
= blk
->data
;
22319 /* The DW_AT_const_value attributes are supposed to carry the
22320 symbol's value "represented as it would be on the target
22321 architecture." By the time we get here, it's already been
22322 converted to host endianness, so we just need to sign- or
22323 zero-extend it as appropriate. */
22324 case DW_FORM_data1
:
22325 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
22327 case DW_FORM_data2
:
22328 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
22330 case DW_FORM_data4
:
22331 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
22333 case DW_FORM_data8
:
22334 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
22337 case DW_FORM_sdata
:
22338 case DW_FORM_implicit_const
:
22339 *value
= DW_SND (attr
);
22342 case DW_FORM_udata
:
22343 *value
= DW_UNSND (attr
);
22347 complaint (_("unsupported const value attribute form: '%s'"),
22348 dwarf_form_name (attr
->form
));
22355 /* Copy constant value from an attribute to a symbol. */
22358 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
22359 struct dwarf2_cu
*cu
)
22361 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22363 const gdb_byte
*bytes
;
22364 struct dwarf2_locexpr_baton
*baton
;
22366 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
22367 sym
->print_name (),
22368 &objfile
->objfile_obstack
, cu
,
22369 &value
, &bytes
, &baton
);
22373 SYMBOL_LOCATION_BATON (sym
) = baton
;
22374 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
22376 else if (bytes
!= NULL
)
22378 SYMBOL_VALUE_BYTES (sym
) = bytes
;
22379 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
22383 SYMBOL_VALUE (sym
) = value
;
22384 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
22388 /* Return the type of the die in question using its DW_AT_type attribute. */
22390 static struct type
*
22391 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22393 struct attribute
*type_attr
;
22395 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
22398 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22399 /* A missing DW_AT_type represents a void type. */
22400 return objfile_type (objfile
)->builtin_void
;
22403 return lookup_die_type (die
, type_attr
, cu
);
22406 /* True iff CU's producer generates GNAT Ada auxiliary information
22407 that allows to find parallel types through that information instead
22408 of having to do expensive parallel lookups by type name. */
22411 need_gnat_info (struct dwarf2_cu
*cu
)
22413 /* Assume that the Ada compiler was GNAT, which always produces
22414 the auxiliary information. */
22415 return (cu
->language
== language_ada
);
22418 /* Return the auxiliary type of the die in question using its
22419 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
22420 attribute is not present. */
22422 static struct type
*
22423 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22425 struct attribute
*type_attr
;
22427 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22431 return lookup_die_type (die
, type_attr
, cu
);
22434 /* If DIE has a descriptive_type attribute, then set the TYPE's
22435 descriptive type accordingly. */
22438 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22439 struct dwarf2_cu
*cu
)
22441 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22443 if (descriptive_type
)
22445 ALLOCATE_GNAT_AUX_TYPE (type
);
22446 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22450 /* Return the containing type of the die in question using its
22451 DW_AT_containing_type attribute. */
22453 static struct type
*
22454 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22456 struct attribute
*type_attr
;
22457 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22459 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22461 error (_("Dwarf Error: Problem turning containing type into gdb type "
22462 "[in module %s]"), objfile_name (objfile
));
22464 return lookup_die_type (die
, type_attr
, cu
);
22467 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22469 static struct type
*
22470 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22472 struct dwarf2_per_objfile
*dwarf2_per_objfile
22473 = cu
->per_cu
->dwarf2_per_objfile
;
22474 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22477 std::string message
22478 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22479 objfile_name (objfile
),
22480 sect_offset_str (cu
->header
.sect_off
),
22481 sect_offset_str (die
->sect_off
));
22482 saved
= obstack_strdup (&objfile
->objfile_obstack
, message
);
22484 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22487 /* Look up the type of DIE in CU using its type attribute ATTR.
22488 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22489 DW_AT_containing_type.
22490 If there is no type substitute an error marker. */
22492 static struct type
*
22493 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22494 struct dwarf2_cu
*cu
)
22496 struct dwarf2_per_objfile
*dwarf2_per_objfile
22497 = cu
->per_cu
->dwarf2_per_objfile
;
22498 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22499 struct type
*this_type
;
22501 gdb_assert (attr
->name
== DW_AT_type
22502 || attr
->name
== DW_AT_GNAT_descriptive_type
22503 || attr
->name
== DW_AT_containing_type
);
22505 /* First see if we have it cached. */
22507 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22509 struct dwarf2_per_cu_data
*per_cu
;
22510 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
22512 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1,
22513 dwarf2_per_objfile
);
22514 this_type
= get_die_type_at_offset (sect_off
, per_cu
);
22516 else if (attr_form_is_ref (attr
))
22518 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
22520 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
22522 else if (attr
->form
== DW_FORM_ref_sig8
)
22524 ULONGEST signature
= DW_SIGNATURE (attr
);
22526 return get_signatured_type (die
, signature
, cu
);
22530 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22531 " at %s [in module %s]"),
22532 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22533 objfile_name (objfile
));
22534 return build_error_marker_type (cu
, die
);
22537 /* If not cached we need to read it in. */
22539 if (this_type
== NULL
)
22541 struct die_info
*type_die
= NULL
;
22542 struct dwarf2_cu
*type_cu
= cu
;
22544 if (attr_form_is_ref (attr
))
22545 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22546 if (type_die
== NULL
)
22547 return build_error_marker_type (cu
, die
);
22548 /* If we find the type now, it's probably because the type came
22549 from an inter-CU reference and the type's CU got expanded before
22551 this_type
= read_type_die (type_die
, type_cu
);
22554 /* If we still don't have a type use an error marker. */
22556 if (this_type
== NULL
)
22557 return build_error_marker_type (cu
, die
);
22562 /* Return the type in DIE, CU.
22563 Returns NULL for invalid types.
22565 This first does a lookup in die_type_hash,
22566 and only reads the die in if necessary.
22568 NOTE: This can be called when reading in partial or full symbols. */
22570 static struct type
*
22571 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22573 struct type
*this_type
;
22575 this_type
= get_die_type (die
, cu
);
22579 return read_type_die_1 (die
, cu
);
22582 /* Read the type in DIE, CU.
22583 Returns NULL for invalid types. */
22585 static struct type
*
22586 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22588 struct type
*this_type
= NULL
;
22592 case DW_TAG_class_type
:
22593 case DW_TAG_interface_type
:
22594 case DW_TAG_structure_type
:
22595 case DW_TAG_union_type
:
22596 this_type
= read_structure_type (die
, cu
);
22598 case DW_TAG_enumeration_type
:
22599 this_type
= read_enumeration_type (die
, cu
);
22601 case DW_TAG_subprogram
:
22602 case DW_TAG_subroutine_type
:
22603 case DW_TAG_inlined_subroutine
:
22604 this_type
= read_subroutine_type (die
, cu
);
22606 case DW_TAG_array_type
:
22607 this_type
= read_array_type (die
, cu
);
22609 case DW_TAG_set_type
:
22610 this_type
= read_set_type (die
, cu
);
22612 case DW_TAG_pointer_type
:
22613 this_type
= read_tag_pointer_type (die
, cu
);
22615 case DW_TAG_ptr_to_member_type
:
22616 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22618 case DW_TAG_reference_type
:
22619 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22621 case DW_TAG_rvalue_reference_type
:
22622 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22624 case DW_TAG_const_type
:
22625 this_type
= read_tag_const_type (die
, cu
);
22627 case DW_TAG_volatile_type
:
22628 this_type
= read_tag_volatile_type (die
, cu
);
22630 case DW_TAG_restrict_type
:
22631 this_type
= read_tag_restrict_type (die
, cu
);
22633 case DW_TAG_string_type
:
22634 this_type
= read_tag_string_type (die
, cu
);
22636 case DW_TAG_typedef
:
22637 this_type
= read_typedef (die
, cu
);
22639 case DW_TAG_subrange_type
:
22640 this_type
= read_subrange_type (die
, cu
);
22642 case DW_TAG_base_type
:
22643 this_type
= read_base_type (die
, cu
);
22645 case DW_TAG_unspecified_type
:
22646 this_type
= read_unspecified_type (die
, cu
);
22648 case DW_TAG_namespace
:
22649 this_type
= read_namespace_type (die
, cu
);
22651 case DW_TAG_module
:
22652 this_type
= read_module_type (die
, cu
);
22654 case DW_TAG_atomic_type
:
22655 this_type
= read_tag_atomic_type (die
, cu
);
22658 complaint (_("unexpected tag in read_type_die: '%s'"),
22659 dwarf_tag_name (die
->tag
));
22666 /* See if we can figure out if the class lives in a namespace. We do
22667 this by looking for a member function; its demangled name will
22668 contain namespace info, if there is any.
22669 Return the computed name or NULL.
22670 Space for the result is allocated on the objfile's obstack.
22671 This is the full-die version of guess_partial_die_structure_name.
22672 In this case we know DIE has no useful parent. */
22674 static const char *
22675 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22677 struct die_info
*spec_die
;
22678 struct dwarf2_cu
*spec_cu
;
22679 struct die_info
*child
;
22680 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22683 spec_die
= die_specification (die
, &spec_cu
);
22684 if (spec_die
!= NULL
)
22690 for (child
= die
->child
;
22692 child
= child
->sibling
)
22694 if (child
->tag
== DW_TAG_subprogram
)
22696 const char *linkage_name
= dw2_linkage_name (child
, cu
);
22698 if (linkage_name
!= NULL
)
22700 gdb::unique_xmalloc_ptr
<char> actual_name
22701 (language_class_name_from_physname (cu
->language_defn
,
22703 const char *name
= NULL
;
22705 if (actual_name
!= NULL
)
22707 const char *die_name
= dwarf2_name (die
, cu
);
22709 if (die_name
!= NULL
22710 && strcmp (die_name
, actual_name
.get ()) != 0)
22712 /* Strip off the class name from the full name.
22713 We want the prefix. */
22714 int die_name_len
= strlen (die_name
);
22715 int actual_name_len
= strlen (actual_name
.get ());
22716 const char *ptr
= actual_name
.get ();
22718 /* Test for '::' as a sanity check. */
22719 if (actual_name_len
> die_name_len
+ 2
22720 && ptr
[actual_name_len
- die_name_len
- 1] == ':')
22721 name
= obstack_strndup (
22722 &objfile
->per_bfd
->storage_obstack
,
22723 ptr
, actual_name_len
- die_name_len
- 2);
22734 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22735 prefix part in such case. See
22736 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22738 static const char *
22739 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22741 struct attribute
*attr
;
22744 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
22745 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
22748 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
22751 attr
= dw2_linkage_name_attr (die
, cu
);
22752 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
22755 /* dwarf2_name had to be already called. */
22756 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
22758 /* Strip the base name, keep any leading namespaces/classes. */
22759 base
= strrchr (DW_STRING (attr
), ':');
22760 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
22763 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22764 return obstack_strndup (&objfile
->per_bfd
->storage_obstack
,
22766 &base
[-1] - DW_STRING (attr
));
22769 /* Return the name of the namespace/class that DIE is defined within,
22770 or "" if we can't tell. The caller should not xfree the result.
22772 For example, if we're within the method foo() in the following
22782 then determine_prefix on foo's die will return "N::C". */
22784 static const char *
22785 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22787 struct dwarf2_per_objfile
*dwarf2_per_objfile
22788 = cu
->per_cu
->dwarf2_per_objfile
;
22789 struct die_info
*parent
, *spec_die
;
22790 struct dwarf2_cu
*spec_cu
;
22791 struct type
*parent_type
;
22792 const char *retval
;
22794 if (cu
->language
!= language_cplus
22795 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
22796 && cu
->language
!= language_rust
)
22799 retval
= anonymous_struct_prefix (die
, cu
);
22803 /* We have to be careful in the presence of DW_AT_specification.
22804 For example, with GCC 3.4, given the code
22808 // Definition of N::foo.
22812 then we'll have a tree of DIEs like this:
22814 1: DW_TAG_compile_unit
22815 2: DW_TAG_namespace // N
22816 3: DW_TAG_subprogram // declaration of N::foo
22817 4: DW_TAG_subprogram // definition of N::foo
22818 DW_AT_specification // refers to die #3
22820 Thus, when processing die #4, we have to pretend that we're in
22821 the context of its DW_AT_specification, namely the contex of die
22824 spec_die
= die_specification (die
, &spec_cu
);
22825 if (spec_die
== NULL
)
22826 parent
= die
->parent
;
22829 parent
= spec_die
->parent
;
22833 if (parent
== NULL
)
22835 else if (parent
->building_fullname
)
22838 const char *parent_name
;
22840 /* It has been seen on RealView 2.2 built binaries,
22841 DW_TAG_template_type_param types actually _defined_ as
22842 children of the parent class:
22845 template class <class Enum> Class{};
22846 Class<enum E> class_e;
22848 1: DW_TAG_class_type (Class)
22849 2: DW_TAG_enumeration_type (E)
22850 3: DW_TAG_enumerator (enum1:0)
22851 3: DW_TAG_enumerator (enum2:1)
22853 2: DW_TAG_template_type_param
22854 DW_AT_type DW_FORM_ref_udata (E)
22856 Besides being broken debug info, it can put GDB into an
22857 infinite loop. Consider:
22859 When we're building the full name for Class<E>, we'll start
22860 at Class, and go look over its template type parameters,
22861 finding E. We'll then try to build the full name of E, and
22862 reach here. We're now trying to build the full name of E,
22863 and look over the parent DIE for containing scope. In the
22864 broken case, if we followed the parent DIE of E, we'd again
22865 find Class, and once again go look at its template type
22866 arguments, etc., etc. Simply don't consider such parent die
22867 as source-level parent of this die (it can't be, the language
22868 doesn't allow it), and break the loop here. */
22869 name
= dwarf2_name (die
, cu
);
22870 parent_name
= dwarf2_name (parent
, cu
);
22871 complaint (_("template param type '%s' defined within parent '%s'"),
22872 name
? name
: "<unknown>",
22873 parent_name
? parent_name
: "<unknown>");
22877 switch (parent
->tag
)
22879 case DW_TAG_namespace
:
22880 parent_type
= read_type_die (parent
, cu
);
22881 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22882 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22883 Work around this problem here. */
22884 if (cu
->language
== language_cplus
22885 && strcmp (TYPE_NAME (parent_type
), "::") == 0)
22887 /* We give a name to even anonymous namespaces. */
22888 return TYPE_NAME (parent_type
);
22889 case DW_TAG_class_type
:
22890 case DW_TAG_interface_type
:
22891 case DW_TAG_structure_type
:
22892 case DW_TAG_union_type
:
22893 case DW_TAG_module
:
22894 parent_type
= read_type_die (parent
, cu
);
22895 if (TYPE_NAME (parent_type
) != NULL
)
22896 return TYPE_NAME (parent_type
);
22898 /* An anonymous structure is only allowed non-static data
22899 members; no typedefs, no member functions, et cetera.
22900 So it does not need a prefix. */
22902 case DW_TAG_compile_unit
:
22903 case DW_TAG_partial_unit
:
22904 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22905 if (cu
->language
== language_cplus
22906 && !dwarf2_per_objfile
->types
.empty ()
22907 && die
->child
!= NULL
22908 && (die
->tag
== DW_TAG_class_type
22909 || die
->tag
== DW_TAG_structure_type
22910 || die
->tag
== DW_TAG_union_type
))
22912 const char *name
= guess_full_die_structure_name (die
, cu
);
22917 case DW_TAG_subprogram
:
22918 /* Nested subroutines in Fortran get a prefix with the name
22919 of the parent's subroutine. */
22920 if (cu
->language
== language_fortran
)
22922 if ((die
->tag
== DW_TAG_subprogram
)
22923 && (dwarf2_name (parent
, cu
) != NULL
))
22924 return dwarf2_name (parent
, cu
);
22926 return determine_prefix (parent
, cu
);
22927 case DW_TAG_enumeration_type
:
22928 parent_type
= read_type_die (parent
, cu
);
22929 if (TYPE_DECLARED_CLASS (parent_type
))
22931 if (TYPE_NAME (parent_type
) != NULL
)
22932 return TYPE_NAME (parent_type
);
22935 /* Fall through. */
22937 return determine_prefix (parent
, cu
);
22941 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22942 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22943 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22944 an obconcat, otherwise allocate storage for the result. The CU argument is
22945 used to determine the language and hence, the appropriate separator. */
22947 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22950 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
22951 int physname
, struct dwarf2_cu
*cu
)
22953 const char *lead
= "";
22956 if (suffix
== NULL
|| suffix
[0] == '\0'
22957 || prefix
== NULL
|| prefix
[0] == '\0')
22959 else if (cu
->language
== language_d
)
22961 /* For D, the 'main' function could be defined in any module, but it
22962 should never be prefixed. */
22963 if (strcmp (suffix
, "D main") == 0)
22971 else if (cu
->language
== language_fortran
&& physname
)
22973 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22974 DW_AT_MIPS_linkage_name is preferred and used instead. */
22982 if (prefix
== NULL
)
22984 if (suffix
== NULL
)
22991 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
22993 strcpy (retval
, lead
);
22994 strcat (retval
, prefix
);
22995 strcat (retval
, sep
);
22996 strcat (retval
, suffix
);
23001 /* We have an obstack. */
23002 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
23006 /* Return sibling of die, NULL if no sibling. */
23008 static struct die_info
*
23009 sibling_die (struct die_info
*die
)
23011 return die
->sibling
;
23014 /* Get name of a die, return NULL if not found. */
23016 static const char *
23017 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
23018 struct obstack
*obstack
)
23020 if (name
&& cu
->language
== language_cplus
)
23022 std::string canon_name
= cp_canonicalize_string (name
);
23024 if (!canon_name
.empty ())
23026 if (canon_name
!= name
)
23027 name
= obstack_strdup (obstack
, canon_name
);
23034 /* Get name of a die, return NULL if not found.
23035 Anonymous namespaces are converted to their magic string. */
23037 static const char *
23038 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
23040 struct attribute
*attr
;
23041 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
23043 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
23044 if ((!attr
|| !DW_STRING (attr
))
23045 && die
->tag
!= DW_TAG_namespace
23046 && die
->tag
!= DW_TAG_class_type
23047 && die
->tag
!= DW_TAG_interface_type
23048 && die
->tag
!= DW_TAG_structure_type
23049 && die
->tag
!= DW_TAG_union_type
)
23054 case DW_TAG_compile_unit
:
23055 case DW_TAG_partial_unit
:
23056 /* Compilation units have a DW_AT_name that is a filename, not
23057 a source language identifier. */
23058 case DW_TAG_enumeration_type
:
23059 case DW_TAG_enumerator
:
23060 /* These tags always have simple identifiers already; no need
23061 to canonicalize them. */
23062 return DW_STRING (attr
);
23064 case DW_TAG_namespace
:
23065 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
23066 return DW_STRING (attr
);
23067 return CP_ANONYMOUS_NAMESPACE_STR
;
23069 case DW_TAG_class_type
:
23070 case DW_TAG_interface_type
:
23071 case DW_TAG_structure_type
:
23072 case DW_TAG_union_type
:
23073 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
23074 structures or unions. These were of the form "._%d" in GCC 4.1,
23075 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
23076 and GCC 4.4. We work around this problem by ignoring these. */
23077 if (attr
&& DW_STRING (attr
)
23078 && (startswith (DW_STRING (attr
), "._")
23079 || startswith (DW_STRING (attr
), "<anonymous")))
23082 /* GCC might emit a nameless typedef that has a linkage name. See
23083 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
23084 if (!attr
|| DW_STRING (attr
) == NULL
)
23086 attr
= dw2_linkage_name_attr (die
, cu
);
23087 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
23090 /* Avoid demangling DW_STRING (attr) the second time on a second
23091 call for the same DIE. */
23092 if (!DW_STRING_IS_CANONICAL (attr
))
23094 gdb::unique_xmalloc_ptr
<char> demangled
23095 (gdb_demangle (DW_STRING (attr
), DMGL_TYPES
));
23099 /* FIXME: we already did this for the partial symbol... */
23101 = obstack_strdup (&objfile
->per_bfd
->storage_obstack
,
23103 DW_STRING_IS_CANONICAL (attr
) = 1;
23105 /* Strip any leading namespaces/classes, keep only the base name.
23106 DW_AT_name for named DIEs does not contain the prefixes. */
23107 base
= strrchr (DW_STRING (attr
), ':');
23108 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
23111 return DW_STRING (attr
);
23120 if (!DW_STRING_IS_CANONICAL (attr
))
23123 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
23124 &objfile
->per_bfd
->storage_obstack
);
23125 DW_STRING_IS_CANONICAL (attr
) = 1;
23127 return DW_STRING (attr
);
23130 /* Return the die that this die in an extension of, or NULL if there
23131 is none. *EXT_CU is the CU containing DIE on input, and the CU
23132 containing the return value on output. */
23134 static struct die_info
*
23135 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
23137 struct attribute
*attr
;
23139 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
23143 return follow_die_ref (die
, attr
, ext_cu
);
23146 /* A convenience function that returns an "unknown" DWARF name,
23147 including the value of V. STR is the name of the entity being
23148 printed, e.g., "TAG". */
23150 static const char *
23151 dwarf_unknown (const char *str
, unsigned v
)
23153 char *cell
= get_print_cell ();
23154 xsnprintf (cell
, PRINT_CELL_SIZE
, "DW_%s_<unknown: %u>", str
, v
);
23158 /* Convert a DIE tag into its string name. */
23160 static const char *
23161 dwarf_tag_name (unsigned tag
)
23163 const char *name
= get_DW_TAG_name (tag
);
23166 return dwarf_unknown ("TAG", tag
);
23171 /* Convert a DWARF attribute code into its string name. */
23173 static const char *
23174 dwarf_attr_name (unsigned attr
)
23178 #ifdef MIPS /* collides with DW_AT_HP_block_index */
23179 if (attr
== DW_AT_MIPS_fde
)
23180 return "DW_AT_MIPS_fde";
23182 if (attr
== DW_AT_HP_block_index
)
23183 return "DW_AT_HP_block_index";
23186 name
= get_DW_AT_name (attr
);
23189 return dwarf_unknown ("AT", attr
);
23194 /* Convert a unit type to corresponding DW_UT name. */
23196 static const char *
23197 dwarf_unit_type_name (int unit_type
) {
23201 return "DW_UT_compile (0x01)";
23203 return "DW_UT_type (0x02)";
23205 return "DW_UT_partial (0x03)";
23207 return "DW_UT_skeleton (0x04)";
23209 return "DW_UT_split_compile (0x05)";
23211 return "DW_UT_split_type (0x06)";
23213 return "DW_UT_lo_user (0x80)";
23215 return "DW_UT_hi_user (0xff)";
23221 /* Convert a DWARF value form code into its string name. */
23223 static const char *
23224 dwarf_form_name (unsigned form
)
23226 const char *name
= get_DW_FORM_name (form
);
23229 return dwarf_unknown ("FORM", form
);
23234 static const char *
23235 dwarf_bool_name (unsigned mybool
)
23243 /* Convert a DWARF type code into its string name. */
23245 static const char *
23246 dwarf_type_encoding_name (unsigned enc
)
23248 const char *name
= get_DW_ATE_name (enc
);
23251 return dwarf_unknown ("ATE", enc
);
23257 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
23261 print_spaces (indent
, f
);
23262 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
23263 dwarf_tag_name (die
->tag
), die
->abbrev
,
23264 sect_offset_str (die
->sect_off
));
23266 if (die
->parent
!= NULL
)
23268 print_spaces (indent
, f
);
23269 fprintf_unfiltered (f
, " parent at offset: %s\n",
23270 sect_offset_str (die
->parent
->sect_off
));
23273 print_spaces (indent
, f
);
23274 fprintf_unfiltered (f
, " has children: %s\n",
23275 dwarf_bool_name (die
->child
!= NULL
));
23277 print_spaces (indent
, f
);
23278 fprintf_unfiltered (f
, " attributes:\n");
23280 for (i
= 0; i
< die
->num_attrs
; ++i
)
23282 print_spaces (indent
, f
);
23283 fprintf_unfiltered (f
, " %s (%s) ",
23284 dwarf_attr_name (die
->attrs
[i
].name
),
23285 dwarf_form_name (die
->attrs
[i
].form
));
23287 switch (die
->attrs
[i
].form
)
23290 case DW_FORM_addrx
:
23291 case DW_FORM_GNU_addr_index
:
23292 fprintf_unfiltered (f
, "address: ");
23293 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
23295 case DW_FORM_block2
:
23296 case DW_FORM_block4
:
23297 case DW_FORM_block
:
23298 case DW_FORM_block1
:
23299 fprintf_unfiltered (f
, "block: size %s",
23300 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
23302 case DW_FORM_exprloc
:
23303 fprintf_unfiltered (f
, "expression: size %s",
23304 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
23306 case DW_FORM_data16
:
23307 fprintf_unfiltered (f
, "constant of 16 bytes");
23309 case DW_FORM_ref_addr
:
23310 fprintf_unfiltered (f
, "ref address: ");
23311 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
23313 case DW_FORM_GNU_ref_alt
:
23314 fprintf_unfiltered (f
, "alt ref address: ");
23315 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
23321 case DW_FORM_ref_udata
:
23322 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
23323 (long) (DW_UNSND (&die
->attrs
[i
])));
23325 case DW_FORM_data1
:
23326 case DW_FORM_data2
:
23327 case DW_FORM_data4
:
23328 case DW_FORM_data8
:
23329 case DW_FORM_udata
:
23330 case DW_FORM_sdata
:
23331 fprintf_unfiltered (f
, "constant: %s",
23332 pulongest (DW_UNSND (&die
->attrs
[i
])));
23334 case DW_FORM_sec_offset
:
23335 fprintf_unfiltered (f
, "section offset: %s",
23336 pulongest (DW_UNSND (&die
->attrs
[i
])));
23338 case DW_FORM_ref_sig8
:
23339 fprintf_unfiltered (f
, "signature: %s",
23340 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
23342 case DW_FORM_string
:
23344 case DW_FORM_line_strp
:
23346 case DW_FORM_GNU_str_index
:
23347 case DW_FORM_GNU_strp_alt
:
23348 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
23349 DW_STRING (&die
->attrs
[i
])
23350 ? DW_STRING (&die
->attrs
[i
]) : "",
23351 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
23354 if (DW_UNSND (&die
->attrs
[i
]))
23355 fprintf_unfiltered (f
, "flag: TRUE");
23357 fprintf_unfiltered (f
, "flag: FALSE");
23359 case DW_FORM_flag_present
:
23360 fprintf_unfiltered (f
, "flag: TRUE");
23362 case DW_FORM_indirect
:
23363 /* The reader will have reduced the indirect form to
23364 the "base form" so this form should not occur. */
23365 fprintf_unfiltered (f
,
23366 "unexpected attribute form: DW_FORM_indirect");
23368 case DW_FORM_implicit_const
:
23369 fprintf_unfiltered (f
, "constant: %s",
23370 plongest (DW_SND (&die
->attrs
[i
])));
23373 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
23374 die
->attrs
[i
].form
);
23377 fprintf_unfiltered (f
, "\n");
23382 dump_die_for_error (struct die_info
*die
)
23384 dump_die_shallow (gdb_stderr
, 0, die
);
23388 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
23390 int indent
= level
* 4;
23392 gdb_assert (die
!= NULL
);
23394 if (level
>= max_level
)
23397 dump_die_shallow (f
, indent
, die
);
23399 if (die
->child
!= NULL
)
23401 print_spaces (indent
, f
);
23402 fprintf_unfiltered (f
, " Children:");
23403 if (level
+ 1 < max_level
)
23405 fprintf_unfiltered (f
, "\n");
23406 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
23410 fprintf_unfiltered (f
,
23411 " [not printed, max nesting level reached]\n");
23415 if (die
->sibling
!= NULL
&& level
> 0)
23417 dump_die_1 (f
, level
, max_level
, die
->sibling
);
23421 /* This is called from the pdie macro in gdbinit.in.
23422 It's not static so gcc will keep a copy callable from gdb. */
23425 dump_die (struct die_info
*die
, int max_level
)
23427 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
23431 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
23435 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
23436 to_underlying (die
->sect_off
),
23442 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
23446 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
23448 if (attr_form_is_ref (attr
))
23449 return (sect_offset
) DW_UNSND (attr
);
23451 complaint (_("unsupported die ref attribute form: '%s'"),
23452 dwarf_form_name (attr
->form
));
23456 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
23457 * the value held by the attribute is not constant. */
23460 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
23462 if (attr
->form
== DW_FORM_sdata
|| attr
->form
== DW_FORM_implicit_const
)
23463 return DW_SND (attr
);
23464 else if (attr
->form
== DW_FORM_udata
23465 || attr
->form
== DW_FORM_data1
23466 || attr
->form
== DW_FORM_data2
23467 || attr
->form
== DW_FORM_data4
23468 || attr
->form
== DW_FORM_data8
)
23469 return DW_UNSND (attr
);
23472 /* For DW_FORM_data16 see attr_form_is_constant. */
23473 complaint (_("Attribute value is not a constant (%s)"),
23474 dwarf_form_name (attr
->form
));
23475 return default_value
;
23479 /* Follow reference or signature attribute ATTR of SRC_DIE.
23480 On entry *REF_CU is the CU of SRC_DIE.
23481 On exit *REF_CU is the CU of the result. */
23483 static struct die_info
*
23484 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23485 struct dwarf2_cu
**ref_cu
)
23487 struct die_info
*die
;
23489 if (attr_form_is_ref (attr
))
23490 die
= follow_die_ref (src_die
, attr
, ref_cu
);
23491 else if (attr
->form
== DW_FORM_ref_sig8
)
23492 die
= follow_die_sig (src_die
, attr
, ref_cu
);
23495 dump_die_for_error (src_die
);
23496 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23497 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23503 /* Follow reference OFFSET.
23504 On entry *REF_CU is the CU of the source die referencing OFFSET.
23505 On exit *REF_CU is the CU of the result.
23506 Returns NULL if OFFSET is invalid. */
23508 static struct die_info
*
23509 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
23510 struct dwarf2_cu
**ref_cu
)
23512 struct die_info temp_die
;
23513 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
23514 struct dwarf2_per_objfile
*dwarf2_per_objfile
23515 = cu
->per_cu
->dwarf2_per_objfile
;
23517 gdb_assert (cu
->per_cu
!= NULL
);
23521 if (cu
->per_cu
->is_debug_types
)
23523 /* .debug_types CUs cannot reference anything outside their CU.
23524 If they need to, they have to reference a signatured type via
23525 DW_FORM_ref_sig8. */
23526 if (!offset_in_cu_p (&cu
->header
, sect_off
))
23529 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
23530 || !offset_in_cu_p (&cu
->header
, sect_off
))
23532 struct dwarf2_per_cu_data
*per_cu
;
23534 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
23535 dwarf2_per_objfile
);
23537 /* If necessary, add it to the queue and load its DIEs. */
23538 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
23539 load_full_comp_unit (per_cu
, false, cu
->language
);
23541 target_cu
= per_cu
->cu
;
23543 else if (cu
->dies
== NULL
)
23545 /* We're loading full DIEs during partial symbol reading. */
23546 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
23547 load_full_comp_unit (cu
->per_cu
, false, language_minimal
);
23550 *ref_cu
= target_cu
;
23551 temp_die
.sect_off
= sect_off
;
23553 if (target_cu
!= cu
)
23554 target_cu
->ancestor
= cu
;
23556 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
23558 to_underlying (sect_off
));
23561 /* Follow reference attribute ATTR of SRC_DIE.
23562 On entry *REF_CU is the CU of SRC_DIE.
23563 On exit *REF_CU is the CU of the result. */
23565 static struct die_info
*
23566 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
23567 struct dwarf2_cu
**ref_cu
)
23569 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
23570 struct dwarf2_cu
*cu
= *ref_cu
;
23571 struct die_info
*die
;
23573 die
= follow_die_offset (sect_off
,
23574 (attr
->form
== DW_FORM_GNU_ref_alt
23575 || cu
->per_cu
->is_dwz
),
23578 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23579 "at %s [in module %s]"),
23580 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
23581 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
23586 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23587 Returned value is intended for DW_OP_call*. Returned
23588 dwarf2_locexpr_baton->data has lifetime of
23589 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
23591 struct dwarf2_locexpr_baton
23592 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
23593 struct dwarf2_per_cu_data
*per_cu
,
23594 CORE_ADDR (*get_frame_pc
) (void *baton
),
23595 void *baton
, bool resolve_abstract_p
)
23597 struct dwarf2_cu
*cu
;
23598 struct die_info
*die
;
23599 struct attribute
*attr
;
23600 struct dwarf2_locexpr_baton retval
;
23601 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
23602 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
23604 if (per_cu
->cu
== NULL
)
23605 load_cu (per_cu
, false);
23609 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23610 Instead just throw an error, not much else we can do. */
23611 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23612 sect_offset_str (sect_off
), objfile_name (objfile
));
23615 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23617 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23618 sect_offset_str (sect_off
), objfile_name (objfile
));
23620 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23621 if (!attr
&& resolve_abstract_p
23622 && (dwarf2_per_objfile
->abstract_to_concrete
.find (die
->sect_off
)
23623 != dwarf2_per_objfile
->abstract_to_concrete
.end ()))
23625 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
23627 = ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
23628 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
23630 for (const auto &cand_off
23631 : dwarf2_per_objfile
->abstract_to_concrete
[die
->sect_off
])
23633 struct dwarf2_cu
*cand_cu
= cu
;
23634 struct die_info
*cand
23635 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23638 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23641 CORE_ADDR pc_low
, pc_high
;
23642 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23643 if (pc_low
== ((CORE_ADDR
) -1))
23645 pc_low
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_low
+ baseaddr
);
23646 pc_high
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_high
+ baseaddr
);
23647 if (!(pc_low
<= pc
&& pc
< pc_high
))
23651 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23658 /* DWARF: "If there is no such attribute, then there is no effect.".
23659 DATA is ignored if SIZE is 0. */
23661 retval
.data
= NULL
;
23664 else if (attr_form_is_section_offset (attr
))
23666 struct dwarf2_loclist_baton loclist_baton
;
23667 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
23670 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23672 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23674 retval
.size
= size
;
23678 if (!attr_form_is_block (attr
))
23679 error (_("Dwarf Error: DIE at %s referenced in module %s "
23680 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23681 sect_offset_str (sect_off
), objfile_name (objfile
));
23683 retval
.data
= DW_BLOCK (attr
)->data
;
23684 retval
.size
= DW_BLOCK (attr
)->size
;
23686 retval
.per_cu
= cu
->per_cu
;
23688 age_cached_comp_units (dwarf2_per_objfile
);
23693 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23696 struct dwarf2_locexpr_baton
23697 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23698 struct dwarf2_per_cu_data
*per_cu
,
23699 CORE_ADDR (*get_frame_pc
) (void *baton
),
23702 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23704 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, get_frame_pc
, baton
);
23707 /* Write a constant of a given type as target-ordered bytes into
23710 static const gdb_byte
*
23711 write_constant_as_bytes (struct obstack
*obstack
,
23712 enum bfd_endian byte_order
,
23719 *len
= TYPE_LENGTH (type
);
23720 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23721 store_unsigned_integer (result
, *len
, byte_order
, value
);
23726 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23727 pointer to the constant bytes and set LEN to the length of the
23728 data. If memory is needed, allocate it on OBSTACK. If the DIE
23729 does not have a DW_AT_const_value, return NULL. */
23732 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23733 struct dwarf2_per_cu_data
*per_cu
,
23734 struct obstack
*obstack
,
23737 struct dwarf2_cu
*cu
;
23738 struct die_info
*die
;
23739 struct attribute
*attr
;
23740 const gdb_byte
*result
= NULL
;
23743 enum bfd_endian byte_order
;
23744 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
23746 if (per_cu
->cu
== NULL
)
23747 load_cu (per_cu
, false);
23751 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23752 Instead just throw an error, not much else we can do. */
23753 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23754 sect_offset_str (sect_off
), objfile_name (objfile
));
23757 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23759 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23760 sect_offset_str (sect_off
), objfile_name (objfile
));
23762 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23766 byte_order
= (bfd_big_endian (objfile
->obfd
)
23767 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23769 switch (attr
->form
)
23772 case DW_FORM_addrx
:
23773 case DW_FORM_GNU_addr_index
:
23777 *len
= cu
->header
.addr_size
;
23778 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23779 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
23783 case DW_FORM_string
:
23786 case DW_FORM_GNU_str_index
:
23787 case DW_FORM_GNU_strp_alt
:
23788 /* DW_STRING is already allocated on the objfile obstack, point
23790 result
= (const gdb_byte
*) DW_STRING (attr
);
23791 *len
= strlen (DW_STRING (attr
));
23793 case DW_FORM_block1
:
23794 case DW_FORM_block2
:
23795 case DW_FORM_block4
:
23796 case DW_FORM_block
:
23797 case DW_FORM_exprloc
:
23798 case DW_FORM_data16
:
23799 result
= DW_BLOCK (attr
)->data
;
23800 *len
= DW_BLOCK (attr
)->size
;
23803 /* The DW_AT_const_value attributes are supposed to carry the
23804 symbol's value "represented as it would be on the target
23805 architecture." By the time we get here, it's already been
23806 converted to host endianness, so we just need to sign- or
23807 zero-extend it as appropriate. */
23808 case DW_FORM_data1
:
23809 type
= die_type (die
, cu
);
23810 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23811 if (result
== NULL
)
23812 result
= write_constant_as_bytes (obstack
, byte_order
,
23815 case DW_FORM_data2
:
23816 type
= die_type (die
, cu
);
23817 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23818 if (result
== NULL
)
23819 result
= write_constant_as_bytes (obstack
, byte_order
,
23822 case DW_FORM_data4
:
23823 type
= die_type (die
, cu
);
23824 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23825 if (result
== NULL
)
23826 result
= write_constant_as_bytes (obstack
, byte_order
,
23829 case DW_FORM_data8
:
23830 type
= die_type (die
, cu
);
23831 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23832 if (result
== NULL
)
23833 result
= write_constant_as_bytes (obstack
, byte_order
,
23837 case DW_FORM_sdata
:
23838 case DW_FORM_implicit_const
:
23839 type
= die_type (die
, cu
);
23840 result
= write_constant_as_bytes (obstack
, byte_order
,
23841 type
, DW_SND (attr
), len
);
23844 case DW_FORM_udata
:
23845 type
= die_type (die
, cu
);
23846 result
= write_constant_as_bytes (obstack
, byte_order
,
23847 type
, DW_UNSND (attr
), len
);
23851 complaint (_("unsupported const value attribute form: '%s'"),
23852 dwarf_form_name (attr
->form
));
23859 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23860 valid type for this die is found. */
23863 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
23864 struct dwarf2_per_cu_data
*per_cu
)
23866 struct dwarf2_cu
*cu
;
23867 struct die_info
*die
;
23869 if (per_cu
->cu
== NULL
)
23870 load_cu (per_cu
, false);
23875 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23879 return die_type (die
, cu
);
23882 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23886 dwarf2_get_die_type (cu_offset die_offset
,
23887 struct dwarf2_per_cu_data
*per_cu
)
23889 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
23890 return get_die_type_at_offset (die_offset_sect
, per_cu
);
23893 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23894 On entry *REF_CU is the CU of SRC_DIE.
23895 On exit *REF_CU is the CU of the result.
23896 Returns NULL if the referenced DIE isn't found. */
23898 static struct die_info
*
23899 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
23900 struct dwarf2_cu
**ref_cu
)
23902 struct die_info temp_die
;
23903 struct dwarf2_cu
*sig_cu
, *cu
= *ref_cu
;
23904 struct die_info
*die
;
23906 /* While it might be nice to assert sig_type->type == NULL here,
23907 we can get here for DW_AT_imported_declaration where we need
23908 the DIE not the type. */
23910 /* If necessary, add it to the queue and load its DIEs. */
23912 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
23913 read_signatured_type (sig_type
);
23915 sig_cu
= sig_type
->per_cu
.cu
;
23916 gdb_assert (sig_cu
!= NULL
);
23917 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
23918 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
23919 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
23920 to_underlying (temp_die
.sect_off
));
23923 struct dwarf2_per_objfile
*dwarf2_per_objfile
23924 = (*ref_cu
)->per_cu
->dwarf2_per_objfile
;
23926 /* For .gdb_index version 7 keep track of included TUs.
23927 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23928 if (dwarf2_per_objfile
->index_table
!= NULL
23929 && dwarf2_per_objfile
->index_table
->version
<= 7)
23931 (*ref_cu
)->per_cu
->imported_symtabs_push (sig_cu
->per_cu
);
23936 sig_cu
->ancestor
= cu
;
23944 /* Follow signatured type referenced by ATTR in SRC_DIE.
23945 On entry *REF_CU is the CU of SRC_DIE.
23946 On exit *REF_CU is the CU of the result.
23947 The result is the DIE of the type.
23948 If the referenced type cannot be found an error is thrown. */
23950 static struct die_info
*
23951 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23952 struct dwarf2_cu
**ref_cu
)
23954 ULONGEST signature
= DW_SIGNATURE (attr
);
23955 struct signatured_type
*sig_type
;
23956 struct die_info
*die
;
23958 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
23960 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
23961 /* sig_type will be NULL if the signatured type is missing from
23963 if (sig_type
== NULL
)
23965 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23966 " from DIE at %s [in module %s]"),
23967 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23968 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23971 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
23974 dump_die_for_error (src_die
);
23975 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23976 " from DIE at %s [in module %s]"),
23977 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23978 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23984 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23985 reading in and processing the type unit if necessary. */
23987 static struct type
*
23988 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
23989 struct dwarf2_cu
*cu
)
23991 struct dwarf2_per_objfile
*dwarf2_per_objfile
23992 = cu
->per_cu
->dwarf2_per_objfile
;
23993 struct signatured_type
*sig_type
;
23994 struct dwarf2_cu
*type_cu
;
23995 struct die_info
*type_die
;
23998 sig_type
= lookup_signatured_type (cu
, signature
);
23999 /* sig_type will be NULL if the signatured type is missing from
24001 if (sig_type
== NULL
)
24003 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
24004 " from DIE at %s [in module %s]"),
24005 hex_string (signature
), sect_offset_str (die
->sect_off
),
24006 objfile_name (dwarf2_per_objfile
->objfile
));
24007 return build_error_marker_type (cu
, die
);
24010 /* If we already know the type we're done. */
24011 if (sig_type
->type
!= NULL
)
24012 return sig_type
->type
;
24015 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
24016 if (type_die
!= NULL
)
24018 /* N.B. We need to call get_die_type to ensure only one type for this DIE
24019 is created. This is important, for example, because for c++ classes
24020 we need TYPE_NAME set which is only done by new_symbol. Blech. */
24021 type
= read_type_die (type_die
, type_cu
);
24024 complaint (_("Dwarf Error: Cannot build signatured type %s"
24025 " referenced from DIE at %s [in module %s]"),
24026 hex_string (signature
), sect_offset_str (die
->sect_off
),
24027 objfile_name (dwarf2_per_objfile
->objfile
));
24028 type
= build_error_marker_type (cu
, die
);
24033 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
24034 " from DIE at %s [in module %s]"),
24035 hex_string (signature
), sect_offset_str (die
->sect_off
),
24036 objfile_name (dwarf2_per_objfile
->objfile
));
24037 type
= build_error_marker_type (cu
, die
);
24039 sig_type
->type
= type
;
24044 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
24045 reading in and processing the type unit if necessary. */
24047 static struct type
*
24048 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
24049 struct dwarf2_cu
*cu
) /* ARI: editCase function */
24051 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
24052 if (attr_form_is_ref (attr
))
24054 struct dwarf2_cu
*type_cu
= cu
;
24055 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
24057 return read_type_die (type_die
, type_cu
);
24059 else if (attr
->form
== DW_FORM_ref_sig8
)
24061 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
24065 struct dwarf2_per_objfile
*dwarf2_per_objfile
24066 = cu
->per_cu
->dwarf2_per_objfile
;
24068 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
24069 " at %s [in module %s]"),
24070 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
24071 objfile_name (dwarf2_per_objfile
->objfile
));
24072 return build_error_marker_type (cu
, die
);
24076 /* Load the DIEs associated with type unit PER_CU into memory. */
24079 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
24081 struct signatured_type
*sig_type
;
24083 /* Caller is responsible for ensuring type_unit_groups don't get here. */
24084 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
24086 /* We have the per_cu, but we need the signatured_type.
24087 Fortunately this is an easy translation. */
24088 gdb_assert (per_cu
->is_debug_types
);
24089 sig_type
= (struct signatured_type
*) per_cu
;
24091 gdb_assert (per_cu
->cu
== NULL
);
24093 read_signatured_type (sig_type
);
24095 gdb_assert (per_cu
->cu
!= NULL
);
24098 /* die_reader_func for read_signatured_type.
24099 This is identical to load_full_comp_unit_reader,
24100 but is kept separate for now. */
24103 read_signatured_type_reader (const struct die_reader_specs
*reader
,
24104 const gdb_byte
*info_ptr
,
24105 struct die_info
*comp_unit_die
,
24109 struct dwarf2_cu
*cu
= reader
->cu
;
24111 gdb_assert (cu
->die_hash
== NULL
);
24113 htab_create_alloc_ex (cu
->header
.length
/ 12,
24117 &cu
->comp_unit_obstack
,
24118 hashtab_obstack_allocate
,
24119 dummy_obstack_deallocate
);
24122 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
24123 &info_ptr
, comp_unit_die
);
24124 cu
->dies
= comp_unit_die
;
24125 /* comp_unit_die is not stored in die_hash, no need. */
24127 /* We try not to read any attributes in this function, because not
24128 all CUs needed for references have been loaded yet, and symbol
24129 table processing isn't initialized. But we have to set the CU language,
24130 or we won't be able to build types correctly.
24131 Similarly, if we do not read the producer, we can not apply
24132 producer-specific interpretation. */
24133 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
24136 /* Read in a signatured type and build its CU and DIEs.
24137 If the type is a stub for the real type in a DWO file,
24138 read in the real type from the DWO file as well. */
24141 read_signatured_type (struct signatured_type
*sig_type
)
24143 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
24145 gdb_assert (per_cu
->is_debug_types
);
24146 gdb_assert (per_cu
->cu
== NULL
);
24148 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1, false,
24149 read_signatured_type_reader
, NULL
);
24150 sig_type
->per_cu
.tu_read
= 1;
24153 /* Decode simple location descriptions.
24154 Given a pointer to a dwarf block that defines a location, compute
24155 the location and return the value.
24157 NOTE drow/2003-11-18: This function is called in two situations
24158 now: for the address of static or global variables (partial symbols
24159 only) and for offsets into structures which are expected to be
24160 (more or less) constant. The partial symbol case should go away,
24161 and only the constant case should remain. That will let this
24162 function complain more accurately. A few special modes are allowed
24163 without complaint for global variables (for instance, global
24164 register values and thread-local values).
24166 A location description containing no operations indicates that the
24167 object is optimized out. The return value is 0 for that case.
24168 FIXME drow/2003-11-16: No callers check for this case any more; soon all
24169 callers will only want a very basic result and this can become a
24172 Note that stack[0] is unused except as a default error return. */
24175 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
24177 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
24179 size_t size
= blk
->size
;
24180 const gdb_byte
*data
= blk
->data
;
24181 CORE_ADDR stack
[64];
24183 unsigned int bytes_read
, unsnd
;
24189 stack
[++stacki
] = 0;
24228 stack
[++stacki
] = op
- DW_OP_lit0
;
24263 stack
[++stacki
] = op
- DW_OP_reg0
;
24265 dwarf2_complex_location_expr_complaint ();
24269 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
24271 stack
[++stacki
] = unsnd
;
24273 dwarf2_complex_location_expr_complaint ();
24277 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
24282 case DW_OP_const1u
:
24283 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
24287 case DW_OP_const1s
:
24288 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
24292 case DW_OP_const2u
:
24293 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
24297 case DW_OP_const2s
:
24298 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
24302 case DW_OP_const4u
:
24303 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
24307 case DW_OP_const4s
:
24308 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
24312 case DW_OP_const8u
:
24313 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
24318 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
24324 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
24329 stack
[stacki
+ 1] = stack
[stacki
];
24334 stack
[stacki
- 1] += stack
[stacki
];
24338 case DW_OP_plus_uconst
:
24339 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
24345 stack
[stacki
- 1] -= stack
[stacki
];
24350 /* If we're not the last op, then we definitely can't encode
24351 this using GDB's address_class enum. This is valid for partial
24352 global symbols, although the variable's address will be bogus
24355 dwarf2_complex_location_expr_complaint ();
24358 case DW_OP_GNU_push_tls_address
:
24359 case DW_OP_form_tls_address
:
24360 /* The top of the stack has the offset from the beginning
24361 of the thread control block at which the variable is located. */
24362 /* Nothing should follow this operator, so the top of stack would
24364 /* This is valid for partial global symbols, but the variable's
24365 address will be bogus in the psymtab. Make it always at least
24366 non-zero to not look as a variable garbage collected by linker
24367 which have DW_OP_addr 0. */
24369 dwarf2_complex_location_expr_complaint ();
24373 case DW_OP_GNU_uninit
:
24377 case DW_OP_GNU_addr_index
:
24378 case DW_OP_GNU_const_index
:
24379 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
24386 const char *name
= get_DW_OP_name (op
);
24389 complaint (_("unsupported stack op: '%s'"),
24392 complaint (_("unsupported stack op: '%02x'"),
24396 return (stack
[stacki
]);
24399 /* Enforce maximum stack depth of SIZE-1 to avoid writing
24400 outside of the allocated space. Also enforce minimum>0. */
24401 if (stacki
>= ARRAY_SIZE (stack
) - 1)
24403 complaint (_("location description stack overflow"));
24409 complaint (_("location description stack underflow"));
24413 return (stack
[stacki
]);
24416 /* memory allocation interface */
24418 static struct dwarf_block
*
24419 dwarf_alloc_block (struct dwarf2_cu
*cu
)
24421 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
24424 static struct die_info
*
24425 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
24427 struct die_info
*die
;
24428 size_t size
= sizeof (struct die_info
);
24431 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
24433 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
24434 memset (die
, 0, sizeof (struct die_info
));
24439 /* Macro support. */
24441 /* Return file name relative to the compilation directory of file number I in
24442 *LH's file name table. The result is allocated using xmalloc; the caller is
24443 responsible for freeing it. */
24446 file_file_name (int file
, struct line_header
*lh
)
24448 /* Is the file number a valid index into the line header's file name
24449 table? Remember that file numbers start with one, not zero. */
24450 if (lh
->is_valid_file_index (file
))
24452 const file_entry
*fe
= lh
->file_name_at (file
);
24454 if (!IS_ABSOLUTE_PATH (fe
->name
))
24456 const char *dir
= fe
->include_dir (lh
);
24458 return concat (dir
, SLASH_STRING
, fe
->name
, (char *) NULL
);
24460 return xstrdup (fe
->name
);
24464 /* The compiler produced a bogus file number. We can at least
24465 record the macro definitions made in the file, even if we
24466 won't be able to find the file by name. */
24467 char fake_name
[80];
24469 xsnprintf (fake_name
, sizeof (fake_name
),
24470 "<bad macro file number %d>", file
);
24472 complaint (_("bad file number in macro information (%d)"),
24475 return xstrdup (fake_name
);
24479 /* Return the full name of file number I in *LH's file name table.
24480 Use COMP_DIR as the name of the current directory of the
24481 compilation. The result is allocated using xmalloc; the caller is
24482 responsible for freeing it. */
24484 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
24486 /* Is the file number a valid index into the line header's file name
24487 table? Remember that file numbers start with one, not zero. */
24488 if (lh
->is_valid_file_index (file
))
24490 char *relative
= file_file_name (file
, lh
);
24492 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
24494 return reconcat (relative
, comp_dir
, SLASH_STRING
,
24495 relative
, (char *) NULL
);
24498 return file_file_name (file
, lh
);
24502 static struct macro_source_file
*
24503 macro_start_file (struct dwarf2_cu
*cu
,
24504 int file
, int line
,
24505 struct macro_source_file
*current_file
,
24506 struct line_header
*lh
)
24508 /* File name relative to the compilation directory of this source file. */
24509 char *file_name
= file_file_name (file
, lh
);
24511 if (! current_file
)
24513 /* Note: We don't create a macro table for this compilation unit
24514 at all until we actually get a filename. */
24515 struct macro_table
*macro_table
= cu
->get_builder ()->get_macro_table ();
24517 /* If we have no current file, then this must be the start_file
24518 directive for the compilation unit's main source file. */
24519 current_file
= macro_set_main (macro_table
, file_name
);
24520 macro_define_special (macro_table
);
24523 current_file
= macro_include (current_file
, line
, file_name
);
24527 return current_file
;
24530 static const char *
24531 consume_improper_spaces (const char *p
, const char *body
)
24535 complaint (_("macro definition contains spaces "
24536 "in formal argument list:\n`%s'"),
24548 parse_macro_definition (struct macro_source_file
*file
, int line
,
24553 /* The body string takes one of two forms. For object-like macro
24554 definitions, it should be:
24556 <macro name> " " <definition>
24558 For function-like macro definitions, it should be:
24560 <macro name> "() " <definition>
24562 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24564 Spaces may appear only where explicitly indicated, and in the
24567 The Dwarf 2 spec says that an object-like macro's name is always
24568 followed by a space, but versions of GCC around March 2002 omit
24569 the space when the macro's definition is the empty string.
24571 The Dwarf 2 spec says that there should be no spaces between the
24572 formal arguments in a function-like macro's formal argument list,
24573 but versions of GCC around March 2002 include spaces after the
24577 /* Find the extent of the macro name. The macro name is terminated
24578 by either a space or null character (for an object-like macro) or
24579 an opening paren (for a function-like macro). */
24580 for (p
= body
; *p
; p
++)
24581 if (*p
== ' ' || *p
== '(')
24584 if (*p
== ' ' || *p
== '\0')
24586 /* It's an object-like macro. */
24587 int name_len
= p
- body
;
24588 char *name
= savestring (body
, name_len
);
24589 const char *replacement
;
24592 replacement
= body
+ name_len
+ 1;
24595 dwarf2_macro_malformed_definition_complaint (body
);
24596 replacement
= body
+ name_len
;
24599 macro_define_object (file
, line
, name
, replacement
);
24603 else if (*p
== '(')
24605 /* It's a function-like macro. */
24606 char *name
= savestring (body
, p
- body
);
24609 char **argv
= XNEWVEC (char *, argv_size
);
24613 p
= consume_improper_spaces (p
, body
);
24615 /* Parse the formal argument list. */
24616 while (*p
&& *p
!= ')')
24618 /* Find the extent of the current argument name. */
24619 const char *arg_start
= p
;
24621 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
24624 if (! *p
|| p
== arg_start
)
24625 dwarf2_macro_malformed_definition_complaint (body
);
24628 /* Make sure argv has room for the new argument. */
24629 if (argc
>= argv_size
)
24632 argv
= XRESIZEVEC (char *, argv
, argv_size
);
24635 argv
[argc
++] = savestring (arg_start
, p
- arg_start
);
24638 p
= consume_improper_spaces (p
, body
);
24640 /* Consume the comma, if present. */
24645 p
= consume_improper_spaces (p
, body
);
24654 /* Perfectly formed definition, no complaints. */
24655 macro_define_function (file
, line
, name
,
24656 argc
, (const char **) argv
,
24658 else if (*p
== '\0')
24660 /* Complain, but do define it. */
24661 dwarf2_macro_malformed_definition_complaint (body
);
24662 macro_define_function (file
, line
, name
,
24663 argc
, (const char **) argv
,
24667 /* Just complain. */
24668 dwarf2_macro_malformed_definition_complaint (body
);
24671 /* Just complain. */
24672 dwarf2_macro_malformed_definition_complaint (body
);
24678 for (i
= 0; i
< argc
; i
++)
24684 dwarf2_macro_malformed_definition_complaint (body
);
24687 /* Skip some bytes from BYTES according to the form given in FORM.
24688 Returns the new pointer. */
24690 static const gdb_byte
*
24691 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
24692 enum dwarf_form form
,
24693 unsigned int offset_size
,
24694 struct dwarf2_section_info
*section
)
24696 unsigned int bytes_read
;
24700 case DW_FORM_data1
:
24705 case DW_FORM_data2
:
24709 case DW_FORM_data4
:
24713 case DW_FORM_data8
:
24717 case DW_FORM_data16
:
24721 case DW_FORM_string
:
24722 read_direct_string (abfd
, bytes
, &bytes_read
);
24723 bytes
+= bytes_read
;
24726 case DW_FORM_sec_offset
:
24728 case DW_FORM_GNU_strp_alt
:
24729 bytes
+= offset_size
;
24732 case DW_FORM_block
:
24733 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
24734 bytes
+= bytes_read
;
24737 case DW_FORM_block1
:
24738 bytes
+= 1 + read_1_byte (abfd
, bytes
);
24740 case DW_FORM_block2
:
24741 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
24743 case DW_FORM_block4
:
24744 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
24747 case DW_FORM_addrx
:
24748 case DW_FORM_sdata
:
24750 case DW_FORM_udata
:
24751 case DW_FORM_GNU_addr_index
:
24752 case DW_FORM_GNU_str_index
:
24753 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
24756 dwarf2_section_buffer_overflow_complaint (section
);
24761 case DW_FORM_implicit_const
:
24766 complaint (_("invalid form 0x%x in `%s'"),
24767 form
, get_section_name (section
));
24775 /* A helper for dwarf_decode_macros that handles skipping an unknown
24776 opcode. Returns an updated pointer to the macro data buffer; or,
24777 on error, issues a complaint and returns NULL. */
24779 static const gdb_byte
*
24780 skip_unknown_opcode (unsigned int opcode
,
24781 const gdb_byte
**opcode_definitions
,
24782 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
24784 unsigned int offset_size
,
24785 struct dwarf2_section_info
*section
)
24787 unsigned int bytes_read
, i
;
24789 const gdb_byte
*defn
;
24791 if (opcode_definitions
[opcode
] == NULL
)
24793 complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24798 defn
= opcode_definitions
[opcode
];
24799 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
24800 defn
+= bytes_read
;
24802 for (i
= 0; i
< arg
; ++i
)
24804 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
,
24805 (enum dwarf_form
) defn
[i
], offset_size
,
24807 if (mac_ptr
== NULL
)
24809 /* skip_form_bytes already issued the complaint. */
24817 /* A helper function which parses the header of a macro section.
24818 If the macro section is the extended (for now called "GNU") type,
24819 then this updates *OFFSET_SIZE. Returns a pointer to just after
24820 the header, or issues a complaint and returns NULL on error. */
24822 static const gdb_byte
*
24823 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
24825 const gdb_byte
*mac_ptr
,
24826 unsigned int *offset_size
,
24827 int section_is_gnu
)
24829 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
24831 if (section_is_gnu
)
24833 unsigned int version
, flags
;
24835 version
= read_2_bytes (abfd
, mac_ptr
);
24836 if (version
!= 4 && version
!= 5)
24838 complaint (_("unrecognized version `%d' in .debug_macro section"),
24844 flags
= read_1_byte (abfd
, mac_ptr
);
24846 *offset_size
= (flags
& 1) ? 8 : 4;
24848 if ((flags
& 2) != 0)
24849 /* We don't need the line table offset. */
24850 mac_ptr
+= *offset_size
;
24852 /* Vendor opcode descriptions. */
24853 if ((flags
& 4) != 0)
24855 unsigned int i
, count
;
24857 count
= read_1_byte (abfd
, mac_ptr
);
24859 for (i
= 0; i
< count
; ++i
)
24861 unsigned int opcode
, bytes_read
;
24864 opcode
= read_1_byte (abfd
, mac_ptr
);
24866 opcode_definitions
[opcode
] = mac_ptr
;
24867 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24868 mac_ptr
+= bytes_read
;
24877 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24878 including DW_MACRO_import. */
24881 dwarf_decode_macro_bytes (struct dwarf2_cu
*cu
,
24883 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
24884 struct macro_source_file
*current_file
,
24885 struct line_header
*lh
,
24886 struct dwarf2_section_info
*section
,
24887 int section_is_gnu
, int section_is_dwz
,
24888 unsigned int offset_size
,
24889 htab_t include_hash
)
24891 struct dwarf2_per_objfile
*dwarf2_per_objfile
24892 = cu
->per_cu
->dwarf2_per_objfile
;
24893 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24894 enum dwarf_macro_record_type macinfo_type
;
24895 int at_commandline
;
24896 const gdb_byte
*opcode_definitions
[256];
24898 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
24899 &offset_size
, section_is_gnu
);
24900 if (mac_ptr
== NULL
)
24902 /* We already issued a complaint. */
24906 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24907 GDB is still reading the definitions from command line. First
24908 DW_MACINFO_start_file will need to be ignored as it was already executed
24909 to create CURRENT_FILE for the main source holding also the command line
24910 definitions. On first met DW_MACINFO_start_file this flag is reset to
24911 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24913 at_commandline
= 1;
24917 /* Do we at least have room for a macinfo type byte? */
24918 if (mac_ptr
>= mac_end
)
24920 dwarf2_section_buffer_overflow_complaint (section
);
24924 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
24927 /* Note that we rely on the fact that the corresponding GNU and
24928 DWARF constants are the same. */
24930 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24931 switch (macinfo_type
)
24933 /* A zero macinfo type indicates the end of the macro
24938 case DW_MACRO_define
:
24939 case DW_MACRO_undef
:
24940 case DW_MACRO_define_strp
:
24941 case DW_MACRO_undef_strp
:
24942 case DW_MACRO_define_sup
:
24943 case DW_MACRO_undef_sup
:
24945 unsigned int bytes_read
;
24950 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24951 mac_ptr
+= bytes_read
;
24953 if (macinfo_type
== DW_MACRO_define
24954 || macinfo_type
== DW_MACRO_undef
)
24956 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24957 mac_ptr
+= bytes_read
;
24961 LONGEST str_offset
;
24963 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
24964 mac_ptr
+= offset_size
;
24966 if (macinfo_type
== DW_MACRO_define_sup
24967 || macinfo_type
== DW_MACRO_undef_sup
24970 struct dwz_file
*dwz
24971 = dwarf2_get_dwz_file (dwarf2_per_objfile
);
24973 body
= read_indirect_string_from_dwz (objfile
,
24977 body
= read_indirect_string_at_offset (dwarf2_per_objfile
,
24981 is_define
= (macinfo_type
== DW_MACRO_define
24982 || macinfo_type
== DW_MACRO_define_strp
24983 || macinfo_type
== DW_MACRO_define_sup
);
24984 if (! current_file
)
24986 /* DWARF violation as no main source is present. */
24987 complaint (_("debug info with no main source gives macro %s "
24989 is_define
? _("definition") : _("undefinition"),
24993 if ((line
== 0 && !at_commandline
)
24994 || (line
!= 0 && at_commandline
))
24995 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24996 at_commandline
? _("command-line") : _("in-file"),
24997 is_define
? _("definition") : _("undefinition"),
24998 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
25002 /* Fedora's rpm-build's "debugedit" binary
25003 corrupted .debug_macro sections.
25006 https://bugzilla.redhat.com/show_bug.cgi?id=1708786 */
25007 complaint (_("debug info gives %s invalid macro %s "
25008 "without body (corrupted?) at line %d "
25010 at_commandline
? _("command-line") : _("in-file"),
25011 is_define
? _("definition") : _("undefinition"),
25012 line
, current_file
->filename
);
25014 else if (is_define
)
25015 parse_macro_definition (current_file
, line
, body
);
25018 gdb_assert (macinfo_type
== DW_MACRO_undef
25019 || macinfo_type
== DW_MACRO_undef_strp
25020 || macinfo_type
== DW_MACRO_undef_sup
);
25021 macro_undef (current_file
, line
, body
);
25026 case DW_MACRO_start_file
:
25028 unsigned int bytes_read
;
25031 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25032 mac_ptr
+= bytes_read
;
25033 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25034 mac_ptr
+= bytes_read
;
25036 if ((line
== 0 && !at_commandline
)
25037 || (line
!= 0 && at_commandline
))
25038 complaint (_("debug info gives source %d included "
25039 "from %s at %s line %d"),
25040 file
, at_commandline
? _("command-line") : _("file"),
25041 line
== 0 ? _("zero") : _("non-zero"), line
);
25043 if (at_commandline
)
25045 /* This DW_MACRO_start_file was executed in the
25047 at_commandline
= 0;
25050 current_file
= macro_start_file (cu
, file
, line
, current_file
,
25055 case DW_MACRO_end_file
:
25056 if (! current_file
)
25057 complaint (_("macro debug info has an unmatched "
25058 "`close_file' directive"));
25061 current_file
= current_file
->included_by
;
25062 if (! current_file
)
25064 enum dwarf_macro_record_type next_type
;
25066 /* GCC circa March 2002 doesn't produce the zero
25067 type byte marking the end of the compilation
25068 unit. Complain if it's not there, but exit no
25071 /* Do we at least have room for a macinfo type byte? */
25072 if (mac_ptr
>= mac_end
)
25074 dwarf2_section_buffer_overflow_complaint (section
);
25078 /* We don't increment mac_ptr here, so this is just
25081 = (enum dwarf_macro_record_type
) read_1_byte (abfd
,
25083 if (next_type
!= 0)
25084 complaint (_("no terminating 0-type entry for "
25085 "macros in `.debug_macinfo' section"));
25092 case DW_MACRO_import
:
25093 case DW_MACRO_import_sup
:
25097 bfd
*include_bfd
= abfd
;
25098 struct dwarf2_section_info
*include_section
= section
;
25099 const gdb_byte
*include_mac_end
= mac_end
;
25100 int is_dwz
= section_is_dwz
;
25101 const gdb_byte
*new_mac_ptr
;
25103 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
25104 mac_ptr
+= offset_size
;
25106 if (macinfo_type
== DW_MACRO_import_sup
)
25108 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
25110 dwarf2_read_section (objfile
, &dwz
->macro
);
25112 include_section
= &dwz
->macro
;
25113 include_bfd
= get_section_bfd_owner (include_section
);
25114 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
25118 new_mac_ptr
= include_section
->buffer
+ offset
;
25119 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
25123 /* This has actually happened; see
25124 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
25125 complaint (_("recursive DW_MACRO_import in "
25126 ".debug_macro section"));
25130 *slot
= (void *) new_mac_ptr
;
25132 dwarf_decode_macro_bytes (cu
, include_bfd
, new_mac_ptr
,
25133 include_mac_end
, current_file
, lh
,
25134 section
, section_is_gnu
, is_dwz
,
25135 offset_size
, include_hash
);
25137 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
25142 case DW_MACINFO_vendor_ext
:
25143 if (!section_is_gnu
)
25145 unsigned int bytes_read
;
25147 /* This reads the constant, but since we don't recognize
25148 any vendor extensions, we ignore it. */
25149 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25150 mac_ptr
+= bytes_read
;
25151 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
25152 mac_ptr
+= bytes_read
;
25154 /* We don't recognize any vendor extensions. */
25160 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
25161 mac_ptr
, mac_end
, abfd
, offset_size
,
25163 if (mac_ptr
== NULL
)
25168 } while (macinfo_type
!= 0);
25172 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
25173 int section_is_gnu
)
25175 struct dwarf2_per_objfile
*dwarf2_per_objfile
25176 = cu
->per_cu
->dwarf2_per_objfile
;
25177 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
25178 struct line_header
*lh
= cu
->line_header
;
25180 const gdb_byte
*mac_ptr
, *mac_end
;
25181 struct macro_source_file
*current_file
= 0;
25182 enum dwarf_macro_record_type macinfo_type
;
25183 unsigned int offset_size
= cu
->header
.offset_size
;
25184 const gdb_byte
*opcode_definitions
[256];
25186 struct dwarf2_section_info
*section
;
25187 const char *section_name
;
25189 if (cu
->dwo_unit
!= NULL
)
25191 if (section_is_gnu
)
25193 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
25194 section_name
= ".debug_macro.dwo";
25198 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
25199 section_name
= ".debug_macinfo.dwo";
25204 if (section_is_gnu
)
25206 section
= &dwarf2_per_objfile
->macro
;
25207 section_name
= ".debug_macro";
25211 section
= &dwarf2_per_objfile
->macinfo
;
25212 section_name
= ".debug_macinfo";
25216 dwarf2_read_section (objfile
, section
);
25217 if (section
->buffer
== NULL
)
25219 complaint (_("missing %s section"), section_name
);
25222 abfd
= get_section_bfd_owner (section
);
25224 /* First pass: Find the name of the base filename.
25225 This filename is needed in order to process all macros whose definition
25226 (or undefinition) comes from the command line. These macros are defined
25227 before the first DW_MACINFO_start_file entry, and yet still need to be
25228 associated to the base file.
25230 To determine the base file name, we scan the macro definitions until we
25231 reach the first DW_MACINFO_start_file entry. We then initialize
25232 CURRENT_FILE accordingly so that any macro definition found before the
25233 first DW_MACINFO_start_file can still be associated to the base file. */
25235 mac_ptr
= section
->buffer
+ offset
;
25236 mac_end
= section
->buffer
+ section
->size
;
25238 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
25239 &offset_size
, section_is_gnu
);
25240 if (mac_ptr
== NULL
)
25242 /* We already issued a complaint. */
25248 /* Do we at least have room for a macinfo type byte? */
25249 if (mac_ptr
>= mac_end
)
25251 /* Complaint is printed during the second pass as GDB will probably
25252 stop the first pass earlier upon finding
25253 DW_MACINFO_start_file. */
25257 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
25260 /* Note that we rely on the fact that the corresponding GNU and
25261 DWARF constants are the same. */
25263 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
25264 switch (macinfo_type
)
25266 /* A zero macinfo type indicates the end of the macro
25271 case DW_MACRO_define
:
25272 case DW_MACRO_undef
:
25273 /* Only skip the data by MAC_PTR. */
25275 unsigned int bytes_read
;
25277 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25278 mac_ptr
+= bytes_read
;
25279 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
25280 mac_ptr
+= bytes_read
;
25284 case DW_MACRO_start_file
:
25286 unsigned int bytes_read
;
25289 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25290 mac_ptr
+= bytes_read
;
25291 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25292 mac_ptr
+= bytes_read
;
25294 current_file
= macro_start_file (cu
, file
, line
, current_file
, lh
);
25298 case DW_MACRO_end_file
:
25299 /* No data to skip by MAC_PTR. */
25302 case DW_MACRO_define_strp
:
25303 case DW_MACRO_undef_strp
:
25304 case DW_MACRO_define_sup
:
25305 case DW_MACRO_undef_sup
:
25307 unsigned int bytes_read
;
25309 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25310 mac_ptr
+= bytes_read
;
25311 mac_ptr
+= offset_size
;
25315 case DW_MACRO_import
:
25316 case DW_MACRO_import_sup
:
25317 /* Note that, according to the spec, a transparent include
25318 chain cannot call DW_MACRO_start_file. So, we can just
25319 skip this opcode. */
25320 mac_ptr
+= offset_size
;
25323 case DW_MACINFO_vendor_ext
:
25324 /* Only skip the data by MAC_PTR. */
25325 if (!section_is_gnu
)
25327 unsigned int bytes_read
;
25329 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25330 mac_ptr
+= bytes_read
;
25331 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
25332 mac_ptr
+= bytes_read
;
25337 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
25338 mac_ptr
, mac_end
, abfd
, offset_size
,
25340 if (mac_ptr
== NULL
)
25345 } while (macinfo_type
!= 0 && current_file
== NULL
);
25347 /* Second pass: Process all entries.
25349 Use the AT_COMMAND_LINE flag to determine whether we are still processing
25350 command-line macro definitions/undefinitions. This flag is unset when we
25351 reach the first DW_MACINFO_start_file entry. */
25353 htab_up
include_hash (htab_create_alloc (1, htab_hash_pointer
,
25355 NULL
, xcalloc
, xfree
));
25356 mac_ptr
= section
->buffer
+ offset
;
25357 slot
= htab_find_slot (include_hash
.get (), mac_ptr
, INSERT
);
25358 *slot
= (void *) mac_ptr
;
25359 dwarf_decode_macro_bytes (cu
, abfd
, mac_ptr
, mac_end
,
25360 current_file
, lh
, section
,
25361 section_is_gnu
, 0, offset_size
,
25362 include_hash
.get ());
25365 /* Check if the attribute's form is a DW_FORM_block*
25366 if so return true else false. */
25369 attr_form_is_block (const struct attribute
*attr
)
25371 return (attr
== NULL
? 0 :
25372 attr
->form
== DW_FORM_block1
25373 || attr
->form
== DW_FORM_block2
25374 || attr
->form
== DW_FORM_block4
25375 || attr
->form
== DW_FORM_block
25376 || attr
->form
== DW_FORM_exprloc
);
25379 /* Return non-zero if ATTR's value is a section offset --- classes
25380 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
25381 You may use DW_UNSND (attr) to retrieve such offsets.
25383 Section 7.5.4, "Attribute Encodings", explains that no attribute
25384 may have a value that belongs to more than one of these classes; it
25385 would be ambiguous if we did, because we use the same forms for all
25389 attr_form_is_section_offset (const struct attribute
*attr
)
25391 return (attr
->form
== DW_FORM_data4
25392 || attr
->form
== DW_FORM_data8
25393 || attr
->form
== DW_FORM_sec_offset
);
25396 /* Return non-zero if ATTR's value falls in the 'constant' class, or
25397 zero otherwise. When this function returns true, you can apply
25398 dwarf2_get_attr_constant_value to it.
25400 However, note that for some attributes you must check
25401 attr_form_is_section_offset before using this test. DW_FORM_data4
25402 and DW_FORM_data8 are members of both the constant class, and of
25403 the classes that contain offsets into other debug sections
25404 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
25405 that, if an attribute's can be either a constant or one of the
25406 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
25407 taken as section offsets, not constants.
25409 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
25410 cannot handle that. */
25413 attr_form_is_constant (const struct attribute
*attr
)
25415 switch (attr
->form
)
25417 case DW_FORM_sdata
:
25418 case DW_FORM_udata
:
25419 case DW_FORM_data1
:
25420 case DW_FORM_data2
:
25421 case DW_FORM_data4
:
25422 case DW_FORM_data8
:
25423 case DW_FORM_implicit_const
:
25431 /* DW_ADDR is always stored already as sect_offset; despite for the forms
25432 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
25435 attr_form_is_ref (const struct attribute
*attr
)
25437 switch (attr
->form
)
25439 case DW_FORM_ref_addr
:
25444 case DW_FORM_ref_udata
:
25445 case DW_FORM_GNU_ref_alt
:
25452 /* Return the .debug_loc section to use for CU.
25453 For DWO files use .debug_loc.dwo. */
25455 static struct dwarf2_section_info
*
25456 cu_debug_loc_section (struct dwarf2_cu
*cu
)
25458 struct dwarf2_per_objfile
*dwarf2_per_objfile
25459 = cu
->per_cu
->dwarf2_per_objfile
;
25463 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
25465 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
25467 return (cu
->header
.version
>= 5 ? &dwarf2_per_objfile
->loclists
25468 : &dwarf2_per_objfile
->loc
);
25471 /* A helper function that fills in a dwarf2_loclist_baton. */
25474 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
25475 struct dwarf2_loclist_baton
*baton
,
25476 const struct attribute
*attr
)
25478 struct dwarf2_per_objfile
*dwarf2_per_objfile
25479 = cu
->per_cu
->dwarf2_per_objfile
;
25480 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
25482 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
25484 baton
->per_cu
= cu
->per_cu
;
25485 gdb_assert (baton
->per_cu
);
25486 /* We don't know how long the location list is, but make sure we
25487 don't run off the edge of the section. */
25488 baton
->size
= section
->size
- DW_UNSND (attr
);
25489 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
25490 baton
->base_address
= cu
->base_address
;
25491 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
25495 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
25496 struct dwarf2_cu
*cu
, int is_block
)
25498 struct dwarf2_per_objfile
*dwarf2_per_objfile
25499 = cu
->per_cu
->dwarf2_per_objfile
;
25500 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
25501 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
25503 if (attr_form_is_section_offset (attr
)
25504 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
25505 the section. If so, fall through to the complaint in the
25507 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
25509 struct dwarf2_loclist_baton
*baton
;
25511 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
25513 fill_in_loclist_baton (cu
, baton
, attr
);
25515 if (cu
->base_known
== 0)
25516 complaint (_("Location list used without "
25517 "specifying the CU base address."));
25519 SYMBOL_ACLASS_INDEX (sym
) = (is_block
25520 ? dwarf2_loclist_block_index
25521 : dwarf2_loclist_index
);
25522 SYMBOL_LOCATION_BATON (sym
) = baton
;
25526 struct dwarf2_locexpr_baton
*baton
;
25528 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
25529 baton
->per_cu
= cu
->per_cu
;
25530 gdb_assert (baton
->per_cu
);
25532 if (attr_form_is_block (attr
))
25534 /* Note that we're just copying the block's data pointer
25535 here, not the actual data. We're still pointing into the
25536 info_buffer for SYM's objfile; right now we never release
25537 that buffer, but when we do clean up properly this may
25539 baton
->size
= DW_BLOCK (attr
)->size
;
25540 baton
->data
= DW_BLOCK (attr
)->data
;
25544 dwarf2_invalid_attrib_class_complaint ("location description",
25545 sym
->natural_name ());
25549 SYMBOL_ACLASS_INDEX (sym
) = (is_block
25550 ? dwarf2_locexpr_block_index
25551 : dwarf2_locexpr_index
);
25552 SYMBOL_LOCATION_BATON (sym
) = baton
;
25556 /* Return the OBJFILE associated with the compilation unit CU. If CU
25557 came from a separate debuginfo file, then the master objfile is
25561 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
25563 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25565 /* Return the master objfile, so that we can report and look up the
25566 correct file containing this variable. */
25567 if (objfile
->separate_debug_objfile_backlink
)
25568 objfile
= objfile
->separate_debug_objfile_backlink
;
25573 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25574 (CU_HEADERP is unused in such case) or prepare a temporary copy at
25575 CU_HEADERP first. */
25577 static const struct comp_unit_head
*
25578 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
25579 struct dwarf2_per_cu_data
*per_cu
)
25581 const gdb_byte
*info_ptr
;
25584 return &per_cu
->cu
->header
;
25586 info_ptr
= per_cu
->section
->buffer
+ to_underlying (per_cu
->sect_off
);
25588 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
25589 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->section
,
25590 rcuh_kind::COMPILE
);
25595 /* Return the address size given in the compilation unit header for CU. */
25598 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
25600 struct comp_unit_head cu_header_local
;
25601 const struct comp_unit_head
*cu_headerp
;
25603 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25605 return cu_headerp
->addr_size
;
25608 /* Return the offset size given in the compilation unit header for CU. */
25611 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
25613 struct comp_unit_head cu_header_local
;
25614 const struct comp_unit_head
*cu_headerp
;
25616 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25618 return cu_headerp
->offset_size
;
25621 /* See its dwarf2loc.h declaration. */
25624 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
25626 struct comp_unit_head cu_header_local
;
25627 const struct comp_unit_head
*cu_headerp
;
25629 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25631 if (cu_headerp
->version
== 2)
25632 return cu_headerp
->addr_size
;
25634 return cu_headerp
->offset_size
;
25637 /* Return the text offset of the CU. The returned offset comes from
25638 this CU's objfile. If this objfile came from a separate debuginfo
25639 file, then the offset may be different from the corresponding
25640 offset in the parent objfile. */
25643 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
25645 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25647 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
25650 /* Return a type that is a generic pointer type, the size of which matches
25651 the address size given in the compilation unit header for PER_CU. */
25652 static struct type
*
25653 dwarf2_per_cu_addr_type (struct dwarf2_per_cu_data
*per_cu
)
25655 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25656 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
25657 struct type
*addr_type
= lookup_pointer_type (void_type
);
25658 int addr_size
= dwarf2_per_cu_addr_size (per_cu
);
25660 if (TYPE_LENGTH (addr_type
) == addr_size
)
25664 = dwarf2_per_cu_addr_sized_int_type (per_cu
, TYPE_UNSIGNED (addr_type
));
25668 /* Return DWARF version number of PER_CU. */
25671 dwarf2_version (struct dwarf2_per_cu_data
*per_cu
)
25673 return per_cu
->dwarf_version
;
25676 /* Locate the .debug_info compilation unit from CU's objfile which contains
25677 the DIE at OFFSET. Raises an error on failure. */
25679 static struct dwarf2_per_cu_data
*
25680 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
25681 unsigned int offset_in_dwz
,
25682 struct dwarf2_per_objfile
*dwarf2_per_objfile
)
25684 struct dwarf2_per_cu_data
*this_cu
;
25688 high
= dwarf2_per_objfile
->all_comp_units
.size () - 1;
25691 struct dwarf2_per_cu_data
*mid_cu
;
25692 int mid
= low
+ (high
- low
) / 2;
25694 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
25695 if (mid_cu
->is_dwz
> offset_in_dwz
25696 || (mid_cu
->is_dwz
== offset_in_dwz
25697 && mid_cu
->sect_off
+ mid_cu
->length
>= sect_off
))
25702 gdb_assert (low
== high
);
25703 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
25704 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
25706 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
25707 error (_("Dwarf Error: could not find partial DIE containing "
25708 "offset %s [in module %s]"),
25709 sect_offset_str (sect_off
),
25710 bfd_get_filename (dwarf2_per_objfile
->objfile
->obfd
));
25712 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->sect_off
25714 return dwarf2_per_objfile
->all_comp_units
[low
-1];
25718 if (low
== dwarf2_per_objfile
->all_comp_units
.size () - 1
25719 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
25720 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
25721 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
25726 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25728 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data
*per_cu_
)
25729 : per_cu (per_cu_
),
25731 has_loclist (false),
25732 checked_producer (false),
25733 producer_is_gxx_lt_4_6 (false),
25734 producer_is_gcc_lt_4_3 (false),
25735 producer_is_icc (false),
25736 producer_is_icc_lt_14 (false),
25737 producer_is_codewarrior (false),
25738 processing_has_namespace_info (false)
25743 /* Destroy a dwarf2_cu. */
25745 dwarf2_cu::~dwarf2_cu ()
25750 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25753 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
25754 enum language pretend_language
)
25756 struct attribute
*attr
;
25758 /* Set the language we're debugging. */
25759 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
25760 if (attr
!= nullptr)
25761 set_cu_language (DW_UNSND (attr
), cu
);
25764 cu
->language
= pretend_language
;
25765 cu
->language_defn
= language_def (cu
->language
);
25768 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
25771 /* Increase the age counter on each cached compilation unit, and free
25772 any that are too old. */
25775 age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
25777 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
25779 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
25780 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25781 while (per_cu
!= NULL
)
25783 per_cu
->cu
->last_used
++;
25784 if (per_cu
->cu
->last_used
<= dwarf_max_cache_age
)
25785 dwarf2_mark (per_cu
->cu
);
25786 per_cu
= per_cu
->cu
->read_in_chain
;
25789 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25790 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
25791 while (per_cu
!= NULL
)
25793 struct dwarf2_per_cu_data
*next_cu
;
25795 next_cu
= per_cu
->cu
->read_in_chain
;
25797 if (!per_cu
->cu
->mark
)
25800 *last_chain
= next_cu
;
25803 last_chain
= &per_cu
->cu
->read_in_chain
;
25809 /* Remove a single compilation unit from the cache. */
25812 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
25814 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
25815 struct dwarf2_per_objfile
*dwarf2_per_objfile
25816 = target_per_cu
->dwarf2_per_objfile
;
25818 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25819 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
25820 while (per_cu
!= NULL
)
25822 struct dwarf2_per_cu_data
*next_cu
;
25824 next_cu
= per_cu
->cu
->read_in_chain
;
25826 if (per_cu
== target_per_cu
)
25830 *last_chain
= next_cu
;
25834 last_chain
= &per_cu
->cu
->read_in_chain
;
25840 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25841 We store these in a hash table separate from the DIEs, and preserve them
25842 when the DIEs are flushed out of cache.
25844 The CU "per_cu" pointer is needed because offset alone is not enough to
25845 uniquely identify the type. A file may have multiple .debug_types sections,
25846 or the type may come from a DWO file. Furthermore, while it's more logical
25847 to use per_cu->section+offset, with Fission the section with the data is in
25848 the DWO file but we don't know that section at the point we need it.
25849 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25850 because we can enter the lookup routine, get_die_type_at_offset, from
25851 outside this file, and thus won't necessarily have PER_CU->cu.
25852 Fortunately, PER_CU is stable for the life of the objfile. */
25854 struct dwarf2_per_cu_offset_and_type
25856 const struct dwarf2_per_cu_data
*per_cu
;
25857 sect_offset sect_off
;
25861 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25864 per_cu_offset_and_type_hash (const void *item
)
25866 const struct dwarf2_per_cu_offset_and_type
*ofs
25867 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
25869 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
25872 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25875 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
25877 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
25878 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
25879 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
25880 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
25882 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
25883 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
25886 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25887 table if necessary. For convenience, return TYPE.
25889 The DIEs reading must have careful ordering to:
25890 * Not cause infinite loops trying to read in DIEs as a prerequisite for
25891 reading current DIE.
25892 * Not trying to dereference contents of still incompletely read in types
25893 while reading in other DIEs.
25894 * Enable referencing still incompletely read in types just by a pointer to
25895 the type without accessing its fields.
25897 Therefore caller should follow these rules:
25898 * Try to fetch any prerequisite types we may need to build this DIE type
25899 before building the type and calling set_die_type.
25900 * After building type call set_die_type for current DIE as soon as
25901 possible before fetching more types to complete the current type.
25902 * Make the type as complete as possible before fetching more types. */
25904 static struct type
*
25905 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
25907 struct dwarf2_per_objfile
*dwarf2_per_objfile
25908 = cu
->per_cu
->dwarf2_per_objfile
;
25909 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
25910 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
25911 struct attribute
*attr
;
25912 struct dynamic_prop prop
;
25914 /* For Ada types, make sure that the gnat-specific data is always
25915 initialized (if not already set). There are a few types where
25916 we should not be doing so, because the type-specific area is
25917 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25918 where the type-specific area is used to store the floatformat).
25919 But this is not a problem, because the gnat-specific information
25920 is actually not needed for these types. */
25921 if (need_gnat_info (cu
)
25922 && TYPE_CODE (type
) != TYPE_CODE_FUNC
25923 && TYPE_CODE (type
) != TYPE_CODE_FLT
25924 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
25925 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
25926 && TYPE_CODE (type
) != TYPE_CODE_METHOD
25927 && !HAVE_GNAT_AUX_INFO (type
))
25928 INIT_GNAT_SPECIFIC (type
);
25930 /* Read DW_AT_allocated and set in type. */
25931 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
25932 if (attr_form_is_block (attr
))
25934 struct type
*prop_type
25935 = dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
25936 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25937 add_dyn_prop (DYN_PROP_ALLOCATED
, prop
, type
);
25939 else if (attr
!= NULL
)
25941 complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25942 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
25943 sect_offset_str (die
->sect_off
));
25946 /* Read DW_AT_associated and set in type. */
25947 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
25948 if (attr_form_is_block (attr
))
25950 struct type
*prop_type
25951 = dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
25952 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25953 add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
, type
);
25955 else if (attr
!= NULL
)
25957 complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25958 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
25959 sect_offset_str (die
->sect_off
));
25962 /* Read DW_AT_data_location and set in type. */
25963 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
25964 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
,
25965 dwarf2_per_cu_addr_type (cu
->per_cu
)))
25966 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
);
25968 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
25970 dwarf2_per_objfile
->die_type_hash
=
25971 htab_create_alloc_ex (127,
25972 per_cu_offset_and_type_hash
,
25973 per_cu_offset_and_type_eq
,
25975 &objfile
->objfile_obstack
,
25976 hashtab_obstack_allocate
,
25977 dummy_obstack_deallocate
);
25980 ofs
.per_cu
= cu
->per_cu
;
25981 ofs
.sect_off
= die
->sect_off
;
25983 slot
= (struct dwarf2_per_cu_offset_and_type
**)
25984 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
25986 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25987 sect_offset_str (die
->sect_off
));
25988 *slot
= XOBNEW (&objfile
->objfile_obstack
,
25989 struct dwarf2_per_cu_offset_and_type
);
25994 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25995 or return NULL if the die does not have a saved type. */
25997 static struct type
*
25998 get_die_type_at_offset (sect_offset sect_off
,
25999 struct dwarf2_per_cu_data
*per_cu
)
26001 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
26002 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
26004 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
26007 ofs
.per_cu
= per_cu
;
26008 ofs
.sect_off
= sect_off
;
26009 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
26010 htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
));
26017 /* Look up the type for DIE in CU in die_type_hash,
26018 or return NULL if DIE does not have a saved type. */
26020 static struct type
*
26021 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
26023 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
);
26026 /* Add a dependence relationship from CU to REF_PER_CU. */
26029 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
26030 struct dwarf2_per_cu_data
*ref_per_cu
)
26034 if (cu
->dependencies
== NULL
)
26036 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
26037 NULL
, &cu
->comp_unit_obstack
,
26038 hashtab_obstack_allocate
,
26039 dummy_obstack_deallocate
);
26041 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
26043 *slot
= ref_per_cu
;
26046 /* Subroutine of dwarf2_mark to pass to htab_traverse.
26047 Set the mark field in every compilation unit in the
26048 cache that we must keep because we are keeping CU. */
26051 dwarf2_mark_helper (void **slot
, void *data
)
26053 struct dwarf2_per_cu_data
*per_cu
;
26055 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
26057 /* cu->dependencies references may not yet have been ever read if QUIT aborts
26058 reading of the chain. As such dependencies remain valid it is not much
26059 useful to track and undo them during QUIT cleanups. */
26060 if (per_cu
->cu
== NULL
)
26063 if (per_cu
->cu
->mark
)
26065 per_cu
->cu
->mark
= true;
26067 if (per_cu
->cu
->dependencies
!= NULL
)
26068 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
26073 /* Set the mark field in CU and in every other compilation unit in the
26074 cache that we must keep because we are keeping CU. */
26077 dwarf2_mark (struct dwarf2_cu
*cu
)
26082 if (cu
->dependencies
!= NULL
)
26083 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
26087 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
26091 per_cu
->cu
->mark
= false;
26092 per_cu
= per_cu
->cu
->read_in_chain
;
26096 /* Trivial hash function for partial_die_info: the hash value of a DIE
26097 is its offset in .debug_info for this objfile. */
26100 partial_die_hash (const void *item
)
26102 const struct partial_die_info
*part_die
26103 = (const struct partial_die_info
*) item
;
26105 return to_underlying (part_die
->sect_off
);
26108 /* Trivial comparison function for partial_die_info structures: two DIEs
26109 are equal if they have the same offset. */
26112 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
26114 const struct partial_die_info
*part_die_lhs
26115 = (const struct partial_die_info
*) item_lhs
;
26116 const struct partial_die_info
*part_die_rhs
26117 = (const struct partial_die_info
*) item_rhs
;
26119 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
26122 struct cmd_list_element
*set_dwarf_cmdlist
;
26123 struct cmd_list_element
*show_dwarf_cmdlist
;
26126 set_dwarf_cmd (const char *args
, int from_tty
)
26128 help_list (set_dwarf_cmdlist
, "maintenance set dwarf ", all_commands
,
26133 show_dwarf_cmd (const char *args
, int from_tty
)
26135 cmd_show_list (show_dwarf_cmdlist
, from_tty
, "");
26138 bool dwarf_always_disassemble
;
26141 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
26142 struct cmd_list_element
*c
, const char *value
)
26144 fprintf_filtered (file
,
26145 _("Whether to always disassemble "
26146 "DWARF expressions is %s.\n"),
26151 show_check_physname (struct ui_file
*file
, int from_tty
,
26152 struct cmd_list_element
*c
, const char *value
)
26154 fprintf_filtered (file
,
26155 _("Whether to check \"physname\" is %s.\n"),
26160 _initialize_dwarf2_read (void)
26162 add_prefix_cmd ("dwarf", class_maintenance
, set_dwarf_cmd
, _("\
26163 Set DWARF specific variables.\n\
26164 Configure DWARF variables such as the cache size."),
26165 &set_dwarf_cmdlist
, "maintenance set dwarf ",
26166 0/*allow-unknown*/, &maintenance_set_cmdlist
);
26168 add_prefix_cmd ("dwarf", class_maintenance
, show_dwarf_cmd
, _("\
26169 Show DWARF specific variables.\n\
26170 Show DWARF variables such as the cache size."),
26171 &show_dwarf_cmdlist
, "maintenance show dwarf ",
26172 0/*allow-unknown*/, &maintenance_show_cmdlist
);
26174 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
26175 &dwarf_max_cache_age
, _("\
26176 Set the upper bound on the age of cached DWARF compilation units."), _("\
26177 Show the upper bound on the age of cached DWARF compilation units."), _("\
26178 A higher limit means that cached compilation units will be stored\n\
26179 in memory longer, and more total memory will be used. Zero disables\n\
26180 caching, which can slow down startup."),
26182 show_dwarf_max_cache_age
,
26183 &set_dwarf_cmdlist
,
26184 &show_dwarf_cmdlist
);
26186 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
26187 &dwarf_always_disassemble
, _("\
26188 Set whether `info address' always disassembles DWARF expressions."), _("\
26189 Show whether `info address' always disassembles DWARF expressions."), _("\
26190 When enabled, DWARF expressions are always printed in an assembly-like\n\
26191 syntax. When disabled, expressions will be printed in a more\n\
26192 conversational style, when possible."),
26194 show_dwarf_always_disassemble
,
26195 &set_dwarf_cmdlist
,
26196 &show_dwarf_cmdlist
);
26198 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
26199 Set debugging of the DWARF reader."), _("\
26200 Show debugging of the DWARF reader."), _("\
26201 When enabled (non-zero), debugging messages are printed during DWARF\n\
26202 reading and symtab expansion. A value of 1 (one) provides basic\n\
26203 information. A value greater than 1 provides more verbose information."),
26206 &setdebuglist
, &showdebuglist
);
26208 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
26209 Set debugging of the DWARF DIE reader."), _("\
26210 Show debugging of the DWARF DIE reader."), _("\
26211 When enabled (non-zero), DIEs are dumped after they are read in.\n\
26212 The value is the maximum depth to print."),
26215 &setdebuglist
, &showdebuglist
);
26217 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
26218 Set debugging of the dwarf line reader."), _("\
26219 Show debugging of the dwarf line reader."), _("\
26220 When enabled (non-zero), line number entries are dumped as they are read in.\n\
26221 A value of 1 (one) provides basic information.\n\
26222 A value greater than 1 provides more verbose information."),
26225 &setdebuglist
, &showdebuglist
);
26227 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
26228 Set cross-checking of \"physname\" code against demangler."), _("\
26229 Show cross-checking of \"physname\" code against demangler."), _("\
26230 When enabled, GDB's internal \"physname\" code is checked against\n\
26232 NULL
, show_check_physname
,
26233 &setdebuglist
, &showdebuglist
);
26235 add_setshow_boolean_cmd ("use-deprecated-index-sections",
26236 no_class
, &use_deprecated_index_sections
, _("\
26237 Set whether to use deprecated gdb_index sections."), _("\
26238 Show whether to use deprecated gdb_index sections."), _("\
26239 When enabled, deprecated .gdb_index sections are used anyway.\n\
26240 Normally they are ignored either because of a missing feature or\n\
26241 performance issue.\n\
26242 Warning: This option must be enabled before gdb reads the file."),
26245 &setlist
, &showlist
);
26247 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
26248 &dwarf2_locexpr_funcs
);
26249 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
26250 &dwarf2_loclist_funcs
);
26252 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
26253 &dwarf2_block_frame_base_locexpr_funcs
);
26254 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
26255 &dwarf2_block_frame_base_loclist_funcs
);
26258 selftests::register_test ("dw2_expand_symtabs_matching",
26259 selftests::dw2_expand_symtabs_matching::run_test
);