1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2019 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 "expression.h"
45 #include "filenames.h" /* for DOSish file names */
48 #include "complaints.h"
49 #include "dwarf2expr.h"
50 #include "dwarf2loc.h"
51 #include "cp-support.h"
57 #include "typeprint.h"
60 #include "completer.h"
61 #include "gdbsupport/vec.h"
65 #include "gdbcore.h" /* for gnutarget */
66 #include "gdb/gdb-index.h"
71 #include "gdbsupport/filestuff.h"
73 #include "namespace.h"
74 #include "gdbsupport/gdb_unlinker.h"
75 #include "gdbsupport/function-view.h"
76 #include "gdbsupport/gdb_optional.h"
77 #include "gdbsupport/underlying.h"
78 #include "gdbsupport/byte-vector.h"
79 #include "gdbsupport/hash_enum.h"
80 #include "filename-seen-cache.h"
83 #include <sys/types.h>
85 #include <unordered_set>
86 #include <unordered_map>
87 #include "gdbsupport/selftest.h"
90 #include <forward_list>
91 #include "rust-lang.h"
92 #include "gdbsupport/pathstuff.h"
94 /* When == 1, print basic high level tracing messages.
95 When > 1, be more verbose.
96 This is in contrast to the low level DIE reading of dwarf_die_debug. */
97 static unsigned int dwarf_read_debug
= 0;
99 /* When non-zero, dump DIEs after they are read in. */
100 static unsigned int dwarf_die_debug
= 0;
102 /* When non-zero, dump line number entries as they are read in. */
103 static unsigned int dwarf_line_debug
= 0;
105 /* When true, cross-check physname against demangler. */
106 static bool check_physname
= false;
108 /* When true, do not reject deprecated .gdb_index sections. */
109 static bool use_deprecated_index_sections
= false;
111 static const struct objfile_key
<dwarf2_per_objfile
> dwarf2_objfile_data_key
;
113 /* The "aclass" indices for various kinds of computed DWARF symbols. */
115 static int dwarf2_locexpr_index
;
116 static int dwarf2_loclist_index
;
117 static int dwarf2_locexpr_block_index
;
118 static int dwarf2_loclist_block_index
;
120 /* An index into a (C++) symbol name component in a symbol name as
121 recorded in the mapped_index's symbol table. For each C++ symbol
122 in the symbol table, we record one entry for the start of each
123 component in the symbol in a table of name components, and then
124 sort the table, in order to be able to binary search symbol names,
125 ignoring leading namespaces, both completion and regular look up.
126 For example, for symbol "A::B::C", we'll have an entry that points
127 to "A::B::C", another that points to "B::C", and another for "C".
128 Note that function symbols in GDB index have no parameter
129 information, just the function/method names. You can convert a
130 name_component to a "const char *" using the
131 'mapped_index::symbol_name_at(offset_type)' method. */
133 struct name_component
135 /* Offset in the symbol name where the component starts. Stored as
136 a (32-bit) offset instead of a pointer to save memory and improve
137 locality on 64-bit architectures. */
138 offset_type name_offset
;
140 /* The symbol's index in the symbol and constant pool tables of a
145 /* Base class containing bits shared by both .gdb_index and
146 .debug_name indexes. */
148 struct mapped_index_base
150 mapped_index_base () = default;
151 DISABLE_COPY_AND_ASSIGN (mapped_index_base
);
153 /* The name_component table (a sorted vector). See name_component's
154 description above. */
155 std::vector
<name_component
> name_components
;
157 /* How NAME_COMPONENTS is sorted. */
158 enum case_sensitivity name_components_casing
;
160 /* Return the number of names in the symbol table. */
161 virtual size_t symbol_name_count () const = 0;
163 /* Get the name of the symbol at IDX in the symbol table. */
164 virtual const char *symbol_name_at (offset_type idx
) const = 0;
166 /* Return whether the name at IDX in the symbol table should be
168 virtual bool symbol_name_slot_invalid (offset_type idx
) const
173 /* Build the symbol name component sorted vector, if we haven't
175 void build_name_components ();
177 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
178 possible matches for LN_NO_PARAMS in the name component
180 std::pair
<std::vector
<name_component
>::const_iterator
,
181 std::vector
<name_component
>::const_iterator
>
182 find_name_components_bounds (const lookup_name_info
&ln_no_params
,
183 enum language lang
) const;
185 /* Prevent deleting/destroying via a base class pointer. */
187 ~mapped_index_base() = default;
190 /* A description of the mapped index. The file format is described in
191 a comment by the code that writes the index. */
192 struct mapped_index final
: public mapped_index_base
194 /* A slot/bucket in the symbol table hash. */
195 struct symbol_table_slot
197 const offset_type name
;
198 const offset_type vec
;
201 /* Index data format version. */
204 /* The address table data. */
205 gdb::array_view
<const gdb_byte
> address_table
;
207 /* The symbol table, implemented as a hash table. */
208 gdb::array_view
<symbol_table_slot
> symbol_table
;
210 /* A pointer to the constant pool. */
211 const char *constant_pool
= nullptr;
213 bool symbol_name_slot_invalid (offset_type idx
) const override
215 const auto &bucket
= this->symbol_table
[idx
];
216 return bucket
.name
== 0 && bucket
.vec
== 0;
219 /* Convenience method to get at the name of the symbol at IDX in the
221 const char *symbol_name_at (offset_type idx
) const override
222 { return this->constant_pool
+ MAYBE_SWAP (this->symbol_table
[idx
].name
); }
224 size_t symbol_name_count () const override
225 { return this->symbol_table
.size (); }
228 /* A description of the mapped .debug_names.
229 Uninitialized map has CU_COUNT 0. */
230 struct mapped_debug_names final
: public mapped_index_base
232 mapped_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile_
)
233 : dwarf2_per_objfile (dwarf2_per_objfile_
)
236 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
237 bfd_endian dwarf5_byte_order
;
238 bool dwarf5_is_dwarf64
;
239 bool augmentation_is_gdb
;
241 uint32_t cu_count
= 0;
242 uint32_t tu_count
, bucket_count
, name_count
;
243 const gdb_byte
*cu_table_reordered
, *tu_table_reordered
;
244 const uint32_t *bucket_table_reordered
, *hash_table_reordered
;
245 const gdb_byte
*name_table_string_offs_reordered
;
246 const gdb_byte
*name_table_entry_offs_reordered
;
247 const gdb_byte
*entry_pool
;
254 /* Attribute name DW_IDX_*. */
257 /* Attribute form DW_FORM_*. */
260 /* Value if FORM is DW_FORM_implicit_const. */
261 LONGEST implicit_const
;
263 std::vector
<attr
> attr_vec
;
266 std::unordered_map
<ULONGEST
, index_val
> abbrev_map
;
268 const char *namei_to_name (uint32_t namei
) const;
270 /* Implementation of the mapped_index_base virtual interface, for
271 the name_components cache. */
273 const char *symbol_name_at (offset_type idx
) const override
274 { return namei_to_name (idx
); }
276 size_t symbol_name_count () const override
277 { return this->name_count
; }
280 /* See dwarf2read.h. */
283 get_dwarf2_per_objfile (struct objfile
*objfile
)
285 return dwarf2_objfile_data_key
.get (objfile
);
288 /* Default names of the debugging sections. */
290 /* Note that if the debugging section has been compressed, it might
291 have a name like .zdebug_info. */
293 static const struct dwarf2_debug_sections dwarf2_elf_names
=
295 { ".debug_info", ".zdebug_info" },
296 { ".debug_abbrev", ".zdebug_abbrev" },
297 { ".debug_line", ".zdebug_line" },
298 { ".debug_loc", ".zdebug_loc" },
299 { ".debug_loclists", ".zdebug_loclists" },
300 { ".debug_macinfo", ".zdebug_macinfo" },
301 { ".debug_macro", ".zdebug_macro" },
302 { ".debug_str", ".zdebug_str" },
303 { ".debug_line_str", ".zdebug_line_str" },
304 { ".debug_ranges", ".zdebug_ranges" },
305 { ".debug_rnglists", ".zdebug_rnglists" },
306 { ".debug_types", ".zdebug_types" },
307 { ".debug_addr", ".zdebug_addr" },
308 { ".debug_frame", ".zdebug_frame" },
309 { ".eh_frame", NULL
},
310 { ".gdb_index", ".zgdb_index" },
311 { ".debug_names", ".zdebug_names" },
312 { ".debug_aranges", ".zdebug_aranges" },
316 /* List of DWO/DWP sections. */
318 static const struct dwop_section_names
320 struct dwarf2_section_names abbrev_dwo
;
321 struct dwarf2_section_names info_dwo
;
322 struct dwarf2_section_names line_dwo
;
323 struct dwarf2_section_names loc_dwo
;
324 struct dwarf2_section_names loclists_dwo
;
325 struct dwarf2_section_names macinfo_dwo
;
326 struct dwarf2_section_names macro_dwo
;
327 struct dwarf2_section_names str_dwo
;
328 struct dwarf2_section_names str_offsets_dwo
;
329 struct dwarf2_section_names types_dwo
;
330 struct dwarf2_section_names cu_index
;
331 struct dwarf2_section_names tu_index
;
335 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
336 { ".debug_info.dwo", ".zdebug_info.dwo" },
337 { ".debug_line.dwo", ".zdebug_line.dwo" },
338 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
339 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
340 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
341 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
342 { ".debug_str.dwo", ".zdebug_str.dwo" },
343 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
344 { ".debug_types.dwo", ".zdebug_types.dwo" },
345 { ".debug_cu_index", ".zdebug_cu_index" },
346 { ".debug_tu_index", ".zdebug_tu_index" },
349 /* local data types */
351 /* The data in a compilation unit header, after target2host
352 translation, looks like this. */
353 struct comp_unit_head
357 unsigned char addr_size
;
358 unsigned char signed_addr_p
;
359 sect_offset abbrev_sect_off
;
361 /* Size of file offsets; either 4 or 8. */
362 unsigned int offset_size
;
364 /* Size of the length field; either 4 or 12. */
365 unsigned int initial_length_size
;
367 enum dwarf_unit_type unit_type
;
369 /* Offset to the first byte of this compilation unit header in the
370 .debug_info section, for resolving relative reference dies. */
371 sect_offset sect_off
;
373 /* Offset to first die in this cu from the start of the cu.
374 This will be the first byte following the compilation unit header. */
375 cu_offset first_die_cu_offset
;
378 /* 64-bit signature of this unit. For type units, it denotes the signature of
379 the type (DW_UT_type in DWARF 4, additionally DW_UT_split_type in DWARF 5).
380 Also used in DWARF 5, to denote the dwo id when the unit type is
381 DW_UT_skeleton or DW_UT_split_compile. */
384 /* For types, offset in the type's DIE of the type defined by this TU. */
385 cu_offset type_cu_offset_in_tu
;
388 /* Type used for delaying computation of method physnames.
389 See comments for compute_delayed_physnames. */
390 struct delayed_method_info
392 /* The type to which the method is attached, i.e., its parent class. */
395 /* The index of the method in the type's function fieldlists. */
398 /* The index of the method in the fieldlist. */
401 /* The name of the DIE. */
404 /* The DIE associated with this method. */
405 struct die_info
*die
;
408 /* Internal state when decoding a particular compilation unit. */
411 explicit dwarf2_cu (struct dwarf2_per_cu_data
*per_cu
);
414 DISABLE_COPY_AND_ASSIGN (dwarf2_cu
);
416 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
417 Create the set of symtabs used by this TU, or if this TU is sharing
418 symtabs with another TU and the symtabs have already been created
419 then restore those symtabs in the line header.
420 We don't need the pc/line-number mapping for type units. */
421 void setup_type_unit_groups (struct die_info
*die
);
423 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
424 buildsym_compunit constructor. */
425 struct compunit_symtab
*start_symtab (const char *name
,
426 const char *comp_dir
,
429 /* Reset the builder. */
430 void reset_builder () { m_builder
.reset (); }
432 /* The header of the compilation unit. */
433 struct comp_unit_head header
{};
435 /* Base address of this compilation unit. */
436 CORE_ADDR base_address
= 0;
438 /* Non-zero if base_address has been set. */
441 /* The language we are debugging. */
442 enum language language
= language_unknown
;
443 const struct language_defn
*language_defn
= nullptr;
445 const char *producer
= nullptr;
448 /* The symtab builder for this CU. This is only non-NULL when full
449 symbols are being read. */
450 std::unique_ptr
<buildsym_compunit
> m_builder
;
453 /* The generic symbol table building routines have separate lists for
454 file scope symbols and all all other scopes (local scopes). So
455 we need to select the right one to pass to add_symbol_to_list().
456 We do it by keeping a pointer to the correct list in list_in_scope.
458 FIXME: The original dwarf code just treated the file scope as the
459 first local scope, and all other local scopes as nested local
460 scopes, and worked fine. Check to see if we really need to
461 distinguish these in buildsym.c. */
462 struct pending
**list_in_scope
= nullptr;
464 /* Hash table holding all the loaded partial DIEs
465 with partial_die->offset.SECT_OFF as hash. */
466 htab_t partial_dies
= nullptr;
468 /* Storage for things with the same lifetime as this read-in compilation
469 unit, including partial DIEs. */
470 auto_obstack comp_unit_obstack
;
472 /* When multiple dwarf2_cu structures are living in memory, this field
473 chains them all together, so that they can be released efficiently.
474 We will probably also want a generation counter so that most-recently-used
475 compilation units are cached... */
476 struct dwarf2_per_cu_data
*read_in_chain
= nullptr;
478 /* Backlink to our per_cu entry. */
479 struct dwarf2_per_cu_data
*per_cu
;
481 /* How many compilation units ago was this CU last referenced? */
484 /* A hash table of DIE cu_offset for following references with
485 die_info->offset.sect_off as hash. */
486 htab_t die_hash
= nullptr;
488 /* Full DIEs if read in. */
489 struct die_info
*dies
= nullptr;
491 /* A set of pointers to dwarf2_per_cu_data objects for compilation
492 units referenced by this one. Only set during full symbol processing;
493 partial symbol tables do not have dependencies. */
494 htab_t dependencies
= nullptr;
496 /* Header data from the line table, during full symbol processing. */
497 struct line_header
*line_header
= nullptr;
498 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
499 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
500 this is the DW_TAG_compile_unit die for this CU. We'll hold on
501 to the line header as long as this DIE is being processed. See
502 process_die_scope. */
503 die_info
*line_header_die_owner
= nullptr;
505 /* A list of methods which need to have physnames computed
506 after all type information has been read. */
507 std::vector
<delayed_method_info
> method_list
;
509 /* To be copied to symtab->call_site_htab. */
510 htab_t call_site_htab
= nullptr;
512 /* Non-NULL if this CU came from a DWO file.
513 There is an invariant here that is important to remember:
514 Except for attributes copied from the top level DIE in the "main"
515 (or "stub") file in preparation for reading the DWO file
516 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
517 Either there isn't a DWO file (in which case this is NULL and the point
518 is moot), or there is and either we're not going to read it (in which
519 case this is NULL) or there is and we are reading it (in which case this
521 struct dwo_unit
*dwo_unit
= nullptr;
523 /* The DW_AT_addr_base attribute if present, zero otherwise
524 (zero is a valid value though).
525 Note this value comes from the Fission stub CU/TU's DIE. */
526 ULONGEST addr_base
= 0;
528 /* The DW_AT_ranges_base attribute if present, zero otherwise
529 (zero is a valid value though).
530 Note this value comes from the Fission stub CU/TU's DIE.
531 Also note that the value is zero in the non-DWO case so this value can
532 be used without needing to know whether DWO files are in use or not.
533 N.B. This does not apply to DW_AT_ranges appearing in
534 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
535 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
536 DW_AT_ranges_base *would* have to be applied, and we'd have to care
537 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
538 ULONGEST ranges_base
= 0;
540 /* When reading debug info generated by older versions of rustc, we
541 have to rewrite some union types to be struct types with a
542 variant part. This rewriting must be done after the CU is fully
543 read in, because otherwise at the point of rewriting some struct
544 type might not have been fully processed. So, we keep a list of
545 all such types here and process them after expansion. */
546 std::vector
<struct type
*> rust_unions
;
548 /* Mark used when releasing cached dies. */
551 /* This CU references .debug_loc. See the symtab->locations_valid field.
552 This test is imperfect as there may exist optimized debug code not using
553 any location list and still facing inlining issues if handled as
554 unoptimized code. For a future better test see GCC PR other/32998. */
555 bool has_loclist
: 1;
557 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is true
558 if all the producer_is_* fields are valid. This information is cached
559 because profiling CU expansion showed excessive time spent in
560 producer_is_gxx_lt_4_6. */
561 bool checked_producer
: 1;
562 bool producer_is_gxx_lt_4_6
: 1;
563 bool producer_is_gcc_lt_4_3
: 1;
564 bool producer_is_icc
: 1;
565 bool producer_is_icc_lt_14
: 1;
566 bool producer_is_codewarrior
: 1;
568 /* When true, the file that we're processing is known to have
569 debugging info for C++ namespaces. GCC 3.3.x did not produce
570 this information, but later versions do. */
572 bool processing_has_namespace_info
: 1;
574 struct partial_die_info
*find_partial_die (sect_offset sect_off
);
576 /* If this CU was inherited by another CU (via specification,
577 abstract_origin, etc), this is the ancestor CU. */
580 /* Get the buildsym_compunit for this CU. */
581 buildsym_compunit
*get_builder ()
583 /* If this CU has a builder associated with it, use that. */
584 if (m_builder
!= nullptr)
585 return m_builder
.get ();
587 /* Otherwise, search ancestors for a valid builder. */
588 if (ancestor
!= nullptr)
589 return ancestor
->get_builder ();
595 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
596 This includes type_unit_group and quick_file_names. */
598 struct stmt_list_hash
600 /* The DWO unit this table is from or NULL if there is none. */
601 struct dwo_unit
*dwo_unit
;
603 /* Offset in .debug_line or .debug_line.dwo. */
604 sect_offset line_sect_off
;
607 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
608 an object of this type. */
610 struct type_unit_group
612 /* dwarf2read.c's main "handle" on a TU symtab.
613 To simplify things we create an artificial CU that "includes" all the
614 type units using this stmt_list so that the rest of the code still has
615 a "per_cu" handle on the symtab.
616 This PER_CU is recognized by having no section. */
617 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
618 struct dwarf2_per_cu_data per_cu
;
620 /* The TUs that share this DW_AT_stmt_list entry.
621 This is added to while parsing type units to build partial symtabs,
622 and is deleted afterwards and not used again. */
623 std::vector
<signatured_type
*> *tus
;
625 /* The compunit symtab.
626 Type units in a group needn't all be defined in the same source file,
627 so we create an essentially anonymous symtab as the compunit symtab. */
628 struct compunit_symtab
*compunit_symtab
;
630 /* The data used to construct the hash key. */
631 struct stmt_list_hash hash
;
633 /* The number of symtabs from the line header.
634 The value here must match line_header.num_file_names. */
635 unsigned int num_symtabs
;
637 /* The symbol tables for this TU (obtained from the files listed in
639 WARNING: The order of entries here must match the order of entries
640 in the line header. After the first TU using this type_unit_group, the
641 line header for the subsequent TUs is recreated from this. This is done
642 because we need to use the same symtabs for each TU using the same
643 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
644 there's no guarantee the line header doesn't have duplicate entries. */
645 struct symtab
**symtabs
;
648 /* These sections are what may appear in a (real or virtual) DWO file. */
652 struct dwarf2_section_info abbrev
;
653 struct dwarf2_section_info line
;
654 struct dwarf2_section_info loc
;
655 struct dwarf2_section_info loclists
;
656 struct dwarf2_section_info macinfo
;
657 struct dwarf2_section_info macro
;
658 struct dwarf2_section_info str
;
659 struct dwarf2_section_info str_offsets
;
660 /* In the case of a virtual DWO file, these two are unused. */
661 struct dwarf2_section_info info
;
662 std::vector
<dwarf2_section_info
> types
;
665 /* CUs/TUs in DWP/DWO files. */
669 /* Backlink to the containing struct dwo_file. */
670 struct dwo_file
*dwo_file
;
672 /* The "id" that distinguishes this CU/TU.
673 .debug_info calls this "dwo_id", .debug_types calls this "signature".
674 Since signatures came first, we stick with it for consistency. */
677 /* The section this CU/TU lives in, in the DWO file. */
678 struct dwarf2_section_info
*section
;
680 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
681 sect_offset sect_off
;
684 /* For types, offset in the type's DIE of the type defined by this TU. */
685 cu_offset type_offset_in_tu
;
688 /* include/dwarf2.h defines the DWP section codes.
689 It defines a max value but it doesn't define a min value, which we
690 use for error checking, so provide one. */
692 enum dwp_v2_section_ids
697 /* Data for one DWO file.
699 This includes virtual DWO files (a virtual DWO file is a DWO file as it
700 appears in a DWP file). DWP files don't really have DWO files per se -
701 comdat folding of types "loses" the DWO file they came from, and from
702 a high level view DWP files appear to contain a mass of random types.
703 However, to maintain consistency with the non-DWP case we pretend DWP
704 files contain virtual DWO files, and we assign each TU with one virtual
705 DWO file (generally based on the line and abbrev section offsets -
706 a heuristic that seems to work in practice). */
710 dwo_file () = default;
711 DISABLE_COPY_AND_ASSIGN (dwo_file
);
713 /* The DW_AT_GNU_dwo_name attribute.
714 For virtual DWO files the name is constructed from the section offsets
715 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
716 from related CU+TUs. */
717 const char *dwo_name
= nullptr;
719 /* The DW_AT_comp_dir attribute. */
720 const char *comp_dir
= nullptr;
722 /* The bfd, when the file is open. Otherwise this is NULL.
723 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
724 gdb_bfd_ref_ptr dbfd
;
726 /* The sections that make up this DWO file.
727 Remember that for virtual DWO files in DWP V2, these are virtual
728 sections (for lack of a better name). */
729 struct dwo_sections sections
{};
731 /* The CUs in the file.
732 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
733 an extension to handle LLVM's Link Time Optimization output (where
734 multiple source files may be compiled into a single object/dwo pair). */
737 /* Table of TUs in the file.
738 Each element is a struct dwo_unit. */
742 /* These sections are what may appear in a DWP file. */
746 /* These are used by both DWP version 1 and 2. */
747 struct dwarf2_section_info str
;
748 struct dwarf2_section_info cu_index
;
749 struct dwarf2_section_info tu_index
;
751 /* These are only used by DWP version 2 files.
752 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
753 sections are referenced by section number, and are not recorded here.
754 In DWP version 2 there is at most one copy of all these sections, each
755 section being (effectively) comprised of the concatenation of all of the
756 individual sections that exist in the version 1 format.
757 To keep the code simple we treat each of these concatenated pieces as a
758 section itself (a virtual section?). */
759 struct dwarf2_section_info abbrev
;
760 struct dwarf2_section_info info
;
761 struct dwarf2_section_info line
;
762 struct dwarf2_section_info loc
;
763 struct dwarf2_section_info macinfo
;
764 struct dwarf2_section_info macro
;
765 struct dwarf2_section_info str_offsets
;
766 struct dwarf2_section_info types
;
769 /* These sections are what may appear in a virtual DWO file in DWP version 1.
770 A virtual DWO file is a DWO file as it appears in a DWP file. */
772 struct virtual_v1_dwo_sections
774 struct dwarf2_section_info abbrev
;
775 struct dwarf2_section_info line
;
776 struct dwarf2_section_info loc
;
777 struct dwarf2_section_info macinfo
;
778 struct dwarf2_section_info macro
;
779 struct dwarf2_section_info str_offsets
;
780 /* Each DWP hash table entry records one CU or one TU.
781 That is recorded here, and copied to dwo_unit.section. */
782 struct dwarf2_section_info info_or_types
;
785 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
786 In version 2, the sections of the DWO files are concatenated together
787 and stored in one section of that name. Thus each ELF section contains
788 several "virtual" sections. */
790 struct virtual_v2_dwo_sections
792 bfd_size_type abbrev_offset
;
793 bfd_size_type abbrev_size
;
795 bfd_size_type line_offset
;
796 bfd_size_type line_size
;
798 bfd_size_type loc_offset
;
799 bfd_size_type loc_size
;
801 bfd_size_type macinfo_offset
;
802 bfd_size_type macinfo_size
;
804 bfd_size_type macro_offset
;
805 bfd_size_type macro_size
;
807 bfd_size_type str_offsets_offset
;
808 bfd_size_type str_offsets_size
;
810 /* Each DWP hash table entry records one CU or one TU.
811 That is recorded here, and copied to dwo_unit.section. */
812 bfd_size_type info_or_types_offset
;
813 bfd_size_type info_or_types_size
;
816 /* Contents of DWP hash tables. */
818 struct dwp_hash_table
820 uint32_t version
, nr_columns
;
821 uint32_t nr_units
, nr_slots
;
822 const gdb_byte
*hash_table
, *unit_table
;
827 const gdb_byte
*indices
;
831 /* This is indexed by column number and gives the id of the section
833 #define MAX_NR_V2_DWO_SECTIONS \
834 (1 /* .debug_info or .debug_types */ \
835 + 1 /* .debug_abbrev */ \
836 + 1 /* .debug_line */ \
837 + 1 /* .debug_loc */ \
838 + 1 /* .debug_str_offsets */ \
839 + 1 /* .debug_macro or .debug_macinfo */)
840 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
841 const gdb_byte
*offsets
;
842 const gdb_byte
*sizes
;
847 /* Data for one DWP file. */
851 dwp_file (const char *name_
, gdb_bfd_ref_ptr
&&abfd
)
853 dbfd (std::move (abfd
))
857 /* Name of the file. */
860 /* File format version. */
864 gdb_bfd_ref_ptr dbfd
;
866 /* Section info for this file. */
867 struct dwp_sections sections
{};
869 /* Table of CUs in the file. */
870 const struct dwp_hash_table
*cus
= nullptr;
872 /* Table of TUs in the file. */
873 const struct dwp_hash_table
*tus
= nullptr;
875 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
876 htab_t loaded_cus
{};
877 htab_t loaded_tus
{};
879 /* Table to map ELF section numbers to their sections.
880 This is only needed for the DWP V1 file format. */
881 unsigned int num_sections
= 0;
882 asection
**elf_sections
= nullptr;
885 /* Struct used to pass misc. parameters to read_die_and_children, et
886 al. which are used for both .debug_info and .debug_types dies.
887 All parameters here are unchanging for the life of the call. This
888 struct exists to abstract away the constant parameters of die reading. */
890 struct die_reader_specs
892 /* The bfd of die_section. */
895 /* The CU of the DIE we are parsing. */
896 struct dwarf2_cu
*cu
;
898 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
899 struct dwo_file
*dwo_file
;
901 /* The section the die comes from.
902 This is either .debug_info or .debug_types, or the .dwo variants. */
903 struct dwarf2_section_info
*die_section
;
905 /* die_section->buffer. */
906 const gdb_byte
*buffer
;
908 /* The end of the buffer. */
909 const gdb_byte
*buffer_end
;
911 /* The value of the DW_AT_comp_dir attribute. */
912 const char *comp_dir
;
914 /* The abbreviation table to use when reading the DIEs. */
915 struct abbrev_table
*abbrev_table
;
918 /* Type of function passed to init_cutu_and_read_dies, et.al. */
919 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
920 const gdb_byte
*info_ptr
,
921 struct die_info
*comp_unit_die
,
925 /* A 1-based directory index. This is a strong typedef to prevent
926 accidentally using a directory index as a 0-based index into an
928 enum class dir_index
: unsigned int {};
930 /* Likewise, a 1-based file name index. */
931 enum class file_name_index
: unsigned int {};
935 file_entry () = default;
937 file_entry (const char *name_
, dir_index d_index_
,
938 unsigned int mod_time_
, unsigned int length_
)
941 mod_time (mod_time_
),
945 /* Return the include directory at D_INDEX stored in LH. Returns
946 NULL if D_INDEX is out of bounds. */
947 const char *include_dir (const line_header
*lh
) const;
949 /* The file name. Note this is an observing pointer. The memory is
950 owned by debug_line_buffer. */
953 /* The directory index (1-based). */
954 dir_index d_index
{};
956 unsigned int mod_time
{};
958 unsigned int length
{};
960 /* True if referenced by the Line Number Program. */
963 /* The associated symbol table, if any. */
964 struct symtab
*symtab
{};
967 /* The line number information for a compilation unit (found in the
968 .debug_line section) begins with a "statement program header",
969 which contains the following information. */
976 /* Add an entry to the include directory table. */
977 void add_include_dir (const char *include_dir
);
979 /* Add an entry to the file name table. */
980 void add_file_name (const char *name
, dir_index d_index
,
981 unsigned int mod_time
, unsigned int length
);
983 /* Return the include dir at INDEX (1-based). Returns NULL if INDEX
985 const char *include_dir_at (dir_index index
) const
987 /* Convert directory index number (1-based) to vector index
989 size_t vec_index
= to_underlying (index
) - 1;
991 if (vec_index
>= include_dirs
.size ())
993 return include_dirs
[vec_index
];
996 /* Return the file name at INDEX (1-based). Returns NULL if INDEX
998 file_entry
*file_name_at (file_name_index index
)
1000 /* Convert file name index number (1-based) to vector index
1002 size_t vec_index
= to_underlying (index
) - 1;
1004 if (vec_index
>= file_names
.size ())
1006 return &file_names
[vec_index
];
1009 /* Offset of line number information in .debug_line section. */
1010 sect_offset sect_off
{};
1012 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1013 unsigned offset_in_dwz
: 1; /* Can't initialize bitfields in-class. */
1015 unsigned int total_length
{};
1016 unsigned short version
{};
1017 unsigned int header_length
{};
1018 unsigned char minimum_instruction_length
{};
1019 unsigned char maximum_ops_per_instruction
{};
1020 unsigned char default_is_stmt
{};
1022 unsigned char line_range
{};
1023 unsigned char opcode_base
{};
1025 /* standard_opcode_lengths[i] is the number of operands for the
1026 standard opcode whose value is i. This means that
1027 standard_opcode_lengths[0] is unused, and the last meaningful
1028 element is standard_opcode_lengths[opcode_base - 1]. */
1029 std::unique_ptr
<unsigned char[]> standard_opcode_lengths
;
1031 /* The include_directories table. Note these are observing
1032 pointers. The memory is owned by debug_line_buffer. */
1033 std::vector
<const char *> include_dirs
;
1035 /* The file_names table. */
1036 std::vector
<file_entry
> file_names
;
1038 /* The start and end of the statement program following this
1039 header. These point into dwarf2_per_objfile->line_buffer. */
1040 const gdb_byte
*statement_program_start
{}, *statement_program_end
{};
1043 typedef std::unique_ptr
<line_header
> line_header_up
;
1046 file_entry::include_dir (const line_header
*lh
) const
1048 return lh
->include_dir_at (d_index
);
1051 /* When we construct a partial symbol table entry we only
1052 need this much information. */
1053 struct partial_die_info
: public allocate_on_obstack
1055 partial_die_info (sect_offset sect_off
, struct abbrev_info
*abbrev
);
1057 /* Disable assign but still keep copy ctor, which is needed
1058 load_partial_dies. */
1059 partial_die_info
& operator=(const partial_die_info
& rhs
) = delete;
1061 /* Adjust the partial die before generating a symbol for it. This
1062 function may set the is_external flag or change the DIE's
1064 void fixup (struct dwarf2_cu
*cu
);
1066 /* Read a minimal amount of information into the minimal die
1068 const gdb_byte
*read (const struct die_reader_specs
*reader
,
1069 const struct abbrev_info
&abbrev
,
1070 const gdb_byte
*info_ptr
);
1072 /* Offset of this DIE. */
1073 const sect_offset sect_off
;
1075 /* DWARF-2 tag for this DIE. */
1076 const ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1078 /* Assorted flags describing the data found in this DIE. */
1079 const unsigned int has_children
: 1;
1081 unsigned int is_external
: 1;
1082 unsigned int is_declaration
: 1;
1083 unsigned int has_type
: 1;
1084 unsigned int has_specification
: 1;
1085 unsigned int has_pc_info
: 1;
1086 unsigned int may_be_inlined
: 1;
1088 /* This DIE has been marked DW_AT_main_subprogram. */
1089 unsigned int main_subprogram
: 1;
1091 /* Flag set if the SCOPE field of this structure has been
1093 unsigned int scope_set
: 1;
1095 /* Flag set if the DIE has a byte_size attribute. */
1096 unsigned int has_byte_size
: 1;
1098 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1099 unsigned int has_const_value
: 1;
1101 /* Flag set if any of the DIE's children are template arguments. */
1102 unsigned int has_template_arguments
: 1;
1104 /* Flag set if fixup has been called on this die. */
1105 unsigned int fixup_called
: 1;
1107 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1108 unsigned int is_dwz
: 1;
1110 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1111 unsigned int spec_is_dwz
: 1;
1113 /* The name of this DIE. Normally the value of DW_AT_name, but
1114 sometimes a default name for unnamed DIEs. */
1115 const char *name
= nullptr;
1117 /* The linkage name, if present. */
1118 const char *linkage_name
= nullptr;
1120 /* The scope to prepend to our children. This is generally
1121 allocated on the comp_unit_obstack, so will disappear
1122 when this compilation unit leaves the cache. */
1123 const char *scope
= nullptr;
1125 /* Some data associated with the partial DIE. The tag determines
1126 which field is live. */
1129 /* The location description associated with this DIE, if any. */
1130 struct dwarf_block
*locdesc
;
1131 /* The offset of an import, for DW_TAG_imported_unit. */
1132 sect_offset sect_off
;
1135 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1136 CORE_ADDR lowpc
= 0;
1137 CORE_ADDR highpc
= 0;
1139 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1140 DW_AT_sibling, if any. */
1141 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1142 could return DW_AT_sibling values to its caller load_partial_dies. */
1143 const gdb_byte
*sibling
= nullptr;
1145 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1146 DW_AT_specification (or DW_AT_abstract_origin or
1147 DW_AT_extension). */
1148 sect_offset spec_offset
{};
1150 /* Pointers to this DIE's parent, first child, and next sibling,
1152 struct partial_die_info
*die_parent
= nullptr;
1153 struct partial_die_info
*die_child
= nullptr;
1154 struct partial_die_info
*die_sibling
= nullptr;
1156 friend struct partial_die_info
*
1157 dwarf2_cu::find_partial_die (sect_offset sect_off
);
1160 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1161 partial_die_info (sect_offset sect_off
)
1162 : partial_die_info (sect_off
, DW_TAG_padding
, 0)
1166 partial_die_info (sect_offset sect_off_
, enum dwarf_tag tag_
,
1168 : sect_off (sect_off_
), tag (tag_
), has_children (has_children_
)
1173 has_specification
= 0;
1176 main_subprogram
= 0;
1179 has_const_value
= 0;
1180 has_template_arguments
= 0;
1187 /* This data structure holds the information of an abbrev. */
1190 unsigned int number
; /* number identifying abbrev */
1191 enum dwarf_tag tag
; /* dwarf tag */
1192 unsigned short has_children
; /* boolean */
1193 unsigned short num_attrs
; /* number of attributes */
1194 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1195 struct abbrev_info
*next
; /* next in chain */
1200 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1201 ENUM_BITFIELD(dwarf_form
) form
: 16;
1203 /* It is valid only if FORM is DW_FORM_implicit_const. */
1204 LONGEST implicit_const
;
1207 /* Size of abbrev_table.abbrev_hash_table. */
1208 #define ABBREV_HASH_SIZE 121
1210 /* Top level data structure to contain an abbreviation table. */
1214 explicit abbrev_table (sect_offset off
)
1218 XOBNEWVEC (&abbrev_obstack
, struct abbrev_info
*, ABBREV_HASH_SIZE
);
1219 memset (m_abbrevs
, 0, ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
1222 DISABLE_COPY_AND_ASSIGN (abbrev_table
);
1224 /* Allocate space for a struct abbrev_info object in
1226 struct abbrev_info
*alloc_abbrev ();
1228 /* Add an abbreviation to the table. */
1229 void add_abbrev (unsigned int abbrev_number
, struct abbrev_info
*abbrev
);
1231 /* Look up an abbrev in the table.
1232 Returns NULL if the abbrev is not found. */
1234 struct abbrev_info
*lookup_abbrev (unsigned int abbrev_number
);
1237 /* Where the abbrev table came from.
1238 This is used as a sanity check when the table is used. */
1239 const sect_offset sect_off
;
1241 /* Storage for the abbrev table. */
1242 auto_obstack abbrev_obstack
;
1246 /* Hash table of abbrevs.
1247 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1248 It could be statically allocated, but the previous code didn't so we
1250 struct abbrev_info
**m_abbrevs
;
1253 typedef std::unique_ptr
<struct abbrev_table
> abbrev_table_up
;
1255 /* Attributes have a name and a value. */
1258 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1259 ENUM_BITFIELD(dwarf_form
) form
: 15;
1261 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1262 field should be in u.str (existing only for DW_STRING) but it is kept
1263 here for better struct attribute alignment. */
1264 unsigned int string_is_canonical
: 1;
1269 struct dwarf_block
*blk
;
1278 /* This data structure holds a complete die structure. */
1281 /* DWARF-2 tag for this DIE. */
1282 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1284 /* Number of attributes */
1285 unsigned char num_attrs
;
1287 /* True if we're presently building the full type name for the
1288 type derived from this DIE. */
1289 unsigned char building_fullname
: 1;
1291 /* True if this die is in process. PR 16581. */
1292 unsigned char in_process
: 1;
1295 unsigned int abbrev
;
1297 /* Offset in .debug_info or .debug_types section. */
1298 sect_offset sect_off
;
1300 /* The dies in a compilation unit form an n-ary tree. PARENT
1301 points to this die's parent; CHILD points to the first child of
1302 this node; and all the children of a given node are chained
1303 together via their SIBLING fields. */
1304 struct die_info
*child
; /* Its first child, if any. */
1305 struct die_info
*sibling
; /* Its next sibling, if any. */
1306 struct die_info
*parent
; /* Its parent, if any. */
1308 /* An array of attributes, with NUM_ATTRS elements. There may be
1309 zero, but it's not common and zero-sized arrays are not
1310 sufficiently portable C. */
1311 struct attribute attrs
[1];
1314 /* Get at parts of an attribute structure. */
1316 #define DW_STRING(attr) ((attr)->u.str)
1317 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1318 #define DW_UNSND(attr) ((attr)->u.unsnd)
1319 #define DW_BLOCK(attr) ((attr)->u.blk)
1320 #define DW_SND(attr) ((attr)->u.snd)
1321 #define DW_ADDR(attr) ((attr)->u.addr)
1322 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1324 /* Blocks are a bunch of untyped bytes. */
1329 /* Valid only if SIZE is not zero. */
1330 const gdb_byte
*data
;
1333 #ifndef ATTR_ALLOC_CHUNK
1334 #define ATTR_ALLOC_CHUNK 4
1337 /* Allocate fields for structs, unions and enums in this size. */
1338 #ifndef DW_FIELD_ALLOC_CHUNK
1339 #define DW_FIELD_ALLOC_CHUNK 4
1342 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1343 but this would require a corresponding change in unpack_field_as_long
1345 static int bits_per_byte
= 8;
1347 /* When reading a variant or variant part, we track a bit more
1348 information about the field, and store it in an object of this
1351 struct variant_field
1353 /* If we see a DW_TAG_variant, then this will be the discriminant
1355 ULONGEST discriminant_value
;
1356 /* If we see a DW_TAG_variant, then this will be set if this is the
1358 bool default_branch
;
1359 /* While reading a DW_TAG_variant_part, this will be set if this
1360 field is the discriminant. */
1361 bool is_discriminant
;
1366 int accessibility
= 0;
1368 /* Extra information to describe a variant or variant part. */
1369 struct variant_field variant
{};
1370 struct field field
{};
1375 const char *name
= nullptr;
1376 std::vector
<struct fn_field
> fnfields
;
1379 /* The routines that read and process dies for a C struct or C++ class
1380 pass lists of data member fields and lists of member function fields
1381 in an instance of a field_info structure, as defined below. */
1384 /* List of data member and baseclasses fields. */
1385 std::vector
<struct nextfield
> fields
;
1386 std::vector
<struct nextfield
> baseclasses
;
1388 /* Number of fields (including baseclasses). */
1391 /* Set if the accesibility of one of the fields is not public. */
1392 int non_public_fields
= 0;
1394 /* Member function fieldlist array, contains name of possibly overloaded
1395 member function, number of overloaded member functions and a pointer
1396 to the head of the member function field chain. */
1397 std::vector
<struct fnfieldlist
> fnfieldlists
;
1399 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1400 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1401 std::vector
<struct decl_field
> typedef_field_list
;
1403 /* Nested types defined by this class and the number of elements in this
1405 std::vector
<struct decl_field
> nested_types_list
;
1408 /* One item on the queue of compilation units to read in full symbols
1410 struct dwarf2_queue_item
1412 struct dwarf2_per_cu_data
*per_cu
;
1413 enum language pretend_language
;
1414 struct dwarf2_queue_item
*next
;
1417 /* The current queue. */
1418 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1420 /* Loaded secondary compilation units are kept in memory until they
1421 have not been referenced for the processing of this many
1422 compilation units. Set this to zero to disable caching. Cache
1423 sizes of up to at least twenty will improve startup time for
1424 typical inter-CU-reference binaries, at an obvious memory cost. */
1425 static int dwarf_max_cache_age
= 5;
1427 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1428 struct cmd_list_element
*c
, const char *value
)
1430 fprintf_filtered (file
, _("The upper bound on the age of cached "
1431 "DWARF compilation units is %s.\n"),
1435 /* local function prototypes */
1437 static const char *get_section_name (const struct dwarf2_section_info
*);
1439 static const char *get_section_file_name (const struct dwarf2_section_info
*);
1441 static void dwarf2_find_base_address (struct die_info
*die
,
1442 struct dwarf2_cu
*cu
);
1444 static struct partial_symtab
*create_partial_symtab
1445 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1447 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1448 const gdb_byte
*info_ptr
,
1449 struct die_info
*type_unit_die
,
1450 int has_children
, void *data
);
1452 static void dwarf2_build_psymtabs_hard
1453 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1455 static void scan_partial_symbols (struct partial_die_info
*,
1456 CORE_ADDR
*, CORE_ADDR
*,
1457 int, struct dwarf2_cu
*);
1459 static void add_partial_symbol (struct partial_die_info
*,
1460 struct dwarf2_cu
*);
1462 static void add_partial_namespace (struct partial_die_info
*pdi
,
1463 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1464 int set_addrmap
, struct dwarf2_cu
*cu
);
1466 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1467 CORE_ADDR
*highpc
, int set_addrmap
,
1468 struct dwarf2_cu
*cu
);
1470 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1471 struct dwarf2_cu
*cu
);
1473 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1474 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1475 int need_pc
, struct dwarf2_cu
*cu
);
1477 static void dwarf2_read_symtab (struct partial_symtab
*,
1480 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1482 static abbrev_table_up abbrev_table_read_table
1483 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, struct dwarf2_section_info
*,
1486 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1488 static struct partial_die_info
*load_partial_dies
1489 (const struct die_reader_specs
*, const gdb_byte
*, int);
1491 /* A pair of partial_die_info and compilation unit. */
1492 struct cu_partial_die_info
1494 /* The compilation unit of the partial_die_info. */
1495 struct dwarf2_cu
*cu
;
1496 /* A partial_die_info. */
1497 struct partial_die_info
*pdi
;
1499 cu_partial_die_info (struct dwarf2_cu
*cu
, struct partial_die_info
*pdi
)
1505 cu_partial_die_info () = delete;
1508 static const struct cu_partial_die_info
find_partial_die (sect_offset
, int,
1509 struct dwarf2_cu
*);
1511 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1512 struct attribute
*, struct attr_abbrev
*,
1515 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1517 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1519 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1521 /* Read the next three bytes (little-endian order) as an unsigned integer. */
1522 static unsigned int read_3_bytes (bfd
*, const gdb_byte
*);
1524 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1526 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1528 static CORE_ADDR
read_address (bfd
*, const gdb_byte
*ptr
, struct dwarf2_cu
*,
1531 static LONGEST
read_initial_length (bfd
*, const gdb_byte
*, unsigned int *);
1533 static LONGEST read_checked_initial_length_and_offset
1534 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1535 unsigned int *, unsigned int *);
1537 static LONGEST
read_offset (bfd
*, const gdb_byte
*,
1538 const struct comp_unit_head
*,
1541 static LONGEST
read_offset_1 (bfd
*, const gdb_byte
*, unsigned int);
1543 static sect_offset read_abbrev_offset
1544 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1545 struct dwarf2_section_info
*, sect_offset
);
1547 static const gdb_byte
*read_n_bytes (bfd
*, const gdb_byte
*, unsigned int);
1549 static const char *read_direct_string (bfd
*, const gdb_byte
*, unsigned int *);
1551 static const char *read_indirect_string
1552 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*, const gdb_byte
*,
1553 const struct comp_unit_head
*, unsigned int *);
1555 static const char *read_indirect_line_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_string_at_offset
1560 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
1561 LONGEST str_offset
);
1563 static const char *read_indirect_string_from_dwz
1564 (struct objfile
*objfile
, struct dwz_file
*, LONGEST
);
1566 static LONGEST
read_signed_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1568 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1572 static const char *read_str_index (const struct die_reader_specs
*reader
,
1573 ULONGEST str_index
);
1575 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1577 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1578 struct dwarf2_cu
*);
1580 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1583 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1584 struct dwarf2_cu
*cu
);
1586 static const char *dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
);
1588 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1589 struct dwarf2_cu
*cu
);
1591 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1593 static struct die_info
*die_specification (struct die_info
*die
,
1594 struct dwarf2_cu
**);
1596 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1597 struct dwarf2_cu
*cu
);
1599 static void dwarf_decode_lines (struct line_header
*, const char *,
1600 struct dwarf2_cu
*, struct partial_symtab
*,
1601 CORE_ADDR
, int decode_mapping
);
1603 static void dwarf2_start_subfile (struct dwarf2_cu
*, const char *,
1606 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1607 struct dwarf2_cu
*, struct symbol
* = NULL
);
1609 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1610 struct dwarf2_cu
*);
1612 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1615 struct obstack
*obstack
,
1616 struct dwarf2_cu
*cu
, LONGEST
*value
,
1617 const gdb_byte
**bytes
,
1618 struct dwarf2_locexpr_baton
**baton
);
1620 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1622 static int need_gnat_info (struct dwarf2_cu
*);
1624 static struct type
*die_descriptive_type (struct die_info
*,
1625 struct dwarf2_cu
*);
1627 static void set_descriptive_type (struct type
*, struct die_info
*,
1628 struct dwarf2_cu
*);
1630 static struct type
*die_containing_type (struct die_info
*,
1631 struct dwarf2_cu
*);
1633 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1634 struct dwarf2_cu
*);
1636 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1638 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1640 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1642 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1643 const char *suffix
, int physname
,
1644 struct dwarf2_cu
*cu
);
1646 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1648 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1650 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1652 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1654 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1656 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1658 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1659 struct dwarf2_cu
*, struct partial_symtab
*);
1661 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1662 values. Keep the items ordered with increasing constraints compliance. */
1665 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1666 PC_BOUNDS_NOT_PRESENT
,
1668 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1669 were present but they do not form a valid range of PC addresses. */
1672 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1675 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1679 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1680 CORE_ADDR
*, CORE_ADDR
*,
1682 struct partial_symtab
*);
1684 static void get_scope_pc_bounds (struct die_info
*,
1685 CORE_ADDR
*, CORE_ADDR
*,
1686 struct dwarf2_cu
*);
1688 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1689 CORE_ADDR
, struct dwarf2_cu
*);
1691 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1692 struct dwarf2_cu
*);
1694 static void dwarf2_attach_fields_to_type (struct field_info
*,
1695 struct type
*, struct dwarf2_cu
*);
1697 static void dwarf2_add_member_fn (struct field_info
*,
1698 struct die_info
*, struct type
*,
1699 struct dwarf2_cu
*);
1701 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1703 struct dwarf2_cu
*);
1705 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1707 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1709 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1711 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1713 static struct using_direct
**using_directives (struct dwarf2_cu
*cu
);
1715 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1717 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1719 static struct type
*read_module_type (struct die_info
*die
,
1720 struct dwarf2_cu
*cu
);
1722 static const char *namespace_name (struct die_info
*die
,
1723 int *is_anonymous
, struct dwarf2_cu
*);
1725 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1727 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1729 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1730 struct dwarf2_cu
*);
1732 static struct die_info
*read_die_and_siblings_1
1733 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1736 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1737 const gdb_byte
*info_ptr
,
1738 const gdb_byte
**new_info_ptr
,
1739 struct die_info
*parent
);
1741 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1742 struct die_info
**, const gdb_byte
*,
1745 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1746 struct die_info
**, const gdb_byte
*,
1749 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1751 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1754 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1756 static const char *dwarf2_full_name (const char *name
,
1757 struct die_info
*die
,
1758 struct dwarf2_cu
*cu
);
1760 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1761 struct dwarf2_cu
*cu
);
1763 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1764 struct dwarf2_cu
**);
1766 static const char *dwarf_tag_name (unsigned int);
1768 static const char *dwarf_attr_name (unsigned int);
1770 static const char *dwarf_unit_type_name (int unit_type
);
1772 static const char *dwarf_form_name (unsigned int);
1774 static const char *dwarf_bool_name (unsigned int);
1776 static const char *dwarf_type_encoding_name (unsigned int);
1778 static struct die_info
*sibling_die (struct die_info
*);
1780 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1782 static void dump_die_for_error (struct die_info
*);
1784 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1787 /*static*/ void dump_die (struct die_info
*, int max_level
);
1789 static void store_in_ref_table (struct die_info
*,
1790 struct dwarf2_cu
*);
1792 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
1794 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
1796 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1797 const struct attribute
*,
1798 struct dwarf2_cu
**);
1800 static struct die_info
*follow_die_ref (struct die_info
*,
1801 const struct attribute
*,
1802 struct dwarf2_cu
**);
1804 static struct die_info
*follow_die_sig (struct die_info
*,
1805 const struct attribute
*,
1806 struct dwarf2_cu
**);
1808 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1809 struct dwarf2_cu
*);
1811 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1812 const struct attribute
*,
1813 struct dwarf2_cu
*);
1815 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1817 static void read_signatured_type (struct signatured_type
*);
1819 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1820 struct die_info
*die
, struct dwarf2_cu
*cu
,
1821 struct dynamic_prop
*prop
, struct type
*type
);
1823 /* memory allocation interface */
1825 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1827 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1829 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1831 static int attr_form_is_block (const struct attribute
*);
1833 static int attr_form_is_section_offset (const struct attribute
*);
1835 static int attr_form_is_constant (const struct attribute
*);
1837 static int attr_form_is_ref (const struct attribute
*);
1839 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1840 struct dwarf2_loclist_baton
*baton
,
1841 const struct attribute
*attr
);
1843 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1845 struct dwarf2_cu
*cu
,
1848 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1849 const gdb_byte
*info_ptr
,
1850 struct abbrev_info
*abbrev
);
1852 static hashval_t
partial_die_hash (const void *item
);
1854 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1856 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1857 (sect_offset sect_off
, unsigned int offset_in_dwz
,
1858 struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1860 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1861 struct die_info
*comp_unit_die
,
1862 enum language pretend_language
);
1864 static void age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1866 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1868 static struct type
*set_die_type (struct die_info
*, struct type
*,
1869 struct dwarf2_cu
*);
1871 static void create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1873 static int create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1875 static void load_full_comp_unit (struct dwarf2_per_cu_data
*, bool,
1878 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1881 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1884 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1885 struct dwarf2_per_cu_data
*);
1887 static void dwarf2_mark (struct dwarf2_cu
*);
1889 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1891 static struct type
*get_die_type_at_offset (sect_offset
,
1892 struct dwarf2_per_cu_data
*);
1894 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1896 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1897 enum language pretend_language
);
1899 static void process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1901 static struct type
*dwarf2_per_cu_addr_type (struct dwarf2_per_cu_data
*per_cu
);
1902 static struct type
*dwarf2_per_cu_addr_sized_int_type
1903 (struct dwarf2_per_cu_data
*per_cu
, bool unsigned_p
);
1905 /* Class, the destructor of which frees all allocated queue entries. This
1906 will only have work to do if an error was thrown while processing the
1907 dwarf. If no error was thrown then the queue entries should have all
1908 been processed, and freed, as we went along. */
1910 class dwarf2_queue_guard
1913 dwarf2_queue_guard () = default;
1915 /* Free any entries remaining on the queue. There should only be
1916 entries left if we hit an error while processing the dwarf. */
1917 ~dwarf2_queue_guard ()
1919 struct dwarf2_queue_item
*item
, *last
;
1921 item
= dwarf2_queue
;
1924 /* Anything still marked queued is likely to be in an
1925 inconsistent state, so discard it. */
1926 if (item
->per_cu
->queued
)
1928 if (item
->per_cu
->cu
!= NULL
)
1929 free_one_cached_comp_unit (item
->per_cu
);
1930 item
->per_cu
->queued
= 0;
1938 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
1942 /* The return type of find_file_and_directory. Note, the enclosed
1943 string pointers are only valid while this object is valid. */
1945 struct file_and_directory
1947 /* The filename. This is never NULL. */
1950 /* The compilation directory. NULL if not known. If we needed to
1951 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1952 points directly to the DW_AT_comp_dir string attribute owned by
1953 the obstack that owns the DIE. */
1954 const char *comp_dir
;
1956 /* If we needed to build a new string for comp_dir, this is what
1957 owns the storage. */
1958 std::string comp_dir_storage
;
1961 static file_and_directory
find_file_and_directory (struct die_info
*die
,
1962 struct dwarf2_cu
*cu
);
1964 static char *file_full_name (int file
, struct line_header
*lh
,
1965 const char *comp_dir
);
1967 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
1968 enum class rcuh_kind
{ COMPILE
, TYPE
};
1970 static const gdb_byte
*read_and_check_comp_unit_head
1971 (struct dwarf2_per_objfile
* dwarf2_per_objfile
,
1972 struct comp_unit_head
*header
,
1973 struct dwarf2_section_info
*section
,
1974 struct dwarf2_section_info
*abbrev_section
, const gdb_byte
*info_ptr
,
1975 rcuh_kind section_kind
);
1977 static void init_cutu_and_read_dies
1978 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
1979 int use_existing_cu
, int keep
, bool skip_partial
,
1980 die_reader_func_ftype
*die_reader_func
, void *data
);
1982 static void init_cutu_and_read_dies_simple
1983 (struct dwarf2_per_cu_data
*this_cu
,
1984 die_reader_func_ftype
*die_reader_func
, void *data
);
1986 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1988 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1990 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1991 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1992 struct dwp_file
*dwp_file
, const char *comp_dir
,
1993 ULONGEST signature
, int is_debug_types
);
1995 static struct dwp_file
*get_dwp_file
1996 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1998 static struct dwo_unit
*lookup_dwo_comp_unit
1999 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
2001 static struct dwo_unit
*lookup_dwo_type_unit
2002 (struct signatured_type
*, const char *, const char *);
2004 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
2006 /* A unique pointer to a dwo_file. */
2008 typedef std::unique_ptr
<struct dwo_file
> dwo_file_up
;
2010 static void process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2012 static void check_producer (struct dwarf2_cu
*cu
);
2014 static void free_line_header_voidp (void *arg
);
2016 /* Various complaints about symbol reading that don't abort the process. */
2019 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2021 complaint (_("statement list doesn't fit in .debug_line section"));
2025 dwarf2_debug_line_missing_file_complaint (void)
2027 complaint (_(".debug_line section has line data without a file"));
2031 dwarf2_debug_line_missing_end_sequence_complaint (void)
2033 complaint (_(".debug_line section has line "
2034 "program sequence without an end"));
2038 dwarf2_complex_location_expr_complaint (void)
2040 complaint (_("location expression too complex"));
2044 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
2047 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
2052 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
2054 complaint (_("debug info runs off end of %s section"
2056 get_section_name (section
),
2057 get_section_file_name (section
));
2061 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
2063 complaint (_("macro debug info contains a "
2064 "malformed macro definition:\n`%s'"),
2069 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
2071 complaint (_("invalid attribute class or form for '%s' in '%s'"),
2075 /* Hash function for line_header_hash. */
2078 line_header_hash (const struct line_header
*ofs
)
2080 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
2083 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2086 line_header_hash_voidp (const void *item
)
2088 const struct line_header
*ofs
= (const struct line_header
*) item
;
2090 return line_header_hash (ofs
);
2093 /* Equality function for line_header_hash. */
2096 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
2098 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
2099 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
2101 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
2102 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
2107 /* Read the given attribute value as an address, taking the attribute's
2108 form into account. */
2111 attr_value_as_address (struct attribute
*attr
)
2115 if (attr
->form
!= DW_FORM_addr
&& attr
->form
!= DW_FORM_addrx
2116 && attr
->form
!= DW_FORM_GNU_addr_index
)
2118 /* Aside from a few clearly defined exceptions, attributes that
2119 contain an address must always be in DW_FORM_addr form.
2120 Unfortunately, some compilers happen to be violating this
2121 requirement by encoding addresses using other forms, such
2122 as DW_FORM_data4 for example. For those broken compilers,
2123 we try to do our best, without any guarantee of success,
2124 to interpret the address correctly. It would also be nice
2125 to generate a complaint, but that would require us to maintain
2126 a list of legitimate cases where a non-address form is allowed,
2127 as well as update callers to pass in at least the CU's DWARF
2128 version. This is more overhead than what we're willing to
2129 expand for a pretty rare case. */
2130 addr
= DW_UNSND (attr
);
2133 addr
= DW_ADDR (attr
);
2138 /* See declaration. */
2140 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile
*objfile_
,
2141 const dwarf2_debug_sections
*names
,
2143 : objfile (objfile_
),
2144 can_copy (can_copy_
)
2147 names
= &dwarf2_elf_names
;
2149 bfd
*obfd
= objfile
->obfd
;
2151 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2152 locate_sections (obfd
, sec
, *names
);
2155 dwarf2_per_objfile::~dwarf2_per_objfile ()
2157 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
2158 free_cached_comp_units ();
2160 if (quick_file_names_table
)
2161 htab_delete (quick_file_names_table
);
2163 if (line_header_hash
)
2164 htab_delete (line_header_hash
);
2166 for (dwarf2_per_cu_data
*per_cu
: all_comp_units
)
2167 VEC_free (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
);
2169 for (signatured_type
*sig_type
: all_type_units
)
2170 VEC_free (dwarf2_per_cu_ptr
, sig_type
->per_cu
.imported_symtabs
);
2172 /* Everything else should be on the objfile obstack. */
2175 /* See declaration. */
2178 dwarf2_per_objfile::free_cached_comp_units ()
2180 dwarf2_per_cu_data
*per_cu
= read_in_chain
;
2181 dwarf2_per_cu_data
**last_chain
= &read_in_chain
;
2182 while (per_cu
!= NULL
)
2184 dwarf2_per_cu_data
*next_cu
= per_cu
->cu
->read_in_chain
;
2187 *last_chain
= next_cu
;
2192 /* A helper class that calls free_cached_comp_units on
2195 class free_cached_comp_units
2199 explicit free_cached_comp_units (dwarf2_per_objfile
*per_objfile
)
2200 : m_per_objfile (per_objfile
)
2204 ~free_cached_comp_units ()
2206 m_per_objfile
->free_cached_comp_units ();
2209 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units
);
2213 dwarf2_per_objfile
*m_per_objfile
;
2216 /* Try to locate the sections we need for DWARF 2 debugging
2217 information and return true if we have enough to do something.
2218 NAMES points to the dwarf2 section names, or is NULL if the standard
2219 ELF names are used. CAN_COPY is true for formats where symbol
2220 interposition is possible and so symbol values must follow copy
2221 relocation rules. */
2224 dwarf2_has_info (struct objfile
*objfile
,
2225 const struct dwarf2_debug_sections
*names
,
2228 if (objfile
->flags
& OBJF_READNEVER
)
2231 struct dwarf2_per_objfile
*dwarf2_per_objfile
2232 = get_dwarf2_per_objfile (objfile
);
2234 if (dwarf2_per_objfile
== NULL
)
2235 dwarf2_per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
,
2239 return (!dwarf2_per_objfile
->info
.is_virtual
2240 && dwarf2_per_objfile
->info
.s
.section
!= NULL
2241 && !dwarf2_per_objfile
->abbrev
.is_virtual
2242 && dwarf2_per_objfile
->abbrev
.s
.section
!= NULL
);
2245 /* Return the containing section of virtual section SECTION. */
2247 static struct dwarf2_section_info
*
2248 get_containing_section (const struct dwarf2_section_info
*section
)
2250 gdb_assert (section
->is_virtual
);
2251 return section
->s
.containing_section
;
2254 /* Return the bfd owner of SECTION. */
2257 get_section_bfd_owner (const struct dwarf2_section_info
*section
)
2259 if (section
->is_virtual
)
2261 section
= get_containing_section (section
);
2262 gdb_assert (!section
->is_virtual
);
2264 return section
->s
.section
->owner
;
2267 /* Return the bfd section of SECTION.
2268 Returns NULL if the section is not present. */
2271 get_section_bfd_section (const struct dwarf2_section_info
*section
)
2273 if (section
->is_virtual
)
2275 section
= get_containing_section (section
);
2276 gdb_assert (!section
->is_virtual
);
2278 return section
->s
.section
;
2281 /* Return the name of SECTION. */
2284 get_section_name (const struct dwarf2_section_info
*section
)
2286 asection
*sectp
= get_section_bfd_section (section
);
2288 gdb_assert (sectp
!= NULL
);
2289 return bfd_section_name (sectp
);
2292 /* Return the name of the file SECTION is in. */
2295 get_section_file_name (const struct dwarf2_section_info
*section
)
2297 bfd
*abfd
= get_section_bfd_owner (section
);
2299 return bfd_get_filename (abfd
);
2302 /* Return the id of SECTION.
2303 Returns 0 if SECTION doesn't exist. */
2306 get_section_id (const struct dwarf2_section_info
*section
)
2308 asection
*sectp
= get_section_bfd_section (section
);
2315 /* Return the flags of SECTION.
2316 SECTION (or containing section if this is a virtual section) must exist. */
2319 get_section_flags (const struct dwarf2_section_info
*section
)
2321 asection
*sectp
= get_section_bfd_section (section
);
2323 gdb_assert (sectp
!= NULL
);
2324 return bfd_section_flags (sectp
);
2327 /* When loading sections, we look either for uncompressed section or for
2328 compressed section names. */
2331 section_is_p (const char *section_name
,
2332 const struct dwarf2_section_names
*names
)
2334 if (names
->normal
!= NULL
2335 && strcmp (section_name
, names
->normal
) == 0)
2337 if (names
->compressed
!= NULL
2338 && strcmp (section_name
, names
->compressed
) == 0)
2343 /* See declaration. */
2346 dwarf2_per_objfile::locate_sections (bfd
*abfd
, asection
*sectp
,
2347 const dwarf2_debug_sections
&names
)
2349 flagword aflag
= bfd_section_flags (sectp
);
2351 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2354 else if (section_is_p (sectp
->name
, &names
.info
))
2356 this->info
.s
.section
= sectp
;
2357 this->info
.size
= bfd_section_size (sectp
);
2359 else if (section_is_p (sectp
->name
, &names
.abbrev
))
2361 this->abbrev
.s
.section
= sectp
;
2362 this->abbrev
.size
= bfd_section_size (sectp
);
2364 else if (section_is_p (sectp
->name
, &names
.line
))
2366 this->line
.s
.section
= sectp
;
2367 this->line
.size
= bfd_section_size (sectp
);
2369 else if (section_is_p (sectp
->name
, &names
.loc
))
2371 this->loc
.s
.section
= sectp
;
2372 this->loc
.size
= bfd_section_size (sectp
);
2374 else if (section_is_p (sectp
->name
, &names
.loclists
))
2376 this->loclists
.s
.section
= sectp
;
2377 this->loclists
.size
= bfd_section_size (sectp
);
2379 else if (section_is_p (sectp
->name
, &names
.macinfo
))
2381 this->macinfo
.s
.section
= sectp
;
2382 this->macinfo
.size
= bfd_section_size (sectp
);
2384 else if (section_is_p (sectp
->name
, &names
.macro
))
2386 this->macro
.s
.section
= sectp
;
2387 this->macro
.size
= bfd_section_size (sectp
);
2389 else if (section_is_p (sectp
->name
, &names
.str
))
2391 this->str
.s
.section
= sectp
;
2392 this->str
.size
= bfd_section_size (sectp
);
2394 else if (section_is_p (sectp
->name
, &names
.line_str
))
2396 this->line_str
.s
.section
= sectp
;
2397 this->line_str
.size
= bfd_section_size (sectp
);
2399 else if (section_is_p (sectp
->name
, &names
.addr
))
2401 this->addr
.s
.section
= sectp
;
2402 this->addr
.size
= bfd_section_size (sectp
);
2404 else if (section_is_p (sectp
->name
, &names
.frame
))
2406 this->frame
.s
.section
= sectp
;
2407 this->frame
.size
= bfd_section_size (sectp
);
2409 else if (section_is_p (sectp
->name
, &names
.eh_frame
))
2411 this->eh_frame
.s
.section
= sectp
;
2412 this->eh_frame
.size
= bfd_section_size (sectp
);
2414 else if (section_is_p (sectp
->name
, &names
.ranges
))
2416 this->ranges
.s
.section
= sectp
;
2417 this->ranges
.size
= bfd_section_size (sectp
);
2419 else if (section_is_p (sectp
->name
, &names
.rnglists
))
2421 this->rnglists
.s
.section
= sectp
;
2422 this->rnglists
.size
= bfd_section_size (sectp
);
2424 else if (section_is_p (sectp
->name
, &names
.types
))
2426 struct dwarf2_section_info type_section
;
2428 memset (&type_section
, 0, sizeof (type_section
));
2429 type_section
.s
.section
= sectp
;
2430 type_section
.size
= bfd_section_size (sectp
);
2432 this->types
.push_back (type_section
);
2434 else if (section_is_p (sectp
->name
, &names
.gdb_index
))
2436 this->gdb_index
.s
.section
= sectp
;
2437 this->gdb_index
.size
= bfd_section_size (sectp
);
2439 else if (section_is_p (sectp
->name
, &names
.debug_names
))
2441 this->debug_names
.s
.section
= sectp
;
2442 this->debug_names
.size
= bfd_section_size (sectp
);
2444 else if (section_is_p (sectp
->name
, &names
.debug_aranges
))
2446 this->debug_aranges
.s
.section
= sectp
;
2447 this->debug_aranges
.size
= bfd_section_size (sectp
);
2450 if ((bfd_section_flags (sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2451 && bfd_section_vma (sectp
) == 0)
2452 this->has_section_at_zero
= true;
2455 /* A helper function that decides whether a section is empty,
2459 dwarf2_section_empty_p (const struct dwarf2_section_info
*section
)
2461 if (section
->is_virtual
)
2462 return section
->size
== 0;
2463 return section
->s
.section
== NULL
|| section
->size
== 0;
2466 /* See dwarf2read.h. */
2469 dwarf2_read_section (struct objfile
*objfile
, dwarf2_section_info
*info
)
2473 gdb_byte
*buf
, *retbuf
;
2477 info
->buffer
= NULL
;
2478 info
->readin
= true;
2480 if (dwarf2_section_empty_p (info
))
2483 sectp
= get_section_bfd_section (info
);
2485 /* If this is a virtual section we need to read in the real one first. */
2486 if (info
->is_virtual
)
2488 struct dwarf2_section_info
*containing_section
=
2489 get_containing_section (info
);
2491 gdb_assert (sectp
!= NULL
);
2492 if ((sectp
->flags
& SEC_RELOC
) != 0)
2494 error (_("Dwarf Error: DWP format V2 with relocations is not"
2495 " supported in section %s [in module %s]"),
2496 get_section_name (info
), get_section_file_name (info
));
2498 dwarf2_read_section (objfile
, containing_section
);
2499 /* Other code should have already caught virtual sections that don't
2501 gdb_assert (info
->virtual_offset
+ info
->size
2502 <= containing_section
->size
);
2503 /* If the real section is empty or there was a problem reading the
2504 section we shouldn't get here. */
2505 gdb_assert (containing_section
->buffer
!= NULL
);
2506 info
->buffer
= containing_section
->buffer
+ info
->virtual_offset
;
2510 /* If the section has relocations, we must read it ourselves.
2511 Otherwise we attach it to the BFD. */
2512 if ((sectp
->flags
& SEC_RELOC
) == 0)
2514 info
->buffer
= gdb_bfd_map_section (sectp
, &info
->size
);
2518 buf
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
2521 /* When debugging .o files, we may need to apply relocations; see
2522 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2523 We never compress sections in .o files, so we only need to
2524 try this when the section is not compressed. */
2525 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
2528 info
->buffer
= retbuf
;
2532 abfd
= get_section_bfd_owner (info
);
2533 gdb_assert (abfd
!= NULL
);
2535 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
2536 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
2538 error (_("Dwarf Error: Can't read DWARF data"
2539 " in section %s [in module %s]"),
2540 bfd_section_name (sectp
), bfd_get_filename (abfd
));
2544 /* A helper function that returns the size of a section in a safe way.
2545 If you are positive that the section has been read before using the
2546 size, then it is safe to refer to the dwarf2_section_info object's
2547 "size" field directly. In other cases, you must call this
2548 function, because for compressed sections the size field is not set
2549 correctly until the section has been read. */
2551 static bfd_size_type
2552 dwarf2_section_size (struct objfile
*objfile
,
2553 struct dwarf2_section_info
*info
)
2556 dwarf2_read_section (objfile
, info
);
2560 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2564 dwarf2_get_section_info (struct objfile
*objfile
,
2565 enum dwarf2_section_enum sect
,
2566 asection
**sectp
, const gdb_byte
**bufp
,
2567 bfd_size_type
*sizep
)
2569 struct dwarf2_per_objfile
*data
= dwarf2_objfile_data_key
.get (objfile
);
2570 struct dwarf2_section_info
*info
;
2572 /* We may see an objfile without any DWARF, in which case we just
2583 case DWARF2_DEBUG_FRAME
:
2584 info
= &data
->frame
;
2586 case DWARF2_EH_FRAME
:
2587 info
= &data
->eh_frame
;
2590 gdb_assert_not_reached ("unexpected section");
2593 dwarf2_read_section (objfile
, info
);
2595 *sectp
= get_section_bfd_section (info
);
2596 *bufp
= info
->buffer
;
2597 *sizep
= info
->size
;
2600 /* A helper function to find the sections for a .dwz file. */
2603 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2605 struct dwz_file
*dwz_file
= (struct dwz_file
*) arg
;
2607 /* Note that we only support the standard ELF names, because .dwz
2608 is ELF-only (at the time of writing). */
2609 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2611 dwz_file
->abbrev
.s
.section
= sectp
;
2612 dwz_file
->abbrev
.size
= bfd_section_size (sectp
);
2614 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2616 dwz_file
->info
.s
.section
= sectp
;
2617 dwz_file
->info
.size
= bfd_section_size (sectp
);
2619 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2621 dwz_file
->str
.s
.section
= sectp
;
2622 dwz_file
->str
.size
= bfd_section_size (sectp
);
2624 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2626 dwz_file
->line
.s
.section
= sectp
;
2627 dwz_file
->line
.size
= bfd_section_size (sectp
);
2629 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2631 dwz_file
->macro
.s
.section
= sectp
;
2632 dwz_file
->macro
.size
= bfd_section_size (sectp
);
2634 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2636 dwz_file
->gdb_index
.s
.section
= sectp
;
2637 dwz_file
->gdb_index
.size
= bfd_section_size (sectp
);
2639 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.debug_names
))
2641 dwz_file
->debug_names
.s
.section
= sectp
;
2642 dwz_file
->debug_names
.size
= bfd_section_size (sectp
);
2646 /* See dwarf2read.h. */
2649 dwarf2_get_dwz_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
2651 const char *filename
;
2652 bfd_size_type buildid_len_arg
;
2656 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2657 return dwarf2_per_objfile
->dwz_file
.get ();
2659 bfd_set_error (bfd_error_no_error
);
2660 gdb::unique_xmalloc_ptr
<char> data
2661 (bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2662 &buildid_len_arg
, &buildid
));
2665 if (bfd_get_error () == bfd_error_no_error
)
2667 error (_("could not read '.gnu_debugaltlink' section: %s"),
2668 bfd_errmsg (bfd_get_error ()));
2671 gdb::unique_xmalloc_ptr
<bfd_byte
> buildid_holder (buildid
);
2673 buildid_len
= (size_t) buildid_len_arg
;
2675 filename
= data
.get ();
2677 std::string abs_storage
;
2678 if (!IS_ABSOLUTE_PATH (filename
))
2680 gdb::unique_xmalloc_ptr
<char> abs
2681 = gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2683 abs_storage
= ldirname (abs
.get ()) + SLASH_STRING
+ filename
;
2684 filename
= abs_storage
.c_str ();
2687 /* First try the file name given in the section. If that doesn't
2688 work, try to use the build-id instead. */
2689 gdb_bfd_ref_ptr
dwz_bfd (gdb_bfd_open (filename
, gnutarget
, -1));
2690 if (dwz_bfd
!= NULL
)
2692 if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2693 dwz_bfd
.reset (nullptr);
2696 if (dwz_bfd
== NULL
)
2697 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2699 if (dwz_bfd
== NULL
)
2700 error (_("could not find '.gnu_debugaltlink' file for %s"),
2701 objfile_name (dwarf2_per_objfile
->objfile
));
2703 std::unique_ptr
<struct dwz_file
> result
2704 (new struct dwz_file (std::move (dwz_bfd
)));
2706 bfd_map_over_sections (result
->dwz_bfd
.get (), locate_dwz_sections
,
2709 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
,
2710 result
->dwz_bfd
.get ());
2711 dwarf2_per_objfile
->dwz_file
= std::move (result
);
2712 return dwarf2_per_objfile
->dwz_file
.get ();
2715 /* DWARF quick_symbols_functions support. */
2717 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2718 unique line tables, so we maintain a separate table of all .debug_line
2719 derived entries to support the sharing.
2720 All the quick functions need is the list of file names. We discard the
2721 line_header when we're done and don't need to record it here. */
2722 struct quick_file_names
2724 /* The data used to construct the hash key. */
2725 struct stmt_list_hash hash
;
2727 /* The number of entries in file_names, real_names. */
2728 unsigned int num_file_names
;
2730 /* The file names from the line table, after being run through
2732 const char **file_names
;
2734 /* The file names from the line table after being run through
2735 gdb_realpath. These are computed lazily. */
2736 const char **real_names
;
2739 /* When using the index (and thus not using psymtabs), each CU has an
2740 object of this type. This is used to hold information needed by
2741 the various "quick" methods. */
2742 struct dwarf2_per_cu_quick_data
2744 /* The file table. This can be NULL if there was no file table
2745 or it's currently not read in.
2746 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2747 struct quick_file_names
*file_names
;
2749 /* The corresponding symbol table. This is NULL if symbols for this
2750 CU have not yet been read. */
2751 struct compunit_symtab
*compunit_symtab
;
2753 /* A temporary mark bit used when iterating over all CUs in
2754 expand_symtabs_matching. */
2755 unsigned int mark
: 1;
2757 /* True if we've tried to read the file table and found there isn't one.
2758 There will be no point in trying to read it again next time. */
2759 unsigned int no_file_data
: 1;
2762 /* Utility hash function for a stmt_list_hash. */
2765 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2769 if (stmt_list_hash
->dwo_unit
!= NULL
)
2770 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2771 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2775 /* Utility equality function for a stmt_list_hash. */
2778 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2779 const struct stmt_list_hash
*rhs
)
2781 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2783 if (lhs
->dwo_unit
!= NULL
2784 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2787 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2790 /* Hash function for a quick_file_names. */
2793 hash_file_name_entry (const void *e
)
2795 const struct quick_file_names
*file_data
2796 = (const struct quick_file_names
*) e
;
2798 return hash_stmt_list_entry (&file_data
->hash
);
2801 /* Equality function for a quick_file_names. */
2804 eq_file_name_entry (const void *a
, const void *b
)
2806 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2807 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2809 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2812 /* Delete function for a quick_file_names. */
2815 delete_file_name_entry (void *e
)
2817 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2820 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2822 xfree ((void*) file_data
->file_names
[i
]);
2823 if (file_data
->real_names
)
2824 xfree ((void*) file_data
->real_names
[i
]);
2827 /* The space for the struct itself lives on objfile_obstack,
2828 so we don't free it here. */
2831 /* Create a quick_file_names hash table. */
2834 create_quick_file_names_table (unsigned int nr_initial_entries
)
2836 return htab_create_alloc (nr_initial_entries
,
2837 hash_file_name_entry
, eq_file_name_entry
,
2838 delete_file_name_entry
, xcalloc
, xfree
);
2841 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2842 have to be created afterwards. You should call age_cached_comp_units after
2843 processing PER_CU->CU. dw2_setup must have been already called. */
2846 load_cu (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2848 if (per_cu
->is_debug_types
)
2849 load_full_type_unit (per_cu
);
2851 load_full_comp_unit (per_cu
, skip_partial
, language_minimal
);
2853 if (per_cu
->cu
== NULL
)
2854 return; /* Dummy CU. */
2856 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2859 /* Read in the symbols for PER_CU. */
2862 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2864 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
2866 /* Skip type_unit_groups, reading the type units they contain
2867 is handled elsewhere. */
2868 if (IS_TYPE_UNIT_GROUP (per_cu
))
2871 /* The destructor of dwarf2_queue_guard frees any entries left on
2872 the queue. After this point we're guaranteed to leave this function
2873 with the dwarf queue empty. */
2874 dwarf2_queue_guard q_guard
;
2876 if (dwarf2_per_objfile
->using_index
2877 ? per_cu
->v
.quick
->compunit_symtab
== NULL
2878 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2880 queue_comp_unit (per_cu
, language_minimal
);
2881 load_cu (per_cu
, skip_partial
);
2883 /* If we just loaded a CU from a DWO, and we're working with an index
2884 that may badly handle TUs, load all the TUs in that DWO as well.
2885 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2886 if (!per_cu
->is_debug_types
2887 && per_cu
->cu
!= NULL
2888 && per_cu
->cu
->dwo_unit
!= NULL
2889 && dwarf2_per_objfile
->index_table
!= NULL
2890 && dwarf2_per_objfile
->index_table
->version
<= 7
2891 /* DWP files aren't supported yet. */
2892 && get_dwp_file (dwarf2_per_objfile
) == NULL
)
2893 queue_and_load_all_dwo_tus (per_cu
);
2896 process_queue (dwarf2_per_objfile
);
2898 /* Age the cache, releasing compilation units that have not
2899 been used recently. */
2900 age_cached_comp_units (dwarf2_per_objfile
);
2903 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2904 the objfile from which this CU came. Returns the resulting symbol
2907 static struct compunit_symtab
*
2908 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2910 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
2912 gdb_assert (dwarf2_per_objfile
->using_index
);
2913 if (!per_cu
->v
.quick
->compunit_symtab
)
2915 free_cached_comp_units
freer (dwarf2_per_objfile
);
2916 scoped_restore decrementer
= increment_reading_symtab ();
2917 dw2_do_instantiate_symtab (per_cu
, skip_partial
);
2918 process_cu_includes (dwarf2_per_objfile
);
2921 return per_cu
->v
.quick
->compunit_symtab
;
2924 /* See declaration. */
2926 dwarf2_per_cu_data
*
2927 dwarf2_per_objfile::get_cutu (int index
)
2929 if (index
>= this->all_comp_units
.size ())
2931 index
-= this->all_comp_units
.size ();
2932 gdb_assert (index
< this->all_type_units
.size ());
2933 return &this->all_type_units
[index
]->per_cu
;
2936 return this->all_comp_units
[index
];
2939 /* See declaration. */
2941 dwarf2_per_cu_data
*
2942 dwarf2_per_objfile::get_cu (int index
)
2944 gdb_assert (index
>= 0 && index
< this->all_comp_units
.size ());
2946 return this->all_comp_units
[index
];
2949 /* See declaration. */
2952 dwarf2_per_objfile::get_tu (int index
)
2954 gdb_assert (index
>= 0 && index
< this->all_type_units
.size ());
2956 return this->all_type_units
[index
];
2959 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2960 objfile_obstack, and constructed with the specified field
2963 static dwarf2_per_cu_data
*
2964 create_cu_from_index_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2965 struct dwarf2_section_info
*section
,
2967 sect_offset sect_off
, ULONGEST length
)
2969 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2970 dwarf2_per_cu_data
*the_cu
2971 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2972 struct dwarf2_per_cu_data
);
2973 the_cu
->sect_off
= sect_off
;
2974 the_cu
->length
= length
;
2975 the_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
2976 the_cu
->section
= section
;
2977 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2978 struct dwarf2_per_cu_quick_data
);
2979 the_cu
->is_dwz
= is_dwz
;
2983 /* A helper for create_cus_from_index that handles a given list of
2987 create_cus_from_index_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2988 const gdb_byte
*cu_list
, offset_type n_elements
,
2989 struct dwarf2_section_info
*section
,
2992 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
2994 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2996 sect_offset sect_off
2997 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2998 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
3001 dwarf2_per_cu_data
*per_cu
3002 = create_cu_from_index_list (dwarf2_per_objfile
, section
, is_dwz
,
3004 dwarf2_per_objfile
->all_comp_units
.push_back (per_cu
);
3008 /* Read the CU list from the mapped index, and use it to create all
3009 the CU objects for this objfile. */
3012 create_cus_from_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3013 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
3014 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
3016 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
3017 dwarf2_per_objfile
->all_comp_units
.reserve
3018 ((cu_list_elements
+ dwz_elements
) / 2);
3020 create_cus_from_index_list (dwarf2_per_objfile
, cu_list
, cu_list_elements
,
3021 &dwarf2_per_objfile
->info
, 0);
3023 if (dwz_elements
== 0)
3026 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
3027 create_cus_from_index_list (dwarf2_per_objfile
, dwz_list
, dwz_elements
,
3031 /* Create the signatured type hash table from the index. */
3034 create_signatured_type_table_from_index
3035 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3036 struct dwarf2_section_info
*section
,
3037 const gdb_byte
*bytes
,
3038 offset_type elements
)
3040 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3042 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
3043 dwarf2_per_objfile
->all_type_units
.reserve (elements
/ 3);
3045 htab_t sig_types_hash
= allocate_signatured_type_table (objfile
);
3047 for (offset_type i
= 0; i
< elements
; i
+= 3)
3049 struct signatured_type
*sig_type
;
3052 cu_offset type_offset_in_tu
;
3054 gdb_static_assert (sizeof (ULONGEST
) >= 8);
3055 sect_offset sect_off
3056 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
3058 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
3060 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
3063 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3064 struct signatured_type
);
3065 sig_type
->signature
= signature
;
3066 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
3067 sig_type
->per_cu
.is_debug_types
= 1;
3068 sig_type
->per_cu
.section
= section
;
3069 sig_type
->per_cu
.sect_off
= sect_off
;
3070 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
3071 sig_type
->per_cu
.v
.quick
3072 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3073 struct dwarf2_per_cu_quick_data
);
3075 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
3078 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
3081 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
3084 /* Create the signatured type hash table from .debug_names. */
3087 create_signatured_type_table_from_debug_names
3088 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3089 const mapped_debug_names
&map
,
3090 struct dwarf2_section_info
*section
,
3091 struct dwarf2_section_info
*abbrev_section
)
3093 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3095 dwarf2_read_section (objfile
, section
);
3096 dwarf2_read_section (objfile
, abbrev_section
);
3098 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
3099 dwarf2_per_objfile
->all_type_units
.reserve (map
.tu_count
);
3101 htab_t sig_types_hash
= allocate_signatured_type_table (objfile
);
3103 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
3105 struct signatured_type
*sig_type
;
3108 sect_offset sect_off
3109 = (sect_offset
) (extract_unsigned_integer
3110 (map
.tu_table_reordered
+ i
* map
.offset_size
,
3112 map
.dwarf5_byte_order
));
3114 comp_unit_head cu_header
;
3115 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
3117 section
->buffer
+ to_underlying (sect_off
),
3120 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3121 struct signatured_type
);
3122 sig_type
->signature
= cu_header
.signature
;
3123 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
3124 sig_type
->per_cu
.is_debug_types
= 1;
3125 sig_type
->per_cu
.section
= section
;
3126 sig_type
->per_cu
.sect_off
= sect_off
;
3127 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
3128 sig_type
->per_cu
.v
.quick
3129 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3130 struct dwarf2_per_cu_quick_data
);
3132 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
3135 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
3138 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
3141 /* Read the address map data from the mapped index, and use it to
3142 populate the objfile's psymtabs_addrmap. */
3145 create_addrmap_from_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3146 struct mapped_index
*index
)
3148 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3149 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3150 const gdb_byte
*iter
, *end
;
3151 struct addrmap
*mutable_map
;
3154 auto_obstack temp_obstack
;
3156 mutable_map
= addrmap_create_mutable (&temp_obstack
);
3158 iter
= index
->address_table
.data ();
3159 end
= iter
+ index
->address_table
.size ();
3161 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3165 ULONGEST hi
, lo
, cu_index
;
3166 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3168 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3170 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
3175 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
3176 hex_string (lo
), hex_string (hi
));
3180 if (cu_index
>= dwarf2_per_objfile
->all_comp_units
.size ())
3182 complaint (_(".gdb_index address table has invalid CU number %u"),
3183 (unsigned) cu_index
);
3187 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
3188 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
3189 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
3190 dwarf2_per_objfile
->get_cu (cu_index
));
3193 objfile
->partial_symtabs
->psymtabs_addrmap
3194 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
3197 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3198 populate the objfile's psymtabs_addrmap. */
3201 create_addrmap_from_aranges (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3202 struct dwarf2_section_info
*section
)
3204 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3205 bfd
*abfd
= objfile
->obfd
;
3206 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3207 const CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
3208 SECT_OFF_TEXT (objfile
));
3210 auto_obstack temp_obstack
;
3211 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
3213 std::unordered_map
<sect_offset
,
3214 dwarf2_per_cu_data
*,
3215 gdb::hash_enum
<sect_offset
>>
3216 debug_info_offset_to_per_cu
;
3217 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
3219 const auto insertpair
3220 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
, per_cu
);
3221 if (!insertpair
.second
)
3223 warning (_("Section .debug_aranges in %s has duplicate "
3224 "debug_info_offset %s, ignoring .debug_aranges."),
3225 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
3230 dwarf2_read_section (objfile
, section
);
3232 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
3234 const gdb_byte
*addr
= section
->buffer
;
3236 while (addr
< section
->buffer
+ section
->size
)
3238 const gdb_byte
*const entry_addr
= addr
;
3239 unsigned int bytes_read
;
3241 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
3245 const gdb_byte
*const entry_end
= addr
+ entry_length
;
3246 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
3247 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
3248 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
3250 warning (_("Section .debug_aranges in %s entry at offset %s "
3251 "length %s exceeds section length %s, "
3252 "ignoring .debug_aranges."),
3253 objfile_name (objfile
),
3254 plongest (entry_addr
- section
->buffer
),
3255 plongest (bytes_read
+ entry_length
),
3256 pulongest (section
->size
));
3260 /* The version number. */
3261 const uint16_t version
= read_2_bytes (abfd
, addr
);
3265 warning (_("Section .debug_aranges in %s entry at offset %s "
3266 "has unsupported version %d, ignoring .debug_aranges."),
3267 objfile_name (objfile
),
3268 plongest (entry_addr
- section
->buffer
), version
);
3272 const uint64_t debug_info_offset
3273 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
3274 addr
+= offset_size
;
3275 const auto per_cu_it
3276 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
3277 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
3279 warning (_("Section .debug_aranges in %s entry at offset %s "
3280 "debug_info_offset %s does not exists, "
3281 "ignoring .debug_aranges."),
3282 objfile_name (objfile
),
3283 plongest (entry_addr
- section
->buffer
),
3284 pulongest (debug_info_offset
));
3287 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
3289 const uint8_t address_size
= *addr
++;
3290 if (address_size
< 1 || address_size
> 8)
3292 warning (_("Section .debug_aranges in %s entry at offset %s "
3293 "address_size %u is invalid, ignoring .debug_aranges."),
3294 objfile_name (objfile
),
3295 plongest (entry_addr
- section
->buffer
), address_size
);
3299 const uint8_t segment_selector_size
= *addr
++;
3300 if (segment_selector_size
!= 0)
3302 warning (_("Section .debug_aranges in %s entry at offset %s "
3303 "segment_selector_size %u is not supported, "
3304 "ignoring .debug_aranges."),
3305 objfile_name (objfile
),
3306 plongest (entry_addr
- section
->buffer
),
3307 segment_selector_size
);
3311 /* Must pad to an alignment boundary that is twice the address
3312 size. It is undocumented by the DWARF standard but GCC does
3314 for (size_t padding
= ((-(addr
- section
->buffer
))
3315 & (2 * address_size
- 1));
3316 padding
> 0; padding
--)
3319 warning (_("Section .debug_aranges in %s entry at offset %s "
3320 "padding is not zero, ignoring .debug_aranges."),
3321 objfile_name (objfile
),
3322 plongest (entry_addr
- section
->buffer
));
3328 if (addr
+ 2 * address_size
> entry_end
)
3330 warning (_("Section .debug_aranges in %s entry at offset %s "
3331 "address list is not properly terminated, "
3332 "ignoring .debug_aranges."),
3333 objfile_name (objfile
),
3334 plongest (entry_addr
- section
->buffer
));
3337 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
3339 addr
+= address_size
;
3340 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
3342 addr
+= address_size
;
3343 if (start
== 0 && length
== 0)
3345 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3347 /* Symbol was eliminated due to a COMDAT group. */
3350 ULONGEST end
= start
+ length
;
3351 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
3353 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
3355 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
3359 objfile
->partial_symtabs
->psymtabs_addrmap
3360 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
3363 /* Find a slot in the mapped index INDEX for the object named NAME.
3364 If NAME is found, set *VEC_OUT to point to the CU vector in the
3365 constant pool and return true. If NAME cannot be found, return
3369 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
3370 offset_type
**vec_out
)
3373 offset_type slot
, step
;
3374 int (*cmp
) (const char *, const char *);
3376 gdb::unique_xmalloc_ptr
<char> without_params
;
3377 if (current_language
->la_language
== language_cplus
3378 || current_language
->la_language
== language_fortran
3379 || current_language
->la_language
== language_d
)
3381 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3384 if (strchr (name
, '(') != NULL
)
3386 without_params
= cp_remove_params (name
);
3388 if (without_params
!= NULL
)
3389 name
= without_params
.get ();
3393 /* Index version 4 did not support case insensitive searches. But the
3394 indices for case insensitive languages are built in lowercase, therefore
3395 simulate our NAME being searched is also lowercased. */
3396 hash
= mapped_index_string_hash ((index
->version
== 4
3397 && case_sensitivity
== case_sensitive_off
3398 ? 5 : index
->version
),
3401 slot
= hash
& (index
->symbol_table
.size () - 1);
3402 step
= ((hash
* 17) & (index
->symbol_table
.size () - 1)) | 1;
3403 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
3409 const auto &bucket
= index
->symbol_table
[slot
];
3410 if (bucket
.name
== 0 && bucket
.vec
== 0)
3413 str
= index
->constant_pool
+ MAYBE_SWAP (bucket
.name
);
3414 if (!cmp (name
, str
))
3416 *vec_out
= (offset_type
*) (index
->constant_pool
3417 + MAYBE_SWAP (bucket
.vec
));
3421 slot
= (slot
+ step
) & (index
->symbol_table
.size () - 1);
3425 /* A helper function that reads the .gdb_index from BUFFER and fills
3426 in MAP. FILENAME is the name of the file containing the data;
3427 it is used for error reporting. DEPRECATED_OK is true if it is
3428 ok to use deprecated sections.
3430 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3431 out parameters that are filled in with information about the CU and
3432 TU lists in the section.
3434 Returns true if all went well, false otherwise. */
3437 read_gdb_index_from_buffer (struct objfile
*objfile
,
3438 const char *filename
,
3440 gdb::array_view
<const gdb_byte
> buffer
,
3441 struct mapped_index
*map
,
3442 const gdb_byte
**cu_list
,
3443 offset_type
*cu_list_elements
,
3444 const gdb_byte
**types_list
,
3445 offset_type
*types_list_elements
)
3447 const gdb_byte
*addr
= &buffer
[0];
3449 /* Version check. */
3450 offset_type version
= MAYBE_SWAP (*(offset_type
*) addr
);
3451 /* Versions earlier than 3 emitted every copy of a psymbol. This
3452 causes the index to behave very poorly for certain requests. Version 3
3453 contained incomplete addrmap. So, it seems better to just ignore such
3457 static int warning_printed
= 0;
3458 if (!warning_printed
)
3460 warning (_("Skipping obsolete .gdb_index section in %s."),
3462 warning_printed
= 1;
3466 /* Index version 4 uses a different hash function than index version
3469 Versions earlier than 6 did not emit psymbols for inlined
3470 functions. Using these files will cause GDB not to be able to
3471 set breakpoints on inlined functions by name, so we ignore these
3472 indices unless the user has done
3473 "set use-deprecated-index-sections on". */
3474 if (version
< 6 && !deprecated_ok
)
3476 static int warning_printed
= 0;
3477 if (!warning_printed
)
3480 Skipping deprecated .gdb_index section in %s.\n\
3481 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3482 to use the section anyway."),
3484 warning_printed
= 1;
3488 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3489 of the TU (for symbols coming from TUs),
3490 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3491 Plus gold-generated indices can have duplicate entries for global symbols,
3492 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3493 These are just performance bugs, and we can't distinguish gdb-generated
3494 indices from gold-generated ones, so issue no warning here. */
3496 /* Indexes with higher version than the one supported by GDB may be no
3497 longer backward compatible. */
3501 map
->version
= version
;
3503 offset_type
*metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3506 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3507 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3511 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3512 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3513 - MAYBE_SWAP (metadata
[i
]))
3517 const gdb_byte
*address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3518 const gdb_byte
*address_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3520 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
3523 const gdb_byte
*symbol_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3524 const gdb_byte
*symbol_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3526 = gdb::array_view
<mapped_index::symbol_table_slot
>
3527 ((mapped_index::symbol_table_slot
*) symbol_table
,
3528 (mapped_index::symbol_table_slot
*) symbol_table_end
);
3531 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3536 /* Callback types for dwarf2_read_gdb_index. */
3538 typedef gdb::function_view
3539 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_objfile
*)>
3540 get_gdb_index_contents_ftype
;
3541 typedef gdb::function_view
3542 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
3543 get_gdb_index_contents_dwz_ftype
;
3545 /* Read .gdb_index. If everything went ok, initialize the "quick"
3546 elements of all the CUs and return 1. Otherwise, return 0. */
3549 dwarf2_read_gdb_index
3550 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3551 get_gdb_index_contents_ftype get_gdb_index_contents
,
3552 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
3554 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3555 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3556 struct dwz_file
*dwz
;
3557 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3559 gdb::array_view
<const gdb_byte
> main_index_contents
3560 = get_gdb_index_contents (objfile
, dwarf2_per_objfile
);
3562 if (main_index_contents
.empty ())
3565 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
3566 if (!read_gdb_index_from_buffer (objfile
, objfile_name (objfile
),
3567 use_deprecated_index_sections
,
3568 main_index_contents
, map
.get (), &cu_list
,
3569 &cu_list_elements
, &types_list
,
3570 &types_list_elements
))
3573 /* Don't use the index if it's empty. */
3574 if (map
->symbol_table
.empty ())
3577 /* If there is a .dwz file, read it so we can get its CU list as
3579 dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
3582 struct mapped_index dwz_map
;
3583 const gdb_byte
*dwz_types_ignore
;
3584 offset_type dwz_types_elements_ignore
;
3586 gdb::array_view
<const gdb_byte
> dwz_index_content
3587 = get_gdb_index_contents_dwz (objfile
, dwz
);
3589 if (dwz_index_content
.empty ())
3592 if (!read_gdb_index_from_buffer (objfile
,
3593 bfd_get_filename (dwz
->dwz_bfd
.get ()),
3594 1, dwz_index_content
, &dwz_map
,
3595 &dwz_list
, &dwz_list_elements
,
3597 &dwz_types_elements_ignore
))
3599 warning (_("could not read '.gdb_index' section from %s; skipping"),
3600 bfd_get_filename (dwz
->dwz_bfd
.get ()));
3605 create_cus_from_index (dwarf2_per_objfile
, cu_list
, cu_list_elements
,
3606 dwz_list
, dwz_list_elements
);
3608 if (types_list_elements
)
3610 /* We can only handle a single .debug_types when we have an
3612 if (dwarf2_per_objfile
->types
.size () != 1)
3615 dwarf2_section_info
*section
= &dwarf2_per_objfile
->types
[0];
3617 create_signatured_type_table_from_index (dwarf2_per_objfile
, section
,
3618 types_list
, types_list_elements
);
3621 create_addrmap_from_index (dwarf2_per_objfile
, map
.get ());
3623 dwarf2_per_objfile
->index_table
= std::move (map
);
3624 dwarf2_per_objfile
->using_index
= 1;
3625 dwarf2_per_objfile
->quick_file_names_table
=
3626 create_quick_file_names_table (dwarf2_per_objfile
->all_comp_units
.size ());
3631 /* die_reader_func for dw2_get_file_names. */
3634 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3635 const gdb_byte
*info_ptr
,
3636 struct die_info
*comp_unit_die
,
3640 struct dwarf2_cu
*cu
= reader
->cu
;
3641 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3642 struct dwarf2_per_objfile
*dwarf2_per_objfile
3643 = cu
->per_cu
->dwarf2_per_objfile
;
3644 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3645 struct dwarf2_per_cu_data
*lh_cu
;
3646 struct attribute
*attr
;
3649 struct quick_file_names
*qfn
;
3651 gdb_assert (! this_cu
->is_debug_types
);
3653 /* Our callers never want to match partial units -- instead they
3654 will match the enclosing full CU. */
3655 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3657 this_cu
->v
.quick
->no_file_data
= 1;
3665 sect_offset line_offset
{};
3667 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3670 struct quick_file_names find_entry
;
3672 line_offset
= (sect_offset
) DW_UNSND (attr
);
3674 /* We may have already read in this line header (TU line header sharing).
3675 If we have we're done. */
3676 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3677 find_entry
.hash
.line_sect_off
= line_offset
;
3678 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
3679 &find_entry
, INSERT
);
3682 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3686 lh
= dwarf_decode_line_header (line_offset
, cu
);
3690 lh_cu
->v
.quick
->no_file_data
= 1;
3694 qfn
= XOBNEW (&objfile
->objfile_obstack
, struct quick_file_names
);
3695 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3696 qfn
->hash
.line_sect_off
= line_offset
;
3697 gdb_assert (slot
!= NULL
);
3700 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3703 if (strcmp (fnd
.name
, "<unknown>") != 0)
3706 qfn
->num_file_names
= offset
+ lh
->file_names
.size ();
3708 XOBNEWVEC (&objfile
->objfile_obstack
, const char *, qfn
->num_file_names
);
3710 qfn
->file_names
[0] = xstrdup (fnd
.name
);
3711 for (i
= 0; i
< lh
->file_names
.size (); ++i
)
3712 qfn
->file_names
[i
+ offset
] = file_full_name (i
+ 1, lh
.get (), fnd
.comp_dir
);
3713 qfn
->real_names
= NULL
;
3715 lh_cu
->v
.quick
->file_names
= qfn
;
3718 /* A helper for the "quick" functions which attempts to read the line
3719 table for THIS_CU. */
3721 static struct quick_file_names
*
3722 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
3724 /* This should never be called for TUs. */
3725 gdb_assert (! this_cu
->is_debug_types
);
3726 /* Nor type unit groups. */
3727 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
3729 if (this_cu
->v
.quick
->file_names
!= NULL
)
3730 return this_cu
->v
.quick
->file_names
;
3731 /* If we know there is no line data, no point in looking again. */
3732 if (this_cu
->v
.quick
->no_file_data
)
3735 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
3737 if (this_cu
->v
.quick
->no_file_data
)
3739 return this_cu
->v
.quick
->file_names
;
3742 /* A helper for the "quick" functions which computes and caches the
3743 real path for a given file name from the line table. */
3746 dw2_get_real_path (struct objfile
*objfile
,
3747 struct quick_file_names
*qfn
, int index
)
3749 if (qfn
->real_names
== NULL
)
3750 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3751 qfn
->num_file_names
, const char *);
3753 if (qfn
->real_names
[index
] == NULL
)
3754 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3756 return qfn
->real_names
[index
];
3759 static struct symtab
*
3760 dw2_find_last_source_symtab (struct objfile
*objfile
)
3762 struct dwarf2_per_objfile
*dwarf2_per_objfile
3763 = get_dwarf2_per_objfile (objfile
);
3764 dwarf2_per_cu_data
*dwarf_cu
= dwarf2_per_objfile
->all_comp_units
.back ();
3765 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, false);
3770 return compunit_primary_filetab (cust
);
3773 /* Traversal function for dw2_forget_cached_source_info. */
3776 dw2_free_cached_file_names (void **slot
, void *info
)
3778 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3780 if (file_data
->real_names
)
3784 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3786 xfree ((void*) file_data
->real_names
[i
]);
3787 file_data
->real_names
[i
] = NULL
;
3795 dw2_forget_cached_source_info (struct objfile
*objfile
)
3797 struct dwarf2_per_objfile
*dwarf2_per_objfile
3798 = get_dwarf2_per_objfile (objfile
);
3800 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
3801 dw2_free_cached_file_names
, NULL
);
3804 /* Helper function for dw2_map_symtabs_matching_filename that expands
3805 the symtabs and calls the iterator. */
3808 dw2_map_expand_apply (struct objfile
*objfile
,
3809 struct dwarf2_per_cu_data
*per_cu
,
3810 const char *name
, const char *real_path
,
3811 gdb::function_view
<bool (symtab
*)> callback
)
3813 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3815 /* Don't visit already-expanded CUs. */
3816 if (per_cu
->v
.quick
->compunit_symtab
)
3819 /* This may expand more than one symtab, and we want to iterate over
3821 dw2_instantiate_symtab (per_cu
, false);
3823 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
3824 last_made
, callback
);
3827 /* Implementation of the map_symtabs_matching_filename method. */
3830 dw2_map_symtabs_matching_filename
3831 (struct objfile
*objfile
, const char *name
, const char *real_path
,
3832 gdb::function_view
<bool (symtab
*)> callback
)
3834 const char *name_basename
= lbasename (name
);
3835 struct dwarf2_per_objfile
*dwarf2_per_objfile
3836 = get_dwarf2_per_objfile (objfile
);
3838 /* The rule is CUs specify all the files, including those used by
3839 any TU, so there's no need to scan TUs here. */
3841 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
3843 /* We only need to look at symtabs not already expanded. */
3844 if (per_cu
->v
.quick
->compunit_symtab
)
3847 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
3848 if (file_data
== NULL
)
3851 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3853 const char *this_name
= file_data
->file_names
[j
];
3854 const char *this_real_name
;
3856 if (compare_filenames_for_search (this_name
, name
))
3858 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3864 /* Before we invoke realpath, which can get expensive when many
3865 files are involved, do a quick comparison of the basenames. */
3866 if (! basenames_may_differ
3867 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3870 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3871 if (compare_filenames_for_search (this_real_name
, name
))
3873 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3879 if (real_path
!= NULL
)
3881 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3882 gdb_assert (IS_ABSOLUTE_PATH (name
));
3883 if (this_real_name
!= NULL
3884 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3886 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3898 /* Struct used to manage iterating over all CUs looking for a symbol. */
3900 struct dw2_symtab_iterator
3902 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3903 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
3904 /* If set, only look for symbols that match that block. Valid values are
3905 GLOBAL_BLOCK and STATIC_BLOCK. */
3906 gdb::optional
<block_enum
> block_index
;
3907 /* The kind of symbol we're looking for. */
3909 /* The list of CUs from the index entry of the symbol,
3910 or NULL if not found. */
3912 /* The next element in VEC to look at. */
3914 /* The number of elements in VEC, or zero if there is no match. */
3916 /* Have we seen a global version of the symbol?
3917 If so we can ignore all further global instances.
3918 This is to work around gold/15646, inefficient gold-generated
3923 /* Initialize the index symtab iterator ITER. */
3926 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3927 struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3928 gdb::optional
<block_enum
> block_index
,
3932 iter
->dwarf2_per_objfile
= dwarf2_per_objfile
;
3933 iter
->block_index
= block_index
;
3934 iter
->domain
= domain
;
3936 iter
->global_seen
= 0;
3938 mapped_index
*index
= dwarf2_per_objfile
->index_table
.get ();
3940 /* index is NULL if OBJF_READNOW. */
3941 if (index
!= NULL
&& find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3942 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3950 /* Return the next matching CU or NULL if there are no more. */
3952 static struct dwarf2_per_cu_data
*
3953 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3955 struct dwarf2_per_objfile
*dwarf2_per_objfile
= iter
->dwarf2_per_objfile
;
3957 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3959 offset_type cu_index_and_attrs
=
3960 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3961 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3962 gdb_index_symbol_kind symbol_kind
=
3963 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3964 /* Only check the symbol attributes if they're present.
3965 Indices prior to version 7 don't record them,
3966 and indices >= 7 may elide them for certain symbols
3967 (gold does this). */
3969 (dwarf2_per_objfile
->index_table
->version
>= 7
3970 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3972 /* Don't crash on bad data. */
3973 if (cu_index
>= (dwarf2_per_objfile
->all_comp_units
.size ()
3974 + dwarf2_per_objfile
->all_type_units
.size ()))
3976 complaint (_(".gdb_index entry has bad CU index"
3978 objfile_name (dwarf2_per_objfile
->objfile
));
3982 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (cu_index
);
3984 /* Skip if already read in. */
3985 if (per_cu
->v
.quick
->compunit_symtab
)
3988 /* Check static vs global. */
3991 bool is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3993 if (iter
->block_index
.has_value ())
3995 bool want_static
= *iter
->block_index
== STATIC_BLOCK
;
3997 if (is_static
!= want_static
)
4001 /* Work around gold/15646. */
4002 if (!is_static
&& iter
->global_seen
)
4005 iter
->global_seen
= 1;
4008 /* Only check the symbol's kind if it has one. */
4011 switch (iter
->domain
)
4014 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
4015 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
4016 /* Some types are also in VAR_DOMAIN. */
4017 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4021 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4025 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4040 static struct compunit_symtab
*
4041 dw2_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
4042 const char *name
, domain_enum domain
)
4044 struct compunit_symtab
*stab_best
= NULL
;
4045 struct dwarf2_per_objfile
*dwarf2_per_objfile
4046 = get_dwarf2_per_objfile (objfile
);
4048 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
4050 struct dw2_symtab_iterator iter
;
4051 struct dwarf2_per_cu_data
*per_cu
;
4053 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, block_index
, domain
, name
);
4055 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
4057 struct symbol
*sym
, *with_opaque
= NULL
;
4058 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
, false);
4059 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
4060 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
4062 sym
= block_find_symbol (block
, name
, domain
,
4063 block_find_non_opaque_type_preferred
,
4066 /* Some caution must be observed with overloaded functions
4067 and methods, since the index will not contain any overload
4068 information (but NAME might contain it). */
4071 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
4073 if (with_opaque
!= NULL
4074 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
4077 /* Keep looking through other CUs. */
4084 dw2_print_stats (struct objfile
*objfile
)
4086 struct dwarf2_per_objfile
*dwarf2_per_objfile
4087 = get_dwarf2_per_objfile (objfile
);
4088 int total
= (dwarf2_per_objfile
->all_comp_units
.size ()
4089 + dwarf2_per_objfile
->all_type_units
.size ());
4092 for (int i
= 0; i
< total
; ++i
)
4094 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
4096 if (!per_cu
->v
.quick
->compunit_symtab
)
4099 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
4100 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
4103 /* This dumps minimal information about the index.
4104 It is called via "mt print objfiles".
4105 One use is to verify .gdb_index has been loaded by the
4106 gdb.dwarf2/gdb-index.exp testcase. */
4109 dw2_dump (struct objfile
*objfile
)
4111 struct dwarf2_per_objfile
*dwarf2_per_objfile
4112 = get_dwarf2_per_objfile (objfile
);
4114 gdb_assert (dwarf2_per_objfile
->using_index
);
4115 printf_filtered (".gdb_index:");
4116 if (dwarf2_per_objfile
->index_table
!= NULL
)
4118 printf_filtered (" version %d\n",
4119 dwarf2_per_objfile
->index_table
->version
);
4122 printf_filtered (" faked for \"readnow\"\n");
4123 printf_filtered ("\n");
4127 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
4128 const char *func_name
)
4130 struct dwarf2_per_objfile
*dwarf2_per_objfile
4131 = get_dwarf2_per_objfile (objfile
);
4133 struct dw2_symtab_iterator iter
;
4134 struct dwarf2_per_cu_data
*per_cu
;
4136 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, {}, VAR_DOMAIN
, func_name
);
4138 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
4139 dw2_instantiate_symtab (per_cu
, false);
4144 dw2_expand_all_symtabs (struct objfile
*objfile
)
4146 struct dwarf2_per_objfile
*dwarf2_per_objfile
4147 = get_dwarf2_per_objfile (objfile
);
4148 int total_units
= (dwarf2_per_objfile
->all_comp_units
.size ()
4149 + dwarf2_per_objfile
->all_type_units
.size ());
4151 for (int i
= 0; i
< total_units
; ++i
)
4153 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
4155 /* We don't want to directly expand a partial CU, because if we
4156 read it with the wrong language, then assertion failures can
4157 be triggered later on. See PR symtab/23010. So, tell
4158 dw2_instantiate_symtab to skip partial CUs -- any important
4159 partial CU will be read via DW_TAG_imported_unit anyway. */
4160 dw2_instantiate_symtab (per_cu
, true);
4165 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
4166 const char *fullname
)
4168 struct dwarf2_per_objfile
*dwarf2_per_objfile
4169 = get_dwarf2_per_objfile (objfile
);
4171 /* We don't need to consider type units here.
4172 This is only called for examining code, e.g. expand_line_sal.
4173 There can be an order of magnitude (or more) more type units
4174 than comp units, and we avoid them if we can. */
4176 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
4178 /* We only need to look at symtabs not already expanded. */
4179 if (per_cu
->v
.quick
->compunit_symtab
)
4182 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
4183 if (file_data
== NULL
)
4186 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4188 const char *this_fullname
= file_data
->file_names
[j
];
4190 if (filename_cmp (this_fullname
, fullname
) == 0)
4192 dw2_instantiate_symtab (per_cu
, false);
4200 dw2_map_matching_symbols
4201 (struct objfile
*objfile
,
4202 const lookup_name_info
&name
, domain_enum domain
,
4204 gdb::function_view
<symbol_found_callback_ftype
> callback
,
4205 symbol_compare_ftype
*ordered_compare
)
4207 /* Currently unimplemented; used for Ada. The function can be called if the
4208 current language is Ada for a non-Ada objfile using GNU index. As Ada
4209 does not look for non-Ada symbols this function should just return. */
4212 /* Starting from a search name, return the string that finds the upper
4213 bound of all strings that start with SEARCH_NAME in a sorted name
4214 list. Returns the empty string to indicate that the upper bound is
4215 the end of the list. */
4218 make_sort_after_prefix_name (const char *search_name
)
4220 /* When looking to complete "func", we find the upper bound of all
4221 symbols that start with "func" by looking for where we'd insert
4222 the closest string that would follow "func" in lexicographical
4223 order. Usually, that's "func"-with-last-character-incremented,
4224 i.e. "fund". Mind non-ASCII characters, though. Usually those
4225 will be UTF-8 multi-byte sequences, but we can't be certain.
4226 Especially mind the 0xff character, which is a valid character in
4227 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4228 rule out compilers allowing it in identifiers. Note that
4229 conveniently, strcmp/strcasecmp are specified to compare
4230 characters interpreted as unsigned char. So what we do is treat
4231 the whole string as a base 256 number composed of a sequence of
4232 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4233 to 0, and carries 1 to the following more-significant position.
4234 If the very first character in SEARCH_NAME ends up incremented
4235 and carries/overflows, then the upper bound is the end of the
4236 list. The string after the empty string is also the empty
4239 Some examples of this operation:
4241 SEARCH_NAME => "+1" RESULT
4245 "\xff" "a" "\xff" => "\xff" "b"
4250 Then, with these symbols for example:
4256 completing "func" looks for symbols between "func" and
4257 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4258 which finds "func" and "func1", but not "fund".
4262 funcÿ (Latin1 'ÿ' [0xff])
4266 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4267 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4271 ÿÿ (Latin1 'ÿ' [0xff])
4274 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4275 the end of the list.
4277 std::string after
= search_name
;
4278 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
4280 if (!after
.empty ())
4281 after
.back () = (unsigned char) after
.back () + 1;
4285 /* See declaration. */
4287 std::pair
<std::vector
<name_component
>::const_iterator
,
4288 std::vector
<name_component
>::const_iterator
>
4289 mapped_index_base::find_name_components_bounds
4290 (const lookup_name_info
&lookup_name_without_params
, language lang
) const
4293 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4295 const char *lang_name
4296 = lookup_name_without_params
.language_lookup_name (lang
).c_str ();
4298 /* Comparison function object for lower_bound that matches against a
4299 given symbol name. */
4300 auto lookup_compare_lower
= [&] (const name_component
&elem
,
4303 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4304 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4305 return name_cmp (elem_name
, name
) < 0;
4308 /* Comparison function object for upper_bound that matches against a
4309 given symbol name. */
4310 auto lookup_compare_upper
= [&] (const char *name
,
4311 const name_component
&elem
)
4313 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4314 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4315 return name_cmp (name
, elem_name
) < 0;
4318 auto begin
= this->name_components
.begin ();
4319 auto end
= this->name_components
.end ();
4321 /* Find the lower bound. */
4324 if (lookup_name_without_params
.completion_mode () && lang_name
[0] == '\0')
4327 return std::lower_bound (begin
, end
, lang_name
, lookup_compare_lower
);
4330 /* Find the upper bound. */
4333 if (lookup_name_without_params
.completion_mode ())
4335 /* In completion mode, we want UPPER to point past all
4336 symbols names that have the same prefix. I.e., with
4337 these symbols, and completing "func":
4339 function << lower bound
4341 other_function << upper bound
4343 We find the upper bound by looking for the insertion
4344 point of "func"-with-last-character-incremented,
4346 std::string after
= make_sort_after_prefix_name (lang_name
);
4349 return std::lower_bound (lower
, end
, after
.c_str (),
4350 lookup_compare_lower
);
4353 return std::upper_bound (lower
, end
, lang_name
, lookup_compare_upper
);
4356 return {lower
, upper
};
4359 /* See declaration. */
4362 mapped_index_base::build_name_components ()
4364 if (!this->name_components
.empty ())
4367 this->name_components_casing
= case_sensitivity
;
4369 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4371 /* The code below only knows how to break apart components of C++
4372 symbol names (and other languages that use '::' as
4373 namespace/module separator) and Ada symbol names. */
4374 auto count
= this->symbol_name_count ();
4375 for (offset_type idx
= 0; idx
< count
; idx
++)
4377 if (this->symbol_name_slot_invalid (idx
))
4380 const char *name
= this->symbol_name_at (idx
);
4382 /* Add each name component to the name component table. */
4383 unsigned int previous_len
= 0;
4385 if (strstr (name
, "::") != nullptr)
4387 for (unsigned int current_len
= cp_find_first_component (name
);
4388 name
[current_len
] != '\0';
4389 current_len
+= cp_find_first_component (name
+ current_len
))
4391 gdb_assert (name
[current_len
] == ':');
4392 this->name_components
.push_back ({previous_len
, idx
});
4393 /* Skip the '::'. */
4395 previous_len
= current_len
;
4400 /* Handle the Ada encoded (aka mangled) form here. */
4401 for (const char *iter
= strstr (name
, "__");
4403 iter
= strstr (iter
, "__"))
4405 this->name_components
.push_back ({previous_len
, idx
});
4407 previous_len
= iter
- name
;
4411 this->name_components
.push_back ({previous_len
, idx
});
4414 /* Sort name_components elements by name. */
4415 auto name_comp_compare
= [&] (const name_component
&left
,
4416 const name_component
&right
)
4418 const char *left_qualified
= this->symbol_name_at (left
.idx
);
4419 const char *right_qualified
= this->symbol_name_at (right
.idx
);
4421 const char *left_name
= left_qualified
+ left
.name_offset
;
4422 const char *right_name
= right_qualified
+ right
.name_offset
;
4424 return name_cmp (left_name
, right_name
) < 0;
4427 std::sort (this->name_components
.begin (),
4428 this->name_components
.end (),
4432 /* Helper for dw2_expand_symtabs_matching that works with a
4433 mapped_index_base instead of the containing objfile. This is split
4434 to a separate function in order to be able to unit test the
4435 name_components matching using a mock mapped_index_base. For each
4436 symbol name that matches, calls MATCH_CALLBACK, passing it the
4437 symbol's index in the mapped_index_base symbol table. */
4440 dw2_expand_symtabs_matching_symbol
4441 (mapped_index_base
&index
,
4442 const lookup_name_info
&lookup_name_in
,
4443 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4444 enum search_domain kind
,
4445 gdb::function_view
<bool (offset_type
)> match_callback
)
4447 lookup_name_info lookup_name_without_params
4448 = lookup_name_in
.make_ignore_params ();
4450 /* Build the symbol name component sorted vector, if we haven't
4452 index
.build_name_components ();
4454 /* The same symbol may appear more than once in the range though.
4455 E.g., if we're looking for symbols that complete "w", and we have
4456 a symbol named "w1::w2", we'll find the two name components for
4457 that same symbol in the range. To be sure we only call the
4458 callback once per symbol, we first collect the symbol name
4459 indexes that matched in a temporary vector and ignore
4461 std::vector
<offset_type
> matches
;
4463 struct name_and_matcher
4465 symbol_name_matcher_ftype
*matcher
;
4466 const std::string
&name
;
4468 bool operator== (const name_and_matcher
&other
) const
4470 return matcher
== other
.matcher
&& name
== other
.name
;
4474 /* A vector holding all the different symbol name matchers, for all
4476 std::vector
<name_and_matcher
> matchers
;
4478 for (int i
= 0; i
< nr_languages
; i
++)
4480 enum language lang_e
= (enum language
) i
;
4482 const language_defn
*lang
= language_def (lang_e
);
4483 symbol_name_matcher_ftype
*name_matcher
4484 = get_symbol_name_matcher (lang
, lookup_name_without_params
);
4486 name_and_matcher key
{
4488 lookup_name_without_params
.language_lookup_name (lang_e
)
4491 /* Don't insert the same comparison routine more than once.
4492 Note that we do this linear walk. This is not a problem in
4493 practice because the number of supported languages is
4495 if (std::find (matchers
.begin (), matchers
.end (), key
)
4498 matchers
.push_back (std::move (key
));
4501 = index
.find_name_components_bounds (lookup_name_without_params
,
4504 /* Now for each symbol name in range, check to see if we have a name
4505 match, and if so, call the MATCH_CALLBACK callback. */
4507 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
4509 const char *qualified
= index
.symbol_name_at (bounds
.first
->idx
);
4511 if (!name_matcher (qualified
, lookup_name_without_params
, NULL
)
4512 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
4515 matches
.push_back (bounds
.first
->idx
);
4519 std::sort (matches
.begin (), matches
.end ());
4521 /* Finally call the callback, once per match. */
4523 for (offset_type idx
: matches
)
4527 if (!match_callback (idx
))
4533 /* Above we use a type wider than idx's for 'prev', since 0 and
4534 (offset_type)-1 are both possible values. */
4535 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
4540 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
4542 /* A mock .gdb_index/.debug_names-like name index table, enough to
4543 exercise dw2_expand_symtabs_matching_symbol, which works with the
4544 mapped_index_base interface. Builds an index from the symbol list
4545 passed as parameter to the constructor. */
4546 class mock_mapped_index
: public mapped_index_base
4549 mock_mapped_index (gdb::array_view
<const char *> symbols
)
4550 : m_symbol_table (symbols
)
4553 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
4555 /* Return the number of names in the symbol table. */
4556 size_t symbol_name_count () const override
4558 return m_symbol_table
.size ();
4561 /* Get the name of the symbol at IDX in the symbol table. */
4562 const char *symbol_name_at (offset_type idx
) const override
4564 return m_symbol_table
[idx
];
4568 gdb::array_view
<const char *> m_symbol_table
;
4571 /* Convenience function that converts a NULL pointer to a "<null>"
4572 string, to pass to print routines. */
4575 string_or_null (const char *str
)
4577 return str
!= NULL
? str
: "<null>";
4580 /* Check if a lookup_name_info built from
4581 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4582 index. EXPECTED_LIST is the list of expected matches, in expected
4583 matching order. If no match expected, then an empty list is
4584 specified. Returns true on success. On failure prints a warning
4585 indicating the file:line that failed, and returns false. */
4588 check_match (const char *file
, int line
,
4589 mock_mapped_index
&mock_index
,
4590 const char *name
, symbol_name_match_type match_type
,
4591 bool completion_mode
,
4592 std::initializer_list
<const char *> expected_list
)
4594 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4596 bool matched
= true;
4598 auto mismatch
= [&] (const char *expected_str
,
4601 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4602 "expected=\"%s\", got=\"%s\"\n"),
4604 (match_type
== symbol_name_match_type::FULL
4606 name
, string_or_null (expected_str
), string_or_null (got
));
4610 auto expected_it
= expected_list
.begin ();
4611 auto expected_end
= expected_list
.end ();
4613 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
4615 [&] (offset_type idx
)
4617 const char *matched_name
= mock_index
.symbol_name_at (idx
);
4618 const char *expected_str
4619 = expected_it
== expected_end
? NULL
: *expected_it
++;
4621 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4622 mismatch (expected_str
, matched_name
);
4626 const char *expected_str
4627 = expected_it
== expected_end
? NULL
: *expected_it
++;
4628 if (expected_str
!= NULL
)
4629 mismatch (expected_str
, NULL
);
4634 /* The symbols added to the mock mapped_index for testing (in
4636 static const char *test_symbols
[] = {
4645 "ns2::tmpl<int>::foo2",
4646 "(anonymous namespace)::A::B::C",
4648 /* These are used to check that the increment-last-char in the
4649 matching algorithm for completion doesn't match "t1_fund" when
4650 completing "t1_func". */
4656 /* A UTF-8 name with multi-byte sequences to make sure that
4657 cp-name-parser understands this as a single identifier ("função"
4658 is "function" in PT). */
4661 /* \377 (0xff) is Latin1 'ÿ'. */
4664 /* \377 (0xff) is Latin1 'ÿ'. */
4668 /* A name with all sorts of complications. Starts with "z" to make
4669 it easier for the completion tests below. */
4670 #define Z_SYM_NAME \
4671 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4672 "::tuple<(anonymous namespace)::ui*, " \
4673 "std::default_delete<(anonymous namespace)::ui>, void>"
4678 /* Returns true if the mapped_index_base::find_name_component_bounds
4679 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4680 in completion mode. */
4683 check_find_bounds_finds (mapped_index_base
&index
,
4684 const char *search_name
,
4685 gdb::array_view
<const char *> expected_syms
)
4687 lookup_name_info
lookup_name (search_name
,
4688 symbol_name_match_type::FULL
, true);
4690 auto bounds
= index
.find_name_components_bounds (lookup_name
,
4693 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
4694 if (distance
!= expected_syms
.size ())
4697 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
4699 auto nc_elem
= bounds
.first
+ exp_elem
;
4700 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
);
4701 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
4708 /* Test the lower-level mapped_index::find_name_component_bounds
4712 test_mapped_index_find_name_component_bounds ()
4714 mock_mapped_index
mock_index (test_symbols
);
4716 mock_index
.build_name_components ();
4718 /* Test the lower-level mapped_index::find_name_component_bounds
4719 method in completion mode. */
4721 static const char *expected_syms
[] = {
4726 SELF_CHECK (check_find_bounds_finds (mock_index
,
4727 "t1_func", expected_syms
));
4730 /* Check that the increment-last-char in the name matching algorithm
4731 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4733 static const char *expected_syms1
[] = {
4737 SELF_CHECK (check_find_bounds_finds (mock_index
,
4738 "\377", expected_syms1
));
4740 static const char *expected_syms2
[] = {
4743 SELF_CHECK (check_find_bounds_finds (mock_index
,
4744 "\377\377", expected_syms2
));
4748 /* Test dw2_expand_symtabs_matching_symbol. */
4751 test_dw2_expand_symtabs_matching_symbol ()
4753 mock_mapped_index
mock_index (test_symbols
);
4755 /* We let all tests run until the end even if some fails, for debug
4757 bool any_mismatch
= false;
4759 /* Create the expected symbols list (an initializer_list). Needed
4760 because lists have commas, and we need to pass them to CHECK,
4761 which is a macro. */
4762 #define EXPECT(...) { __VA_ARGS__ }
4764 /* Wrapper for check_match that passes down the current
4765 __FILE__/__LINE__. */
4766 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4767 any_mismatch |= !check_match (__FILE__, __LINE__, \
4769 NAME, MATCH_TYPE, COMPLETION_MODE, \
4772 /* Identity checks. */
4773 for (const char *sym
: test_symbols
)
4775 /* Should be able to match all existing symbols. */
4776 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4779 /* Should be able to match all existing symbols with
4781 std::string with_params
= std::string (sym
) + "(int)";
4782 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4785 /* Should be able to match all existing symbols with
4786 parameters and qualifiers. */
4787 with_params
= std::string (sym
) + " ( int ) const";
4788 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4791 /* This should really find sym, but cp-name-parser.y doesn't
4792 know about lvalue/rvalue qualifiers yet. */
4793 with_params
= std::string (sym
) + " ( int ) &&";
4794 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4798 /* Check that the name matching algorithm for completion doesn't get
4799 confused with Latin1 'ÿ' / 0xff. */
4801 static const char str
[] = "\377";
4802 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4803 EXPECT ("\377", "\377\377123"));
4806 /* Check that the increment-last-char in the matching algorithm for
4807 completion doesn't match "t1_fund" when completing "t1_func". */
4809 static const char str
[] = "t1_func";
4810 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4811 EXPECT ("t1_func", "t1_func1"));
4814 /* Check that completion mode works at each prefix of the expected
4817 static const char str
[] = "function(int)";
4818 size_t len
= strlen (str
);
4821 for (size_t i
= 1; i
< len
; i
++)
4823 lookup
.assign (str
, i
);
4824 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4825 EXPECT ("function"));
4829 /* While "w" is a prefix of both components, the match function
4830 should still only be called once. */
4832 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4834 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4838 /* Same, with a "complicated" symbol. */
4840 static const char str
[] = Z_SYM_NAME
;
4841 size_t len
= strlen (str
);
4844 for (size_t i
= 1; i
< len
; i
++)
4846 lookup
.assign (str
, i
);
4847 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4848 EXPECT (Z_SYM_NAME
));
4852 /* In FULL mode, an incomplete symbol doesn't match. */
4854 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4858 /* A complete symbol with parameters matches any overload, since the
4859 index has no overload info. */
4861 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4862 EXPECT ("std::zfunction", "std::zfunction2"));
4863 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4864 EXPECT ("std::zfunction", "std::zfunction2"));
4865 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4866 EXPECT ("std::zfunction", "std::zfunction2"));
4869 /* Check that whitespace is ignored appropriately. A symbol with a
4870 template argument list. */
4872 static const char expected
[] = "ns::foo<int>";
4873 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4875 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4879 /* Check that whitespace is ignored appropriately. A symbol with a
4880 template argument list that includes a pointer. */
4882 static const char expected
[] = "ns::foo<char*>";
4883 /* Try both completion and non-completion modes. */
4884 static const bool completion_mode
[2] = {false, true};
4885 for (size_t i
= 0; i
< 2; i
++)
4887 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4888 completion_mode
[i
], EXPECT (expected
));
4889 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4890 completion_mode
[i
], EXPECT (expected
));
4892 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4893 completion_mode
[i
], EXPECT (expected
));
4894 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4895 completion_mode
[i
], EXPECT (expected
));
4900 /* Check method qualifiers are ignored. */
4901 static const char expected
[] = "ns::foo<char*>";
4902 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4903 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4904 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4905 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4906 CHECK_MATCH ("foo < char * > ( int ) const",
4907 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4908 CHECK_MATCH ("foo < char * > ( int ) &&",
4909 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4912 /* Test lookup names that don't match anything. */
4914 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4917 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4921 /* Some wild matching tests, exercising "(anonymous namespace)",
4922 which should not be confused with a parameter list. */
4924 static const char *syms
[] = {
4928 "A :: B :: C ( int )",
4933 for (const char *s
: syms
)
4935 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4936 EXPECT ("(anonymous namespace)::A::B::C"));
4941 static const char expected
[] = "ns2::tmpl<int>::foo2";
4942 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4944 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4948 SELF_CHECK (!any_mismatch
);
4957 test_mapped_index_find_name_component_bounds ();
4958 test_dw2_expand_symtabs_matching_symbol ();
4961 }} // namespace selftests::dw2_expand_symtabs_matching
4963 #endif /* GDB_SELF_TEST */
4965 /* If FILE_MATCHER is NULL or if PER_CU has
4966 dwarf2_per_cu_quick_data::MARK set (see
4967 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4968 EXPANSION_NOTIFY on it. */
4971 dw2_expand_symtabs_matching_one
4972 (struct dwarf2_per_cu_data
*per_cu
,
4973 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4974 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4976 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4978 bool symtab_was_null
4979 = (per_cu
->v
.quick
->compunit_symtab
== NULL
);
4981 dw2_instantiate_symtab (per_cu
, false);
4983 if (expansion_notify
!= NULL
4985 && per_cu
->v
.quick
->compunit_symtab
!= NULL
)
4986 expansion_notify (per_cu
->v
.quick
->compunit_symtab
);
4990 /* Helper for dw2_expand_matching symtabs. Called on each symbol
4991 matched, to expand corresponding CUs that were marked. IDX is the
4992 index of the symbol name that matched. */
4995 dw2_expand_marked_cus
4996 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, offset_type idx
,
4997 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4998 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5001 offset_type
*vec
, vec_len
, vec_idx
;
5002 bool global_seen
= false;
5003 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
5005 vec
= (offset_type
*) (index
.constant_pool
5006 + MAYBE_SWAP (index
.symbol_table
[idx
].vec
));
5007 vec_len
= MAYBE_SWAP (vec
[0]);
5008 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
5010 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
5011 /* This value is only valid for index versions >= 7. */
5012 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
5013 gdb_index_symbol_kind symbol_kind
=
5014 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
5015 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
5016 /* Only check the symbol attributes if they're present.
5017 Indices prior to version 7 don't record them,
5018 and indices >= 7 may elide them for certain symbols
5019 (gold does this). */
5022 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
5024 /* Work around gold/15646. */
5027 if (!is_static
&& global_seen
)
5033 /* Only check the symbol's kind if it has one. */
5038 case VARIABLES_DOMAIN
:
5039 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
5042 case FUNCTIONS_DOMAIN
:
5043 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
5047 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
5055 /* Don't crash on bad data. */
5056 if (cu_index
>= (dwarf2_per_objfile
->all_comp_units
.size ()
5057 + dwarf2_per_objfile
->all_type_units
.size ()))
5059 complaint (_(".gdb_index entry has bad CU index"
5061 objfile_name (dwarf2_per_objfile
->objfile
));
5065 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (cu_index
);
5066 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
5071 /* If FILE_MATCHER is non-NULL, set all the
5072 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5073 that match FILE_MATCHER. */
5076 dw_expand_symtabs_matching_file_matcher
5077 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5078 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
5080 if (file_matcher
== NULL
)
5083 objfile
*const objfile
= dwarf2_per_objfile
->objfile
;
5085 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
5087 NULL
, xcalloc
, xfree
));
5088 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
5090 NULL
, xcalloc
, xfree
));
5092 /* The rule is CUs specify all the files, including those used by
5093 any TU, so there's no need to scan TUs here. */
5095 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5099 per_cu
->v
.quick
->mark
= 0;
5101 /* We only need to look at symtabs not already expanded. */
5102 if (per_cu
->v
.quick
->compunit_symtab
)
5105 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
5106 if (file_data
== NULL
)
5109 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
5111 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
5113 per_cu
->v
.quick
->mark
= 1;
5117 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5119 const char *this_real_name
;
5121 if (file_matcher (file_data
->file_names
[j
], false))
5123 per_cu
->v
.quick
->mark
= 1;
5127 /* Before we invoke realpath, which can get expensive when many
5128 files are involved, do a quick comparison of the basenames. */
5129 if (!basenames_may_differ
5130 && !file_matcher (lbasename (file_data
->file_names
[j
]),
5134 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
5135 if (file_matcher (this_real_name
, false))
5137 per_cu
->v
.quick
->mark
= 1;
5142 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
5143 ? visited_found
.get ()
5144 : visited_not_found
.get (),
5151 dw2_expand_symtabs_matching
5152 (struct objfile
*objfile
,
5153 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5154 const lookup_name_info
&lookup_name
,
5155 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5156 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5157 enum search_domain kind
)
5159 struct dwarf2_per_objfile
*dwarf2_per_objfile
5160 = get_dwarf2_per_objfile (objfile
);
5162 /* index_table is NULL if OBJF_READNOW. */
5163 if (!dwarf2_per_objfile
->index_table
)
5166 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
5168 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
5170 dw2_expand_symtabs_matching_symbol (index
, lookup_name
,
5172 kind
, [&] (offset_type idx
)
5174 dw2_expand_marked_cus (dwarf2_per_objfile
, idx
, file_matcher
,
5175 expansion_notify
, kind
);
5180 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5183 static struct compunit_symtab
*
5184 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
5189 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
5190 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
5193 if (cust
->includes
== NULL
)
5196 for (i
= 0; cust
->includes
[i
]; ++i
)
5198 struct compunit_symtab
*s
= cust
->includes
[i
];
5200 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
5208 static struct compunit_symtab
*
5209 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
5210 struct bound_minimal_symbol msymbol
,
5212 struct obj_section
*section
,
5215 struct dwarf2_per_cu_data
*data
;
5216 struct compunit_symtab
*result
;
5218 if (!objfile
->partial_symtabs
->psymtabs_addrmap
)
5221 CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
5222 SECT_OFF_TEXT (objfile
));
5223 data
= (struct dwarf2_per_cu_data
*) addrmap_find
5224 (objfile
->partial_symtabs
->psymtabs_addrmap
, pc
- baseaddr
);
5228 if (warn_if_readin
&& data
->v
.quick
->compunit_symtab
)
5229 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5230 paddress (get_objfile_arch (objfile
), pc
));
5233 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data
,
5236 gdb_assert (result
!= NULL
);
5241 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
5242 void *data
, int need_fullname
)
5244 struct dwarf2_per_objfile
*dwarf2_per_objfile
5245 = get_dwarf2_per_objfile (objfile
);
5247 if (!dwarf2_per_objfile
->filenames_cache
)
5249 dwarf2_per_objfile
->filenames_cache
.emplace ();
5251 htab_up
visited (htab_create_alloc (10,
5252 htab_hash_pointer
, htab_eq_pointer
,
5253 NULL
, xcalloc
, xfree
));
5255 /* The rule is CUs specify all the files, including those used
5256 by any TU, so there's no need to scan TUs here. We can
5257 ignore file names coming from already-expanded CUs. */
5259 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5261 if (per_cu
->v
.quick
->compunit_symtab
)
5263 void **slot
= htab_find_slot (visited
.get (),
5264 per_cu
->v
.quick
->file_names
,
5267 *slot
= per_cu
->v
.quick
->file_names
;
5271 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5273 /* We only need to look at symtabs not already expanded. */
5274 if (per_cu
->v
.quick
->compunit_symtab
)
5277 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
5278 if (file_data
== NULL
)
5281 void **slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
5284 /* Already visited. */
5289 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5291 const char *filename
= file_data
->file_names
[j
];
5292 dwarf2_per_objfile
->filenames_cache
->seen (filename
);
5297 dwarf2_per_objfile
->filenames_cache
->traverse ([&] (const char *filename
)
5299 gdb::unique_xmalloc_ptr
<char> this_real_name
;
5302 this_real_name
= gdb_realpath (filename
);
5303 (*fun
) (filename
, this_real_name
.get (), data
);
5308 dw2_has_symbols (struct objfile
*objfile
)
5313 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
5316 dw2_find_last_source_symtab
,
5317 dw2_forget_cached_source_info
,
5318 dw2_map_symtabs_matching_filename
,
5322 dw2_expand_symtabs_for_function
,
5323 dw2_expand_all_symtabs
,
5324 dw2_expand_symtabs_with_fullname
,
5325 dw2_map_matching_symbols
,
5326 dw2_expand_symtabs_matching
,
5327 dw2_find_pc_sect_compunit_symtab
,
5329 dw2_map_symbol_filenames
5332 /* DWARF-5 debug_names reader. */
5334 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5335 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
5337 /* A helper function that reads the .debug_names section in SECTION
5338 and fills in MAP. FILENAME is the name of the file containing the
5339 section; it is used for error reporting.
5341 Returns true if all went well, false otherwise. */
5344 read_debug_names_from_section (struct objfile
*objfile
,
5345 const char *filename
,
5346 struct dwarf2_section_info
*section
,
5347 mapped_debug_names
&map
)
5349 if (dwarf2_section_empty_p (section
))
5352 /* Older elfutils strip versions could keep the section in the main
5353 executable while splitting it for the separate debug info file. */
5354 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
5357 dwarf2_read_section (objfile
, section
);
5359 map
.dwarf5_byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
5361 const gdb_byte
*addr
= section
->buffer
;
5363 bfd
*const abfd
= get_section_bfd_owner (section
);
5365 unsigned int bytes_read
;
5366 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
5369 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
5370 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
5371 if (bytes_read
+ length
!= section
->size
)
5373 /* There may be multiple per-CU indices. */
5374 warning (_("Section .debug_names in %s length %s does not match "
5375 "section length %s, ignoring .debug_names."),
5376 filename
, plongest (bytes_read
+ length
),
5377 pulongest (section
->size
));
5381 /* The version number. */
5382 uint16_t version
= read_2_bytes (abfd
, addr
);
5386 warning (_("Section .debug_names in %s has unsupported version %d, "
5387 "ignoring .debug_names."),
5393 uint16_t padding
= read_2_bytes (abfd
, addr
);
5397 warning (_("Section .debug_names in %s has unsupported padding %d, "
5398 "ignoring .debug_names."),
5403 /* comp_unit_count - The number of CUs in the CU list. */
5404 map
.cu_count
= read_4_bytes (abfd
, addr
);
5407 /* local_type_unit_count - The number of TUs in the local TU
5409 map
.tu_count
= read_4_bytes (abfd
, addr
);
5412 /* foreign_type_unit_count - The number of TUs in the foreign TU
5414 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
5416 if (foreign_tu_count
!= 0)
5418 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5419 "ignoring .debug_names."),
5420 filename
, static_cast<unsigned long> (foreign_tu_count
));
5424 /* bucket_count - The number of hash buckets in the hash lookup
5426 map
.bucket_count
= read_4_bytes (abfd
, addr
);
5429 /* name_count - The number of unique names in the index. */
5430 map
.name_count
= read_4_bytes (abfd
, addr
);
5433 /* abbrev_table_size - The size in bytes of the abbreviations
5435 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
5438 /* augmentation_string_size - The size in bytes of the augmentation
5439 string. This value is rounded up to a multiple of 4. */
5440 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
5442 map
.augmentation_is_gdb
= ((augmentation_string_size
5443 == sizeof (dwarf5_augmentation
))
5444 && memcmp (addr
, dwarf5_augmentation
,
5445 sizeof (dwarf5_augmentation
)) == 0);
5446 augmentation_string_size
+= (-augmentation_string_size
) & 3;
5447 addr
+= augmentation_string_size
;
5450 map
.cu_table_reordered
= addr
;
5451 addr
+= map
.cu_count
* map
.offset_size
;
5453 /* List of Local TUs */
5454 map
.tu_table_reordered
= addr
;
5455 addr
+= map
.tu_count
* map
.offset_size
;
5457 /* Hash Lookup Table */
5458 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5459 addr
+= map
.bucket_count
* 4;
5460 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5461 addr
+= map
.name_count
* 4;
5464 map
.name_table_string_offs_reordered
= addr
;
5465 addr
+= map
.name_count
* map
.offset_size
;
5466 map
.name_table_entry_offs_reordered
= addr
;
5467 addr
+= map
.name_count
* map
.offset_size
;
5469 const gdb_byte
*abbrev_table_start
= addr
;
5472 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5477 const auto insertpair
5478 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
5479 if (!insertpair
.second
)
5481 warning (_("Section .debug_names in %s has duplicate index %s, "
5482 "ignoring .debug_names."),
5483 filename
, pulongest (index_num
));
5486 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
5487 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5492 mapped_debug_names::index_val::attr attr
;
5493 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5495 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5497 if (attr
.form
== DW_FORM_implicit_const
)
5499 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
5503 if (attr
.dw_idx
== 0 && attr
.form
== 0)
5505 indexval
.attr_vec
.push_back (std::move (attr
));
5508 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
5510 warning (_("Section .debug_names in %s has abbreviation_table "
5511 "of size %s vs. written as %u, ignoring .debug_names."),
5512 filename
, plongest (addr
- abbrev_table_start
),
5516 map
.entry_pool
= addr
;
5521 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5525 create_cus_from_debug_names_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5526 const mapped_debug_names
&map
,
5527 dwarf2_section_info
§ion
,
5530 sect_offset sect_off_prev
;
5531 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
5533 sect_offset sect_off_next
;
5534 if (i
< map
.cu_count
)
5537 = (sect_offset
) (extract_unsigned_integer
5538 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5540 map
.dwarf5_byte_order
));
5543 sect_off_next
= (sect_offset
) section
.size
;
5546 const ULONGEST length
= sect_off_next
- sect_off_prev
;
5547 dwarf2_per_cu_data
*per_cu
5548 = create_cu_from_index_list (dwarf2_per_objfile
, §ion
, is_dwz
,
5549 sect_off_prev
, length
);
5550 dwarf2_per_objfile
->all_comp_units
.push_back (per_cu
);
5552 sect_off_prev
= sect_off_next
;
5556 /* Read the CU list from the mapped index, and use it to create all
5557 the CU objects for this dwarf2_per_objfile. */
5560 create_cus_from_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5561 const mapped_debug_names
&map
,
5562 const mapped_debug_names
&dwz_map
)
5564 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
5565 dwarf2_per_objfile
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
5567 create_cus_from_debug_names_list (dwarf2_per_objfile
, map
,
5568 dwarf2_per_objfile
->info
,
5569 false /* is_dwz */);
5571 if (dwz_map
.cu_count
== 0)
5574 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5575 create_cus_from_debug_names_list (dwarf2_per_objfile
, dwz_map
, dwz
->info
,
5579 /* Read .debug_names. If everything went ok, initialize the "quick"
5580 elements of all the CUs and return true. Otherwise, return false. */
5583 dwarf2_read_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
5585 std::unique_ptr
<mapped_debug_names
> map
5586 (new mapped_debug_names (dwarf2_per_objfile
));
5587 mapped_debug_names
dwz_map (dwarf2_per_objfile
);
5588 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5590 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
5591 &dwarf2_per_objfile
->debug_names
,
5595 /* Don't use the index if it's empty. */
5596 if (map
->name_count
== 0)
5599 /* If there is a .dwz file, read it so we can get its CU list as
5601 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5604 if (!read_debug_names_from_section (objfile
,
5605 bfd_get_filename (dwz
->dwz_bfd
.get ()),
5606 &dwz
->debug_names
, dwz_map
))
5608 warning (_("could not read '.debug_names' section from %s; skipping"),
5609 bfd_get_filename (dwz
->dwz_bfd
.get ()));
5614 create_cus_from_debug_names (dwarf2_per_objfile
, *map
, dwz_map
);
5616 if (map
->tu_count
!= 0)
5618 /* We can only handle a single .debug_types when we have an
5620 if (dwarf2_per_objfile
->types
.size () != 1)
5623 dwarf2_section_info
*section
= &dwarf2_per_objfile
->types
[0];
5625 create_signatured_type_table_from_debug_names
5626 (dwarf2_per_objfile
, *map
, section
, &dwarf2_per_objfile
->abbrev
);
5629 create_addrmap_from_aranges (dwarf2_per_objfile
,
5630 &dwarf2_per_objfile
->debug_aranges
);
5632 dwarf2_per_objfile
->debug_names_table
= std::move (map
);
5633 dwarf2_per_objfile
->using_index
= 1;
5634 dwarf2_per_objfile
->quick_file_names_table
=
5635 create_quick_file_names_table (dwarf2_per_objfile
->all_comp_units
.size ());
5640 /* Type used to manage iterating over all CUs looking for a symbol for
5643 class dw2_debug_names_iterator
5646 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5647 gdb::optional
<block_enum
> block_index
,
5650 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5651 m_addr (find_vec_in_debug_names (map
, name
))
5654 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5655 search_domain search
, uint32_t namei
)
5658 m_addr (find_vec_in_debug_names (map
, namei
))
5661 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5662 block_enum block_index
, domain_enum domain
,
5664 : m_map (map
), m_block_index (block_index
), m_domain (domain
),
5665 m_addr (find_vec_in_debug_names (map
, namei
))
5668 /* Return the next matching CU or NULL if there are no more. */
5669 dwarf2_per_cu_data
*next ();
5672 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5674 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5677 /* The internalized form of .debug_names. */
5678 const mapped_debug_names
&m_map
;
5680 /* If set, only look for symbols that match that block. Valid values are
5681 GLOBAL_BLOCK and STATIC_BLOCK. */
5682 const gdb::optional
<block_enum
> m_block_index
;
5684 /* The kind of symbol we're looking for. */
5685 const domain_enum m_domain
= UNDEF_DOMAIN
;
5686 const search_domain m_search
= ALL_DOMAIN
;
5688 /* The list of CUs from the index entry of the symbol, or NULL if
5690 const gdb_byte
*m_addr
;
5694 mapped_debug_names::namei_to_name (uint32_t namei
) const
5696 const ULONGEST namei_string_offs
5697 = extract_unsigned_integer ((name_table_string_offs_reordered
5698 + namei
* offset_size
),
5701 return read_indirect_string_at_offset
5702 (dwarf2_per_objfile
, dwarf2_per_objfile
->objfile
->obfd
, namei_string_offs
);
5705 /* Find a slot in .debug_names for the object named NAME. If NAME is
5706 found, return pointer to its pool data. If NAME cannot be found,
5710 dw2_debug_names_iterator::find_vec_in_debug_names
5711 (const mapped_debug_names
&map
, const char *name
)
5713 int (*cmp
) (const char *, const char *);
5715 gdb::unique_xmalloc_ptr
<char> without_params
;
5716 if (current_language
->la_language
== language_cplus
5717 || current_language
->la_language
== language_fortran
5718 || current_language
->la_language
== language_d
)
5720 /* NAME is already canonical. Drop any qualifiers as
5721 .debug_names does not contain any. */
5723 if (strchr (name
, '(') != NULL
)
5725 without_params
= cp_remove_params (name
);
5726 if (without_params
!= NULL
)
5727 name
= without_params
.get ();
5731 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
5733 const uint32_t full_hash
= dwarf5_djb_hash (name
);
5735 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5736 (map
.bucket_table_reordered
5737 + (full_hash
% map
.bucket_count
)), 4,
5738 map
.dwarf5_byte_order
);
5742 if (namei
>= map
.name_count
)
5744 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5746 namei
, map
.name_count
,
5747 objfile_name (map
.dwarf2_per_objfile
->objfile
));
5753 const uint32_t namei_full_hash
5754 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5755 (map
.hash_table_reordered
+ namei
), 4,
5756 map
.dwarf5_byte_order
);
5757 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
5760 if (full_hash
== namei_full_hash
)
5762 const char *const namei_string
= map
.namei_to_name (namei
);
5764 #if 0 /* An expensive sanity check. */
5765 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
5767 complaint (_("Wrong .debug_names hash for string at index %u "
5769 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
5774 if (cmp (namei_string
, name
) == 0)
5776 const ULONGEST namei_entry_offs
5777 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5778 + namei
* map
.offset_size
),
5779 map
.offset_size
, map
.dwarf5_byte_order
);
5780 return map
.entry_pool
+ namei_entry_offs
;
5785 if (namei
>= map
.name_count
)
5791 dw2_debug_names_iterator::find_vec_in_debug_names
5792 (const mapped_debug_names
&map
, uint32_t namei
)
5794 if (namei
>= map
.name_count
)
5796 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5798 namei
, map
.name_count
,
5799 objfile_name (map
.dwarf2_per_objfile
->objfile
));
5803 const ULONGEST namei_entry_offs
5804 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5805 + namei
* map
.offset_size
),
5806 map
.offset_size
, map
.dwarf5_byte_order
);
5807 return map
.entry_pool
+ namei_entry_offs
;
5810 /* See dw2_debug_names_iterator. */
5812 dwarf2_per_cu_data
*
5813 dw2_debug_names_iterator::next ()
5818 struct dwarf2_per_objfile
*dwarf2_per_objfile
= m_map
.dwarf2_per_objfile
;
5819 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5820 bfd
*const abfd
= objfile
->obfd
;
5824 unsigned int bytes_read
;
5825 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5826 m_addr
+= bytes_read
;
5830 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5831 if (indexval_it
== m_map
.abbrev_map
.cend ())
5833 complaint (_("Wrong .debug_names undefined abbrev code %s "
5835 pulongest (abbrev
), objfile_name (objfile
));
5838 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5839 enum class symbol_linkage
{
5843 } symbol_linkage_
= symbol_linkage::unknown
;
5844 dwarf2_per_cu_data
*per_cu
= NULL
;
5845 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5850 case DW_FORM_implicit_const
:
5851 ull
= attr
.implicit_const
;
5853 case DW_FORM_flag_present
:
5857 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5858 m_addr
+= bytes_read
;
5861 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5862 dwarf_form_name (attr
.form
),
5863 objfile_name (objfile
));
5866 switch (attr
.dw_idx
)
5868 case DW_IDX_compile_unit
:
5869 /* Don't crash on bad data. */
5870 if (ull
>= dwarf2_per_objfile
->all_comp_units
.size ())
5872 complaint (_(".debug_names entry has bad CU index %s"
5875 objfile_name (dwarf2_per_objfile
->objfile
));
5878 per_cu
= dwarf2_per_objfile
->get_cutu (ull
);
5880 case DW_IDX_type_unit
:
5881 /* Don't crash on bad data. */
5882 if (ull
>= dwarf2_per_objfile
->all_type_units
.size ())
5884 complaint (_(".debug_names entry has bad TU index %s"
5887 objfile_name (dwarf2_per_objfile
->objfile
));
5890 per_cu
= &dwarf2_per_objfile
->get_tu (ull
)->per_cu
;
5892 case DW_IDX_GNU_internal
:
5893 if (!m_map
.augmentation_is_gdb
)
5895 symbol_linkage_
= symbol_linkage::static_
;
5897 case DW_IDX_GNU_external
:
5898 if (!m_map
.augmentation_is_gdb
)
5900 symbol_linkage_
= symbol_linkage::extern_
;
5905 /* Skip if already read in. */
5906 if (per_cu
->v
.quick
->compunit_symtab
)
5909 /* Check static vs global. */
5910 if (symbol_linkage_
!= symbol_linkage::unknown
&& m_block_index
.has_value ())
5912 const bool want_static
= *m_block_index
== STATIC_BLOCK
;
5913 const bool symbol_is_static
=
5914 symbol_linkage_
== symbol_linkage::static_
;
5915 if (want_static
!= symbol_is_static
)
5919 /* Match dw2_symtab_iter_next, symbol_kind
5920 and debug_names::psymbol_tag. */
5924 switch (indexval
.dwarf_tag
)
5926 case DW_TAG_variable
:
5927 case DW_TAG_subprogram
:
5928 /* Some types are also in VAR_DOMAIN. */
5929 case DW_TAG_typedef
:
5930 case DW_TAG_structure_type
:
5937 switch (indexval
.dwarf_tag
)
5939 case DW_TAG_typedef
:
5940 case DW_TAG_structure_type
:
5947 switch (indexval
.dwarf_tag
)
5950 case DW_TAG_variable
:
5960 /* Match dw2_expand_symtabs_matching, symbol_kind and
5961 debug_names::psymbol_tag. */
5964 case VARIABLES_DOMAIN
:
5965 switch (indexval
.dwarf_tag
)
5967 case DW_TAG_variable
:
5973 case FUNCTIONS_DOMAIN
:
5974 switch (indexval
.dwarf_tag
)
5976 case DW_TAG_subprogram
:
5983 switch (indexval
.dwarf_tag
)
5985 case DW_TAG_typedef
:
5986 case DW_TAG_structure_type
:
5999 static struct compunit_symtab
*
6000 dw2_debug_names_lookup_symbol (struct objfile
*objfile
, block_enum block_index
,
6001 const char *name
, domain_enum domain
)
6003 struct dwarf2_per_objfile
*dwarf2_per_objfile
6004 = get_dwarf2_per_objfile (objfile
);
6006 const auto &mapp
= dwarf2_per_objfile
->debug_names_table
;
6009 /* index is NULL if OBJF_READNOW. */
6012 const auto &map
= *mapp
;
6014 dw2_debug_names_iterator
iter (map
, block_index
, domain
, name
);
6016 struct compunit_symtab
*stab_best
= NULL
;
6017 struct dwarf2_per_cu_data
*per_cu
;
6018 while ((per_cu
= iter
.next ()) != NULL
)
6020 struct symbol
*sym
, *with_opaque
= NULL
;
6021 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
, false);
6022 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
6023 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
6025 sym
= block_find_symbol (block
, name
, domain
,
6026 block_find_non_opaque_type_preferred
,
6029 /* Some caution must be observed with overloaded functions and
6030 methods, since the index will not contain any overload
6031 information (but NAME might contain it). */
6034 && strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
6036 if (with_opaque
!= NULL
6037 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque
), name
) == 0)
6040 /* Keep looking through other CUs. */
6046 /* This dumps minimal information about .debug_names. It is called
6047 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
6048 uses this to verify that .debug_names has been loaded. */
6051 dw2_debug_names_dump (struct objfile
*objfile
)
6053 struct dwarf2_per_objfile
*dwarf2_per_objfile
6054 = get_dwarf2_per_objfile (objfile
);
6056 gdb_assert (dwarf2_per_objfile
->using_index
);
6057 printf_filtered (".debug_names:");
6058 if (dwarf2_per_objfile
->debug_names_table
)
6059 printf_filtered (" exists\n");
6061 printf_filtered (" faked for \"readnow\"\n");
6062 printf_filtered ("\n");
6066 dw2_debug_names_expand_symtabs_for_function (struct objfile
*objfile
,
6067 const char *func_name
)
6069 struct dwarf2_per_objfile
*dwarf2_per_objfile
6070 = get_dwarf2_per_objfile (objfile
);
6072 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
6073 if (dwarf2_per_objfile
->debug_names_table
)
6075 const mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6077 dw2_debug_names_iterator
iter (map
, {}, VAR_DOMAIN
, func_name
);
6079 struct dwarf2_per_cu_data
*per_cu
;
6080 while ((per_cu
= iter
.next ()) != NULL
)
6081 dw2_instantiate_symtab (per_cu
, false);
6086 dw2_debug_names_map_matching_symbols
6087 (struct objfile
*objfile
,
6088 const lookup_name_info
&name
, domain_enum domain
,
6090 gdb::function_view
<symbol_found_callback_ftype
> callback
,
6091 symbol_compare_ftype
*ordered_compare
)
6093 struct dwarf2_per_objfile
*dwarf2_per_objfile
6094 = get_dwarf2_per_objfile (objfile
);
6096 /* debug_names_table is NULL if OBJF_READNOW. */
6097 if (!dwarf2_per_objfile
->debug_names_table
)
6100 mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6101 const block_enum block_kind
= global
? GLOBAL_BLOCK
: STATIC_BLOCK
;
6103 const char *match_name
= name
.ada ().lookup_name ().c_str ();
6104 auto matcher
= [&] (const char *symname
)
6106 if (ordered_compare
== nullptr)
6108 return ordered_compare (symname
, match_name
) == 0;
6111 dw2_expand_symtabs_matching_symbol (map
, name
, matcher
, ALL_DOMAIN
,
6112 [&] (offset_type namei
)
6114 /* The name was matched, now expand corresponding CUs that were
6116 dw2_debug_names_iterator
iter (map
, block_kind
, domain
, namei
);
6118 struct dwarf2_per_cu_data
*per_cu
;
6119 while ((per_cu
= iter
.next ()) != NULL
)
6120 dw2_expand_symtabs_matching_one (per_cu
, nullptr, nullptr);
6124 /* It's a shame we couldn't do this inside the
6125 dw2_expand_symtabs_matching_symbol callback, but that skips CUs
6126 that have already been expanded. Instead, this loop matches what
6127 the psymtab code does. */
6128 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
6130 struct compunit_symtab
*cust
= per_cu
->v
.quick
->compunit_symtab
;
6131 if (cust
!= nullptr)
6133 const struct block
*block
6134 = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust
), block_kind
);
6135 if (!iterate_over_symbols_terminated (block
, name
,
6143 dw2_debug_names_expand_symtabs_matching
6144 (struct objfile
*objfile
,
6145 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
6146 const lookup_name_info
&lookup_name
,
6147 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
6148 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
6149 enum search_domain kind
)
6151 struct dwarf2_per_objfile
*dwarf2_per_objfile
6152 = get_dwarf2_per_objfile (objfile
);
6154 /* debug_names_table is NULL if OBJF_READNOW. */
6155 if (!dwarf2_per_objfile
->debug_names_table
)
6158 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
6160 mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6162 dw2_expand_symtabs_matching_symbol (map
, lookup_name
,
6164 kind
, [&] (offset_type namei
)
6166 /* The name was matched, now expand corresponding CUs that were
6168 dw2_debug_names_iterator
iter (map
, kind
, namei
);
6170 struct dwarf2_per_cu_data
*per_cu
;
6171 while ((per_cu
= iter
.next ()) != NULL
)
6172 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
6178 const struct quick_symbol_functions dwarf2_debug_names_functions
=
6181 dw2_find_last_source_symtab
,
6182 dw2_forget_cached_source_info
,
6183 dw2_map_symtabs_matching_filename
,
6184 dw2_debug_names_lookup_symbol
,
6186 dw2_debug_names_dump
,
6187 dw2_debug_names_expand_symtabs_for_function
,
6188 dw2_expand_all_symtabs
,
6189 dw2_expand_symtabs_with_fullname
,
6190 dw2_debug_names_map_matching_symbols
,
6191 dw2_debug_names_expand_symtabs_matching
,
6192 dw2_find_pc_sect_compunit_symtab
,
6194 dw2_map_symbol_filenames
6197 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
6198 to either a dwarf2_per_objfile or dwz_file object. */
6200 template <typename T
>
6201 static gdb::array_view
<const gdb_byte
>
6202 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
6204 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
6206 if (dwarf2_section_empty_p (section
))
6209 /* Older elfutils strip versions could keep the section in the main
6210 executable while splitting it for the separate debug info file. */
6211 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
6214 dwarf2_read_section (obj
, section
);
6216 /* dwarf2_section_info::size is a bfd_size_type, while
6217 gdb::array_view works with size_t. On 32-bit hosts, with
6218 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6219 is 32-bit. So we need an explicit narrowing conversion here.
6220 This is fine, because it's impossible to allocate or mmap an
6221 array/buffer larger than what size_t can represent. */
6222 return gdb::make_array_view (section
->buffer
, section
->size
);
6225 /* Lookup the index cache for the contents of the index associated to
6228 static gdb::array_view
<const gdb_byte
>
6229 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_objfile
*dwarf2_obj
)
6231 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
6232 if (build_id
== nullptr)
6235 return global_index_cache
.lookup_gdb_index (build_id
,
6236 &dwarf2_obj
->index_cache_res
);
6239 /* Same as the above, but for DWZ. */
6241 static gdb::array_view
<const gdb_byte
>
6242 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
6244 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
6245 if (build_id
== nullptr)
6248 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
6251 /* See symfile.h. */
6254 dwarf2_initialize_objfile (struct objfile
*objfile
, dw_index_kind
*index_kind
)
6256 struct dwarf2_per_objfile
*dwarf2_per_objfile
6257 = get_dwarf2_per_objfile (objfile
);
6259 /* If we're about to read full symbols, don't bother with the
6260 indices. In this case we also don't care if some other debug
6261 format is making psymtabs, because they are all about to be
6263 if ((objfile
->flags
& OBJF_READNOW
))
6265 dwarf2_per_objfile
->using_index
= 1;
6266 create_all_comp_units (dwarf2_per_objfile
);
6267 create_all_type_units (dwarf2_per_objfile
);
6268 dwarf2_per_objfile
->quick_file_names_table
6269 = create_quick_file_names_table
6270 (dwarf2_per_objfile
->all_comp_units
.size ());
6272 for (int i
= 0; i
< (dwarf2_per_objfile
->all_comp_units
.size ()
6273 + dwarf2_per_objfile
->all_type_units
.size ()); ++i
)
6275 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
6277 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6278 struct dwarf2_per_cu_quick_data
);
6281 /* Return 1 so that gdb sees the "quick" functions. However,
6282 these functions will be no-ops because we will have expanded
6284 *index_kind
= dw_index_kind::GDB_INDEX
;
6288 if (dwarf2_read_debug_names (dwarf2_per_objfile
))
6290 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6294 if (dwarf2_read_gdb_index (dwarf2_per_objfile
,
6295 get_gdb_index_contents_from_section
<struct dwarf2_per_objfile
>,
6296 get_gdb_index_contents_from_section
<dwz_file
>))
6298 *index_kind
= dw_index_kind::GDB_INDEX
;
6302 /* ... otherwise, try to find the index in the index cache. */
6303 if (dwarf2_read_gdb_index (dwarf2_per_objfile
,
6304 get_gdb_index_contents_from_cache
,
6305 get_gdb_index_contents_from_cache_dwz
))
6307 global_index_cache
.hit ();
6308 *index_kind
= dw_index_kind::GDB_INDEX
;
6312 global_index_cache
.miss ();
6318 /* Build a partial symbol table. */
6321 dwarf2_build_psymtabs (struct objfile
*objfile
)
6323 struct dwarf2_per_objfile
*dwarf2_per_objfile
6324 = get_dwarf2_per_objfile (objfile
);
6326 init_psymbol_list (objfile
, 1024);
6330 /* This isn't really ideal: all the data we allocate on the
6331 objfile's obstack is still uselessly kept around. However,
6332 freeing it seems unsafe. */
6333 psymtab_discarder
psymtabs (objfile
);
6334 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
);
6337 /* (maybe) store an index in the cache. */
6338 global_index_cache
.store (dwarf2_per_objfile
);
6340 catch (const gdb_exception_error
&except
)
6342 exception_print (gdb_stderr
, except
);
6346 /* Return the total length of the CU described by HEADER. */
6349 get_cu_length (const struct comp_unit_head
*header
)
6351 return header
->initial_length_size
+ header
->length
;
6354 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6357 offset_in_cu_p (const comp_unit_head
*cu_header
, sect_offset sect_off
)
6359 sect_offset bottom
= cu_header
->sect_off
;
6360 sect_offset top
= cu_header
->sect_off
+ get_cu_length (cu_header
);
6362 return sect_off
>= bottom
&& sect_off
< top
;
6365 /* Find the base address of the compilation unit for range lists and
6366 location lists. It will normally be specified by DW_AT_low_pc.
6367 In DWARF-3 draft 4, the base address could be overridden by
6368 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6369 compilation units with discontinuous ranges. */
6372 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
6374 struct attribute
*attr
;
6377 cu
->base_address
= 0;
6379 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
6382 cu
->base_address
= attr_value_as_address (attr
);
6387 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6390 cu
->base_address
= attr_value_as_address (attr
);
6396 /* Read in the comp unit header information from the debug_info at info_ptr.
6397 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6398 NOTE: This leaves members offset, first_die_offset to be filled in
6401 static const gdb_byte
*
6402 read_comp_unit_head (struct comp_unit_head
*cu_header
,
6403 const gdb_byte
*info_ptr
,
6404 struct dwarf2_section_info
*section
,
6405 rcuh_kind section_kind
)
6408 unsigned int bytes_read
;
6409 const char *filename
= get_section_file_name (section
);
6410 bfd
*abfd
= get_section_bfd_owner (section
);
6412 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
6413 cu_header
->initial_length_size
= bytes_read
;
6414 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
6415 info_ptr
+= bytes_read
;
6416 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
6417 if (cu_header
->version
< 2 || cu_header
->version
> 5)
6418 error (_("Dwarf Error: wrong version in compilation unit header "
6419 "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6420 cu_header
->version
, filename
);
6422 if (cu_header
->version
< 5)
6423 switch (section_kind
)
6425 case rcuh_kind::COMPILE
:
6426 cu_header
->unit_type
= DW_UT_compile
;
6428 case rcuh_kind::TYPE
:
6429 cu_header
->unit_type
= DW_UT_type
;
6432 internal_error (__FILE__
, __LINE__
,
6433 _("read_comp_unit_head: invalid section_kind"));
6437 cu_header
->unit_type
= static_cast<enum dwarf_unit_type
>
6438 (read_1_byte (abfd
, info_ptr
));
6440 switch (cu_header
->unit_type
)
6444 case DW_UT_skeleton
:
6445 case DW_UT_split_compile
:
6446 if (section_kind
!= rcuh_kind::COMPILE
)
6447 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6448 "(is %s, should be %s) [in module %s]"),
6449 dwarf_unit_type_name (cu_header
->unit_type
),
6450 dwarf_unit_type_name (DW_UT_type
), filename
);
6453 case DW_UT_split_type
:
6454 section_kind
= rcuh_kind::TYPE
;
6457 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6458 "(is %#04x, should be one of: %s, %s, %s, %s or %s) "
6459 "[in module %s]"), cu_header
->unit_type
,
6460 dwarf_unit_type_name (DW_UT_compile
),
6461 dwarf_unit_type_name (DW_UT_skeleton
),
6462 dwarf_unit_type_name (DW_UT_split_compile
),
6463 dwarf_unit_type_name (DW_UT_type
),
6464 dwarf_unit_type_name (DW_UT_split_type
), filename
);
6467 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
6470 cu_header
->abbrev_sect_off
= (sect_offset
) read_offset (abfd
, info_ptr
,
6473 info_ptr
+= bytes_read
;
6474 if (cu_header
->version
< 5)
6476 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
6479 signed_addr
= bfd_get_sign_extend_vma (abfd
);
6480 if (signed_addr
< 0)
6481 internal_error (__FILE__
, __LINE__
,
6482 _("read_comp_unit_head: dwarf from non elf file"));
6483 cu_header
->signed_addr_p
= signed_addr
;
6485 bool header_has_signature
= section_kind
== rcuh_kind::TYPE
6486 || cu_header
->unit_type
== DW_UT_skeleton
6487 || cu_header
->unit_type
== DW_UT_split_compile
;
6489 if (header_has_signature
)
6491 cu_header
->signature
= read_8_bytes (abfd
, info_ptr
);
6495 if (section_kind
== rcuh_kind::TYPE
)
6497 LONGEST type_offset
;
6498 type_offset
= read_offset (abfd
, info_ptr
, cu_header
, &bytes_read
);
6499 info_ptr
+= bytes_read
;
6500 cu_header
->type_cu_offset_in_tu
= (cu_offset
) type_offset
;
6501 if (to_underlying (cu_header
->type_cu_offset_in_tu
) != type_offset
)
6502 error (_("Dwarf Error: Too big type_offset in compilation unit "
6503 "header (is %s) [in module %s]"), plongest (type_offset
),
6510 /* Helper function that returns the proper abbrev section for
6513 static struct dwarf2_section_info
*
6514 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
6516 struct dwarf2_section_info
*abbrev
;
6517 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
6519 if (this_cu
->is_dwz
)
6520 abbrev
= &dwarf2_get_dwz_file (dwarf2_per_objfile
)->abbrev
;
6522 abbrev
= &dwarf2_per_objfile
->abbrev
;
6527 /* Subroutine of read_and_check_comp_unit_head and
6528 read_and_check_type_unit_head to simplify them.
6529 Perform various error checking on the header. */
6532 error_check_comp_unit_head (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6533 struct comp_unit_head
*header
,
6534 struct dwarf2_section_info
*section
,
6535 struct dwarf2_section_info
*abbrev_section
)
6537 const char *filename
= get_section_file_name (section
);
6539 if (to_underlying (header
->abbrev_sect_off
)
6540 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
6541 error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6542 "(offset %s + 6) [in module %s]"),
6543 sect_offset_str (header
->abbrev_sect_off
),
6544 sect_offset_str (header
->sect_off
),
6547 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6548 avoid potential 32-bit overflow. */
6549 if (((ULONGEST
) header
->sect_off
+ get_cu_length (header
))
6551 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6552 "(offset %s + 0) [in module %s]"),
6553 header
->length
, sect_offset_str (header
->sect_off
),
6557 /* Read in a CU/TU header and perform some basic error checking.
6558 The contents of the header are stored in HEADER.
6559 The result is a pointer to the start of the first DIE. */
6561 static const gdb_byte
*
6562 read_and_check_comp_unit_head (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6563 struct comp_unit_head
*header
,
6564 struct dwarf2_section_info
*section
,
6565 struct dwarf2_section_info
*abbrev_section
,
6566 const gdb_byte
*info_ptr
,
6567 rcuh_kind section_kind
)
6569 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
6571 header
->sect_off
= (sect_offset
) (beg_of_comp_unit
- section
->buffer
);
6573 info_ptr
= read_comp_unit_head (header
, info_ptr
, section
, section_kind
);
6575 header
->first_die_cu_offset
= (cu_offset
) (info_ptr
- beg_of_comp_unit
);
6577 error_check_comp_unit_head (dwarf2_per_objfile
, header
, section
,
6583 /* Fetch the abbreviation table offset from a comp or type unit header. */
6586 read_abbrev_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6587 struct dwarf2_section_info
*section
,
6588 sect_offset sect_off
)
6590 bfd
*abfd
= get_section_bfd_owner (section
);
6591 const gdb_byte
*info_ptr
;
6592 unsigned int initial_length_size
, offset_size
;
6595 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
6596 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
6597 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6598 offset_size
= initial_length_size
== 4 ? 4 : 8;
6599 info_ptr
+= initial_length_size
;
6601 version
= read_2_bytes (abfd
, info_ptr
);
6605 /* Skip unit type and address size. */
6609 return (sect_offset
) read_offset_1 (abfd
, info_ptr
, offset_size
);
6612 /* Allocate a new partial symtab for file named NAME and mark this new
6613 partial symtab as being an include of PST. */
6616 dwarf2_create_include_psymtab (const char *name
, struct partial_symtab
*pst
,
6617 struct objfile
*objfile
)
6619 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
6621 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
6623 /* It shares objfile->objfile_obstack. */
6624 subpst
->dirname
= pst
->dirname
;
6627 subpst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (1);
6628 subpst
->dependencies
[0] = pst
;
6629 subpst
->number_of_dependencies
= 1;
6631 subpst
->read_symtab
= pst
->read_symtab
;
6633 /* No private part is necessary for include psymtabs. This property
6634 can be used to differentiate between such include psymtabs and
6635 the regular ones. */
6636 subpst
->read_symtab_private
= NULL
;
6639 /* Read the Line Number Program data and extract the list of files
6640 included by the source file represented by PST. Build an include
6641 partial symtab for each of these included files. */
6644 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
6645 struct die_info
*die
,
6646 struct partial_symtab
*pst
)
6649 struct attribute
*attr
;
6651 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6653 lh
= dwarf_decode_line_header ((sect_offset
) DW_UNSND (attr
), cu
);
6655 return; /* No linetable, so no includes. */
6657 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6658 that we pass in the raw text_low here; that is ok because we're
6659 only decoding the line table to make include partial symtabs, and
6660 so the addresses aren't really used. */
6661 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
6662 pst
->raw_text_low (), 1);
6666 hash_signatured_type (const void *item
)
6668 const struct signatured_type
*sig_type
6669 = (const struct signatured_type
*) item
;
6671 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6672 return sig_type
->signature
;
6676 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6678 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6679 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6681 return lhs
->signature
== rhs
->signature
;
6684 /* Allocate a hash table for signatured types. */
6687 allocate_signatured_type_table (struct objfile
*objfile
)
6689 return htab_create_alloc_ex (41,
6690 hash_signatured_type
,
6693 &objfile
->objfile_obstack
,
6694 hashtab_obstack_allocate
,
6695 dummy_obstack_deallocate
);
6698 /* A helper function to add a signatured type CU to a table. */
6701 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6703 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6704 std::vector
<signatured_type
*> *all_type_units
6705 = (std::vector
<signatured_type
*> *) datum
;
6707 all_type_units
->push_back (sigt
);
6712 /* A helper for create_debug_types_hash_table. Read types from SECTION
6713 and fill them into TYPES_HTAB. It will process only type units,
6714 therefore DW_UT_type. */
6717 create_debug_type_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6718 struct dwo_file
*dwo_file
,
6719 dwarf2_section_info
*section
, htab_t
&types_htab
,
6720 rcuh_kind section_kind
)
6722 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6723 struct dwarf2_section_info
*abbrev_section
;
6725 const gdb_byte
*info_ptr
, *end_ptr
;
6727 abbrev_section
= (dwo_file
!= NULL
6728 ? &dwo_file
->sections
.abbrev
6729 : &dwarf2_per_objfile
->abbrev
);
6731 if (dwarf_read_debug
)
6732 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
6733 get_section_name (section
),
6734 get_section_file_name (abbrev_section
));
6736 dwarf2_read_section (objfile
, section
);
6737 info_ptr
= section
->buffer
;
6739 if (info_ptr
== NULL
)
6742 /* We can't set abfd until now because the section may be empty or
6743 not present, in which case the bfd is unknown. */
6744 abfd
= get_section_bfd_owner (section
);
6746 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6747 because we don't need to read any dies: the signature is in the
6750 end_ptr
= info_ptr
+ section
->size
;
6751 while (info_ptr
< end_ptr
)
6753 struct signatured_type
*sig_type
;
6754 struct dwo_unit
*dwo_tu
;
6756 const gdb_byte
*ptr
= info_ptr
;
6757 struct comp_unit_head header
;
6758 unsigned int length
;
6760 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
6762 /* Initialize it due to a false compiler warning. */
6763 header
.signature
= -1;
6764 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
6766 /* We need to read the type's signature in order to build the hash
6767 table, but we don't need anything else just yet. */
6769 ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
, &header
, section
,
6770 abbrev_section
, ptr
, section_kind
);
6772 length
= get_cu_length (&header
);
6774 /* Skip dummy type units. */
6775 if (ptr
>= info_ptr
+ length
6776 || peek_abbrev_code (abfd
, ptr
) == 0
6777 || header
.unit_type
!= DW_UT_type
)
6783 if (types_htab
== NULL
)
6786 types_htab
= allocate_dwo_unit_table (objfile
);
6788 types_htab
= allocate_signatured_type_table (objfile
);
6794 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6796 dwo_tu
->dwo_file
= dwo_file
;
6797 dwo_tu
->signature
= header
.signature
;
6798 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6799 dwo_tu
->section
= section
;
6800 dwo_tu
->sect_off
= sect_off
;
6801 dwo_tu
->length
= length
;
6805 /* N.B.: type_offset is not usable if this type uses a DWO file.
6806 The real type_offset is in the DWO file. */
6808 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6809 struct signatured_type
);
6810 sig_type
->signature
= header
.signature
;
6811 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6812 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
6813 sig_type
->per_cu
.is_debug_types
= 1;
6814 sig_type
->per_cu
.section
= section
;
6815 sig_type
->per_cu
.sect_off
= sect_off
;
6816 sig_type
->per_cu
.length
= length
;
6819 slot
= htab_find_slot (types_htab
,
6820 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
6822 gdb_assert (slot
!= NULL
);
6825 sect_offset dup_sect_off
;
6829 const struct dwo_unit
*dup_tu
6830 = (const struct dwo_unit
*) *slot
;
6832 dup_sect_off
= dup_tu
->sect_off
;
6836 const struct signatured_type
*dup_tu
6837 = (const struct signatured_type
*) *slot
;
6839 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
6842 complaint (_("debug type entry at offset %s is duplicate to"
6843 " the entry at offset %s, signature %s"),
6844 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
6845 hex_string (header
.signature
));
6847 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
6849 if (dwarf_read_debug
> 1)
6850 fprintf_unfiltered (gdb_stdlog
, " offset %s, signature %s\n",
6851 sect_offset_str (sect_off
),
6852 hex_string (header
.signature
));
6858 /* Create the hash table of all entries in the .debug_types
6859 (or .debug_types.dwo) section(s).
6860 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6861 otherwise it is NULL.
6863 The result is a pointer to the hash table or NULL if there are no types.
6865 Note: This function processes DWO files only, not DWP files. */
6868 create_debug_types_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6869 struct dwo_file
*dwo_file
,
6870 gdb::array_view
<dwarf2_section_info
> type_sections
,
6873 for (dwarf2_section_info
§ion
: type_sections
)
6874 create_debug_type_hash_table (dwarf2_per_objfile
, dwo_file
, §ion
,
6875 types_htab
, rcuh_kind::TYPE
);
6878 /* Create the hash table of all entries in the .debug_types section,
6879 and initialize all_type_units.
6880 The result is zero if there is an error (e.g. missing .debug_types section),
6881 otherwise non-zero. */
6884 create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
6886 htab_t types_htab
= NULL
;
6888 create_debug_type_hash_table (dwarf2_per_objfile
, NULL
,
6889 &dwarf2_per_objfile
->info
, types_htab
,
6890 rcuh_kind::COMPILE
);
6891 create_debug_types_hash_table (dwarf2_per_objfile
, NULL
,
6892 dwarf2_per_objfile
->types
, types_htab
);
6893 if (types_htab
== NULL
)
6895 dwarf2_per_objfile
->signatured_types
= NULL
;
6899 dwarf2_per_objfile
->signatured_types
= types_htab
;
6901 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
6902 dwarf2_per_objfile
->all_type_units
.reserve (htab_elements (types_htab
));
6904 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
,
6905 &dwarf2_per_objfile
->all_type_units
);
6910 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6911 If SLOT is non-NULL, it is the entry to use in the hash table.
6912 Otherwise we find one. */
6914 static struct signatured_type
*
6915 add_type_unit (struct dwarf2_per_objfile
*dwarf2_per_objfile
, ULONGEST sig
,
6918 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6920 if (dwarf2_per_objfile
->all_type_units
.size ()
6921 == dwarf2_per_objfile
->all_type_units
.capacity ())
6922 ++dwarf2_per_objfile
->tu_stats
.nr_all_type_units_reallocs
;
6924 signatured_type
*sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6925 struct signatured_type
);
6927 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
6928 sig_type
->signature
= sig
;
6929 sig_type
->per_cu
.is_debug_types
= 1;
6930 if (dwarf2_per_objfile
->using_index
)
6932 sig_type
->per_cu
.v
.quick
=
6933 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6934 struct dwarf2_per_cu_quick_data
);
6939 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
6942 gdb_assert (*slot
== NULL
);
6944 /* The rest of sig_type must be filled in by the caller. */
6948 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6949 Fill in SIG_ENTRY with DWO_ENTRY. */
6952 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6953 struct signatured_type
*sig_entry
,
6954 struct dwo_unit
*dwo_entry
)
6956 /* Make sure we're not clobbering something we don't expect to. */
6957 gdb_assert (! sig_entry
->per_cu
.queued
);
6958 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
6959 if (dwarf2_per_objfile
->using_index
)
6961 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
6962 gdb_assert (sig_entry
->per_cu
.v
.quick
->compunit_symtab
== NULL
);
6965 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
6966 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
6967 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
6968 gdb_assert (sig_entry
->type_unit_group
== NULL
);
6969 gdb_assert (sig_entry
->dwo_unit
== NULL
);
6971 sig_entry
->per_cu
.section
= dwo_entry
->section
;
6972 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
6973 sig_entry
->per_cu
.length
= dwo_entry
->length
;
6974 sig_entry
->per_cu
.reading_dwo_directly
= 1;
6975 sig_entry
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
6976 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
6977 sig_entry
->dwo_unit
= dwo_entry
;
6980 /* Subroutine of lookup_signatured_type.
6981 If we haven't read the TU yet, create the signatured_type data structure
6982 for a TU to be read in directly from a DWO file, bypassing the stub.
6983 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6984 using .gdb_index, then when reading a CU we want to stay in the DWO file
6985 containing that CU. Otherwise we could end up reading several other DWO
6986 files (due to comdat folding) to process the transitive closure of all the
6987 mentioned TUs, and that can be slow. The current DWO file will have every
6988 type signature that it needs.
6989 We only do this for .gdb_index because in the psymtab case we already have
6990 to read all the DWOs to build the type unit groups. */
6992 static struct signatured_type
*
6993 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6995 struct dwarf2_per_objfile
*dwarf2_per_objfile
6996 = cu
->per_cu
->dwarf2_per_objfile
;
6997 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6998 struct dwo_file
*dwo_file
;
6999 struct dwo_unit find_dwo_entry
, *dwo_entry
;
7000 struct signatured_type find_sig_entry
, *sig_entry
;
7003 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
7005 /* If TU skeletons have been removed then we may not have read in any
7007 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7009 dwarf2_per_objfile
->signatured_types
7010 = allocate_signatured_type_table (objfile
);
7013 /* We only ever need to read in one copy of a signatured type.
7014 Use the global signatured_types array to do our own comdat-folding
7015 of types. If this is the first time we're reading this TU, and
7016 the TU has an entry in .gdb_index, replace the recorded data from
7017 .gdb_index with this TU. */
7019 find_sig_entry
.signature
= sig
;
7020 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
7021 &find_sig_entry
, INSERT
);
7022 sig_entry
= (struct signatured_type
*) *slot
;
7024 /* We can get here with the TU already read, *or* in the process of being
7025 read. Don't reassign the global entry to point to this DWO if that's
7026 the case. Also note that if the TU is already being read, it may not
7027 have come from a DWO, the program may be a mix of Fission-compiled
7028 code and non-Fission-compiled code. */
7030 /* Have we already tried to read this TU?
7031 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7032 needn't exist in the global table yet). */
7033 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
7036 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
7037 dwo_unit of the TU itself. */
7038 dwo_file
= cu
->dwo_unit
->dwo_file
;
7040 /* Ok, this is the first time we're reading this TU. */
7041 if (dwo_file
->tus
== NULL
)
7043 find_dwo_entry
.signature
= sig
;
7044 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_entry
);
7045 if (dwo_entry
== NULL
)
7048 /* If the global table doesn't have an entry for this TU, add one. */
7049 if (sig_entry
== NULL
)
7050 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
7052 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
7053 sig_entry
->per_cu
.tu_read
= 1;
7057 /* Subroutine of lookup_signatured_type.
7058 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7059 then try the DWP file. If the TU stub (skeleton) has been removed then
7060 it won't be in .gdb_index. */
7062 static struct signatured_type
*
7063 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7065 struct dwarf2_per_objfile
*dwarf2_per_objfile
7066 = cu
->per_cu
->dwarf2_per_objfile
;
7067 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7068 struct dwp_file
*dwp_file
= get_dwp_file (dwarf2_per_objfile
);
7069 struct dwo_unit
*dwo_entry
;
7070 struct signatured_type find_sig_entry
, *sig_entry
;
7073 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
7074 gdb_assert (dwp_file
!= NULL
);
7076 /* If TU skeletons have been removed then we may not have read in any
7078 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7080 dwarf2_per_objfile
->signatured_types
7081 = allocate_signatured_type_table (objfile
);
7084 find_sig_entry
.signature
= sig
;
7085 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
7086 &find_sig_entry
, INSERT
);
7087 sig_entry
= (struct signatured_type
*) *slot
;
7089 /* Have we already tried to read this TU?
7090 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7091 needn't exist in the global table yet). */
7092 if (sig_entry
!= NULL
)
7095 if (dwp_file
->tus
== NULL
)
7097 dwo_entry
= lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, NULL
,
7098 sig
, 1 /* is_debug_types */);
7099 if (dwo_entry
== NULL
)
7102 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
7103 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
7108 /* Lookup a signature based type for DW_FORM_ref_sig8.
7109 Returns NULL if signature SIG is not present in the table.
7110 It is up to the caller to complain about this. */
7112 static struct signatured_type
*
7113 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7115 struct dwarf2_per_objfile
*dwarf2_per_objfile
7116 = cu
->per_cu
->dwarf2_per_objfile
;
7119 && dwarf2_per_objfile
->using_index
)
7121 /* We're in a DWO/DWP file, and we're using .gdb_index.
7122 These cases require special processing. */
7123 if (get_dwp_file (dwarf2_per_objfile
) == NULL
)
7124 return lookup_dwo_signatured_type (cu
, sig
);
7126 return lookup_dwp_signatured_type (cu
, sig
);
7130 struct signatured_type find_entry
, *entry
;
7132 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7134 find_entry
.signature
= sig
;
7135 entry
= ((struct signatured_type
*)
7136 htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
));
7141 /* Low level DIE reading support. */
7143 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7146 init_cu_die_reader (struct die_reader_specs
*reader
,
7147 struct dwarf2_cu
*cu
,
7148 struct dwarf2_section_info
*section
,
7149 struct dwo_file
*dwo_file
,
7150 struct abbrev_table
*abbrev_table
)
7152 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
7153 reader
->abfd
= get_section_bfd_owner (section
);
7155 reader
->dwo_file
= dwo_file
;
7156 reader
->die_section
= section
;
7157 reader
->buffer
= section
->buffer
;
7158 reader
->buffer_end
= section
->buffer
+ section
->size
;
7159 reader
->comp_dir
= NULL
;
7160 reader
->abbrev_table
= abbrev_table
;
7163 /* Subroutine of init_cutu_and_read_dies to simplify it.
7164 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7165 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7168 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7169 from it to the DIE in the DWO. If NULL we are skipping the stub.
7170 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7171 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7172 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7173 STUB_COMP_DIR may be non-NULL.
7174 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7175 are filled in with the info of the DIE from the DWO file.
7176 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7177 from the dwo. Since *RESULT_READER references this abbrev table, it must be
7178 kept around for at least as long as *RESULT_READER.
7180 The result is non-zero if a valid (non-dummy) DIE was found. */
7183 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
7184 struct dwo_unit
*dwo_unit
,
7185 struct die_info
*stub_comp_unit_die
,
7186 const char *stub_comp_dir
,
7187 struct die_reader_specs
*result_reader
,
7188 const gdb_byte
**result_info_ptr
,
7189 struct die_info
**result_comp_unit_die
,
7190 int *result_has_children
,
7191 abbrev_table_up
*result_dwo_abbrev_table
)
7193 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7194 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7195 struct dwarf2_cu
*cu
= this_cu
->cu
;
7197 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7198 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
7199 int i
,num_extra_attrs
;
7200 struct dwarf2_section_info
*dwo_abbrev_section
;
7201 struct attribute
*attr
;
7202 struct die_info
*comp_unit_die
;
7204 /* At most one of these may be provided. */
7205 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
7207 /* These attributes aren't processed until later:
7208 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7209 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7210 referenced later. However, these attributes are found in the stub
7211 which we won't have later. In order to not impose this complication
7212 on the rest of the code, we read them here and copy them to the
7221 if (stub_comp_unit_die
!= NULL
)
7223 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7225 if (! this_cu
->is_debug_types
)
7226 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
7227 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
7228 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
7229 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
7230 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
7232 /* There should be a DW_AT_addr_base attribute here (if needed).
7233 We need the value before we can process DW_FORM_GNU_addr_index
7234 or DW_FORM_addrx. */
7236 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
7238 cu
->addr_base
= DW_UNSND (attr
);
7240 /* There should be a DW_AT_ranges_base attribute here (if needed).
7241 We need the value before we can process DW_AT_ranges. */
7242 cu
->ranges_base
= 0;
7243 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
7245 cu
->ranges_base
= DW_UNSND (attr
);
7247 else if (stub_comp_dir
!= NULL
)
7249 /* Reconstruct the comp_dir attribute to simplify the code below. */
7250 comp_dir
= XOBNEW (&cu
->comp_unit_obstack
, struct attribute
);
7251 comp_dir
->name
= DW_AT_comp_dir
;
7252 comp_dir
->form
= DW_FORM_string
;
7253 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
7254 DW_STRING (comp_dir
) = stub_comp_dir
;
7257 /* Set up for reading the DWO CU/TU. */
7258 cu
->dwo_unit
= dwo_unit
;
7259 dwarf2_section_info
*section
= dwo_unit
->section
;
7260 dwarf2_read_section (objfile
, section
);
7261 abfd
= get_section_bfd_owner (section
);
7262 begin_info_ptr
= info_ptr
= (section
->buffer
7263 + to_underlying (dwo_unit
->sect_off
));
7264 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
7266 if (this_cu
->is_debug_types
)
7268 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
7270 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7271 &cu
->header
, section
,
7273 info_ptr
, rcuh_kind::TYPE
);
7274 /* This is not an assert because it can be caused by bad debug info. */
7275 if (sig_type
->signature
!= cu
->header
.signature
)
7277 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7278 " TU at offset %s [in module %s]"),
7279 hex_string (sig_type
->signature
),
7280 hex_string (cu
->header
.signature
),
7281 sect_offset_str (dwo_unit
->sect_off
),
7282 bfd_get_filename (abfd
));
7284 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7285 /* For DWOs coming from DWP files, we don't know the CU length
7286 nor the type's offset in the TU until now. */
7287 dwo_unit
->length
= get_cu_length (&cu
->header
);
7288 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
7290 /* Establish the type offset that can be used to lookup the type.
7291 For DWO files, we don't know it until now. */
7292 sig_type
->type_offset_in_section
7293 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
7297 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7298 &cu
->header
, section
,
7300 info_ptr
, rcuh_kind::COMPILE
);
7301 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7302 /* For DWOs coming from DWP files, we don't know the CU length
7304 dwo_unit
->length
= get_cu_length (&cu
->header
);
7307 *result_dwo_abbrev_table
7308 = abbrev_table_read_table (dwarf2_per_objfile
, dwo_abbrev_section
,
7309 cu
->header
.abbrev_sect_off
);
7310 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
7311 result_dwo_abbrev_table
->get ());
7313 /* Read in the die, but leave space to copy over the attributes
7314 from the stub. This has the benefit of simplifying the rest of
7315 the code - all the work to maintain the illusion of a single
7316 DW_TAG_{compile,type}_unit DIE is done here. */
7317 num_extra_attrs
= ((stmt_list
!= NULL
)
7321 + (comp_dir
!= NULL
));
7322 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
7323 result_has_children
, num_extra_attrs
);
7325 /* Copy over the attributes from the stub to the DIE we just read in. */
7326 comp_unit_die
= *result_comp_unit_die
;
7327 i
= comp_unit_die
->num_attrs
;
7328 if (stmt_list
!= NULL
)
7329 comp_unit_die
->attrs
[i
++] = *stmt_list
;
7331 comp_unit_die
->attrs
[i
++] = *low_pc
;
7332 if (high_pc
!= NULL
)
7333 comp_unit_die
->attrs
[i
++] = *high_pc
;
7335 comp_unit_die
->attrs
[i
++] = *ranges
;
7336 if (comp_dir
!= NULL
)
7337 comp_unit_die
->attrs
[i
++] = *comp_dir
;
7338 comp_unit_die
->num_attrs
+= num_extra_attrs
;
7340 if (dwarf_die_debug
)
7342 fprintf_unfiltered (gdb_stdlog
,
7343 "Read die from %s@0x%x of %s:\n",
7344 get_section_name (section
),
7345 (unsigned) (begin_info_ptr
- section
->buffer
),
7346 bfd_get_filename (abfd
));
7347 dump_die (comp_unit_die
, dwarf_die_debug
);
7350 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7351 TUs by skipping the stub and going directly to the entry in the DWO file.
7352 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7353 to get it via circuitous means. Blech. */
7354 if (comp_dir
!= NULL
)
7355 result_reader
->comp_dir
= DW_STRING (comp_dir
);
7357 /* Skip dummy compilation units. */
7358 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
7359 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7362 *result_info_ptr
= info_ptr
;
7366 /* Return the signature of the compile unit, if found. In DWARF 4 and before,
7367 the signature is in the DW_AT_GNU_dwo_id attribute. In DWARF 5 and later, the
7368 signature is part of the header. */
7369 static gdb::optional
<ULONGEST
>
7370 lookup_dwo_id (struct dwarf2_cu
*cu
, struct die_info
* comp_unit_die
)
7372 if (cu
->header
.version
>= 5)
7373 return cu
->header
.signature
;
7374 struct attribute
*attr
;
7375 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
7376 if (attr
== nullptr)
7377 return gdb::optional
<ULONGEST
> ();
7378 return DW_UNSND (attr
);
7381 /* Subroutine of init_cutu_and_read_dies to simplify it.
7382 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7383 Returns NULL if the specified DWO unit cannot be found. */
7385 static struct dwo_unit
*
7386 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
7387 struct die_info
*comp_unit_die
)
7389 struct dwarf2_cu
*cu
= this_cu
->cu
;
7390 struct dwo_unit
*dwo_unit
;
7391 const char *comp_dir
, *dwo_name
;
7393 gdb_assert (cu
!= NULL
);
7395 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7396 dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7397 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7399 if (this_cu
->is_debug_types
)
7401 struct signatured_type
*sig_type
;
7403 /* Since this_cu is the first member of struct signatured_type,
7404 we can go from a pointer to one to a pointer to the other. */
7405 sig_type
= (struct signatured_type
*) this_cu
;
7406 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
7410 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
7411 if (!signature
.has_value ())
7412 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7414 dwo_name
, objfile_name (this_cu
->dwarf2_per_objfile
->objfile
));
7415 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
7422 /* Subroutine of init_cutu_and_read_dies to simplify it.
7423 See it for a description of the parameters.
7424 Read a TU directly from a DWO file, bypassing the stub. */
7427 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
7428 int use_existing_cu
, int keep
,
7429 die_reader_func_ftype
*die_reader_func
,
7432 std::unique_ptr
<dwarf2_cu
> new_cu
;
7433 struct signatured_type
*sig_type
;
7434 struct die_reader_specs reader
;
7435 const gdb_byte
*info_ptr
;
7436 struct die_info
*comp_unit_die
;
7438 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7440 /* Verify we can do the following downcast, and that we have the
7442 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
7443 sig_type
= (struct signatured_type
*) this_cu
;
7444 gdb_assert (sig_type
->dwo_unit
!= NULL
);
7446 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
7448 gdb_assert (this_cu
->cu
->dwo_unit
== sig_type
->dwo_unit
);
7449 /* There's no need to do the rereading_dwo_cu handling that
7450 init_cutu_and_read_dies does since we don't read the stub. */
7454 /* If !use_existing_cu, this_cu->cu must be NULL. */
7455 gdb_assert (this_cu
->cu
== NULL
);
7456 new_cu
.reset (new dwarf2_cu (this_cu
));
7459 /* A future optimization, if needed, would be to use an existing
7460 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7461 could share abbrev tables. */
7463 /* The abbreviation table used by READER, this must live at least as long as
7465 abbrev_table_up dwo_abbrev_table
;
7467 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
7468 NULL
/* stub_comp_unit_die */,
7469 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
7471 &comp_unit_die
, &has_children
,
7472 &dwo_abbrev_table
) == 0)
7478 /* All the "real" work is done here. */
7479 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7481 /* This duplicates the code in init_cutu_and_read_dies,
7482 but the alternative is making the latter more complex.
7483 This function is only for the special case of using DWO files directly:
7484 no point in overly complicating the general case just to handle this. */
7485 if (new_cu
!= NULL
&& keep
)
7487 /* Link this CU into read_in_chain. */
7488 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
7489 dwarf2_per_objfile
->read_in_chain
= this_cu
;
7490 /* The chain owns it now. */
7495 /* Initialize a CU (or TU) and read its DIEs.
7496 If the CU defers to a DWO file, read the DWO file as well.
7498 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7499 Otherwise the table specified in the comp unit header is read in and used.
7500 This is an optimization for when we already have the abbrev table.
7502 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7503 Otherwise, a new CU is allocated with xmalloc.
7505 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7506 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7508 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7509 linker) then DIE_READER_FUNC will not get called. */
7512 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
7513 struct abbrev_table
*abbrev_table
,
7514 int use_existing_cu
, int keep
,
7516 die_reader_func_ftype
*die_reader_func
,
7519 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7520 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7521 struct dwarf2_section_info
*section
= this_cu
->section
;
7522 bfd
*abfd
= get_section_bfd_owner (section
);
7523 struct dwarf2_cu
*cu
;
7524 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7525 struct die_reader_specs reader
;
7526 struct die_info
*comp_unit_die
;
7528 struct signatured_type
*sig_type
= NULL
;
7529 struct dwarf2_section_info
*abbrev_section
;
7530 /* Non-zero if CU currently points to a DWO file and we need to
7531 reread it. When this happens we need to reread the skeleton die
7532 before we can reread the DWO file (this only applies to CUs, not TUs). */
7533 int rereading_dwo_cu
= 0;
7535 if (dwarf_die_debug
)
7536 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7537 this_cu
->is_debug_types
? "type" : "comp",
7538 sect_offset_str (this_cu
->sect_off
));
7540 if (use_existing_cu
)
7543 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7544 file (instead of going through the stub), short-circuit all of this. */
7545 if (this_cu
->reading_dwo_directly
)
7547 /* Narrow down the scope of possibilities to have to understand. */
7548 gdb_assert (this_cu
->is_debug_types
);
7549 gdb_assert (abbrev_table
== NULL
);
7550 init_tu_and_read_dwo_dies (this_cu
, use_existing_cu
, keep
,
7551 die_reader_func
, data
);
7555 /* This is cheap if the section is already read in. */
7556 dwarf2_read_section (objfile
, section
);
7558 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7560 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
7562 std::unique_ptr
<dwarf2_cu
> new_cu
;
7563 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
7566 /* If this CU is from a DWO file we need to start over, we need to
7567 refetch the attributes from the skeleton CU.
7568 This could be optimized by retrieving those attributes from when we
7569 were here the first time: the previous comp_unit_die was stored in
7570 comp_unit_obstack. But there's no data yet that we need this
7572 if (cu
->dwo_unit
!= NULL
)
7573 rereading_dwo_cu
= 1;
7577 /* If !use_existing_cu, this_cu->cu must be NULL. */
7578 gdb_assert (this_cu
->cu
== NULL
);
7579 new_cu
.reset (new dwarf2_cu (this_cu
));
7583 /* Get the header. */
7584 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
7586 /* We already have the header, there's no need to read it in again. */
7587 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
7591 if (this_cu
->is_debug_types
)
7593 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7594 &cu
->header
, section
,
7595 abbrev_section
, info_ptr
,
7598 /* Since per_cu is the first member of struct signatured_type,
7599 we can go from a pointer to one to a pointer to the other. */
7600 sig_type
= (struct signatured_type
*) this_cu
;
7601 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
7602 gdb_assert (sig_type
->type_offset_in_tu
7603 == cu
->header
.type_cu_offset_in_tu
);
7604 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7606 /* LENGTH has not been set yet for type units if we're
7607 using .gdb_index. */
7608 this_cu
->length
= get_cu_length (&cu
->header
);
7610 /* Establish the type offset that can be used to lookup the type. */
7611 sig_type
->type_offset_in_section
=
7612 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
7614 this_cu
->dwarf_version
= cu
->header
.version
;
7618 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7619 &cu
->header
, section
,
7622 rcuh_kind::COMPILE
);
7624 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7625 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
7626 this_cu
->dwarf_version
= cu
->header
.version
;
7630 /* Skip dummy compilation units. */
7631 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7632 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7635 /* If we don't have them yet, read the abbrevs for this compilation unit.
7636 And if we need to read them now, make sure they're freed when we're
7637 done (own the table through ABBREV_TABLE_HOLDER). */
7638 abbrev_table_up abbrev_table_holder
;
7639 if (abbrev_table
!= NULL
)
7640 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
7644 = abbrev_table_read_table (dwarf2_per_objfile
, abbrev_section
,
7645 cu
->header
.abbrev_sect_off
);
7646 abbrev_table
= abbrev_table_holder
.get ();
7649 /* Read the top level CU/TU die. */
7650 init_cu_die_reader (&reader
, cu
, section
, NULL
, abbrev_table
);
7651 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
7653 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
7656 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7657 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7658 table from the DWO file and pass the ownership over to us. It will be
7659 referenced from READER, so we must make sure to free it after we're done
7662 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7663 DWO CU, that this test will fail (the attribute will not be present). */
7664 const char *dwo_name
= dwarf2_dwo_name (comp_unit_die
, cu
);
7665 abbrev_table_up dwo_abbrev_table
;
7666 if (dwo_name
!= nullptr)
7668 struct dwo_unit
*dwo_unit
;
7669 struct die_info
*dwo_comp_unit_die
;
7673 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7674 " has children (offset %s) [in module %s]"),
7675 sect_offset_str (this_cu
->sect_off
),
7676 bfd_get_filename (abfd
));
7678 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
7679 if (dwo_unit
!= NULL
)
7681 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
7682 comp_unit_die
, NULL
,
7684 &dwo_comp_unit_die
, &has_children
,
7685 &dwo_abbrev_table
) == 0)
7690 comp_unit_die
= dwo_comp_unit_die
;
7694 /* Yikes, we couldn't find the rest of the DIE, we only have
7695 the stub. A complaint has already been logged. There's
7696 not much more we can do except pass on the stub DIE to
7697 die_reader_func. We don't want to throw an error on bad
7702 /* All of the above is setup for this call. Yikes. */
7703 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7705 /* Done, clean up. */
7706 if (new_cu
!= NULL
&& keep
)
7708 /* Link this CU into read_in_chain. */
7709 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
7710 dwarf2_per_objfile
->read_in_chain
= this_cu
;
7711 /* The chain owns it now. */
7716 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7717 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7718 to have already done the lookup to find the DWO file).
7720 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7721 THIS_CU->is_debug_types, but nothing else.
7723 We fill in THIS_CU->length.
7725 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7726 linker) then DIE_READER_FUNC will not get called.
7728 THIS_CU->cu is always freed when done.
7729 This is done in order to not leave THIS_CU->cu in a state where we have
7730 to care whether it refers to the "main" CU or the DWO CU. */
7733 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
7734 struct dwo_file
*dwo_file
,
7735 die_reader_func_ftype
*die_reader_func
,
7738 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7739 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7740 struct dwarf2_section_info
*section
= this_cu
->section
;
7741 bfd
*abfd
= get_section_bfd_owner (section
);
7742 struct dwarf2_section_info
*abbrev_section
;
7743 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7744 struct die_reader_specs reader
;
7745 struct die_info
*comp_unit_die
;
7748 if (dwarf_die_debug
)
7749 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7750 this_cu
->is_debug_types
? "type" : "comp",
7751 sect_offset_str (this_cu
->sect_off
));
7753 gdb_assert (this_cu
->cu
== NULL
);
7755 abbrev_section
= (dwo_file
!= NULL
7756 ? &dwo_file
->sections
.abbrev
7757 : get_abbrev_section_for_cu (this_cu
));
7759 /* This is cheap if the section is already read in. */
7760 dwarf2_read_section (objfile
, section
);
7762 struct dwarf2_cu
cu (this_cu
);
7764 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7765 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7766 &cu
.header
, section
,
7767 abbrev_section
, info_ptr
,
7768 (this_cu
->is_debug_types
7770 : rcuh_kind::COMPILE
));
7772 this_cu
->length
= get_cu_length (&cu
.header
);
7774 /* Skip dummy compilation units. */
7775 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7776 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7779 abbrev_table_up abbrev_table
7780 = abbrev_table_read_table (dwarf2_per_objfile
, abbrev_section
,
7781 cu
.header
.abbrev_sect_off
);
7783 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
, abbrev_table
.get ());
7784 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
7786 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7789 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7790 does not lookup the specified DWO file.
7791 This cannot be used to read DWO files.
7793 THIS_CU->cu is always freed when done.
7794 This is done in order to not leave THIS_CU->cu in a state where we have
7795 to care whether it refers to the "main" CU or the DWO CU.
7796 We can revisit this if the data shows there's a performance issue. */
7799 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
7800 die_reader_func_ftype
*die_reader_func
,
7803 init_cutu_and_read_dies_no_follow (this_cu
, NULL
, die_reader_func
, data
);
7806 /* Type Unit Groups.
7808 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7809 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7810 so that all types coming from the same compilation (.o file) are grouped
7811 together. A future step could be to put the types in the same symtab as
7812 the CU the types ultimately came from. */
7815 hash_type_unit_group (const void *item
)
7817 const struct type_unit_group
*tu_group
7818 = (const struct type_unit_group
*) item
;
7820 return hash_stmt_list_entry (&tu_group
->hash
);
7824 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
7826 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
7827 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
7829 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
7832 /* Allocate a hash table for type unit groups. */
7835 allocate_type_unit_groups_table (struct objfile
*objfile
)
7837 return htab_create_alloc_ex (3,
7838 hash_type_unit_group
,
7841 &objfile
->objfile_obstack
,
7842 hashtab_obstack_allocate
,
7843 dummy_obstack_deallocate
);
7846 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7847 partial symtabs. We combine several TUs per psymtab to not let the size
7848 of any one psymtab grow too big. */
7849 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7850 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7852 /* Helper routine for get_type_unit_group.
7853 Create the type_unit_group object used to hold one or more TUs. */
7855 static struct type_unit_group
*
7856 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
7858 struct dwarf2_per_objfile
*dwarf2_per_objfile
7859 = cu
->per_cu
->dwarf2_per_objfile
;
7860 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7861 struct dwarf2_per_cu_data
*per_cu
;
7862 struct type_unit_group
*tu_group
;
7864 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7865 struct type_unit_group
);
7866 per_cu
= &tu_group
->per_cu
;
7867 per_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
7869 if (dwarf2_per_objfile
->using_index
)
7871 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7872 struct dwarf2_per_cu_quick_data
);
7876 unsigned int line_offset
= to_underlying (line_offset_struct
);
7877 struct partial_symtab
*pst
;
7880 /* Give the symtab a useful name for debug purposes. */
7881 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
7882 name
= string_printf ("<type_units_%d>",
7883 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
7885 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
7887 pst
= create_partial_symtab (per_cu
, name
.c_str ());
7891 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
7892 tu_group
->hash
.line_sect_off
= line_offset_struct
;
7897 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7898 STMT_LIST is a DW_AT_stmt_list attribute. */
7900 static struct type_unit_group
*
7901 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
7903 struct dwarf2_per_objfile
*dwarf2_per_objfile
7904 = cu
->per_cu
->dwarf2_per_objfile
;
7905 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
7906 struct type_unit_group
*tu_group
;
7908 unsigned int line_offset
;
7909 struct type_unit_group type_unit_group_for_lookup
;
7911 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
7913 dwarf2_per_objfile
->type_unit_groups
=
7914 allocate_type_unit_groups_table (dwarf2_per_objfile
->objfile
);
7917 /* Do we need to create a new group, or can we use an existing one? */
7921 line_offset
= DW_UNSND (stmt_list
);
7922 ++tu_stats
->nr_symtab_sharers
;
7926 /* Ugh, no stmt_list. Rare, but we have to handle it.
7927 We can do various things here like create one group per TU or
7928 spread them over multiple groups to split up the expansion work.
7929 To avoid worst case scenarios (too many groups or too large groups)
7930 we, umm, group them in bunches. */
7931 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7932 | (tu_stats
->nr_stmt_less_type_units
7933 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
7934 ++tu_stats
->nr_stmt_less_type_units
;
7937 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
7938 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
7939 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
7940 &type_unit_group_for_lookup
, INSERT
);
7943 tu_group
= (struct type_unit_group
*) *slot
;
7944 gdb_assert (tu_group
!= NULL
);
7948 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
7949 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
7951 ++tu_stats
->nr_symtabs
;
7957 /* Partial symbol tables. */
7959 /* Create a psymtab named NAME and assign it to PER_CU.
7961 The caller must fill in the following details:
7962 dirname, textlow, texthigh. */
7964 static struct partial_symtab
*
7965 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
7967 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
7968 struct partial_symtab
*pst
;
7970 pst
= start_psymtab_common (objfile
, name
, 0);
7972 pst
->psymtabs_addrmap_supported
= 1;
7974 /* This is the glue that links PST into GDB's symbol API. */
7975 pst
->read_symtab_private
= per_cu
;
7976 pst
->read_symtab
= dwarf2_read_symtab
;
7977 per_cu
->v
.psymtab
= pst
;
7982 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7985 struct process_psymtab_comp_unit_data
7987 /* True if we are reading a DW_TAG_partial_unit. */
7989 int want_partial_unit
;
7991 /* The "pretend" language that is used if the CU doesn't declare a
7994 enum language pretend_language
;
7997 /* die_reader_func for process_psymtab_comp_unit. */
8000 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
8001 const gdb_byte
*info_ptr
,
8002 struct die_info
*comp_unit_die
,
8006 struct dwarf2_cu
*cu
= reader
->cu
;
8007 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
8008 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8009 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
8011 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
8012 struct partial_symtab
*pst
;
8013 enum pc_bounds_kind cu_bounds_kind
;
8014 const char *filename
;
8015 struct process_psymtab_comp_unit_data
*info
8016 = (struct process_psymtab_comp_unit_data
*) data
;
8018 if (comp_unit_die
->tag
== DW_TAG_partial_unit
&& !info
->want_partial_unit
)
8021 gdb_assert (! per_cu
->is_debug_types
);
8023 prepare_one_comp_unit (cu
, comp_unit_die
, info
->pretend_language
);
8025 /* Allocate a new partial symbol table structure. */
8026 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
8027 if (filename
== NULL
)
8030 pst
= create_partial_symtab (per_cu
, filename
);
8032 /* This must be done before calling dwarf2_build_include_psymtabs. */
8033 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
8035 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8037 dwarf2_find_base_address (comp_unit_die
, cu
);
8039 /* Possibly set the default values of LOWPC and HIGHPC from
8041 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
8042 &best_highpc
, cu
, pst
);
8043 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
8046 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
8049 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
8051 /* Store the contiguous range if it is not empty; it can be
8052 empty for CUs with no code. */
8053 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
8057 /* Check if comp unit has_children.
8058 If so, read the rest of the partial symbols from this comp unit.
8059 If not, there's no more debug_info for this comp unit. */
8062 struct partial_die_info
*first_die
;
8063 CORE_ADDR lowpc
, highpc
;
8065 lowpc
= ((CORE_ADDR
) -1);
8066 highpc
= ((CORE_ADDR
) 0);
8068 first_die
= load_partial_dies (reader
, info_ptr
, 1);
8070 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
8071 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
8073 /* If we didn't find a lowpc, set it to highpc to avoid
8074 complaints from `maint check'. */
8075 if (lowpc
== ((CORE_ADDR
) -1))
8078 /* If the compilation unit didn't have an explicit address range,
8079 then use the information extracted from its child dies. */
8080 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
8083 best_highpc
= highpc
;
8086 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
8087 best_lowpc
+ baseaddr
)
8089 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
8090 best_highpc
+ baseaddr
)
8093 end_psymtab_common (objfile
, pst
);
8095 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
8098 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
8099 struct dwarf2_per_cu_data
*iter
;
8101 /* Fill in 'dependencies' here; we fill in 'users' in a
8103 pst
->number_of_dependencies
= len
;
8105 = objfile
->partial_symtabs
->allocate_dependencies (len
);
8107 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
8110 pst
->dependencies
[i
] = iter
->v
.psymtab
;
8112 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
8115 /* Get the list of files included in the current compilation unit,
8116 and build a psymtab for each of them. */
8117 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
8119 if (dwarf_read_debug
)
8120 fprintf_unfiltered (gdb_stdlog
,
8121 "Psymtab for %s unit @%s: %s - %s"
8122 ", %d global, %d static syms\n",
8123 per_cu
->is_debug_types
? "type" : "comp",
8124 sect_offset_str (per_cu
->sect_off
),
8125 paddress (gdbarch
, pst
->text_low (objfile
)),
8126 paddress (gdbarch
, pst
->text_high (objfile
)),
8127 pst
->n_global_syms
, pst
->n_static_syms
);
8130 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8131 Process compilation unit THIS_CU for a psymtab. */
8134 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
8135 int want_partial_unit
,
8136 enum language pretend_language
)
8138 /* If this compilation unit was already read in, free the
8139 cached copy in order to read it in again. This is
8140 necessary because we skipped some symbols when we first
8141 read in the compilation unit (see load_partial_dies).
8142 This problem could be avoided, but the benefit is unclear. */
8143 if (this_cu
->cu
!= NULL
)
8144 free_one_cached_comp_unit (this_cu
);
8146 if (this_cu
->is_debug_types
)
8147 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0, false,
8148 build_type_psymtabs_reader
, NULL
);
8151 process_psymtab_comp_unit_data info
;
8152 info
.want_partial_unit
= want_partial_unit
;
8153 info
.pretend_language
= pretend_language
;
8154 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0, false,
8155 process_psymtab_comp_unit_reader
, &info
);
8158 /* Age out any secondary CUs. */
8159 age_cached_comp_units (this_cu
->dwarf2_per_objfile
);
8162 /* Reader function for build_type_psymtabs. */
8165 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
8166 const gdb_byte
*info_ptr
,
8167 struct die_info
*type_unit_die
,
8171 struct dwarf2_per_objfile
*dwarf2_per_objfile
8172 = reader
->cu
->per_cu
->dwarf2_per_objfile
;
8173 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8174 struct dwarf2_cu
*cu
= reader
->cu
;
8175 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
8176 struct signatured_type
*sig_type
;
8177 struct type_unit_group
*tu_group
;
8178 struct attribute
*attr
;
8179 struct partial_die_info
*first_die
;
8180 CORE_ADDR lowpc
, highpc
;
8181 struct partial_symtab
*pst
;
8183 gdb_assert (data
== NULL
);
8184 gdb_assert (per_cu
->is_debug_types
);
8185 sig_type
= (struct signatured_type
*) per_cu
;
8190 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
8191 tu_group
= get_type_unit_group (cu
, attr
);
8193 if (tu_group
->tus
== nullptr)
8194 tu_group
->tus
= new std::vector
<signatured_type
*>;
8195 tu_group
->tus
->push_back (sig_type
);
8197 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
8198 pst
= create_partial_symtab (per_cu
, "");
8201 first_die
= load_partial_dies (reader
, info_ptr
, 1);
8203 lowpc
= (CORE_ADDR
) -1;
8204 highpc
= (CORE_ADDR
) 0;
8205 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
8207 end_psymtab_common (objfile
, pst
);
8210 /* Struct used to sort TUs by their abbreviation table offset. */
8212 struct tu_abbrev_offset
8214 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
8215 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
8218 signatured_type
*sig_type
;
8219 sect_offset abbrev_offset
;
8222 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
8225 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset
&a
,
8226 const struct tu_abbrev_offset
&b
)
8228 return a
.abbrev_offset
< b
.abbrev_offset
;
8231 /* Efficiently read all the type units.
8232 This does the bulk of the work for build_type_psymtabs.
8234 The efficiency is because we sort TUs by the abbrev table they use and
8235 only read each abbrev table once. In one program there are 200K TUs
8236 sharing 8K abbrev tables.
8238 The main purpose of this function is to support building the
8239 dwarf2_per_objfile->type_unit_groups table.
8240 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8241 can collapse the search space by grouping them by stmt_list.
8242 The savings can be significant, in the same program from above the 200K TUs
8243 share 8K stmt_list tables.
8245 FUNC is expected to call get_type_unit_group, which will create the
8246 struct type_unit_group if necessary and add it to
8247 dwarf2_per_objfile->type_unit_groups. */
8250 build_type_psymtabs_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8252 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
8253 abbrev_table_up abbrev_table
;
8254 sect_offset abbrev_offset
;
8256 /* It's up to the caller to not call us multiple times. */
8257 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
8259 if (dwarf2_per_objfile
->all_type_units
.empty ())
8262 /* TUs typically share abbrev tables, and there can be way more TUs than
8263 abbrev tables. Sort by abbrev table to reduce the number of times we
8264 read each abbrev table in.
8265 Alternatives are to punt or to maintain a cache of abbrev tables.
8266 This is simpler and efficient enough for now.
8268 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8269 symtab to use). Typically TUs with the same abbrev offset have the same
8270 stmt_list value too so in practice this should work well.
8272 The basic algorithm here is:
8274 sort TUs by abbrev table
8275 for each TU with same abbrev table:
8276 read abbrev table if first user
8277 read TU top level DIE
8278 [IWBN if DWO skeletons had DW_AT_stmt_list]
8281 if (dwarf_read_debug
)
8282 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
8284 /* Sort in a separate table to maintain the order of all_type_units
8285 for .gdb_index: TU indices directly index all_type_units. */
8286 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
8287 sorted_by_abbrev
.reserve (dwarf2_per_objfile
->all_type_units
.size ());
8289 for (signatured_type
*sig_type
: dwarf2_per_objfile
->all_type_units
)
8290 sorted_by_abbrev
.emplace_back
8291 (sig_type
, read_abbrev_offset (dwarf2_per_objfile
,
8292 sig_type
->per_cu
.section
,
8293 sig_type
->per_cu
.sect_off
));
8295 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end (),
8296 sort_tu_by_abbrev_offset
);
8298 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
8300 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
8302 /* Switch to the next abbrev table if necessary. */
8303 if (abbrev_table
== NULL
8304 || tu
.abbrev_offset
!= abbrev_offset
)
8306 abbrev_offset
= tu
.abbrev_offset
;
8308 abbrev_table_read_table (dwarf2_per_objfile
,
8309 &dwarf2_per_objfile
->abbrev
,
8311 ++tu_stats
->nr_uniq_abbrev_tables
;
8314 init_cutu_and_read_dies (&tu
.sig_type
->per_cu
, abbrev_table
.get (),
8315 0, 0, false, build_type_psymtabs_reader
, NULL
);
8319 /* Print collected type unit statistics. */
8322 print_tu_stats (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8324 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
8326 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
8327 fprintf_unfiltered (gdb_stdlog
, " %zu TUs\n",
8328 dwarf2_per_objfile
->all_type_units
.size ());
8329 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
8330 tu_stats
->nr_uniq_abbrev_tables
);
8331 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
8332 tu_stats
->nr_symtabs
);
8333 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
8334 tu_stats
->nr_symtab_sharers
);
8335 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
8336 tu_stats
->nr_stmt_less_type_units
);
8337 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
8338 tu_stats
->nr_all_type_units_reallocs
);
8341 /* Traversal function for build_type_psymtabs. */
8344 build_type_psymtab_dependencies (void **slot
, void *info
)
8346 struct dwarf2_per_objfile
*dwarf2_per_objfile
8347 = (struct dwarf2_per_objfile
*) info
;
8348 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8349 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
8350 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
8351 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8352 int len
= (tu_group
->tus
== nullptr) ? 0 : tu_group
->tus
->size ();
8355 gdb_assert (len
> 0);
8356 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
8358 pst
->number_of_dependencies
= len
;
8359 pst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (len
);
8360 for (i
= 0; i
< len
; ++i
)
8362 struct signatured_type
*iter
= tu_group
->tus
->at (i
);
8363 gdb_assert (iter
->per_cu
.is_debug_types
);
8364 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
8365 iter
->type_unit_group
= tu_group
;
8368 delete tu_group
->tus
;
8369 tu_group
->tus
= nullptr;
8374 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8375 Build partial symbol tables for the .debug_types comp-units. */
8378 build_type_psymtabs (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8380 if (! create_all_type_units (dwarf2_per_objfile
))
8383 build_type_psymtabs_1 (dwarf2_per_objfile
);
8386 /* Traversal function for process_skeletonless_type_unit.
8387 Read a TU in a DWO file and build partial symbols for it. */
8390 process_skeletonless_type_unit (void **slot
, void *info
)
8392 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
8393 struct dwarf2_per_objfile
*dwarf2_per_objfile
8394 = (struct dwarf2_per_objfile
*) info
;
8395 struct signatured_type find_entry
, *entry
;
8397 /* If this TU doesn't exist in the global table, add it and read it in. */
8399 if (dwarf2_per_objfile
->signatured_types
== NULL
)
8401 dwarf2_per_objfile
->signatured_types
8402 = allocate_signatured_type_table (dwarf2_per_objfile
->objfile
);
8405 find_entry
.signature
= dwo_unit
->signature
;
8406 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
, &find_entry
,
8408 /* If we've already seen this type there's nothing to do. What's happening
8409 is we're doing our own version of comdat-folding here. */
8413 /* This does the job that create_all_type_units would have done for
8415 entry
= add_type_unit (dwarf2_per_objfile
, dwo_unit
->signature
, slot
);
8416 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, entry
, dwo_unit
);
8419 /* This does the job that build_type_psymtabs_1 would have done. */
8420 init_cutu_and_read_dies (&entry
->per_cu
, NULL
, 0, 0, false,
8421 build_type_psymtabs_reader
, NULL
);
8426 /* Traversal function for process_skeletonless_type_units. */
8429 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
8431 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
8433 if (dwo_file
->tus
!= NULL
)
8435 htab_traverse_noresize (dwo_file
->tus
,
8436 process_skeletonless_type_unit
, info
);
8442 /* Scan all TUs of DWO files, verifying we've processed them.
8443 This is needed in case a TU was emitted without its skeleton.
8444 Note: This can't be done until we know what all the DWO files are. */
8447 process_skeletonless_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8449 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8450 if (get_dwp_file (dwarf2_per_objfile
) == NULL
8451 && dwarf2_per_objfile
->dwo_files
!= NULL
)
8453 htab_traverse_noresize (dwarf2_per_objfile
->dwo_files
.get (),
8454 process_dwo_file_for_skeletonless_type_units
,
8455 dwarf2_per_objfile
);
8459 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8462 set_partial_user (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8464 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
8466 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8471 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
8473 /* Set the 'user' field only if it is not already set. */
8474 if (pst
->dependencies
[j
]->user
== NULL
)
8475 pst
->dependencies
[j
]->user
= pst
;
8480 /* Build the partial symbol table by doing a quick pass through the
8481 .debug_info and .debug_abbrev sections. */
8484 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8486 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8488 if (dwarf_read_debug
)
8490 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
8491 objfile_name (objfile
));
8494 dwarf2_per_objfile
->reading_partial_symbols
= 1;
8496 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
8498 /* Any cached compilation units will be linked by the per-objfile
8499 read_in_chain. Make sure to free them when we're done. */
8500 free_cached_comp_units
freer (dwarf2_per_objfile
);
8502 build_type_psymtabs (dwarf2_per_objfile
);
8504 create_all_comp_units (dwarf2_per_objfile
);
8506 /* Create a temporary address map on a temporary obstack. We later
8507 copy this to the final obstack. */
8508 auto_obstack temp_obstack
;
8510 scoped_restore save_psymtabs_addrmap
8511 = make_scoped_restore (&objfile
->partial_symtabs
->psymtabs_addrmap
,
8512 addrmap_create_mutable (&temp_obstack
));
8514 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
8515 process_psymtab_comp_unit (per_cu
, 0, language_minimal
);
8517 /* This has to wait until we read the CUs, we need the list of DWOs. */
8518 process_skeletonless_type_units (dwarf2_per_objfile
);
8520 /* Now that all TUs have been processed we can fill in the dependencies. */
8521 if (dwarf2_per_objfile
->type_unit_groups
!= NULL
)
8523 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
8524 build_type_psymtab_dependencies
, dwarf2_per_objfile
);
8527 if (dwarf_read_debug
)
8528 print_tu_stats (dwarf2_per_objfile
);
8530 set_partial_user (dwarf2_per_objfile
);
8532 objfile
->partial_symtabs
->psymtabs_addrmap
8533 = addrmap_create_fixed (objfile
->partial_symtabs
->psymtabs_addrmap
,
8534 objfile
->partial_symtabs
->obstack ());
8535 /* At this point we want to keep the address map. */
8536 save_psymtabs_addrmap
.release ();
8538 if (dwarf_read_debug
)
8539 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
8540 objfile_name (objfile
));
8543 /* die_reader_func for load_partial_comp_unit. */
8546 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
8547 const gdb_byte
*info_ptr
,
8548 struct die_info
*comp_unit_die
,
8552 struct dwarf2_cu
*cu
= reader
->cu
;
8554 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
8556 /* Check if comp unit has_children.
8557 If so, read the rest of the partial symbols from this comp unit.
8558 If not, there's no more debug_info for this comp unit. */
8560 load_partial_dies (reader
, info_ptr
, 0);
8563 /* Load the partial DIEs for a secondary CU into memory.
8564 This is also used when rereading a primary CU with load_all_dies. */
8567 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
8569 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1, false,
8570 load_partial_comp_unit_reader
, NULL
);
8574 read_comp_units_from_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
8575 struct dwarf2_section_info
*section
,
8576 struct dwarf2_section_info
*abbrev_section
,
8577 unsigned int is_dwz
)
8579 const gdb_byte
*info_ptr
;
8580 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8582 if (dwarf_read_debug
)
8583 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
8584 get_section_name (section
),
8585 get_section_file_name (section
));
8587 dwarf2_read_section (objfile
, section
);
8589 info_ptr
= section
->buffer
;
8591 while (info_ptr
< section
->buffer
+ section
->size
)
8593 struct dwarf2_per_cu_data
*this_cu
;
8595 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
8597 comp_unit_head cu_header
;
8598 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
8599 abbrev_section
, info_ptr
,
8600 rcuh_kind::COMPILE
);
8602 /* Save the compilation unit for later lookup. */
8603 if (cu_header
.unit_type
!= DW_UT_type
)
8605 this_cu
= XOBNEW (&objfile
->objfile_obstack
,
8606 struct dwarf2_per_cu_data
);
8607 memset (this_cu
, 0, sizeof (*this_cu
));
8611 auto sig_type
= XOBNEW (&objfile
->objfile_obstack
,
8612 struct signatured_type
);
8613 memset (sig_type
, 0, sizeof (*sig_type
));
8614 sig_type
->signature
= cu_header
.signature
;
8615 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
8616 this_cu
= &sig_type
->per_cu
;
8618 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
8619 this_cu
->sect_off
= sect_off
;
8620 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
8621 this_cu
->is_dwz
= is_dwz
;
8622 this_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
8623 this_cu
->section
= section
;
8625 dwarf2_per_objfile
->all_comp_units
.push_back (this_cu
);
8627 info_ptr
= info_ptr
+ this_cu
->length
;
8631 /* Create a list of all compilation units in OBJFILE.
8632 This is only done for -readnow and building partial symtabs. */
8635 create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8637 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
8638 read_comp_units_from_section (dwarf2_per_objfile
, &dwarf2_per_objfile
->info
,
8639 &dwarf2_per_objfile
->abbrev
, 0);
8641 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
8643 read_comp_units_from_section (dwarf2_per_objfile
, &dwz
->info
, &dwz
->abbrev
,
8647 /* Process all loaded DIEs for compilation unit CU, starting at
8648 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8649 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8650 DW_AT_ranges). See the comments of add_partial_subprogram on how
8651 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8654 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
8655 CORE_ADDR
*highpc
, int set_addrmap
,
8656 struct dwarf2_cu
*cu
)
8658 struct partial_die_info
*pdi
;
8660 /* Now, march along the PDI's, descending into ones which have
8661 interesting children but skipping the children of the other ones,
8662 until we reach the end of the compilation unit. */
8670 /* Anonymous namespaces or modules have no name but have interesting
8671 children, so we need to look at them. Ditto for anonymous
8674 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
8675 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
8676 || pdi
->tag
== DW_TAG_imported_unit
8677 || pdi
->tag
== DW_TAG_inlined_subroutine
)
8681 case DW_TAG_subprogram
:
8682 case DW_TAG_inlined_subroutine
:
8683 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8685 case DW_TAG_constant
:
8686 case DW_TAG_variable
:
8687 case DW_TAG_typedef
:
8688 case DW_TAG_union_type
:
8689 if (!pdi
->is_declaration
)
8691 add_partial_symbol (pdi
, cu
);
8694 case DW_TAG_class_type
:
8695 case DW_TAG_interface_type
:
8696 case DW_TAG_structure_type
:
8697 if (!pdi
->is_declaration
)
8699 add_partial_symbol (pdi
, cu
);
8701 if ((cu
->language
== language_rust
8702 || cu
->language
== language_cplus
) && pdi
->has_children
)
8703 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8706 case DW_TAG_enumeration_type
:
8707 if (!pdi
->is_declaration
)
8708 add_partial_enumeration (pdi
, cu
);
8710 case DW_TAG_base_type
:
8711 case DW_TAG_subrange_type
:
8712 /* File scope base type definitions are added to the partial
8714 add_partial_symbol (pdi
, cu
);
8716 case DW_TAG_namespace
:
8717 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8720 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8722 case DW_TAG_imported_unit
:
8724 struct dwarf2_per_cu_data
*per_cu
;
8726 /* For now we don't handle imported units in type units. */
8727 if (cu
->per_cu
->is_debug_types
)
8729 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8730 " supported in type units [in module %s]"),
8731 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
8734 per_cu
= dwarf2_find_containing_comp_unit
8735 (pdi
->d
.sect_off
, pdi
->is_dwz
,
8736 cu
->per_cu
->dwarf2_per_objfile
);
8738 /* Go read the partial unit, if needed. */
8739 if (per_cu
->v
.psymtab
== NULL
)
8740 process_psymtab_comp_unit (per_cu
, 1, cu
->language
);
8742 VEC_safe_push (dwarf2_per_cu_ptr
,
8743 cu
->per_cu
->imported_symtabs
, per_cu
);
8746 case DW_TAG_imported_declaration
:
8747 add_partial_symbol (pdi
, cu
);
8754 /* If the die has a sibling, skip to the sibling. */
8756 pdi
= pdi
->die_sibling
;
8760 /* Functions used to compute the fully scoped name of a partial DIE.
8762 Normally, this is simple. For C++, the parent DIE's fully scoped
8763 name is concatenated with "::" and the partial DIE's name.
8764 Enumerators are an exception; they use the scope of their parent
8765 enumeration type, i.e. the name of the enumeration type is not
8766 prepended to the enumerator.
8768 There are two complexities. One is DW_AT_specification; in this
8769 case "parent" means the parent of the target of the specification,
8770 instead of the direct parent of the DIE. The other is compilers
8771 which do not emit DW_TAG_namespace; in this case we try to guess
8772 the fully qualified name of structure types from their members'
8773 linkage names. This must be done using the DIE's children rather
8774 than the children of any DW_AT_specification target. We only need
8775 to do this for structures at the top level, i.e. if the target of
8776 any DW_AT_specification (if any; otherwise the DIE itself) does not
8779 /* Compute the scope prefix associated with PDI's parent, in
8780 compilation unit CU. The result will be allocated on CU's
8781 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8782 field. NULL is returned if no prefix is necessary. */
8784 partial_die_parent_scope (struct partial_die_info
*pdi
,
8785 struct dwarf2_cu
*cu
)
8787 const char *grandparent_scope
;
8788 struct partial_die_info
*parent
, *real_pdi
;
8790 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8791 then this means the parent of the specification DIE. */
8794 while (real_pdi
->has_specification
)
8796 auto res
= find_partial_die (real_pdi
->spec_offset
,
8797 real_pdi
->spec_is_dwz
, cu
);
8802 parent
= real_pdi
->die_parent
;
8806 if (parent
->scope_set
)
8807 return parent
->scope
;
8811 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
8813 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8814 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8815 Work around this problem here. */
8816 if (cu
->language
== language_cplus
8817 && parent
->tag
== DW_TAG_namespace
8818 && strcmp (parent
->name
, "::") == 0
8819 && grandparent_scope
== NULL
)
8821 parent
->scope
= NULL
;
8822 parent
->scope_set
= 1;
8826 /* Nested subroutines in Fortran get a prefix. */
8827 if (pdi
->tag
== DW_TAG_enumerator
)
8828 /* Enumerators should not get the name of the enumeration as a prefix. */
8829 parent
->scope
= grandparent_scope
;
8830 else if (parent
->tag
== DW_TAG_namespace
8831 || parent
->tag
== DW_TAG_module
8832 || parent
->tag
== DW_TAG_structure_type
8833 || parent
->tag
== DW_TAG_class_type
8834 || parent
->tag
== DW_TAG_interface_type
8835 || parent
->tag
== DW_TAG_union_type
8836 || parent
->tag
== DW_TAG_enumeration_type
8837 || (cu
->language
== language_fortran
8838 && parent
->tag
== DW_TAG_subprogram
8839 && pdi
->tag
== DW_TAG_subprogram
))
8841 if (grandparent_scope
== NULL
)
8842 parent
->scope
= parent
->name
;
8844 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
8846 parent
->name
, 0, cu
);
8850 /* FIXME drow/2004-04-01: What should we be doing with
8851 function-local names? For partial symbols, we should probably be
8853 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8854 dwarf_tag_name (parent
->tag
),
8855 sect_offset_str (pdi
->sect_off
));
8856 parent
->scope
= grandparent_scope
;
8859 parent
->scope_set
= 1;
8860 return parent
->scope
;
8863 /* Return the fully scoped name associated with PDI, from compilation unit
8864 CU. The result will be allocated with malloc. */
8867 partial_die_full_name (struct partial_die_info
*pdi
,
8868 struct dwarf2_cu
*cu
)
8870 const char *parent_scope
;
8872 /* If this is a template instantiation, we can not work out the
8873 template arguments from partial DIEs. So, unfortunately, we have
8874 to go through the full DIEs. At least any work we do building
8875 types here will be reused if full symbols are loaded later. */
8876 if (pdi
->has_template_arguments
)
8880 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
8882 struct die_info
*die
;
8883 struct attribute attr
;
8884 struct dwarf2_cu
*ref_cu
= cu
;
8886 /* DW_FORM_ref_addr is using section offset. */
8887 attr
.name
= (enum dwarf_attribute
) 0;
8888 attr
.form
= DW_FORM_ref_addr
;
8889 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
8890 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
8892 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
8896 parent_scope
= partial_die_parent_scope (pdi
, cu
);
8897 if (parent_scope
== NULL
)
8900 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
8904 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
8906 struct dwarf2_per_objfile
*dwarf2_per_objfile
8907 = cu
->per_cu
->dwarf2_per_objfile
;
8908 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8909 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8911 const char *actual_name
= NULL
;
8913 char *built_actual_name
;
8915 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8917 built_actual_name
= partial_die_full_name (pdi
, cu
);
8918 if (built_actual_name
!= NULL
)
8919 actual_name
= built_actual_name
;
8921 if (actual_name
== NULL
)
8922 actual_name
= pdi
->name
;
8926 case DW_TAG_inlined_subroutine
:
8927 case DW_TAG_subprogram
:
8928 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
8930 if (pdi
->is_external
8931 || cu
->language
== language_ada
8932 || (cu
->language
== language_fortran
8933 && pdi
->die_parent
!= NULL
8934 && pdi
->die_parent
->tag
== DW_TAG_subprogram
))
8936 /* Normally, only "external" DIEs are part of the global scope.
8937 But in Ada and Fortran, we want to be able to access nested
8938 procedures globally. So all Ada and Fortran subprograms are
8939 stored in the global scope. */
8940 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8941 built_actual_name
!= NULL
,
8942 VAR_DOMAIN
, LOC_BLOCK
,
8943 SECT_OFF_TEXT (objfile
),
8944 psymbol_placement::GLOBAL
,
8946 cu
->language
, objfile
);
8950 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8951 built_actual_name
!= NULL
,
8952 VAR_DOMAIN
, LOC_BLOCK
,
8953 SECT_OFF_TEXT (objfile
),
8954 psymbol_placement::STATIC
,
8955 addr
, cu
->language
, objfile
);
8958 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8959 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
8961 case DW_TAG_constant
:
8962 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8963 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
8964 -1, (pdi
->is_external
8965 ? psymbol_placement::GLOBAL
8966 : psymbol_placement::STATIC
),
8967 0, cu
->language
, objfile
);
8969 case DW_TAG_variable
:
8971 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
8975 && !dwarf2_per_objfile
->has_section_at_zero
)
8977 /* A global or static variable may also have been stripped
8978 out by the linker if unused, in which case its address
8979 will be nullified; do not add such variables into partial
8980 symbol table then. */
8982 else if (pdi
->is_external
)
8985 Don't enter into the minimal symbol tables as there is
8986 a minimal symbol table entry from the ELF symbols already.
8987 Enter into partial symbol table if it has a location
8988 descriptor or a type.
8989 If the location descriptor is missing, new_symbol will create
8990 a LOC_UNRESOLVED symbol, the address of the variable will then
8991 be determined from the minimal symbol table whenever the variable
8993 The address for the partial symbol table entry is not
8994 used by GDB, but it comes in handy for debugging partial symbol
8997 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8998 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8999 built_actual_name
!= NULL
,
9000 VAR_DOMAIN
, LOC_STATIC
,
9001 SECT_OFF_TEXT (objfile
),
9002 psymbol_placement::GLOBAL
,
9003 addr
, cu
->language
, objfile
);
9007 int has_loc
= pdi
->d
.locdesc
!= NULL
;
9009 /* Static Variable. Skip symbols whose value we cannot know (those
9010 without location descriptors or constant values). */
9011 if (!has_loc
&& !pdi
->has_const_value
)
9013 xfree (built_actual_name
);
9017 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9018 built_actual_name
!= NULL
,
9019 VAR_DOMAIN
, LOC_STATIC
,
9020 SECT_OFF_TEXT (objfile
),
9021 psymbol_placement::STATIC
,
9023 cu
->language
, objfile
);
9026 case DW_TAG_typedef
:
9027 case DW_TAG_base_type
:
9028 case DW_TAG_subrange_type
:
9029 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9030 built_actual_name
!= NULL
,
9031 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
9032 psymbol_placement::STATIC
,
9033 0, cu
->language
, objfile
);
9035 case DW_TAG_imported_declaration
:
9036 case DW_TAG_namespace
:
9037 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9038 built_actual_name
!= NULL
,
9039 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
9040 psymbol_placement::GLOBAL
,
9041 0, cu
->language
, objfile
);
9044 /* With Fortran 77 there might be a "BLOCK DATA" module
9045 available without any name. If so, we skip the module as it
9046 doesn't bring any value. */
9047 if (actual_name
!= nullptr)
9048 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9049 built_actual_name
!= NULL
,
9050 MODULE_DOMAIN
, LOC_TYPEDEF
, -1,
9051 psymbol_placement::GLOBAL
,
9052 0, cu
->language
, objfile
);
9054 case DW_TAG_class_type
:
9055 case DW_TAG_interface_type
:
9056 case DW_TAG_structure_type
:
9057 case DW_TAG_union_type
:
9058 case DW_TAG_enumeration_type
:
9059 /* Skip external references. The DWARF standard says in the section
9060 about "Structure, Union, and Class Type Entries": "An incomplete
9061 structure, union or class type is represented by a structure,
9062 union or class entry that does not have a byte size attribute
9063 and that has a DW_AT_declaration attribute." */
9064 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
9066 xfree (built_actual_name
);
9070 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9071 static vs. global. */
9072 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9073 built_actual_name
!= NULL
,
9074 STRUCT_DOMAIN
, LOC_TYPEDEF
, -1,
9075 cu
->language
== language_cplus
9076 ? psymbol_placement::GLOBAL
9077 : psymbol_placement::STATIC
,
9078 0, cu
->language
, objfile
);
9081 case DW_TAG_enumerator
:
9082 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9083 built_actual_name
!= NULL
,
9084 VAR_DOMAIN
, LOC_CONST
, -1,
9085 cu
->language
== language_cplus
9086 ? psymbol_placement::GLOBAL
9087 : psymbol_placement::STATIC
,
9088 0, cu
->language
, objfile
);
9094 xfree (built_actual_name
);
9097 /* Read a partial die corresponding to a namespace; also, add a symbol
9098 corresponding to that namespace to the symbol table. NAMESPACE is
9099 the name of the enclosing namespace. */
9102 add_partial_namespace (struct partial_die_info
*pdi
,
9103 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9104 int set_addrmap
, struct dwarf2_cu
*cu
)
9106 /* Add a symbol for the namespace. */
9108 add_partial_symbol (pdi
, cu
);
9110 /* Now scan partial symbols in that namespace. */
9112 if (pdi
->has_children
)
9113 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
9116 /* Read a partial die corresponding to a Fortran module. */
9119 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
9120 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
9122 /* Add a symbol for the namespace. */
9124 add_partial_symbol (pdi
, cu
);
9126 /* Now scan partial symbols in that module. */
9128 if (pdi
->has_children
)
9129 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
9132 /* Read a partial die corresponding to a subprogram or an inlined
9133 subprogram and create a partial symbol for that subprogram.
9134 When the CU language allows it, this routine also defines a partial
9135 symbol for each nested subprogram that this subprogram contains.
9136 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9137 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9139 PDI may also be a lexical block, in which case we simply search
9140 recursively for subprograms defined inside that lexical block.
9141 Again, this is only performed when the CU language allows this
9142 type of definitions. */
9145 add_partial_subprogram (struct partial_die_info
*pdi
,
9146 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9147 int set_addrmap
, struct dwarf2_cu
*cu
)
9149 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
9151 if (pdi
->has_pc_info
)
9153 if (pdi
->lowpc
< *lowpc
)
9154 *lowpc
= pdi
->lowpc
;
9155 if (pdi
->highpc
> *highpc
)
9156 *highpc
= pdi
->highpc
;
9159 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9160 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9162 CORE_ADDR this_highpc
;
9163 CORE_ADDR this_lowpc
;
9165 baseaddr
= ANOFFSET (objfile
->section_offsets
,
9166 SECT_OFF_TEXT (objfile
));
9168 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
9169 pdi
->lowpc
+ baseaddr
)
9172 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
9173 pdi
->highpc
+ baseaddr
)
9175 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
9176 this_lowpc
, this_highpc
- 1,
9177 cu
->per_cu
->v
.psymtab
);
9181 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
9183 if (!pdi
->is_declaration
)
9184 /* Ignore subprogram DIEs that do not have a name, they are
9185 illegal. Do not emit a complaint at this point, we will
9186 do so when we convert this psymtab into a symtab. */
9188 add_partial_symbol (pdi
, cu
);
9192 if (! pdi
->has_children
)
9195 if (cu
->language
== language_ada
|| cu
->language
== language_fortran
)
9197 pdi
= pdi
->die_child
;
9201 if (pdi
->tag
== DW_TAG_subprogram
9202 || pdi
->tag
== DW_TAG_inlined_subroutine
9203 || pdi
->tag
== DW_TAG_lexical_block
)
9204 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
9205 pdi
= pdi
->die_sibling
;
9210 /* Read a partial die corresponding to an enumeration type. */
9213 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
9214 struct dwarf2_cu
*cu
)
9216 struct partial_die_info
*pdi
;
9218 if (enum_pdi
->name
!= NULL
)
9219 add_partial_symbol (enum_pdi
, cu
);
9221 pdi
= enum_pdi
->die_child
;
9224 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
9225 complaint (_("malformed enumerator DIE ignored"));
9227 add_partial_symbol (pdi
, cu
);
9228 pdi
= pdi
->die_sibling
;
9232 /* Return the initial uleb128 in the die at INFO_PTR. */
9235 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
9237 unsigned int bytes_read
;
9239 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9242 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9243 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
9245 Return the corresponding abbrev, or NULL if the number is zero (indicating
9246 an empty DIE). In either case *BYTES_READ will be set to the length of
9247 the initial number. */
9249 static struct abbrev_info
*
9250 peek_die_abbrev (const die_reader_specs
&reader
,
9251 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
9253 dwarf2_cu
*cu
= reader
.cu
;
9254 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
9255 unsigned int abbrev_number
9256 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
9258 if (abbrev_number
== 0)
9261 abbrev_info
*abbrev
= reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
9264 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9265 " at offset %s [in module %s]"),
9266 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
9267 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
9273 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9274 Returns a pointer to the end of a series of DIEs, terminated by an empty
9275 DIE. Any children of the skipped DIEs will also be skipped. */
9277 static const gdb_byte
*
9278 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
9282 unsigned int bytes_read
;
9283 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
9286 return info_ptr
+ bytes_read
;
9288 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
9292 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9293 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9294 abbrev corresponding to that skipped uleb128 should be passed in
9295 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9298 static const gdb_byte
*
9299 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
9300 struct abbrev_info
*abbrev
)
9302 unsigned int bytes_read
;
9303 struct attribute attr
;
9304 bfd
*abfd
= reader
->abfd
;
9305 struct dwarf2_cu
*cu
= reader
->cu
;
9306 const gdb_byte
*buffer
= reader
->buffer
;
9307 const gdb_byte
*buffer_end
= reader
->buffer_end
;
9308 unsigned int form
, i
;
9310 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
9312 /* The only abbrev we care about is DW_AT_sibling. */
9313 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
9315 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
9316 if (attr
.form
== DW_FORM_ref_addr
)
9317 complaint (_("ignoring absolute DW_AT_sibling"));
9320 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
9321 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
9323 if (sibling_ptr
< info_ptr
)
9324 complaint (_("DW_AT_sibling points backwards"));
9325 else if (sibling_ptr
> reader
->buffer_end
)
9326 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
9332 /* If it isn't DW_AT_sibling, skip this attribute. */
9333 form
= abbrev
->attrs
[i
].form
;
9337 case DW_FORM_ref_addr
:
9338 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9339 and later it is offset sized. */
9340 if (cu
->header
.version
== 2)
9341 info_ptr
+= cu
->header
.addr_size
;
9343 info_ptr
+= cu
->header
.offset_size
;
9345 case DW_FORM_GNU_ref_alt
:
9346 info_ptr
+= cu
->header
.offset_size
;
9349 info_ptr
+= cu
->header
.addr_size
;
9357 case DW_FORM_flag_present
:
9358 case DW_FORM_implicit_const
:
9375 case DW_FORM_ref_sig8
:
9378 case DW_FORM_data16
:
9381 case DW_FORM_string
:
9382 read_direct_string (abfd
, info_ptr
, &bytes_read
);
9383 info_ptr
+= bytes_read
;
9385 case DW_FORM_sec_offset
:
9387 case DW_FORM_GNU_strp_alt
:
9388 info_ptr
+= cu
->header
.offset_size
;
9390 case DW_FORM_exprloc
:
9392 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9393 info_ptr
+= bytes_read
;
9395 case DW_FORM_block1
:
9396 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
9398 case DW_FORM_block2
:
9399 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
9401 case DW_FORM_block4
:
9402 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
9408 case DW_FORM_ref_udata
:
9409 case DW_FORM_GNU_addr_index
:
9410 case DW_FORM_GNU_str_index
:
9411 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
9413 case DW_FORM_indirect
:
9414 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9415 info_ptr
+= bytes_read
;
9416 /* We need to continue parsing from here, so just go back to
9418 goto skip_attribute
;
9421 error (_("Dwarf Error: Cannot handle %s "
9422 "in DWARF reader [in module %s]"),
9423 dwarf_form_name (form
),
9424 bfd_get_filename (abfd
));
9428 if (abbrev
->has_children
)
9429 return skip_children (reader
, info_ptr
);
9434 /* Locate ORIG_PDI's sibling.
9435 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9437 static const gdb_byte
*
9438 locate_pdi_sibling (const struct die_reader_specs
*reader
,
9439 struct partial_die_info
*orig_pdi
,
9440 const gdb_byte
*info_ptr
)
9442 /* Do we know the sibling already? */
9444 if (orig_pdi
->sibling
)
9445 return orig_pdi
->sibling
;
9447 /* Are there any children to deal with? */
9449 if (!orig_pdi
->has_children
)
9452 /* Skip the children the long way. */
9454 return skip_children (reader
, info_ptr
);
9457 /* Expand this partial symbol table into a full symbol table. SELF is
9461 dwarf2_read_symtab (struct partial_symtab
*self
,
9462 struct objfile
*objfile
)
9464 struct dwarf2_per_objfile
*dwarf2_per_objfile
9465 = get_dwarf2_per_objfile (objfile
);
9469 warning (_("bug: psymtab for %s is already read in."),
9476 printf_filtered (_("Reading in symbols for %s..."),
9478 gdb_flush (gdb_stdout
);
9481 /* If this psymtab is constructed from a debug-only objfile, the
9482 has_section_at_zero flag will not necessarily be correct. We
9483 can get the correct value for this flag by looking at the data
9484 associated with the (presumably stripped) associated objfile. */
9485 if (objfile
->separate_debug_objfile_backlink
)
9487 struct dwarf2_per_objfile
*dpo_backlink
9488 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
9490 dwarf2_per_objfile
->has_section_at_zero
9491 = dpo_backlink
->has_section_at_zero
;
9494 dwarf2_per_objfile
->reading_partial_symbols
= 0;
9496 psymtab_to_symtab_1 (self
);
9498 /* Finish up the debug error message. */
9500 printf_filtered (_("done.\n"));
9503 process_cu_includes (dwarf2_per_objfile
);
9506 /* Reading in full CUs. */
9508 /* Add PER_CU to the queue. */
9511 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
9512 enum language pretend_language
)
9514 struct dwarf2_queue_item
*item
;
9517 item
= XNEW (struct dwarf2_queue_item
);
9518 item
->per_cu
= per_cu
;
9519 item
->pretend_language
= pretend_language
;
9522 if (dwarf2_queue
== NULL
)
9523 dwarf2_queue
= item
;
9525 dwarf2_queue_tail
->next
= item
;
9527 dwarf2_queue_tail
= item
;
9530 /* If PER_CU is not yet queued, add it to the queue.
9531 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9533 The result is non-zero if PER_CU was queued, otherwise the result is zero
9534 meaning either PER_CU is already queued or it is already loaded.
9536 N.B. There is an invariant here that if a CU is queued then it is loaded.
9537 The caller is required to load PER_CU if we return non-zero. */
9540 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
9541 struct dwarf2_per_cu_data
*per_cu
,
9542 enum language pretend_language
)
9544 /* We may arrive here during partial symbol reading, if we need full
9545 DIEs to process an unusual case (e.g. template arguments). Do
9546 not queue PER_CU, just tell our caller to load its DIEs. */
9547 if (per_cu
->dwarf2_per_objfile
->reading_partial_symbols
)
9549 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
9554 /* Mark the dependence relation so that we don't flush PER_CU
9556 if (dependent_cu
!= NULL
)
9557 dwarf2_add_dependence (dependent_cu
, per_cu
);
9559 /* If it's already on the queue, we have nothing to do. */
9563 /* If the compilation unit is already loaded, just mark it as
9565 if (per_cu
->cu
!= NULL
)
9567 per_cu
->cu
->last_used
= 0;
9571 /* Add it to the queue. */
9572 queue_comp_unit (per_cu
, pretend_language
);
9577 /* Process the queue. */
9580 process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
9582 struct dwarf2_queue_item
*item
, *next_item
;
9584 if (dwarf_read_debug
)
9586 fprintf_unfiltered (gdb_stdlog
,
9587 "Expanding one or more symtabs of objfile %s ...\n",
9588 objfile_name (dwarf2_per_objfile
->objfile
));
9591 /* The queue starts out with one item, but following a DIE reference
9592 may load a new CU, adding it to the end of the queue. */
9593 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
9595 if ((dwarf2_per_objfile
->using_index
9596 ? !item
->per_cu
->v
.quick
->compunit_symtab
9597 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
9598 /* Skip dummy CUs. */
9599 && item
->per_cu
->cu
!= NULL
)
9601 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
9602 unsigned int debug_print_threshold
;
9605 if (per_cu
->is_debug_types
)
9607 struct signatured_type
*sig_type
=
9608 (struct signatured_type
*) per_cu
;
9610 sprintf (buf
, "TU %s at offset %s",
9611 hex_string (sig_type
->signature
),
9612 sect_offset_str (per_cu
->sect_off
));
9613 /* There can be 100s of TUs.
9614 Only print them in verbose mode. */
9615 debug_print_threshold
= 2;
9619 sprintf (buf
, "CU at offset %s",
9620 sect_offset_str (per_cu
->sect_off
));
9621 debug_print_threshold
= 1;
9624 if (dwarf_read_debug
>= debug_print_threshold
)
9625 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
9627 if (per_cu
->is_debug_types
)
9628 process_full_type_unit (per_cu
, item
->pretend_language
);
9630 process_full_comp_unit (per_cu
, item
->pretend_language
);
9632 if (dwarf_read_debug
>= debug_print_threshold
)
9633 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
9636 item
->per_cu
->queued
= 0;
9637 next_item
= item
->next
;
9641 dwarf2_queue_tail
= NULL
;
9643 if (dwarf_read_debug
)
9645 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
9646 objfile_name (dwarf2_per_objfile
->objfile
));
9650 /* Read in full symbols for PST, and anything it depends on. */
9653 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
9655 struct dwarf2_per_cu_data
*per_cu
;
9661 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
9662 if (!pst
->dependencies
[i
]->readin
9663 && pst
->dependencies
[i
]->user
== NULL
)
9665 /* Inform about additional files that need to be read in. */
9668 /* FIXME: i18n: Need to make this a single string. */
9669 fputs_filtered (" ", gdb_stdout
);
9671 fputs_filtered ("and ", gdb_stdout
);
9673 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
9674 wrap_here (""); /* Flush output. */
9675 gdb_flush (gdb_stdout
);
9677 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
9680 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
9684 /* It's an include file, no symbols to read for it.
9685 Everything is in the parent symtab. */
9690 dw2_do_instantiate_symtab (per_cu
, false);
9693 /* Trivial hash function for die_info: the hash value of a DIE
9694 is its offset in .debug_info for this objfile. */
9697 die_hash (const void *item
)
9699 const struct die_info
*die
= (const struct die_info
*) item
;
9701 return to_underlying (die
->sect_off
);
9704 /* Trivial comparison function for die_info structures: two DIEs
9705 are equal if they have the same offset. */
9708 die_eq (const void *item_lhs
, const void *item_rhs
)
9710 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
9711 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
9713 return die_lhs
->sect_off
== die_rhs
->sect_off
;
9716 /* die_reader_func for load_full_comp_unit.
9717 This is identical to read_signatured_type_reader,
9718 but is kept separate for now. */
9721 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
9722 const gdb_byte
*info_ptr
,
9723 struct die_info
*comp_unit_die
,
9727 struct dwarf2_cu
*cu
= reader
->cu
;
9728 enum language
*language_ptr
= (enum language
*) data
;
9730 gdb_assert (cu
->die_hash
== NULL
);
9732 htab_create_alloc_ex (cu
->header
.length
/ 12,
9736 &cu
->comp_unit_obstack
,
9737 hashtab_obstack_allocate
,
9738 dummy_obstack_deallocate
);
9741 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
9742 &info_ptr
, comp_unit_die
);
9743 cu
->dies
= comp_unit_die
;
9744 /* comp_unit_die is not stored in die_hash, no need. */
9746 /* We try not to read any attributes in this function, because not
9747 all CUs needed for references have been loaded yet, and symbol
9748 table processing isn't initialized. But we have to set the CU language,
9749 or we won't be able to build types correctly.
9750 Similarly, if we do not read the producer, we can not apply
9751 producer-specific interpretation. */
9752 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
9755 /* Load the DIEs associated with PER_CU into memory. */
9758 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
9760 enum language pretend_language
)
9762 gdb_assert (! this_cu
->is_debug_types
);
9764 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1, skip_partial
,
9765 load_full_comp_unit_reader
, &pretend_language
);
9768 /* Add a DIE to the delayed physname list. */
9771 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
9772 const char *name
, struct die_info
*die
,
9773 struct dwarf2_cu
*cu
)
9775 struct delayed_method_info mi
;
9777 mi
.fnfield_index
= fnfield_index
;
9781 cu
->method_list
.push_back (mi
);
9784 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9785 "const" / "volatile". If so, decrements LEN by the length of the
9786 modifier and return true. Otherwise return false. */
9790 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
9792 size_t mod_len
= sizeof (mod
) - 1;
9793 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
9801 /* Compute the physnames of any methods on the CU's method list.
9803 The computation of method physnames is delayed in order to avoid the
9804 (bad) condition that one of the method's formal parameters is of an as yet
9808 compute_delayed_physnames (struct dwarf2_cu
*cu
)
9810 /* Only C++ delays computing physnames. */
9811 if (cu
->method_list
.empty ())
9813 gdb_assert (cu
->language
== language_cplus
);
9815 for (const delayed_method_info
&mi
: cu
->method_list
)
9817 const char *physname
;
9818 struct fn_fieldlist
*fn_flp
9819 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
9820 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
9821 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
9822 = physname
? physname
: "";
9824 /* Since there's no tag to indicate whether a method is a
9825 const/volatile overload, extract that information out of the
9827 if (physname
!= NULL
)
9829 size_t len
= strlen (physname
);
9833 if (physname
[len
] == ')') /* shortcut */
9835 else if (check_modifier (physname
, len
, " const"))
9836 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
9837 else if (check_modifier (physname
, len
, " volatile"))
9838 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
9845 /* The list is no longer needed. */
9846 cu
->method_list
.clear ();
9849 /* Go objects should be embedded in a DW_TAG_module DIE,
9850 and it's not clear if/how imported objects will appear.
9851 To keep Go support simple until that's worked out,
9852 go back through what we've read and create something usable.
9853 We could do this while processing each DIE, and feels kinda cleaner,
9854 but that way is more invasive.
9855 This is to, for example, allow the user to type "p var" or "b main"
9856 without having to specify the package name, and allow lookups
9857 of module.object to work in contexts that use the expression
9861 fixup_go_packaging (struct dwarf2_cu
*cu
)
9863 char *package_name
= NULL
;
9864 struct pending
*list
;
9867 for (list
= *cu
->get_builder ()->get_global_symbols ();
9871 for (i
= 0; i
< list
->nsyms
; ++i
)
9873 struct symbol
*sym
= list
->symbol
[i
];
9875 if (SYMBOL_LANGUAGE (sym
) == language_go
9876 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
9878 char *this_package_name
= go_symbol_package_name (sym
);
9880 if (this_package_name
== NULL
)
9882 if (package_name
== NULL
)
9883 package_name
= this_package_name
;
9886 struct objfile
*objfile
9887 = cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9888 if (strcmp (package_name
, this_package_name
) != 0)
9889 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9890 (symbol_symtab (sym
) != NULL
9891 ? symtab_to_filename_for_display
9892 (symbol_symtab (sym
))
9893 : objfile_name (objfile
)),
9894 this_package_name
, package_name
);
9895 xfree (this_package_name
);
9901 if (package_name
!= NULL
)
9903 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9904 const char *saved_package_name
9905 = obstack_strdup (&objfile
->per_bfd
->storage_obstack
, package_name
);
9906 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9907 saved_package_name
);
9910 sym
= allocate_symbol (objfile
);
9911 SYMBOL_SET_LANGUAGE (sym
, language_go
, &objfile
->objfile_obstack
);
9912 SYMBOL_SET_NAMES (sym
, saved_package_name
,
9913 strlen (saved_package_name
), 0, objfile
);
9914 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9915 e.g., "main" finds the "main" module and not C's main(). */
9916 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9917 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9918 SYMBOL_TYPE (sym
) = type
;
9920 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
9922 xfree (package_name
);
9926 /* Allocate a fully-qualified name consisting of the two parts on the
9930 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
9932 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
9935 /* A helper that allocates a struct discriminant_info to attach to a
9938 static struct discriminant_info
*
9939 alloc_discriminant_info (struct type
*type
, int discriminant_index
,
9942 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
9943 gdb_assert (discriminant_index
== -1
9944 || (discriminant_index
>= 0
9945 && discriminant_index
< TYPE_NFIELDS (type
)));
9946 gdb_assert (default_index
== -1
9947 || (default_index
>= 0 && default_index
< TYPE_NFIELDS (type
)));
9949 TYPE_FLAG_DISCRIMINATED_UNION (type
) = 1;
9951 struct discriminant_info
*disc
9952 = ((struct discriminant_info
*)
9954 offsetof (struct discriminant_info
, discriminants
)
9955 + TYPE_NFIELDS (type
) * sizeof (disc
->discriminants
[0])));
9956 disc
->default_index
= default_index
;
9957 disc
->discriminant_index
= discriminant_index
;
9959 struct dynamic_prop prop
;
9960 prop
.kind
= PROP_UNDEFINED
;
9961 prop
.data
.baton
= disc
;
9963 add_dyn_prop (DYN_PROP_DISCRIMINATED
, prop
, type
);
9968 /* Some versions of rustc emitted enums in an unusual way.
9970 Ordinary enums were emitted as unions. The first element of each
9971 structure in the union was named "RUST$ENUM$DISR". This element
9972 held the discriminant.
9974 These versions of Rust also implemented the "non-zero"
9975 optimization. When the enum had two values, and one is empty and
9976 the other holds a pointer that cannot be zero, the pointer is used
9977 as the discriminant, with a zero value meaning the empty variant.
9978 Here, the union's first member is of the form
9979 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9980 where the fieldnos are the indices of the fields that should be
9981 traversed in order to find the field (which may be several fields deep)
9982 and the variantname is the name of the variant of the case when the
9985 This function recognizes whether TYPE is of one of these forms,
9986 and, if so, smashes it to be a variant type. */
9989 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
9991 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
9993 /* We don't need to deal with empty enums. */
9994 if (TYPE_NFIELDS (type
) == 0)
9997 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9998 if (TYPE_NFIELDS (type
) == 1
9999 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
10001 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
10003 /* Decode the field name to find the offset of the
10005 ULONGEST bit_offset
= 0;
10006 struct type
*field_type
= TYPE_FIELD_TYPE (type
, 0);
10007 while (name
[0] >= '0' && name
[0] <= '9')
10010 unsigned long index
= strtoul (name
, &tail
, 10);
10013 || index
>= TYPE_NFIELDS (field_type
)
10014 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
10015 != FIELD_LOC_KIND_BITPOS
))
10017 complaint (_("Could not parse Rust enum encoding string \"%s\""
10019 TYPE_FIELD_NAME (type
, 0),
10020 objfile_name (objfile
));
10025 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
10026 field_type
= TYPE_FIELD_TYPE (field_type
, index
);
10029 /* Make a union to hold the variants. */
10030 struct type
*union_type
= alloc_type (objfile
);
10031 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
10032 TYPE_NFIELDS (union_type
) = 3;
10033 TYPE_FIELDS (union_type
)
10034 = (struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
));
10035 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
10036 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
10038 /* Put the discriminant must at index 0. */
10039 TYPE_FIELD_TYPE (union_type
, 0) = field_type
;
10040 TYPE_FIELD_ARTIFICIAL (union_type
, 0) = 1;
10041 TYPE_FIELD_NAME (union_type
, 0) = "<<discriminant>>";
10042 SET_FIELD_BITPOS (TYPE_FIELD (union_type
, 0), bit_offset
);
10044 /* The order of fields doesn't really matter, so put the real
10045 field at index 1 and the data-less field at index 2. */
10046 struct discriminant_info
*disc
10047 = alloc_discriminant_info (union_type
, 0, 1);
10048 TYPE_FIELD (union_type
, 1) = TYPE_FIELD (type
, 0);
10049 TYPE_FIELD_NAME (union_type
, 1)
10050 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type
, 1)));
10051 TYPE_NAME (TYPE_FIELD_TYPE (union_type
, 1))
10052 = rust_fully_qualify (&objfile
->objfile_obstack
, TYPE_NAME (type
),
10053 TYPE_FIELD_NAME (union_type
, 1));
10055 const char *dataless_name
10056 = rust_fully_qualify (&objfile
->objfile_obstack
, TYPE_NAME (type
),
10058 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
10060 TYPE_FIELD_TYPE (union_type
, 2) = dataless_type
;
10061 /* NAME points into the original discriminant name, which
10062 already has the correct lifetime. */
10063 TYPE_FIELD_NAME (union_type
, 2) = name
;
10064 SET_FIELD_BITPOS (TYPE_FIELD (union_type
, 2), 0);
10065 disc
->discriminants
[2] = 0;
10067 /* Smash this type to be a structure type. We have to do this
10068 because the type has already been recorded. */
10069 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10070 TYPE_NFIELDS (type
) = 1;
10072 = (struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
));
10074 /* Install the variant part. */
10075 TYPE_FIELD_TYPE (type
, 0) = union_type
;
10076 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10077 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10079 /* A union with a single anonymous field is probably an old-style
10080 univariant enum. */
10081 else if (TYPE_NFIELDS (type
) == 1 && streq (TYPE_FIELD_NAME (type
, 0), ""))
10083 /* Smash this type to be a structure type. We have to do this
10084 because the type has already been recorded. */
10085 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10087 /* Make a union to hold the variants. */
10088 struct type
*union_type
= alloc_type (objfile
);
10089 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
10090 TYPE_NFIELDS (union_type
) = TYPE_NFIELDS (type
);
10091 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
10092 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
10093 TYPE_FIELDS (union_type
) = TYPE_FIELDS (type
);
10095 struct type
*field_type
= TYPE_FIELD_TYPE (union_type
, 0);
10096 const char *variant_name
10097 = rust_last_path_segment (TYPE_NAME (field_type
));
10098 TYPE_FIELD_NAME (union_type
, 0) = variant_name
;
10099 TYPE_NAME (field_type
)
10100 = rust_fully_qualify (&objfile
->objfile_obstack
,
10101 TYPE_NAME (type
), variant_name
);
10103 /* Install the union in the outer struct type. */
10104 TYPE_NFIELDS (type
) = 1;
10106 = (struct field
*) TYPE_ZALLOC (union_type
, sizeof (struct field
));
10107 TYPE_FIELD_TYPE (type
, 0) = union_type
;
10108 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10109 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10111 alloc_discriminant_info (union_type
, -1, 0);
10115 struct type
*disr_type
= nullptr;
10116 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
10118 disr_type
= TYPE_FIELD_TYPE (type
, i
);
10120 if (TYPE_CODE (disr_type
) != TYPE_CODE_STRUCT
)
10122 /* All fields of a true enum will be structs. */
10125 else if (TYPE_NFIELDS (disr_type
) == 0)
10127 /* Could be data-less variant, so keep going. */
10128 disr_type
= nullptr;
10130 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
10131 "RUST$ENUM$DISR") != 0)
10133 /* Not a Rust enum. */
10143 /* If we got here without a discriminant, then it's probably
10145 if (disr_type
== nullptr)
10148 /* Smash this type to be a structure type. We have to do this
10149 because the type has already been recorded. */
10150 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10152 /* Make a union to hold the variants. */
10153 struct field
*disr_field
= &TYPE_FIELD (disr_type
, 0);
10154 struct type
*union_type
= alloc_type (objfile
);
10155 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
10156 TYPE_NFIELDS (union_type
) = 1 + TYPE_NFIELDS (type
);
10157 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
10158 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
10159 TYPE_FIELDS (union_type
)
10160 = (struct field
*) TYPE_ZALLOC (union_type
,
10161 (TYPE_NFIELDS (union_type
)
10162 * sizeof (struct field
)));
10164 memcpy (TYPE_FIELDS (union_type
) + 1, TYPE_FIELDS (type
),
10165 TYPE_NFIELDS (type
) * sizeof (struct field
));
10167 /* Install the discriminant at index 0 in the union. */
10168 TYPE_FIELD (union_type
, 0) = *disr_field
;
10169 TYPE_FIELD_ARTIFICIAL (union_type
, 0) = 1;
10170 TYPE_FIELD_NAME (union_type
, 0) = "<<discriminant>>";
10172 /* Install the union in the outer struct type. */
10173 TYPE_FIELD_TYPE (type
, 0) = union_type
;
10174 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10175 TYPE_NFIELDS (type
) = 1;
10177 /* Set the size and offset of the union type. */
10178 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10180 /* We need a way to find the correct discriminant given a
10181 variant name. For convenience we build a map here. */
10182 struct type
*enum_type
= FIELD_TYPE (*disr_field
);
10183 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
10184 for (int i
= 0; i
< TYPE_NFIELDS (enum_type
); ++i
)
10186 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
10189 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
10190 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
10194 int n_fields
= TYPE_NFIELDS (union_type
);
10195 struct discriminant_info
*disc
10196 = alloc_discriminant_info (union_type
, 0, -1);
10197 /* Skip the discriminant here. */
10198 for (int i
= 1; i
< n_fields
; ++i
)
10200 /* Find the final word in the name of this variant's type.
10201 That name can be used to look up the correct
10203 const char *variant_name
10204 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type
,
10207 auto iter
= discriminant_map
.find (variant_name
);
10208 if (iter
!= discriminant_map
.end ())
10209 disc
->discriminants
[i
] = iter
->second
;
10211 /* Remove the discriminant field, if it exists. */
10212 struct type
*sub_type
= TYPE_FIELD_TYPE (union_type
, i
);
10213 if (TYPE_NFIELDS (sub_type
) > 0)
10215 --TYPE_NFIELDS (sub_type
);
10216 ++TYPE_FIELDS (sub_type
);
10218 TYPE_FIELD_NAME (union_type
, i
) = variant_name
;
10219 TYPE_NAME (sub_type
)
10220 = rust_fully_qualify (&objfile
->objfile_obstack
,
10221 TYPE_NAME (type
), variant_name
);
10226 /* Rewrite some Rust unions to be structures with variants parts. */
10229 rust_union_quirks (struct dwarf2_cu
*cu
)
10231 gdb_assert (cu
->language
== language_rust
);
10232 for (type
*type_
: cu
->rust_unions
)
10233 quirk_rust_enum (type_
, cu
->per_cu
->dwarf2_per_objfile
->objfile
);
10234 /* We don't need this any more. */
10235 cu
->rust_unions
.clear ();
10238 /* Return the symtab for PER_CU. This works properly regardless of
10239 whether we're using the index or psymtabs. */
10241 static struct compunit_symtab
*
10242 get_compunit_symtab (struct dwarf2_per_cu_data
*per_cu
)
10244 return (per_cu
->dwarf2_per_objfile
->using_index
10245 ? per_cu
->v
.quick
->compunit_symtab
10246 : per_cu
->v
.psymtab
->compunit_symtab
);
10249 /* A helper function for computing the list of all symbol tables
10250 included by PER_CU. */
10253 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
10254 htab_t all_children
, htab_t all_type_symtabs
,
10255 struct dwarf2_per_cu_data
*per_cu
,
10256 struct compunit_symtab
*immediate_parent
)
10260 struct compunit_symtab
*cust
;
10261 struct dwarf2_per_cu_data
*iter
;
10263 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
10266 /* This inclusion and its children have been processed. */
10271 /* Only add a CU if it has a symbol table. */
10272 cust
= get_compunit_symtab (per_cu
);
10275 /* If this is a type unit only add its symbol table if we haven't
10276 seen it yet (type unit per_cu's can share symtabs). */
10277 if (per_cu
->is_debug_types
)
10279 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
10283 result
->push_back (cust
);
10284 if (cust
->user
== NULL
)
10285 cust
->user
= immediate_parent
;
10290 result
->push_back (cust
);
10291 if (cust
->user
== NULL
)
10292 cust
->user
= immediate_parent
;
10297 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
10300 recursively_compute_inclusions (result
, all_children
,
10301 all_type_symtabs
, iter
, cust
);
10305 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10309 compute_compunit_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
10311 gdb_assert (! per_cu
->is_debug_types
);
10313 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
10316 struct dwarf2_per_cu_data
*per_cu_iter
;
10317 std::vector
<compunit_symtab
*> result_symtabs
;
10318 htab_t all_children
, all_type_symtabs
;
10319 struct compunit_symtab
*cust
= get_compunit_symtab (per_cu
);
10321 /* If we don't have a symtab, we can just skip this case. */
10325 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
10326 NULL
, xcalloc
, xfree
);
10327 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
10328 NULL
, xcalloc
, xfree
);
10331 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
10335 recursively_compute_inclusions (&result_symtabs
, all_children
,
10336 all_type_symtabs
, per_cu_iter
,
10340 /* Now we have a transitive closure of all the included symtabs. */
10341 len
= result_symtabs
.size ();
10343 = XOBNEWVEC (&per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
,
10344 struct compunit_symtab
*, len
+ 1);
10345 memcpy (cust
->includes
, result_symtabs
.data (),
10346 len
* sizeof (compunit_symtab
*));
10347 cust
->includes
[len
] = NULL
;
10349 htab_delete (all_children
);
10350 htab_delete (all_type_symtabs
);
10354 /* Compute the 'includes' field for the symtabs of all the CUs we just
10358 process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
10360 for (dwarf2_per_cu_data
*iter
: dwarf2_per_objfile
->just_read_cus
)
10362 if (! iter
->is_debug_types
)
10363 compute_compunit_symtab_includes (iter
);
10366 dwarf2_per_objfile
->just_read_cus
.clear ();
10369 /* Generate full symbol information for PER_CU, whose DIEs have
10370 already been loaded into memory. */
10373 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
10374 enum language pretend_language
)
10376 struct dwarf2_cu
*cu
= per_cu
->cu
;
10377 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
10378 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10379 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10380 CORE_ADDR lowpc
, highpc
;
10381 struct compunit_symtab
*cust
;
10382 CORE_ADDR baseaddr
;
10383 struct block
*static_block
;
10386 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10388 /* Clear the list here in case something was left over. */
10389 cu
->method_list
.clear ();
10391 cu
->language
= pretend_language
;
10392 cu
->language_defn
= language_def (cu
->language
);
10394 /* Do line number decoding in read_file_scope () */
10395 process_die (cu
->dies
, cu
);
10397 /* For now fudge the Go package. */
10398 if (cu
->language
== language_go
)
10399 fixup_go_packaging (cu
);
10401 /* Now that we have processed all the DIEs in the CU, all the types
10402 should be complete, and it should now be safe to compute all of the
10404 compute_delayed_physnames (cu
);
10406 if (cu
->language
== language_rust
)
10407 rust_union_quirks (cu
);
10409 /* Some compilers don't define a DW_AT_high_pc attribute for the
10410 compilation unit. If the DW_AT_high_pc is missing, synthesize
10411 it, by scanning the DIE's below the compilation unit. */
10412 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
10414 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
10415 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
10417 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10418 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10419 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10420 addrmap to help ensure it has an accurate map of pc values belonging to
10422 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
10424 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
10425 SECT_OFF_TEXT (objfile
),
10430 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
10432 /* Set symtab language to language from DW_AT_language. If the
10433 compilation is from a C file generated by language preprocessors, do
10434 not set the language if it was already deduced by start_subfile. */
10435 if (!(cu
->language
== language_c
10436 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
10437 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10439 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10440 produce DW_AT_location with location lists but it can be possibly
10441 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10442 there were bugs in prologue debug info, fixed later in GCC-4.5
10443 by "unwind info for epilogues" patch (which is not directly related).
10445 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10446 needed, it would be wrong due to missing DW_AT_producer there.
10448 Still one can confuse GDB by using non-standard GCC compilation
10449 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10451 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
10452 cust
->locations_valid
= 1;
10454 if (gcc_4_minor
>= 5)
10455 cust
->epilogue_unwind_valid
= 1;
10457 cust
->call_site_htab
= cu
->call_site_htab
;
10460 if (dwarf2_per_objfile
->using_index
)
10461 per_cu
->v
.quick
->compunit_symtab
= cust
;
10464 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
10465 pst
->compunit_symtab
= cust
;
10469 /* Push it for inclusion processing later. */
10470 dwarf2_per_objfile
->just_read_cus
.push_back (per_cu
);
10472 /* Not needed any more. */
10473 cu
->reset_builder ();
10476 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10477 already been loaded into memory. */
10480 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
10481 enum language pretend_language
)
10483 struct dwarf2_cu
*cu
= per_cu
->cu
;
10484 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
10485 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10486 struct compunit_symtab
*cust
;
10487 struct signatured_type
*sig_type
;
10489 gdb_assert (per_cu
->is_debug_types
);
10490 sig_type
= (struct signatured_type
*) per_cu
;
10492 /* Clear the list here in case something was left over. */
10493 cu
->method_list
.clear ();
10495 cu
->language
= pretend_language
;
10496 cu
->language_defn
= language_def (cu
->language
);
10498 /* The symbol tables are set up in read_type_unit_scope. */
10499 process_die (cu
->dies
, cu
);
10501 /* For now fudge the Go package. */
10502 if (cu
->language
== language_go
)
10503 fixup_go_packaging (cu
);
10505 /* Now that we have processed all the DIEs in the CU, all the types
10506 should be complete, and it should now be safe to compute all of the
10508 compute_delayed_physnames (cu
);
10510 if (cu
->language
== language_rust
)
10511 rust_union_quirks (cu
);
10513 /* TUs share symbol tables.
10514 If this is the first TU to use this symtab, complete the construction
10515 of it with end_expandable_symtab. Otherwise, complete the addition of
10516 this TU's symbols to the existing symtab. */
10517 if (sig_type
->type_unit_group
->compunit_symtab
== NULL
)
10519 buildsym_compunit
*builder
= cu
->get_builder ();
10520 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
10521 sig_type
->type_unit_group
->compunit_symtab
= cust
;
10525 /* Set symtab language to language from DW_AT_language. If the
10526 compilation is from a C file generated by language preprocessors,
10527 do not set the language if it was already deduced by
10529 if (!(cu
->language
== language_c
10530 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
10531 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10536 cu
->get_builder ()->augment_type_symtab ();
10537 cust
= sig_type
->type_unit_group
->compunit_symtab
;
10540 if (dwarf2_per_objfile
->using_index
)
10541 per_cu
->v
.quick
->compunit_symtab
= cust
;
10544 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
10545 pst
->compunit_symtab
= cust
;
10549 /* Not needed any more. */
10550 cu
->reset_builder ();
10553 /* Process an imported unit DIE. */
10556 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10558 struct attribute
*attr
;
10560 /* For now we don't handle imported units in type units. */
10561 if (cu
->per_cu
->is_debug_types
)
10563 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10564 " supported in type units [in module %s]"),
10565 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
10568 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10571 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
10572 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
10573 dwarf2_per_cu_data
*per_cu
10574 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
,
10575 cu
->per_cu
->dwarf2_per_objfile
);
10577 /* If necessary, add it to the queue and load its DIEs. */
10578 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
10579 load_full_comp_unit (per_cu
, false, cu
->language
);
10581 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
10586 /* RAII object that represents a process_die scope: i.e.,
10587 starts/finishes processing a DIE. */
10588 class process_die_scope
10591 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
10592 : m_die (die
), m_cu (cu
)
10594 /* We should only be processing DIEs not already in process. */
10595 gdb_assert (!m_die
->in_process
);
10596 m_die
->in_process
= true;
10599 ~process_die_scope ()
10601 m_die
->in_process
= false;
10603 /* If we're done processing the DIE for the CU that owns the line
10604 header, we don't need the line header anymore. */
10605 if (m_cu
->line_header_die_owner
== m_die
)
10607 delete m_cu
->line_header
;
10608 m_cu
->line_header
= NULL
;
10609 m_cu
->line_header_die_owner
= NULL
;
10618 /* Process a die and its children. */
10621 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10623 process_die_scope
scope (die
, cu
);
10627 case DW_TAG_padding
:
10629 case DW_TAG_compile_unit
:
10630 case DW_TAG_partial_unit
:
10631 read_file_scope (die
, cu
);
10633 case DW_TAG_type_unit
:
10634 read_type_unit_scope (die
, cu
);
10636 case DW_TAG_subprogram
:
10637 /* Nested subprograms in Fortran get a prefix. */
10638 if (cu
->language
== language_fortran
10639 && die
->parent
!= NULL
10640 && die
->parent
->tag
== DW_TAG_subprogram
)
10641 cu
->processing_has_namespace_info
= true;
10642 /* Fall through. */
10643 case DW_TAG_inlined_subroutine
:
10644 read_func_scope (die
, cu
);
10646 case DW_TAG_lexical_block
:
10647 case DW_TAG_try_block
:
10648 case DW_TAG_catch_block
:
10649 read_lexical_block_scope (die
, cu
);
10651 case DW_TAG_call_site
:
10652 case DW_TAG_GNU_call_site
:
10653 read_call_site_scope (die
, cu
);
10655 case DW_TAG_class_type
:
10656 case DW_TAG_interface_type
:
10657 case DW_TAG_structure_type
:
10658 case DW_TAG_union_type
:
10659 process_structure_scope (die
, cu
);
10661 case DW_TAG_enumeration_type
:
10662 process_enumeration_scope (die
, cu
);
10665 /* These dies have a type, but processing them does not create
10666 a symbol or recurse to process the children. Therefore we can
10667 read them on-demand through read_type_die. */
10668 case DW_TAG_subroutine_type
:
10669 case DW_TAG_set_type
:
10670 case DW_TAG_array_type
:
10671 case DW_TAG_pointer_type
:
10672 case DW_TAG_ptr_to_member_type
:
10673 case DW_TAG_reference_type
:
10674 case DW_TAG_rvalue_reference_type
:
10675 case DW_TAG_string_type
:
10678 case DW_TAG_base_type
:
10679 case DW_TAG_subrange_type
:
10680 case DW_TAG_typedef
:
10681 /* Add a typedef symbol for the type definition, if it has a
10683 new_symbol (die
, read_type_die (die
, cu
), cu
);
10685 case DW_TAG_common_block
:
10686 read_common_block (die
, cu
);
10688 case DW_TAG_common_inclusion
:
10690 case DW_TAG_namespace
:
10691 cu
->processing_has_namespace_info
= true;
10692 read_namespace (die
, cu
);
10694 case DW_TAG_module
:
10695 cu
->processing_has_namespace_info
= true;
10696 read_module (die
, cu
);
10698 case DW_TAG_imported_declaration
:
10699 cu
->processing_has_namespace_info
= true;
10700 if (read_namespace_alias (die
, cu
))
10702 /* The declaration is not a global namespace alias. */
10703 /* Fall through. */
10704 case DW_TAG_imported_module
:
10705 cu
->processing_has_namespace_info
= true;
10706 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
10707 || cu
->language
!= language_fortran
))
10708 complaint (_("Tag '%s' has unexpected children"),
10709 dwarf_tag_name (die
->tag
));
10710 read_import_statement (die
, cu
);
10713 case DW_TAG_imported_unit
:
10714 process_imported_unit_die (die
, cu
);
10717 case DW_TAG_variable
:
10718 read_variable (die
, cu
);
10722 new_symbol (die
, NULL
, cu
);
10727 /* DWARF name computation. */
10729 /* A helper function for dwarf2_compute_name which determines whether DIE
10730 needs to have the name of the scope prepended to the name listed in the
10734 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
10736 struct attribute
*attr
;
10740 case DW_TAG_namespace
:
10741 case DW_TAG_typedef
:
10742 case DW_TAG_class_type
:
10743 case DW_TAG_interface_type
:
10744 case DW_TAG_structure_type
:
10745 case DW_TAG_union_type
:
10746 case DW_TAG_enumeration_type
:
10747 case DW_TAG_enumerator
:
10748 case DW_TAG_subprogram
:
10749 case DW_TAG_inlined_subroutine
:
10750 case DW_TAG_member
:
10751 case DW_TAG_imported_declaration
:
10754 case DW_TAG_variable
:
10755 case DW_TAG_constant
:
10756 /* We only need to prefix "globally" visible variables. These include
10757 any variable marked with DW_AT_external or any variable that
10758 lives in a namespace. [Variables in anonymous namespaces
10759 require prefixing, but they are not DW_AT_external.] */
10761 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
10763 struct dwarf2_cu
*spec_cu
= cu
;
10765 return die_needs_namespace (die_specification (die
, &spec_cu
),
10769 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
10770 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
10771 && die
->parent
->tag
!= DW_TAG_module
)
10773 /* A variable in a lexical block of some kind does not need a
10774 namespace, even though in C++ such variables may be external
10775 and have a mangled name. */
10776 if (die
->parent
->tag
== DW_TAG_lexical_block
10777 || die
->parent
->tag
== DW_TAG_try_block
10778 || die
->parent
->tag
== DW_TAG_catch_block
10779 || die
->parent
->tag
== DW_TAG_subprogram
)
10788 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10789 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10790 defined for the given DIE. */
10792 static struct attribute
*
10793 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
10795 struct attribute
*attr
;
10797 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
10799 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10804 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10805 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10806 defined for the given DIE. */
10808 static const char *
10809 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10811 const char *linkage_name
;
10813 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
10814 if (linkage_name
== NULL
)
10815 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10817 return linkage_name
;
10820 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10821 compute the physname for the object, which include a method's:
10822 - formal parameters (C++),
10823 - receiver type (Go),
10825 The term "physname" is a bit confusing.
10826 For C++, for example, it is the demangled name.
10827 For Go, for example, it's the mangled name.
10829 For Ada, return the DIE's linkage name rather than the fully qualified
10830 name. PHYSNAME is ignored..
10832 The result is allocated on the objfile_obstack and canonicalized. */
10834 static const char *
10835 dwarf2_compute_name (const char *name
,
10836 struct die_info
*die
, struct dwarf2_cu
*cu
,
10839 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
10842 name
= dwarf2_name (die
, cu
);
10844 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10845 but otherwise compute it by typename_concat inside GDB.
10846 FIXME: Actually this is not really true, or at least not always true.
10847 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
10848 Fortran names because there is no mangling standard. So new_symbol
10849 will set the demangled name to the result of dwarf2_full_name, and it is
10850 the demangled name that GDB uses if it exists. */
10851 if (cu
->language
== language_ada
10852 || (cu
->language
== language_fortran
&& physname
))
10854 /* For Ada unit, we prefer the linkage name over the name, as
10855 the former contains the exported name, which the user expects
10856 to be able to reference. Ideally, we want the user to be able
10857 to reference this entity using either natural or linkage name,
10858 but we haven't started looking at this enhancement yet. */
10859 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10861 if (linkage_name
!= NULL
)
10862 return linkage_name
;
10865 /* These are the only languages we know how to qualify names in. */
10867 && (cu
->language
== language_cplus
10868 || cu
->language
== language_fortran
|| cu
->language
== language_d
10869 || cu
->language
== language_rust
))
10871 if (die_needs_namespace (die
, cu
))
10873 const char *prefix
;
10874 const char *canonical_name
= NULL
;
10878 prefix
= determine_prefix (die
, cu
);
10879 if (*prefix
!= '\0')
10881 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
10884 buf
.puts (prefixed_name
);
10885 xfree (prefixed_name
);
10890 /* Template parameters may be specified in the DIE's DW_AT_name, or
10891 as children with DW_TAG_template_type_param or
10892 DW_TAG_value_type_param. If the latter, add them to the name
10893 here. If the name already has template parameters, then
10894 skip this step; some versions of GCC emit both, and
10895 it is more efficient to use the pre-computed name.
10897 Something to keep in mind about this process: it is very
10898 unlikely, or in some cases downright impossible, to produce
10899 something that will match the mangled name of a function.
10900 If the definition of the function has the same debug info,
10901 we should be able to match up with it anyway. But fallbacks
10902 using the minimal symbol, for instance to find a method
10903 implemented in a stripped copy of libstdc++, will not work.
10904 If we do not have debug info for the definition, we will have to
10905 match them up some other way.
10907 When we do name matching there is a related problem with function
10908 templates; two instantiated function templates are allowed to
10909 differ only by their return types, which we do not add here. */
10911 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
10913 struct attribute
*attr
;
10914 struct die_info
*child
;
10917 die
->building_fullname
= 1;
10919 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
10923 const gdb_byte
*bytes
;
10924 struct dwarf2_locexpr_baton
*baton
;
10927 if (child
->tag
!= DW_TAG_template_type_param
10928 && child
->tag
!= DW_TAG_template_value_param
)
10939 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10942 complaint (_("template parameter missing DW_AT_type"));
10943 buf
.puts ("UNKNOWN_TYPE");
10946 type
= die_type (child
, cu
);
10948 if (child
->tag
== DW_TAG_template_type_param
)
10950 c_print_type (type
, "", &buf
, -1, 0, cu
->language
,
10951 &type_print_raw_options
);
10955 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10958 complaint (_("template parameter missing "
10959 "DW_AT_const_value"));
10960 buf
.puts ("UNKNOWN_VALUE");
10964 dwarf2_const_value_attr (attr
, type
, name
,
10965 &cu
->comp_unit_obstack
, cu
,
10966 &value
, &bytes
, &baton
);
10968 if (TYPE_NOSIGN (type
))
10969 /* GDB prints characters as NUMBER 'CHAR'. If that's
10970 changed, this can use value_print instead. */
10971 c_printchar (value
, type
, &buf
);
10974 struct value_print_options opts
;
10977 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
10981 else if (bytes
!= NULL
)
10983 v
= allocate_value (type
);
10984 memcpy (value_contents_writeable (v
), bytes
,
10985 TYPE_LENGTH (type
));
10988 v
= value_from_longest (type
, value
);
10990 /* Specify decimal so that we do not depend on
10992 get_formatted_print_options (&opts
, 'd');
10994 value_print (v
, &buf
, &opts
);
10999 die
->building_fullname
= 0;
11003 /* Close the argument list, with a space if necessary
11004 (nested templates). */
11005 if (!buf
.empty () && buf
.string ().back () == '>')
11012 /* For C++ methods, append formal parameter type
11013 information, if PHYSNAME. */
11015 if (physname
&& die
->tag
== DW_TAG_subprogram
11016 && cu
->language
== language_cplus
)
11018 struct type
*type
= read_type_die (die
, cu
);
11020 c_type_print_args (type
, &buf
, 1, cu
->language
,
11021 &type_print_raw_options
);
11023 if (cu
->language
== language_cplus
)
11025 /* Assume that an artificial first parameter is
11026 "this", but do not crash if it is not. RealView
11027 marks unnamed (and thus unused) parameters as
11028 artificial; there is no way to differentiate
11030 if (TYPE_NFIELDS (type
) > 0
11031 && TYPE_FIELD_ARTIFICIAL (type
, 0)
11032 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
11033 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
11035 buf
.puts (" const");
11039 const std::string
&intermediate_name
= buf
.string ();
11041 if (cu
->language
== language_cplus
)
11043 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
11044 &objfile
->per_bfd
->storage_obstack
);
11046 /* If we only computed INTERMEDIATE_NAME, or if
11047 INTERMEDIATE_NAME is already canonical, then we need to
11048 copy it to the appropriate obstack. */
11049 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
11050 name
= obstack_strdup (&objfile
->per_bfd
->storage_obstack
,
11051 intermediate_name
);
11053 name
= canonical_name
;
11060 /* Return the fully qualified name of DIE, based on its DW_AT_name.
11061 If scope qualifiers are appropriate they will be added. The result
11062 will be allocated on the storage_obstack, or NULL if the DIE does
11063 not have a name. NAME may either be from a previous call to
11064 dwarf2_name or NULL.
11066 The output string will be canonicalized (if C++). */
11068 static const char *
11069 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
11071 return dwarf2_compute_name (name
, die
, cu
, 0);
11074 /* Construct a physname for the given DIE in CU. NAME may either be
11075 from a previous call to dwarf2_name or NULL. The result will be
11076 allocated on the objfile_objstack or NULL if the DIE does not have a
11079 The output string will be canonicalized (if C++). */
11081 static const char *
11082 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
11084 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
11085 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
11088 /* In this case dwarf2_compute_name is just a shortcut not building anything
11090 if (!die_needs_namespace (die
, cu
))
11091 return dwarf2_compute_name (name
, die
, cu
, 1);
11093 mangled
= dw2_linkage_name (die
, cu
);
11095 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
11096 See https://github.com/rust-lang/rust/issues/32925. */
11097 if (cu
->language
== language_rust
&& mangled
!= NULL
11098 && strchr (mangled
, '{') != NULL
)
11101 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11103 gdb::unique_xmalloc_ptr
<char> demangled
;
11104 if (mangled
!= NULL
)
11107 if (language_def (cu
->language
)->la_store_sym_names_in_linkage_form_p
)
11109 /* Do nothing (do not demangle the symbol name). */
11111 else if (cu
->language
== language_go
)
11113 /* This is a lie, but we already lie to the caller new_symbol.
11114 new_symbol assumes we return the mangled name.
11115 This just undoes that lie until things are cleaned up. */
11119 /* Use DMGL_RET_DROP for C++ template functions to suppress
11120 their return type. It is easier for GDB users to search
11121 for such functions as `name(params)' than `long name(params)'.
11122 In such case the minimal symbol names do not match the full
11123 symbol names but for template functions there is never a need
11124 to look up their definition from their declaration so
11125 the only disadvantage remains the minimal symbol variant
11126 `long name(params)' does not have the proper inferior type. */
11127 demangled
.reset (gdb_demangle (mangled
,
11128 (DMGL_PARAMS
| DMGL_ANSI
11129 | DMGL_RET_DROP
)));
11132 canon
= demangled
.get ();
11140 if (canon
== NULL
|| check_physname
)
11142 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
11144 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
11146 /* It may not mean a bug in GDB. The compiler could also
11147 compute DW_AT_linkage_name incorrectly. But in such case
11148 GDB would need to be bug-to-bug compatible. */
11150 complaint (_("Computed physname <%s> does not match demangled <%s> "
11151 "(from linkage <%s>) - DIE at %s [in module %s]"),
11152 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
11153 objfile_name (objfile
));
11155 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11156 is available here - over computed PHYSNAME. It is safer
11157 against both buggy GDB and buggy compilers. */
11171 retval
= obstack_strdup (&objfile
->per_bfd
->storage_obstack
, retval
);
11176 /* Inspect DIE in CU for a namespace alias. If one exists, record
11177 a new symbol for it.
11179 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11182 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
11184 struct attribute
*attr
;
11186 /* If the die does not have a name, this is not a namespace
11188 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
11192 struct die_info
*d
= die
;
11193 struct dwarf2_cu
*imported_cu
= cu
;
11195 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11196 keep inspecting DIEs until we hit the underlying import. */
11197 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11198 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
11200 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
11204 d
= follow_die_ref (d
, attr
, &imported_cu
);
11205 if (d
->tag
!= DW_TAG_imported_declaration
)
11209 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
11211 complaint (_("DIE at %s has too many recursively imported "
11212 "declarations"), sect_offset_str (d
->sect_off
));
11219 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
11221 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
11222 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
11224 /* This declaration is a global namespace alias. Add
11225 a symbol for it whose type is the aliased namespace. */
11226 new_symbol (die
, type
, cu
);
11235 /* Return the using directives repository (global or local?) to use in the
11236 current context for CU.
11238 For Ada, imported declarations can materialize renamings, which *may* be
11239 global. However it is impossible (for now?) in DWARF to distinguish
11240 "external" imported declarations and "static" ones. As all imported
11241 declarations seem to be static in all other languages, make them all CU-wide
11242 global only in Ada. */
11244 static struct using_direct
**
11245 using_directives (struct dwarf2_cu
*cu
)
11247 if (cu
->language
== language_ada
11248 && cu
->get_builder ()->outermost_context_p ())
11249 return cu
->get_builder ()->get_global_using_directives ();
11251 return cu
->get_builder ()->get_local_using_directives ();
11254 /* Read the import statement specified by the given die and record it. */
11257 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
11259 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
11260 struct attribute
*import_attr
;
11261 struct die_info
*imported_die
, *child_die
;
11262 struct dwarf2_cu
*imported_cu
;
11263 const char *imported_name
;
11264 const char *imported_name_prefix
;
11265 const char *canonical_name
;
11266 const char *import_alias
;
11267 const char *imported_declaration
= NULL
;
11268 const char *import_prefix
;
11269 std::vector
<const char *> excludes
;
11271 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
11272 if (import_attr
== NULL
)
11274 complaint (_("Tag '%s' has no DW_AT_import"),
11275 dwarf_tag_name (die
->tag
));
11280 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
11281 imported_name
= dwarf2_name (imported_die
, imported_cu
);
11282 if (imported_name
== NULL
)
11284 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11286 The import in the following code:
11300 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11301 <52> DW_AT_decl_file : 1
11302 <53> DW_AT_decl_line : 6
11303 <54> DW_AT_import : <0x75>
11304 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11305 <59> DW_AT_name : B
11306 <5b> DW_AT_decl_file : 1
11307 <5c> DW_AT_decl_line : 2
11308 <5d> DW_AT_type : <0x6e>
11310 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11311 <76> DW_AT_byte_size : 4
11312 <77> DW_AT_encoding : 5 (signed)
11314 imports the wrong die ( 0x75 instead of 0x58 ).
11315 This case will be ignored until the gcc bug is fixed. */
11319 /* Figure out the local name after import. */
11320 import_alias
= dwarf2_name (die
, cu
);
11322 /* Figure out where the statement is being imported to. */
11323 import_prefix
= determine_prefix (die
, cu
);
11325 /* Figure out what the scope of the imported die is and prepend it
11326 to the name of the imported die. */
11327 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
11329 if (imported_die
->tag
!= DW_TAG_namespace
11330 && imported_die
->tag
!= DW_TAG_module
)
11332 imported_declaration
= imported_name
;
11333 canonical_name
= imported_name_prefix
;
11335 else if (strlen (imported_name_prefix
) > 0)
11336 canonical_name
= obconcat (&objfile
->objfile_obstack
,
11337 imported_name_prefix
,
11338 (cu
->language
== language_d
? "." : "::"),
11339 imported_name
, (char *) NULL
);
11341 canonical_name
= imported_name
;
11343 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
11344 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
11345 child_die
= sibling_die (child_die
))
11347 /* DWARF-4: A Fortran use statement with a “rename list” may be
11348 represented by an imported module entry with an import attribute
11349 referring to the module and owned entries corresponding to those
11350 entities that are renamed as part of being imported. */
11352 if (child_die
->tag
!= DW_TAG_imported_declaration
)
11354 complaint (_("child DW_TAG_imported_declaration expected "
11355 "- DIE at %s [in module %s]"),
11356 sect_offset_str (child_die
->sect_off
),
11357 objfile_name (objfile
));
11361 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
11362 if (import_attr
== NULL
)
11364 complaint (_("Tag '%s' has no DW_AT_import"),
11365 dwarf_tag_name (child_die
->tag
));
11370 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
11372 imported_name
= dwarf2_name (imported_die
, imported_cu
);
11373 if (imported_name
== NULL
)
11375 complaint (_("child DW_TAG_imported_declaration has unknown "
11376 "imported name - DIE at %s [in module %s]"),
11377 sect_offset_str (child_die
->sect_off
),
11378 objfile_name (objfile
));
11382 excludes
.push_back (imported_name
);
11384 process_die (child_die
, cu
);
11387 add_using_directive (using_directives (cu
),
11391 imported_declaration
,
11394 &objfile
->objfile_obstack
);
11397 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11398 types, but gives them a size of zero. Starting with version 14,
11399 ICC is compatible with GCC. */
11402 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
11404 if (!cu
->checked_producer
)
11405 check_producer (cu
);
11407 return cu
->producer_is_icc_lt_14
;
11410 /* ICC generates a DW_AT_type for C void functions. This was observed on
11411 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11412 which says that void functions should not have a DW_AT_type. */
11415 producer_is_icc (struct dwarf2_cu
*cu
)
11417 if (!cu
->checked_producer
)
11418 check_producer (cu
);
11420 return cu
->producer_is_icc
;
11423 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11424 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11425 this, it was first present in GCC release 4.3.0. */
11428 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
11430 if (!cu
->checked_producer
)
11431 check_producer (cu
);
11433 return cu
->producer_is_gcc_lt_4_3
;
11436 static file_and_directory
11437 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
11439 file_and_directory res
;
11441 /* Find the filename. Do not use dwarf2_name here, since the filename
11442 is not a source language identifier. */
11443 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
11444 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
11446 if (res
.comp_dir
== NULL
11447 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
11448 && IS_ABSOLUTE_PATH (res
.name
))
11450 res
.comp_dir_storage
= ldirname (res
.name
);
11451 if (!res
.comp_dir_storage
.empty ())
11452 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
11454 if (res
.comp_dir
!= NULL
)
11456 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11457 directory, get rid of it. */
11458 const char *cp
= strchr (res
.comp_dir
, ':');
11460 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
11461 res
.comp_dir
= cp
+ 1;
11464 if (res
.name
== NULL
)
11465 res
.name
= "<unknown>";
11470 /* Handle DW_AT_stmt_list for a compilation unit.
11471 DIE is the DW_TAG_compile_unit die for CU.
11472 COMP_DIR is the compilation directory. LOWPC is passed to
11473 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11476 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
11477 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
11479 struct dwarf2_per_objfile
*dwarf2_per_objfile
11480 = cu
->per_cu
->dwarf2_per_objfile
;
11481 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11482 struct attribute
*attr
;
11483 struct line_header line_header_local
;
11484 hashval_t line_header_local_hash
;
11486 int decode_mapping
;
11488 gdb_assert (! cu
->per_cu
->is_debug_types
);
11490 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
11494 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
11496 /* The line header hash table is only created if needed (it exists to
11497 prevent redundant reading of the line table for partial_units).
11498 If we're given a partial_unit, we'll need it. If we're given a
11499 compile_unit, then use the line header hash table if it's already
11500 created, but don't create one just yet. */
11502 if (dwarf2_per_objfile
->line_header_hash
== NULL
11503 && die
->tag
== DW_TAG_partial_unit
)
11505 dwarf2_per_objfile
->line_header_hash
11506 = htab_create_alloc_ex (127, line_header_hash_voidp
,
11507 line_header_eq_voidp
,
11508 free_line_header_voidp
,
11509 &objfile
->objfile_obstack
,
11510 hashtab_obstack_allocate
,
11511 dummy_obstack_deallocate
);
11514 line_header_local
.sect_off
= line_offset
;
11515 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
11516 line_header_local_hash
= line_header_hash (&line_header_local
);
11517 if (dwarf2_per_objfile
->line_header_hash
!= NULL
)
11519 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
11520 &line_header_local
,
11521 line_header_local_hash
, NO_INSERT
);
11523 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11524 is not present in *SLOT (since if there is something in *SLOT then
11525 it will be for a partial_unit). */
11526 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
11528 gdb_assert (*slot
!= NULL
);
11529 cu
->line_header
= (struct line_header
*) *slot
;
11534 /* dwarf_decode_line_header does not yet provide sufficient information.
11535 We always have to call also dwarf_decode_lines for it. */
11536 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
11540 cu
->line_header
= lh
.release ();
11541 cu
->line_header_die_owner
= die
;
11543 if (dwarf2_per_objfile
->line_header_hash
== NULL
)
11547 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
11548 &line_header_local
,
11549 line_header_local_hash
, INSERT
);
11550 gdb_assert (slot
!= NULL
);
11552 if (slot
!= NULL
&& *slot
== NULL
)
11554 /* This newly decoded line number information unit will be owned
11555 by line_header_hash hash table. */
11556 *slot
= cu
->line_header
;
11557 cu
->line_header_die_owner
= NULL
;
11561 /* We cannot free any current entry in (*slot) as that struct line_header
11562 may be already used by multiple CUs. Create only temporary decoded
11563 line_header for this CU - it may happen at most once for each line
11564 number information unit. And if we're not using line_header_hash
11565 then this is what we want as well. */
11566 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
11568 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
11569 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
11574 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11577 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11579 struct dwarf2_per_objfile
*dwarf2_per_objfile
11580 = cu
->per_cu
->dwarf2_per_objfile
;
11581 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11582 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11583 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
11584 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
11585 struct attribute
*attr
;
11586 struct die_info
*child_die
;
11587 CORE_ADDR baseaddr
;
11589 prepare_one_comp_unit (cu
, die
, cu
->language
);
11590 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11592 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
11594 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11595 from finish_block. */
11596 if (lowpc
== ((CORE_ADDR
) -1))
11598 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11600 file_and_directory fnd
= find_file_and_directory (die
, cu
);
11602 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11603 standardised yet. As a workaround for the language detection we fall
11604 back to the DW_AT_producer string. */
11605 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
11606 cu
->language
= language_opencl
;
11608 /* Similar hack for Go. */
11609 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
11610 set_cu_language (DW_LANG_Go
, cu
);
11612 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
11614 /* Decode line number information if present. We do this before
11615 processing child DIEs, so that the line header table is available
11616 for DW_AT_decl_file. */
11617 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
11619 /* Process all dies in compilation unit. */
11620 if (die
->child
!= NULL
)
11622 child_die
= die
->child
;
11623 while (child_die
&& child_die
->tag
)
11625 process_die (child_die
, cu
);
11626 child_die
= sibling_die (child_die
);
11630 /* Decode macro information, if present. Dwarf 2 macro information
11631 refers to information in the line number info statement program
11632 header, so we can only read it if we've read the header
11634 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
11636 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
11637 if (attr
&& cu
->line_header
)
11639 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
11640 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11642 dwarf_decode_macros (cu
, DW_UNSND (attr
), 1);
11646 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
11647 if (attr
&& cu
->line_header
)
11649 unsigned int macro_offset
= DW_UNSND (attr
);
11651 dwarf_decode_macros (cu
, macro_offset
, 0);
11657 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
11659 struct type_unit_group
*tu_group
;
11661 struct attribute
*attr
;
11663 struct signatured_type
*sig_type
;
11665 gdb_assert (per_cu
->is_debug_types
);
11666 sig_type
= (struct signatured_type
*) per_cu
;
11668 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
11670 /* If we're using .gdb_index (includes -readnow) then
11671 per_cu->type_unit_group may not have been set up yet. */
11672 if (sig_type
->type_unit_group
== NULL
)
11673 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
11674 tu_group
= sig_type
->type_unit_group
;
11676 /* If we've already processed this stmt_list there's no real need to
11677 do it again, we could fake it and just recreate the part we need
11678 (file name,index -> symtab mapping). If data shows this optimization
11679 is useful we can do it then. */
11680 first_time
= tu_group
->compunit_symtab
== NULL
;
11682 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11687 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
11688 lh
= dwarf_decode_line_header (line_offset
, this);
11693 start_symtab ("", NULL
, 0);
11696 gdb_assert (tu_group
->symtabs
== NULL
);
11697 gdb_assert (m_builder
== nullptr);
11698 struct compunit_symtab
*cust
= tu_group
->compunit_symtab
;
11699 m_builder
.reset (new struct buildsym_compunit
11700 (COMPUNIT_OBJFILE (cust
), "",
11701 COMPUNIT_DIRNAME (cust
),
11702 compunit_language (cust
),
11708 line_header
= lh
.release ();
11709 line_header_die_owner
= die
;
11713 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
11715 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11716 still initializing it, and our caller (a few levels up)
11717 process_full_type_unit still needs to know if this is the first
11720 tu_group
->num_symtabs
= line_header
->file_names
.size ();
11721 tu_group
->symtabs
= XNEWVEC (struct symtab
*,
11722 line_header
->file_names
.size ());
11724 for (i
= 0; i
< line_header
->file_names
.size (); ++i
)
11726 file_entry
&fe
= line_header
->file_names
[i
];
11728 dwarf2_start_subfile (this, fe
.name
,
11729 fe
.include_dir (line_header
));
11730 buildsym_compunit
*b
= get_builder ();
11731 if (b
->get_current_subfile ()->symtab
== NULL
)
11733 /* NOTE: start_subfile will recognize when it's been
11734 passed a file it has already seen. So we can't
11735 assume there's a simple mapping from
11736 cu->line_header->file_names to subfiles, plus
11737 cu->line_header->file_names may contain dups. */
11738 b
->get_current_subfile ()->symtab
11739 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
11742 fe
.symtab
= b
->get_current_subfile ()->symtab
;
11743 tu_group
->symtabs
[i
] = fe
.symtab
;
11748 gdb_assert (m_builder
== nullptr);
11749 struct compunit_symtab
*cust
= tu_group
->compunit_symtab
;
11750 m_builder
.reset (new struct buildsym_compunit
11751 (COMPUNIT_OBJFILE (cust
), "",
11752 COMPUNIT_DIRNAME (cust
),
11753 compunit_language (cust
),
11756 for (i
= 0; i
< line_header
->file_names
.size (); ++i
)
11758 file_entry
&fe
= line_header
->file_names
[i
];
11760 fe
.symtab
= tu_group
->symtabs
[i
];
11764 /* The main symtab is allocated last. Type units don't have DW_AT_name
11765 so they don't have a "real" (so to speak) symtab anyway.
11766 There is later code that will assign the main symtab to all symbols
11767 that don't have one. We need to handle the case of a symbol with a
11768 missing symtab (DW_AT_decl_file) anyway. */
11771 /* Process DW_TAG_type_unit.
11772 For TUs we want to skip the first top level sibling if it's not the
11773 actual type being defined by this TU. In this case the first top
11774 level sibling is there to provide context only. */
11777 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11779 struct die_info
*child_die
;
11781 prepare_one_comp_unit (cu
, die
, language_minimal
);
11783 /* Initialize (or reinitialize) the machinery for building symtabs.
11784 We do this before processing child DIEs, so that the line header table
11785 is available for DW_AT_decl_file. */
11786 cu
->setup_type_unit_groups (die
);
11788 if (die
->child
!= NULL
)
11790 child_die
= die
->child
;
11791 while (child_die
&& child_die
->tag
)
11793 process_die (child_die
, cu
);
11794 child_die
= sibling_die (child_die
);
11801 http://gcc.gnu.org/wiki/DebugFission
11802 http://gcc.gnu.org/wiki/DebugFissionDWP
11804 To simplify handling of both DWO files ("object" files with the DWARF info)
11805 and DWP files (a file with the DWOs packaged up into one file), we treat
11806 DWP files as having a collection of virtual DWO files. */
11809 hash_dwo_file (const void *item
)
11811 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
11814 hash
= htab_hash_string (dwo_file
->dwo_name
);
11815 if (dwo_file
->comp_dir
!= NULL
)
11816 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11821 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11823 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11824 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11826 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11828 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11829 return lhs
->comp_dir
== rhs
->comp_dir
;
11830 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11833 /* Allocate a hash table for DWO files. */
11836 allocate_dwo_file_hash_table (struct objfile
*objfile
)
11838 auto delete_dwo_file
= [] (void *item
)
11840 struct dwo_file
*dwo_file
= (struct dwo_file
*) item
;
11845 return htab_up (htab_create_alloc_ex (41,
11849 &objfile
->objfile_obstack
,
11850 hashtab_obstack_allocate
,
11851 dummy_obstack_deallocate
));
11854 /* Lookup DWO file DWO_NAME. */
11857 lookup_dwo_file_slot (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11858 const char *dwo_name
,
11859 const char *comp_dir
)
11861 struct dwo_file find_entry
;
11864 if (dwarf2_per_objfile
->dwo_files
== NULL
)
11865 dwarf2_per_objfile
->dwo_files
11866 = allocate_dwo_file_hash_table (dwarf2_per_objfile
->objfile
);
11868 find_entry
.dwo_name
= dwo_name
;
11869 find_entry
.comp_dir
= comp_dir
;
11870 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
.get (), &find_entry
,
11877 hash_dwo_unit (const void *item
)
11879 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11881 /* This drops the top 32 bits of the id, but is ok for a hash. */
11882 return dwo_unit
->signature
;
11886 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11888 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11889 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11891 /* The signature is assumed to be unique within the DWO file.
11892 So while object file CU dwo_id's always have the value zero,
11893 that's OK, assuming each object file DWO file has only one CU,
11894 and that's the rule for now. */
11895 return lhs
->signature
== rhs
->signature
;
11898 /* Allocate a hash table for DWO CUs,TUs.
11899 There is one of these tables for each of CUs,TUs for each DWO file. */
11902 allocate_dwo_unit_table (struct objfile
*objfile
)
11904 /* Start out with a pretty small number.
11905 Generally DWO files contain only one CU and maybe some TUs. */
11906 return htab_create_alloc_ex (3,
11910 &objfile
->objfile_obstack
,
11911 hashtab_obstack_allocate
,
11912 dummy_obstack_deallocate
);
11915 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11917 struct create_dwo_cu_data
11919 struct dwo_file
*dwo_file
;
11920 struct dwo_unit dwo_unit
;
11923 /* die_reader_func for create_dwo_cu. */
11926 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
11927 const gdb_byte
*info_ptr
,
11928 struct die_info
*comp_unit_die
,
11932 struct dwarf2_cu
*cu
= reader
->cu
;
11933 sect_offset sect_off
= cu
->per_cu
->sect_off
;
11934 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
11935 struct create_dwo_cu_data
*data
= (struct create_dwo_cu_data
*) datap
;
11936 struct dwo_file
*dwo_file
= data
->dwo_file
;
11937 struct dwo_unit
*dwo_unit
= &data
->dwo_unit
;
11939 gdb::optional
<ULONGEST
> signature
= lookup_dwo_id (cu
, comp_unit_die
);
11940 if (!signature
.has_value ())
11942 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11943 " its dwo_id [in module %s]"),
11944 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
11948 dwo_unit
->dwo_file
= dwo_file
;
11949 dwo_unit
->signature
= *signature
;
11950 dwo_unit
->section
= section
;
11951 dwo_unit
->sect_off
= sect_off
;
11952 dwo_unit
->length
= cu
->per_cu
->length
;
11954 if (dwarf_read_debug
)
11955 fprintf_unfiltered (gdb_stdlog
, " offset %s, dwo_id %s\n",
11956 sect_offset_str (sect_off
),
11957 hex_string (dwo_unit
->signature
));
11960 /* Create the dwo_units for the CUs in a DWO_FILE.
11961 Note: This function processes DWO files only, not DWP files. */
11964 create_cus_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11965 struct dwo_file
&dwo_file
, dwarf2_section_info
§ion
,
11968 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11969 const gdb_byte
*info_ptr
, *end_ptr
;
11971 dwarf2_read_section (objfile
, §ion
);
11972 info_ptr
= section
.buffer
;
11974 if (info_ptr
== NULL
)
11977 if (dwarf_read_debug
)
11979 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
11980 get_section_name (§ion
),
11981 get_section_file_name (§ion
));
11984 end_ptr
= info_ptr
+ section
.size
;
11985 while (info_ptr
< end_ptr
)
11987 struct dwarf2_per_cu_data per_cu
;
11988 struct create_dwo_cu_data create_dwo_cu_data
;
11989 struct dwo_unit
*dwo_unit
;
11991 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
11993 memset (&create_dwo_cu_data
.dwo_unit
, 0,
11994 sizeof (create_dwo_cu_data
.dwo_unit
));
11995 memset (&per_cu
, 0, sizeof (per_cu
));
11996 per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
11997 per_cu
.is_debug_types
= 0;
11998 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
11999 per_cu
.section
= §ion
;
12000 create_dwo_cu_data
.dwo_file
= &dwo_file
;
12002 init_cutu_and_read_dies_no_follow (
12003 &per_cu
, &dwo_file
, create_dwo_cu_reader
, &create_dwo_cu_data
);
12004 info_ptr
+= per_cu
.length
;
12006 // If the unit could not be parsed, skip it.
12007 if (create_dwo_cu_data
.dwo_unit
.dwo_file
== NULL
)
12010 if (cus_htab
== NULL
)
12011 cus_htab
= allocate_dwo_unit_table (objfile
);
12013 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12014 *dwo_unit
= create_dwo_cu_data
.dwo_unit
;
12015 slot
= htab_find_slot (cus_htab
, dwo_unit
, INSERT
);
12016 gdb_assert (slot
!= NULL
);
12019 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
12020 sect_offset dup_sect_off
= dup_cu
->sect_off
;
12022 complaint (_("debug cu entry at offset %s is duplicate to"
12023 " the entry at offset %s, signature %s"),
12024 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
12025 hex_string (dwo_unit
->signature
));
12027 *slot
= (void *)dwo_unit
;
12031 /* DWP file .debug_{cu,tu}_index section format:
12032 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
12036 Both index sections have the same format, and serve to map a 64-bit
12037 signature to a set of section numbers. Each section begins with a header,
12038 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
12039 indexes, and a pool of 32-bit section numbers. The index sections will be
12040 aligned at 8-byte boundaries in the file.
12042 The index section header consists of:
12044 V, 32 bit version number
12046 N, 32 bit number of compilation units or type units in the index
12047 M, 32 bit number of slots in the hash table
12049 Numbers are recorded using the byte order of the application binary.
12051 The hash table begins at offset 16 in the section, and consists of an array
12052 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
12053 order of the application binary). Unused slots in the hash table are 0.
12054 (We rely on the extreme unlikeliness of a signature being exactly 0.)
12056 The parallel table begins immediately after the hash table
12057 (at offset 16 + 8 * M from the beginning of the section), and consists of an
12058 array of 32-bit indexes (using the byte order of the application binary),
12059 corresponding 1-1 with slots in the hash table. Each entry in the parallel
12060 table contains a 32-bit index into the pool of section numbers. For unused
12061 hash table slots, the corresponding entry in the parallel table will be 0.
12063 The pool of section numbers begins immediately following the hash table
12064 (at offset 16 + 12 * M from the beginning of the section). The pool of
12065 section numbers consists of an array of 32-bit words (using the byte order
12066 of the application binary). Each item in the array is indexed starting
12067 from 0. The hash table entry provides the index of the first section
12068 number in the set. Additional section numbers in the set follow, and the
12069 set is terminated by a 0 entry (section number 0 is not used in ELF).
12071 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12072 section must be the first entry in the set, and the .debug_abbrev.dwo must
12073 be the second entry. Other members of the set may follow in any order.
12079 DWP Version 2 combines all the .debug_info, etc. sections into one,
12080 and the entries in the index tables are now offsets into these sections.
12081 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
12084 Index Section Contents:
12086 Hash Table of Signatures dwp_hash_table.hash_table
12087 Parallel Table of Indices dwp_hash_table.unit_table
12088 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
12089 Table of Section Sizes dwp_hash_table.v2.sizes
12091 The index section header consists of:
12093 V, 32 bit version number
12094 L, 32 bit number of columns in the table of section offsets
12095 N, 32 bit number of compilation units or type units in the index
12096 M, 32 bit number of slots in the hash table
12098 Numbers are recorded using the byte order of the application binary.
12100 The hash table has the same format as version 1.
12101 The parallel table of indices has the same format as version 1,
12102 except that the entries are origin-1 indices into the table of sections
12103 offsets and the table of section sizes.
12105 The table of offsets begins immediately following the parallel table
12106 (at offset 16 + 12 * M from the beginning of the section). The table is
12107 a two-dimensional array of 32-bit words (using the byte order of the
12108 application binary), with L columns and N+1 rows, in row-major order.
12109 Each row in the array is indexed starting from 0. The first row provides
12110 a key to the remaining rows: each column in this row provides an identifier
12111 for a debug section, and the offsets in the same column of subsequent rows
12112 refer to that section. The section identifiers are:
12114 DW_SECT_INFO 1 .debug_info.dwo
12115 DW_SECT_TYPES 2 .debug_types.dwo
12116 DW_SECT_ABBREV 3 .debug_abbrev.dwo
12117 DW_SECT_LINE 4 .debug_line.dwo
12118 DW_SECT_LOC 5 .debug_loc.dwo
12119 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
12120 DW_SECT_MACINFO 7 .debug_macinfo.dwo
12121 DW_SECT_MACRO 8 .debug_macro.dwo
12123 The offsets provided by the CU and TU index sections are the base offsets
12124 for the contributions made by each CU or TU to the corresponding section
12125 in the package file. Each CU and TU header contains an abbrev_offset
12126 field, used to find the abbreviations table for that CU or TU within the
12127 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12128 be interpreted as relative to the base offset given in the index section.
12129 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12130 should be interpreted as relative to the base offset for .debug_line.dwo,
12131 and offsets into other debug sections obtained from DWARF attributes should
12132 also be interpreted as relative to the corresponding base offset.
12134 The table of sizes begins immediately following the table of offsets.
12135 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12136 with L columns and N rows, in row-major order. Each row in the array is
12137 indexed starting from 1 (row 0 is shared by the two tables).
12141 Hash table lookup is handled the same in version 1 and 2:
12143 We assume that N and M will not exceed 2^32 - 1.
12144 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12146 Given a 64-bit compilation unit signature or a type signature S, an entry
12147 in the hash table is located as follows:
12149 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12150 the low-order k bits all set to 1.
12152 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12154 3) If the hash table entry at index H matches the signature, use that
12155 entry. If the hash table entry at index H is unused (all zeroes),
12156 terminate the search: the signature is not present in the table.
12158 4) Let H = (H + H') modulo M. Repeat at Step 3.
12160 Because M > N and H' and M are relatively prime, the search is guaranteed
12161 to stop at an unused slot or find the match. */
12163 /* Create a hash table to map DWO IDs to their CU/TU entry in
12164 .debug_{info,types}.dwo in DWP_FILE.
12165 Returns NULL if there isn't one.
12166 Note: This function processes DWP files only, not DWO files. */
12168 static struct dwp_hash_table
*
12169 create_dwp_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12170 struct dwp_file
*dwp_file
, int is_debug_types
)
12172 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12173 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12174 const gdb_byte
*index_ptr
, *index_end
;
12175 struct dwarf2_section_info
*index
;
12176 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
12177 struct dwp_hash_table
*htab
;
12179 if (is_debug_types
)
12180 index
= &dwp_file
->sections
.tu_index
;
12182 index
= &dwp_file
->sections
.cu_index
;
12184 if (dwarf2_section_empty_p (index
))
12186 dwarf2_read_section (objfile
, index
);
12188 index_ptr
= index
->buffer
;
12189 index_end
= index_ptr
+ index
->size
;
12191 version
= read_4_bytes (dbfd
, index_ptr
);
12194 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
12198 nr_units
= read_4_bytes (dbfd
, index_ptr
);
12200 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
12203 if (version
!= 1 && version
!= 2)
12205 error (_("Dwarf Error: unsupported DWP file version (%s)"
12206 " [in module %s]"),
12207 pulongest (version
), dwp_file
->name
);
12209 if (nr_slots
!= (nr_slots
& -nr_slots
))
12211 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12212 " is not power of 2 [in module %s]"),
12213 pulongest (nr_slots
), dwp_file
->name
);
12216 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
12217 htab
->version
= version
;
12218 htab
->nr_columns
= nr_columns
;
12219 htab
->nr_units
= nr_units
;
12220 htab
->nr_slots
= nr_slots
;
12221 htab
->hash_table
= index_ptr
;
12222 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
12224 /* Exit early if the table is empty. */
12225 if (nr_slots
== 0 || nr_units
== 0
12226 || (version
== 2 && nr_columns
== 0))
12228 /* All must be zero. */
12229 if (nr_slots
!= 0 || nr_units
!= 0
12230 || (version
== 2 && nr_columns
!= 0))
12232 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12233 " all zero [in modules %s]"),
12241 htab
->section_pool
.v1
.indices
=
12242 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
12243 /* It's harder to decide whether the section is too small in v1.
12244 V1 is deprecated anyway so we punt. */
12248 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
12249 int *ids
= htab
->section_pool
.v2
.section_ids
;
12250 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
12251 /* Reverse map for error checking. */
12252 int ids_seen
[DW_SECT_MAX
+ 1];
12255 if (nr_columns
< 2)
12257 error (_("Dwarf Error: bad DWP hash table, too few columns"
12258 " in section table [in module %s]"),
12261 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
12263 error (_("Dwarf Error: bad DWP hash table, too many columns"
12264 " in section table [in module %s]"),
12267 memset (ids
, 255, sizeof_ids
);
12268 memset (ids_seen
, 255, sizeof (ids_seen
));
12269 for (i
= 0; i
< nr_columns
; ++i
)
12271 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
12273 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
12275 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12276 " in section table [in module %s]"),
12277 id
, dwp_file
->name
);
12279 if (ids_seen
[id
] != -1)
12281 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12282 " id %d in section table [in module %s]"),
12283 id
, dwp_file
->name
);
12288 /* Must have exactly one info or types section. */
12289 if (((ids_seen
[DW_SECT_INFO
] != -1)
12290 + (ids_seen
[DW_SECT_TYPES
] != -1))
12293 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12294 " DWO info/types section [in module %s]"),
12297 /* Must have an abbrev section. */
12298 if (ids_seen
[DW_SECT_ABBREV
] == -1)
12300 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12301 " section [in module %s]"),
12304 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
12305 htab
->section_pool
.v2
.sizes
=
12306 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
12307 * nr_units
* nr_columns
);
12308 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
12309 * nr_units
* nr_columns
))
12312 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12313 " [in module %s]"),
12321 /* Update SECTIONS with the data from SECTP.
12323 This function is like the other "locate" section routines that are
12324 passed to bfd_map_over_sections, but in this context the sections to
12325 read comes from the DWP V1 hash table, not the full ELF section table.
12327 The result is non-zero for success, or zero if an error was found. */
12330 locate_v1_virtual_dwo_sections (asection
*sectp
,
12331 struct virtual_v1_dwo_sections
*sections
)
12333 const struct dwop_section_names
*names
= &dwop_section_names
;
12335 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12337 /* There can be only one. */
12338 if (sections
->abbrev
.s
.section
!= NULL
)
12340 sections
->abbrev
.s
.section
= sectp
;
12341 sections
->abbrev
.size
= bfd_section_size (sectp
);
12343 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
12344 || section_is_p (sectp
->name
, &names
->types_dwo
))
12346 /* There can be only one. */
12347 if (sections
->info_or_types
.s
.section
!= NULL
)
12349 sections
->info_or_types
.s
.section
= sectp
;
12350 sections
->info_or_types
.size
= bfd_section_size (sectp
);
12352 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12354 /* There can be only one. */
12355 if (sections
->line
.s
.section
!= NULL
)
12357 sections
->line
.s
.section
= sectp
;
12358 sections
->line
.size
= bfd_section_size (sectp
);
12360 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12362 /* There can be only one. */
12363 if (sections
->loc
.s
.section
!= NULL
)
12365 sections
->loc
.s
.section
= sectp
;
12366 sections
->loc
.size
= bfd_section_size (sectp
);
12368 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12370 /* There can be only one. */
12371 if (sections
->macinfo
.s
.section
!= NULL
)
12373 sections
->macinfo
.s
.section
= sectp
;
12374 sections
->macinfo
.size
= bfd_section_size (sectp
);
12376 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12378 /* There can be only one. */
12379 if (sections
->macro
.s
.section
!= NULL
)
12381 sections
->macro
.s
.section
= sectp
;
12382 sections
->macro
.size
= bfd_section_size (sectp
);
12384 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12386 /* There can be only one. */
12387 if (sections
->str_offsets
.s
.section
!= NULL
)
12389 sections
->str_offsets
.s
.section
= sectp
;
12390 sections
->str_offsets
.size
= bfd_section_size (sectp
);
12394 /* No other kind of section is valid. */
12401 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12402 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12403 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12404 This is for DWP version 1 files. */
12406 static struct dwo_unit
*
12407 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12408 struct dwp_file
*dwp_file
,
12409 uint32_t unit_index
,
12410 const char *comp_dir
,
12411 ULONGEST signature
, int is_debug_types
)
12413 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12414 const struct dwp_hash_table
*dwp_htab
=
12415 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12416 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12417 const char *kind
= is_debug_types
? "TU" : "CU";
12418 struct dwo_file
*dwo_file
;
12419 struct dwo_unit
*dwo_unit
;
12420 struct virtual_v1_dwo_sections sections
;
12421 void **dwo_file_slot
;
12424 gdb_assert (dwp_file
->version
== 1);
12426 if (dwarf_read_debug
)
12428 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
12430 pulongest (unit_index
), hex_string (signature
),
12434 /* Fetch the sections of this DWO unit.
12435 Put a limit on the number of sections we look for so that bad data
12436 doesn't cause us to loop forever. */
12438 #define MAX_NR_V1_DWO_SECTIONS \
12439 (1 /* .debug_info or .debug_types */ \
12440 + 1 /* .debug_abbrev */ \
12441 + 1 /* .debug_line */ \
12442 + 1 /* .debug_loc */ \
12443 + 1 /* .debug_str_offsets */ \
12444 + 1 /* .debug_macro or .debug_macinfo */ \
12445 + 1 /* trailing zero */)
12447 memset (§ions
, 0, sizeof (sections
));
12449 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
12452 uint32_t section_nr
=
12453 read_4_bytes (dbfd
,
12454 dwp_htab
->section_pool
.v1
.indices
12455 + (unit_index
+ i
) * sizeof (uint32_t));
12457 if (section_nr
== 0)
12459 if (section_nr
>= dwp_file
->num_sections
)
12461 error (_("Dwarf Error: bad DWP hash table, section number too large"
12462 " [in module %s]"),
12466 sectp
= dwp_file
->elf_sections
[section_nr
];
12467 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
12469 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12470 " [in module %s]"),
12476 || dwarf2_section_empty_p (§ions
.info_or_types
)
12477 || dwarf2_section_empty_p (§ions
.abbrev
))
12479 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12480 " [in module %s]"),
12483 if (i
== MAX_NR_V1_DWO_SECTIONS
)
12485 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12486 " [in module %s]"),
12490 /* It's easier for the rest of the code if we fake a struct dwo_file and
12491 have dwo_unit "live" in that. At least for now.
12493 The DWP file can be made up of a random collection of CUs and TUs.
12494 However, for each CU + set of TUs that came from the same original DWO
12495 file, we can combine them back into a virtual DWO file to save space
12496 (fewer struct dwo_file objects to allocate). Remember that for really
12497 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12499 std::string virtual_dwo_name
=
12500 string_printf ("virtual-dwo/%d-%d-%d-%d",
12501 get_section_id (§ions
.abbrev
),
12502 get_section_id (§ions
.line
),
12503 get_section_id (§ions
.loc
),
12504 get_section_id (§ions
.str_offsets
));
12505 /* Can we use an existing virtual DWO file? */
12506 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
12507 virtual_dwo_name
.c_str (),
12509 /* Create one if necessary. */
12510 if (*dwo_file_slot
== NULL
)
12512 if (dwarf_read_debug
)
12514 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12515 virtual_dwo_name
.c_str ());
12517 dwo_file
= new struct dwo_file
;
12518 dwo_file
->dwo_name
= obstack_strdup (&objfile
->objfile_obstack
,
12520 dwo_file
->comp_dir
= comp_dir
;
12521 dwo_file
->sections
.abbrev
= sections
.abbrev
;
12522 dwo_file
->sections
.line
= sections
.line
;
12523 dwo_file
->sections
.loc
= sections
.loc
;
12524 dwo_file
->sections
.macinfo
= sections
.macinfo
;
12525 dwo_file
->sections
.macro
= sections
.macro
;
12526 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
12527 /* The "str" section is global to the entire DWP file. */
12528 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12529 /* The info or types section is assigned below to dwo_unit,
12530 there's no need to record it in dwo_file.
12531 Also, we can't simply record type sections in dwo_file because
12532 we record a pointer into the vector in dwo_unit. As we collect more
12533 types we'll grow the vector and eventually have to reallocate space
12534 for it, invalidating all copies of pointers into the previous
12536 *dwo_file_slot
= dwo_file
;
12540 if (dwarf_read_debug
)
12542 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12543 virtual_dwo_name
.c_str ());
12545 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12548 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12549 dwo_unit
->dwo_file
= dwo_file
;
12550 dwo_unit
->signature
= signature
;
12551 dwo_unit
->section
=
12552 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
12553 *dwo_unit
->section
= sections
.info_or_types
;
12554 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12559 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12560 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12561 piece within that section used by a TU/CU, return a virtual section
12562 of just that piece. */
12564 static struct dwarf2_section_info
12565 create_dwp_v2_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12566 struct dwarf2_section_info
*section
,
12567 bfd_size_type offset
, bfd_size_type size
)
12569 struct dwarf2_section_info result
;
12572 gdb_assert (section
!= NULL
);
12573 gdb_assert (!section
->is_virtual
);
12575 memset (&result
, 0, sizeof (result
));
12576 result
.s
.containing_section
= section
;
12577 result
.is_virtual
= true;
12582 sectp
= get_section_bfd_section (section
);
12584 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12585 bounds of the real section. This is a pretty-rare event, so just
12586 flag an error (easier) instead of a warning and trying to cope. */
12588 || offset
+ size
> bfd_section_size (sectp
))
12590 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12591 " in section %s [in module %s]"),
12592 sectp
? bfd_section_name (sectp
) : "<unknown>",
12593 objfile_name (dwarf2_per_objfile
->objfile
));
12596 result
.virtual_offset
= offset
;
12597 result
.size
= size
;
12601 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12602 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12603 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12604 This is for DWP version 2 files. */
12606 static struct dwo_unit
*
12607 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12608 struct dwp_file
*dwp_file
,
12609 uint32_t unit_index
,
12610 const char *comp_dir
,
12611 ULONGEST signature
, int is_debug_types
)
12613 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12614 const struct dwp_hash_table
*dwp_htab
=
12615 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12616 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12617 const char *kind
= is_debug_types
? "TU" : "CU";
12618 struct dwo_file
*dwo_file
;
12619 struct dwo_unit
*dwo_unit
;
12620 struct virtual_v2_dwo_sections sections
;
12621 void **dwo_file_slot
;
12624 gdb_assert (dwp_file
->version
== 2);
12626 if (dwarf_read_debug
)
12628 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
12630 pulongest (unit_index
), hex_string (signature
),
12634 /* Fetch the section offsets of this DWO unit. */
12636 memset (§ions
, 0, sizeof (sections
));
12638 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12640 uint32_t offset
= read_4_bytes (dbfd
,
12641 dwp_htab
->section_pool
.v2
.offsets
12642 + (((unit_index
- 1) * dwp_htab
->nr_columns
12644 * sizeof (uint32_t)));
12645 uint32_t size
= read_4_bytes (dbfd
,
12646 dwp_htab
->section_pool
.v2
.sizes
12647 + (((unit_index
- 1) * dwp_htab
->nr_columns
12649 * sizeof (uint32_t)));
12651 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
12654 case DW_SECT_TYPES
:
12655 sections
.info_or_types_offset
= offset
;
12656 sections
.info_or_types_size
= size
;
12658 case DW_SECT_ABBREV
:
12659 sections
.abbrev_offset
= offset
;
12660 sections
.abbrev_size
= size
;
12663 sections
.line_offset
= offset
;
12664 sections
.line_size
= size
;
12667 sections
.loc_offset
= offset
;
12668 sections
.loc_size
= size
;
12670 case DW_SECT_STR_OFFSETS
:
12671 sections
.str_offsets_offset
= offset
;
12672 sections
.str_offsets_size
= size
;
12674 case DW_SECT_MACINFO
:
12675 sections
.macinfo_offset
= offset
;
12676 sections
.macinfo_size
= size
;
12678 case DW_SECT_MACRO
:
12679 sections
.macro_offset
= offset
;
12680 sections
.macro_size
= size
;
12685 /* It's easier for the rest of the code if we fake a struct dwo_file and
12686 have dwo_unit "live" in that. At least for now.
12688 The DWP file can be made up of a random collection of CUs and TUs.
12689 However, for each CU + set of TUs that came from the same original DWO
12690 file, we can combine them back into a virtual DWO file to save space
12691 (fewer struct dwo_file objects to allocate). Remember that for really
12692 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12694 std::string virtual_dwo_name
=
12695 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12696 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12697 (long) (sections
.line_size
? sections
.line_offset
: 0),
12698 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
12699 (long) (sections
.str_offsets_size
12700 ? sections
.str_offsets_offset
: 0));
12701 /* Can we use an existing virtual DWO file? */
12702 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
12703 virtual_dwo_name
.c_str (),
12705 /* Create one if necessary. */
12706 if (*dwo_file_slot
== NULL
)
12708 if (dwarf_read_debug
)
12710 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12711 virtual_dwo_name
.c_str ());
12713 dwo_file
= new struct dwo_file
;
12714 dwo_file
->dwo_name
= obstack_strdup (&objfile
->objfile_obstack
,
12716 dwo_file
->comp_dir
= comp_dir
;
12717 dwo_file
->sections
.abbrev
=
12718 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.abbrev
,
12719 sections
.abbrev_offset
, sections
.abbrev_size
);
12720 dwo_file
->sections
.line
=
12721 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.line
,
12722 sections
.line_offset
, sections
.line_size
);
12723 dwo_file
->sections
.loc
=
12724 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.loc
,
12725 sections
.loc_offset
, sections
.loc_size
);
12726 dwo_file
->sections
.macinfo
=
12727 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macinfo
,
12728 sections
.macinfo_offset
, sections
.macinfo_size
);
12729 dwo_file
->sections
.macro
=
12730 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macro
,
12731 sections
.macro_offset
, sections
.macro_size
);
12732 dwo_file
->sections
.str_offsets
=
12733 create_dwp_v2_section (dwarf2_per_objfile
,
12734 &dwp_file
->sections
.str_offsets
,
12735 sections
.str_offsets_offset
,
12736 sections
.str_offsets_size
);
12737 /* The "str" section is global to the entire DWP file. */
12738 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12739 /* The info or types section is assigned below to dwo_unit,
12740 there's no need to record it in dwo_file.
12741 Also, we can't simply record type sections in dwo_file because
12742 we record a pointer into the vector in dwo_unit. As we collect more
12743 types we'll grow the vector and eventually have to reallocate space
12744 for it, invalidating all copies of pointers into the previous
12746 *dwo_file_slot
= dwo_file
;
12750 if (dwarf_read_debug
)
12752 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12753 virtual_dwo_name
.c_str ());
12755 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12758 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12759 dwo_unit
->dwo_file
= dwo_file
;
12760 dwo_unit
->signature
= signature
;
12761 dwo_unit
->section
=
12762 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
12763 *dwo_unit
->section
= create_dwp_v2_section (dwarf2_per_objfile
,
12765 ? &dwp_file
->sections
.types
12766 : &dwp_file
->sections
.info
,
12767 sections
.info_or_types_offset
,
12768 sections
.info_or_types_size
);
12769 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12774 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12775 Returns NULL if the signature isn't found. */
12777 static struct dwo_unit
*
12778 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12779 struct dwp_file
*dwp_file
, const char *comp_dir
,
12780 ULONGEST signature
, int is_debug_types
)
12782 const struct dwp_hash_table
*dwp_htab
=
12783 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12784 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12785 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12786 uint32_t hash
= signature
& mask
;
12787 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12790 struct dwo_unit find_dwo_cu
;
12792 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12793 find_dwo_cu
.signature
= signature
;
12794 slot
= htab_find_slot (is_debug_types
12795 ? dwp_file
->loaded_tus
12796 : dwp_file
->loaded_cus
,
12797 &find_dwo_cu
, INSERT
);
12800 return (struct dwo_unit
*) *slot
;
12802 /* Use a for loop so that we don't loop forever on bad debug info. */
12803 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12805 ULONGEST signature_in_table
;
12807 signature_in_table
=
12808 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12809 if (signature_in_table
== signature
)
12811 uint32_t unit_index
=
12812 read_4_bytes (dbfd
,
12813 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12815 if (dwp_file
->version
== 1)
12817 *slot
= create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
,
12818 dwp_file
, unit_index
,
12819 comp_dir
, signature
,
12824 *slot
= create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
,
12825 dwp_file
, unit_index
,
12826 comp_dir
, signature
,
12829 return (struct dwo_unit
*) *slot
;
12831 if (signature_in_table
== 0)
12833 hash
= (hash
+ hash2
) & mask
;
12836 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12837 " [in module %s]"),
12841 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12842 Open the file specified by FILE_NAME and hand it off to BFD for
12843 preliminary analysis. Return a newly initialized bfd *, which
12844 includes a canonicalized copy of FILE_NAME.
12845 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12846 SEARCH_CWD is true if the current directory is to be searched.
12847 It will be searched before debug-file-directory.
12848 If successful, the file is added to the bfd include table of the
12849 objfile's bfd (see gdb_bfd_record_inclusion).
12850 If unable to find/open the file, return NULL.
12851 NOTE: This function is derived from symfile_bfd_open. */
12853 static gdb_bfd_ref_ptr
12854 try_open_dwop_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12855 const char *file_name
, int is_dwp
, int search_cwd
)
12858 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12859 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12860 to debug_file_directory. */
12861 const char *search_path
;
12862 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12864 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12867 if (*debug_file_directory
!= '\0')
12869 search_path_holder
.reset (concat (".", dirname_separator_string
,
12870 debug_file_directory
,
12872 search_path
= search_path_holder
.get ();
12878 search_path
= debug_file_directory
;
12880 openp_flags flags
= OPF_RETURN_REALPATH
;
12882 flags
|= OPF_SEARCH_IN_PATH
;
12884 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12885 desc
= openp (search_path
, flags
, file_name
,
12886 O_RDONLY
| O_BINARY
, &absolute_name
);
12890 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12892 if (sym_bfd
== NULL
)
12894 bfd_set_cacheable (sym_bfd
.get (), 1);
12896 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12899 /* Success. Record the bfd as having been included by the objfile's bfd.
12900 This is important because things like demangled_names_hash lives in the
12901 objfile's per_bfd space and may have references to things like symbol
12902 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12903 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12908 /* Try to open DWO file FILE_NAME.
12909 COMP_DIR is the DW_AT_comp_dir attribute.
12910 The result is the bfd handle of the file.
12911 If there is a problem finding or opening the file, return NULL.
12912 Upon success, the canonicalized path of the file is stored in the bfd,
12913 same as symfile_bfd_open. */
12915 static gdb_bfd_ref_ptr
12916 open_dwo_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12917 const char *file_name
, const char *comp_dir
)
12919 if (IS_ABSOLUTE_PATH (file_name
))
12920 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12921 0 /*is_dwp*/, 0 /*search_cwd*/);
12923 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12925 if (comp_dir
!= NULL
)
12927 char *path_to_try
= concat (comp_dir
, SLASH_STRING
,
12928 file_name
, (char *) NULL
);
12930 /* NOTE: If comp_dir is a relative path, this will also try the
12931 search path, which seems useful. */
12932 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
,
12935 1 /*search_cwd*/));
12936 xfree (path_to_try
);
12941 /* That didn't work, try debug-file-directory, which, despite its name,
12942 is a list of paths. */
12944 if (*debug_file_directory
== '\0')
12947 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12948 0 /*is_dwp*/, 1 /*search_cwd*/);
12951 /* This function is mapped across the sections and remembers the offset and
12952 size of each of the DWO debugging sections we are interested in. */
12955 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
12957 struct dwo_sections
*dwo_sections
= (struct dwo_sections
*) dwo_sections_ptr
;
12958 const struct dwop_section_names
*names
= &dwop_section_names
;
12960 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12962 dwo_sections
->abbrev
.s
.section
= sectp
;
12963 dwo_sections
->abbrev
.size
= bfd_section_size (sectp
);
12965 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12967 dwo_sections
->info
.s
.section
= sectp
;
12968 dwo_sections
->info
.size
= bfd_section_size (sectp
);
12970 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12972 dwo_sections
->line
.s
.section
= sectp
;
12973 dwo_sections
->line
.size
= bfd_section_size (sectp
);
12975 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12977 dwo_sections
->loc
.s
.section
= sectp
;
12978 dwo_sections
->loc
.size
= bfd_section_size (sectp
);
12980 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12982 dwo_sections
->macinfo
.s
.section
= sectp
;
12983 dwo_sections
->macinfo
.size
= bfd_section_size (sectp
);
12985 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12987 dwo_sections
->macro
.s
.section
= sectp
;
12988 dwo_sections
->macro
.size
= bfd_section_size (sectp
);
12990 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
12992 dwo_sections
->str
.s
.section
= sectp
;
12993 dwo_sections
->str
.size
= bfd_section_size (sectp
);
12995 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12997 dwo_sections
->str_offsets
.s
.section
= sectp
;
12998 dwo_sections
->str_offsets
.size
= bfd_section_size (sectp
);
13000 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
13002 struct dwarf2_section_info type_section
;
13004 memset (&type_section
, 0, sizeof (type_section
));
13005 type_section
.s
.section
= sectp
;
13006 type_section
.size
= bfd_section_size (sectp
);
13007 dwo_sections
->types
.push_back (type_section
);
13011 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
13012 by PER_CU. This is for the non-DWP case.
13013 The result is NULL if DWO_NAME can't be found. */
13015 static struct dwo_file
*
13016 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
13017 const char *dwo_name
, const char *comp_dir
)
13019 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
13021 gdb_bfd_ref_ptr dbfd
= open_dwo_file (dwarf2_per_objfile
, dwo_name
, comp_dir
);
13024 if (dwarf_read_debug
)
13025 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
13029 dwo_file_up
dwo_file (new struct dwo_file
);
13030 dwo_file
->dwo_name
= dwo_name
;
13031 dwo_file
->comp_dir
= comp_dir
;
13032 dwo_file
->dbfd
= std::move (dbfd
);
13034 bfd_map_over_sections (dwo_file
->dbfd
.get (), dwarf2_locate_dwo_sections
,
13035 &dwo_file
->sections
);
13037 create_cus_hash_table (dwarf2_per_objfile
, *dwo_file
, dwo_file
->sections
.info
,
13040 create_debug_types_hash_table (dwarf2_per_objfile
, dwo_file
.get (),
13041 dwo_file
->sections
.types
, dwo_file
->tus
);
13043 if (dwarf_read_debug
)
13044 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
13046 return dwo_file
.release ();
13049 /* This function is mapped across the sections and remembers the offset and
13050 size of each of the DWP debugging sections common to version 1 and 2 that
13051 we are interested in. */
13054 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
13055 void *dwp_file_ptr
)
13057 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
13058 const struct dwop_section_names
*names
= &dwop_section_names
;
13059 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
13061 /* Record the ELF section number for later lookup: this is what the
13062 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13063 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
13064 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
13066 /* Look for specific sections that we need. */
13067 if (section_is_p (sectp
->name
, &names
->str_dwo
))
13069 dwp_file
->sections
.str
.s
.section
= sectp
;
13070 dwp_file
->sections
.str
.size
= bfd_section_size (sectp
);
13072 else if (section_is_p (sectp
->name
, &names
->cu_index
))
13074 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
13075 dwp_file
->sections
.cu_index
.size
= bfd_section_size (sectp
);
13077 else if (section_is_p (sectp
->name
, &names
->tu_index
))
13079 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
13080 dwp_file
->sections
.tu_index
.size
= bfd_section_size (sectp
);
13084 /* This function is mapped across the sections and remembers the offset and
13085 size of each of the DWP version 2 debugging sections that we are interested
13086 in. This is split into a separate function because we don't know if we
13087 have version 1 or 2 until we parse the cu_index/tu_index sections. */
13090 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
13092 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
13093 const struct dwop_section_names
*names
= &dwop_section_names
;
13094 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
13096 /* Record the ELF section number for later lookup: this is what the
13097 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13098 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
13099 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
13101 /* Look for specific sections that we need. */
13102 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
13104 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
13105 dwp_file
->sections
.abbrev
.size
= bfd_section_size (sectp
);
13107 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
13109 dwp_file
->sections
.info
.s
.section
= sectp
;
13110 dwp_file
->sections
.info
.size
= bfd_section_size (sectp
);
13112 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
13114 dwp_file
->sections
.line
.s
.section
= sectp
;
13115 dwp_file
->sections
.line
.size
= bfd_section_size (sectp
);
13117 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
13119 dwp_file
->sections
.loc
.s
.section
= sectp
;
13120 dwp_file
->sections
.loc
.size
= bfd_section_size (sectp
);
13122 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
13124 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
13125 dwp_file
->sections
.macinfo
.size
= bfd_section_size (sectp
);
13127 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
13129 dwp_file
->sections
.macro
.s
.section
= sectp
;
13130 dwp_file
->sections
.macro
.size
= bfd_section_size (sectp
);
13132 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
13134 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
13135 dwp_file
->sections
.str_offsets
.size
= bfd_section_size (sectp
);
13137 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
13139 dwp_file
->sections
.types
.s
.section
= sectp
;
13140 dwp_file
->sections
.types
.size
= bfd_section_size (sectp
);
13144 /* Hash function for dwp_file loaded CUs/TUs. */
13147 hash_dwp_loaded_cutus (const void *item
)
13149 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
13151 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13152 return dwo_unit
->signature
;
13155 /* Equality function for dwp_file loaded CUs/TUs. */
13158 eq_dwp_loaded_cutus (const void *a
, const void *b
)
13160 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
13161 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
13163 return dua
->signature
== dub
->signature
;
13166 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13169 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
13171 return htab_create_alloc_ex (3,
13172 hash_dwp_loaded_cutus
,
13173 eq_dwp_loaded_cutus
,
13175 &objfile
->objfile_obstack
,
13176 hashtab_obstack_allocate
,
13177 dummy_obstack_deallocate
);
13180 /* Try to open DWP file FILE_NAME.
13181 The result is the bfd handle of the file.
13182 If there is a problem finding or opening the file, return NULL.
13183 Upon success, the canonicalized path of the file is stored in the bfd,
13184 same as symfile_bfd_open. */
13186 static gdb_bfd_ref_ptr
13187 open_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
13188 const char *file_name
)
13190 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
, file_name
,
13192 1 /*search_cwd*/));
13196 /* Work around upstream bug 15652.
13197 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13198 [Whether that's a "bug" is debatable, but it is getting in our way.]
13199 We have no real idea where the dwp file is, because gdb's realpath-ing
13200 of the executable's path may have discarded the needed info.
13201 [IWBN if the dwp file name was recorded in the executable, akin to
13202 .gnu_debuglink, but that doesn't exist yet.]
13203 Strip the directory from FILE_NAME and search again. */
13204 if (*debug_file_directory
!= '\0')
13206 /* Don't implicitly search the current directory here.
13207 If the user wants to search "." to handle this case,
13208 it must be added to debug-file-directory. */
13209 return try_open_dwop_file (dwarf2_per_objfile
,
13210 lbasename (file_name
), 1 /*is_dwp*/,
13217 /* Initialize the use of the DWP file for the current objfile.
13218 By convention the name of the DWP file is ${objfile}.dwp.
13219 The result is NULL if it can't be found. */
13221 static std::unique_ptr
<struct dwp_file
>
13222 open_and_init_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
13224 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13226 /* Try to find first .dwp for the binary file before any symbolic links
13229 /* If the objfile is a debug file, find the name of the real binary
13230 file and get the name of dwp file from there. */
13231 std::string dwp_name
;
13232 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
13234 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
13235 const char *backlink_basename
= lbasename (backlink
->original_name
);
13237 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
13240 dwp_name
= objfile
->original_name
;
13242 dwp_name
+= ".dwp";
13244 gdb_bfd_ref_ptr
dbfd (open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ()));
13246 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
13248 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13249 dwp_name
= objfile_name (objfile
);
13250 dwp_name
+= ".dwp";
13251 dbfd
= open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ());
13256 if (dwarf_read_debug
)
13257 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
.c_str ());
13258 return std::unique_ptr
<dwp_file
> ();
13261 const char *name
= bfd_get_filename (dbfd
.get ());
13262 std::unique_ptr
<struct dwp_file
> dwp_file
13263 (new struct dwp_file (name
, std::move (dbfd
)));
13265 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
13266 dwp_file
->elf_sections
=
13267 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
13268 dwp_file
->num_sections
, asection
*);
13270 bfd_map_over_sections (dwp_file
->dbfd
.get (),
13271 dwarf2_locate_common_dwp_sections
,
13274 dwp_file
->cus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
.get (),
13277 dwp_file
->tus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
.get (),
13280 /* The DWP file version is stored in the hash table. Oh well. */
13281 if (dwp_file
->cus
&& dwp_file
->tus
13282 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
13284 /* Technically speaking, we should try to limp along, but this is
13285 pretty bizarre. We use pulongest here because that's the established
13286 portability solution (e.g, we cannot use %u for uint32_t). */
13287 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13288 " TU version %s [in DWP file %s]"),
13289 pulongest (dwp_file
->cus
->version
),
13290 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
13294 dwp_file
->version
= dwp_file
->cus
->version
;
13295 else if (dwp_file
->tus
)
13296 dwp_file
->version
= dwp_file
->tus
->version
;
13298 dwp_file
->version
= 2;
13300 if (dwp_file
->version
== 2)
13301 bfd_map_over_sections (dwp_file
->dbfd
.get (),
13302 dwarf2_locate_v2_dwp_sections
,
13305 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table (objfile
);
13306 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table (objfile
);
13308 if (dwarf_read_debug
)
13310 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
13311 fprintf_unfiltered (gdb_stdlog
,
13312 " %s CUs, %s TUs\n",
13313 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
13314 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
13320 /* Wrapper around open_and_init_dwp_file, only open it once. */
13322 static struct dwp_file
*
13323 get_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
13325 if (! dwarf2_per_objfile
->dwp_checked
)
13327 dwarf2_per_objfile
->dwp_file
13328 = open_and_init_dwp_file (dwarf2_per_objfile
);
13329 dwarf2_per_objfile
->dwp_checked
= 1;
13331 return dwarf2_per_objfile
->dwp_file
.get ();
13334 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13335 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13336 or in the DWP file for the objfile, referenced by THIS_UNIT.
13337 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13338 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13340 This is called, for example, when wanting to read a variable with a
13341 complex location. Therefore we don't want to do file i/o for every call.
13342 Therefore we don't want to look for a DWO file on every call.
13343 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13344 then we check if we've already seen DWO_NAME, and only THEN do we check
13347 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13348 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13350 static struct dwo_unit
*
13351 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
13352 const char *dwo_name
, const char *comp_dir
,
13353 ULONGEST signature
, int is_debug_types
)
13355 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_unit
->dwarf2_per_objfile
;
13356 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13357 const char *kind
= is_debug_types
? "TU" : "CU";
13358 void **dwo_file_slot
;
13359 struct dwo_file
*dwo_file
;
13360 struct dwp_file
*dwp_file
;
13362 /* First see if there's a DWP file.
13363 If we have a DWP file but didn't find the DWO inside it, don't
13364 look for the original DWO file. It makes gdb behave differently
13365 depending on whether one is debugging in the build tree. */
13367 dwp_file
= get_dwp_file (dwarf2_per_objfile
);
13368 if (dwp_file
!= NULL
)
13370 const struct dwp_hash_table
*dwp_htab
=
13371 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
13373 if (dwp_htab
!= NULL
)
13375 struct dwo_unit
*dwo_cutu
=
13376 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, comp_dir
,
13377 signature
, is_debug_types
);
13379 if (dwo_cutu
!= NULL
)
13381 if (dwarf_read_debug
)
13383 fprintf_unfiltered (gdb_stdlog
,
13384 "Virtual DWO %s %s found: @%s\n",
13385 kind
, hex_string (signature
),
13386 host_address_to_string (dwo_cutu
));
13394 /* No DWP file, look for the DWO file. */
13396 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
13397 dwo_name
, comp_dir
);
13398 if (*dwo_file_slot
== NULL
)
13400 /* Read in the file and build a table of the CUs/TUs it contains. */
13401 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
13403 /* NOTE: This will be NULL if unable to open the file. */
13404 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
13406 if (dwo_file
!= NULL
)
13408 struct dwo_unit
*dwo_cutu
= NULL
;
13410 if (is_debug_types
&& dwo_file
->tus
)
13412 struct dwo_unit find_dwo_cutu
;
13414 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13415 find_dwo_cutu
.signature
= signature
;
13417 = (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_cutu
);
13419 else if (!is_debug_types
&& dwo_file
->cus
)
13421 struct dwo_unit find_dwo_cutu
;
13423 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13424 find_dwo_cutu
.signature
= signature
;
13425 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
,
13429 if (dwo_cutu
!= NULL
)
13431 if (dwarf_read_debug
)
13433 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
13434 kind
, dwo_name
, hex_string (signature
),
13435 host_address_to_string (dwo_cutu
));
13442 /* We didn't find it. This could mean a dwo_id mismatch, or
13443 someone deleted the DWO/DWP file, or the search path isn't set up
13444 correctly to find the file. */
13446 if (dwarf_read_debug
)
13448 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
13449 kind
, dwo_name
, hex_string (signature
));
13452 /* This is a warning and not a complaint because it can be caused by
13453 pilot error (e.g., user accidentally deleting the DWO). */
13455 /* Print the name of the DWP file if we looked there, helps the user
13456 better diagnose the problem. */
13457 std::string dwp_text
;
13459 if (dwp_file
!= NULL
)
13460 dwp_text
= string_printf (" [in DWP file %s]",
13461 lbasename (dwp_file
->name
));
13463 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13464 " [in module %s]"),
13465 kind
, dwo_name
, hex_string (signature
),
13467 this_unit
->is_debug_types
? "TU" : "CU",
13468 sect_offset_str (this_unit
->sect_off
), objfile_name (objfile
));
13473 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13474 See lookup_dwo_cutu_unit for details. */
13476 static struct dwo_unit
*
13477 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
13478 const char *dwo_name
, const char *comp_dir
,
13479 ULONGEST signature
)
13481 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
13484 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13485 See lookup_dwo_cutu_unit for details. */
13487 static struct dwo_unit
*
13488 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
13489 const char *dwo_name
, const char *comp_dir
)
13491 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
13494 /* Traversal function for queue_and_load_all_dwo_tus. */
13497 queue_and_load_dwo_tu (void **slot
, void *info
)
13499 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
13500 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
13501 ULONGEST signature
= dwo_unit
->signature
;
13502 struct signatured_type
*sig_type
=
13503 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
13505 if (sig_type
!= NULL
)
13507 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
13509 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13510 a real dependency of PER_CU on SIG_TYPE. That is detected later
13511 while processing PER_CU. */
13512 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
13513 load_full_type_unit (sig_cu
);
13514 VEC_safe_push (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, sig_cu
);
13520 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13521 The DWO may have the only definition of the type, though it may not be
13522 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13523 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13526 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
13528 struct dwo_unit
*dwo_unit
;
13529 struct dwo_file
*dwo_file
;
13531 gdb_assert (!per_cu
->is_debug_types
);
13532 gdb_assert (get_dwp_file (per_cu
->dwarf2_per_objfile
) == NULL
);
13533 gdb_assert (per_cu
->cu
!= NULL
);
13535 dwo_unit
= per_cu
->cu
->dwo_unit
;
13536 gdb_assert (dwo_unit
!= NULL
);
13538 dwo_file
= dwo_unit
->dwo_file
;
13539 if (dwo_file
->tus
!= NULL
)
13540 htab_traverse_noresize (dwo_file
->tus
, queue_and_load_dwo_tu
, per_cu
);
13543 /* Read in various DIEs. */
13545 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13546 Inherit only the children of the DW_AT_abstract_origin DIE not being
13547 already referenced by DW_AT_abstract_origin from the children of the
13551 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
13553 struct die_info
*child_die
;
13554 sect_offset
*offsetp
;
13555 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13556 struct die_info
*origin_die
;
13557 /* Iterator of the ORIGIN_DIE children. */
13558 struct die_info
*origin_child_die
;
13559 struct attribute
*attr
;
13560 struct dwarf2_cu
*origin_cu
;
13561 struct pending
**origin_previous_list_in_scope
;
13563 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13567 /* Note that following die references may follow to a die in a
13571 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
13573 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13575 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
13576 origin_cu
->list_in_scope
= cu
->list_in_scope
;
13578 if (die
->tag
!= origin_die
->tag
13579 && !(die
->tag
== DW_TAG_inlined_subroutine
13580 && origin_die
->tag
== DW_TAG_subprogram
))
13581 complaint (_("DIE %s and its abstract origin %s have different tags"),
13582 sect_offset_str (die
->sect_off
),
13583 sect_offset_str (origin_die
->sect_off
));
13585 std::vector
<sect_offset
> offsets
;
13587 for (child_die
= die
->child
;
13588 child_die
&& child_die
->tag
;
13589 child_die
= sibling_die (child_die
))
13591 struct die_info
*child_origin_die
;
13592 struct dwarf2_cu
*child_origin_cu
;
13594 /* We are trying to process concrete instance entries:
13595 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13596 it's not relevant to our analysis here. i.e. detecting DIEs that are
13597 present in the abstract instance but not referenced in the concrete
13599 if (child_die
->tag
== DW_TAG_call_site
13600 || child_die
->tag
== DW_TAG_GNU_call_site
)
13603 /* For each CHILD_DIE, find the corresponding child of
13604 ORIGIN_DIE. If there is more than one layer of
13605 DW_AT_abstract_origin, follow them all; there shouldn't be,
13606 but GCC versions at least through 4.4 generate this (GCC PR
13608 child_origin_die
= child_die
;
13609 child_origin_cu
= cu
;
13612 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
13616 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
13620 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13621 counterpart may exist. */
13622 if (child_origin_die
!= child_die
)
13624 if (child_die
->tag
!= child_origin_die
->tag
13625 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13626 && child_origin_die
->tag
== DW_TAG_subprogram
))
13627 complaint (_("Child DIE %s and its abstract origin %s have "
13629 sect_offset_str (child_die
->sect_off
),
13630 sect_offset_str (child_origin_die
->sect_off
));
13631 if (child_origin_die
->parent
!= origin_die
)
13632 complaint (_("Child DIE %s and its abstract origin %s have "
13633 "different parents"),
13634 sect_offset_str (child_die
->sect_off
),
13635 sect_offset_str (child_origin_die
->sect_off
));
13637 offsets
.push_back (child_origin_die
->sect_off
);
13640 std::sort (offsets
.begin (), offsets
.end ());
13641 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13642 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13643 if (offsetp
[-1] == *offsetp
)
13644 complaint (_("Multiple children of DIE %s refer "
13645 "to DIE %s as their abstract origin"),
13646 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
13648 offsetp
= offsets
.data ();
13649 origin_child_die
= origin_die
->child
;
13650 while (origin_child_die
&& origin_child_die
->tag
)
13652 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13653 while (offsetp
< offsets_end
13654 && *offsetp
< origin_child_die
->sect_off
)
13656 if (offsetp
>= offsets_end
13657 || *offsetp
> origin_child_die
->sect_off
)
13659 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13660 Check whether we're already processing ORIGIN_CHILD_DIE.
13661 This can happen with mutually referenced abstract_origins.
13663 if (!origin_child_die
->in_process
)
13664 process_die (origin_child_die
, origin_cu
);
13666 origin_child_die
= sibling_die (origin_child_die
);
13668 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13672 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13674 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13675 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13676 struct context_stack
*newobj
;
13679 struct die_info
*child_die
;
13680 struct attribute
*attr
, *call_line
, *call_file
;
13682 CORE_ADDR baseaddr
;
13683 struct block
*block
;
13684 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13685 std::vector
<struct symbol
*> template_args
;
13686 struct template_symbol
*templ_func
= NULL
;
13690 /* If we do not have call site information, we can't show the
13691 caller of this inlined function. That's too confusing, so
13692 only use the scope for local variables. */
13693 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13694 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13695 if (call_line
== NULL
|| call_file
== NULL
)
13697 read_lexical_block_scope (die
, cu
);
13702 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13704 name
= dwarf2_name (die
, cu
);
13706 /* Ignore functions with missing or empty names. These are actually
13707 illegal according to the DWARF standard. */
13710 complaint (_("missing name for subprogram DIE at %s"),
13711 sect_offset_str (die
->sect_off
));
13715 /* Ignore functions with missing or invalid low and high pc attributes. */
13716 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13717 <= PC_BOUNDS_INVALID
)
13719 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13720 if (!attr
|| !DW_UNSND (attr
))
13721 complaint (_("cannot get low and high bounds "
13722 "for subprogram DIE at %s"),
13723 sect_offset_str (die
->sect_off
));
13727 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13728 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13730 /* If we have any template arguments, then we must allocate a
13731 different sort of symbol. */
13732 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
13734 if (child_die
->tag
== DW_TAG_template_type_param
13735 || child_die
->tag
== DW_TAG_template_value_param
)
13737 templ_func
= allocate_template_symbol (objfile
);
13738 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13743 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13744 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13745 (struct symbol
*) templ_func
);
13747 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13748 set_objfile_main_name (objfile
, SYMBOL_LINKAGE_NAME (newobj
->name
),
13751 /* If there is a location expression for DW_AT_frame_base, record
13753 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13755 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13757 /* If there is a location for the static link, record it. */
13758 newobj
->static_link
= NULL
;
13759 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13762 newobj
->static_link
13763 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13764 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
13765 dwarf2_per_cu_addr_type (cu
->per_cu
));
13768 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13770 if (die
->child
!= NULL
)
13772 child_die
= die
->child
;
13773 while (child_die
&& child_die
->tag
)
13775 if (child_die
->tag
== DW_TAG_template_type_param
13776 || child_die
->tag
== DW_TAG_template_value_param
)
13778 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13781 template_args
.push_back (arg
);
13784 process_die (child_die
, cu
);
13785 child_die
= sibling_die (child_die
);
13789 inherit_abstract_dies (die
, cu
);
13791 /* If we have a DW_AT_specification, we might need to import using
13792 directives from the context of the specification DIE. See the
13793 comment in determine_prefix. */
13794 if (cu
->language
== language_cplus
13795 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13797 struct dwarf2_cu
*spec_cu
= cu
;
13798 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13802 child_die
= spec_die
->child
;
13803 while (child_die
&& child_die
->tag
)
13805 if (child_die
->tag
== DW_TAG_imported_module
)
13806 process_die (child_die
, spec_cu
);
13807 child_die
= sibling_die (child_die
);
13810 /* In some cases, GCC generates specification DIEs that
13811 themselves contain DW_AT_specification attributes. */
13812 spec_die
= die_specification (spec_die
, &spec_cu
);
13816 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13817 /* Make a block for the local symbols within. */
13818 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13819 cstk
.static_link
, lowpc
, highpc
);
13821 /* For C++, set the block's scope. */
13822 if ((cu
->language
== language_cplus
13823 || cu
->language
== language_fortran
13824 || cu
->language
== language_d
13825 || cu
->language
== language_rust
)
13826 && cu
->processing_has_namespace_info
)
13827 block_set_scope (block
, determine_prefix (die
, cu
),
13828 &objfile
->objfile_obstack
);
13830 /* If we have address ranges, record them. */
13831 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13833 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13835 /* Attach template arguments to function. */
13836 if (!template_args
.empty ())
13838 gdb_assert (templ_func
!= NULL
);
13840 templ_func
->n_template_arguments
= template_args
.size ();
13841 templ_func
->template_arguments
13842 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13843 templ_func
->n_template_arguments
);
13844 memcpy (templ_func
->template_arguments
,
13845 template_args
.data (),
13846 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13848 /* Make sure that the symtab is set on the new symbols. Even
13849 though they don't appear in this symtab directly, other parts
13850 of gdb assume that symbols do, and this is reasonably
13852 for (symbol
*sym
: template_args
)
13853 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13856 /* In C++, we can have functions nested inside functions (e.g., when
13857 a function declares a class that has methods). This means that
13858 when we finish processing a function scope, we may need to go
13859 back to building a containing block's symbol lists. */
13860 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13861 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13863 /* If we've finished processing a top-level function, subsequent
13864 symbols go in the file symbol list. */
13865 if (cu
->get_builder ()->outermost_context_p ())
13866 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13869 /* Process all the DIES contained within a lexical block scope. Start
13870 a new scope, process the dies, and then close the scope. */
13873 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13875 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13876 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13877 CORE_ADDR lowpc
, highpc
;
13878 struct die_info
*child_die
;
13879 CORE_ADDR baseaddr
;
13881 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13883 /* Ignore blocks with missing or invalid low and high pc attributes. */
13884 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13885 as multiple lexical blocks? Handling children in a sane way would
13886 be nasty. Might be easier to properly extend generic blocks to
13887 describe ranges. */
13888 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13890 case PC_BOUNDS_NOT_PRESENT
:
13891 /* DW_TAG_lexical_block has no attributes, process its children as if
13892 there was no wrapping by that DW_TAG_lexical_block.
13893 GCC does no longer produces such DWARF since GCC r224161. */
13894 for (child_die
= die
->child
;
13895 child_die
!= NULL
&& child_die
->tag
;
13896 child_die
= sibling_die (child_die
))
13897 process_die (child_die
, cu
);
13899 case PC_BOUNDS_INVALID
:
13902 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13903 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13905 cu
->get_builder ()->push_context (0, lowpc
);
13906 if (die
->child
!= NULL
)
13908 child_die
= die
->child
;
13909 while (child_die
&& child_die
->tag
)
13911 process_die (child_die
, cu
);
13912 child_die
= sibling_die (child_die
);
13915 inherit_abstract_dies (die
, cu
);
13916 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13918 if (*cu
->get_builder ()->get_local_symbols () != NULL
13919 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13921 struct block
*block
13922 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13923 cstk
.start_addr
, highpc
);
13925 /* Note that recording ranges after traversing children, as we
13926 do here, means that recording a parent's ranges entails
13927 walking across all its children's ranges as they appear in
13928 the address map, which is quadratic behavior.
13930 It would be nicer to record the parent's ranges before
13931 traversing its children, simply overriding whatever you find
13932 there. But since we don't even decide whether to create a
13933 block until after we've traversed its children, that's hard
13935 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13937 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13938 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13941 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13944 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13946 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13947 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13948 CORE_ADDR pc
, baseaddr
;
13949 struct attribute
*attr
;
13950 struct call_site
*call_site
, call_site_local
;
13953 struct die_info
*child_die
;
13955 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13957 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13960 /* This was a pre-DWARF-5 GNU extension alias
13961 for DW_AT_call_return_pc. */
13962 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13966 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13967 "DIE %s [in module %s]"),
13968 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13971 pc
= attr_value_as_address (attr
) + baseaddr
;
13972 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13974 if (cu
->call_site_htab
== NULL
)
13975 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13976 NULL
, &objfile
->objfile_obstack
,
13977 hashtab_obstack_allocate
, NULL
);
13978 call_site_local
.pc
= pc
;
13979 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13982 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13983 "DIE %s [in module %s]"),
13984 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13985 objfile_name (objfile
));
13989 /* Count parameters at the caller. */
13992 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13993 child_die
= sibling_die (child_die
))
13995 if (child_die
->tag
!= DW_TAG_call_site_parameter
13996 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13998 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13999 "DW_TAG_call_site child DIE %s [in module %s]"),
14000 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
14001 objfile_name (objfile
));
14009 = ((struct call_site
*)
14010 obstack_alloc (&objfile
->objfile_obstack
,
14011 sizeof (*call_site
)
14012 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
14014 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
14015 call_site
->pc
= pc
;
14017 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
14018 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
14020 struct die_info
*func_die
;
14022 /* Skip also over DW_TAG_inlined_subroutine. */
14023 for (func_die
= die
->parent
;
14024 func_die
&& func_die
->tag
!= DW_TAG_subprogram
14025 && func_die
->tag
!= DW_TAG_subroutine_type
;
14026 func_die
= func_die
->parent
);
14028 /* DW_AT_call_all_calls is a superset
14029 of DW_AT_call_all_tail_calls. */
14031 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
14032 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
14033 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
14034 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
14036 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
14037 not complete. But keep CALL_SITE for look ups via call_site_htab,
14038 both the initial caller containing the real return address PC and
14039 the final callee containing the current PC of a chain of tail
14040 calls do not need to have the tail call list complete. But any
14041 function candidate for a virtual tail call frame searched via
14042 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14043 determined unambiguously. */
14047 struct type
*func_type
= NULL
;
14050 func_type
= get_die_type (func_die
, cu
);
14051 if (func_type
!= NULL
)
14053 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
14055 /* Enlist this call site to the function. */
14056 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
14057 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
14060 complaint (_("Cannot find function owning DW_TAG_call_site "
14061 "DIE %s [in module %s]"),
14062 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14066 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
14068 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
14070 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
14073 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
14074 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14076 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
14077 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
14078 /* Keep NULL DWARF_BLOCK. */;
14079 else if (attr_form_is_block (attr
))
14081 struct dwarf2_locexpr_baton
*dlbaton
;
14083 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
14084 dlbaton
->data
= DW_BLOCK (attr
)->data
;
14085 dlbaton
->size
= DW_BLOCK (attr
)->size
;
14086 dlbaton
->per_cu
= cu
->per_cu
;
14088 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
14090 else if (attr_form_is_ref (attr
))
14092 struct dwarf2_cu
*target_cu
= cu
;
14093 struct die_info
*target_die
;
14095 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14096 gdb_assert (target_cu
->per_cu
->dwarf2_per_objfile
->objfile
== objfile
);
14097 if (die_is_declaration (target_die
, target_cu
))
14099 const char *target_physname
;
14101 /* Prefer the mangled name; otherwise compute the demangled one. */
14102 target_physname
= dw2_linkage_name (target_die
, target_cu
);
14103 if (target_physname
== NULL
)
14104 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
14105 if (target_physname
== NULL
)
14106 complaint (_("DW_AT_call_target target DIE has invalid "
14107 "physname, for referencing DIE %s [in module %s]"),
14108 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14110 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
14116 /* DW_AT_entry_pc should be preferred. */
14117 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
14118 <= PC_BOUNDS_INVALID
)
14119 complaint (_("DW_AT_call_target target DIE has invalid "
14120 "low pc, for referencing DIE %s [in module %s]"),
14121 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14124 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
14125 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
14130 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14131 "block nor reference, for DIE %s [in module %s]"),
14132 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14134 call_site
->per_cu
= cu
->per_cu
;
14136 for (child_die
= die
->child
;
14137 child_die
&& child_die
->tag
;
14138 child_die
= sibling_die (child_die
))
14140 struct call_site_parameter
*parameter
;
14141 struct attribute
*loc
, *origin
;
14143 if (child_die
->tag
!= DW_TAG_call_site_parameter
14144 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14146 /* Already printed the complaint above. */
14150 gdb_assert (call_site
->parameter_count
< nparams
);
14151 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
14153 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14154 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14155 register is contained in DW_AT_call_value. */
14157 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
14158 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
14159 if (origin
== NULL
)
14161 /* This was a pre-DWARF-5 GNU extension alias
14162 for DW_AT_call_parameter. */
14163 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
14165 if (loc
== NULL
&& origin
!= NULL
&& attr_form_is_ref (origin
))
14167 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
14169 sect_offset sect_off
14170 = (sect_offset
) dwarf2_get_ref_die_offset (origin
);
14171 if (!offset_in_cu_p (&cu
->header
, sect_off
))
14173 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14174 binding can be done only inside one CU. Such referenced DIE
14175 therefore cannot be even moved to DW_TAG_partial_unit. */
14176 complaint (_("DW_AT_call_parameter offset is not in CU for "
14177 "DW_TAG_call_site child DIE %s [in module %s]"),
14178 sect_offset_str (child_die
->sect_off
),
14179 objfile_name (objfile
));
14182 parameter
->u
.param_cu_off
14183 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
14185 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
14187 complaint (_("No DW_FORM_block* DW_AT_location for "
14188 "DW_TAG_call_site child DIE %s [in module %s]"),
14189 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
14194 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
14195 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
14196 if (parameter
->u
.dwarf_reg
!= -1)
14197 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
14198 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
14199 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
14200 ¶meter
->u
.fb_offset
))
14201 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
14204 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14205 "for DW_FORM_block* DW_AT_location is supported for "
14206 "DW_TAG_call_site child DIE %s "
14208 sect_offset_str (child_die
->sect_off
),
14209 objfile_name (objfile
));
14214 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
14216 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
14217 if (!attr_form_is_block (attr
))
14219 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14220 "DW_TAG_call_site child DIE %s [in module %s]"),
14221 sect_offset_str (child_die
->sect_off
),
14222 objfile_name (objfile
));
14225 parameter
->value
= DW_BLOCK (attr
)->data
;
14226 parameter
->value_size
= DW_BLOCK (attr
)->size
;
14228 /* Parameters are not pre-cleared by memset above. */
14229 parameter
->data_value
= NULL
;
14230 parameter
->data_value_size
= 0;
14231 call_site
->parameter_count
++;
14233 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
14235 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
14238 if (!attr_form_is_block (attr
))
14239 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14240 "DW_TAG_call_site child DIE %s [in module %s]"),
14241 sect_offset_str (child_die
->sect_off
),
14242 objfile_name (objfile
));
14245 parameter
->data_value
= DW_BLOCK (attr
)->data
;
14246 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
14252 /* Helper function for read_variable. If DIE represents a virtual
14253 table, then return the type of the concrete object that is
14254 associated with the virtual table. Otherwise, return NULL. */
14256 static struct type
*
14257 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14259 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
14263 /* Find the type DIE. */
14264 struct die_info
*type_die
= NULL
;
14265 struct dwarf2_cu
*type_cu
= cu
;
14267 if (attr_form_is_ref (attr
))
14268 type_die
= follow_die_ref (die
, attr
, &type_cu
);
14269 if (type_die
== NULL
)
14272 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
14274 return die_containing_type (type_die
, type_cu
);
14277 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14280 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
14282 struct rust_vtable_symbol
*storage
= NULL
;
14284 if (cu
->language
== language_rust
)
14286 struct type
*containing_type
= rust_containing_type (die
, cu
);
14288 if (containing_type
!= NULL
)
14290 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14292 storage
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
14293 struct rust_vtable_symbol
);
14294 initialize_objfile_symbol (storage
);
14295 storage
->concrete_type
= containing_type
;
14296 storage
->subclass
= SYMBOL_RUST_VTABLE
;
14300 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
14301 struct attribute
*abstract_origin
14302 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14303 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
14304 if (res
== NULL
&& loc
&& abstract_origin
)
14306 /* We have a variable without a name, but with a location and an abstract
14307 origin. This may be a concrete instance of an abstract variable
14308 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14310 struct dwarf2_cu
*origin_cu
= cu
;
14311 struct die_info
*origin_die
14312 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
14313 dwarf2_per_objfile
*dpo
= cu
->per_cu
->dwarf2_per_objfile
;
14314 dpo
->abstract_to_concrete
[origin_die
->sect_off
].push_back (die
->sect_off
);
14318 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14319 reading .debug_rnglists.
14320 Callback's type should be:
14321 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14322 Return true if the attributes are present and valid, otherwise,
14325 template <typename Callback
>
14327 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
14328 Callback
&&callback
)
14330 struct dwarf2_per_objfile
*dwarf2_per_objfile
14331 = cu
->per_cu
->dwarf2_per_objfile
;
14332 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14333 bfd
*obfd
= objfile
->obfd
;
14334 /* Base address selection entry. */
14337 const gdb_byte
*buffer
;
14338 CORE_ADDR baseaddr
;
14339 bool overflow
= false;
14341 found_base
= cu
->base_known
;
14342 base
= cu
->base_address
;
14344 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->rnglists
);
14345 if (offset
>= dwarf2_per_objfile
->rnglists
.size
)
14347 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14351 buffer
= dwarf2_per_objfile
->rnglists
.buffer
+ offset
;
14353 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14357 /* Initialize it due to a false compiler warning. */
14358 CORE_ADDR range_beginning
= 0, range_end
= 0;
14359 const gdb_byte
*buf_end
= (dwarf2_per_objfile
->rnglists
.buffer
14360 + dwarf2_per_objfile
->rnglists
.size
);
14361 unsigned int bytes_read
;
14363 if (buffer
== buf_end
)
14368 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
14371 case DW_RLE_end_of_list
:
14373 case DW_RLE_base_address
:
14374 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14379 base
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14381 buffer
+= bytes_read
;
14383 case DW_RLE_start_length
:
14384 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14389 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14390 buffer
+= bytes_read
;
14391 range_end
= (range_beginning
14392 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14393 buffer
+= bytes_read
;
14394 if (buffer
> buf_end
)
14400 case DW_RLE_offset_pair
:
14401 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14402 buffer
+= bytes_read
;
14403 if (buffer
> buf_end
)
14408 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14409 buffer
+= bytes_read
;
14410 if (buffer
> buf_end
)
14416 case DW_RLE_start_end
:
14417 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
14422 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14423 buffer
+= bytes_read
;
14424 range_end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14425 buffer
+= bytes_read
;
14428 complaint (_("Invalid .debug_rnglists data (no base address)"));
14431 if (rlet
== DW_RLE_end_of_list
|| overflow
)
14433 if (rlet
== DW_RLE_base_address
)
14438 /* We have no valid base address for the ranges
14440 complaint (_("Invalid .debug_rnglists data (no base address)"));
14444 if (range_beginning
> range_end
)
14446 /* Inverted range entries are invalid. */
14447 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14451 /* Empty range entries have no effect. */
14452 if (range_beginning
== range_end
)
14455 range_beginning
+= base
;
14458 /* A not-uncommon case of bad debug info.
14459 Don't pollute the addrmap with bad data. */
14460 if (range_beginning
+ baseaddr
== 0
14461 && !dwarf2_per_objfile
->has_section_at_zero
)
14463 complaint (_(".debug_rnglists entry has start address of zero"
14464 " [in module %s]"), objfile_name (objfile
));
14468 callback (range_beginning
, range_end
);
14473 complaint (_("Offset %d is not terminated "
14474 "for DW_AT_ranges attribute"),
14482 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14483 Callback's type should be:
14484 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14485 Return 1 if the attributes are present and valid, otherwise, return 0. */
14487 template <typename Callback
>
14489 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
,
14490 Callback
&&callback
)
14492 struct dwarf2_per_objfile
*dwarf2_per_objfile
14493 = cu
->per_cu
->dwarf2_per_objfile
;
14494 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14495 struct comp_unit_head
*cu_header
= &cu
->header
;
14496 bfd
*obfd
= objfile
->obfd
;
14497 unsigned int addr_size
= cu_header
->addr_size
;
14498 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
14499 /* Base address selection entry. */
14502 unsigned int dummy
;
14503 const gdb_byte
*buffer
;
14504 CORE_ADDR baseaddr
;
14506 if (cu_header
->version
>= 5)
14507 return dwarf2_rnglists_process (offset
, cu
, callback
);
14509 found_base
= cu
->base_known
;
14510 base
= cu
->base_address
;
14512 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
14513 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
14515 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14519 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
14521 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14525 CORE_ADDR range_beginning
, range_end
;
14527 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
14528 buffer
+= addr_size
;
14529 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
14530 buffer
+= addr_size
;
14531 offset
+= 2 * addr_size
;
14533 /* An end of list marker is a pair of zero addresses. */
14534 if (range_beginning
== 0 && range_end
== 0)
14535 /* Found the end of list entry. */
14538 /* Each base address selection entry is a pair of 2 values.
14539 The first is the largest possible address, the second is
14540 the base address. Check for a base address here. */
14541 if ((range_beginning
& mask
) == mask
)
14543 /* If we found the largest possible address, then we already
14544 have the base address in range_end. */
14552 /* We have no valid base address for the ranges
14554 complaint (_("Invalid .debug_ranges data (no base address)"));
14558 if (range_beginning
> range_end
)
14560 /* Inverted range entries are invalid. */
14561 complaint (_("Invalid .debug_ranges data (inverted range)"));
14565 /* Empty range entries have no effect. */
14566 if (range_beginning
== range_end
)
14569 range_beginning
+= base
;
14572 /* A not-uncommon case of bad debug info.
14573 Don't pollute the addrmap with bad data. */
14574 if (range_beginning
+ baseaddr
== 0
14575 && !dwarf2_per_objfile
->has_section_at_zero
)
14577 complaint (_(".debug_ranges entry has start address of zero"
14578 " [in module %s]"), objfile_name (objfile
));
14582 callback (range_beginning
, range_end
);
14588 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14589 Return 1 if the attributes are present and valid, otherwise, return 0.
14590 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14593 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14594 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14595 struct partial_symtab
*ranges_pst
)
14597 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14598 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14599 const CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
14600 SECT_OFF_TEXT (objfile
));
14603 CORE_ADDR high
= 0;
14606 retval
= dwarf2_ranges_process (offset
, cu
,
14607 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14609 if (ranges_pst
!= NULL
)
14614 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14615 range_beginning
+ baseaddr
)
14617 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14618 range_end
+ baseaddr
)
14620 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
14621 lowpc
, highpc
- 1, ranges_pst
);
14624 /* FIXME: This is recording everything as a low-high
14625 segment of consecutive addresses. We should have a
14626 data structure for discontiguous block ranges
14630 low
= range_beginning
;
14636 if (range_beginning
< low
)
14637 low
= range_beginning
;
14638 if (range_end
> high
)
14646 /* If the first entry is an end-of-list marker, the range
14647 describes an empty scope, i.e. no instructions. */
14653 *high_return
= high
;
14657 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14658 definition for the return value. *LOWPC and *HIGHPC are set iff
14659 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14661 static enum pc_bounds_kind
14662 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14663 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14664 struct partial_symtab
*pst
)
14666 struct dwarf2_per_objfile
*dwarf2_per_objfile
14667 = cu
->per_cu
->dwarf2_per_objfile
;
14668 struct attribute
*attr
;
14669 struct attribute
*attr_high
;
14671 CORE_ADDR high
= 0;
14672 enum pc_bounds_kind ret
;
14674 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14677 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14680 low
= attr_value_as_address (attr
);
14681 high
= attr_value_as_address (attr_high
);
14682 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
14686 /* Found high w/o low attribute. */
14687 return PC_BOUNDS_INVALID
;
14689 /* Found consecutive range of addresses. */
14690 ret
= PC_BOUNDS_HIGH_LOW
;
14694 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14697 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14698 We take advantage of the fact that DW_AT_ranges does not appear
14699 in DW_TAG_compile_unit of DWO files. */
14700 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
14701 unsigned int ranges_offset
= (DW_UNSND (attr
)
14702 + (need_ranges_base
14706 /* Value of the DW_AT_ranges attribute is the offset in the
14707 .debug_ranges section. */
14708 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
14709 return PC_BOUNDS_INVALID
;
14710 /* Found discontinuous range of addresses. */
14711 ret
= PC_BOUNDS_RANGES
;
14714 return PC_BOUNDS_NOT_PRESENT
;
14717 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14719 return PC_BOUNDS_INVALID
;
14721 /* When using the GNU linker, .gnu.linkonce. sections are used to
14722 eliminate duplicate copies of functions and vtables and such.
14723 The linker will arbitrarily choose one and discard the others.
14724 The AT_*_pc values for such functions refer to local labels in
14725 these sections. If the section from that file was discarded, the
14726 labels are not in the output, so the relocs get a value of 0.
14727 If this is a discarded function, mark the pc bounds as invalid,
14728 so that GDB will ignore it. */
14729 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
14730 return PC_BOUNDS_INVALID
;
14738 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14739 its low and high PC addresses. Do nothing if these addresses could not
14740 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14741 and HIGHPC to the high address if greater than HIGHPC. */
14744 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14745 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14746 struct dwarf2_cu
*cu
)
14748 CORE_ADDR low
, high
;
14749 struct die_info
*child
= die
->child
;
14751 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14753 *lowpc
= std::min (*lowpc
, low
);
14754 *highpc
= std::max (*highpc
, high
);
14757 /* If the language does not allow nested subprograms (either inside
14758 subprograms or lexical blocks), we're done. */
14759 if (cu
->language
!= language_ada
)
14762 /* Check all the children of the given DIE. If it contains nested
14763 subprograms, then check their pc bounds. Likewise, we need to
14764 check lexical blocks as well, as they may also contain subprogram
14766 while (child
&& child
->tag
)
14768 if (child
->tag
== DW_TAG_subprogram
14769 || child
->tag
== DW_TAG_lexical_block
)
14770 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14771 child
= sibling_die (child
);
14775 /* Get the low and high pc's represented by the scope DIE, and store
14776 them in *LOWPC and *HIGHPC. If the correct values can't be
14777 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14780 get_scope_pc_bounds (struct die_info
*die
,
14781 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14782 struct dwarf2_cu
*cu
)
14784 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14785 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14786 CORE_ADDR current_low
, current_high
;
14788 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14789 >= PC_BOUNDS_RANGES
)
14791 best_low
= current_low
;
14792 best_high
= current_high
;
14796 struct die_info
*child
= die
->child
;
14798 while (child
&& child
->tag
)
14800 switch (child
->tag
) {
14801 case DW_TAG_subprogram
:
14802 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14804 case DW_TAG_namespace
:
14805 case DW_TAG_module
:
14806 /* FIXME: carlton/2004-01-16: Should we do this for
14807 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14808 that current GCC's always emit the DIEs corresponding
14809 to definitions of methods of classes as children of a
14810 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14811 the DIEs giving the declarations, which could be
14812 anywhere). But I don't see any reason why the
14813 standards says that they have to be there. */
14814 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14816 if (current_low
!= ((CORE_ADDR
) -1))
14818 best_low
= std::min (best_low
, current_low
);
14819 best_high
= std::max (best_high
, current_high
);
14827 child
= sibling_die (child
);
14832 *highpc
= best_high
;
14835 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14839 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14840 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14842 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14843 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14844 struct attribute
*attr
;
14845 struct attribute
*attr_high
;
14847 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14850 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14853 CORE_ADDR low
= attr_value_as_address (attr
);
14854 CORE_ADDR high
= attr_value_as_address (attr_high
);
14856 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
14859 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14860 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14861 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14865 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14868 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14869 We take advantage of the fact that DW_AT_ranges does not appear
14870 in DW_TAG_compile_unit of DWO files. */
14871 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
14873 /* The value of the DW_AT_ranges attribute is the offset of the
14874 address range list in the .debug_ranges section. */
14875 unsigned long offset
= (DW_UNSND (attr
)
14876 + (need_ranges_base
? cu
->ranges_base
: 0));
14878 std::vector
<blockrange
> blockvec
;
14879 dwarf2_ranges_process (offset
, cu
,
14880 [&] (CORE_ADDR start
, CORE_ADDR end
)
14884 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14885 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14886 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14887 blockvec
.emplace_back (start
, end
);
14890 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14894 /* Check whether the producer field indicates either of GCC < 4.6, or the
14895 Intel C/C++ compiler, and cache the result in CU. */
14898 check_producer (struct dwarf2_cu
*cu
)
14902 if (cu
->producer
== NULL
)
14904 /* For unknown compilers expect their behavior is DWARF version
14907 GCC started to support .debug_types sections by -gdwarf-4 since
14908 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14909 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14910 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14911 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14913 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14915 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14916 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14918 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14920 cu
->producer_is_icc
= true;
14921 cu
->producer_is_icc_lt_14
= major
< 14;
14923 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14924 cu
->producer_is_codewarrior
= true;
14927 /* For other non-GCC compilers, expect their behavior is DWARF version
14931 cu
->checked_producer
= true;
14934 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14935 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14936 during 4.6.0 experimental. */
14939 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14941 if (!cu
->checked_producer
)
14942 check_producer (cu
);
14944 return cu
->producer_is_gxx_lt_4_6
;
14948 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14949 with incorrect is_stmt attributes. */
14952 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14954 if (!cu
->checked_producer
)
14955 check_producer (cu
);
14957 return cu
->producer_is_codewarrior
;
14960 /* Return the default accessibility type if it is not overriden by
14961 DW_AT_accessibility. */
14963 static enum dwarf_access_attribute
14964 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14966 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14968 /* The default DWARF 2 accessibility for members is public, the default
14969 accessibility for inheritance is private. */
14971 if (die
->tag
!= DW_TAG_inheritance
)
14972 return DW_ACCESS_public
;
14974 return DW_ACCESS_private
;
14978 /* DWARF 3+ defines the default accessibility a different way. The same
14979 rules apply now for DW_TAG_inheritance as for the members and it only
14980 depends on the container kind. */
14982 if (die
->parent
->tag
== DW_TAG_class_type
)
14983 return DW_ACCESS_private
;
14985 return DW_ACCESS_public
;
14989 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14990 offset. If the attribute was not found return 0, otherwise return
14991 1. If it was found but could not properly be handled, set *OFFSET
14995 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14998 struct attribute
*attr
;
15000 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
15005 /* Note that we do not check for a section offset first here.
15006 This is because DW_AT_data_member_location is new in DWARF 4,
15007 so if we see it, we can assume that a constant form is really
15008 a constant and not a section offset. */
15009 if (attr_form_is_constant (attr
))
15010 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
15011 else if (attr_form_is_section_offset (attr
))
15012 dwarf2_complex_location_expr_complaint ();
15013 else if (attr_form_is_block (attr
))
15014 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
15016 dwarf2_complex_location_expr_complaint ();
15024 /* Add an aggregate field to the field list. */
15027 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
15028 struct dwarf2_cu
*cu
)
15030 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15031 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
15032 struct nextfield
*new_field
;
15033 struct attribute
*attr
;
15035 const char *fieldname
= "";
15037 if (die
->tag
== DW_TAG_inheritance
)
15039 fip
->baseclasses
.emplace_back ();
15040 new_field
= &fip
->baseclasses
.back ();
15044 fip
->fields
.emplace_back ();
15045 new_field
= &fip
->fields
.back ();
15050 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15052 new_field
->accessibility
= DW_UNSND (attr
);
15054 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
15055 if (new_field
->accessibility
!= DW_ACCESS_public
)
15056 fip
->non_public_fields
= 1;
15058 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15060 new_field
->virtuality
= DW_UNSND (attr
);
15062 new_field
->virtuality
= DW_VIRTUALITY_none
;
15064 fp
= &new_field
->field
;
15066 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
15070 /* Data member other than a C++ static data member. */
15072 /* Get type of field. */
15073 fp
->type
= die_type (die
, cu
);
15075 SET_FIELD_BITPOS (*fp
, 0);
15077 /* Get bit size of field (zero if none). */
15078 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
15081 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
15085 FIELD_BITSIZE (*fp
) = 0;
15088 /* Get bit offset of field. */
15089 if (handle_data_member_location (die
, cu
, &offset
))
15090 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
15091 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
15094 if (gdbarch_bits_big_endian (gdbarch
))
15096 /* For big endian bits, the DW_AT_bit_offset gives the
15097 additional bit offset from the MSB of the containing
15098 anonymous object to the MSB of the field. We don't
15099 have to do anything special since we don't need to
15100 know the size of the anonymous object. */
15101 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
15105 /* For little endian bits, compute the bit offset to the
15106 MSB of the anonymous object, subtract off the number of
15107 bits from the MSB of the field to the MSB of the
15108 object, and then subtract off the number of bits of
15109 the field itself. The result is the bit offset of
15110 the LSB of the field. */
15111 int anonymous_size
;
15112 int bit_offset
= DW_UNSND (attr
);
15114 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15117 /* The size of the anonymous object containing
15118 the bit field is explicit, so use the
15119 indicated size (in bytes). */
15120 anonymous_size
= DW_UNSND (attr
);
15124 /* The size of the anonymous object containing
15125 the bit field must be inferred from the type
15126 attribute of the data member containing the
15128 anonymous_size
= TYPE_LENGTH (fp
->type
);
15130 SET_FIELD_BITPOS (*fp
,
15131 (FIELD_BITPOS (*fp
)
15132 + anonymous_size
* bits_per_byte
15133 - bit_offset
- FIELD_BITSIZE (*fp
)));
15136 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
15138 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15139 + dwarf2_get_attr_constant_value (attr
, 0)));
15141 /* Get name of field. */
15142 fieldname
= dwarf2_name (die
, cu
);
15143 if (fieldname
== NULL
)
15146 /* The name is already allocated along with this objfile, so we don't
15147 need to duplicate it for the type. */
15148 fp
->name
= fieldname
;
15150 /* Change accessibility for artificial fields (e.g. virtual table
15151 pointer or virtual base class pointer) to private. */
15152 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
15154 FIELD_ARTIFICIAL (*fp
) = 1;
15155 new_field
->accessibility
= DW_ACCESS_private
;
15156 fip
->non_public_fields
= 1;
15159 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
15161 /* C++ static member. */
15163 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15164 is a declaration, but all versions of G++ as of this writing
15165 (so through at least 3.2.1) incorrectly generate
15166 DW_TAG_variable tags. */
15168 const char *physname
;
15170 /* Get name of field. */
15171 fieldname
= dwarf2_name (die
, cu
);
15172 if (fieldname
== NULL
)
15175 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15177 /* Only create a symbol if this is an external value.
15178 new_symbol checks this and puts the value in the global symbol
15179 table, which we want. If it is not external, new_symbol
15180 will try to put the value in cu->list_in_scope which is wrong. */
15181 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
15183 /* A static const member, not much different than an enum as far as
15184 we're concerned, except that we can support more types. */
15185 new_symbol (die
, NULL
, cu
);
15188 /* Get physical name. */
15189 physname
= dwarf2_physname (fieldname
, die
, cu
);
15191 /* The name is already allocated along with this objfile, so we don't
15192 need to duplicate it for the type. */
15193 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
15194 FIELD_TYPE (*fp
) = die_type (die
, cu
);
15195 FIELD_NAME (*fp
) = fieldname
;
15197 else if (die
->tag
== DW_TAG_inheritance
)
15201 /* C++ base class field. */
15202 if (handle_data_member_location (die
, cu
, &offset
))
15203 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
15204 FIELD_BITSIZE (*fp
) = 0;
15205 FIELD_TYPE (*fp
) = die_type (die
, cu
);
15206 FIELD_NAME (*fp
) = TYPE_NAME (fp
->type
);
15208 else if (die
->tag
== DW_TAG_variant_part
)
15210 /* process_structure_scope will treat this DIE as a union. */
15211 process_structure_scope (die
, cu
);
15213 /* The variant part is relative to the start of the enclosing
15215 SET_FIELD_BITPOS (*fp
, 0);
15216 fp
->type
= get_die_type (die
, cu
);
15217 fp
->artificial
= 1;
15218 fp
->name
= "<<variant>>";
15220 /* Normally a DW_TAG_variant_part won't have a size, but our
15221 representation requires one, so set it to the maximum of the
15223 if (TYPE_LENGTH (fp
->type
) == 0)
15226 for (int i
= 0; i
< TYPE_NFIELDS (fp
->type
); ++i
)
15227 if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp
->type
, i
)) > max
)
15228 max
= TYPE_LENGTH (TYPE_FIELD_TYPE (fp
->type
, i
));
15229 TYPE_LENGTH (fp
->type
) = max
;
15233 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15236 /* Can the type given by DIE define another type? */
15239 type_can_define_types (const struct die_info
*die
)
15243 case DW_TAG_typedef
:
15244 case DW_TAG_class_type
:
15245 case DW_TAG_structure_type
:
15246 case DW_TAG_union_type
:
15247 case DW_TAG_enumeration_type
:
15255 /* Add a type definition defined in the scope of the FIP's class. */
15258 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
15259 struct dwarf2_cu
*cu
)
15261 struct decl_field fp
;
15262 memset (&fp
, 0, sizeof (fp
));
15264 gdb_assert (type_can_define_types (die
));
15266 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15267 fp
.name
= dwarf2_name (die
, cu
);
15268 fp
.type
= read_type_die (die
, cu
);
15270 /* Save accessibility. */
15271 enum dwarf_access_attribute accessibility
;
15272 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15274 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
15276 accessibility
= dwarf2_default_access_attribute (die
, cu
);
15277 switch (accessibility
)
15279 case DW_ACCESS_public
:
15280 /* The assumed value if neither private nor protected. */
15282 case DW_ACCESS_private
:
15285 case DW_ACCESS_protected
:
15286 fp
.is_protected
= 1;
15289 complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility
);
15292 if (die
->tag
== DW_TAG_typedef
)
15293 fip
->typedef_field_list
.push_back (fp
);
15295 fip
->nested_types_list
.push_back (fp
);
15298 /* Create the vector of fields, and attach it to the type. */
15301 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
15302 struct dwarf2_cu
*cu
)
15304 int nfields
= fip
->nfields
;
15306 /* Record the field count, allocate space for the array of fields,
15307 and create blank accessibility bitfields if necessary. */
15308 TYPE_NFIELDS (type
) = nfields
;
15309 TYPE_FIELDS (type
) = (struct field
*)
15310 TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
);
15312 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
15314 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15316 TYPE_FIELD_PRIVATE_BITS (type
) =
15317 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15318 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
15320 TYPE_FIELD_PROTECTED_BITS (type
) =
15321 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15322 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
15324 TYPE_FIELD_IGNORE_BITS (type
) =
15325 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15326 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
15329 /* If the type has baseclasses, allocate and clear a bit vector for
15330 TYPE_FIELD_VIRTUAL_BITS. */
15331 if (!fip
->baseclasses
.empty () && cu
->language
!= language_ada
)
15333 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
15334 unsigned char *pointer
;
15336 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15337 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
15338 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
15339 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
15340 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
15343 if (TYPE_FLAG_DISCRIMINATED_UNION (type
))
15345 struct discriminant_info
*di
= alloc_discriminant_info (type
, -1, -1);
15347 for (int index
= 0; index
< nfields
; ++index
)
15349 struct nextfield
&field
= fip
->fields
[index
];
15351 if (field
.variant
.is_discriminant
)
15352 di
->discriminant_index
= index
;
15353 else if (field
.variant
.default_branch
)
15354 di
->default_index
= index
;
15356 di
->discriminants
[index
] = field
.variant
.discriminant_value
;
15360 /* Copy the saved-up fields into the field vector. */
15361 for (int i
= 0; i
< nfields
; ++i
)
15363 struct nextfield
&field
15364 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
15365 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
15367 TYPE_FIELD (type
, i
) = field
.field
;
15368 switch (field
.accessibility
)
15370 case DW_ACCESS_private
:
15371 if (cu
->language
!= language_ada
)
15372 SET_TYPE_FIELD_PRIVATE (type
, i
);
15375 case DW_ACCESS_protected
:
15376 if (cu
->language
!= language_ada
)
15377 SET_TYPE_FIELD_PROTECTED (type
, i
);
15380 case DW_ACCESS_public
:
15384 /* Unknown accessibility. Complain and treat it as public. */
15386 complaint (_("unsupported accessibility %d"),
15387 field
.accessibility
);
15391 if (i
< fip
->baseclasses
.size ())
15393 switch (field
.virtuality
)
15395 case DW_VIRTUALITY_virtual
:
15396 case DW_VIRTUALITY_pure_virtual
:
15397 if (cu
->language
== language_ada
)
15398 error (_("unexpected virtuality in component of Ada type"));
15399 SET_TYPE_FIELD_VIRTUAL (type
, i
);
15406 /* Return true if this member function is a constructor, false
15410 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15412 const char *fieldname
;
15413 const char *type_name
;
15416 if (die
->parent
== NULL
)
15419 if (die
->parent
->tag
!= DW_TAG_structure_type
15420 && die
->parent
->tag
!= DW_TAG_union_type
15421 && die
->parent
->tag
!= DW_TAG_class_type
)
15424 fieldname
= dwarf2_name (die
, cu
);
15425 type_name
= dwarf2_name (die
->parent
, cu
);
15426 if (fieldname
== NULL
|| type_name
== NULL
)
15429 len
= strlen (fieldname
);
15430 return (strncmp (fieldname
, type_name
, len
) == 0
15431 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15434 /* Add a member function to the proper fieldlist. */
15437 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15438 struct type
*type
, struct dwarf2_cu
*cu
)
15440 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15441 struct attribute
*attr
;
15443 struct fnfieldlist
*flp
= nullptr;
15444 struct fn_field
*fnp
;
15445 const char *fieldname
;
15446 struct type
*this_type
;
15447 enum dwarf_access_attribute accessibility
;
15449 if (cu
->language
== language_ada
)
15450 error (_("unexpected member function in Ada type"));
15452 /* Get name of member function. */
15453 fieldname
= dwarf2_name (die
, cu
);
15454 if (fieldname
== NULL
)
15457 /* Look up member function name in fieldlist. */
15458 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15460 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15462 flp
= &fip
->fnfieldlists
[i
];
15467 /* Create a new fnfieldlist if necessary. */
15468 if (flp
== nullptr)
15470 fip
->fnfieldlists
.emplace_back ();
15471 flp
= &fip
->fnfieldlists
.back ();
15472 flp
->name
= fieldname
;
15473 i
= fip
->fnfieldlists
.size () - 1;
15476 /* Create a new member function field and add it to the vector of
15478 flp
->fnfields
.emplace_back ();
15479 fnp
= &flp
->fnfields
.back ();
15481 /* Delay processing of the physname until later. */
15482 if (cu
->language
== language_cplus
)
15483 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15487 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15488 fnp
->physname
= physname
? physname
: "";
15491 fnp
->type
= alloc_type (objfile
);
15492 this_type
= read_type_die (die
, cu
);
15493 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
15495 int nparams
= TYPE_NFIELDS (this_type
);
15497 /* TYPE is the domain of this method, and THIS_TYPE is the type
15498 of the method itself (TYPE_CODE_METHOD). */
15499 smash_to_method_type (fnp
->type
, type
,
15500 TYPE_TARGET_TYPE (this_type
),
15501 TYPE_FIELDS (this_type
),
15502 TYPE_NFIELDS (this_type
),
15503 TYPE_VARARGS (this_type
));
15505 /* Handle static member functions.
15506 Dwarf2 has no clean way to discern C++ static and non-static
15507 member functions. G++ helps GDB by marking the first
15508 parameter for non-static member functions (which is the this
15509 pointer) as artificial. We obtain this information from
15510 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15511 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15512 fnp
->voffset
= VOFFSET_STATIC
;
15515 complaint (_("member function type missing for '%s'"),
15516 dwarf2_full_name (fieldname
, die
, cu
));
15518 /* Get fcontext from DW_AT_containing_type if present. */
15519 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15520 fnp
->fcontext
= die_containing_type (die
, cu
);
15522 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15523 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15525 /* Get accessibility. */
15526 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15528 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
15530 accessibility
= dwarf2_default_access_attribute (die
, cu
);
15531 switch (accessibility
)
15533 case DW_ACCESS_private
:
15534 fnp
->is_private
= 1;
15536 case DW_ACCESS_protected
:
15537 fnp
->is_protected
= 1;
15541 /* Check for artificial methods. */
15542 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15543 if (attr
&& DW_UNSND (attr
) != 0)
15544 fnp
->is_artificial
= 1;
15546 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15548 /* Get index in virtual function table if it is a virtual member
15549 function. For older versions of GCC, this is an offset in the
15550 appropriate virtual table, as specified by DW_AT_containing_type.
15551 For everyone else, it is an expression to be evaluated relative
15552 to the object address. */
15554 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15557 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
15559 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
15561 /* Old-style GCC. */
15562 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
15564 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
15565 || (DW_BLOCK (attr
)->size
> 1
15566 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
15567 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
15569 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
15570 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15571 dwarf2_complex_location_expr_complaint ();
15573 fnp
->voffset
/= cu
->header
.addr_size
;
15577 dwarf2_complex_location_expr_complaint ();
15579 if (!fnp
->fcontext
)
15581 /* If there is no `this' field and no DW_AT_containing_type,
15582 we cannot actually find a base class context for the
15584 if (TYPE_NFIELDS (this_type
) == 0
15585 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15587 complaint (_("cannot determine context for virtual member "
15588 "function \"%s\" (offset %s)"),
15589 fieldname
, sect_offset_str (die
->sect_off
));
15594 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
15598 else if (attr_form_is_section_offset (attr
))
15600 dwarf2_complex_location_expr_complaint ();
15604 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15610 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15611 if (attr
&& DW_UNSND (attr
))
15613 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15614 complaint (_("Member function \"%s\" (offset %s) is virtual "
15615 "but the vtable offset is not specified"),
15616 fieldname
, sect_offset_str (die
->sect_off
));
15617 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15618 TYPE_CPLUS_DYNAMIC (type
) = 1;
15623 /* Create the vector of member function fields, and attach it to the type. */
15626 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15627 struct dwarf2_cu
*cu
)
15629 if (cu
->language
== language_ada
)
15630 error (_("unexpected member functions in Ada type"));
15632 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15633 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15635 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15637 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15639 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15640 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15642 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15643 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15644 fn_flp
->fn_fields
= (struct fn_field
*)
15645 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15647 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15648 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15651 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15654 /* Returns non-zero if NAME is the name of a vtable member in CU's
15655 language, zero otherwise. */
15657 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15659 static const char vptr
[] = "_vptr";
15661 /* Look for the C++ form of the vtable. */
15662 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15668 /* GCC outputs unnamed structures that are really pointers to member
15669 functions, with the ABI-specified layout. If TYPE describes
15670 such a structure, smash it into a member function type.
15672 GCC shouldn't do this; it should just output pointer to member DIEs.
15673 This is GCC PR debug/28767. */
15676 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15678 struct type
*pfn_type
, *self_type
, *new_type
;
15680 /* Check for a structure with no name and two children. */
15681 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
15684 /* Check for __pfn and __delta members. */
15685 if (TYPE_FIELD_NAME (type
, 0) == NULL
15686 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15687 || TYPE_FIELD_NAME (type
, 1) == NULL
15688 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15691 /* Find the type of the method. */
15692 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
15693 if (pfn_type
== NULL
15694 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
15695 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
15698 /* Look for the "this" argument. */
15699 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15700 if (TYPE_NFIELDS (pfn_type
) == 0
15701 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15702 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
15705 self_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
15706 new_type
= alloc_type (objfile
);
15707 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15708 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
15709 TYPE_VARARGS (pfn_type
));
15710 smash_to_methodptr_type (type
, new_type
);
15713 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15714 appropriate error checking and issuing complaints if there is a
15718 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
15720 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
15722 if (attr
== nullptr)
15725 if (!attr_form_is_constant (attr
))
15727 complaint (_("DW_AT_alignment must have constant form"
15728 " - DIE at %s [in module %s]"),
15729 sect_offset_str (die
->sect_off
),
15730 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15735 if (attr
->form
== DW_FORM_sdata
)
15737 LONGEST val
= DW_SND (attr
);
15740 complaint (_("DW_AT_alignment value must not be negative"
15741 " - DIE at %s [in module %s]"),
15742 sect_offset_str (die
->sect_off
),
15743 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15749 align
= DW_UNSND (attr
);
15753 complaint (_("DW_AT_alignment value must not be zero"
15754 " - DIE at %s [in module %s]"),
15755 sect_offset_str (die
->sect_off
),
15756 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15759 if ((align
& (align
- 1)) != 0)
15761 complaint (_("DW_AT_alignment value must be a power of 2"
15762 " - DIE at %s [in module %s]"),
15763 sect_offset_str (die
->sect_off
),
15764 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15771 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15772 the alignment for TYPE. */
15775 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
15778 if (!set_type_align (type
, get_alignment (cu
, die
)))
15779 complaint (_("DW_AT_alignment value too large"
15780 " - DIE at %s [in module %s]"),
15781 sect_offset_str (die
->sect_off
),
15782 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15785 /* Called when we find the DIE that starts a structure or union scope
15786 (definition) to create a type for the structure or union. Fill in
15787 the type's name and general properties; the members will not be
15788 processed until process_structure_scope. A symbol table entry for
15789 the type will also not be done until process_structure_scope (assuming
15790 the type has a name).
15792 NOTE: we need to call these functions regardless of whether or not the
15793 DIE has a DW_AT_name attribute, since it might be an anonymous
15794 structure or union. This gets the type entered into our set of
15795 user defined types. */
15797 static struct type
*
15798 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15800 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15802 struct attribute
*attr
;
15805 /* If the definition of this type lives in .debug_types, read that type.
15806 Don't follow DW_AT_specification though, that will take us back up
15807 the chain and we want to go down. */
15808 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
15811 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15813 /* The type's CU may not be the same as CU.
15814 Ensure TYPE is recorded with CU in die_type_hash. */
15815 return set_die_type (die
, type
, cu
);
15818 type
= alloc_type (objfile
);
15819 INIT_CPLUS_SPECIFIC (type
);
15821 name
= dwarf2_name (die
, cu
);
15824 if (cu
->language
== language_cplus
15825 || cu
->language
== language_d
15826 || cu
->language
== language_rust
)
15828 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
15830 /* dwarf2_full_name might have already finished building the DIE's
15831 type. If so, there is no need to continue. */
15832 if (get_die_type (die
, cu
) != NULL
)
15833 return get_die_type (die
, cu
);
15835 TYPE_NAME (type
) = full_name
;
15839 /* The name is already allocated along with this objfile, so
15840 we don't need to duplicate it for the type. */
15841 TYPE_NAME (type
) = name
;
15845 if (die
->tag
== DW_TAG_structure_type
)
15847 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15849 else if (die
->tag
== DW_TAG_union_type
)
15851 TYPE_CODE (type
) = TYPE_CODE_UNION
;
15853 else if (die
->tag
== DW_TAG_variant_part
)
15855 TYPE_CODE (type
) = TYPE_CODE_UNION
;
15856 TYPE_FLAG_DISCRIMINATED_UNION (type
) = 1;
15860 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15863 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
15864 TYPE_DECLARED_CLASS (type
) = 1;
15866 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15869 if (attr_form_is_constant (attr
))
15870 TYPE_LENGTH (type
) = DW_UNSND (attr
);
15873 /* For the moment, dynamic type sizes are not supported
15874 by GDB's struct type. The actual size is determined
15875 on-demand when resolving the type of a given object,
15876 so set the type's length to zero for now. Otherwise,
15877 we record an expression as the length, and that expression
15878 could lead to a very large value, which could eventually
15879 lead to us trying to allocate that much memory when creating
15880 a value of that type. */
15881 TYPE_LENGTH (type
) = 0;
15886 TYPE_LENGTH (type
) = 0;
15889 maybe_set_alignment (cu
, die
, type
);
15891 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
15893 /* ICC<14 does not output the required DW_AT_declaration on
15894 incomplete types, but gives them a size of zero. */
15895 TYPE_STUB (type
) = 1;
15898 TYPE_STUB_SUPPORTED (type
) = 1;
15900 if (die_is_declaration (die
, cu
))
15901 TYPE_STUB (type
) = 1;
15902 else if (attr
== NULL
&& die
->child
== NULL
15903 && producer_is_realview (cu
->producer
))
15904 /* RealView does not output the required DW_AT_declaration
15905 on incomplete types. */
15906 TYPE_STUB (type
) = 1;
15908 /* We need to add the type field to the die immediately so we don't
15909 infinitely recurse when dealing with pointers to the structure
15910 type within the structure itself. */
15911 set_die_type (die
, type
, cu
);
15913 /* set_die_type should be already done. */
15914 set_descriptive_type (type
, die
, cu
);
15919 /* A helper for process_structure_scope that handles a single member
15923 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
15924 struct field_info
*fi
,
15925 std::vector
<struct symbol
*> *template_args
,
15926 struct dwarf2_cu
*cu
)
15928 if (child_die
->tag
== DW_TAG_member
15929 || child_die
->tag
== DW_TAG_variable
15930 || child_die
->tag
== DW_TAG_variant_part
)
15932 /* NOTE: carlton/2002-11-05: A C++ static data member
15933 should be a DW_TAG_member that is a declaration, but
15934 all versions of G++ as of this writing (so through at
15935 least 3.2.1) incorrectly generate DW_TAG_variable
15936 tags for them instead. */
15937 dwarf2_add_field (fi
, child_die
, cu
);
15939 else if (child_die
->tag
== DW_TAG_subprogram
)
15941 /* Rust doesn't have member functions in the C++ sense.
15942 However, it does emit ordinary functions as children
15943 of a struct DIE. */
15944 if (cu
->language
== language_rust
)
15945 read_func_scope (child_die
, cu
);
15948 /* C++ member function. */
15949 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
15952 else if (child_die
->tag
== DW_TAG_inheritance
)
15954 /* C++ base class field. */
15955 dwarf2_add_field (fi
, child_die
, cu
);
15957 else if (type_can_define_types (child_die
))
15958 dwarf2_add_type_defn (fi
, child_die
, cu
);
15959 else if (child_die
->tag
== DW_TAG_template_type_param
15960 || child_die
->tag
== DW_TAG_template_value_param
)
15962 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
15965 template_args
->push_back (arg
);
15967 else if (child_die
->tag
== DW_TAG_variant
)
15969 /* In a variant we want to get the discriminant and also add a
15970 field for our sole member child. */
15971 struct attribute
*discr
= dwarf2_attr (child_die
, DW_AT_discr_value
, cu
);
15973 for (die_info
*variant_child
= child_die
->child
;
15974 variant_child
!= NULL
;
15975 variant_child
= sibling_die (variant_child
))
15977 if (variant_child
->tag
== DW_TAG_member
)
15979 handle_struct_member_die (variant_child
, type
, fi
,
15980 template_args
, cu
);
15981 /* Only handle the one. */
15986 /* We don't handle this but we might as well report it if we see
15988 if (dwarf2_attr (child_die
, DW_AT_discr_list
, cu
) != nullptr)
15989 complaint (_("DW_AT_discr_list is not supported yet"
15990 " - DIE at %s [in module %s]"),
15991 sect_offset_str (child_die
->sect_off
),
15992 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15994 /* The first field was just added, so we can stash the
15995 discriminant there. */
15996 gdb_assert (!fi
->fields
.empty ());
15998 fi
->fields
.back ().variant
.default_branch
= true;
16000 fi
->fields
.back ().variant
.discriminant_value
= DW_UNSND (discr
);
16004 /* Finish creating a structure or union type, including filling in
16005 its members and creating a symbol for it. */
16008 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16010 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16011 struct die_info
*child_die
;
16014 type
= get_die_type (die
, cu
);
16016 type
= read_structure_type (die
, cu
);
16018 /* When reading a DW_TAG_variant_part, we need to notice when we
16019 read the discriminant member, so we can record it later in the
16020 discriminant_info. */
16021 bool is_variant_part
= TYPE_FLAG_DISCRIMINATED_UNION (type
);
16022 sect_offset discr_offset
;
16023 bool has_template_parameters
= false;
16025 if (is_variant_part
)
16027 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
16030 /* Maybe it's a univariant form, an extension we support.
16031 In this case arrange not to check the offset. */
16032 is_variant_part
= false;
16034 else if (attr_form_is_ref (discr
))
16036 struct dwarf2_cu
*target_cu
= cu
;
16037 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
16039 discr_offset
= target_die
->sect_off
;
16043 complaint (_("DW_AT_discr does not have DIE reference form"
16044 " - DIE at %s [in module %s]"),
16045 sect_offset_str (die
->sect_off
),
16046 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
16047 is_variant_part
= false;
16051 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
16053 struct field_info fi
;
16054 std::vector
<struct symbol
*> template_args
;
16056 child_die
= die
->child
;
16058 while (child_die
&& child_die
->tag
)
16060 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
16062 if (is_variant_part
&& discr_offset
== child_die
->sect_off
)
16063 fi
.fields
.back ().variant
.is_discriminant
= true;
16065 child_die
= sibling_die (child_die
);
16068 /* Attach template arguments to type. */
16069 if (!template_args
.empty ())
16071 has_template_parameters
= true;
16072 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16073 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
16074 TYPE_TEMPLATE_ARGUMENTS (type
)
16075 = XOBNEWVEC (&objfile
->objfile_obstack
,
16077 TYPE_N_TEMPLATE_ARGUMENTS (type
));
16078 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
16079 template_args
.data (),
16080 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
16081 * sizeof (struct symbol
*)));
16084 /* Attach fields and member functions to the type. */
16086 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
16087 if (!fi
.fnfieldlists
.empty ())
16089 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
16091 /* Get the type which refers to the base class (possibly this
16092 class itself) which contains the vtable pointer for the current
16093 class from the DW_AT_containing_type attribute. This use of
16094 DW_AT_containing_type is a GNU extension. */
16096 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
16098 struct type
*t
= die_containing_type (die
, cu
);
16100 set_type_vptr_basetype (type
, t
);
16105 /* Our own class provides vtbl ptr. */
16106 for (i
= TYPE_NFIELDS (t
) - 1;
16107 i
>= TYPE_N_BASECLASSES (t
);
16110 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
16112 if (is_vtable_name (fieldname
, cu
))
16114 set_type_vptr_fieldno (type
, i
);
16119 /* Complain if virtual function table field not found. */
16120 if (i
< TYPE_N_BASECLASSES (t
))
16121 complaint (_("virtual function table pointer "
16122 "not found when defining class '%s'"),
16123 TYPE_NAME (type
) ? TYPE_NAME (type
) : "");
16127 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
16130 else if (cu
->producer
16131 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
16133 /* The IBM XLC compiler does not provide direct indication
16134 of the containing type, but the vtable pointer is
16135 always named __vfp. */
16139 for (i
= TYPE_NFIELDS (type
) - 1;
16140 i
>= TYPE_N_BASECLASSES (type
);
16143 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
16145 set_type_vptr_fieldno (type
, i
);
16146 set_type_vptr_basetype (type
, type
);
16153 /* Copy fi.typedef_field_list linked list elements content into the
16154 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16155 if (!fi
.typedef_field_list
.empty ())
16157 int count
= fi
.typedef_field_list
.size ();
16159 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16160 TYPE_TYPEDEF_FIELD_ARRAY (type
)
16161 = ((struct decl_field
*)
16163 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
16164 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
16166 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
16167 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
16170 /* Copy fi.nested_types_list linked list elements content into the
16171 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16172 if (!fi
.nested_types_list
.empty () && cu
->language
!= language_ada
)
16174 int count
= fi
.nested_types_list
.size ();
16176 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16177 TYPE_NESTED_TYPES_ARRAY (type
)
16178 = ((struct decl_field
*)
16179 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
16180 TYPE_NESTED_TYPES_COUNT (type
) = count
;
16182 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
16183 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
16187 quirk_gcc_member_function_pointer (type
, objfile
);
16188 if (cu
->language
== language_rust
&& die
->tag
== DW_TAG_union_type
)
16189 cu
->rust_unions
.push_back (type
);
16191 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16192 snapshots) has been known to create a die giving a declaration
16193 for a class that has, as a child, a die giving a definition for a
16194 nested class. So we have to process our children even if the
16195 current die is a declaration. Normally, of course, a declaration
16196 won't have any children at all. */
16198 child_die
= die
->child
;
16200 while (child_die
!= NULL
&& child_die
->tag
)
16202 if (child_die
->tag
== DW_TAG_member
16203 || child_die
->tag
== DW_TAG_variable
16204 || child_die
->tag
== DW_TAG_inheritance
16205 || child_die
->tag
== DW_TAG_template_value_param
16206 || child_die
->tag
== DW_TAG_template_type_param
)
16211 process_die (child_die
, cu
);
16213 child_die
= sibling_die (child_die
);
16216 /* Do not consider external references. According to the DWARF standard,
16217 these DIEs are identified by the fact that they have no byte_size
16218 attribute, and a declaration attribute. */
16219 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16220 || !die_is_declaration (die
, cu
))
16222 struct symbol
*sym
= new_symbol (die
, type
, cu
);
16224 if (has_template_parameters
)
16226 struct symtab
*symtab
;
16227 if (sym
!= nullptr)
16228 symtab
= symbol_symtab (sym
);
16229 else if (cu
->line_header
!= nullptr)
16231 /* Any related symtab will do. */
16233 = cu
->line_header
->file_name_at (file_name_index (1))->symtab
;
16238 complaint (_("could not find suitable "
16239 "symtab for template parameter"
16240 " - DIE at %s [in module %s]"),
16241 sect_offset_str (die
->sect_off
),
16242 objfile_name (objfile
));
16245 if (symtab
!= nullptr)
16247 /* Make sure that the symtab is set on the new symbols.
16248 Even though they don't appear in this symtab directly,
16249 other parts of gdb assume that symbols do, and this is
16250 reasonably true. */
16251 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
16252 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
16258 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16259 update TYPE using some information only available in DIE's children. */
16262 update_enumeration_type_from_children (struct die_info
*die
,
16264 struct dwarf2_cu
*cu
)
16266 struct die_info
*child_die
;
16267 int unsigned_enum
= 1;
16271 auto_obstack obstack
;
16273 for (child_die
= die
->child
;
16274 child_die
!= NULL
&& child_die
->tag
;
16275 child_die
= sibling_die (child_die
))
16277 struct attribute
*attr
;
16279 const gdb_byte
*bytes
;
16280 struct dwarf2_locexpr_baton
*baton
;
16283 if (child_die
->tag
!= DW_TAG_enumerator
)
16286 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16290 name
= dwarf2_name (child_die
, cu
);
16292 name
= "<anonymous enumerator>";
16294 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16295 &value
, &bytes
, &baton
);
16301 else if ((mask
& value
) != 0)
16306 /* If we already know that the enum type is neither unsigned, nor
16307 a flag type, no need to look at the rest of the enumerates. */
16308 if (!unsigned_enum
&& !flag_enum
)
16313 TYPE_UNSIGNED (type
) = 1;
16315 TYPE_FLAG_ENUM (type
) = 1;
16318 /* Given a DW_AT_enumeration_type die, set its type. We do not
16319 complete the type's fields yet, or create any symbols. */
16321 static struct type
*
16322 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16324 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16326 struct attribute
*attr
;
16329 /* If the definition of this type lives in .debug_types, read that type.
16330 Don't follow DW_AT_specification though, that will take us back up
16331 the chain and we want to go down. */
16332 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
16335 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16337 /* The type's CU may not be the same as CU.
16338 Ensure TYPE is recorded with CU in die_type_hash. */
16339 return set_die_type (die
, type
, cu
);
16342 type
= alloc_type (objfile
);
16344 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
16345 name
= dwarf2_full_name (NULL
, die
, cu
);
16347 TYPE_NAME (type
) = name
;
16349 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16352 struct type
*underlying_type
= die_type (die
, cu
);
16354 TYPE_TARGET_TYPE (type
) = underlying_type
;
16357 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16360 TYPE_LENGTH (type
) = DW_UNSND (attr
);
16364 TYPE_LENGTH (type
) = 0;
16367 maybe_set_alignment (cu
, die
, type
);
16369 /* The enumeration DIE can be incomplete. In Ada, any type can be
16370 declared as private in the package spec, and then defined only
16371 inside the package body. Such types are known as Taft Amendment
16372 Types. When another package uses such a type, an incomplete DIE
16373 may be generated by the compiler. */
16374 if (die_is_declaration (die
, cu
))
16375 TYPE_STUB (type
) = 1;
16377 /* Finish the creation of this type by using the enum's children.
16378 We must call this even when the underlying type has been provided
16379 so that we can determine if we're looking at a "flag" enum. */
16380 update_enumeration_type_from_children (die
, type
, cu
);
16382 /* If this type has an underlying type that is not a stub, then we
16383 may use its attributes. We always use the "unsigned" attribute
16384 in this situation, because ordinarily we guess whether the type
16385 is unsigned -- but the guess can be wrong and the underlying type
16386 can tell us the reality. However, we defer to a local size
16387 attribute if one exists, because this lets the compiler override
16388 the underlying type if needed. */
16389 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_STUB (TYPE_TARGET_TYPE (type
)))
16391 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
));
16392 if (TYPE_LENGTH (type
) == 0)
16393 TYPE_LENGTH (type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
16394 if (TYPE_RAW_ALIGN (type
) == 0
16395 && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type
)) != 0)
16396 set_type_align (type
, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type
)));
16399 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
16401 return set_die_type (die
, type
, cu
);
16404 /* Given a pointer to a die which begins an enumeration, process all
16405 the dies that define the members of the enumeration, and create the
16406 symbol for the enumeration type.
16408 NOTE: We reverse the order of the element list. */
16411 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16413 struct type
*this_type
;
16415 this_type
= get_die_type (die
, cu
);
16416 if (this_type
== NULL
)
16417 this_type
= read_enumeration_type (die
, cu
);
16419 if (die
->child
!= NULL
)
16421 struct die_info
*child_die
;
16422 struct symbol
*sym
;
16423 struct field
*fields
= NULL
;
16424 int num_fields
= 0;
16427 child_die
= die
->child
;
16428 while (child_die
&& child_die
->tag
)
16430 if (child_die
->tag
!= DW_TAG_enumerator
)
16432 process_die (child_die
, cu
);
16436 name
= dwarf2_name (child_die
, cu
);
16439 sym
= new_symbol (child_die
, this_type
, cu
);
16441 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
16443 fields
= (struct field
*)
16445 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
16446 * sizeof (struct field
));
16449 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
16450 FIELD_TYPE (fields
[num_fields
]) = NULL
;
16451 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
16452 FIELD_BITSIZE (fields
[num_fields
]) = 0;
16458 child_die
= sibling_die (child_die
);
16463 TYPE_NFIELDS (this_type
) = num_fields
;
16464 TYPE_FIELDS (this_type
) = (struct field
*)
16465 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
16466 memcpy (TYPE_FIELDS (this_type
), fields
,
16467 sizeof (struct field
) * num_fields
);
16472 /* If we are reading an enum from a .debug_types unit, and the enum
16473 is a declaration, and the enum is not the signatured type in the
16474 unit, then we do not want to add a symbol for it. Adding a
16475 symbol would in some cases obscure the true definition of the
16476 enum, giving users an incomplete type when the definition is
16477 actually available. Note that we do not want to do this for all
16478 enums which are just declarations, because C++0x allows forward
16479 enum declarations. */
16480 if (cu
->per_cu
->is_debug_types
16481 && die_is_declaration (die
, cu
))
16483 struct signatured_type
*sig_type
;
16485 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16486 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16487 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16491 new_symbol (die
, this_type
, cu
);
16494 /* Extract all information from a DW_TAG_array_type DIE and put it in
16495 the DIE's type field. For now, this only handles one dimensional
16498 static struct type
*
16499 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16501 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16502 struct die_info
*child_die
;
16504 struct type
*element_type
, *range_type
, *index_type
;
16505 struct attribute
*attr
;
16507 struct dynamic_prop
*byte_stride_prop
= NULL
;
16508 unsigned int bit_stride
= 0;
16510 element_type
= die_type (die
, cu
);
16512 /* The die_type call above may have already set the type for this DIE. */
16513 type
= get_die_type (die
, cu
);
16517 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
16521 struct type
*prop_type
16522 = dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
16525 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
16526 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
16530 complaint (_("unable to read array DW_AT_byte_stride "
16531 " - DIE at %s [in module %s]"),
16532 sect_offset_str (die
->sect_off
),
16533 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
16534 /* Ignore this attribute. We will likely not be able to print
16535 arrays of this type correctly, but there is little we can do
16536 to help if we cannot read the attribute's value. */
16537 byte_stride_prop
= NULL
;
16541 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
16543 bit_stride
= DW_UNSND (attr
);
16545 /* Irix 6.2 native cc creates array types without children for
16546 arrays with unspecified length. */
16547 if (die
->child
== NULL
)
16549 index_type
= objfile_type (objfile
)->builtin_int
;
16550 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
16551 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
16552 byte_stride_prop
, bit_stride
);
16553 return set_die_type (die
, type
, cu
);
16556 std::vector
<struct type
*> range_types
;
16557 child_die
= die
->child
;
16558 while (child_die
&& child_die
->tag
)
16560 if (child_die
->tag
== DW_TAG_subrange_type
)
16562 struct type
*child_type
= read_type_die (child_die
, cu
);
16564 if (child_type
!= NULL
)
16566 /* The range type was succesfully read. Save it for the
16567 array type creation. */
16568 range_types
.push_back (child_type
);
16571 child_die
= sibling_die (child_die
);
16574 /* Dwarf2 dimensions are output from left to right, create the
16575 necessary array types in backwards order. */
16577 type
= element_type
;
16579 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
16583 while (i
< range_types
.size ())
16584 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
16585 byte_stride_prop
, bit_stride
);
16589 size_t ndim
= range_types
.size ();
16591 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
16592 byte_stride_prop
, bit_stride
);
16595 /* Understand Dwarf2 support for vector types (like they occur on
16596 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16597 array type. This is not part of the Dwarf2/3 standard yet, but a
16598 custom vendor extension. The main difference between a regular
16599 array and the vector variant is that vectors are passed by value
16601 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
16603 make_vector_type (type
);
16605 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16606 implementation may choose to implement triple vectors using this
16608 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16611 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
16612 TYPE_LENGTH (type
) = DW_UNSND (attr
);
16614 complaint (_("DW_AT_byte_size for array type smaller "
16615 "than the total size of elements"));
16618 name
= dwarf2_name (die
, cu
);
16620 TYPE_NAME (type
) = name
;
16622 maybe_set_alignment (cu
, die
, type
);
16624 /* Install the type in the die. */
16625 set_die_type (die
, type
, cu
);
16627 /* set_die_type should be already done. */
16628 set_descriptive_type (type
, die
, cu
);
16633 static enum dwarf_array_dim_ordering
16634 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
16636 struct attribute
*attr
;
16638 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
16641 return (enum dwarf_array_dim_ordering
) DW_SND (attr
);
16643 /* GNU F77 is a special case, as at 08/2004 array type info is the
16644 opposite order to the dwarf2 specification, but data is still
16645 laid out as per normal fortran.
16647 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16648 version checking. */
16650 if (cu
->language
== language_fortran
16651 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
16653 return DW_ORD_row_major
;
16656 switch (cu
->language_defn
->la_array_ordering
)
16658 case array_column_major
:
16659 return DW_ORD_col_major
;
16660 case array_row_major
:
16662 return DW_ORD_row_major
;
16666 /* Extract all information from a DW_TAG_set_type DIE and put it in
16667 the DIE's type field. */
16669 static struct type
*
16670 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16672 struct type
*domain_type
, *set_type
;
16673 struct attribute
*attr
;
16675 domain_type
= die_type (die
, cu
);
16677 /* The die_type call above may have already set the type for this DIE. */
16678 set_type
= get_die_type (die
, cu
);
16682 set_type
= create_set_type (NULL
, domain_type
);
16684 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16686 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
16688 maybe_set_alignment (cu
, die
, set_type
);
16690 return set_die_type (die
, set_type
, cu
);
16693 /* A helper for read_common_block that creates a locexpr baton.
16694 SYM is the symbol which we are marking as computed.
16695 COMMON_DIE is the DIE for the common block.
16696 COMMON_LOC is the location expression attribute for the common
16698 MEMBER_LOC is the location expression attribute for the particular
16699 member of the common block that we are processing.
16700 CU is the CU from which the above come. */
16703 mark_common_block_symbol_computed (struct symbol
*sym
,
16704 struct die_info
*common_die
,
16705 struct attribute
*common_loc
,
16706 struct attribute
*member_loc
,
16707 struct dwarf2_cu
*cu
)
16709 struct dwarf2_per_objfile
*dwarf2_per_objfile
16710 = cu
->per_cu
->dwarf2_per_objfile
;
16711 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16712 struct dwarf2_locexpr_baton
*baton
;
16714 unsigned int cu_off
;
16715 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
16716 LONGEST offset
= 0;
16718 gdb_assert (common_loc
&& member_loc
);
16719 gdb_assert (attr_form_is_block (common_loc
));
16720 gdb_assert (attr_form_is_block (member_loc
)
16721 || attr_form_is_constant (member_loc
));
16723 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
16724 baton
->per_cu
= cu
->per_cu
;
16725 gdb_assert (baton
->per_cu
);
16727 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16729 if (attr_form_is_constant (member_loc
))
16731 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
16732 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
16735 baton
->size
+= DW_BLOCK (member_loc
)->size
;
16737 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
16740 *ptr
++ = DW_OP_call4
;
16741 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
16742 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
16745 if (attr_form_is_constant (member_loc
))
16747 *ptr
++ = DW_OP_addr
;
16748 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
16749 ptr
+= cu
->header
.addr_size
;
16753 /* We have to copy the data here, because DW_OP_call4 will only
16754 use a DW_AT_location attribute. */
16755 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
16756 ptr
+= DW_BLOCK (member_loc
)->size
;
16759 *ptr
++ = DW_OP_plus
;
16760 gdb_assert (ptr
- baton
->data
== baton
->size
);
16762 SYMBOL_LOCATION_BATON (sym
) = baton
;
16763 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
16766 /* Create appropriate locally-scoped variables for all the
16767 DW_TAG_common_block entries. Also create a struct common_block
16768 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16769 is used to sepate the common blocks name namespace from regular
16773 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
16775 struct attribute
*attr
;
16777 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16780 /* Support the .debug_loc offsets. */
16781 if (attr_form_is_block (attr
))
16785 else if (attr_form_is_section_offset (attr
))
16787 dwarf2_complex_location_expr_complaint ();
16792 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16793 "common block member");
16798 if (die
->child
!= NULL
)
16800 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16801 struct die_info
*child_die
;
16802 size_t n_entries
= 0, size
;
16803 struct common_block
*common_block
;
16804 struct symbol
*sym
;
16806 for (child_die
= die
->child
;
16807 child_die
&& child_die
->tag
;
16808 child_die
= sibling_die (child_die
))
16811 size
= (sizeof (struct common_block
)
16812 + (n_entries
- 1) * sizeof (struct symbol
*));
16814 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
16816 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
16817 common_block
->n_entries
= 0;
16819 for (child_die
= die
->child
;
16820 child_die
&& child_die
->tag
;
16821 child_die
= sibling_die (child_die
))
16823 /* Create the symbol in the DW_TAG_common_block block in the current
16825 sym
= new_symbol (child_die
, NULL
, cu
);
16828 struct attribute
*member_loc
;
16830 common_block
->contents
[common_block
->n_entries
++] = sym
;
16832 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
16836 /* GDB has handled this for a long time, but it is
16837 not specified by DWARF. It seems to have been
16838 emitted by gfortran at least as recently as:
16839 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16840 complaint (_("Variable in common block has "
16841 "DW_AT_data_member_location "
16842 "- DIE at %s [in module %s]"),
16843 sect_offset_str (child_die
->sect_off
),
16844 objfile_name (objfile
));
16846 if (attr_form_is_section_offset (member_loc
))
16847 dwarf2_complex_location_expr_complaint ();
16848 else if (attr_form_is_constant (member_loc
)
16849 || attr_form_is_block (member_loc
))
16852 mark_common_block_symbol_computed (sym
, die
, attr
,
16856 dwarf2_complex_location_expr_complaint ();
16861 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
16862 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
16866 /* Create a type for a C++ namespace. */
16868 static struct type
*
16869 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16871 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16872 const char *previous_prefix
, *name
;
16876 /* For extensions, reuse the type of the original namespace. */
16877 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
16879 struct die_info
*ext_die
;
16880 struct dwarf2_cu
*ext_cu
= cu
;
16882 ext_die
= dwarf2_extension (die
, &ext_cu
);
16883 type
= read_type_die (ext_die
, ext_cu
);
16885 /* EXT_CU may not be the same as CU.
16886 Ensure TYPE is recorded with CU in die_type_hash. */
16887 return set_die_type (die
, type
, cu
);
16890 name
= namespace_name (die
, &is_anonymous
, cu
);
16892 /* Now build the name of the current namespace. */
16894 previous_prefix
= determine_prefix (die
, cu
);
16895 if (previous_prefix
[0] != '\0')
16896 name
= typename_concat (&objfile
->objfile_obstack
,
16897 previous_prefix
, name
, 0, cu
);
16899 /* Create the type. */
16900 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
16902 return set_die_type (die
, type
, cu
);
16905 /* Read a namespace scope. */
16908 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
16910 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16913 /* Add a symbol associated to this if we haven't seen the namespace
16914 before. Also, add a using directive if it's an anonymous
16917 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
16921 type
= read_type_die (die
, cu
);
16922 new_symbol (die
, type
, cu
);
16924 namespace_name (die
, &is_anonymous
, cu
);
16927 const char *previous_prefix
= determine_prefix (die
, cu
);
16929 std::vector
<const char *> excludes
;
16930 add_using_directive (using_directives (cu
),
16931 previous_prefix
, TYPE_NAME (type
), NULL
,
16932 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
16936 if (die
->child
!= NULL
)
16938 struct die_info
*child_die
= die
->child
;
16940 while (child_die
&& child_die
->tag
)
16942 process_die (child_die
, cu
);
16943 child_die
= sibling_die (child_die
);
16948 /* Read a Fortran module as type. This DIE can be only a declaration used for
16949 imported module. Still we need that type as local Fortran "use ... only"
16950 declaration imports depend on the created type in determine_prefix. */
16952 static struct type
*
16953 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16955 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16956 const char *module_name
;
16959 module_name
= dwarf2_name (die
, cu
);
16960 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
16962 return set_die_type (die
, type
, cu
);
16965 /* Read a Fortran module. */
16968 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
16970 struct die_info
*child_die
= die
->child
;
16973 type
= read_type_die (die
, cu
);
16974 new_symbol (die
, type
, cu
);
16976 while (child_die
&& child_die
->tag
)
16978 process_die (child_die
, cu
);
16979 child_die
= sibling_die (child_die
);
16983 /* Return the name of the namespace represented by DIE. Set
16984 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16987 static const char *
16988 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
16990 struct die_info
*current_die
;
16991 const char *name
= NULL
;
16993 /* Loop through the extensions until we find a name. */
16995 for (current_die
= die
;
16996 current_die
!= NULL
;
16997 current_die
= dwarf2_extension (die
, &cu
))
16999 /* We don't use dwarf2_name here so that we can detect the absence
17000 of a name -> anonymous namespace. */
17001 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
17007 /* Is it an anonymous namespace? */
17009 *is_anonymous
= (name
== NULL
);
17011 name
= CP_ANONYMOUS_NAMESPACE_STR
;
17016 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17017 the user defined type vector. */
17019 static struct type
*
17020 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17022 struct gdbarch
*gdbarch
17023 = get_objfile_arch (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
17024 struct comp_unit_head
*cu_header
= &cu
->header
;
17026 struct attribute
*attr_byte_size
;
17027 struct attribute
*attr_address_class
;
17028 int byte_size
, addr_class
;
17029 struct type
*target_type
;
17031 target_type
= die_type (die
, cu
);
17033 /* The die_type call above may have already set the type for this DIE. */
17034 type
= get_die_type (die
, cu
);
17038 type
= lookup_pointer_type (target_type
);
17040 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17041 if (attr_byte_size
)
17042 byte_size
= DW_UNSND (attr_byte_size
);
17044 byte_size
= cu_header
->addr_size
;
17046 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
17047 if (attr_address_class
)
17048 addr_class
= DW_UNSND (attr_address_class
);
17050 addr_class
= DW_ADDR_none
;
17052 ULONGEST alignment
= get_alignment (cu
, die
);
17054 /* If the pointer size, alignment, or address class is different
17055 than the default, create a type variant marked as such and set
17056 the length accordingly. */
17057 if (TYPE_LENGTH (type
) != byte_size
17058 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
17059 && alignment
!= TYPE_RAW_ALIGN (type
))
17060 || addr_class
!= DW_ADDR_none
)
17062 if (gdbarch_address_class_type_flags_p (gdbarch
))
17066 type_flags
= gdbarch_address_class_type_flags
17067 (gdbarch
, byte_size
, addr_class
);
17068 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17070 type
= make_type_with_address_space (type
, type_flags
);
17072 else if (TYPE_LENGTH (type
) != byte_size
)
17074 complaint (_("invalid pointer size %d"), byte_size
);
17076 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17078 complaint (_("Invalid DW_AT_alignment"
17079 " - DIE at %s [in module %s]"),
17080 sect_offset_str (die
->sect_off
),
17081 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17085 /* Should we also complain about unhandled address classes? */
17089 TYPE_LENGTH (type
) = byte_size
;
17090 set_type_align (type
, alignment
);
17091 return set_die_type (die
, type
, cu
);
17094 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17095 the user defined type vector. */
17097 static struct type
*
17098 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17101 struct type
*to_type
;
17102 struct type
*domain
;
17104 to_type
= die_type (die
, cu
);
17105 domain
= die_containing_type (die
, cu
);
17107 /* The calls above may have already set the type for this DIE. */
17108 type
= get_die_type (die
, cu
);
17112 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
17113 type
= lookup_methodptr_type (to_type
);
17114 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
17116 struct type
*new_type
17117 = alloc_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
17119 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17120 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
17121 TYPE_VARARGS (to_type
));
17122 type
= lookup_methodptr_type (new_type
);
17125 type
= lookup_memberptr_type (to_type
, domain
);
17127 return set_die_type (die
, type
, cu
);
17130 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17131 the user defined type vector. */
17133 static struct type
*
17134 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17135 enum type_code refcode
)
17137 struct comp_unit_head
*cu_header
= &cu
->header
;
17138 struct type
*type
, *target_type
;
17139 struct attribute
*attr
;
17141 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17143 target_type
= die_type (die
, cu
);
17145 /* The die_type call above may have already set the type for this DIE. */
17146 type
= get_die_type (die
, cu
);
17150 type
= lookup_reference_type (target_type
, refcode
);
17151 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17154 TYPE_LENGTH (type
) = DW_UNSND (attr
);
17158 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17160 maybe_set_alignment (cu
, die
, type
);
17161 return set_die_type (die
, type
, cu
);
17164 /* Add the given cv-qualifiers to the element type of the array. GCC
17165 outputs DWARF type qualifiers that apply to an array, not the
17166 element type. But GDB relies on the array element type to carry
17167 the cv-qualifiers. This mimics section 6.7.3 of the C99
17170 static struct type
*
17171 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17172 struct type
*base_type
, int cnst
, int voltl
)
17174 struct type
*el_type
, *inner_array
;
17176 base_type
= copy_type (base_type
);
17177 inner_array
= base_type
;
17179 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
17181 TYPE_TARGET_TYPE (inner_array
) =
17182 copy_type (TYPE_TARGET_TYPE (inner_array
));
17183 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17186 el_type
= TYPE_TARGET_TYPE (inner_array
);
17187 cnst
|= TYPE_CONST (el_type
);
17188 voltl
|= TYPE_VOLATILE (el_type
);
17189 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17191 return set_die_type (die
, base_type
, cu
);
17194 static struct type
*
17195 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17197 struct type
*base_type
, *cv_type
;
17199 base_type
= die_type (die
, cu
);
17201 /* The die_type call above may have already set the type for this DIE. */
17202 cv_type
= get_die_type (die
, cu
);
17206 /* In case the const qualifier is applied to an array type, the element type
17207 is so qualified, not the array type (section 6.7.3 of C99). */
17208 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
17209 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17211 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17212 return set_die_type (die
, cv_type
, cu
);
17215 static struct type
*
17216 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17218 struct type
*base_type
, *cv_type
;
17220 base_type
= die_type (die
, cu
);
17222 /* The die_type call above may have already set the type for this DIE. */
17223 cv_type
= get_die_type (die
, cu
);
17227 /* In case the volatile qualifier is applied to an array type, the
17228 element type is so qualified, not the array type (section 6.7.3
17230 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
17231 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17233 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17234 return set_die_type (die
, cv_type
, cu
);
17237 /* Handle DW_TAG_restrict_type. */
17239 static struct type
*
17240 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17242 struct type
*base_type
, *cv_type
;
17244 base_type
= die_type (die
, cu
);
17246 /* The die_type call above may have already set the type for this DIE. */
17247 cv_type
= get_die_type (die
, cu
);
17251 cv_type
= make_restrict_type (base_type
);
17252 return set_die_type (die
, cv_type
, cu
);
17255 /* Handle DW_TAG_atomic_type. */
17257 static struct type
*
17258 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17260 struct type
*base_type
, *cv_type
;
17262 base_type
= die_type (die
, cu
);
17264 /* The die_type call above may have already set the type for this DIE. */
17265 cv_type
= get_die_type (die
, cu
);
17269 cv_type
= make_atomic_type (base_type
);
17270 return set_die_type (die
, cv_type
, cu
);
17273 /* Extract all information from a DW_TAG_string_type DIE and add to
17274 the user defined type vector. It isn't really a user defined type,
17275 but it behaves like one, with other DIE's using an AT_user_def_type
17276 attribute to reference it. */
17278 static struct type
*
17279 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17281 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17282 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17283 struct type
*type
, *range_type
, *index_type
, *char_type
;
17284 struct attribute
*attr
;
17285 unsigned int length
;
17287 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17290 length
= DW_UNSND (attr
);
17294 /* Check for the DW_AT_byte_size attribute. */
17295 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17298 length
= DW_UNSND (attr
);
17306 index_type
= objfile_type (objfile
)->builtin_int
;
17307 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17308 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17309 type
= create_string_type (NULL
, char_type
, range_type
);
17311 return set_die_type (die
, type
, cu
);
17314 /* Assuming that DIE corresponds to a function, returns nonzero
17315 if the function is prototyped. */
17318 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17320 struct attribute
*attr
;
17322 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17323 if (attr
&& (DW_UNSND (attr
) != 0))
17326 /* The DWARF standard implies that the DW_AT_prototyped attribute
17327 is only meaninful for C, but the concept also extends to other
17328 languages that allow unprototyped functions (Eg: Objective C).
17329 For all other languages, assume that functions are always
17331 if (cu
->language
!= language_c
17332 && cu
->language
!= language_objc
17333 && cu
->language
!= language_opencl
)
17336 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17337 prototyped and unprototyped functions; default to prototyped,
17338 since that is more common in modern code (and RealView warns
17339 about unprototyped functions). */
17340 if (producer_is_realview (cu
->producer
))
17346 /* Handle DIES due to C code like:
17350 int (*funcp)(int a, long l);
17354 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17356 static struct type
*
17357 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17359 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17360 struct type
*type
; /* Type that this function returns. */
17361 struct type
*ftype
; /* Function that returns above type. */
17362 struct attribute
*attr
;
17364 type
= die_type (die
, cu
);
17366 /* The die_type call above may have already set the type for this DIE. */
17367 ftype
= get_die_type (die
, cu
);
17371 ftype
= lookup_function_type (type
);
17373 if (prototyped_function_p (die
, cu
))
17374 TYPE_PROTOTYPED (ftype
) = 1;
17376 /* Store the calling convention in the type if it's available in
17377 the subroutine die. Otherwise set the calling convention to
17378 the default value DW_CC_normal. */
17379 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
17381 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
17382 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
17383 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
17385 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
17387 /* Record whether the function returns normally to its caller or not
17388 if the DWARF producer set that information. */
17389 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
17390 if (attr
&& (DW_UNSND (attr
) != 0))
17391 TYPE_NO_RETURN (ftype
) = 1;
17393 /* We need to add the subroutine type to the die immediately so
17394 we don't infinitely recurse when dealing with parameters
17395 declared as the same subroutine type. */
17396 set_die_type (die
, ftype
, cu
);
17398 if (die
->child
!= NULL
)
17400 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
17401 struct die_info
*child_die
;
17402 int nparams
, iparams
;
17404 /* Count the number of parameters.
17405 FIXME: GDB currently ignores vararg functions, but knows about
17406 vararg member functions. */
17408 child_die
= die
->child
;
17409 while (child_die
&& child_die
->tag
)
17411 if (child_die
->tag
== DW_TAG_formal_parameter
)
17413 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
17414 TYPE_VARARGS (ftype
) = 1;
17415 child_die
= sibling_die (child_die
);
17418 /* Allocate storage for parameters and fill them in. */
17419 TYPE_NFIELDS (ftype
) = nparams
;
17420 TYPE_FIELDS (ftype
) = (struct field
*)
17421 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
17423 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17424 even if we error out during the parameters reading below. */
17425 for (iparams
= 0; iparams
< nparams
; iparams
++)
17426 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
17429 child_die
= die
->child
;
17430 while (child_die
&& child_die
->tag
)
17432 if (child_die
->tag
== DW_TAG_formal_parameter
)
17434 struct type
*arg_type
;
17436 /* DWARF version 2 has no clean way to discern C++
17437 static and non-static member functions. G++ helps
17438 GDB by marking the first parameter for non-static
17439 member functions (which is the this pointer) as
17440 artificial. We pass this information to
17441 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17443 DWARF version 3 added DW_AT_object_pointer, which GCC
17444 4.5 does not yet generate. */
17445 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
17447 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
17449 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
17450 arg_type
= die_type (child_die
, cu
);
17452 /* RealView does not mark THIS as const, which the testsuite
17453 expects. GCC marks THIS as const in method definitions,
17454 but not in the class specifications (GCC PR 43053). */
17455 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
17456 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
17459 struct dwarf2_cu
*arg_cu
= cu
;
17460 const char *name
= dwarf2_name (child_die
, cu
);
17462 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
17465 /* If the compiler emits this, use it. */
17466 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
17469 else if (name
&& strcmp (name
, "this") == 0)
17470 /* Function definitions will have the argument names. */
17472 else if (name
== NULL
&& iparams
== 0)
17473 /* Declarations may not have the names, so like
17474 elsewhere in GDB, assume an artificial first
17475 argument is "this". */
17479 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
17483 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
17486 child_die
= sibling_die (child_die
);
17493 static struct type
*
17494 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
17496 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17497 const char *name
= NULL
;
17498 struct type
*this_type
, *target_type
;
17500 name
= dwarf2_full_name (NULL
, die
, cu
);
17501 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
17502 TYPE_TARGET_STUB (this_type
) = 1;
17503 set_die_type (die
, this_type
, cu
);
17504 target_type
= die_type (die
, cu
);
17505 if (target_type
!= this_type
)
17506 TYPE_TARGET_TYPE (this_type
) = target_type
;
17509 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17510 spec and cause infinite loops in GDB. */
17511 complaint (_("Self-referential DW_TAG_typedef "
17512 "- DIE at %s [in module %s]"),
17513 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
17514 TYPE_TARGET_TYPE (this_type
) = NULL
;
17519 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17520 (which may be different from NAME) to the architecture back-end to allow
17521 it to guess the correct format if necessary. */
17523 static struct type
*
17524 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
17525 const char *name_hint
)
17527 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17528 const struct floatformat
**format
;
17531 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
17533 type
= init_float_type (objfile
, bits
, name
, format
);
17535 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17540 /* Allocate an integer type of size BITS and name NAME. */
17542 static struct type
*
17543 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
17544 int bits
, int unsigned_p
, const char *name
)
17548 /* Versions of Intel's C Compiler generate an integer type called "void"
17549 instead of using DW_TAG_unspecified_type. This has been seen on
17550 at least versions 14, 17, and 18. */
17551 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
17552 && strcmp (name
, "void") == 0)
17553 type
= objfile_type (objfile
)->builtin_void
;
17555 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
17560 /* Initialise and return a floating point type of size BITS suitable for
17561 use as a component of a complex number. The NAME_HINT is passed through
17562 when initialising the floating point type and is the name of the complex
17565 As DWARF doesn't currently provide an explicit name for the components
17566 of a complex number, but it can be helpful to have these components
17567 named, we try to select a suitable name based on the size of the
17569 static struct type
*
17570 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
17571 struct objfile
*objfile
,
17572 int bits
, const char *name_hint
)
17574 gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17575 struct type
*tt
= nullptr;
17577 /* Try to find a suitable floating point builtin type of size BITS.
17578 We're going to use the name of this type as the name for the complex
17579 target type that we are about to create. */
17580 switch (cu
->language
)
17582 case language_fortran
:
17586 tt
= builtin_f_type (gdbarch
)->builtin_real
;
17589 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
17591 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17593 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
17601 tt
= builtin_type (gdbarch
)->builtin_float
;
17604 tt
= builtin_type (gdbarch
)->builtin_double
;
17606 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17608 tt
= builtin_type (gdbarch
)->builtin_long_double
;
17614 /* If the type we found doesn't match the size we were looking for, then
17615 pretend we didn't find a type at all, the complex target type we
17616 create will then be nameless. */
17617 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
17620 const char *name
= (tt
== nullptr) ? nullptr : TYPE_NAME (tt
);
17621 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
);
17624 /* Find a representation of a given base type and install
17625 it in the TYPE field of the die. */
17627 static struct type
*
17628 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17630 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17632 struct attribute
*attr
;
17633 int encoding
= 0, bits
= 0;
17636 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
17639 encoding
= DW_UNSND (attr
);
17641 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17644 bits
= DW_UNSND (attr
) * TARGET_CHAR_BIT
;
17646 name
= dwarf2_name (die
, cu
);
17649 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17654 case DW_ATE_address
:
17655 /* Turn DW_ATE_address into a void * pointer. */
17656 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
17657 type
= init_pointer_type (objfile
, bits
, name
, type
);
17659 case DW_ATE_boolean
:
17660 type
= init_boolean_type (objfile
, bits
, 1, name
);
17662 case DW_ATE_complex_float
:
17663 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
);
17664 type
= init_complex_type (objfile
, name
, type
);
17666 case DW_ATE_decimal_float
:
17667 type
= init_decfloat_type (objfile
, bits
, name
);
17670 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
);
17672 case DW_ATE_signed
:
17673 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
17675 case DW_ATE_unsigned
:
17676 if (cu
->language
== language_fortran
17678 && startswith (name
, "character("))
17679 type
= init_character_type (objfile
, bits
, 1, name
);
17681 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17683 case DW_ATE_signed_char
:
17684 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17685 || cu
->language
== language_pascal
17686 || cu
->language
== language_fortran
)
17687 type
= init_character_type (objfile
, bits
, 0, name
);
17689 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
17691 case DW_ATE_unsigned_char
:
17692 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17693 || cu
->language
== language_pascal
17694 || cu
->language
== language_fortran
17695 || cu
->language
== language_rust
)
17696 type
= init_character_type (objfile
, bits
, 1, name
);
17698 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17702 gdbarch
*arch
= get_objfile_arch (objfile
);
17705 type
= builtin_type (arch
)->builtin_char16
;
17706 else if (bits
== 32)
17707 type
= builtin_type (arch
)->builtin_char32
;
17710 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17712 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17714 return set_die_type (die
, type
, cu
);
17719 complaint (_("unsupported DW_AT_encoding: '%s'"),
17720 dwarf_type_encoding_name (encoding
));
17721 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17725 if (name
&& strcmp (name
, "char") == 0)
17726 TYPE_NOSIGN (type
) = 1;
17728 maybe_set_alignment (cu
, die
, type
);
17730 return set_die_type (die
, type
, cu
);
17733 /* Parse dwarf attribute if it's a block, reference or constant and put the
17734 resulting value of the attribute into struct bound_prop.
17735 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17738 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
17739 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
17740 struct type
*default_type
)
17742 struct dwarf2_property_baton
*baton
;
17743 struct obstack
*obstack
17744 = &cu
->per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
;
17746 gdb_assert (default_type
!= NULL
);
17748 if (attr
== NULL
|| prop
== NULL
)
17751 if (attr_form_is_block (attr
))
17753 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17754 baton
->property_type
= default_type
;
17755 baton
->locexpr
.per_cu
= cu
->per_cu
;
17756 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
17757 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
17758 baton
->locexpr
.is_reference
= false;
17759 prop
->data
.baton
= baton
;
17760 prop
->kind
= PROP_LOCEXPR
;
17761 gdb_assert (prop
->data
.baton
!= NULL
);
17763 else if (attr_form_is_ref (attr
))
17765 struct dwarf2_cu
*target_cu
= cu
;
17766 struct die_info
*target_die
;
17767 struct attribute
*target_attr
;
17769 target_die
= follow_die_ref (die
, attr
, &target_cu
);
17770 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
17771 if (target_attr
== NULL
)
17772 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
17774 if (target_attr
== NULL
)
17777 switch (target_attr
->name
)
17779 case DW_AT_location
:
17780 if (attr_form_is_section_offset (target_attr
))
17782 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17783 baton
->property_type
= die_type (target_die
, target_cu
);
17784 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
17785 prop
->data
.baton
= baton
;
17786 prop
->kind
= PROP_LOCLIST
;
17787 gdb_assert (prop
->data
.baton
!= NULL
);
17789 else if (attr_form_is_block (target_attr
))
17791 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17792 baton
->property_type
= die_type (target_die
, target_cu
);
17793 baton
->locexpr
.per_cu
= cu
->per_cu
;
17794 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
17795 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
17796 baton
->locexpr
.is_reference
= true;
17797 prop
->data
.baton
= baton
;
17798 prop
->kind
= PROP_LOCEXPR
;
17799 gdb_assert (prop
->data
.baton
!= NULL
);
17803 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17804 "dynamic property");
17808 case DW_AT_data_member_location
:
17812 if (!handle_data_member_location (target_die
, target_cu
,
17816 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17817 baton
->property_type
= read_type_die (target_die
->parent
,
17819 baton
->offset_info
.offset
= offset
;
17820 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
17821 prop
->data
.baton
= baton
;
17822 prop
->kind
= PROP_ADDR_OFFSET
;
17827 else if (attr_form_is_constant (attr
))
17829 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
17830 prop
->kind
= PROP_CONST
;
17834 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
17835 dwarf2_name (die
, cu
));
17842 /* Find an integer type the same size as the address size given in the
17843 compilation unit header for PER_CU. UNSIGNED_P controls if the integer
17844 is unsigned or not. */
17846 static struct type
*
17847 dwarf2_per_cu_addr_sized_int_type (struct dwarf2_per_cu_data
*per_cu
,
17850 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
17851 int addr_size
= dwarf2_per_cu_addr_size (per_cu
);
17852 struct type
*int_type
;
17854 /* Helper macro to examine the various builtin types. */
17855 #define TRY_TYPE(F) \
17856 int_type = (unsigned_p \
17857 ? objfile_type (objfile)->builtin_unsigned_ ## F \
17858 : objfile_type (objfile)->builtin_ ## F); \
17859 if (int_type != NULL && TYPE_LENGTH (int_type) == addr_size) \
17866 TRY_TYPE (long_long
);
17870 gdb_assert_not_reached ("unable to find suitable integer type");
17873 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
17874 present (which is valid) then compute the default type based on the
17875 compilation units address size. */
17877 static struct type
*
17878 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17880 struct type
*index_type
= die_type (die
, cu
);
17882 /* Dwarf-2 specifications explicitly allows to create subrange types
17883 without specifying a base type.
17884 In that case, the base type must be set to the type of
17885 the lower bound, upper bound or count, in that order, if any of these
17886 three attributes references an object that has a type.
17887 If no base type is found, the Dwarf-2 specifications say that
17888 a signed integer type of size equal to the size of an address should
17890 For the following C code: `extern char gdb_int [];'
17891 GCC produces an empty range DIE.
17892 FIXME: muller/2010-05-28: Possible references to object for low bound,
17893 high bound or count are not yet handled by this code. */
17894 if (TYPE_CODE (index_type
) == TYPE_CODE_VOID
)
17895 index_type
= dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
17900 /* Read the given DW_AT_subrange DIE. */
17902 static struct type
*
17903 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17905 struct type
*base_type
, *orig_base_type
;
17906 struct type
*range_type
;
17907 struct attribute
*attr
;
17908 struct dynamic_prop low
, high
;
17909 int low_default_is_valid
;
17910 int high_bound_is_count
= 0;
17912 ULONGEST negative_mask
;
17914 orig_base_type
= read_subrange_index_type (die
, cu
);
17916 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17917 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17918 creating the range type, but we use the result of check_typedef
17919 when examining properties of the type. */
17920 base_type
= check_typedef (orig_base_type
);
17922 /* The die_type call above may have already set the type for this DIE. */
17923 range_type
= get_die_type (die
, cu
);
17927 low
.kind
= PROP_CONST
;
17928 high
.kind
= PROP_CONST
;
17929 high
.data
.const_val
= 0;
17931 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17932 omitting DW_AT_lower_bound. */
17933 switch (cu
->language
)
17936 case language_cplus
:
17937 low
.data
.const_val
= 0;
17938 low_default_is_valid
= 1;
17940 case language_fortran
:
17941 low
.data
.const_val
= 1;
17942 low_default_is_valid
= 1;
17945 case language_objc
:
17946 case language_rust
:
17947 low
.data
.const_val
= 0;
17948 low_default_is_valid
= (cu
->header
.version
>= 4);
17952 case language_pascal
:
17953 low
.data
.const_val
= 1;
17954 low_default_is_valid
= (cu
->header
.version
>= 4);
17957 low
.data
.const_val
= 0;
17958 low_default_is_valid
= 0;
17962 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
17964 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
17965 else if (!low_default_is_valid
)
17966 complaint (_("Missing DW_AT_lower_bound "
17967 "- DIE at %s [in module %s]"),
17968 sect_offset_str (die
->sect_off
),
17969 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17971 struct attribute
*attr_ub
, *attr_count
;
17972 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
17973 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
17975 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
17976 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
17978 /* If bounds are constant do the final calculation here. */
17979 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
17980 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
17982 high_bound_is_count
= 1;
17986 if (attr_ub
!= NULL
)
17987 complaint (_("Unresolved DW_AT_upper_bound "
17988 "- DIE at %s [in module %s]"),
17989 sect_offset_str (die
->sect_off
),
17990 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17991 if (attr_count
!= NULL
)
17992 complaint (_("Unresolved DW_AT_count "
17993 "- DIE at %s [in module %s]"),
17994 sect_offset_str (die
->sect_off
),
17995 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
18000 struct attribute
*bias_attr
= dwarf2_attr (die
, DW_AT_GNU_bias
, cu
);
18001 if (bias_attr
!= nullptr && attr_form_is_constant (bias_attr
))
18002 bias
= dwarf2_get_attr_constant_value (bias_attr
, 0);
18004 /* Normally, the DWARF producers are expected to use a signed
18005 constant form (Eg. DW_FORM_sdata) to express negative bounds.
18006 But this is unfortunately not always the case, as witnessed
18007 with GCC, for instance, where the ambiguous DW_FORM_dataN form
18008 is used instead. To work around that ambiguity, we treat
18009 the bounds as signed, and thus sign-extend their values, when
18010 the base type is signed. */
18012 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
18013 if (low
.kind
== PROP_CONST
18014 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
18015 low
.data
.const_val
|= negative_mask
;
18016 if (high
.kind
== PROP_CONST
18017 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
18018 high
.data
.const_val
|= negative_mask
;
18020 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
, bias
);
18022 if (high_bound_is_count
)
18023 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
18025 /* Ada expects an empty array on no boundary attributes. */
18026 if (attr
== NULL
&& cu
->language
!= language_ada
)
18027 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
18029 name
= dwarf2_name (die
, cu
);
18031 TYPE_NAME (range_type
) = name
;
18033 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
18035 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
18037 maybe_set_alignment (cu
, die
, range_type
);
18039 set_die_type (die
, range_type
, cu
);
18041 /* set_die_type should be already done. */
18042 set_descriptive_type (range_type
, die
, cu
);
18047 static struct type
*
18048 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
18052 type
= init_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
, TYPE_CODE_VOID
,0,
18054 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
18056 /* In Ada, an unspecified type is typically used when the description
18057 of the type is defered to a different unit. When encountering
18058 such a type, we treat it as a stub, and try to resolve it later on,
18060 if (cu
->language
== language_ada
)
18061 TYPE_STUB (type
) = 1;
18063 return set_die_type (die
, type
, cu
);
18066 /* Read a single die and all its descendents. Set the die's sibling
18067 field to NULL; set other fields in the die correctly, and set all
18068 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
18069 location of the info_ptr after reading all of those dies. PARENT
18070 is the parent of the die in question. */
18072 static struct die_info
*
18073 read_die_and_children (const struct die_reader_specs
*reader
,
18074 const gdb_byte
*info_ptr
,
18075 const gdb_byte
**new_info_ptr
,
18076 struct die_info
*parent
)
18078 struct die_info
*die
;
18079 const gdb_byte
*cur_ptr
;
18082 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
18085 *new_info_ptr
= cur_ptr
;
18088 store_in_ref_table (die
, reader
->cu
);
18091 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
18095 *new_info_ptr
= cur_ptr
;
18098 die
->sibling
= NULL
;
18099 die
->parent
= parent
;
18103 /* Read a die, all of its descendents, and all of its siblings; set
18104 all of the fields of all of the dies correctly. Arguments are as
18105 in read_die_and_children. */
18107 static struct die_info
*
18108 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
18109 const gdb_byte
*info_ptr
,
18110 const gdb_byte
**new_info_ptr
,
18111 struct die_info
*parent
)
18113 struct die_info
*first_die
, *last_sibling
;
18114 const gdb_byte
*cur_ptr
;
18116 cur_ptr
= info_ptr
;
18117 first_die
= last_sibling
= NULL
;
18121 struct die_info
*die
18122 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
18126 *new_info_ptr
= cur_ptr
;
18133 last_sibling
->sibling
= die
;
18135 last_sibling
= die
;
18139 /* Read a die, all of its descendents, and all of its siblings; set
18140 all of the fields of all of the dies correctly. Arguments are as
18141 in read_die_and_children.
18142 This the main entry point for reading a DIE and all its children. */
18144 static struct die_info
*
18145 read_die_and_siblings (const struct die_reader_specs
*reader
,
18146 const gdb_byte
*info_ptr
,
18147 const gdb_byte
**new_info_ptr
,
18148 struct die_info
*parent
)
18150 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
18151 new_info_ptr
, parent
);
18153 if (dwarf_die_debug
)
18155 fprintf_unfiltered (gdb_stdlog
,
18156 "Read die from %s@0x%x of %s:\n",
18157 get_section_name (reader
->die_section
),
18158 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18159 bfd_get_filename (reader
->abfd
));
18160 dump_die (die
, dwarf_die_debug
);
18166 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18168 The caller is responsible for filling in the extra attributes
18169 and updating (*DIEP)->num_attrs.
18170 Set DIEP to point to a newly allocated die with its information,
18171 except for its child, sibling, and parent fields.
18172 Set HAS_CHILDREN to tell whether the die has children or not. */
18174 static const gdb_byte
*
18175 read_full_die_1 (const struct die_reader_specs
*reader
,
18176 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18177 int *has_children
, int num_extra_attrs
)
18179 unsigned int abbrev_number
, bytes_read
, i
;
18180 struct abbrev_info
*abbrev
;
18181 struct die_info
*die
;
18182 struct dwarf2_cu
*cu
= reader
->cu
;
18183 bfd
*abfd
= reader
->abfd
;
18185 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
18186 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18187 info_ptr
+= bytes_read
;
18188 if (!abbrev_number
)
18195 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
18197 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18199 bfd_get_filename (abfd
));
18201 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
18202 die
->sect_off
= sect_off
;
18203 die
->tag
= abbrev
->tag
;
18204 die
->abbrev
= abbrev_number
;
18206 /* Make the result usable.
18207 The caller needs to update num_attrs after adding the extra
18209 die
->num_attrs
= abbrev
->num_attrs
;
18211 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18212 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
18216 *has_children
= abbrev
->has_children
;
18220 /* Read a die and all its attributes.
18221 Set DIEP to point to a newly allocated die with its information,
18222 except for its child, sibling, and parent fields.
18223 Set HAS_CHILDREN to tell whether the die has children or not. */
18225 static const gdb_byte
*
18226 read_full_die (const struct die_reader_specs
*reader
,
18227 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18230 const gdb_byte
*result
;
18232 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
18234 if (dwarf_die_debug
)
18236 fprintf_unfiltered (gdb_stdlog
,
18237 "Read die from %s@0x%x of %s:\n",
18238 get_section_name (reader
->die_section
),
18239 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18240 bfd_get_filename (reader
->abfd
));
18241 dump_die (*diep
, dwarf_die_debug
);
18247 /* Abbreviation tables.
18249 In DWARF version 2, the description of the debugging information is
18250 stored in a separate .debug_abbrev section. Before we read any
18251 dies from a section we read in all abbreviations and install them
18252 in a hash table. */
18254 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18256 struct abbrev_info
*
18257 abbrev_table::alloc_abbrev ()
18259 struct abbrev_info
*abbrev
;
18261 abbrev
= XOBNEW (&abbrev_obstack
, struct abbrev_info
);
18262 memset (abbrev
, 0, sizeof (struct abbrev_info
));
18267 /* Add an abbreviation to the table. */
18270 abbrev_table::add_abbrev (unsigned int abbrev_number
,
18271 struct abbrev_info
*abbrev
)
18273 unsigned int hash_number
;
18275 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
18276 abbrev
->next
= m_abbrevs
[hash_number
];
18277 m_abbrevs
[hash_number
] = abbrev
;
18280 /* Look up an abbrev in the table.
18281 Returns NULL if the abbrev is not found. */
18283 struct abbrev_info
*
18284 abbrev_table::lookup_abbrev (unsigned int abbrev_number
)
18286 unsigned int hash_number
;
18287 struct abbrev_info
*abbrev
;
18289 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
18290 abbrev
= m_abbrevs
[hash_number
];
18294 if (abbrev
->number
== abbrev_number
)
18296 abbrev
= abbrev
->next
;
18301 /* Read in an abbrev table. */
18303 static abbrev_table_up
18304 abbrev_table_read_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
18305 struct dwarf2_section_info
*section
,
18306 sect_offset sect_off
)
18308 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18309 bfd
*abfd
= get_section_bfd_owner (section
);
18310 const gdb_byte
*abbrev_ptr
;
18311 struct abbrev_info
*cur_abbrev
;
18312 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
18313 unsigned int abbrev_form
;
18314 struct attr_abbrev
*cur_attrs
;
18315 unsigned int allocated_attrs
;
18317 abbrev_table_up
abbrev_table (new struct abbrev_table (sect_off
));
18319 dwarf2_read_section (objfile
, section
);
18320 abbrev_ptr
= section
->buffer
+ to_underlying (sect_off
);
18321 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18322 abbrev_ptr
+= bytes_read
;
18324 allocated_attrs
= ATTR_ALLOC_CHUNK
;
18325 cur_attrs
= XNEWVEC (struct attr_abbrev
, allocated_attrs
);
18327 /* Loop until we reach an abbrev number of 0. */
18328 while (abbrev_number
)
18330 cur_abbrev
= abbrev_table
->alloc_abbrev ();
18332 /* read in abbrev header */
18333 cur_abbrev
->number
= abbrev_number
;
18335 = (enum dwarf_tag
) read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18336 abbrev_ptr
+= bytes_read
;
18337 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
18340 /* now read in declarations */
18343 LONGEST implicit_const
;
18345 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18346 abbrev_ptr
+= bytes_read
;
18347 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18348 abbrev_ptr
+= bytes_read
;
18349 if (abbrev_form
== DW_FORM_implicit_const
)
18351 implicit_const
= read_signed_leb128 (abfd
, abbrev_ptr
,
18353 abbrev_ptr
+= bytes_read
;
18357 /* Initialize it due to a false compiler warning. */
18358 implicit_const
= -1;
18361 if (abbrev_name
== 0)
18364 if (cur_abbrev
->num_attrs
== allocated_attrs
)
18366 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
18368 = XRESIZEVEC (struct attr_abbrev
, cur_attrs
, allocated_attrs
);
18371 cur_attrs
[cur_abbrev
->num_attrs
].name
18372 = (enum dwarf_attribute
) abbrev_name
;
18373 cur_attrs
[cur_abbrev
->num_attrs
].form
18374 = (enum dwarf_form
) abbrev_form
;
18375 cur_attrs
[cur_abbrev
->num_attrs
].implicit_const
= implicit_const
;
18376 ++cur_abbrev
->num_attrs
;
18379 cur_abbrev
->attrs
=
18380 XOBNEWVEC (&abbrev_table
->abbrev_obstack
, struct attr_abbrev
,
18381 cur_abbrev
->num_attrs
);
18382 memcpy (cur_abbrev
->attrs
, cur_attrs
,
18383 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
18385 abbrev_table
->add_abbrev (abbrev_number
, cur_abbrev
);
18387 /* Get next abbreviation.
18388 Under Irix6 the abbreviations for a compilation unit are not
18389 always properly terminated with an abbrev number of 0.
18390 Exit loop if we encounter an abbreviation which we have
18391 already read (which means we are about to read the abbreviations
18392 for the next compile unit) or if the end of the abbreviation
18393 table is reached. */
18394 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
18396 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18397 abbrev_ptr
+= bytes_read
;
18398 if (abbrev_table
->lookup_abbrev (abbrev_number
) != NULL
)
18403 return abbrev_table
;
18406 /* Returns nonzero if TAG represents a type that we might generate a partial
18410 is_type_tag_for_partial (int tag
)
18415 /* Some types that would be reasonable to generate partial symbols for,
18416 that we don't at present. */
18417 case DW_TAG_array_type
:
18418 case DW_TAG_file_type
:
18419 case DW_TAG_ptr_to_member_type
:
18420 case DW_TAG_set_type
:
18421 case DW_TAG_string_type
:
18422 case DW_TAG_subroutine_type
:
18424 case DW_TAG_base_type
:
18425 case DW_TAG_class_type
:
18426 case DW_TAG_interface_type
:
18427 case DW_TAG_enumeration_type
:
18428 case DW_TAG_structure_type
:
18429 case DW_TAG_subrange_type
:
18430 case DW_TAG_typedef
:
18431 case DW_TAG_union_type
:
18438 /* Load all DIEs that are interesting for partial symbols into memory. */
18440 static struct partial_die_info
*
18441 load_partial_dies (const struct die_reader_specs
*reader
,
18442 const gdb_byte
*info_ptr
, int building_psymtab
)
18444 struct dwarf2_cu
*cu
= reader
->cu
;
18445 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
18446 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
18447 unsigned int bytes_read
;
18448 unsigned int load_all
= 0;
18449 int nesting_level
= 1;
18454 gdb_assert (cu
->per_cu
!= NULL
);
18455 if (cu
->per_cu
->load_all_dies
)
18459 = htab_create_alloc_ex (cu
->header
.length
/ 12,
18463 &cu
->comp_unit_obstack
,
18464 hashtab_obstack_allocate
,
18465 dummy_obstack_deallocate
);
18469 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
18471 /* A NULL abbrev means the end of a series of children. */
18472 if (abbrev
== NULL
)
18474 if (--nesting_level
== 0)
18477 info_ptr
+= bytes_read
;
18478 last_die
= parent_die
;
18479 parent_die
= parent_die
->die_parent
;
18483 /* Check for template arguments. We never save these; if
18484 they're seen, we just mark the parent, and go on our way. */
18485 if (parent_die
!= NULL
18486 && cu
->language
== language_cplus
18487 && (abbrev
->tag
== DW_TAG_template_type_param
18488 || abbrev
->tag
== DW_TAG_template_value_param
))
18490 parent_die
->has_template_arguments
= 1;
18494 /* We don't need a partial DIE for the template argument. */
18495 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18500 /* We only recurse into c++ subprograms looking for template arguments.
18501 Skip their other children. */
18503 && cu
->language
== language_cplus
18504 && parent_die
!= NULL
18505 && parent_die
->tag
== DW_TAG_subprogram
)
18507 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18511 /* Check whether this DIE is interesting enough to save. Normally
18512 we would not be interested in members here, but there may be
18513 later variables referencing them via DW_AT_specification (for
18514 static members). */
18516 && !is_type_tag_for_partial (abbrev
->tag
)
18517 && abbrev
->tag
!= DW_TAG_constant
18518 && abbrev
->tag
!= DW_TAG_enumerator
18519 && abbrev
->tag
!= DW_TAG_subprogram
18520 && abbrev
->tag
!= DW_TAG_inlined_subroutine
18521 && abbrev
->tag
!= DW_TAG_lexical_block
18522 && abbrev
->tag
!= DW_TAG_variable
18523 && abbrev
->tag
!= DW_TAG_namespace
18524 && abbrev
->tag
!= DW_TAG_module
18525 && abbrev
->tag
!= DW_TAG_member
18526 && abbrev
->tag
!= DW_TAG_imported_unit
18527 && abbrev
->tag
!= DW_TAG_imported_declaration
)
18529 /* Otherwise we skip to the next sibling, if any. */
18530 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18534 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
18537 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
18539 /* This two-pass algorithm for processing partial symbols has a
18540 high cost in cache pressure. Thus, handle some simple cases
18541 here which cover the majority of C partial symbols. DIEs
18542 which neither have specification tags in them, nor could have
18543 specification tags elsewhere pointing at them, can simply be
18544 processed and discarded.
18546 This segment is also optional; scan_partial_symbols and
18547 add_partial_symbol will handle these DIEs if we chain
18548 them in normally. When compilers which do not emit large
18549 quantities of duplicate debug information are more common,
18550 this code can probably be removed. */
18552 /* Any complete simple types at the top level (pretty much all
18553 of them, for a language without namespaces), can be processed
18555 if (parent_die
== NULL
18556 && pdi
.has_specification
== 0
18557 && pdi
.is_declaration
== 0
18558 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
18559 || pdi
.tag
== DW_TAG_base_type
18560 || pdi
.tag
== DW_TAG_subrange_type
))
18562 if (building_psymtab
&& pdi
.name
!= NULL
)
18563 add_psymbol_to_list (pdi
.name
, strlen (pdi
.name
), false,
18564 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
18565 psymbol_placement::STATIC
,
18566 0, cu
->language
, objfile
);
18567 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18571 /* The exception for DW_TAG_typedef with has_children above is
18572 a workaround of GCC PR debug/47510. In the case of this complaint
18573 type_name_or_error will error on such types later.
18575 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18576 it could not find the child DIEs referenced later, this is checked
18577 above. In correct DWARF DW_TAG_typedef should have no children. */
18579 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
18580 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18581 "- DIE at %s [in module %s]"),
18582 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
18584 /* If we're at the second level, and we're an enumerator, and
18585 our parent has no specification (meaning possibly lives in a
18586 namespace elsewhere), then we can add the partial symbol now
18587 instead of queueing it. */
18588 if (pdi
.tag
== DW_TAG_enumerator
18589 && parent_die
!= NULL
18590 && parent_die
->die_parent
== NULL
18591 && parent_die
->tag
== DW_TAG_enumeration_type
18592 && parent_die
->has_specification
== 0)
18594 if (pdi
.name
== NULL
)
18595 complaint (_("malformed enumerator DIE ignored"));
18596 else if (building_psymtab
)
18597 add_psymbol_to_list (pdi
.name
, strlen (pdi
.name
), false,
18598 VAR_DOMAIN
, LOC_CONST
, -1,
18599 cu
->language
== language_cplus
18600 ? psymbol_placement::GLOBAL
18601 : psymbol_placement::STATIC
,
18602 0, cu
->language
, objfile
);
18604 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18608 struct partial_die_info
*part_die
18609 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
18611 /* We'll save this DIE so link it in. */
18612 part_die
->die_parent
= parent_die
;
18613 part_die
->die_sibling
= NULL
;
18614 part_die
->die_child
= NULL
;
18616 if (last_die
&& last_die
== parent_die
)
18617 last_die
->die_child
= part_die
;
18619 last_die
->die_sibling
= part_die
;
18621 last_die
= part_die
;
18623 if (first_die
== NULL
)
18624 first_die
= part_die
;
18626 /* Maybe add the DIE to the hash table. Not all DIEs that we
18627 find interesting need to be in the hash table, because we
18628 also have the parent/sibling/child chains; only those that we
18629 might refer to by offset later during partial symbol reading.
18631 For now this means things that might have be the target of a
18632 DW_AT_specification, DW_AT_abstract_origin, or
18633 DW_AT_extension. DW_AT_extension will refer only to
18634 namespaces; DW_AT_abstract_origin refers to functions (and
18635 many things under the function DIE, but we do not recurse
18636 into function DIEs during partial symbol reading) and
18637 possibly variables as well; DW_AT_specification refers to
18638 declarations. Declarations ought to have the DW_AT_declaration
18639 flag. It happens that GCC forgets to put it in sometimes, but
18640 only for functions, not for types.
18642 Adding more things than necessary to the hash table is harmless
18643 except for the performance cost. Adding too few will result in
18644 wasted time in find_partial_die, when we reread the compilation
18645 unit with load_all_dies set. */
18648 || abbrev
->tag
== DW_TAG_constant
18649 || abbrev
->tag
== DW_TAG_subprogram
18650 || abbrev
->tag
== DW_TAG_variable
18651 || abbrev
->tag
== DW_TAG_namespace
18652 || part_die
->is_declaration
)
18656 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
18657 to_underlying (part_die
->sect_off
),
18662 /* For some DIEs we want to follow their children (if any). For C
18663 we have no reason to follow the children of structures; for other
18664 languages we have to, so that we can get at method physnames
18665 to infer fully qualified class names, for DW_AT_specification,
18666 and for C++ template arguments. For C++, we also look one level
18667 inside functions to find template arguments (if the name of the
18668 function does not already contain the template arguments).
18670 For Ada and Fortran, we need to scan the children of subprograms
18671 and lexical blocks as well because these languages allow the
18672 definition of nested entities that could be interesting for the
18673 debugger, such as nested subprograms for instance. */
18674 if (last_die
->has_children
18676 || last_die
->tag
== DW_TAG_namespace
18677 || last_die
->tag
== DW_TAG_module
18678 || last_die
->tag
== DW_TAG_enumeration_type
18679 || (cu
->language
== language_cplus
18680 && last_die
->tag
== DW_TAG_subprogram
18681 && (last_die
->name
== NULL
18682 || strchr (last_die
->name
, '<') == NULL
))
18683 || (cu
->language
!= language_c
18684 && (last_die
->tag
== DW_TAG_class_type
18685 || last_die
->tag
== DW_TAG_interface_type
18686 || last_die
->tag
== DW_TAG_structure_type
18687 || last_die
->tag
== DW_TAG_union_type
))
18688 || ((cu
->language
== language_ada
18689 || cu
->language
== language_fortran
)
18690 && (last_die
->tag
== DW_TAG_subprogram
18691 || last_die
->tag
== DW_TAG_lexical_block
))))
18694 parent_die
= last_die
;
18698 /* Otherwise we skip to the next sibling, if any. */
18699 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
18701 /* Back to the top, do it again. */
18705 partial_die_info::partial_die_info (sect_offset sect_off_
,
18706 struct abbrev_info
*abbrev
)
18707 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
18711 /* Read a minimal amount of information into the minimal die structure.
18712 INFO_PTR should point just after the initial uleb128 of a DIE. */
18715 partial_die_info::read (const struct die_reader_specs
*reader
,
18716 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
18718 struct dwarf2_cu
*cu
= reader
->cu
;
18719 struct dwarf2_per_objfile
*dwarf2_per_objfile
18720 = cu
->per_cu
->dwarf2_per_objfile
;
18722 int has_low_pc_attr
= 0;
18723 int has_high_pc_attr
= 0;
18724 int high_pc_relative
= 0;
18726 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
18728 struct attribute attr
;
18730 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
18732 /* Store the data if it is of an attribute we want to keep in a
18733 partial symbol table. */
18739 case DW_TAG_compile_unit
:
18740 case DW_TAG_partial_unit
:
18741 case DW_TAG_type_unit
:
18742 /* Compilation units have a DW_AT_name that is a filename, not
18743 a source language identifier. */
18744 case DW_TAG_enumeration_type
:
18745 case DW_TAG_enumerator
:
18746 /* These tags always have simple identifiers already; no need
18747 to canonicalize them. */
18748 name
= DW_STRING (&attr
);
18752 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18755 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
18756 &objfile
->per_bfd
->storage_obstack
);
18761 case DW_AT_linkage_name
:
18762 case DW_AT_MIPS_linkage_name
:
18763 /* Note that both forms of linkage name might appear. We
18764 assume they will be the same, and we only store the last
18766 linkage_name
= DW_STRING (&attr
);
18769 has_low_pc_attr
= 1;
18770 lowpc
= attr_value_as_address (&attr
);
18772 case DW_AT_high_pc
:
18773 has_high_pc_attr
= 1;
18774 highpc
= attr_value_as_address (&attr
);
18775 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
18776 high_pc_relative
= 1;
18778 case DW_AT_location
:
18779 /* Support the .debug_loc offsets. */
18780 if (attr_form_is_block (&attr
))
18782 d
.locdesc
= DW_BLOCK (&attr
);
18784 else if (attr_form_is_section_offset (&attr
))
18786 dwarf2_complex_location_expr_complaint ();
18790 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18791 "partial symbol information");
18794 case DW_AT_external
:
18795 is_external
= DW_UNSND (&attr
);
18797 case DW_AT_declaration
:
18798 is_declaration
= DW_UNSND (&attr
);
18803 case DW_AT_abstract_origin
:
18804 case DW_AT_specification
:
18805 case DW_AT_extension
:
18806 has_specification
= 1;
18807 spec_offset
= dwarf2_get_ref_die_offset (&attr
);
18808 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
18809 || cu
->per_cu
->is_dwz
);
18811 case DW_AT_sibling
:
18812 /* Ignore absolute siblings, they might point outside of
18813 the current compile unit. */
18814 if (attr
.form
== DW_FORM_ref_addr
)
18815 complaint (_("ignoring absolute DW_AT_sibling"));
18818 const gdb_byte
*buffer
= reader
->buffer
;
18819 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
18820 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
18822 if (sibling_ptr
< info_ptr
)
18823 complaint (_("DW_AT_sibling points backwards"));
18824 else if (sibling_ptr
> reader
->buffer_end
)
18825 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
18827 sibling
= sibling_ptr
;
18830 case DW_AT_byte_size
:
18833 case DW_AT_const_value
:
18834 has_const_value
= 1;
18836 case DW_AT_calling_convention
:
18837 /* DWARF doesn't provide a way to identify a program's source-level
18838 entry point. DW_AT_calling_convention attributes are only meant
18839 to describe functions' calling conventions.
18841 However, because it's a necessary piece of information in
18842 Fortran, and before DWARF 4 DW_CC_program was the only
18843 piece of debugging information whose definition refers to
18844 a 'main program' at all, several compilers marked Fortran
18845 main programs with DW_CC_program --- even when those
18846 functions use the standard calling conventions.
18848 Although DWARF now specifies a way to provide this
18849 information, we support this practice for backward
18851 if (DW_UNSND (&attr
) == DW_CC_program
18852 && cu
->language
== language_fortran
)
18853 main_subprogram
= 1;
18856 if (DW_UNSND (&attr
) == DW_INL_inlined
18857 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
18858 may_be_inlined
= 1;
18862 if (tag
== DW_TAG_imported_unit
)
18864 d
.sect_off
= dwarf2_get_ref_die_offset (&attr
);
18865 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
18866 || cu
->per_cu
->is_dwz
);
18870 case DW_AT_main_subprogram
:
18871 main_subprogram
= DW_UNSND (&attr
);
18876 /* It would be nice to reuse dwarf2_get_pc_bounds here,
18877 but that requires a full DIE, so instead we just
18879 int need_ranges_base
= tag
!= DW_TAG_compile_unit
;
18880 unsigned int ranges_offset
= (DW_UNSND (&attr
)
18881 + (need_ranges_base
18885 /* Value of the DW_AT_ranges attribute is the offset in the
18886 .debug_ranges section. */
18887 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
18898 /* For Ada, if both the name and the linkage name appear, we prefer
18899 the latter. This lets "catch exception" work better, regardless
18900 of the order in which the name and linkage name were emitted.
18901 Really, though, this is just a workaround for the fact that gdb
18902 doesn't store both the name and the linkage name. */
18903 if (cu
->language
== language_ada
&& linkage_name
!= nullptr)
18904 name
= linkage_name
;
18906 if (high_pc_relative
)
18909 if (has_low_pc_attr
&& has_high_pc_attr
)
18911 /* When using the GNU linker, .gnu.linkonce. sections are used to
18912 eliminate duplicate copies of functions and vtables and such.
18913 The linker will arbitrarily choose one and discard the others.
18914 The AT_*_pc values for such functions refer to local labels in
18915 these sections. If the section from that file was discarded, the
18916 labels are not in the output, so the relocs get a value of 0.
18917 If this is a discarded function, mark the pc bounds as invalid,
18918 so that GDB will ignore it. */
18919 if (lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
18921 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18922 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18924 complaint (_("DW_AT_low_pc %s is zero "
18925 "for DIE at %s [in module %s]"),
18926 paddress (gdbarch
, lowpc
),
18927 sect_offset_str (sect_off
),
18928 objfile_name (objfile
));
18930 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18931 else if (lowpc
>= highpc
)
18933 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18934 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18936 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18937 "for DIE at %s [in module %s]"),
18938 paddress (gdbarch
, lowpc
),
18939 paddress (gdbarch
, highpc
),
18940 sect_offset_str (sect_off
),
18941 objfile_name (objfile
));
18950 /* Find a cached partial DIE at OFFSET in CU. */
18952 struct partial_die_info
*
18953 dwarf2_cu::find_partial_die (sect_offset sect_off
)
18955 struct partial_die_info
*lookup_die
= NULL
;
18956 struct partial_die_info
part_die (sect_off
);
18958 lookup_die
= ((struct partial_die_info
*)
18959 htab_find_with_hash (partial_dies
, &part_die
,
18960 to_underlying (sect_off
)));
18965 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18966 except in the case of .debug_types DIEs which do not reference
18967 outside their CU (they do however referencing other types via
18968 DW_FORM_ref_sig8). */
18970 static const struct cu_partial_die_info
18971 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
18973 struct dwarf2_per_objfile
*dwarf2_per_objfile
18974 = cu
->per_cu
->dwarf2_per_objfile
;
18975 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18976 struct dwarf2_per_cu_data
*per_cu
= NULL
;
18977 struct partial_die_info
*pd
= NULL
;
18979 if (offset_in_dwz
== cu
->per_cu
->is_dwz
18980 && offset_in_cu_p (&cu
->header
, sect_off
))
18982 pd
= cu
->find_partial_die (sect_off
);
18985 /* We missed recording what we needed.
18986 Load all dies and try again. */
18987 per_cu
= cu
->per_cu
;
18991 /* TUs don't reference other CUs/TUs (except via type signatures). */
18992 if (cu
->per_cu
->is_debug_types
)
18994 error (_("Dwarf Error: Type Unit at offset %s contains"
18995 " external reference to offset %s [in module %s].\n"),
18996 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
18997 bfd_get_filename (objfile
->obfd
));
18999 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
19000 dwarf2_per_objfile
);
19002 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
19003 load_partial_comp_unit (per_cu
);
19005 per_cu
->cu
->last_used
= 0;
19006 pd
= per_cu
->cu
->find_partial_die (sect_off
);
19009 /* If we didn't find it, and not all dies have been loaded,
19010 load them all and try again. */
19012 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
19014 per_cu
->load_all_dies
= 1;
19016 /* This is nasty. When we reread the DIEs, somewhere up the call chain
19017 THIS_CU->cu may already be in use. So we can't just free it and
19018 replace its DIEs with the ones we read in. Instead, we leave those
19019 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
19020 and clobber THIS_CU->cu->partial_dies with the hash table for the new
19022 load_partial_comp_unit (per_cu
);
19024 pd
= per_cu
->cu
->find_partial_die (sect_off
);
19028 internal_error (__FILE__
, __LINE__
,
19029 _("could not find partial DIE %s "
19030 "in cache [from module %s]\n"),
19031 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
19032 return { per_cu
->cu
, pd
};
19035 /* See if we can figure out if the class lives in a namespace. We do
19036 this by looking for a member function; its demangled name will
19037 contain namespace info, if there is any. */
19040 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
19041 struct dwarf2_cu
*cu
)
19043 /* NOTE: carlton/2003-10-07: Getting the info this way changes
19044 what template types look like, because the demangler
19045 frequently doesn't give the same name as the debug info. We
19046 could fix this by only using the demangled name to get the
19047 prefix (but see comment in read_structure_type). */
19049 struct partial_die_info
*real_pdi
;
19050 struct partial_die_info
*child_pdi
;
19052 /* If this DIE (this DIE's specification, if any) has a parent, then
19053 we should not do this. We'll prepend the parent's fully qualified
19054 name when we create the partial symbol. */
19056 real_pdi
= struct_pdi
;
19057 while (real_pdi
->has_specification
)
19059 auto res
= find_partial_die (real_pdi
->spec_offset
,
19060 real_pdi
->spec_is_dwz
, cu
);
19061 real_pdi
= res
.pdi
;
19065 if (real_pdi
->die_parent
!= NULL
)
19068 for (child_pdi
= struct_pdi
->die_child
;
19070 child_pdi
= child_pdi
->die_sibling
)
19072 if (child_pdi
->tag
== DW_TAG_subprogram
19073 && child_pdi
->linkage_name
!= NULL
)
19075 char *actual_class_name
19076 = language_class_name_from_physname (cu
->language_defn
,
19077 child_pdi
->linkage_name
);
19078 if (actual_class_name
!= NULL
)
19080 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
19082 = obstack_strdup (&objfile
->per_bfd
->storage_obstack
,
19083 actual_class_name
);
19084 xfree (actual_class_name
);
19092 partial_die_info::fixup (struct dwarf2_cu
*cu
)
19094 /* Once we've fixed up a die, there's no point in doing so again.
19095 This also avoids a memory leak if we were to call
19096 guess_partial_die_structure_name multiple times. */
19100 /* If we found a reference attribute and the DIE has no name, try
19101 to find a name in the referred to DIE. */
19103 if (name
== NULL
&& has_specification
)
19105 struct partial_die_info
*spec_die
;
19107 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19108 spec_die
= res
.pdi
;
19111 spec_die
->fixup (cu
);
19113 if (spec_die
->name
)
19115 name
= spec_die
->name
;
19117 /* Copy DW_AT_external attribute if it is set. */
19118 if (spec_die
->is_external
)
19119 is_external
= spec_die
->is_external
;
19123 /* Set default names for some unnamed DIEs. */
19125 if (name
== NULL
&& tag
== DW_TAG_namespace
)
19126 name
= CP_ANONYMOUS_NAMESPACE_STR
;
19128 /* If there is no parent die to provide a namespace, and there are
19129 children, see if we can determine the namespace from their linkage
19131 if (cu
->language
== language_cplus
19132 && !cu
->per_cu
->dwarf2_per_objfile
->types
.empty ()
19133 && die_parent
== NULL
19135 && (tag
== DW_TAG_class_type
19136 || tag
== DW_TAG_structure_type
19137 || tag
== DW_TAG_union_type
))
19138 guess_partial_die_structure_name (this, cu
);
19140 /* GCC might emit a nameless struct or union that has a linkage
19141 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19143 && (tag
== DW_TAG_class_type
19144 || tag
== DW_TAG_interface_type
19145 || tag
== DW_TAG_structure_type
19146 || tag
== DW_TAG_union_type
)
19147 && linkage_name
!= NULL
)
19151 demangled
= gdb_demangle (linkage_name
, DMGL_TYPES
);
19156 /* Strip any leading namespaces/classes, keep only the base name.
19157 DW_AT_name for named DIEs does not contain the prefixes. */
19158 base
= strrchr (demangled
, ':');
19159 if (base
&& base
> demangled
&& base
[-1] == ':')
19164 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
19165 name
= obstack_strdup (&objfile
->per_bfd
->storage_obstack
, base
);
19173 /* Read an attribute value described by an attribute form. */
19175 static const gdb_byte
*
19176 read_attribute_value (const struct die_reader_specs
*reader
,
19177 struct attribute
*attr
, unsigned form
,
19178 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
19180 struct dwarf2_cu
*cu
= reader
->cu
;
19181 struct dwarf2_per_objfile
*dwarf2_per_objfile
19182 = cu
->per_cu
->dwarf2_per_objfile
;
19183 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19184 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
19185 bfd
*abfd
= reader
->abfd
;
19186 struct comp_unit_head
*cu_header
= &cu
->header
;
19187 unsigned int bytes_read
;
19188 struct dwarf_block
*blk
;
19190 attr
->form
= (enum dwarf_form
) form
;
19193 case DW_FORM_ref_addr
:
19194 if (cu
->header
.version
== 2)
19195 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
19197 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
19198 &cu
->header
, &bytes_read
);
19199 info_ptr
+= bytes_read
;
19201 case DW_FORM_GNU_ref_alt
:
19202 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
19203 info_ptr
+= bytes_read
;
19206 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
19207 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
19208 info_ptr
+= bytes_read
;
19210 case DW_FORM_block2
:
19211 blk
= dwarf_alloc_block (cu
);
19212 blk
->size
= read_2_bytes (abfd
, info_ptr
);
19214 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19215 info_ptr
+= blk
->size
;
19216 DW_BLOCK (attr
) = blk
;
19218 case DW_FORM_block4
:
19219 blk
= dwarf_alloc_block (cu
);
19220 blk
->size
= read_4_bytes (abfd
, info_ptr
);
19222 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19223 info_ptr
+= blk
->size
;
19224 DW_BLOCK (attr
) = blk
;
19226 case DW_FORM_data2
:
19227 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
19230 case DW_FORM_data4
:
19231 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
19234 case DW_FORM_data8
:
19235 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
19238 case DW_FORM_data16
:
19239 blk
= dwarf_alloc_block (cu
);
19241 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
19243 DW_BLOCK (attr
) = blk
;
19245 case DW_FORM_sec_offset
:
19246 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
19247 info_ptr
+= bytes_read
;
19249 case DW_FORM_string
:
19250 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
19251 DW_STRING_IS_CANONICAL (attr
) = 0;
19252 info_ptr
+= bytes_read
;
19255 if (!cu
->per_cu
->is_dwz
)
19257 DW_STRING (attr
) = read_indirect_string (dwarf2_per_objfile
,
19258 abfd
, info_ptr
, cu_header
,
19260 DW_STRING_IS_CANONICAL (attr
) = 0;
19261 info_ptr
+= bytes_read
;
19265 case DW_FORM_line_strp
:
19266 if (!cu
->per_cu
->is_dwz
)
19268 DW_STRING (attr
) = read_indirect_line_string (dwarf2_per_objfile
,
19270 cu_header
, &bytes_read
);
19271 DW_STRING_IS_CANONICAL (attr
) = 0;
19272 info_ptr
+= bytes_read
;
19276 case DW_FORM_GNU_strp_alt
:
19278 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
19279 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
19282 DW_STRING (attr
) = read_indirect_string_from_dwz (objfile
,
19284 DW_STRING_IS_CANONICAL (attr
) = 0;
19285 info_ptr
+= bytes_read
;
19288 case DW_FORM_exprloc
:
19289 case DW_FORM_block
:
19290 blk
= dwarf_alloc_block (cu
);
19291 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19292 info_ptr
+= bytes_read
;
19293 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19294 info_ptr
+= blk
->size
;
19295 DW_BLOCK (attr
) = blk
;
19297 case DW_FORM_block1
:
19298 blk
= dwarf_alloc_block (cu
);
19299 blk
->size
= read_1_byte (abfd
, info_ptr
);
19301 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19302 info_ptr
+= blk
->size
;
19303 DW_BLOCK (attr
) = blk
;
19305 case DW_FORM_data1
:
19306 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
19310 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
19313 case DW_FORM_flag_present
:
19314 DW_UNSND (attr
) = 1;
19316 case DW_FORM_sdata
:
19317 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19318 info_ptr
+= bytes_read
;
19320 case DW_FORM_udata
:
19321 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19322 info_ptr
+= bytes_read
;
19325 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19326 + read_1_byte (abfd
, info_ptr
));
19330 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19331 + read_2_bytes (abfd
, info_ptr
));
19335 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19336 + read_4_bytes (abfd
, info_ptr
));
19340 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19341 + read_8_bytes (abfd
, info_ptr
));
19344 case DW_FORM_ref_sig8
:
19345 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
19348 case DW_FORM_ref_udata
:
19349 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19350 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
19351 info_ptr
+= bytes_read
;
19353 case DW_FORM_indirect
:
19354 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19355 info_ptr
+= bytes_read
;
19356 if (form
== DW_FORM_implicit_const
)
19358 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19359 info_ptr
+= bytes_read
;
19361 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
19364 case DW_FORM_implicit_const
:
19365 DW_SND (attr
) = implicit_const
;
19367 case DW_FORM_addrx
:
19368 case DW_FORM_GNU_addr_index
:
19369 if (reader
->dwo_file
== NULL
)
19371 /* For now flag a hard error.
19372 Later we can turn this into a complaint. */
19373 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19374 dwarf_form_name (form
),
19375 bfd_get_filename (abfd
));
19377 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
19378 info_ptr
+= bytes_read
;
19381 case DW_FORM_strx1
:
19382 case DW_FORM_strx2
:
19383 case DW_FORM_strx3
:
19384 case DW_FORM_strx4
:
19385 case DW_FORM_GNU_str_index
:
19386 if (reader
->dwo_file
== NULL
)
19388 /* For now flag a hard error.
19389 Later we can turn this into a complaint if warranted. */
19390 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19391 dwarf_form_name (form
),
19392 bfd_get_filename (abfd
));
19395 ULONGEST str_index
;
19396 if (form
== DW_FORM_strx1
)
19398 str_index
= read_1_byte (abfd
, info_ptr
);
19401 else if (form
== DW_FORM_strx2
)
19403 str_index
= read_2_bytes (abfd
, info_ptr
);
19406 else if (form
== DW_FORM_strx3
)
19408 str_index
= read_3_bytes (abfd
, info_ptr
);
19411 else if (form
== DW_FORM_strx4
)
19413 str_index
= read_4_bytes (abfd
, info_ptr
);
19418 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19419 info_ptr
+= bytes_read
;
19421 DW_STRING (attr
) = read_str_index (reader
, str_index
);
19422 DW_STRING_IS_CANONICAL (attr
) = 0;
19426 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19427 dwarf_form_name (form
),
19428 bfd_get_filename (abfd
));
19432 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
19433 attr
->form
= DW_FORM_GNU_ref_alt
;
19435 /* We have seen instances where the compiler tried to emit a byte
19436 size attribute of -1 which ended up being encoded as an unsigned
19437 0xffffffff. Although 0xffffffff is technically a valid size value,
19438 an object of this size seems pretty unlikely so we can relatively
19439 safely treat these cases as if the size attribute was invalid and
19440 treat them as zero by default. */
19441 if (attr
->name
== DW_AT_byte_size
19442 && form
== DW_FORM_data4
19443 && DW_UNSND (attr
) >= 0xffffffff)
19446 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19447 hex_string (DW_UNSND (attr
)));
19448 DW_UNSND (attr
) = 0;
19454 /* Read an attribute described by an abbreviated attribute. */
19456 static const gdb_byte
*
19457 read_attribute (const struct die_reader_specs
*reader
,
19458 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
19459 const gdb_byte
*info_ptr
)
19461 attr
->name
= abbrev
->name
;
19462 return read_attribute_value (reader
, attr
, abbrev
->form
,
19463 abbrev
->implicit_const
, info_ptr
);
19466 /* Read dwarf information from a buffer. */
19468 static unsigned int
19469 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
19471 return bfd_get_8 (abfd
, buf
);
19475 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
19477 return bfd_get_signed_8 (abfd
, buf
);
19480 static unsigned int
19481 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19483 return bfd_get_16 (abfd
, buf
);
19487 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19489 return bfd_get_signed_16 (abfd
, buf
);
19492 static unsigned int
19493 read_3_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19495 unsigned int result
= 0;
19496 for (int i
= 0; i
< 3; ++i
)
19498 unsigned char byte
= bfd_get_8 (abfd
, buf
);
19500 result
|= ((unsigned int) byte
<< (i
* 8));
19505 static unsigned int
19506 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19508 return bfd_get_32 (abfd
, buf
);
19512 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19514 return bfd_get_signed_32 (abfd
, buf
);
19518 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19520 return bfd_get_64 (abfd
, buf
);
19524 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
19525 unsigned int *bytes_read
)
19527 struct comp_unit_head
*cu_header
= &cu
->header
;
19528 CORE_ADDR retval
= 0;
19530 if (cu_header
->signed_addr_p
)
19532 switch (cu_header
->addr_size
)
19535 retval
= bfd_get_signed_16 (abfd
, buf
);
19538 retval
= bfd_get_signed_32 (abfd
, buf
);
19541 retval
= bfd_get_signed_64 (abfd
, buf
);
19544 internal_error (__FILE__
, __LINE__
,
19545 _("read_address: bad switch, signed [in module %s]"),
19546 bfd_get_filename (abfd
));
19551 switch (cu_header
->addr_size
)
19554 retval
= bfd_get_16 (abfd
, buf
);
19557 retval
= bfd_get_32 (abfd
, buf
);
19560 retval
= bfd_get_64 (abfd
, buf
);
19563 internal_error (__FILE__
, __LINE__
,
19564 _("read_address: bad switch, "
19565 "unsigned [in module %s]"),
19566 bfd_get_filename (abfd
));
19570 *bytes_read
= cu_header
->addr_size
;
19574 /* Read the initial length from a section. The (draft) DWARF 3
19575 specification allows the initial length to take up either 4 bytes
19576 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19577 bytes describe the length and all offsets will be 8 bytes in length
19580 An older, non-standard 64-bit format is also handled by this
19581 function. The older format in question stores the initial length
19582 as an 8-byte quantity without an escape value. Lengths greater
19583 than 2^32 aren't very common which means that the initial 4 bytes
19584 is almost always zero. Since a length value of zero doesn't make
19585 sense for the 32-bit format, this initial zero can be considered to
19586 be an escape value which indicates the presence of the older 64-bit
19587 format. As written, the code can't detect (old format) lengths
19588 greater than 4GB. If it becomes necessary to handle lengths
19589 somewhat larger than 4GB, we could allow other small values (such
19590 as the non-sensical values of 1, 2, and 3) to also be used as
19591 escape values indicating the presence of the old format.
19593 The value returned via bytes_read should be used to increment the
19594 relevant pointer after calling read_initial_length().
19596 [ Note: read_initial_length() and read_offset() are based on the
19597 document entitled "DWARF Debugging Information Format", revision
19598 3, draft 8, dated November 19, 2001. This document was obtained
19601 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19603 This document is only a draft and is subject to change. (So beware.)
19605 Details regarding the older, non-standard 64-bit format were
19606 determined empirically by examining 64-bit ELF files produced by
19607 the SGI toolchain on an IRIX 6.5 machine.
19609 - Kevin, July 16, 2002
19613 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
19615 LONGEST length
= bfd_get_32 (abfd
, buf
);
19617 if (length
== 0xffffffff)
19619 length
= bfd_get_64 (abfd
, buf
+ 4);
19622 else if (length
== 0)
19624 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19625 length
= bfd_get_64 (abfd
, buf
);
19636 /* Cover function for read_initial_length.
19637 Returns the length of the object at BUF, and stores the size of the
19638 initial length in *BYTES_READ and stores the size that offsets will be in
19640 If the initial length size is not equivalent to that specified in
19641 CU_HEADER then issue a complaint.
19642 This is useful when reading non-comp-unit headers. */
19645 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
19646 const struct comp_unit_head
*cu_header
,
19647 unsigned int *bytes_read
,
19648 unsigned int *offset_size
)
19650 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
19652 gdb_assert (cu_header
->initial_length_size
== 4
19653 || cu_header
->initial_length_size
== 8
19654 || cu_header
->initial_length_size
== 12);
19656 if (cu_header
->initial_length_size
!= *bytes_read
)
19657 complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19659 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
19663 /* Read an offset from the data stream. The size of the offset is
19664 given by cu_header->offset_size. */
19667 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
19668 const struct comp_unit_head
*cu_header
,
19669 unsigned int *bytes_read
)
19671 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
19673 *bytes_read
= cu_header
->offset_size
;
19677 /* Read an offset from the data stream. */
19680 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
19682 LONGEST retval
= 0;
19684 switch (offset_size
)
19687 retval
= bfd_get_32 (abfd
, buf
);
19690 retval
= bfd_get_64 (abfd
, buf
);
19693 internal_error (__FILE__
, __LINE__
,
19694 _("read_offset_1: bad switch [in module %s]"),
19695 bfd_get_filename (abfd
));
19701 static const gdb_byte
*
19702 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
19704 /* If the size of a host char is 8 bits, we can return a pointer
19705 to the buffer, otherwise we have to copy the data to a buffer
19706 allocated on the temporary obstack. */
19707 gdb_assert (HOST_CHAR_BIT
== 8);
19711 static const char *
19712 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
19713 unsigned int *bytes_read_ptr
)
19715 /* If the size of a host char is 8 bits, we can return a pointer
19716 to the string, otherwise we have to copy the string to a buffer
19717 allocated on the temporary obstack. */
19718 gdb_assert (HOST_CHAR_BIT
== 8);
19721 *bytes_read_ptr
= 1;
19724 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
19725 return (const char *) buf
;
19728 /* Return pointer to string at section SECT offset STR_OFFSET with error
19729 reporting strings FORM_NAME and SECT_NAME. */
19731 static const char *
19732 read_indirect_string_at_offset_from (struct objfile
*objfile
,
19733 bfd
*abfd
, LONGEST str_offset
,
19734 struct dwarf2_section_info
*sect
,
19735 const char *form_name
,
19736 const char *sect_name
)
19738 dwarf2_read_section (objfile
, sect
);
19739 if (sect
->buffer
== NULL
)
19740 error (_("%s used without %s section [in module %s]"),
19741 form_name
, sect_name
, bfd_get_filename (abfd
));
19742 if (str_offset
>= sect
->size
)
19743 error (_("%s pointing outside of %s section [in module %s]"),
19744 form_name
, sect_name
, bfd_get_filename (abfd
));
19745 gdb_assert (HOST_CHAR_BIT
== 8);
19746 if (sect
->buffer
[str_offset
] == '\0')
19748 return (const char *) (sect
->buffer
+ str_offset
);
19751 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19753 static const char *
19754 read_indirect_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19755 bfd
*abfd
, LONGEST str_offset
)
19757 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
19759 &dwarf2_per_objfile
->str
,
19760 "DW_FORM_strp", ".debug_str");
19763 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
19765 static const char *
19766 read_indirect_line_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19767 bfd
*abfd
, LONGEST str_offset
)
19769 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
19771 &dwarf2_per_objfile
->line_str
,
19772 "DW_FORM_line_strp",
19773 ".debug_line_str");
19776 /* Read a string at offset STR_OFFSET in the .debug_str section from
19777 the .dwz file DWZ. Throw an error if the offset is too large. If
19778 the string consists of a single NUL byte, return NULL; otherwise
19779 return a pointer to the string. */
19781 static const char *
19782 read_indirect_string_from_dwz (struct objfile
*objfile
, struct dwz_file
*dwz
,
19783 LONGEST str_offset
)
19785 dwarf2_read_section (objfile
, &dwz
->str
);
19787 if (dwz
->str
.buffer
== NULL
)
19788 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19789 "section [in module %s]"),
19790 bfd_get_filename (dwz
->dwz_bfd
.get ()));
19791 if (str_offset
>= dwz
->str
.size
)
19792 error (_("DW_FORM_GNU_strp_alt pointing outside of "
19793 ".debug_str section [in module %s]"),
19794 bfd_get_filename (dwz
->dwz_bfd
.get ()));
19795 gdb_assert (HOST_CHAR_BIT
== 8);
19796 if (dwz
->str
.buffer
[str_offset
] == '\0')
19798 return (const char *) (dwz
->str
.buffer
+ str_offset
);
19801 /* Return pointer to string at .debug_str offset as read from BUF.
19802 BUF is assumed to be in a compilation unit described by CU_HEADER.
19803 Return *BYTES_READ_PTR count of bytes read from BUF. */
19805 static const char *
19806 read_indirect_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
19807 const gdb_byte
*buf
,
19808 const struct comp_unit_head
*cu_header
,
19809 unsigned int *bytes_read_ptr
)
19811 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
19813 return read_indirect_string_at_offset (dwarf2_per_objfile
, abfd
, str_offset
);
19816 /* Return pointer to string at .debug_line_str offset as read from BUF.
19817 BUF is assumed to be in a compilation unit described by CU_HEADER.
19818 Return *BYTES_READ_PTR count of bytes read from BUF. */
19820 static const char *
19821 read_indirect_line_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19822 bfd
*abfd
, const gdb_byte
*buf
,
19823 const struct comp_unit_head
*cu_header
,
19824 unsigned int *bytes_read_ptr
)
19826 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
19828 return read_indirect_line_string_at_offset (dwarf2_per_objfile
, abfd
,
19833 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
19834 unsigned int *bytes_read_ptr
)
19837 unsigned int num_read
;
19839 unsigned char byte
;
19846 byte
= bfd_get_8 (abfd
, buf
);
19849 result
|= ((ULONGEST
) (byte
& 127) << shift
);
19850 if ((byte
& 128) == 0)
19856 *bytes_read_ptr
= num_read
;
19861 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
19862 unsigned int *bytes_read_ptr
)
19865 int shift
, num_read
;
19866 unsigned char byte
;
19873 byte
= bfd_get_8 (abfd
, buf
);
19876 result
|= ((ULONGEST
) (byte
& 127) << shift
);
19878 if ((byte
& 128) == 0)
19883 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
19884 result
|= -(((ULONGEST
) 1) << shift
);
19885 *bytes_read_ptr
= num_read
;
19889 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19890 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19891 ADDR_SIZE is the size of addresses from the CU header. */
19894 read_addr_index_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19895 unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
19897 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19898 bfd
*abfd
= objfile
->obfd
;
19899 const gdb_byte
*info_ptr
;
19901 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
19902 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
19903 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19904 objfile_name (objfile
));
19905 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
19906 error (_("DW_FORM_addr_index pointing outside of "
19907 ".debug_addr section [in module %s]"),
19908 objfile_name (objfile
));
19909 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
19910 + addr_base
+ addr_index
* addr_size
);
19911 if (addr_size
== 4)
19912 return bfd_get_32 (abfd
, info_ptr
);
19914 return bfd_get_64 (abfd
, info_ptr
);
19917 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
19920 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
19922 return read_addr_index_1 (cu
->per_cu
->dwarf2_per_objfile
, addr_index
,
19923 cu
->addr_base
, cu
->header
.addr_size
);
19926 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
19929 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
19930 unsigned int *bytes_read
)
19932 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
19933 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
19935 return read_addr_index (cu
, addr_index
);
19938 /* Data structure to pass results from dwarf2_read_addr_index_reader
19939 back to dwarf2_read_addr_index. */
19941 struct dwarf2_read_addr_index_data
19943 ULONGEST addr_base
;
19947 /* die_reader_func for dwarf2_read_addr_index. */
19950 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
19951 const gdb_byte
*info_ptr
,
19952 struct die_info
*comp_unit_die
,
19956 struct dwarf2_cu
*cu
= reader
->cu
;
19957 struct dwarf2_read_addr_index_data
*aidata
=
19958 (struct dwarf2_read_addr_index_data
*) data
;
19960 aidata
->addr_base
= cu
->addr_base
;
19961 aidata
->addr_size
= cu
->header
.addr_size
;
19964 /* Given an index in .debug_addr, fetch the value.
19965 NOTE: This can be called during dwarf expression evaluation,
19966 long after the debug information has been read, and thus per_cu->cu
19967 may no longer exist. */
19970 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
19971 unsigned int addr_index
)
19973 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
19974 struct dwarf2_cu
*cu
= per_cu
->cu
;
19975 ULONGEST addr_base
;
19978 /* We need addr_base and addr_size.
19979 If we don't have PER_CU->cu, we have to get it.
19980 Nasty, but the alternative is storing the needed info in PER_CU,
19981 which at this point doesn't seem justified: it's not clear how frequently
19982 it would get used and it would increase the size of every PER_CU.
19983 Entry points like dwarf2_per_cu_addr_size do a similar thing
19984 so we're not in uncharted territory here.
19985 Alas we need to be a bit more complicated as addr_base is contained
19988 We don't need to read the entire CU(/TU).
19989 We just need the header and top level die.
19991 IWBN to use the aging mechanism to let us lazily later discard the CU.
19992 For now we skip this optimization. */
19996 addr_base
= cu
->addr_base
;
19997 addr_size
= cu
->header
.addr_size
;
20001 struct dwarf2_read_addr_index_data aidata
;
20003 /* Note: We can't use init_cutu_and_read_dies_simple here,
20004 we need addr_base. */
20005 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0, false,
20006 dwarf2_read_addr_index_reader
, &aidata
);
20007 addr_base
= aidata
.addr_base
;
20008 addr_size
= aidata
.addr_size
;
20011 return read_addr_index_1 (dwarf2_per_objfile
, addr_index
, addr_base
,
20015 /* Given a DW_FORM_GNU_str_index or DW_FORM_strx, fetch the string.
20016 This is only used by the Fission support. */
20018 static const char *
20019 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
20021 struct dwarf2_cu
*cu
= reader
->cu
;
20022 struct dwarf2_per_objfile
*dwarf2_per_objfile
20023 = cu
->per_cu
->dwarf2_per_objfile
;
20024 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
20025 const char *objf_name
= objfile_name (objfile
);
20026 bfd
*abfd
= objfile
->obfd
;
20027 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
20028 struct dwarf2_section_info
*str_offsets_section
=
20029 &reader
->dwo_file
->sections
.str_offsets
;
20030 const gdb_byte
*info_ptr
;
20031 ULONGEST str_offset
;
20032 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
20034 dwarf2_read_section (objfile
, str_section
);
20035 dwarf2_read_section (objfile
, str_offsets_section
);
20036 if (str_section
->buffer
== NULL
)
20037 error (_("%s used without .debug_str.dwo section"
20038 " in CU at offset %s [in module %s]"),
20039 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20040 if (str_offsets_section
->buffer
== NULL
)
20041 error (_("%s used without .debug_str_offsets.dwo section"
20042 " in CU at offset %s [in module %s]"),
20043 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20044 if (str_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
20045 error (_("%s pointing outside of .debug_str_offsets.dwo"
20046 " section in CU at offset %s [in module %s]"),
20047 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20048 info_ptr
= (str_offsets_section
->buffer
20049 + str_index
* cu
->header
.offset_size
);
20050 if (cu
->header
.offset_size
== 4)
20051 str_offset
= bfd_get_32 (abfd
, info_ptr
);
20053 str_offset
= bfd_get_64 (abfd
, info_ptr
);
20054 if (str_offset
>= str_section
->size
)
20055 error (_("Offset from %s pointing outside of"
20056 " .debug_str.dwo section in CU at offset %s [in module %s]"),
20057 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
20058 return (const char *) (str_section
->buffer
+ str_offset
);
20061 /* Return the length of an LEB128 number in BUF. */
20064 leb128_size (const gdb_byte
*buf
)
20066 const gdb_byte
*begin
= buf
;
20072 if ((byte
& 128) == 0)
20073 return buf
- begin
;
20078 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
20087 cu
->language
= language_c
;
20090 case DW_LANG_C_plus_plus
:
20091 case DW_LANG_C_plus_plus_11
:
20092 case DW_LANG_C_plus_plus_14
:
20093 cu
->language
= language_cplus
;
20096 cu
->language
= language_d
;
20098 case DW_LANG_Fortran77
:
20099 case DW_LANG_Fortran90
:
20100 case DW_LANG_Fortran95
:
20101 case DW_LANG_Fortran03
:
20102 case DW_LANG_Fortran08
:
20103 cu
->language
= language_fortran
;
20106 cu
->language
= language_go
;
20108 case DW_LANG_Mips_Assembler
:
20109 cu
->language
= language_asm
;
20111 case DW_LANG_Ada83
:
20112 case DW_LANG_Ada95
:
20113 cu
->language
= language_ada
;
20115 case DW_LANG_Modula2
:
20116 cu
->language
= language_m2
;
20118 case DW_LANG_Pascal83
:
20119 cu
->language
= language_pascal
;
20122 cu
->language
= language_objc
;
20125 case DW_LANG_Rust_old
:
20126 cu
->language
= language_rust
;
20128 case DW_LANG_Cobol74
:
20129 case DW_LANG_Cobol85
:
20131 cu
->language
= language_minimal
;
20134 cu
->language_defn
= language_def (cu
->language
);
20137 /* Return the named attribute or NULL if not there. */
20139 static struct attribute
*
20140 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20145 struct attribute
*spec
= NULL
;
20147 for (i
= 0; i
< die
->num_attrs
; ++i
)
20149 if (die
->attrs
[i
].name
== name
)
20150 return &die
->attrs
[i
];
20151 if (die
->attrs
[i
].name
== DW_AT_specification
20152 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
20153 spec
= &die
->attrs
[i
];
20159 die
= follow_die_ref (die
, spec
, &cu
);
20165 /* Return the named attribute or NULL if not there,
20166 but do not follow DW_AT_specification, etc.
20167 This is for use in contexts where we're reading .debug_types dies.
20168 Following DW_AT_specification, DW_AT_abstract_origin will take us
20169 back up the chain, and we want to go down. */
20171 static struct attribute
*
20172 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
20176 for (i
= 0; i
< die
->num_attrs
; ++i
)
20177 if (die
->attrs
[i
].name
== name
)
20178 return &die
->attrs
[i
];
20183 /* Return the string associated with a string-typed attribute, or NULL if it
20184 is either not found or is of an incorrect type. */
20186 static const char *
20187 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20189 struct attribute
*attr
;
20190 const char *str
= NULL
;
20192 attr
= dwarf2_attr (die
, name
, cu
);
20196 if (attr
->form
== DW_FORM_strp
|| attr
->form
== DW_FORM_line_strp
20197 || attr
->form
== DW_FORM_string
20198 || attr
->form
== DW_FORM_strx
20199 || attr
->form
== DW_FORM_strx1
20200 || attr
->form
== DW_FORM_strx2
20201 || attr
->form
== DW_FORM_strx3
20202 || attr
->form
== DW_FORM_strx4
20203 || attr
->form
== DW_FORM_GNU_str_index
20204 || attr
->form
== DW_FORM_GNU_strp_alt
)
20205 str
= DW_STRING (attr
);
20207 complaint (_("string type expected for attribute %s for "
20208 "DIE at %s in module %s"),
20209 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
20210 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
20216 /* Return the dwo name or NULL if not present. If present, it is in either
20217 DW_AT_GNU_dwo_name or DW_AT_dwo_name atrribute. */
20218 static const char *
20219 dwarf2_dwo_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
20221 const char *dwo_name
= dwarf2_string_attr (die
, DW_AT_GNU_dwo_name
, cu
);
20222 if (dwo_name
== nullptr)
20223 dwo_name
= dwarf2_string_attr (die
, DW_AT_dwo_name
, cu
);
20227 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20228 and holds a non-zero value. This function should only be used for
20229 DW_FORM_flag or DW_FORM_flag_present attributes. */
20232 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
20234 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
20236 return (attr
&& DW_UNSND (attr
));
20240 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
20242 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20243 which value is non-zero. However, we have to be careful with
20244 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20245 (via dwarf2_flag_true_p) follows this attribute. So we may
20246 end up accidently finding a declaration attribute that belongs
20247 to a different DIE referenced by the specification attribute,
20248 even though the given DIE does not have a declaration attribute. */
20249 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
20250 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
20253 /* Return the die giving the specification for DIE, if there is
20254 one. *SPEC_CU is the CU containing DIE on input, and the CU
20255 containing the return value on output. If there is no
20256 specification, but there is an abstract origin, that is
20259 static struct die_info
*
20260 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
20262 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
20265 if (spec_attr
== NULL
)
20266 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
20268 if (spec_attr
== NULL
)
20271 return follow_die_ref (die
, spec_attr
, spec_cu
);
20274 /* Stub for free_line_header to match void * callback types. */
20277 free_line_header_voidp (void *arg
)
20279 struct line_header
*lh
= (struct line_header
*) arg
;
20285 line_header::add_include_dir (const char *include_dir
)
20287 if (dwarf_line_debug
>= 2)
20288 fprintf_unfiltered (gdb_stdlog
, "Adding dir %zu: %s\n",
20289 include_dirs
.size () + 1, include_dir
);
20291 include_dirs
.push_back (include_dir
);
20295 line_header::add_file_name (const char *name
,
20297 unsigned int mod_time
,
20298 unsigned int length
)
20300 if (dwarf_line_debug
>= 2)
20301 fprintf_unfiltered (gdb_stdlog
, "Adding file %u: %s\n",
20302 (unsigned) file_names
.size () + 1, name
);
20304 file_names
.emplace_back (name
, d_index
, mod_time
, length
);
20307 /* A convenience function to find the proper .debug_line section for a CU. */
20309 static struct dwarf2_section_info
*
20310 get_debug_line_section (struct dwarf2_cu
*cu
)
20312 struct dwarf2_section_info
*section
;
20313 struct dwarf2_per_objfile
*dwarf2_per_objfile
20314 = cu
->per_cu
->dwarf2_per_objfile
;
20316 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20318 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20319 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
20320 else if (cu
->per_cu
->is_dwz
)
20322 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
20324 section
= &dwz
->line
;
20327 section
= &dwarf2_per_objfile
->line
;
20332 /* Read directory or file name entry format, starting with byte of
20333 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20334 entries count and the entries themselves in the described entry
20338 read_formatted_entries (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
20339 bfd
*abfd
, const gdb_byte
**bufp
,
20340 struct line_header
*lh
,
20341 const struct comp_unit_head
*cu_header
,
20342 void (*callback
) (struct line_header
*lh
,
20345 unsigned int mod_time
,
20346 unsigned int length
))
20348 gdb_byte format_count
, formati
;
20349 ULONGEST data_count
, datai
;
20350 const gdb_byte
*buf
= *bufp
;
20351 const gdb_byte
*format_header_data
;
20352 unsigned int bytes_read
;
20354 format_count
= read_1_byte (abfd
, buf
);
20356 format_header_data
= buf
;
20357 for (formati
= 0; formati
< format_count
; formati
++)
20359 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20361 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20365 data_count
= read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20367 for (datai
= 0; datai
< data_count
; datai
++)
20369 const gdb_byte
*format
= format_header_data
;
20370 struct file_entry fe
;
20372 for (formati
= 0; formati
< format_count
; formati
++)
20374 ULONGEST content_type
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
20375 format
+= bytes_read
;
20377 ULONGEST form
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
20378 format
+= bytes_read
;
20380 gdb::optional
<const char *> string
;
20381 gdb::optional
<unsigned int> uint
;
20385 case DW_FORM_string
:
20386 string
.emplace (read_direct_string (abfd
, buf
, &bytes_read
));
20390 case DW_FORM_line_strp
:
20391 string
.emplace (read_indirect_line_string (dwarf2_per_objfile
,
20398 case DW_FORM_data1
:
20399 uint
.emplace (read_1_byte (abfd
, buf
));
20403 case DW_FORM_data2
:
20404 uint
.emplace (read_2_bytes (abfd
, buf
));
20408 case DW_FORM_data4
:
20409 uint
.emplace (read_4_bytes (abfd
, buf
));
20413 case DW_FORM_data8
:
20414 uint
.emplace (read_8_bytes (abfd
, buf
));
20418 case DW_FORM_udata
:
20419 uint
.emplace (read_unsigned_leb128 (abfd
, buf
, &bytes_read
));
20423 case DW_FORM_block
:
20424 /* It is valid only for DW_LNCT_timestamp which is ignored by
20429 switch (content_type
)
20432 if (string
.has_value ())
20435 case DW_LNCT_directory_index
:
20436 if (uint
.has_value ())
20437 fe
.d_index
= (dir_index
) *uint
;
20439 case DW_LNCT_timestamp
:
20440 if (uint
.has_value ())
20441 fe
.mod_time
= *uint
;
20444 if (uint
.has_value ())
20450 complaint (_("Unknown format content type %s"),
20451 pulongest (content_type
));
20455 callback (lh
, fe
.name
, fe
.d_index
, fe
.mod_time
, fe
.length
);
20461 /* Read the statement program header starting at OFFSET in
20462 .debug_line, or .debug_line.dwo. Return a pointer
20463 to a struct line_header, allocated using xmalloc.
20464 Returns NULL if there is a problem reading the header, e.g., if it
20465 has a version we don't understand.
20467 NOTE: the strings in the include directory and file name tables of
20468 the returned object point into the dwarf line section buffer,
20469 and must not be freed. */
20471 static line_header_up
20472 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
20474 const gdb_byte
*line_ptr
;
20475 unsigned int bytes_read
, offset_size
;
20477 const char *cur_dir
, *cur_file
;
20478 struct dwarf2_section_info
*section
;
20480 struct dwarf2_per_objfile
*dwarf2_per_objfile
20481 = cu
->per_cu
->dwarf2_per_objfile
;
20483 section
= get_debug_line_section (cu
);
20484 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
20485 if (section
->buffer
== NULL
)
20487 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20488 complaint (_("missing .debug_line.dwo section"));
20490 complaint (_("missing .debug_line section"));
20494 /* We can't do this until we know the section is non-empty.
20495 Only then do we know we have such a section. */
20496 abfd
= get_section_bfd_owner (section
);
20498 /* Make sure that at least there's room for the total_length field.
20499 That could be 12 bytes long, but we're just going to fudge that. */
20500 if (to_underlying (sect_off
) + 4 >= section
->size
)
20502 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20506 line_header_up
lh (new line_header ());
20508 lh
->sect_off
= sect_off
;
20509 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
20511 line_ptr
= section
->buffer
+ to_underlying (sect_off
);
20513 /* Read in the header. */
20515 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
20516 &bytes_read
, &offset_size
);
20517 line_ptr
+= bytes_read
;
20518 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
20520 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20523 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
20524 lh
->version
= read_2_bytes (abfd
, line_ptr
);
20526 if (lh
->version
> 5)
20528 /* This is a version we don't understand. The format could have
20529 changed in ways we don't handle properly so just punt. */
20530 complaint (_("unsupported version in .debug_line section"));
20533 if (lh
->version
>= 5)
20535 gdb_byte segment_selector_size
;
20537 /* Skip address size. */
20538 read_1_byte (abfd
, line_ptr
);
20541 segment_selector_size
= read_1_byte (abfd
, line_ptr
);
20543 if (segment_selector_size
!= 0)
20545 complaint (_("unsupported segment selector size %u "
20546 "in .debug_line section"),
20547 segment_selector_size
);
20551 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
20552 line_ptr
+= offset_size
;
20553 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
20555 if (lh
->version
>= 4)
20557 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
20561 lh
->maximum_ops_per_instruction
= 1;
20563 if (lh
->maximum_ops_per_instruction
== 0)
20565 lh
->maximum_ops_per_instruction
= 1;
20566 complaint (_("invalid maximum_ops_per_instruction "
20567 "in `.debug_line' section"));
20570 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
20572 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
20574 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
20576 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
20578 lh
->standard_opcode_lengths
.reset (new unsigned char[lh
->opcode_base
]);
20580 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
20581 for (i
= 1; i
< lh
->opcode_base
; ++i
)
20583 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
20587 if (lh
->version
>= 5)
20589 /* Read directory table. */
20590 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
20592 [] (struct line_header
*header
, const char *name
,
20593 dir_index d_index
, unsigned int mod_time
,
20594 unsigned int length
)
20596 header
->add_include_dir (name
);
20599 /* Read file name table. */
20600 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
20602 [] (struct line_header
*header
, const char *name
,
20603 dir_index d_index
, unsigned int mod_time
,
20604 unsigned int length
)
20606 header
->add_file_name (name
, d_index
, mod_time
, length
);
20611 /* Read directory table. */
20612 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
20614 line_ptr
+= bytes_read
;
20615 lh
->add_include_dir (cur_dir
);
20617 line_ptr
+= bytes_read
;
20619 /* Read file name table. */
20620 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
20622 unsigned int mod_time
, length
;
20625 line_ptr
+= bytes_read
;
20626 d_index
= (dir_index
) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20627 line_ptr
+= bytes_read
;
20628 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20629 line_ptr
+= bytes_read
;
20630 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20631 line_ptr
+= bytes_read
;
20633 lh
->add_file_name (cur_file
, d_index
, mod_time
, length
);
20635 line_ptr
+= bytes_read
;
20637 lh
->statement_program_start
= line_ptr
;
20639 if (line_ptr
> (section
->buffer
+ section
->size
))
20640 complaint (_("line number info header doesn't "
20641 "fit in `.debug_line' section"));
20646 /* Subroutine of dwarf_decode_lines to simplify it.
20647 Return the file name of the psymtab for included file FILE_INDEX
20648 in line header LH of PST.
20649 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20650 If space for the result is malloc'd, *NAME_HOLDER will be set.
20651 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20653 static const char *
20654 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
20655 const struct partial_symtab
*pst
,
20656 const char *comp_dir
,
20657 gdb::unique_xmalloc_ptr
<char> *name_holder
)
20659 const file_entry
&fe
= lh
->file_names
[file_index
];
20660 const char *include_name
= fe
.name
;
20661 const char *include_name_to_compare
= include_name
;
20662 const char *pst_filename
;
20665 const char *dir_name
= fe
.include_dir (lh
);
20667 gdb::unique_xmalloc_ptr
<char> hold_compare
;
20668 if (!IS_ABSOLUTE_PATH (include_name
)
20669 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
20671 /* Avoid creating a duplicate psymtab for PST.
20672 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20673 Before we do the comparison, however, we need to account
20674 for DIR_NAME and COMP_DIR.
20675 First prepend dir_name (if non-NULL). If we still don't
20676 have an absolute path prepend comp_dir (if non-NULL).
20677 However, the directory we record in the include-file's
20678 psymtab does not contain COMP_DIR (to match the
20679 corresponding symtab(s)).
20684 bash$ gcc -g ./hello.c
20685 include_name = "hello.c"
20687 DW_AT_comp_dir = comp_dir = "/tmp"
20688 DW_AT_name = "./hello.c"
20692 if (dir_name
!= NULL
)
20694 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
20695 include_name
, (char *) NULL
));
20696 include_name
= name_holder
->get ();
20697 include_name_to_compare
= include_name
;
20699 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
20701 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
20702 include_name
, (char *) NULL
));
20703 include_name_to_compare
= hold_compare
.get ();
20707 pst_filename
= pst
->filename
;
20708 gdb::unique_xmalloc_ptr
<char> copied_name
;
20709 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
20711 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
20712 pst_filename
, (char *) NULL
));
20713 pst_filename
= copied_name
.get ();
20716 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
20720 return include_name
;
20723 /* State machine to track the state of the line number program. */
20725 class lnp_state_machine
20728 /* Initialize a machine state for the start of a line number
20730 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
20731 bool record_lines_p
);
20733 file_entry
*current_file ()
20735 /* lh->file_names is 0-based, but the file name numbers in the
20736 statement program are 1-based. */
20737 return m_line_header
->file_name_at (m_file
);
20740 /* Record the line in the state machine. END_SEQUENCE is true if
20741 we're processing the end of a sequence. */
20742 void record_line (bool end_sequence
);
20744 /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20745 nop-out rest of the lines in this sequence. */
20746 void check_line_address (struct dwarf2_cu
*cu
,
20747 const gdb_byte
*line_ptr
,
20748 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
20750 void handle_set_discriminator (unsigned int discriminator
)
20752 m_discriminator
= discriminator
;
20753 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
20756 /* Handle DW_LNE_set_address. */
20757 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
20760 address
+= baseaddr
;
20761 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
20764 /* Handle DW_LNS_advance_pc. */
20765 void handle_advance_pc (CORE_ADDR adjust
);
20767 /* Handle a special opcode. */
20768 void handle_special_opcode (unsigned char op_code
);
20770 /* Handle DW_LNS_advance_line. */
20771 void handle_advance_line (int line_delta
)
20773 advance_line (line_delta
);
20776 /* Handle DW_LNS_set_file. */
20777 void handle_set_file (file_name_index file
);
20779 /* Handle DW_LNS_negate_stmt. */
20780 void handle_negate_stmt ()
20782 m_is_stmt
= !m_is_stmt
;
20785 /* Handle DW_LNS_const_add_pc. */
20786 void handle_const_add_pc ();
20788 /* Handle DW_LNS_fixed_advance_pc. */
20789 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
20791 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20795 /* Handle DW_LNS_copy. */
20796 void handle_copy ()
20798 record_line (false);
20799 m_discriminator
= 0;
20802 /* Handle DW_LNE_end_sequence. */
20803 void handle_end_sequence ()
20805 m_currently_recording_lines
= true;
20809 /* Advance the line by LINE_DELTA. */
20810 void advance_line (int line_delta
)
20812 m_line
+= line_delta
;
20814 if (line_delta
!= 0)
20815 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20818 struct dwarf2_cu
*m_cu
;
20820 gdbarch
*m_gdbarch
;
20822 /* True if we're recording lines.
20823 Otherwise we're building partial symtabs and are just interested in
20824 finding include files mentioned by the line number program. */
20825 bool m_record_lines_p
;
20827 /* The line number header. */
20828 line_header
*m_line_header
;
20830 /* These are part of the standard DWARF line number state machine,
20831 and initialized according to the DWARF spec. */
20833 unsigned char m_op_index
= 0;
20834 /* The line table index (1-based) of the current file. */
20835 file_name_index m_file
= (file_name_index
) 1;
20836 unsigned int m_line
= 1;
20838 /* These are initialized in the constructor. */
20840 CORE_ADDR m_address
;
20842 unsigned int m_discriminator
;
20844 /* Additional bits of state we need to track. */
20846 /* The last file that we called dwarf2_start_subfile for.
20847 This is only used for TLLs. */
20848 unsigned int m_last_file
= 0;
20849 /* The last file a line number was recorded for. */
20850 struct subfile
*m_last_subfile
= NULL
;
20852 /* When true, record the lines we decode. */
20853 bool m_currently_recording_lines
= false;
20855 /* The last line number that was recorded, used to coalesce
20856 consecutive entries for the same line. This can happen, for
20857 example, when discriminators are present. PR 17276. */
20858 unsigned int m_last_line
= 0;
20859 bool m_line_has_non_zero_discriminator
= false;
20863 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
20865 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
20866 / m_line_header
->maximum_ops_per_instruction
)
20867 * m_line_header
->minimum_instruction_length
);
20868 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20869 m_op_index
= ((m_op_index
+ adjust
)
20870 % m_line_header
->maximum_ops_per_instruction
);
20874 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
20876 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
20877 CORE_ADDR addr_adj
= (((m_op_index
20878 + (adj_opcode
/ m_line_header
->line_range
))
20879 / m_line_header
->maximum_ops_per_instruction
)
20880 * m_line_header
->minimum_instruction_length
);
20881 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20882 m_op_index
= ((m_op_index
+ (adj_opcode
/ m_line_header
->line_range
))
20883 % m_line_header
->maximum_ops_per_instruction
);
20885 int line_delta
= (m_line_header
->line_base
20886 + (adj_opcode
% m_line_header
->line_range
));
20887 advance_line (line_delta
);
20888 record_line (false);
20889 m_discriminator
= 0;
20893 lnp_state_machine::handle_set_file (file_name_index file
)
20897 const file_entry
*fe
= current_file ();
20899 dwarf2_debug_line_missing_file_complaint ();
20900 else if (m_record_lines_p
)
20902 const char *dir
= fe
->include_dir (m_line_header
);
20904 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20905 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20906 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
20911 lnp_state_machine::handle_const_add_pc ()
20914 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
20917 = (((m_op_index
+ adjust
)
20918 / m_line_header
->maximum_ops_per_instruction
)
20919 * m_line_header
->minimum_instruction_length
);
20921 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20922 m_op_index
= ((m_op_index
+ adjust
)
20923 % m_line_header
->maximum_ops_per_instruction
);
20926 /* Return non-zero if we should add LINE to the line number table.
20927 LINE is the line to add, LAST_LINE is the last line that was added,
20928 LAST_SUBFILE is the subfile for LAST_LINE.
20929 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20930 had a non-zero discriminator.
20932 We have to be careful in the presence of discriminators.
20933 E.g., for this line:
20935 for (i = 0; i < 100000; i++);
20937 clang can emit four line number entries for that one line,
20938 each with a different discriminator.
20939 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20941 However, we want gdb to coalesce all four entries into one.
20942 Otherwise the user could stepi into the middle of the line and
20943 gdb would get confused about whether the pc really was in the
20944 middle of the line.
20946 Things are further complicated by the fact that two consecutive
20947 line number entries for the same line is a heuristic used by gcc
20948 to denote the end of the prologue. So we can't just discard duplicate
20949 entries, we have to be selective about it. The heuristic we use is
20950 that we only collapse consecutive entries for the same line if at least
20951 one of those entries has a non-zero discriminator. PR 17276.
20953 Note: Addresses in the line number state machine can never go backwards
20954 within one sequence, thus this coalescing is ok. */
20957 dwarf_record_line_p (struct dwarf2_cu
*cu
,
20958 unsigned int line
, unsigned int last_line
,
20959 int line_has_non_zero_discriminator
,
20960 struct subfile
*last_subfile
)
20962 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
20964 if (line
!= last_line
)
20966 /* Same line for the same file that we've seen already.
20967 As a last check, for pr 17276, only record the line if the line
20968 has never had a non-zero discriminator. */
20969 if (!line_has_non_zero_discriminator
)
20974 /* Use the CU's builder to record line number LINE beginning at
20975 address ADDRESS in the line table of subfile SUBFILE. */
20978 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20979 unsigned int line
, CORE_ADDR address
,
20980 struct dwarf2_cu
*cu
)
20982 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
20984 if (dwarf_line_debug
)
20986 fprintf_unfiltered (gdb_stdlog
,
20987 "Recording line %u, file %s, address %s\n",
20988 line
, lbasename (subfile
->name
),
20989 paddress (gdbarch
, address
));
20993 cu
->get_builder ()->record_line (subfile
, line
, addr
);
20996 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20997 Mark the end of a set of line number records.
20998 The arguments are the same as for dwarf_record_line_1.
20999 If SUBFILE is NULL the request is ignored. */
21002 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
21003 CORE_ADDR address
, struct dwarf2_cu
*cu
)
21005 if (subfile
== NULL
)
21008 if (dwarf_line_debug
)
21010 fprintf_unfiltered (gdb_stdlog
,
21011 "Finishing current line, file %s, address %s\n",
21012 lbasename (subfile
->name
),
21013 paddress (gdbarch
, address
));
21016 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, cu
);
21020 lnp_state_machine::record_line (bool end_sequence
)
21022 if (dwarf_line_debug
)
21024 fprintf_unfiltered (gdb_stdlog
,
21025 "Processing actual line %u: file %u,"
21026 " address %s, is_stmt %u, discrim %u\n",
21027 m_line
, to_underlying (m_file
),
21028 paddress (m_gdbarch
, m_address
),
21029 m_is_stmt
, m_discriminator
);
21032 file_entry
*fe
= current_file ();
21035 dwarf2_debug_line_missing_file_complaint ();
21036 /* For now we ignore lines not starting on an instruction boundary.
21037 But not when processing end_sequence for compatibility with the
21038 previous version of the code. */
21039 else if (m_op_index
== 0 || end_sequence
)
21041 fe
->included_p
= 1;
21042 if (m_record_lines_p
&& (producer_is_codewarrior (m_cu
) || m_is_stmt
))
21044 if (m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ()
21047 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
21048 m_currently_recording_lines
? m_cu
: nullptr);
21053 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
21054 m_line_has_non_zero_discriminator
,
21057 buildsym_compunit
*builder
= m_cu
->get_builder ();
21058 dwarf_record_line_1 (m_gdbarch
,
21059 builder
->get_current_subfile (),
21061 m_currently_recording_lines
? m_cu
: nullptr);
21063 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
21064 m_last_line
= m_line
;
21070 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
21071 line_header
*lh
, bool record_lines_p
)
21075 m_record_lines_p
= record_lines_p
;
21076 m_line_header
= lh
;
21078 m_currently_recording_lines
= true;
21080 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
21081 was a line entry for it so that the backend has a chance to adjust it
21082 and also record it in case it needs it. This is currently used by MIPS
21083 code, cf. `mips_adjust_dwarf2_line'. */
21084 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
21085 m_is_stmt
= lh
->default_is_stmt
;
21086 m_discriminator
= 0;
21090 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
21091 const gdb_byte
*line_ptr
,
21092 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
21094 /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
21095 the pc range of the CU. However, we restrict the test to only ADDRESS
21096 values of zero to preserve GDB's previous behaviour which is to handle
21097 the specific case of a function being GC'd by the linker. */
21099 if (address
== 0 && address
< unrelocated_lowpc
)
21101 /* This line table is for a function which has been
21102 GCd by the linker. Ignore it. PR gdb/12528 */
21104 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21105 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
21107 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21108 line_offset
, objfile_name (objfile
));
21109 m_currently_recording_lines
= false;
21110 /* Note: m_currently_recording_lines is left as false until we see
21111 DW_LNE_end_sequence. */
21115 /* Subroutine of dwarf_decode_lines to simplify it.
21116 Process the line number information in LH.
21117 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21118 program in order to set included_p for every referenced header. */
21121 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
21122 const int decode_for_pst_p
, CORE_ADDR lowpc
)
21124 const gdb_byte
*line_ptr
, *extended_end
;
21125 const gdb_byte
*line_end
;
21126 unsigned int bytes_read
, extended_len
;
21127 unsigned char op_code
, extended_op
;
21128 CORE_ADDR baseaddr
;
21129 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21130 bfd
*abfd
= objfile
->obfd
;
21131 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
21132 /* True if we're recording line info (as opposed to building partial
21133 symtabs and just interested in finding include files mentioned by
21134 the line number program). */
21135 bool record_lines_p
= !decode_for_pst_p
;
21137 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21139 line_ptr
= lh
->statement_program_start
;
21140 line_end
= lh
->statement_program_end
;
21142 /* Read the statement sequences until there's nothing left. */
21143 while (line_ptr
< line_end
)
21145 /* The DWARF line number program state machine. Reset the state
21146 machine at the start of each sequence. */
21147 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
21148 bool end_sequence
= false;
21150 if (record_lines_p
)
21152 /* Start a subfile for the current file of the state
21154 const file_entry
*fe
= state_machine
.current_file ();
21157 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
21160 /* Decode the table. */
21161 while (line_ptr
< line_end
&& !end_sequence
)
21163 op_code
= read_1_byte (abfd
, line_ptr
);
21166 if (op_code
>= lh
->opcode_base
)
21168 /* Special opcode. */
21169 state_machine
.handle_special_opcode (op_code
);
21171 else switch (op_code
)
21173 case DW_LNS_extended_op
:
21174 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
21176 line_ptr
+= bytes_read
;
21177 extended_end
= line_ptr
+ extended_len
;
21178 extended_op
= read_1_byte (abfd
, line_ptr
);
21180 switch (extended_op
)
21182 case DW_LNE_end_sequence
:
21183 state_machine
.handle_end_sequence ();
21184 end_sequence
= true;
21186 case DW_LNE_set_address
:
21189 = read_address (abfd
, line_ptr
, cu
, &bytes_read
);
21190 line_ptr
+= bytes_read
;
21192 state_machine
.check_line_address (cu
, line_ptr
,
21193 lowpc
- baseaddr
, address
);
21194 state_machine
.handle_set_address (baseaddr
, address
);
21197 case DW_LNE_define_file
:
21199 const char *cur_file
;
21200 unsigned int mod_time
, length
;
21203 cur_file
= read_direct_string (abfd
, line_ptr
,
21205 line_ptr
+= bytes_read
;
21206 dindex
= (dir_index
)
21207 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21208 line_ptr
+= bytes_read
;
21210 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21211 line_ptr
+= bytes_read
;
21213 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21214 line_ptr
+= bytes_read
;
21215 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21218 case DW_LNE_set_discriminator
:
21220 /* The discriminator is not interesting to the
21221 debugger; just ignore it. We still need to
21222 check its value though:
21223 if there are consecutive entries for the same
21224 (non-prologue) line we want to coalesce them.
21227 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21228 line_ptr
+= bytes_read
;
21230 state_machine
.handle_set_discriminator (discr
);
21234 complaint (_("mangled .debug_line section"));
21237 /* Make sure that we parsed the extended op correctly. If e.g.
21238 we expected a different address size than the producer used,
21239 we may have read the wrong number of bytes. */
21240 if (line_ptr
!= extended_end
)
21242 complaint (_("mangled .debug_line section"));
21247 state_machine
.handle_copy ();
21249 case DW_LNS_advance_pc
:
21252 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21253 line_ptr
+= bytes_read
;
21255 state_machine
.handle_advance_pc (adjust
);
21258 case DW_LNS_advance_line
:
21261 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21262 line_ptr
+= bytes_read
;
21264 state_machine
.handle_advance_line (line_delta
);
21267 case DW_LNS_set_file
:
21269 file_name_index file
21270 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21272 line_ptr
+= bytes_read
;
21274 state_machine
.handle_set_file (file
);
21277 case DW_LNS_set_column
:
21278 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21279 line_ptr
+= bytes_read
;
21281 case DW_LNS_negate_stmt
:
21282 state_machine
.handle_negate_stmt ();
21284 case DW_LNS_set_basic_block
:
21286 /* Add to the address register of the state machine the
21287 address increment value corresponding to special opcode
21288 255. I.e., this value is scaled by the minimum
21289 instruction length since special opcode 255 would have
21290 scaled the increment. */
21291 case DW_LNS_const_add_pc
:
21292 state_machine
.handle_const_add_pc ();
21294 case DW_LNS_fixed_advance_pc
:
21296 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21299 state_machine
.handle_fixed_advance_pc (addr_adj
);
21304 /* Unknown standard opcode, ignore it. */
21307 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21309 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21310 line_ptr
+= bytes_read
;
21317 dwarf2_debug_line_missing_end_sequence_complaint ();
21319 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21320 in which case we still finish recording the last line). */
21321 state_machine
.record_line (true);
21325 /* Decode the Line Number Program (LNP) for the given line_header
21326 structure and CU. The actual information extracted and the type
21327 of structures created from the LNP depends on the value of PST.
21329 1. If PST is NULL, then this procedure uses the data from the program
21330 to create all necessary symbol tables, and their linetables.
21332 2. If PST is not NULL, this procedure reads the program to determine
21333 the list of files included by the unit represented by PST, and
21334 builds all the associated partial symbol tables.
21336 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21337 It is used for relative paths in the line table.
21338 NOTE: When processing partial symtabs (pst != NULL),
21339 comp_dir == pst->dirname.
21341 NOTE: It is important that psymtabs have the same file name (via strcmp)
21342 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21343 symtab we don't use it in the name of the psymtabs we create.
21344 E.g. expand_line_sal requires this when finding psymtabs to expand.
21345 A good testcase for this is mb-inline.exp.
21347 LOWPC is the lowest address in CU (or 0 if not known).
21349 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21350 for its PC<->lines mapping information. Otherwise only the filename
21351 table is read in. */
21354 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21355 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
21356 CORE_ADDR lowpc
, int decode_mapping
)
21358 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21359 const int decode_for_pst_p
= (pst
!= NULL
);
21361 if (decode_mapping
)
21362 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21364 if (decode_for_pst_p
)
21368 /* Now that we're done scanning the Line Header Program, we can
21369 create the psymtab of each included file. */
21370 for (file_index
= 0; file_index
< lh
->file_names
.size (); file_index
++)
21371 if (lh
->file_names
[file_index
].included_p
== 1)
21373 gdb::unique_xmalloc_ptr
<char> name_holder
;
21374 const char *include_name
=
21375 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
,
21377 if (include_name
!= NULL
)
21378 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
21383 /* Make sure a symtab is created for every file, even files
21384 which contain only variables (i.e. no code with associated
21386 buildsym_compunit
*builder
= cu
->get_builder ();
21387 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21390 for (i
= 0; i
< lh
->file_names
.size (); i
++)
21392 file_entry
&fe
= lh
->file_names
[i
];
21394 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21396 if (builder
->get_current_subfile ()->symtab
== NULL
)
21398 builder
->get_current_subfile ()->symtab
21399 = allocate_symtab (cust
,
21400 builder
->get_current_subfile ()->name
);
21402 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21407 /* Start a subfile for DWARF. FILENAME is the name of the file and
21408 DIRNAME the name of the source directory which contains FILENAME
21409 or NULL if not known.
21410 This routine tries to keep line numbers from identical absolute and
21411 relative file names in a common subfile.
21413 Using the `list' example from the GDB testsuite, which resides in
21414 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21415 of /srcdir/list0.c yields the following debugging information for list0.c:
21417 DW_AT_name: /srcdir/list0.c
21418 DW_AT_comp_dir: /compdir
21419 files.files[0].name: list0.h
21420 files.files[0].dir: /srcdir
21421 files.files[1].name: list0.c
21422 files.files[1].dir: /srcdir
21424 The line number information for list0.c has to end up in a single
21425 subfile, so that `break /srcdir/list0.c:1' works as expected.
21426 start_subfile will ensure that this happens provided that we pass the
21427 concatenation of files.files[1].dir and files.files[1].name as the
21431 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
21432 const char *dirname
)
21436 /* In order not to lose the line information directory,
21437 we concatenate it to the filename when it makes sense.
21438 Note that the Dwarf3 standard says (speaking of filenames in line
21439 information): ``The directory index is ignored for file names
21440 that represent full path names''. Thus ignoring dirname in the
21441 `else' branch below isn't an issue. */
21443 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
21445 copy
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
21449 cu
->get_builder ()->start_subfile (filename
);
21455 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21456 buildsym_compunit constructor. */
21458 struct compunit_symtab
*
21459 dwarf2_cu::start_symtab (const char *name
, const char *comp_dir
,
21462 gdb_assert (m_builder
== nullptr);
21464 m_builder
.reset (new struct buildsym_compunit
21465 (per_cu
->dwarf2_per_objfile
->objfile
,
21466 name
, comp_dir
, language
, low_pc
));
21468 list_in_scope
= get_builder ()->get_file_symbols ();
21470 get_builder ()->record_debugformat ("DWARF 2");
21471 get_builder ()->record_producer (producer
);
21473 processing_has_namespace_info
= false;
21475 return get_builder ()->get_compunit_symtab ();
21479 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
21480 struct dwarf2_cu
*cu
)
21482 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21483 struct comp_unit_head
*cu_header
= &cu
->header
;
21485 /* NOTE drow/2003-01-30: There used to be a comment and some special
21486 code here to turn a symbol with DW_AT_external and a
21487 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21488 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21489 with some versions of binutils) where shared libraries could have
21490 relocations against symbols in their debug information - the
21491 minimal symbol would have the right address, but the debug info
21492 would not. It's no longer necessary, because we will explicitly
21493 apply relocations when we read in the debug information now. */
21495 /* A DW_AT_location attribute with no contents indicates that a
21496 variable has been optimized away. */
21497 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
21499 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21503 /* Handle one degenerate form of location expression specially, to
21504 preserve GDB's previous behavior when section offsets are
21505 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
21506 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
21508 if (attr_form_is_block (attr
)
21509 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
21510 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
21511 || ((DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
21512 || DW_BLOCK (attr
)->data
[0] == DW_OP_addrx
)
21513 && (DW_BLOCK (attr
)->size
21514 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
21516 unsigned int dummy
;
21518 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
21519 SET_SYMBOL_VALUE_ADDRESS (sym
,
21520 read_address (objfile
->obfd
,
21521 DW_BLOCK (attr
)->data
+ 1,
21524 SET_SYMBOL_VALUE_ADDRESS
21525 (sym
, read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1,
21527 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
21528 fixup_symbol_section (sym
, objfile
);
21529 SET_SYMBOL_VALUE_ADDRESS (sym
,
21530 SYMBOL_VALUE_ADDRESS (sym
)
21531 + ANOFFSET (objfile
->section_offsets
,
21532 SYMBOL_SECTION (sym
)));
21536 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21537 expression evaluator, and use LOC_COMPUTED only when necessary
21538 (i.e. when the value of a register or memory location is
21539 referenced, or a thread-local block, etc.). Then again, it might
21540 not be worthwhile. I'm assuming that it isn't unless performance
21541 or memory numbers show me otherwise. */
21543 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
21545 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
21546 cu
->has_loclist
= true;
21549 /* Given a pointer to a DWARF information entry, figure out if we need
21550 to make a symbol table entry for it, and if so, create a new entry
21551 and return a pointer to it.
21552 If TYPE is NULL, determine symbol type from the die, otherwise
21553 used the passed type.
21554 If SPACE is not NULL, use it to hold the new symbol. If it is
21555 NULL, allocate a new symbol on the objfile's obstack. */
21557 static struct symbol
*
21558 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
21559 struct symbol
*space
)
21561 struct dwarf2_per_objfile
*dwarf2_per_objfile
21562 = cu
->per_cu
->dwarf2_per_objfile
;
21563 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21564 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
21565 struct symbol
*sym
= NULL
;
21567 struct attribute
*attr
= NULL
;
21568 struct attribute
*attr2
= NULL
;
21569 CORE_ADDR baseaddr
;
21570 struct pending
**list_to_add
= NULL
;
21572 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
21574 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21576 name
= dwarf2_name (die
, cu
);
21579 const char *linkagename
;
21580 int suppress_add
= 0;
21585 sym
= allocate_symbol (objfile
);
21586 OBJSTAT (objfile
, n_syms
++);
21588 /* Cache this symbol's name and the name's demangled form (if any). */
21589 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
21590 linkagename
= dwarf2_physname (name
, die
, cu
);
21591 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
21593 /* Fortran does not have mangling standard and the mangling does differ
21594 between gfortran, iFort etc. */
21595 if (cu
->language
== language_fortran
21596 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
21597 symbol_set_demangled_name (&(sym
->ginfo
),
21598 dwarf2_full_name (name
, die
, cu
),
21601 /* Default assumptions.
21602 Use the passed type or decode it from the die. */
21603 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21604 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21606 SYMBOL_TYPE (sym
) = type
;
21608 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
21609 attr
= dwarf2_attr (die
,
21610 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
21614 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
21617 attr
= dwarf2_attr (die
,
21618 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
21622 file_name_index file_index
= (file_name_index
) DW_UNSND (attr
);
21623 struct file_entry
*fe
;
21625 if (cu
->line_header
!= NULL
)
21626 fe
= cu
->line_header
->file_name_at (file_index
);
21631 complaint (_("file index out of range"));
21633 symbol_set_symtab (sym
, fe
->symtab
);
21639 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
21644 addr
= attr_value_as_address (attr
);
21645 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
21646 SET_SYMBOL_VALUE_ADDRESS (sym
, addr
);
21648 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
21649 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
21650 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
21651 add_symbol_to_list (sym
, cu
->list_in_scope
);
21653 case DW_TAG_subprogram
:
21654 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21656 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21657 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21658 if ((attr2
&& (DW_UNSND (attr2
) != 0))
21659 || cu
->language
== language_ada
21660 || cu
->language
== language_fortran
)
21662 /* Subprograms marked external are stored as a global symbol.
21663 Ada and Fortran subprograms, whether marked external or
21664 not, are always stored as a global symbol, because we want
21665 to be able to access them globally. For instance, we want
21666 to be able to break on a nested subprogram without having
21667 to specify the context. */
21668 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21672 list_to_add
= cu
->list_in_scope
;
21675 case DW_TAG_inlined_subroutine
:
21676 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21678 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21679 SYMBOL_INLINED (sym
) = 1;
21680 list_to_add
= cu
->list_in_scope
;
21682 case DW_TAG_template_value_param
:
21684 /* Fall through. */
21685 case DW_TAG_constant
:
21686 case DW_TAG_variable
:
21687 case DW_TAG_member
:
21688 /* Compilation with minimal debug info may result in
21689 variables with missing type entries. Change the
21690 misleading `void' type to something sensible. */
21691 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
21692 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
21694 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21695 /* In the case of DW_TAG_member, we should only be called for
21696 static const members. */
21697 if (die
->tag
== DW_TAG_member
)
21699 /* dwarf2_add_field uses die_is_declaration,
21700 so we do the same. */
21701 gdb_assert (die_is_declaration (die
, cu
));
21706 dwarf2_const_value (attr
, sym
, cu
);
21707 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21710 if (attr2
&& (DW_UNSND (attr2
) != 0))
21711 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21713 list_to_add
= cu
->list_in_scope
;
21717 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21720 var_decode_location (attr
, sym
, cu
);
21721 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21723 /* Fortran explicitly imports any global symbols to the local
21724 scope by DW_TAG_common_block. */
21725 if (cu
->language
== language_fortran
&& die
->parent
21726 && die
->parent
->tag
== DW_TAG_common_block
)
21729 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21730 && SYMBOL_VALUE_ADDRESS (sym
) == 0
21731 && !dwarf2_per_objfile
->has_section_at_zero
)
21733 /* When a static variable is eliminated by the linker,
21734 the corresponding debug information is not stripped
21735 out, but the variable address is set to null;
21736 do not add such variables into symbol table. */
21738 else if (attr2
&& (DW_UNSND (attr2
) != 0))
21740 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21741 && (objfile
->flags
& OBJF_MAINLINE
) == 0
21742 && dwarf2_per_objfile
->can_copy
)
21744 /* A global static variable might be subject to
21745 copy relocation. We first check for a local
21746 minsym, though, because maybe the symbol was
21747 marked hidden, in which case this would not
21749 bound_minimal_symbol found
21750 = (lookup_minimal_symbol_linkage
21751 (SYMBOL_LINKAGE_NAME (sym
), objfile
));
21752 if (found
.minsym
!= nullptr)
21753 sym
->maybe_copied
= 1;
21756 /* A variable with DW_AT_external is never static,
21757 but it may be block-scoped. */
21759 = ((cu
->list_in_scope
21760 == cu
->get_builder ()->get_file_symbols ())
21761 ? cu
->get_builder ()->get_global_symbols ()
21762 : cu
->list_in_scope
);
21765 list_to_add
= cu
->list_in_scope
;
21769 /* We do not know the address of this symbol.
21770 If it is an external symbol and we have type information
21771 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21772 The address of the variable will then be determined from
21773 the minimal symbol table whenever the variable is
21775 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21777 /* Fortran explicitly imports any global symbols to the local
21778 scope by DW_TAG_common_block. */
21779 if (cu
->language
== language_fortran
&& die
->parent
21780 && die
->parent
->tag
== DW_TAG_common_block
)
21782 /* SYMBOL_CLASS doesn't matter here because
21783 read_common_block is going to reset it. */
21785 list_to_add
= cu
->list_in_scope
;
21787 else if (attr2
&& (DW_UNSND (attr2
) != 0)
21788 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
21790 /* A variable with DW_AT_external is never static, but it
21791 may be block-scoped. */
21793 = ((cu
->list_in_scope
21794 == cu
->get_builder ()->get_file_symbols ())
21795 ? cu
->get_builder ()->get_global_symbols ()
21796 : cu
->list_in_scope
);
21798 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21800 else if (!die_is_declaration (die
, cu
))
21802 /* Use the default LOC_OPTIMIZED_OUT class. */
21803 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
21805 list_to_add
= cu
->list_in_scope
;
21809 case DW_TAG_formal_parameter
:
21811 /* If we are inside a function, mark this as an argument. If
21812 not, we might be looking at an argument to an inlined function
21813 when we do not have enough information to show inlined frames;
21814 pretend it's a local variable in that case so that the user can
21816 struct context_stack
*curr
21817 = cu
->get_builder ()->get_current_context_stack ();
21818 if (curr
!= nullptr && curr
->name
!= nullptr)
21819 SYMBOL_IS_ARGUMENT (sym
) = 1;
21820 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21823 var_decode_location (attr
, sym
, cu
);
21825 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21828 dwarf2_const_value (attr
, sym
, cu
);
21831 list_to_add
= cu
->list_in_scope
;
21834 case DW_TAG_unspecified_parameters
:
21835 /* From varargs functions; gdb doesn't seem to have any
21836 interest in this information, so just ignore it for now.
21839 case DW_TAG_template_type_param
:
21841 /* Fall through. */
21842 case DW_TAG_class_type
:
21843 case DW_TAG_interface_type
:
21844 case DW_TAG_structure_type
:
21845 case DW_TAG_union_type
:
21846 case DW_TAG_set_type
:
21847 case DW_TAG_enumeration_type
:
21848 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21849 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
21852 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21853 really ever be static objects: otherwise, if you try
21854 to, say, break of a class's method and you're in a file
21855 which doesn't mention that class, it won't work unless
21856 the check for all static symbols in lookup_symbol_aux
21857 saves you. See the OtherFileClass tests in
21858 gdb.c++/namespace.exp. */
21862 buildsym_compunit
*builder
= cu
->get_builder ();
21864 = (cu
->list_in_scope
== builder
->get_file_symbols ()
21865 && cu
->language
== language_cplus
21866 ? builder
->get_global_symbols ()
21867 : cu
->list_in_scope
);
21869 /* The semantics of C++ state that "struct foo {
21870 ... }" also defines a typedef for "foo". */
21871 if (cu
->language
== language_cplus
21872 || cu
->language
== language_ada
21873 || cu
->language
== language_d
21874 || cu
->language
== language_rust
)
21876 /* The symbol's name is already allocated along
21877 with this objfile, so we don't need to
21878 duplicate it for the type. */
21879 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
21880 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
21885 case DW_TAG_typedef
:
21886 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21887 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21888 list_to_add
= cu
->list_in_scope
;
21890 case DW_TAG_base_type
:
21891 case DW_TAG_subrange_type
:
21892 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21893 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21894 list_to_add
= cu
->list_in_scope
;
21896 case DW_TAG_enumerator
:
21897 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21900 dwarf2_const_value (attr
, sym
, cu
);
21903 /* NOTE: carlton/2003-11-10: See comment above in the
21904 DW_TAG_class_type, etc. block. */
21907 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
21908 && cu
->language
== language_cplus
21909 ? cu
->get_builder ()->get_global_symbols ()
21910 : cu
->list_in_scope
);
21913 case DW_TAG_imported_declaration
:
21914 case DW_TAG_namespace
:
21915 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21916 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21918 case DW_TAG_module
:
21919 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21920 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
21921 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21923 case DW_TAG_common_block
:
21924 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
21925 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
21926 add_symbol_to_list (sym
, cu
->list_in_scope
);
21929 /* Not a tag we recognize. Hopefully we aren't processing
21930 trash data, but since we must specifically ignore things
21931 we don't recognize, there is nothing else we should do at
21933 complaint (_("unsupported tag: '%s'"),
21934 dwarf_tag_name (die
->tag
));
21940 sym
->hash_next
= objfile
->template_symbols
;
21941 objfile
->template_symbols
= sym
;
21942 list_to_add
= NULL
;
21945 if (list_to_add
!= NULL
)
21946 add_symbol_to_list (sym
, list_to_add
);
21948 /* For the benefit of old versions of GCC, check for anonymous
21949 namespaces based on the demangled name. */
21950 if (!cu
->processing_has_namespace_info
21951 && cu
->language
== language_cplus
)
21952 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
21957 /* Given an attr with a DW_FORM_dataN value in host byte order,
21958 zero-extend it as appropriate for the symbol's type. The DWARF
21959 standard (v4) is not entirely clear about the meaning of using
21960 DW_FORM_dataN for a constant with a signed type, where the type is
21961 wider than the data. The conclusion of a discussion on the DWARF
21962 list was that this is unspecified. We choose to always zero-extend
21963 because that is the interpretation long in use by GCC. */
21966 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
21967 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
21969 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21970 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
21971 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
21972 LONGEST l
= DW_UNSND (attr
);
21974 if (bits
< sizeof (*value
) * 8)
21976 l
&= ((LONGEST
) 1 << bits
) - 1;
21979 else if (bits
== sizeof (*value
) * 8)
21983 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
21984 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
21991 /* Read a constant value from an attribute. Either set *VALUE, or if
21992 the value does not fit in *VALUE, set *BYTES - either already
21993 allocated on the objfile obstack, or newly allocated on OBSTACK,
21994 or, set *BATON, if we translated the constant to a location
21998 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
21999 const char *name
, struct obstack
*obstack
,
22000 struct dwarf2_cu
*cu
,
22001 LONGEST
*value
, const gdb_byte
**bytes
,
22002 struct dwarf2_locexpr_baton
**baton
)
22004 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22005 struct comp_unit_head
*cu_header
= &cu
->header
;
22006 struct dwarf_block
*blk
;
22007 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
22008 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
22014 switch (attr
->form
)
22017 case DW_FORM_addrx
:
22018 case DW_FORM_GNU_addr_index
:
22022 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
22023 dwarf2_const_value_length_mismatch_complaint (name
,
22024 cu_header
->addr_size
,
22025 TYPE_LENGTH (type
));
22026 /* Symbols of this form are reasonably rare, so we just
22027 piggyback on the existing location code rather than writing
22028 a new implementation of symbol_computed_ops. */
22029 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
22030 (*baton
)->per_cu
= cu
->per_cu
;
22031 gdb_assert ((*baton
)->per_cu
);
22033 (*baton
)->size
= 2 + cu_header
->addr_size
;
22034 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
22035 (*baton
)->data
= data
;
22037 data
[0] = DW_OP_addr
;
22038 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
22039 byte_order
, DW_ADDR (attr
));
22040 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
22043 case DW_FORM_string
:
22046 case DW_FORM_GNU_str_index
:
22047 case DW_FORM_GNU_strp_alt
:
22048 /* DW_STRING is already allocated on the objfile obstack, point
22050 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
22052 case DW_FORM_block1
:
22053 case DW_FORM_block2
:
22054 case DW_FORM_block4
:
22055 case DW_FORM_block
:
22056 case DW_FORM_exprloc
:
22057 case DW_FORM_data16
:
22058 blk
= DW_BLOCK (attr
);
22059 if (TYPE_LENGTH (type
) != blk
->size
)
22060 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
22061 TYPE_LENGTH (type
));
22062 *bytes
= blk
->data
;
22065 /* The DW_AT_const_value attributes are supposed to carry the
22066 symbol's value "represented as it would be on the target
22067 architecture." By the time we get here, it's already been
22068 converted to host endianness, so we just need to sign- or
22069 zero-extend it as appropriate. */
22070 case DW_FORM_data1
:
22071 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
22073 case DW_FORM_data2
:
22074 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
22076 case DW_FORM_data4
:
22077 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
22079 case DW_FORM_data8
:
22080 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
22083 case DW_FORM_sdata
:
22084 case DW_FORM_implicit_const
:
22085 *value
= DW_SND (attr
);
22088 case DW_FORM_udata
:
22089 *value
= DW_UNSND (attr
);
22093 complaint (_("unsupported const value attribute form: '%s'"),
22094 dwarf_form_name (attr
->form
));
22101 /* Copy constant value from an attribute to a symbol. */
22104 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
22105 struct dwarf2_cu
*cu
)
22107 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22109 const gdb_byte
*bytes
;
22110 struct dwarf2_locexpr_baton
*baton
;
22112 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
22113 SYMBOL_PRINT_NAME (sym
),
22114 &objfile
->objfile_obstack
, cu
,
22115 &value
, &bytes
, &baton
);
22119 SYMBOL_LOCATION_BATON (sym
) = baton
;
22120 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
22122 else if (bytes
!= NULL
)
22124 SYMBOL_VALUE_BYTES (sym
) = bytes
;
22125 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
22129 SYMBOL_VALUE (sym
) = value
;
22130 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
22134 /* Return the type of the die in question using its DW_AT_type attribute. */
22136 static struct type
*
22137 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22139 struct attribute
*type_attr
;
22141 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
22144 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22145 /* A missing DW_AT_type represents a void type. */
22146 return objfile_type (objfile
)->builtin_void
;
22149 return lookup_die_type (die
, type_attr
, cu
);
22152 /* True iff CU's producer generates GNAT Ada auxiliary information
22153 that allows to find parallel types through that information instead
22154 of having to do expensive parallel lookups by type name. */
22157 need_gnat_info (struct dwarf2_cu
*cu
)
22159 /* Assume that the Ada compiler was GNAT, which always produces
22160 the auxiliary information. */
22161 return (cu
->language
== language_ada
);
22164 /* Return the auxiliary type of the die in question using its
22165 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
22166 attribute is not present. */
22168 static struct type
*
22169 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22171 struct attribute
*type_attr
;
22173 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22177 return lookup_die_type (die
, type_attr
, cu
);
22180 /* If DIE has a descriptive_type attribute, then set the TYPE's
22181 descriptive type accordingly. */
22184 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22185 struct dwarf2_cu
*cu
)
22187 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22189 if (descriptive_type
)
22191 ALLOCATE_GNAT_AUX_TYPE (type
);
22192 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22196 /* Return the containing type of the die in question using its
22197 DW_AT_containing_type attribute. */
22199 static struct type
*
22200 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22202 struct attribute
*type_attr
;
22203 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22205 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22207 error (_("Dwarf Error: Problem turning containing type into gdb type "
22208 "[in module %s]"), objfile_name (objfile
));
22210 return lookup_die_type (die
, type_attr
, cu
);
22213 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22215 static struct type
*
22216 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22218 struct dwarf2_per_objfile
*dwarf2_per_objfile
22219 = cu
->per_cu
->dwarf2_per_objfile
;
22220 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22223 std::string message
22224 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22225 objfile_name (objfile
),
22226 sect_offset_str (cu
->header
.sect_off
),
22227 sect_offset_str (die
->sect_off
));
22228 saved
= obstack_strdup (&objfile
->objfile_obstack
, message
);
22230 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22233 /* Look up the type of DIE in CU using its type attribute ATTR.
22234 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22235 DW_AT_containing_type.
22236 If there is no type substitute an error marker. */
22238 static struct type
*
22239 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22240 struct dwarf2_cu
*cu
)
22242 struct dwarf2_per_objfile
*dwarf2_per_objfile
22243 = cu
->per_cu
->dwarf2_per_objfile
;
22244 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22245 struct type
*this_type
;
22247 gdb_assert (attr
->name
== DW_AT_type
22248 || attr
->name
== DW_AT_GNAT_descriptive_type
22249 || attr
->name
== DW_AT_containing_type
);
22251 /* First see if we have it cached. */
22253 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22255 struct dwarf2_per_cu_data
*per_cu
;
22256 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
22258 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1,
22259 dwarf2_per_objfile
);
22260 this_type
= get_die_type_at_offset (sect_off
, per_cu
);
22262 else if (attr_form_is_ref (attr
))
22264 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
22266 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
22268 else if (attr
->form
== DW_FORM_ref_sig8
)
22270 ULONGEST signature
= DW_SIGNATURE (attr
);
22272 return get_signatured_type (die
, signature
, cu
);
22276 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22277 " at %s [in module %s]"),
22278 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22279 objfile_name (objfile
));
22280 return build_error_marker_type (cu
, die
);
22283 /* If not cached we need to read it in. */
22285 if (this_type
== NULL
)
22287 struct die_info
*type_die
= NULL
;
22288 struct dwarf2_cu
*type_cu
= cu
;
22290 if (attr_form_is_ref (attr
))
22291 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22292 if (type_die
== NULL
)
22293 return build_error_marker_type (cu
, die
);
22294 /* If we find the type now, it's probably because the type came
22295 from an inter-CU reference and the type's CU got expanded before
22297 this_type
= read_type_die (type_die
, type_cu
);
22300 /* If we still don't have a type use an error marker. */
22302 if (this_type
== NULL
)
22303 return build_error_marker_type (cu
, die
);
22308 /* Return the type in DIE, CU.
22309 Returns NULL for invalid types.
22311 This first does a lookup in die_type_hash,
22312 and only reads the die in if necessary.
22314 NOTE: This can be called when reading in partial or full symbols. */
22316 static struct type
*
22317 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22319 struct type
*this_type
;
22321 this_type
= get_die_type (die
, cu
);
22325 return read_type_die_1 (die
, cu
);
22328 /* Read the type in DIE, CU.
22329 Returns NULL for invalid types. */
22331 static struct type
*
22332 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22334 struct type
*this_type
= NULL
;
22338 case DW_TAG_class_type
:
22339 case DW_TAG_interface_type
:
22340 case DW_TAG_structure_type
:
22341 case DW_TAG_union_type
:
22342 this_type
= read_structure_type (die
, cu
);
22344 case DW_TAG_enumeration_type
:
22345 this_type
= read_enumeration_type (die
, cu
);
22347 case DW_TAG_subprogram
:
22348 case DW_TAG_subroutine_type
:
22349 case DW_TAG_inlined_subroutine
:
22350 this_type
= read_subroutine_type (die
, cu
);
22352 case DW_TAG_array_type
:
22353 this_type
= read_array_type (die
, cu
);
22355 case DW_TAG_set_type
:
22356 this_type
= read_set_type (die
, cu
);
22358 case DW_TAG_pointer_type
:
22359 this_type
= read_tag_pointer_type (die
, cu
);
22361 case DW_TAG_ptr_to_member_type
:
22362 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22364 case DW_TAG_reference_type
:
22365 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22367 case DW_TAG_rvalue_reference_type
:
22368 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22370 case DW_TAG_const_type
:
22371 this_type
= read_tag_const_type (die
, cu
);
22373 case DW_TAG_volatile_type
:
22374 this_type
= read_tag_volatile_type (die
, cu
);
22376 case DW_TAG_restrict_type
:
22377 this_type
= read_tag_restrict_type (die
, cu
);
22379 case DW_TAG_string_type
:
22380 this_type
= read_tag_string_type (die
, cu
);
22382 case DW_TAG_typedef
:
22383 this_type
= read_typedef (die
, cu
);
22385 case DW_TAG_subrange_type
:
22386 this_type
= read_subrange_type (die
, cu
);
22388 case DW_TAG_base_type
:
22389 this_type
= read_base_type (die
, cu
);
22391 case DW_TAG_unspecified_type
:
22392 this_type
= read_unspecified_type (die
, cu
);
22394 case DW_TAG_namespace
:
22395 this_type
= read_namespace_type (die
, cu
);
22397 case DW_TAG_module
:
22398 this_type
= read_module_type (die
, cu
);
22400 case DW_TAG_atomic_type
:
22401 this_type
= read_tag_atomic_type (die
, cu
);
22404 complaint (_("unexpected tag in read_type_die: '%s'"),
22405 dwarf_tag_name (die
->tag
));
22412 /* See if we can figure out if the class lives in a namespace. We do
22413 this by looking for a member function; its demangled name will
22414 contain namespace info, if there is any.
22415 Return the computed name or NULL.
22416 Space for the result is allocated on the objfile's obstack.
22417 This is the full-die version of guess_partial_die_structure_name.
22418 In this case we know DIE has no useful parent. */
22421 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22423 struct die_info
*spec_die
;
22424 struct dwarf2_cu
*spec_cu
;
22425 struct die_info
*child
;
22426 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22429 spec_die
= die_specification (die
, &spec_cu
);
22430 if (spec_die
!= NULL
)
22436 for (child
= die
->child
;
22438 child
= child
->sibling
)
22440 if (child
->tag
== DW_TAG_subprogram
)
22442 const char *linkage_name
= dw2_linkage_name (child
, cu
);
22444 if (linkage_name
!= NULL
)
22447 = language_class_name_from_physname (cu
->language_defn
,
22451 if (actual_name
!= NULL
)
22453 const char *die_name
= dwarf2_name (die
, cu
);
22455 if (die_name
!= NULL
22456 && strcmp (die_name
, actual_name
) != 0)
22458 /* Strip off the class name from the full name.
22459 We want the prefix. */
22460 int die_name_len
= strlen (die_name
);
22461 int actual_name_len
= strlen (actual_name
);
22463 /* Test for '::' as a sanity check. */
22464 if (actual_name_len
> die_name_len
+ 2
22465 && actual_name
[actual_name_len
22466 - die_name_len
- 1] == ':')
22467 name
= obstack_strndup (
22468 &objfile
->per_bfd
->storage_obstack
,
22469 actual_name
, actual_name_len
- die_name_len
- 2);
22472 xfree (actual_name
);
22481 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22482 prefix part in such case. See
22483 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22485 static const char *
22486 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22488 struct attribute
*attr
;
22491 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
22492 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
22495 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
22498 attr
= dw2_linkage_name_attr (die
, cu
);
22499 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
22502 /* dwarf2_name had to be already called. */
22503 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
22505 /* Strip the base name, keep any leading namespaces/classes. */
22506 base
= strrchr (DW_STRING (attr
), ':');
22507 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
22510 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22511 return obstack_strndup (&objfile
->per_bfd
->storage_obstack
,
22513 &base
[-1] - DW_STRING (attr
));
22516 /* Return the name of the namespace/class that DIE is defined within,
22517 or "" if we can't tell. The caller should not xfree the result.
22519 For example, if we're within the method foo() in the following
22529 then determine_prefix on foo's die will return "N::C". */
22531 static const char *
22532 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22534 struct dwarf2_per_objfile
*dwarf2_per_objfile
22535 = cu
->per_cu
->dwarf2_per_objfile
;
22536 struct die_info
*parent
, *spec_die
;
22537 struct dwarf2_cu
*spec_cu
;
22538 struct type
*parent_type
;
22539 const char *retval
;
22541 if (cu
->language
!= language_cplus
22542 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
22543 && cu
->language
!= language_rust
)
22546 retval
= anonymous_struct_prefix (die
, cu
);
22550 /* We have to be careful in the presence of DW_AT_specification.
22551 For example, with GCC 3.4, given the code
22555 // Definition of N::foo.
22559 then we'll have a tree of DIEs like this:
22561 1: DW_TAG_compile_unit
22562 2: DW_TAG_namespace // N
22563 3: DW_TAG_subprogram // declaration of N::foo
22564 4: DW_TAG_subprogram // definition of N::foo
22565 DW_AT_specification // refers to die #3
22567 Thus, when processing die #4, we have to pretend that we're in
22568 the context of its DW_AT_specification, namely the contex of die
22571 spec_die
= die_specification (die
, &spec_cu
);
22572 if (spec_die
== NULL
)
22573 parent
= die
->parent
;
22576 parent
= spec_die
->parent
;
22580 if (parent
== NULL
)
22582 else if (parent
->building_fullname
)
22585 const char *parent_name
;
22587 /* It has been seen on RealView 2.2 built binaries,
22588 DW_TAG_template_type_param types actually _defined_ as
22589 children of the parent class:
22592 template class <class Enum> Class{};
22593 Class<enum E> class_e;
22595 1: DW_TAG_class_type (Class)
22596 2: DW_TAG_enumeration_type (E)
22597 3: DW_TAG_enumerator (enum1:0)
22598 3: DW_TAG_enumerator (enum2:1)
22600 2: DW_TAG_template_type_param
22601 DW_AT_type DW_FORM_ref_udata (E)
22603 Besides being broken debug info, it can put GDB into an
22604 infinite loop. Consider:
22606 When we're building the full name for Class<E>, we'll start
22607 at Class, and go look over its template type parameters,
22608 finding E. We'll then try to build the full name of E, and
22609 reach here. We're now trying to build the full name of E,
22610 and look over the parent DIE for containing scope. In the
22611 broken case, if we followed the parent DIE of E, we'd again
22612 find Class, and once again go look at its template type
22613 arguments, etc., etc. Simply don't consider such parent die
22614 as source-level parent of this die (it can't be, the language
22615 doesn't allow it), and break the loop here. */
22616 name
= dwarf2_name (die
, cu
);
22617 parent_name
= dwarf2_name (parent
, cu
);
22618 complaint (_("template param type '%s' defined within parent '%s'"),
22619 name
? name
: "<unknown>",
22620 parent_name
? parent_name
: "<unknown>");
22624 switch (parent
->tag
)
22626 case DW_TAG_namespace
:
22627 parent_type
= read_type_die (parent
, cu
);
22628 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22629 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22630 Work around this problem here. */
22631 if (cu
->language
== language_cplus
22632 && strcmp (TYPE_NAME (parent_type
), "::") == 0)
22634 /* We give a name to even anonymous namespaces. */
22635 return TYPE_NAME (parent_type
);
22636 case DW_TAG_class_type
:
22637 case DW_TAG_interface_type
:
22638 case DW_TAG_structure_type
:
22639 case DW_TAG_union_type
:
22640 case DW_TAG_module
:
22641 parent_type
= read_type_die (parent
, cu
);
22642 if (TYPE_NAME (parent_type
) != NULL
)
22643 return TYPE_NAME (parent_type
);
22645 /* An anonymous structure is only allowed non-static data
22646 members; no typedefs, no member functions, et cetera.
22647 So it does not need a prefix. */
22649 case DW_TAG_compile_unit
:
22650 case DW_TAG_partial_unit
:
22651 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22652 if (cu
->language
== language_cplus
22653 && !dwarf2_per_objfile
->types
.empty ()
22654 && die
->child
!= NULL
22655 && (die
->tag
== DW_TAG_class_type
22656 || die
->tag
== DW_TAG_structure_type
22657 || die
->tag
== DW_TAG_union_type
))
22659 char *name
= guess_full_die_structure_name (die
, cu
);
22664 case DW_TAG_subprogram
:
22665 /* Nested subroutines in Fortran get a prefix with the name
22666 of the parent's subroutine. */
22667 if (cu
->language
== language_fortran
)
22669 if ((die
->tag
== DW_TAG_subprogram
)
22670 && (dwarf2_name (parent
, cu
) != NULL
))
22671 return dwarf2_name (parent
, cu
);
22673 return determine_prefix (parent
, cu
);
22674 case DW_TAG_enumeration_type
:
22675 parent_type
= read_type_die (parent
, cu
);
22676 if (TYPE_DECLARED_CLASS (parent_type
))
22678 if (TYPE_NAME (parent_type
) != NULL
)
22679 return TYPE_NAME (parent_type
);
22682 /* Fall through. */
22684 return determine_prefix (parent
, cu
);
22688 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22689 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22690 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22691 an obconcat, otherwise allocate storage for the result. The CU argument is
22692 used to determine the language and hence, the appropriate separator. */
22694 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22697 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
22698 int physname
, struct dwarf2_cu
*cu
)
22700 const char *lead
= "";
22703 if (suffix
== NULL
|| suffix
[0] == '\0'
22704 || prefix
== NULL
|| prefix
[0] == '\0')
22706 else if (cu
->language
== language_d
)
22708 /* For D, the 'main' function could be defined in any module, but it
22709 should never be prefixed. */
22710 if (strcmp (suffix
, "D main") == 0)
22718 else if (cu
->language
== language_fortran
&& physname
)
22720 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22721 DW_AT_MIPS_linkage_name is preferred and used instead. */
22729 if (prefix
== NULL
)
22731 if (suffix
== NULL
)
22738 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
22740 strcpy (retval
, lead
);
22741 strcat (retval
, prefix
);
22742 strcat (retval
, sep
);
22743 strcat (retval
, suffix
);
22748 /* We have an obstack. */
22749 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
22753 /* Return sibling of die, NULL if no sibling. */
22755 static struct die_info
*
22756 sibling_die (struct die_info
*die
)
22758 return die
->sibling
;
22761 /* Get name of a die, return NULL if not found. */
22763 static const char *
22764 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
22765 struct obstack
*obstack
)
22767 if (name
&& cu
->language
== language_cplus
)
22769 std::string canon_name
= cp_canonicalize_string (name
);
22771 if (!canon_name
.empty ())
22773 if (canon_name
!= name
)
22774 name
= obstack_strdup (obstack
, canon_name
);
22781 /* Get name of a die, return NULL if not found.
22782 Anonymous namespaces are converted to their magic string. */
22784 static const char *
22785 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22787 struct attribute
*attr
;
22788 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22790 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
22791 if ((!attr
|| !DW_STRING (attr
))
22792 && die
->tag
!= DW_TAG_namespace
22793 && die
->tag
!= DW_TAG_class_type
22794 && die
->tag
!= DW_TAG_interface_type
22795 && die
->tag
!= DW_TAG_structure_type
22796 && die
->tag
!= DW_TAG_union_type
)
22801 case DW_TAG_compile_unit
:
22802 case DW_TAG_partial_unit
:
22803 /* Compilation units have a DW_AT_name that is a filename, not
22804 a source language identifier. */
22805 case DW_TAG_enumeration_type
:
22806 case DW_TAG_enumerator
:
22807 /* These tags always have simple identifiers already; no need
22808 to canonicalize them. */
22809 return DW_STRING (attr
);
22811 case DW_TAG_namespace
:
22812 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
22813 return DW_STRING (attr
);
22814 return CP_ANONYMOUS_NAMESPACE_STR
;
22816 case DW_TAG_class_type
:
22817 case DW_TAG_interface_type
:
22818 case DW_TAG_structure_type
:
22819 case DW_TAG_union_type
:
22820 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22821 structures or unions. These were of the form "._%d" in GCC 4.1,
22822 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22823 and GCC 4.4. We work around this problem by ignoring these. */
22824 if (attr
&& DW_STRING (attr
)
22825 && (startswith (DW_STRING (attr
), "._")
22826 || startswith (DW_STRING (attr
), "<anonymous")))
22829 /* GCC might emit a nameless typedef that has a linkage name. See
22830 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22831 if (!attr
|| DW_STRING (attr
) == NULL
)
22833 char *demangled
= NULL
;
22835 attr
= dw2_linkage_name_attr (die
, cu
);
22836 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
22839 /* Avoid demangling DW_STRING (attr) the second time on a second
22840 call for the same DIE. */
22841 if (!DW_STRING_IS_CANONICAL (attr
))
22842 demangled
= gdb_demangle (DW_STRING (attr
), DMGL_TYPES
);
22848 /* FIXME: we already did this for the partial symbol... */
22850 = obstack_strdup (&objfile
->per_bfd
->storage_obstack
,
22852 DW_STRING_IS_CANONICAL (attr
) = 1;
22855 /* Strip any leading namespaces/classes, keep only the base name.
22856 DW_AT_name for named DIEs does not contain the prefixes. */
22857 base
= strrchr (DW_STRING (attr
), ':');
22858 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
22861 return DW_STRING (attr
);
22870 if (!DW_STRING_IS_CANONICAL (attr
))
22873 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
22874 &objfile
->per_bfd
->storage_obstack
);
22875 DW_STRING_IS_CANONICAL (attr
) = 1;
22877 return DW_STRING (attr
);
22880 /* Return the die that this die in an extension of, or NULL if there
22881 is none. *EXT_CU is the CU containing DIE on input, and the CU
22882 containing the return value on output. */
22884 static struct die_info
*
22885 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
22887 struct attribute
*attr
;
22889 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
22893 return follow_die_ref (die
, attr
, ext_cu
);
22896 /* A convenience function that returns an "unknown" DWARF name,
22897 including the value of V. STR is the name of the entity being
22898 printed, e.g., "TAG". */
22900 static const char *
22901 dwarf_unknown (const char *str
, unsigned v
)
22903 char *cell
= get_print_cell ();
22904 xsnprintf (cell
, PRINT_CELL_SIZE
, "DW_%s_<unknown: %u>", str
, v
);
22908 /* Convert a DIE tag into its string name. */
22910 static const char *
22911 dwarf_tag_name (unsigned tag
)
22913 const char *name
= get_DW_TAG_name (tag
);
22916 return dwarf_unknown ("TAG", tag
);
22921 /* Convert a DWARF attribute code into its string name. */
22923 static const char *
22924 dwarf_attr_name (unsigned attr
)
22928 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22929 if (attr
== DW_AT_MIPS_fde
)
22930 return "DW_AT_MIPS_fde";
22932 if (attr
== DW_AT_HP_block_index
)
22933 return "DW_AT_HP_block_index";
22936 name
= get_DW_AT_name (attr
);
22939 return dwarf_unknown ("AT", attr
);
22944 /* Convert a unit type to corresponding DW_UT name. */
22946 static const char *
22947 dwarf_unit_type_name (int unit_type
) {
22951 return "DW_UT_compile (0x01)";
22953 return "DW_UT_type (0x02)";
22955 return "DW_UT_partial (0x03)";
22957 return "DW_UT_skeleton (0x04)";
22959 return "DW_UT_split_compile (0x05)";
22961 return "DW_UT_split_type (0x06)";
22963 return "DW_UT_lo_user (0x80)";
22965 return "DW_UT_hi_user (0xff)";
22971 /* Convert a DWARF value form code into its string name. */
22973 static const char *
22974 dwarf_form_name (unsigned form
)
22976 const char *name
= get_DW_FORM_name (form
);
22979 return dwarf_unknown ("FORM", form
);
22984 static const char *
22985 dwarf_bool_name (unsigned mybool
)
22993 /* Convert a DWARF type code into its string name. */
22995 static const char *
22996 dwarf_type_encoding_name (unsigned enc
)
22998 const char *name
= get_DW_ATE_name (enc
);
23001 return dwarf_unknown ("ATE", enc
);
23007 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
23011 print_spaces (indent
, f
);
23012 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
23013 dwarf_tag_name (die
->tag
), die
->abbrev
,
23014 sect_offset_str (die
->sect_off
));
23016 if (die
->parent
!= NULL
)
23018 print_spaces (indent
, f
);
23019 fprintf_unfiltered (f
, " parent at offset: %s\n",
23020 sect_offset_str (die
->parent
->sect_off
));
23023 print_spaces (indent
, f
);
23024 fprintf_unfiltered (f
, " has children: %s\n",
23025 dwarf_bool_name (die
->child
!= NULL
));
23027 print_spaces (indent
, f
);
23028 fprintf_unfiltered (f
, " attributes:\n");
23030 for (i
= 0; i
< die
->num_attrs
; ++i
)
23032 print_spaces (indent
, f
);
23033 fprintf_unfiltered (f
, " %s (%s) ",
23034 dwarf_attr_name (die
->attrs
[i
].name
),
23035 dwarf_form_name (die
->attrs
[i
].form
));
23037 switch (die
->attrs
[i
].form
)
23040 case DW_FORM_addrx
:
23041 case DW_FORM_GNU_addr_index
:
23042 fprintf_unfiltered (f
, "address: ");
23043 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
23045 case DW_FORM_block2
:
23046 case DW_FORM_block4
:
23047 case DW_FORM_block
:
23048 case DW_FORM_block1
:
23049 fprintf_unfiltered (f
, "block: size %s",
23050 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
23052 case DW_FORM_exprloc
:
23053 fprintf_unfiltered (f
, "expression: size %s",
23054 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
23056 case DW_FORM_data16
:
23057 fprintf_unfiltered (f
, "constant of 16 bytes");
23059 case DW_FORM_ref_addr
:
23060 fprintf_unfiltered (f
, "ref address: ");
23061 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
23063 case DW_FORM_GNU_ref_alt
:
23064 fprintf_unfiltered (f
, "alt ref address: ");
23065 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
23071 case DW_FORM_ref_udata
:
23072 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
23073 (long) (DW_UNSND (&die
->attrs
[i
])));
23075 case DW_FORM_data1
:
23076 case DW_FORM_data2
:
23077 case DW_FORM_data4
:
23078 case DW_FORM_data8
:
23079 case DW_FORM_udata
:
23080 case DW_FORM_sdata
:
23081 fprintf_unfiltered (f
, "constant: %s",
23082 pulongest (DW_UNSND (&die
->attrs
[i
])));
23084 case DW_FORM_sec_offset
:
23085 fprintf_unfiltered (f
, "section offset: %s",
23086 pulongest (DW_UNSND (&die
->attrs
[i
])));
23088 case DW_FORM_ref_sig8
:
23089 fprintf_unfiltered (f
, "signature: %s",
23090 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
23092 case DW_FORM_string
:
23094 case DW_FORM_line_strp
:
23096 case DW_FORM_GNU_str_index
:
23097 case DW_FORM_GNU_strp_alt
:
23098 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
23099 DW_STRING (&die
->attrs
[i
])
23100 ? DW_STRING (&die
->attrs
[i
]) : "",
23101 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
23104 if (DW_UNSND (&die
->attrs
[i
]))
23105 fprintf_unfiltered (f
, "flag: TRUE");
23107 fprintf_unfiltered (f
, "flag: FALSE");
23109 case DW_FORM_flag_present
:
23110 fprintf_unfiltered (f
, "flag: TRUE");
23112 case DW_FORM_indirect
:
23113 /* The reader will have reduced the indirect form to
23114 the "base form" so this form should not occur. */
23115 fprintf_unfiltered (f
,
23116 "unexpected attribute form: DW_FORM_indirect");
23118 case DW_FORM_implicit_const
:
23119 fprintf_unfiltered (f
, "constant: %s",
23120 plongest (DW_SND (&die
->attrs
[i
])));
23123 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
23124 die
->attrs
[i
].form
);
23127 fprintf_unfiltered (f
, "\n");
23132 dump_die_for_error (struct die_info
*die
)
23134 dump_die_shallow (gdb_stderr
, 0, die
);
23138 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
23140 int indent
= level
* 4;
23142 gdb_assert (die
!= NULL
);
23144 if (level
>= max_level
)
23147 dump_die_shallow (f
, indent
, die
);
23149 if (die
->child
!= NULL
)
23151 print_spaces (indent
, f
);
23152 fprintf_unfiltered (f
, " Children:");
23153 if (level
+ 1 < max_level
)
23155 fprintf_unfiltered (f
, "\n");
23156 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
23160 fprintf_unfiltered (f
,
23161 " [not printed, max nesting level reached]\n");
23165 if (die
->sibling
!= NULL
&& level
> 0)
23167 dump_die_1 (f
, level
, max_level
, die
->sibling
);
23171 /* This is called from the pdie macro in gdbinit.in.
23172 It's not static so gcc will keep a copy callable from gdb. */
23175 dump_die (struct die_info
*die
, int max_level
)
23177 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
23181 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
23185 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
23186 to_underlying (die
->sect_off
),
23192 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
23196 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
23198 if (attr_form_is_ref (attr
))
23199 return (sect_offset
) DW_UNSND (attr
);
23201 complaint (_("unsupported die ref attribute form: '%s'"),
23202 dwarf_form_name (attr
->form
));
23206 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
23207 * the value held by the attribute is not constant. */
23210 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
23212 if (attr
->form
== DW_FORM_sdata
|| attr
->form
== DW_FORM_implicit_const
)
23213 return DW_SND (attr
);
23214 else if (attr
->form
== DW_FORM_udata
23215 || attr
->form
== DW_FORM_data1
23216 || attr
->form
== DW_FORM_data2
23217 || attr
->form
== DW_FORM_data4
23218 || attr
->form
== DW_FORM_data8
)
23219 return DW_UNSND (attr
);
23222 /* For DW_FORM_data16 see attr_form_is_constant. */
23223 complaint (_("Attribute value is not a constant (%s)"),
23224 dwarf_form_name (attr
->form
));
23225 return default_value
;
23229 /* Follow reference or signature attribute ATTR of SRC_DIE.
23230 On entry *REF_CU is the CU of SRC_DIE.
23231 On exit *REF_CU is the CU of the result. */
23233 static struct die_info
*
23234 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23235 struct dwarf2_cu
**ref_cu
)
23237 struct die_info
*die
;
23239 if (attr_form_is_ref (attr
))
23240 die
= follow_die_ref (src_die
, attr
, ref_cu
);
23241 else if (attr
->form
== DW_FORM_ref_sig8
)
23242 die
= follow_die_sig (src_die
, attr
, ref_cu
);
23245 dump_die_for_error (src_die
);
23246 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23247 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23253 /* Follow reference OFFSET.
23254 On entry *REF_CU is the CU of the source die referencing OFFSET.
23255 On exit *REF_CU is the CU of the result.
23256 Returns NULL if OFFSET is invalid. */
23258 static struct die_info
*
23259 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
23260 struct dwarf2_cu
**ref_cu
)
23262 struct die_info temp_die
;
23263 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
23264 struct dwarf2_per_objfile
*dwarf2_per_objfile
23265 = cu
->per_cu
->dwarf2_per_objfile
;
23267 gdb_assert (cu
->per_cu
!= NULL
);
23271 if (cu
->per_cu
->is_debug_types
)
23273 /* .debug_types CUs cannot reference anything outside their CU.
23274 If they need to, they have to reference a signatured type via
23275 DW_FORM_ref_sig8. */
23276 if (!offset_in_cu_p (&cu
->header
, sect_off
))
23279 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
23280 || !offset_in_cu_p (&cu
->header
, sect_off
))
23282 struct dwarf2_per_cu_data
*per_cu
;
23284 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
23285 dwarf2_per_objfile
);
23287 /* If necessary, add it to the queue and load its DIEs. */
23288 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
23289 load_full_comp_unit (per_cu
, false, cu
->language
);
23291 target_cu
= per_cu
->cu
;
23293 else if (cu
->dies
== NULL
)
23295 /* We're loading full DIEs during partial symbol reading. */
23296 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
23297 load_full_comp_unit (cu
->per_cu
, false, language_minimal
);
23300 *ref_cu
= target_cu
;
23301 temp_die
.sect_off
= sect_off
;
23303 if (target_cu
!= cu
)
23304 target_cu
->ancestor
= cu
;
23306 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
23308 to_underlying (sect_off
));
23311 /* Follow reference attribute ATTR of SRC_DIE.
23312 On entry *REF_CU is the CU of SRC_DIE.
23313 On exit *REF_CU is the CU of the result. */
23315 static struct die_info
*
23316 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
23317 struct dwarf2_cu
**ref_cu
)
23319 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
23320 struct dwarf2_cu
*cu
= *ref_cu
;
23321 struct die_info
*die
;
23323 die
= follow_die_offset (sect_off
,
23324 (attr
->form
== DW_FORM_GNU_ref_alt
23325 || cu
->per_cu
->is_dwz
),
23328 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23329 "at %s [in module %s]"),
23330 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
23331 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
23336 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23337 Returned value is intended for DW_OP_call*. Returned
23338 dwarf2_locexpr_baton->data has lifetime of
23339 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
23341 struct dwarf2_locexpr_baton
23342 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
23343 struct dwarf2_per_cu_data
*per_cu
,
23344 CORE_ADDR (*get_frame_pc
) (void *baton
),
23345 void *baton
, bool resolve_abstract_p
)
23347 struct dwarf2_cu
*cu
;
23348 struct die_info
*die
;
23349 struct attribute
*attr
;
23350 struct dwarf2_locexpr_baton retval
;
23351 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
23352 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
23354 if (per_cu
->cu
== NULL
)
23355 load_cu (per_cu
, false);
23359 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23360 Instead just throw an error, not much else we can do. */
23361 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23362 sect_offset_str (sect_off
), objfile_name (objfile
));
23365 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23367 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23368 sect_offset_str (sect_off
), objfile_name (objfile
));
23370 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23371 if (!attr
&& resolve_abstract_p
23372 && (dwarf2_per_objfile
->abstract_to_concrete
.find (die
->sect_off
)
23373 != dwarf2_per_objfile
->abstract_to_concrete
.end ()))
23375 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
23377 = ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
23378 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
23380 for (const auto &cand_off
23381 : dwarf2_per_objfile
->abstract_to_concrete
[die
->sect_off
])
23383 struct dwarf2_cu
*cand_cu
= cu
;
23384 struct die_info
*cand
23385 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23388 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23391 CORE_ADDR pc_low
, pc_high
;
23392 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23393 if (pc_low
== ((CORE_ADDR
) -1))
23395 pc_low
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_low
+ baseaddr
);
23396 pc_high
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc_high
+ baseaddr
);
23397 if (!(pc_low
<= pc
&& pc
< pc_high
))
23401 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23408 /* DWARF: "If there is no such attribute, then there is no effect.".
23409 DATA is ignored if SIZE is 0. */
23411 retval
.data
= NULL
;
23414 else if (attr_form_is_section_offset (attr
))
23416 struct dwarf2_loclist_baton loclist_baton
;
23417 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
23420 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23422 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23424 retval
.size
= size
;
23428 if (!attr_form_is_block (attr
))
23429 error (_("Dwarf Error: DIE at %s referenced in module %s "
23430 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23431 sect_offset_str (sect_off
), objfile_name (objfile
));
23433 retval
.data
= DW_BLOCK (attr
)->data
;
23434 retval
.size
= DW_BLOCK (attr
)->size
;
23436 retval
.per_cu
= cu
->per_cu
;
23438 age_cached_comp_units (dwarf2_per_objfile
);
23443 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23446 struct dwarf2_locexpr_baton
23447 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23448 struct dwarf2_per_cu_data
*per_cu
,
23449 CORE_ADDR (*get_frame_pc
) (void *baton
),
23452 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23454 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, get_frame_pc
, baton
);
23457 /* Write a constant of a given type as target-ordered bytes into
23460 static const gdb_byte
*
23461 write_constant_as_bytes (struct obstack
*obstack
,
23462 enum bfd_endian byte_order
,
23469 *len
= TYPE_LENGTH (type
);
23470 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23471 store_unsigned_integer (result
, *len
, byte_order
, value
);
23476 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23477 pointer to the constant bytes and set LEN to the length of the
23478 data. If memory is needed, allocate it on OBSTACK. If the DIE
23479 does not have a DW_AT_const_value, return NULL. */
23482 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23483 struct dwarf2_per_cu_data
*per_cu
,
23484 struct obstack
*obstack
,
23487 struct dwarf2_cu
*cu
;
23488 struct die_info
*die
;
23489 struct attribute
*attr
;
23490 const gdb_byte
*result
= NULL
;
23493 enum bfd_endian byte_order
;
23494 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
23496 if (per_cu
->cu
== NULL
)
23497 load_cu (per_cu
, false);
23501 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23502 Instead just throw an error, not much else we can do. */
23503 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23504 sect_offset_str (sect_off
), objfile_name (objfile
));
23507 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23509 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23510 sect_offset_str (sect_off
), objfile_name (objfile
));
23512 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23516 byte_order
= (bfd_big_endian (objfile
->obfd
)
23517 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23519 switch (attr
->form
)
23522 case DW_FORM_addrx
:
23523 case DW_FORM_GNU_addr_index
:
23527 *len
= cu
->header
.addr_size
;
23528 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23529 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
23533 case DW_FORM_string
:
23536 case DW_FORM_GNU_str_index
:
23537 case DW_FORM_GNU_strp_alt
:
23538 /* DW_STRING is already allocated on the objfile obstack, point
23540 result
= (const gdb_byte
*) DW_STRING (attr
);
23541 *len
= strlen (DW_STRING (attr
));
23543 case DW_FORM_block1
:
23544 case DW_FORM_block2
:
23545 case DW_FORM_block4
:
23546 case DW_FORM_block
:
23547 case DW_FORM_exprloc
:
23548 case DW_FORM_data16
:
23549 result
= DW_BLOCK (attr
)->data
;
23550 *len
= DW_BLOCK (attr
)->size
;
23553 /* The DW_AT_const_value attributes are supposed to carry the
23554 symbol's value "represented as it would be on the target
23555 architecture." By the time we get here, it's already been
23556 converted to host endianness, so we just need to sign- or
23557 zero-extend it as appropriate. */
23558 case DW_FORM_data1
:
23559 type
= die_type (die
, cu
);
23560 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23561 if (result
== NULL
)
23562 result
= write_constant_as_bytes (obstack
, byte_order
,
23565 case DW_FORM_data2
:
23566 type
= die_type (die
, cu
);
23567 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23568 if (result
== NULL
)
23569 result
= write_constant_as_bytes (obstack
, byte_order
,
23572 case DW_FORM_data4
:
23573 type
= die_type (die
, cu
);
23574 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23575 if (result
== NULL
)
23576 result
= write_constant_as_bytes (obstack
, byte_order
,
23579 case DW_FORM_data8
:
23580 type
= die_type (die
, cu
);
23581 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23582 if (result
== NULL
)
23583 result
= write_constant_as_bytes (obstack
, byte_order
,
23587 case DW_FORM_sdata
:
23588 case DW_FORM_implicit_const
:
23589 type
= die_type (die
, cu
);
23590 result
= write_constant_as_bytes (obstack
, byte_order
,
23591 type
, DW_SND (attr
), len
);
23594 case DW_FORM_udata
:
23595 type
= die_type (die
, cu
);
23596 result
= write_constant_as_bytes (obstack
, byte_order
,
23597 type
, DW_UNSND (attr
), len
);
23601 complaint (_("unsupported const value attribute form: '%s'"),
23602 dwarf_form_name (attr
->form
));
23609 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23610 valid type for this die is found. */
23613 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
23614 struct dwarf2_per_cu_data
*per_cu
)
23616 struct dwarf2_cu
*cu
;
23617 struct die_info
*die
;
23619 if (per_cu
->cu
== NULL
)
23620 load_cu (per_cu
, false);
23625 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23629 return die_type (die
, cu
);
23632 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23636 dwarf2_get_die_type (cu_offset die_offset
,
23637 struct dwarf2_per_cu_data
*per_cu
)
23639 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
23640 return get_die_type_at_offset (die_offset_sect
, per_cu
);
23643 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23644 On entry *REF_CU is the CU of SRC_DIE.
23645 On exit *REF_CU is the CU of the result.
23646 Returns NULL if the referenced DIE isn't found. */
23648 static struct die_info
*
23649 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
23650 struct dwarf2_cu
**ref_cu
)
23652 struct die_info temp_die
;
23653 struct dwarf2_cu
*sig_cu
, *cu
= *ref_cu
;
23654 struct die_info
*die
;
23656 /* While it might be nice to assert sig_type->type == NULL here,
23657 we can get here for DW_AT_imported_declaration where we need
23658 the DIE not the type. */
23660 /* If necessary, add it to the queue and load its DIEs. */
23662 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
23663 read_signatured_type (sig_type
);
23665 sig_cu
= sig_type
->per_cu
.cu
;
23666 gdb_assert (sig_cu
!= NULL
);
23667 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
23668 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
23669 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
23670 to_underlying (temp_die
.sect_off
));
23673 struct dwarf2_per_objfile
*dwarf2_per_objfile
23674 = (*ref_cu
)->per_cu
->dwarf2_per_objfile
;
23676 /* For .gdb_index version 7 keep track of included TUs.
23677 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23678 if (dwarf2_per_objfile
->index_table
!= NULL
23679 && dwarf2_per_objfile
->index_table
->version
<= 7)
23681 VEC_safe_push (dwarf2_per_cu_ptr
,
23682 (*ref_cu
)->per_cu
->imported_symtabs
,
23688 sig_cu
->ancestor
= cu
;
23696 /* Follow signatured type referenced by ATTR in SRC_DIE.
23697 On entry *REF_CU is the CU of SRC_DIE.
23698 On exit *REF_CU is the CU of the result.
23699 The result is the DIE of the type.
23700 If the referenced type cannot be found an error is thrown. */
23702 static struct die_info
*
23703 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23704 struct dwarf2_cu
**ref_cu
)
23706 ULONGEST signature
= DW_SIGNATURE (attr
);
23707 struct signatured_type
*sig_type
;
23708 struct die_info
*die
;
23710 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
23712 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
23713 /* sig_type will be NULL if the signatured type is missing from
23715 if (sig_type
== NULL
)
23717 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23718 " from DIE at %s [in module %s]"),
23719 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23720 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23723 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
23726 dump_die_for_error (src_die
);
23727 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23728 " from DIE at %s [in module %s]"),
23729 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23730 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23736 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23737 reading in and processing the type unit if necessary. */
23739 static struct type
*
23740 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
23741 struct dwarf2_cu
*cu
)
23743 struct dwarf2_per_objfile
*dwarf2_per_objfile
23744 = cu
->per_cu
->dwarf2_per_objfile
;
23745 struct signatured_type
*sig_type
;
23746 struct dwarf2_cu
*type_cu
;
23747 struct die_info
*type_die
;
23750 sig_type
= lookup_signatured_type (cu
, signature
);
23751 /* sig_type will be NULL if the signatured type is missing from
23753 if (sig_type
== NULL
)
23755 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23756 " from DIE at %s [in module %s]"),
23757 hex_string (signature
), sect_offset_str (die
->sect_off
),
23758 objfile_name (dwarf2_per_objfile
->objfile
));
23759 return build_error_marker_type (cu
, die
);
23762 /* If we already know the type we're done. */
23763 if (sig_type
->type
!= NULL
)
23764 return sig_type
->type
;
23767 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
23768 if (type_die
!= NULL
)
23770 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23771 is created. This is important, for example, because for c++ classes
23772 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23773 type
= read_type_die (type_die
, type_cu
);
23776 complaint (_("Dwarf Error: Cannot build signatured type %s"
23777 " referenced from DIE at %s [in module %s]"),
23778 hex_string (signature
), sect_offset_str (die
->sect_off
),
23779 objfile_name (dwarf2_per_objfile
->objfile
));
23780 type
= build_error_marker_type (cu
, die
);
23785 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23786 " from DIE at %s [in module %s]"),
23787 hex_string (signature
), sect_offset_str (die
->sect_off
),
23788 objfile_name (dwarf2_per_objfile
->objfile
));
23789 type
= build_error_marker_type (cu
, die
);
23791 sig_type
->type
= type
;
23796 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23797 reading in and processing the type unit if necessary. */
23799 static struct type
*
23800 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
23801 struct dwarf2_cu
*cu
) /* ARI: editCase function */
23803 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23804 if (attr_form_is_ref (attr
))
23806 struct dwarf2_cu
*type_cu
= cu
;
23807 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
23809 return read_type_die (type_die
, type_cu
);
23811 else if (attr
->form
== DW_FORM_ref_sig8
)
23813 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
23817 struct dwarf2_per_objfile
*dwarf2_per_objfile
23818 = cu
->per_cu
->dwarf2_per_objfile
;
23820 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23821 " at %s [in module %s]"),
23822 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
23823 objfile_name (dwarf2_per_objfile
->objfile
));
23824 return build_error_marker_type (cu
, die
);
23828 /* Load the DIEs associated with type unit PER_CU into memory. */
23831 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
23833 struct signatured_type
*sig_type
;
23835 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23836 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
23838 /* We have the per_cu, but we need the signatured_type.
23839 Fortunately this is an easy translation. */
23840 gdb_assert (per_cu
->is_debug_types
);
23841 sig_type
= (struct signatured_type
*) per_cu
;
23843 gdb_assert (per_cu
->cu
== NULL
);
23845 read_signatured_type (sig_type
);
23847 gdb_assert (per_cu
->cu
!= NULL
);
23850 /* die_reader_func for read_signatured_type.
23851 This is identical to load_full_comp_unit_reader,
23852 but is kept separate for now. */
23855 read_signatured_type_reader (const struct die_reader_specs
*reader
,
23856 const gdb_byte
*info_ptr
,
23857 struct die_info
*comp_unit_die
,
23861 struct dwarf2_cu
*cu
= reader
->cu
;
23863 gdb_assert (cu
->die_hash
== NULL
);
23865 htab_create_alloc_ex (cu
->header
.length
/ 12,
23869 &cu
->comp_unit_obstack
,
23870 hashtab_obstack_allocate
,
23871 dummy_obstack_deallocate
);
23874 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
23875 &info_ptr
, comp_unit_die
);
23876 cu
->dies
= comp_unit_die
;
23877 /* comp_unit_die is not stored in die_hash, no need. */
23879 /* We try not to read any attributes in this function, because not
23880 all CUs needed for references have been loaded yet, and symbol
23881 table processing isn't initialized. But we have to set the CU language,
23882 or we won't be able to build types correctly.
23883 Similarly, if we do not read the producer, we can not apply
23884 producer-specific interpretation. */
23885 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
23888 /* Read in a signatured type and build its CU and DIEs.
23889 If the type is a stub for the real type in a DWO file,
23890 read in the real type from the DWO file as well. */
23893 read_signatured_type (struct signatured_type
*sig_type
)
23895 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
23897 gdb_assert (per_cu
->is_debug_types
);
23898 gdb_assert (per_cu
->cu
== NULL
);
23900 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1, false,
23901 read_signatured_type_reader
, NULL
);
23902 sig_type
->per_cu
.tu_read
= 1;
23905 /* Decode simple location descriptions.
23906 Given a pointer to a dwarf block that defines a location, compute
23907 the location and return the value.
23909 NOTE drow/2003-11-18: This function is called in two situations
23910 now: for the address of static or global variables (partial symbols
23911 only) and for offsets into structures which are expected to be
23912 (more or less) constant. The partial symbol case should go away,
23913 and only the constant case should remain. That will let this
23914 function complain more accurately. A few special modes are allowed
23915 without complaint for global variables (for instance, global
23916 register values and thread-local values).
23918 A location description containing no operations indicates that the
23919 object is optimized out. The return value is 0 for that case.
23920 FIXME drow/2003-11-16: No callers check for this case any more; soon all
23921 callers will only want a very basic result and this can become a
23924 Note that stack[0] is unused except as a default error return. */
23927 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
23929 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
23931 size_t size
= blk
->size
;
23932 const gdb_byte
*data
= blk
->data
;
23933 CORE_ADDR stack
[64];
23935 unsigned int bytes_read
, unsnd
;
23941 stack
[++stacki
] = 0;
23980 stack
[++stacki
] = op
- DW_OP_lit0
;
24015 stack
[++stacki
] = op
- DW_OP_reg0
;
24017 dwarf2_complex_location_expr_complaint ();
24021 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
24023 stack
[++stacki
] = unsnd
;
24025 dwarf2_complex_location_expr_complaint ();
24029 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
24034 case DW_OP_const1u
:
24035 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
24039 case DW_OP_const1s
:
24040 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
24044 case DW_OP_const2u
:
24045 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
24049 case DW_OP_const2s
:
24050 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
24054 case DW_OP_const4u
:
24055 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
24059 case DW_OP_const4s
:
24060 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
24064 case DW_OP_const8u
:
24065 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
24070 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
24076 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
24081 stack
[stacki
+ 1] = stack
[stacki
];
24086 stack
[stacki
- 1] += stack
[stacki
];
24090 case DW_OP_plus_uconst
:
24091 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
24097 stack
[stacki
- 1] -= stack
[stacki
];
24102 /* If we're not the last op, then we definitely can't encode
24103 this using GDB's address_class enum. This is valid for partial
24104 global symbols, although the variable's address will be bogus
24107 dwarf2_complex_location_expr_complaint ();
24110 case DW_OP_GNU_push_tls_address
:
24111 case DW_OP_form_tls_address
:
24112 /* The top of the stack has the offset from the beginning
24113 of the thread control block at which the variable is located. */
24114 /* Nothing should follow this operator, so the top of stack would
24116 /* This is valid for partial global symbols, but the variable's
24117 address will be bogus in the psymtab. Make it always at least
24118 non-zero to not look as a variable garbage collected by linker
24119 which have DW_OP_addr 0. */
24121 dwarf2_complex_location_expr_complaint ();
24125 case DW_OP_GNU_uninit
:
24129 case DW_OP_GNU_addr_index
:
24130 case DW_OP_GNU_const_index
:
24131 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
24138 const char *name
= get_DW_OP_name (op
);
24141 complaint (_("unsupported stack op: '%s'"),
24144 complaint (_("unsupported stack op: '%02x'"),
24148 return (stack
[stacki
]);
24151 /* Enforce maximum stack depth of SIZE-1 to avoid writing
24152 outside of the allocated space. Also enforce minimum>0. */
24153 if (stacki
>= ARRAY_SIZE (stack
) - 1)
24155 complaint (_("location description stack overflow"));
24161 complaint (_("location description stack underflow"));
24165 return (stack
[stacki
]);
24168 /* memory allocation interface */
24170 static struct dwarf_block
*
24171 dwarf_alloc_block (struct dwarf2_cu
*cu
)
24173 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
24176 static struct die_info
*
24177 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
24179 struct die_info
*die
;
24180 size_t size
= sizeof (struct die_info
);
24183 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
24185 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
24186 memset (die
, 0, sizeof (struct die_info
));
24191 /* Macro support. */
24193 /* Return file name relative to the compilation directory of file number I in
24194 *LH's file name table. The result is allocated using xmalloc; the caller is
24195 responsible for freeing it. */
24198 file_file_name (int file
, struct line_header
*lh
)
24200 /* Is the file number a valid index into the line header's file name
24201 table? Remember that file numbers start with one, not zero. */
24202 if (1 <= file
&& file
<= lh
->file_names
.size ())
24204 const file_entry
&fe
= lh
->file_names
[file
- 1];
24206 if (!IS_ABSOLUTE_PATH (fe
.name
))
24208 const char *dir
= fe
.include_dir (lh
);
24210 return concat (dir
, SLASH_STRING
, fe
.name
, (char *) NULL
);
24212 return xstrdup (fe
.name
);
24216 /* The compiler produced a bogus file number. We can at least
24217 record the macro definitions made in the file, even if we
24218 won't be able to find the file by name. */
24219 char fake_name
[80];
24221 xsnprintf (fake_name
, sizeof (fake_name
),
24222 "<bad macro file number %d>", file
);
24224 complaint (_("bad file number in macro information (%d)"),
24227 return xstrdup (fake_name
);
24231 /* Return the full name of file number I in *LH's file name table.
24232 Use COMP_DIR as the name of the current directory of the
24233 compilation. The result is allocated using xmalloc; the caller is
24234 responsible for freeing it. */
24236 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
24238 /* Is the file number a valid index into the line header's file name
24239 table? Remember that file numbers start with one, not zero. */
24240 if (1 <= file
&& file
<= lh
->file_names
.size ())
24242 char *relative
= file_file_name (file
, lh
);
24244 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
24246 return reconcat (relative
, comp_dir
, SLASH_STRING
,
24247 relative
, (char *) NULL
);
24250 return file_file_name (file
, lh
);
24254 static struct macro_source_file
*
24255 macro_start_file (struct dwarf2_cu
*cu
,
24256 int file
, int line
,
24257 struct macro_source_file
*current_file
,
24258 struct line_header
*lh
)
24260 /* File name relative to the compilation directory of this source file. */
24261 char *file_name
= file_file_name (file
, lh
);
24263 if (! current_file
)
24265 /* Note: We don't create a macro table for this compilation unit
24266 at all until we actually get a filename. */
24267 struct macro_table
*macro_table
= cu
->get_builder ()->get_macro_table ();
24269 /* If we have no current file, then this must be the start_file
24270 directive for the compilation unit's main source file. */
24271 current_file
= macro_set_main (macro_table
, file_name
);
24272 macro_define_special (macro_table
);
24275 current_file
= macro_include (current_file
, line
, file_name
);
24279 return current_file
;
24282 static const char *
24283 consume_improper_spaces (const char *p
, const char *body
)
24287 complaint (_("macro definition contains spaces "
24288 "in formal argument list:\n`%s'"),
24300 parse_macro_definition (struct macro_source_file
*file
, int line
,
24305 /* The body string takes one of two forms. For object-like macro
24306 definitions, it should be:
24308 <macro name> " " <definition>
24310 For function-like macro definitions, it should be:
24312 <macro name> "() " <definition>
24314 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24316 Spaces may appear only where explicitly indicated, and in the
24319 The Dwarf 2 spec says that an object-like macro's name is always
24320 followed by a space, but versions of GCC around March 2002 omit
24321 the space when the macro's definition is the empty string.
24323 The Dwarf 2 spec says that there should be no spaces between the
24324 formal arguments in a function-like macro's formal argument list,
24325 but versions of GCC around March 2002 include spaces after the
24329 /* Find the extent of the macro name. The macro name is terminated
24330 by either a space or null character (for an object-like macro) or
24331 an opening paren (for a function-like macro). */
24332 for (p
= body
; *p
; p
++)
24333 if (*p
== ' ' || *p
== '(')
24336 if (*p
== ' ' || *p
== '\0')
24338 /* It's an object-like macro. */
24339 int name_len
= p
- body
;
24340 char *name
= savestring (body
, name_len
);
24341 const char *replacement
;
24344 replacement
= body
+ name_len
+ 1;
24347 dwarf2_macro_malformed_definition_complaint (body
);
24348 replacement
= body
+ name_len
;
24351 macro_define_object (file
, line
, name
, replacement
);
24355 else if (*p
== '(')
24357 /* It's a function-like macro. */
24358 char *name
= savestring (body
, p
- body
);
24361 char **argv
= XNEWVEC (char *, argv_size
);
24365 p
= consume_improper_spaces (p
, body
);
24367 /* Parse the formal argument list. */
24368 while (*p
&& *p
!= ')')
24370 /* Find the extent of the current argument name. */
24371 const char *arg_start
= p
;
24373 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
24376 if (! *p
|| p
== arg_start
)
24377 dwarf2_macro_malformed_definition_complaint (body
);
24380 /* Make sure argv has room for the new argument. */
24381 if (argc
>= argv_size
)
24384 argv
= XRESIZEVEC (char *, argv
, argv_size
);
24387 argv
[argc
++] = savestring (arg_start
, p
- arg_start
);
24390 p
= consume_improper_spaces (p
, body
);
24392 /* Consume the comma, if present. */
24397 p
= consume_improper_spaces (p
, body
);
24406 /* Perfectly formed definition, no complaints. */
24407 macro_define_function (file
, line
, name
,
24408 argc
, (const char **) argv
,
24410 else if (*p
== '\0')
24412 /* Complain, but do define it. */
24413 dwarf2_macro_malformed_definition_complaint (body
);
24414 macro_define_function (file
, line
, name
,
24415 argc
, (const char **) argv
,
24419 /* Just complain. */
24420 dwarf2_macro_malformed_definition_complaint (body
);
24423 /* Just complain. */
24424 dwarf2_macro_malformed_definition_complaint (body
);
24430 for (i
= 0; i
< argc
; i
++)
24436 dwarf2_macro_malformed_definition_complaint (body
);
24439 /* Skip some bytes from BYTES according to the form given in FORM.
24440 Returns the new pointer. */
24442 static const gdb_byte
*
24443 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
24444 enum dwarf_form form
,
24445 unsigned int offset_size
,
24446 struct dwarf2_section_info
*section
)
24448 unsigned int bytes_read
;
24452 case DW_FORM_data1
:
24457 case DW_FORM_data2
:
24461 case DW_FORM_data4
:
24465 case DW_FORM_data8
:
24469 case DW_FORM_data16
:
24473 case DW_FORM_string
:
24474 read_direct_string (abfd
, bytes
, &bytes_read
);
24475 bytes
+= bytes_read
;
24478 case DW_FORM_sec_offset
:
24480 case DW_FORM_GNU_strp_alt
:
24481 bytes
+= offset_size
;
24484 case DW_FORM_block
:
24485 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
24486 bytes
+= bytes_read
;
24489 case DW_FORM_block1
:
24490 bytes
+= 1 + read_1_byte (abfd
, bytes
);
24492 case DW_FORM_block2
:
24493 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
24495 case DW_FORM_block4
:
24496 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
24499 case DW_FORM_addrx
:
24500 case DW_FORM_sdata
:
24502 case DW_FORM_udata
:
24503 case DW_FORM_GNU_addr_index
:
24504 case DW_FORM_GNU_str_index
:
24505 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
24508 dwarf2_section_buffer_overflow_complaint (section
);
24513 case DW_FORM_implicit_const
:
24518 complaint (_("invalid form 0x%x in `%s'"),
24519 form
, get_section_name (section
));
24527 /* A helper for dwarf_decode_macros that handles skipping an unknown
24528 opcode. Returns an updated pointer to the macro data buffer; or,
24529 on error, issues a complaint and returns NULL. */
24531 static const gdb_byte
*
24532 skip_unknown_opcode (unsigned int opcode
,
24533 const gdb_byte
**opcode_definitions
,
24534 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
24536 unsigned int offset_size
,
24537 struct dwarf2_section_info
*section
)
24539 unsigned int bytes_read
, i
;
24541 const gdb_byte
*defn
;
24543 if (opcode_definitions
[opcode
] == NULL
)
24545 complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24550 defn
= opcode_definitions
[opcode
];
24551 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
24552 defn
+= bytes_read
;
24554 for (i
= 0; i
< arg
; ++i
)
24556 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
,
24557 (enum dwarf_form
) defn
[i
], offset_size
,
24559 if (mac_ptr
== NULL
)
24561 /* skip_form_bytes already issued the complaint. */
24569 /* A helper function which parses the header of a macro section.
24570 If the macro section is the extended (for now called "GNU") type,
24571 then this updates *OFFSET_SIZE. Returns a pointer to just after
24572 the header, or issues a complaint and returns NULL on error. */
24574 static const gdb_byte
*
24575 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
24577 const gdb_byte
*mac_ptr
,
24578 unsigned int *offset_size
,
24579 int section_is_gnu
)
24581 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
24583 if (section_is_gnu
)
24585 unsigned int version
, flags
;
24587 version
= read_2_bytes (abfd
, mac_ptr
);
24588 if (version
!= 4 && version
!= 5)
24590 complaint (_("unrecognized version `%d' in .debug_macro section"),
24596 flags
= read_1_byte (abfd
, mac_ptr
);
24598 *offset_size
= (flags
& 1) ? 8 : 4;
24600 if ((flags
& 2) != 0)
24601 /* We don't need the line table offset. */
24602 mac_ptr
+= *offset_size
;
24604 /* Vendor opcode descriptions. */
24605 if ((flags
& 4) != 0)
24607 unsigned int i
, count
;
24609 count
= read_1_byte (abfd
, mac_ptr
);
24611 for (i
= 0; i
< count
; ++i
)
24613 unsigned int opcode
, bytes_read
;
24616 opcode
= read_1_byte (abfd
, mac_ptr
);
24618 opcode_definitions
[opcode
] = mac_ptr
;
24619 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24620 mac_ptr
+= bytes_read
;
24629 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24630 including DW_MACRO_import. */
24633 dwarf_decode_macro_bytes (struct dwarf2_cu
*cu
,
24635 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
24636 struct macro_source_file
*current_file
,
24637 struct line_header
*lh
,
24638 struct dwarf2_section_info
*section
,
24639 int section_is_gnu
, int section_is_dwz
,
24640 unsigned int offset_size
,
24641 htab_t include_hash
)
24643 struct dwarf2_per_objfile
*dwarf2_per_objfile
24644 = cu
->per_cu
->dwarf2_per_objfile
;
24645 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24646 enum dwarf_macro_record_type macinfo_type
;
24647 int at_commandline
;
24648 const gdb_byte
*opcode_definitions
[256];
24650 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
24651 &offset_size
, section_is_gnu
);
24652 if (mac_ptr
== NULL
)
24654 /* We already issued a complaint. */
24658 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24659 GDB is still reading the definitions from command line. First
24660 DW_MACINFO_start_file will need to be ignored as it was already executed
24661 to create CURRENT_FILE for the main source holding also the command line
24662 definitions. On first met DW_MACINFO_start_file this flag is reset to
24663 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24665 at_commandline
= 1;
24669 /* Do we at least have room for a macinfo type byte? */
24670 if (mac_ptr
>= mac_end
)
24672 dwarf2_section_buffer_overflow_complaint (section
);
24676 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
24679 /* Note that we rely on the fact that the corresponding GNU and
24680 DWARF constants are the same. */
24682 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24683 switch (macinfo_type
)
24685 /* A zero macinfo type indicates the end of the macro
24690 case DW_MACRO_define
:
24691 case DW_MACRO_undef
:
24692 case DW_MACRO_define_strp
:
24693 case DW_MACRO_undef_strp
:
24694 case DW_MACRO_define_sup
:
24695 case DW_MACRO_undef_sup
:
24697 unsigned int bytes_read
;
24702 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24703 mac_ptr
+= bytes_read
;
24705 if (macinfo_type
== DW_MACRO_define
24706 || macinfo_type
== DW_MACRO_undef
)
24708 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24709 mac_ptr
+= bytes_read
;
24713 LONGEST str_offset
;
24715 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
24716 mac_ptr
+= offset_size
;
24718 if (macinfo_type
== DW_MACRO_define_sup
24719 || macinfo_type
== DW_MACRO_undef_sup
24722 struct dwz_file
*dwz
24723 = dwarf2_get_dwz_file (dwarf2_per_objfile
);
24725 body
= read_indirect_string_from_dwz (objfile
,
24729 body
= read_indirect_string_at_offset (dwarf2_per_objfile
,
24733 is_define
= (macinfo_type
== DW_MACRO_define
24734 || macinfo_type
== DW_MACRO_define_strp
24735 || macinfo_type
== DW_MACRO_define_sup
);
24736 if (! current_file
)
24738 /* DWARF violation as no main source is present. */
24739 complaint (_("debug info with no main source gives macro %s "
24741 is_define
? _("definition") : _("undefinition"),
24745 if ((line
== 0 && !at_commandline
)
24746 || (line
!= 0 && at_commandline
))
24747 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24748 at_commandline
? _("command-line") : _("in-file"),
24749 is_define
? _("definition") : _("undefinition"),
24750 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
24754 /* Fedora's rpm-build's "debugedit" binary
24755 corrupted .debug_macro sections.
24758 https://bugzilla.redhat.com/show_bug.cgi?id=1708786 */
24759 complaint (_("debug info gives %s invalid macro %s "
24760 "without body (corrupted?) at line %d "
24762 at_commandline
? _("command-line") : _("in-file"),
24763 is_define
? _("definition") : _("undefinition"),
24764 line
, current_file
->filename
);
24766 else if (is_define
)
24767 parse_macro_definition (current_file
, line
, body
);
24770 gdb_assert (macinfo_type
== DW_MACRO_undef
24771 || macinfo_type
== DW_MACRO_undef_strp
24772 || macinfo_type
== DW_MACRO_undef_sup
);
24773 macro_undef (current_file
, line
, body
);
24778 case DW_MACRO_start_file
:
24780 unsigned int bytes_read
;
24783 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24784 mac_ptr
+= bytes_read
;
24785 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24786 mac_ptr
+= bytes_read
;
24788 if ((line
== 0 && !at_commandline
)
24789 || (line
!= 0 && at_commandline
))
24790 complaint (_("debug info gives source %d included "
24791 "from %s at %s line %d"),
24792 file
, at_commandline
? _("command-line") : _("file"),
24793 line
== 0 ? _("zero") : _("non-zero"), line
);
24795 if (at_commandline
)
24797 /* This DW_MACRO_start_file was executed in the
24799 at_commandline
= 0;
24802 current_file
= macro_start_file (cu
, file
, line
, current_file
,
24807 case DW_MACRO_end_file
:
24808 if (! current_file
)
24809 complaint (_("macro debug info has an unmatched "
24810 "`close_file' directive"));
24813 current_file
= current_file
->included_by
;
24814 if (! current_file
)
24816 enum dwarf_macro_record_type next_type
;
24818 /* GCC circa March 2002 doesn't produce the zero
24819 type byte marking the end of the compilation
24820 unit. Complain if it's not there, but exit no
24823 /* Do we at least have room for a macinfo type byte? */
24824 if (mac_ptr
>= mac_end
)
24826 dwarf2_section_buffer_overflow_complaint (section
);
24830 /* We don't increment mac_ptr here, so this is just
24833 = (enum dwarf_macro_record_type
) read_1_byte (abfd
,
24835 if (next_type
!= 0)
24836 complaint (_("no terminating 0-type entry for "
24837 "macros in `.debug_macinfo' section"));
24844 case DW_MACRO_import
:
24845 case DW_MACRO_import_sup
:
24849 bfd
*include_bfd
= abfd
;
24850 struct dwarf2_section_info
*include_section
= section
;
24851 const gdb_byte
*include_mac_end
= mac_end
;
24852 int is_dwz
= section_is_dwz
;
24853 const gdb_byte
*new_mac_ptr
;
24855 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
24856 mac_ptr
+= offset_size
;
24858 if (macinfo_type
== DW_MACRO_import_sup
)
24860 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
24862 dwarf2_read_section (objfile
, &dwz
->macro
);
24864 include_section
= &dwz
->macro
;
24865 include_bfd
= get_section_bfd_owner (include_section
);
24866 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
24870 new_mac_ptr
= include_section
->buffer
+ offset
;
24871 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
24875 /* This has actually happened; see
24876 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
24877 complaint (_("recursive DW_MACRO_import in "
24878 ".debug_macro section"));
24882 *slot
= (void *) new_mac_ptr
;
24884 dwarf_decode_macro_bytes (cu
, include_bfd
, new_mac_ptr
,
24885 include_mac_end
, current_file
, lh
,
24886 section
, section_is_gnu
, is_dwz
,
24887 offset_size
, include_hash
);
24889 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
24894 case DW_MACINFO_vendor_ext
:
24895 if (!section_is_gnu
)
24897 unsigned int bytes_read
;
24899 /* This reads the constant, but since we don't recognize
24900 any vendor extensions, we ignore it. */
24901 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24902 mac_ptr
+= bytes_read
;
24903 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24904 mac_ptr
+= bytes_read
;
24906 /* We don't recognize any vendor extensions. */
24912 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
24913 mac_ptr
, mac_end
, abfd
, offset_size
,
24915 if (mac_ptr
== NULL
)
24920 } while (macinfo_type
!= 0);
24924 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
24925 int section_is_gnu
)
24927 struct dwarf2_per_objfile
*dwarf2_per_objfile
24928 = cu
->per_cu
->dwarf2_per_objfile
;
24929 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24930 struct line_header
*lh
= cu
->line_header
;
24932 const gdb_byte
*mac_ptr
, *mac_end
;
24933 struct macro_source_file
*current_file
= 0;
24934 enum dwarf_macro_record_type macinfo_type
;
24935 unsigned int offset_size
= cu
->header
.offset_size
;
24936 const gdb_byte
*opcode_definitions
[256];
24938 struct dwarf2_section_info
*section
;
24939 const char *section_name
;
24941 if (cu
->dwo_unit
!= NULL
)
24943 if (section_is_gnu
)
24945 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
24946 section_name
= ".debug_macro.dwo";
24950 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
24951 section_name
= ".debug_macinfo.dwo";
24956 if (section_is_gnu
)
24958 section
= &dwarf2_per_objfile
->macro
;
24959 section_name
= ".debug_macro";
24963 section
= &dwarf2_per_objfile
->macinfo
;
24964 section_name
= ".debug_macinfo";
24968 dwarf2_read_section (objfile
, section
);
24969 if (section
->buffer
== NULL
)
24971 complaint (_("missing %s section"), section_name
);
24974 abfd
= get_section_bfd_owner (section
);
24976 /* First pass: Find the name of the base filename.
24977 This filename is needed in order to process all macros whose definition
24978 (or undefinition) comes from the command line. These macros are defined
24979 before the first DW_MACINFO_start_file entry, and yet still need to be
24980 associated to the base file.
24982 To determine the base file name, we scan the macro definitions until we
24983 reach the first DW_MACINFO_start_file entry. We then initialize
24984 CURRENT_FILE accordingly so that any macro definition found before the
24985 first DW_MACINFO_start_file can still be associated to the base file. */
24987 mac_ptr
= section
->buffer
+ offset
;
24988 mac_end
= section
->buffer
+ section
->size
;
24990 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
24991 &offset_size
, section_is_gnu
);
24992 if (mac_ptr
== NULL
)
24994 /* We already issued a complaint. */
25000 /* Do we at least have room for a macinfo type byte? */
25001 if (mac_ptr
>= mac_end
)
25003 /* Complaint is printed during the second pass as GDB will probably
25004 stop the first pass earlier upon finding
25005 DW_MACINFO_start_file. */
25009 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
25012 /* Note that we rely on the fact that the corresponding GNU and
25013 DWARF constants are the same. */
25015 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
25016 switch (macinfo_type
)
25018 /* A zero macinfo type indicates the end of the macro
25023 case DW_MACRO_define
:
25024 case DW_MACRO_undef
:
25025 /* Only skip the data by MAC_PTR. */
25027 unsigned int bytes_read
;
25029 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25030 mac_ptr
+= bytes_read
;
25031 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
25032 mac_ptr
+= bytes_read
;
25036 case DW_MACRO_start_file
:
25038 unsigned int bytes_read
;
25041 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25042 mac_ptr
+= bytes_read
;
25043 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25044 mac_ptr
+= bytes_read
;
25046 current_file
= macro_start_file (cu
, file
, line
, current_file
, lh
);
25050 case DW_MACRO_end_file
:
25051 /* No data to skip by MAC_PTR. */
25054 case DW_MACRO_define_strp
:
25055 case DW_MACRO_undef_strp
:
25056 case DW_MACRO_define_sup
:
25057 case DW_MACRO_undef_sup
:
25059 unsigned int bytes_read
;
25061 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25062 mac_ptr
+= bytes_read
;
25063 mac_ptr
+= offset_size
;
25067 case DW_MACRO_import
:
25068 case DW_MACRO_import_sup
:
25069 /* Note that, according to the spec, a transparent include
25070 chain cannot call DW_MACRO_start_file. So, we can just
25071 skip this opcode. */
25072 mac_ptr
+= offset_size
;
25075 case DW_MACINFO_vendor_ext
:
25076 /* Only skip the data by MAC_PTR. */
25077 if (!section_is_gnu
)
25079 unsigned int bytes_read
;
25081 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
25082 mac_ptr
+= bytes_read
;
25083 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
25084 mac_ptr
+= bytes_read
;
25089 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
25090 mac_ptr
, mac_end
, abfd
, offset_size
,
25092 if (mac_ptr
== NULL
)
25097 } while (macinfo_type
!= 0 && current_file
== NULL
);
25099 /* Second pass: Process all entries.
25101 Use the AT_COMMAND_LINE flag to determine whether we are still processing
25102 command-line macro definitions/undefinitions. This flag is unset when we
25103 reach the first DW_MACINFO_start_file entry. */
25105 htab_up
include_hash (htab_create_alloc (1, htab_hash_pointer
,
25107 NULL
, xcalloc
, xfree
));
25108 mac_ptr
= section
->buffer
+ offset
;
25109 slot
= htab_find_slot (include_hash
.get (), mac_ptr
, INSERT
);
25110 *slot
= (void *) mac_ptr
;
25111 dwarf_decode_macro_bytes (cu
, abfd
, mac_ptr
, mac_end
,
25112 current_file
, lh
, section
,
25113 section_is_gnu
, 0, offset_size
,
25114 include_hash
.get ());
25117 /* Check if the attribute's form is a DW_FORM_block*
25118 if so return true else false. */
25121 attr_form_is_block (const struct attribute
*attr
)
25123 return (attr
== NULL
? 0 :
25124 attr
->form
== DW_FORM_block1
25125 || attr
->form
== DW_FORM_block2
25126 || attr
->form
== DW_FORM_block4
25127 || attr
->form
== DW_FORM_block
25128 || attr
->form
== DW_FORM_exprloc
);
25131 /* Return non-zero if ATTR's value is a section offset --- classes
25132 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
25133 You may use DW_UNSND (attr) to retrieve such offsets.
25135 Section 7.5.4, "Attribute Encodings", explains that no attribute
25136 may have a value that belongs to more than one of these classes; it
25137 would be ambiguous if we did, because we use the same forms for all
25141 attr_form_is_section_offset (const struct attribute
*attr
)
25143 return (attr
->form
== DW_FORM_data4
25144 || attr
->form
== DW_FORM_data8
25145 || attr
->form
== DW_FORM_sec_offset
);
25148 /* Return non-zero if ATTR's value falls in the 'constant' class, or
25149 zero otherwise. When this function returns true, you can apply
25150 dwarf2_get_attr_constant_value to it.
25152 However, note that for some attributes you must check
25153 attr_form_is_section_offset before using this test. DW_FORM_data4
25154 and DW_FORM_data8 are members of both the constant class, and of
25155 the classes that contain offsets into other debug sections
25156 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
25157 that, if an attribute's can be either a constant or one of the
25158 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
25159 taken as section offsets, not constants.
25161 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
25162 cannot handle that. */
25165 attr_form_is_constant (const struct attribute
*attr
)
25167 switch (attr
->form
)
25169 case DW_FORM_sdata
:
25170 case DW_FORM_udata
:
25171 case DW_FORM_data1
:
25172 case DW_FORM_data2
:
25173 case DW_FORM_data4
:
25174 case DW_FORM_data8
:
25175 case DW_FORM_implicit_const
:
25183 /* DW_ADDR is always stored already as sect_offset; despite for the forms
25184 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
25187 attr_form_is_ref (const struct attribute
*attr
)
25189 switch (attr
->form
)
25191 case DW_FORM_ref_addr
:
25196 case DW_FORM_ref_udata
:
25197 case DW_FORM_GNU_ref_alt
:
25204 /* Return the .debug_loc section to use for CU.
25205 For DWO files use .debug_loc.dwo. */
25207 static struct dwarf2_section_info
*
25208 cu_debug_loc_section (struct dwarf2_cu
*cu
)
25210 struct dwarf2_per_objfile
*dwarf2_per_objfile
25211 = cu
->per_cu
->dwarf2_per_objfile
;
25215 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
25217 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
25219 return (cu
->header
.version
>= 5 ? &dwarf2_per_objfile
->loclists
25220 : &dwarf2_per_objfile
->loc
);
25223 /* A helper function that fills in a dwarf2_loclist_baton. */
25226 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
25227 struct dwarf2_loclist_baton
*baton
,
25228 const struct attribute
*attr
)
25230 struct dwarf2_per_objfile
*dwarf2_per_objfile
25231 = cu
->per_cu
->dwarf2_per_objfile
;
25232 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
25234 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
25236 baton
->per_cu
= cu
->per_cu
;
25237 gdb_assert (baton
->per_cu
);
25238 /* We don't know how long the location list is, but make sure we
25239 don't run off the edge of the section. */
25240 baton
->size
= section
->size
- DW_UNSND (attr
);
25241 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
25242 baton
->base_address
= cu
->base_address
;
25243 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
25247 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
25248 struct dwarf2_cu
*cu
, int is_block
)
25250 struct dwarf2_per_objfile
*dwarf2_per_objfile
25251 = cu
->per_cu
->dwarf2_per_objfile
;
25252 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
25253 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
25255 if (attr_form_is_section_offset (attr
)
25256 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
25257 the section. If so, fall through to the complaint in the
25259 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
25261 struct dwarf2_loclist_baton
*baton
;
25263 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
25265 fill_in_loclist_baton (cu
, baton
, attr
);
25267 if (cu
->base_known
== 0)
25268 complaint (_("Location list used without "
25269 "specifying the CU base address."));
25271 SYMBOL_ACLASS_INDEX (sym
) = (is_block
25272 ? dwarf2_loclist_block_index
25273 : dwarf2_loclist_index
);
25274 SYMBOL_LOCATION_BATON (sym
) = baton
;
25278 struct dwarf2_locexpr_baton
*baton
;
25280 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
25281 baton
->per_cu
= cu
->per_cu
;
25282 gdb_assert (baton
->per_cu
);
25284 if (attr_form_is_block (attr
))
25286 /* Note that we're just copying the block's data pointer
25287 here, not the actual data. We're still pointing into the
25288 info_buffer for SYM's objfile; right now we never release
25289 that buffer, but when we do clean up properly this may
25291 baton
->size
= DW_BLOCK (attr
)->size
;
25292 baton
->data
= DW_BLOCK (attr
)->data
;
25296 dwarf2_invalid_attrib_class_complaint ("location description",
25297 SYMBOL_NATURAL_NAME (sym
));
25301 SYMBOL_ACLASS_INDEX (sym
) = (is_block
25302 ? dwarf2_locexpr_block_index
25303 : dwarf2_locexpr_index
);
25304 SYMBOL_LOCATION_BATON (sym
) = baton
;
25308 /* Return the OBJFILE associated with the compilation unit CU. If CU
25309 came from a separate debuginfo file, then the master objfile is
25313 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
25315 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25317 /* Return the master objfile, so that we can report and look up the
25318 correct file containing this variable. */
25319 if (objfile
->separate_debug_objfile_backlink
)
25320 objfile
= objfile
->separate_debug_objfile_backlink
;
25325 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25326 (CU_HEADERP is unused in such case) or prepare a temporary copy at
25327 CU_HEADERP first. */
25329 static const struct comp_unit_head
*
25330 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
25331 struct dwarf2_per_cu_data
*per_cu
)
25333 const gdb_byte
*info_ptr
;
25336 return &per_cu
->cu
->header
;
25338 info_ptr
= per_cu
->section
->buffer
+ to_underlying (per_cu
->sect_off
);
25340 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
25341 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->section
,
25342 rcuh_kind::COMPILE
);
25347 /* Return the address size given in the compilation unit header for CU. */
25350 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
25352 struct comp_unit_head cu_header_local
;
25353 const struct comp_unit_head
*cu_headerp
;
25355 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25357 return cu_headerp
->addr_size
;
25360 /* Return the offset size given in the compilation unit header for CU. */
25363 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
25365 struct comp_unit_head cu_header_local
;
25366 const struct comp_unit_head
*cu_headerp
;
25368 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25370 return cu_headerp
->offset_size
;
25373 /* See its dwarf2loc.h declaration. */
25376 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
25378 struct comp_unit_head cu_header_local
;
25379 const struct comp_unit_head
*cu_headerp
;
25381 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25383 if (cu_headerp
->version
== 2)
25384 return cu_headerp
->addr_size
;
25386 return cu_headerp
->offset_size
;
25389 /* Return the text offset of the CU. The returned offset comes from
25390 this CU's objfile. If this objfile came from a separate debuginfo
25391 file, then the offset may be different from the corresponding
25392 offset in the parent objfile. */
25395 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
25397 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25399 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
25402 /* Return a type that is a generic pointer type, the size of which matches
25403 the address size given in the compilation unit header for PER_CU. */
25404 static struct type
*
25405 dwarf2_per_cu_addr_type (struct dwarf2_per_cu_data
*per_cu
)
25407 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25408 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
25409 struct type
*addr_type
= lookup_pointer_type (void_type
);
25410 int addr_size
= dwarf2_per_cu_addr_size (per_cu
);
25412 if (TYPE_LENGTH (addr_type
) == addr_size
)
25416 = dwarf2_per_cu_addr_sized_int_type (per_cu
, TYPE_UNSIGNED (addr_type
));
25420 /* Return DWARF version number of PER_CU. */
25423 dwarf2_version (struct dwarf2_per_cu_data
*per_cu
)
25425 return per_cu
->dwarf_version
;
25428 /* Locate the .debug_info compilation unit from CU's objfile which contains
25429 the DIE at OFFSET. Raises an error on failure. */
25431 static struct dwarf2_per_cu_data
*
25432 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
25433 unsigned int offset_in_dwz
,
25434 struct dwarf2_per_objfile
*dwarf2_per_objfile
)
25436 struct dwarf2_per_cu_data
*this_cu
;
25440 high
= dwarf2_per_objfile
->all_comp_units
.size () - 1;
25443 struct dwarf2_per_cu_data
*mid_cu
;
25444 int mid
= low
+ (high
- low
) / 2;
25446 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
25447 if (mid_cu
->is_dwz
> offset_in_dwz
25448 || (mid_cu
->is_dwz
== offset_in_dwz
25449 && mid_cu
->sect_off
+ mid_cu
->length
>= sect_off
))
25454 gdb_assert (low
== high
);
25455 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
25456 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
25458 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
25459 error (_("Dwarf Error: could not find partial DIE containing "
25460 "offset %s [in module %s]"),
25461 sect_offset_str (sect_off
),
25462 bfd_get_filename (dwarf2_per_objfile
->objfile
->obfd
));
25464 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->sect_off
25466 return dwarf2_per_objfile
->all_comp_units
[low
-1];
25470 if (low
== dwarf2_per_objfile
->all_comp_units
.size () - 1
25471 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
25472 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
25473 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
25478 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25480 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data
*per_cu_
)
25481 : per_cu (per_cu_
),
25483 has_loclist (false),
25484 checked_producer (false),
25485 producer_is_gxx_lt_4_6 (false),
25486 producer_is_gcc_lt_4_3 (false),
25487 producer_is_icc (false),
25488 producer_is_icc_lt_14 (false),
25489 producer_is_codewarrior (false),
25490 processing_has_namespace_info (false)
25495 /* Destroy a dwarf2_cu. */
25497 dwarf2_cu::~dwarf2_cu ()
25502 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25505 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
25506 enum language pretend_language
)
25508 struct attribute
*attr
;
25510 /* Set the language we're debugging. */
25511 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
25513 set_cu_language (DW_UNSND (attr
), cu
);
25516 cu
->language
= pretend_language
;
25517 cu
->language_defn
= language_def (cu
->language
);
25520 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
25523 /* Increase the age counter on each cached compilation unit, and free
25524 any that are too old. */
25527 age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
25529 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
25531 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
25532 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25533 while (per_cu
!= NULL
)
25535 per_cu
->cu
->last_used
++;
25536 if (per_cu
->cu
->last_used
<= dwarf_max_cache_age
)
25537 dwarf2_mark (per_cu
->cu
);
25538 per_cu
= per_cu
->cu
->read_in_chain
;
25541 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25542 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
25543 while (per_cu
!= NULL
)
25545 struct dwarf2_per_cu_data
*next_cu
;
25547 next_cu
= per_cu
->cu
->read_in_chain
;
25549 if (!per_cu
->cu
->mark
)
25552 *last_chain
= next_cu
;
25555 last_chain
= &per_cu
->cu
->read_in_chain
;
25561 /* Remove a single compilation unit from the cache. */
25564 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
25566 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
25567 struct dwarf2_per_objfile
*dwarf2_per_objfile
25568 = target_per_cu
->dwarf2_per_objfile
;
25570 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25571 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
25572 while (per_cu
!= NULL
)
25574 struct dwarf2_per_cu_data
*next_cu
;
25576 next_cu
= per_cu
->cu
->read_in_chain
;
25578 if (per_cu
== target_per_cu
)
25582 *last_chain
= next_cu
;
25586 last_chain
= &per_cu
->cu
->read_in_chain
;
25592 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25593 We store these in a hash table separate from the DIEs, and preserve them
25594 when the DIEs are flushed out of cache.
25596 The CU "per_cu" pointer is needed because offset alone is not enough to
25597 uniquely identify the type. A file may have multiple .debug_types sections,
25598 or the type may come from a DWO file. Furthermore, while it's more logical
25599 to use per_cu->section+offset, with Fission the section with the data is in
25600 the DWO file but we don't know that section at the point we need it.
25601 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25602 because we can enter the lookup routine, get_die_type_at_offset, from
25603 outside this file, and thus won't necessarily have PER_CU->cu.
25604 Fortunately, PER_CU is stable for the life of the objfile. */
25606 struct dwarf2_per_cu_offset_and_type
25608 const struct dwarf2_per_cu_data
*per_cu
;
25609 sect_offset sect_off
;
25613 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25616 per_cu_offset_and_type_hash (const void *item
)
25618 const struct dwarf2_per_cu_offset_and_type
*ofs
25619 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
25621 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
25624 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25627 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
25629 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
25630 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
25631 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
25632 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
25634 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
25635 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
25638 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25639 table if necessary. For convenience, return TYPE.
25641 The DIEs reading must have careful ordering to:
25642 * Not cause infite loops trying to read in DIEs as a prerequisite for
25643 reading current DIE.
25644 * Not trying to dereference contents of still incompletely read in types
25645 while reading in other DIEs.
25646 * Enable referencing still incompletely read in types just by a pointer to
25647 the type without accessing its fields.
25649 Therefore caller should follow these rules:
25650 * Try to fetch any prerequisite types we may need to build this DIE type
25651 before building the type and calling set_die_type.
25652 * After building type call set_die_type for current DIE as soon as
25653 possible before fetching more types to complete the current type.
25654 * Make the type as complete as possible before fetching more types. */
25656 static struct type
*
25657 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
25659 struct dwarf2_per_objfile
*dwarf2_per_objfile
25660 = cu
->per_cu
->dwarf2_per_objfile
;
25661 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
25662 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
25663 struct attribute
*attr
;
25664 struct dynamic_prop prop
;
25666 /* For Ada types, make sure that the gnat-specific data is always
25667 initialized (if not already set). There are a few types where
25668 we should not be doing so, because the type-specific area is
25669 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25670 where the type-specific area is used to store the floatformat).
25671 But this is not a problem, because the gnat-specific information
25672 is actually not needed for these types. */
25673 if (need_gnat_info (cu
)
25674 && TYPE_CODE (type
) != TYPE_CODE_FUNC
25675 && TYPE_CODE (type
) != TYPE_CODE_FLT
25676 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
25677 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
25678 && TYPE_CODE (type
) != TYPE_CODE_METHOD
25679 && !HAVE_GNAT_AUX_INFO (type
))
25680 INIT_GNAT_SPECIFIC (type
);
25682 /* Read DW_AT_allocated and set in type. */
25683 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
25684 if (attr_form_is_block (attr
))
25686 struct type
*prop_type
25687 = dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
25688 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25689 add_dyn_prop (DYN_PROP_ALLOCATED
, prop
, type
);
25691 else if (attr
!= NULL
)
25693 complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25694 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
25695 sect_offset_str (die
->sect_off
));
25698 /* Read DW_AT_associated and set in type. */
25699 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
25700 if (attr_form_is_block (attr
))
25702 struct type
*prop_type
25703 = dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
25704 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25705 add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
, type
);
25707 else if (attr
!= NULL
)
25709 complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25710 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
25711 sect_offset_str (die
->sect_off
));
25714 /* Read DW_AT_data_location and set in type. */
25715 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
25716 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
,
25717 dwarf2_per_cu_addr_type (cu
->per_cu
)))
25718 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
);
25720 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
25722 dwarf2_per_objfile
->die_type_hash
=
25723 htab_create_alloc_ex (127,
25724 per_cu_offset_and_type_hash
,
25725 per_cu_offset_and_type_eq
,
25727 &objfile
->objfile_obstack
,
25728 hashtab_obstack_allocate
,
25729 dummy_obstack_deallocate
);
25732 ofs
.per_cu
= cu
->per_cu
;
25733 ofs
.sect_off
= die
->sect_off
;
25735 slot
= (struct dwarf2_per_cu_offset_and_type
**)
25736 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
25738 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25739 sect_offset_str (die
->sect_off
));
25740 *slot
= XOBNEW (&objfile
->objfile_obstack
,
25741 struct dwarf2_per_cu_offset_and_type
);
25746 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25747 or return NULL if the die does not have a saved type. */
25749 static struct type
*
25750 get_die_type_at_offset (sect_offset sect_off
,
25751 struct dwarf2_per_cu_data
*per_cu
)
25753 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
25754 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
25756 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
25759 ofs
.per_cu
= per_cu
;
25760 ofs
.sect_off
= sect_off
;
25761 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
25762 htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
));
25769 /* Look up the type for DIE in CU in die_type_hash,
25770 or return NULL if DIE does not have a saved type. */
25772 static struct type
*
25773 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
25775 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
);
25778 /* Add a dependence relationship from CU to REF_PER_CU. */
25781 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
25782 struct dwarf2_per_cu_data
*ref_per_cu
)
25786 if (cu
->dependencies
== NULL
)
25788 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
25789 NULL
, &cu
->comp_unit_obstack
,
25790 hashtab_obstack_allocate
,
25791 dummy_obstack_deallocate
);
25793 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
25795 *slot
= ref_per_cu
;
25798 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25799 Set the mark field in every compilation unit in the
25800 cache that we must keep because we are keeping CU. */
25803 dwarf2_mark_helper (void **slot
, void *data
)
25805 struct dwarf2_per_cu_data
*per_cu
;
25807 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
25809 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25810 reading of the chain. As such dependencies remain valid it is not much
25811 useful to track and undo them during QUIT cleanups. */
25812 if (per_cu
->cu
== NULL
)
25815 if (per_cu
->cu
->mark
)
25817 per_cu
->cu
->mark
= true;
25819 if (per_cu
->cu
->dependencies
!= NULL
)
25820 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
25825 /* Set the mark field in CU and in every other compilation unit in the
25826 cache that we must keep because we are keeping CU. */
25829 dwarf2_mark (struct dwarf2_cu
*cu
)
25834 if (cu
->dependencies
!= NULL
)
25835 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
25839 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
25843 per_cu
->cu
->mark
= false;
25844 per_cu
= per_cu
->cu
->read_in_chain
;
25848 /* Trivial hash function for partial_die_info: the hash value of a DIE
25849 is its offset in .debug_info for this objfile. */
25852 partial_die_hash (const void *item
)
25854 const struct partial_die_info
*part_die
25855 = (const struct partial_die_info
*) item
;
25857 return to_underlying (part_die
->sect_off
);
25860 /* Trivial comparison function for partial_die_info structures: two DIEs
25861 are equal if they have the same offset. */
25864 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
25866 const struct partial_die_info
*part_die_lhs
25867 = (const struct partial_die_info
*) item_lhs
;
25868 const struct partial_die_info
*part_die_rhs
25869 = (const struct partial_die_info
*) item_rhs
;
25871 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
25874 struct cmd_list_element
*set_dwarf_cmdlist
;
25875 struct cmd_list_element
*show_dwarf_cmdlist
;
25878 set_dwarf_cmd (const char *args
, int from_tty
)
25880 help_list (set_dwarf_cmdlist
, "maintenance set dwarf ", all_commands
,
25885 show_dwarf_cmd (const char *args
, int from_tty
)
25887 cmd_show_list (show_dwarf_cmdlist
, from_tty
, "");
25890 bool dwarf_always_disassemble
;
25893 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
25894 struct cmd_list_element
*c
, const char *value
)
25896 fprintf_filtered (file
,
25897 _("Whether to always disassemble "
25898 "DWARF expressions is %s.\n"),
25903 show_check_physname (struct ui_file
*file
, int from_tty
,
25904 struct cmd_list_element
*c
, const char *value
)
25906 fprintf_filtered (file
,
25907 _("Whether to check \"physname\" is %s.\n"),
25912 _initialize_dwarf2_read (void)
25914 add_prefix_cmd ("dwarf", class_maintenance
, set_dwarf_cmd
, _("\
25915 Set DWARF specific variables.\n\
25916 Configure DWARF variables such as the cache size."),
25917 &set_dwarf_cmdlist
, "maintenance set dwarf ",
25918 0/*allow-unknown*/, &maintenance_set_cmdlist
);
25920 add_prefix_cmd ("dwarf", class_maintenance
, show_dwarf_cmd
, _("\
25921 Show DWARF specific variables.\n\
25922 Show DWARF variables such as the cache size."),
25923 &show_dwarf_cmdlist
, "maintenance show dwarf ",
25924 0/*allow-unknown*/, &maintenance_show_cmdlist
);
25926 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
25927 &dwarf_max_cache_age
, _("\
25928 Set the upper bound on the age of cached DWARF compilation units."), _("\
25929 Show the upper bound on the age of cached DWARF compilation units."), _("\
25930 A higher limit means that cached compilation units will be stored\n\
25931 in memory longer, and more total memory will be used. Zero disables\n\
25932 caching, which can slow down startup."),
25934 show_dwarf_max_cache_age
,
25935 &set_dwarf_cmdlist
,
25936 &show_dwarf_cmdlist
);
25938 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
25939 &dwarf_always_disassemble
, _("\
25940 Set whether `info address' always disassembles DWARF expressions."), _("\
25941 Show whether `info address' always disassembles DWARF expressions."), _("\
25942 When enabled, DWARF expressions are always printed in an assembly-like\n\
25943 syntax. When disabled, expressions will be printed in a more\n\
25944 conversational style, when possible."),
25946 show_dwarf_always_disassemble
,
25947 &set_dwarf_cmdlist
,
25948 &show_dwarf_cmdlist
);
25950 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
25951 Set debugging of the DWARF reader."), _("\
25952 Show debugging of the DWARF reader."), _("\
25953 When enabled (non-zero), debugging messages are printed during DWARF\n\
25954 reading and symtab expansion. A value of 1 (one) provides basic\n\
25955 information. A value greater than 1 provides more verbose information."),
25958 &setdebuglist
, &showdebuglist
);
25960 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
25961 Set debugging of the DWARF DIE reader."), _("\
25962 Show debugging of the DWARF DIE reader."), _("\
25963 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25964 The value is the maximum depth to print."),
25967 &setdebuglist
, &showdebuglist
);
25969 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
25970 Set debugging of the dwarf line reader."), _("\
25971 Show debugging of the dwarf line reader."), _("\
25972 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25973 A value of 1 (one) provides basic information.\n\
25974 A value greater than 1 provides more verbose information."),
25977 &setdebuglist
, &showdebuglist
);
25979 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
25980 Set cross-checking of \"physname\" code against demangler."), _("\
25981 Show cross-checking of \"physname\" code against demangler."), _("\
25982 When enabled, GDB's internal \"physname\" code is checked against\n\
25984 NULL
, show_check_physname
,
25985 &setdebuglist
, &showdebuglist
);
25987 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25988 no_class
, &use_deprecated_index_sections
, _("\
25989 Set whether to use deprecated gdb_index sections."), _("\
25990 Show whether to use deprecated gdb_index sections."), _("\
25991 When enabled, deprecated .gdb_index sections are used anyway.\n\
25992 Normally they are ignored either because of a missing feature or\n\
25993 performance issue.\n\
25994 Warning: This option must be enabled before gdb reads the file."),
25997 &setlist
, &showlist
);
25999 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
26000 &dwarf2_locexpr_funcs
);
26001 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
26002 &dwarf2_loclist_funcs
);
26004 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
26005 &dwarf2_block_frame_base_locexpr_funcs
);
26006 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
26007 &dwarf2_block_frame_base_loclist_funcs
);
26010 selftests::register_test ("dw2_expand_symtabs_matching",
26011 selftests::dw2_expand_symtabs_matching::run_test
);