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 "common/vec.h"
65 #include "gdbcore.h" /* for gnutarget */
66 #include "gdb/gdb-index.h"
71 #include "common/filestuff.h"
73 #include "namespace.h"
74 #include "common/gdb_unlinker.h"
75 #include "common/function-view.h"
76 #include "common/gdb_optional.h"
77 #include "common/underlying.h"
78 #include "common/byte-vector.h"
79 #include "common/hash_enum.h"
80 #include "filename-seen-cache.h"
83 #include <sys/types.h>
85 #include <unordered_set>
86 #include <unordered_map>
87 #include "common/selftest.h"
90 #include <forward_list>
91 #include "rust-lang.h"
92 #include "common/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 non-zero, cross-check physname against demangler. */
106 static int check_physname
= 0;
108 /* When non-zero, do not reject deprecated .gdb_index sections. */
109 static int use_deprecated_index_sections
= 0;
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
) const;
184 /* Prevent deleting/destroying via a base class pointer. */
186 ~mapped_index_base() = default;
189 /* A description of the mapped index. The file format is described in
190 a comment by the code that writes the index. */
191 struct mapped_index final
: public mapped_index_base
193 /* A slot/bucket in the symbol table hash. */
194 struct symbol_table_slot
196 const offset_type name
;
197 const offset_type vec
;
200 /* Index data format version. */
203 /* The address table data. */
204 gdb::array_view
<const gdb_byte
> address_table
;
206 /* The symbol table, implemented as a hash table. */
207 gdb::array_view
<symbol_table_slot
> symbol_table
;
209 /* A pointer to the constant pool. */
210 const char *constant_pool
= nullptr;
212 bool symbol_name_slot_invalid (offset_type idx
) const override
214 const auto &bucket
= this->symbol_table
[idx
];
215 return bucket
.name
== 0 && bucket
.vec
== 0;
218 /* Convenience method to get at the name of the symbol at IDX in the
220 const char *symbol_name_at (offset_type idx
) const override
221 { return this->constant_pool
+ MAYBE_SWAP (this->symbol_table
[idx
].name
); }
223 size_t symbol_name_count () const override
224 { return this->symbol_table
.size (); }
227 /* A description of the mapped .debug_names.
228 Uninitialized map has CU_COUNT 0. */
229 struct mapped_debug_names final
: public mapped_index_base
231 mapped_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile_
)
232 : dwarf2_per_objfile (dwarf2_per_objfile_
)
235 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
236 bfd_endian dwarf5_byte_order
;
237 bool dwarf5_is_dwarf64
;
238 bool augmentation_is_gdb
;
240 uint32_t cu_count
= 0;
241 uint32_t tu_count
, bucket_count
, name_count
;
242 const gdb_byte
*cu_table_reordered
, *tu_table_reordered
;
243 const uint32_t *bucket_table_reordered
, *hash_table_reordered
;
244 const gdb_byte
*name_table_string_offs_reordered
;
245 const gdb_byte
*name_table_entry_offs_reordered
;
246 const gdb_byte
*entry_pool
;
253 /* Attribute name DW_IDX_*. */
256 /* Attribute form DW_FORM_*. */
259 /* Value if FORM is DW_FORM_implicit_const. */
260 LONGEST implicit_const
;
262 std::vector
<attr
> attr_vec
;
265 std::unordered_map
<ULONGEST
, index_val
> abbrev_map
;
267 const char *namei_to_name (uint32_t namei
) const;
269 /* Implementation of the mapped_index_base virtual interface, for
270 the name_components cache. */
272 const char *symbol_name_at (offset_type idx
) const override
273 { return namei_to_name (idx
); }
275 size_t symbol_name_count () const override
276 { return this->name_count
; }
279 /* See dwarf2read.h. */
282 get_dwarf2_per_objfile (struct objfile
*objfile
)
284 return dwarf2_objfile_data_key
.get (objfile
);
287 /* Default names of the debugging sections. */
289 /* Note that if the debugging section has been compressed, it might
290 have a name like .zdebug_info. */
292 static const struct dwarf2_debug_sections dwarf2_elf_names
=
294 { ".debug_info", ".zdebug_info" },
295 { ".debug_abbrev", ".zdebug_abbrev" },
296 { ".debug_line", ".zdebug_line" },
297 { ".debug_loc", ".zdebug_loc" },
298 { ".debug_loclists", ".zdebug_loclists" },
299 { ".debug_macinfo", ".zdebug_macinfo" },
300 { ".debug_macro", ".zdebug_macro" },
301 { ".debug_str", ".zdebug_str" },
302 { ".debug_line_str", ".zdebug_line_str" },
303 { ".debug_ranges", ".zdebug_ranges" },
304 { ".debug_rnglists", ".zdebug_rnglists" },
305 { ".debug_types", ".zdebug_types" },
306 { ".debug_addr", ".zdebug_addr" },
307 { ".debug_frame", ".zdebug_frame" },
308 { ".eh_frame", NULL
},
309 { ".gdb_index", ".zgdb_index" },
310 { ".debug_names", ".zdebug_names" },
311 { ".debug_aranges", ".zdebug_aranges" },
315 /* List of DWO/DWP sections. */
317 static const struct dwop_section_names
319 struct dwarf2_section_names abbrev_dwo
;
320 struct dwarf2_section_names info_dwo
;
321 struct dwarf2_section_names line_dwo
;
322 struct dwarf2_section_names loc_dwo
;
323 struct dwarf2_section_names loclists_dwo
;
324 struct dwarf2_section_names macinfo_dwo
;
325 struct dwarf2_section_names macro_dwo
;
326 struct dwarf2_section_names str_dwo
;
327 struct dwarf2_section_names str_offsets_dwo
;
328 struct dwarf2_section_names types_dwo
;
329 struct dwarf2_section_names cu_index
;
330 struct dwarf2_section_names tu_index
;
334 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
335 { ".debug_info.dwo", ".zdebug_info.dwo" },
336 { ".debug_line.dwo", ".zdebug_line.dwo" },
337 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
338 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
339 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
340 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
341 { ".debug_str.dwo", ".zdebug_str.dwo" },
342 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
343 { ".debug_types.dwo", ".zdebug_types.dwo" },
344 { ".debug_cu_index", ".zdebug_cu_index" },
345 { ".debug_tu_index", ".zdebug_tu_index" },
348 /* local data types */
350 /* The data in a compilation unit header, after target2host
351 translation, looks like this. */
352 struct comp_unit_head
356 unsigned char addr_size
;
357 unsigned char signed_addr_p
;
358 sect_offset abbrev_sect_off
;
360 /* Size of file offsets; either 4 or 8. */
361 unsigned int offset_size
;
363 /* Size of the length field; either 4 or 12. */
364 unsigned int initial_length_size
;
366 enum dwarf_unit_type unit_type
;
368 /* Offset to the first byte of this compilation unit header in the
369 .debug_info section, for resolving relative reference dies. */
370 sect_offset sect_off
;
372 /* Offset to first die in this cu from the start of the cu.
373 This will be the first byte following the compilation unit header. */
374 cu_offset first_die_cu_offset
;
376 /* 64-bit signature of this type unit - it is valid only for
377 UNIT_TYPE DW_UT_type. */
380 /* For types, offset in the type's DIE of the type defined by this TU. */
381 cu_offset type_cu_offset_in_tu
;
384 /* Type used for delaying computation of method physnames.
385 See comments for compute_delayed_physnames. */
386 struct delayed_method_info
388 /* The type to which the method is attached, i.e., its parent class. */
391 /* The index of the method in the type's function fieldlists. */
394 /* The index of the method in the fieldlist. */
397 /* The name of the DIE. */
400 /* The DIE associated with this method. */
401 struct die_info
*die
;
404 /* Internal state when decoding a particular compilation unit. */
407 explicit dwarf2_cu (struct dwarf2_per_cu_data
*per_cu
);
410 DISABLE_COPY_AND_ASSIGN (dwarf2_cu
);
412 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
413 Create the set of symtabs used by this TU, or if this TU is sharing
414 symtabs with another TU and the symtabs have already been created
415 then restore those symtabs in the line header.
416 We don't need the pc/line-number mapping for type units. */
417 void setup_type_unit_groups (struct die_info
*die
);
419 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
420 buildsym_compunit constructor. */
421 struct compunit_symtab
*start_symtab (const char *name
,
422 const char *comp_dir
,
425 /* Reset the builder. */
426 void reset_builder () { m_builder
.reset (); }
428 /* The header of the compilation unit. */
429 struct comp_unit_head header
{};
431 /* Base address of this compilation unit. */
432 CORE_ADDR base_address
= 0;
434 /* Non-zero if base_address has been set. */
437 /* The language we are debugging. */
438 enum language language
= language_unknown
;
439 const struct language_defn
*language_defn
= nullptr;
441 const char *producer
= nullptr;
444 /* The symtab builder for this CU. This is only non-NULL when full
445 symbols are being read. */
446 std::unique_ptr
<buildsym_compunit
> m_builder
;
449 /* The generic symbol table building routines have separate lists for
450 file scope symbols and all all other scopes (local scopes). So
451 we need to select the right one to pass to add_symbol_to_list().
452 We do it by keeping a pointer to the correct list in list_in_scope.
454 FIXME: The original dwarf code just treated the file scope as the
455 first local scope, and all other local scopes as nested local
456 scopes, and worked fine. Check to see if we really need to
457 distinguish these in buildsym.c. */
458 struct pending
**list_in_scope
= nullptr;
460 /* Hash table holding all the loaded partial DIEs
461 with partial_die->offset.SECT_OFF as hash. */
462 htab_t partial_dies
= nullptr;
464 /* Storage for things with the same lifetime as this read-in compilation
465 unit, including partial DIEs. */
466 auto_obstack comp_unit_obstack
;
468 /* When multiple dwarf2_cu structures are living in memory, this field
469 chains them all together, so that they can be released efficiently.
470 We will probably also want a generation counter so that most-recently-used
471 compilation units are cached... */
472 struct dwarf2_per_cu_data
*read_in_chain
= nullptr;
474 /* Backlink to our per_cu entry. */
475 struct dwarf2_per_cu_data
*per_cu
;
477 /* How many compilation units ago was this CU last referenced? */
480 /* A hash table of DIE cu_offset for following references with
481 die_info->offset.sect_off as hash. */
482 htab_t die_hash
= nullptr;
484 /* Full DIEs if read in. */
485 struct die_info
*dies
= nullptr;
487 /* A set of pointers to dwarf2_per_cu_data objects for compilation
488 units referenced by this one. Only set during full symbol processing;
489 partial symbol tables do not have dependencies. */
490 htab_t dependencies
= nullptr;
492 /* Header data from the line table, during full symbol processing. */
493 struct line_header
*line_header
= nullptr;
494 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
495 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
496 this is the DW_TAG_compile_unit die for this CU. We'll hold on
497 to the line header as long as this DIE is being processed. See
498 process_die_scope. */
499 die_info
*line_header_die_owner
= nullptr;
501 /* A list of methods which need to have physnames computed
502 after all type information has been read. */
503 std::vector
<delayed_method_info
> method_list
;
505 /* To be copied to symtab->call_site_htab. */
506 htab_t call_site_htab
= nullptr;
508 /* Non-NULL if this CU came from a DWO file.
509 There is an invariant here that is important to remember:
510 Except for attributes copied from the top level DIE in the "main"
511 (or "stub") file in preparation for reading the DWO file
512 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
513 Either there isn't a DWO file (in which case this is NULL and the point
514 is moot), or there is and either we're not going to read it (in which
515 case this is NULL) or there is and we are reading it (in which case this
517 struct dwo_unit
*dwo_unit
= nullptr;
519 /* The DW_AT_addr_base attribute if present, zero otherwise
520 (zero is a valid value though).
521 Note this value comes from the Fission stub CU/TU's DIE. */
522 ULONGEST addr_base
= 0;
524 /* The DW_AT_ranges_base attribute if present, zero otherwise
525 (zero is a valid value though).
526 Note this value comes from the Fission stub CU/TU's DIE.
527 Also note that the value is zero in the non-DWO case so this value can
528 be used without needing to know whether DWO files are in use or not.
529 N.B. This does not apply to DW_AT_ranges appearing in
530 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
531 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
532 DW_AT_ranges_base *would* have to be applied, and we'd have to care
533 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
534 ULONGEST ranges_base
= 0;
536 /* When reading debug info generated by older versions of rustc, we
537 have to rewrite some union types to be struct types with a
538 variant part. This rewriting must be done after the CU is fully
539 read in, because otherwise at the point of rewriting some struct
540 type might not have been fully processed. So, we keep a list of
541 all such types here and process them after expansion. */
542 std::vector
<struct type
*> rust_unions
;
544 /* Mark used when releasing cached dies. */
547 /* This CU references .debug_loc. See the symtab->locations_valid field.
548 This test is imperfect as there may exist optimized debug code not using
549 any location list and still facing inlining issues if handled as
550 unoptimized code. For a future better test see GCC PR other/32998. */
551 bool has_loclist
: 1;
553 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is true
554 if all the producer_is_* fields are valid. This information is cached
555 because profiling CU expansion showed excessive time spent in
556 producer_is_gxx_lt_4_6. */
557 bool checked_producer
: 1;
558 bool producer_is_gxx_lt_4_6
: 1;
559 bool producer_is_gcc_lt_4_3
: 1;
560 bool producer_is_icc
: 1;
561 bool producer_is_icc_lt_14
: 1;
562 bool producer_is_codewarrior
: 1;
564 /* When true, the file that we're processing is known to have
565 debugging info for C++ namespaces. GCC 3.3.x did not produce
566 this information, but later versions do. */
568 bool processing_has_namespace_info
: 1;
570 struct partial_die_info
*find_partial_die (sect_offset sect_off
);
572 /* If this CU was inherited by another CU (via specification,
573 abstract_origin, etc), this is the ancestor CU. */
576 /* Get the buildsym_compunit for this CU. */
577 buildsym_compunit
*get_builder ()
579 /* If this CU has a builder associated with it, use that. */
580 if (m_builder
!= nullptr)
581 return m_builder
.get ();
583 /* Otherwise, search ancestors for a valid builder. */
584 if (ancestor
!= nullptr)
585 return ancestor
->get_builder ();
591 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
592 This includes type_unit_group and quick_file_names. */
594 struct stmt_list_hash
596 /* The DWO unit this table is from or NULL if there is none. */
597 struct dwo_unit
*dwo_unit
;
599 /* Offset in .debug_line or .debug_line.dwo. */
600 sect_offset line_sect_off
;
603 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
604 an object of this type. */
606 struct type_unit_group
608 /* dwarf2read.c's main "handle" on a TU symtab.
609 To simplify things we create an artificial CU that "includes" all the
610 type units using this stmt_list so that the rest of the code still has
611 a "per_cu" handle on the symtab.
612 This PER_CU is recognized by having no section. */
613 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
614 struct dwarf2_per_cu_data per_cu
;
616 /* The TUs that share this DW_AT_stmt_list entry.
617 This is added to while parsing type units to build partial symtabs,
618 and is deleted afterwards and not used again. */
619 VEC (sig_type_ptr
) *tus
;
621 /* The compunit symtab.
622 Type units in a group needn't all be defined in the same source file,
623 so we create an essentially anonymous symtab as the compunit symtab. */
624 struct compunit_symtab
*compunit_symtab
;
626 /* The data used to construct the hash key. */
627 struct stmt_list_hash hash
;
629 /* The number of symtabs from the line header.
630 The value here must match line_header.num_file_names. */
631 unsigned int num_symtabs
;
633 /* The symbol tables for this TU (obtained from the files listed in
635 WARNING: The order of entries here must match the order of entries
636 in the line header. After the first TU using this type_unit_group, the
637 line header for the subsequent TUs is recreated from this. This is done
638 because we need to use the same symtabs for each TU using the same
639 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
640 there's no guarantee the line header doesn't have duplicate entries. */
641 struct symtab
**symtabs
;
644 /* These sections are what may appear in a (real or virtual) DWO file. */
648 struct dwarf2_section_info abbrev
;
649 struct dwarf2_section_info line
;
650 struct dwarf2_section_info loc
;
651 struct dwarf2_section_info loclists
;
652 struct dwarf2_section_info macinfo
;
653 struct dwarf2_section_info macro
;
654 struct dwarf2_section_info str
;
655 struct dwarf2_section_info str_offsets
;
656 /* In the case of a virtual DWO file, these two are unused. */
657 struct dwarf2_section_info info
;
658 VEC (dwarf2_section_info_def
) *types
;
661 /* CUs/TUs in DWP/DWO files. */
665 /* Backlink to the containing struct dwo_file. */
666 struct dwo_file
*dwo_file
;
668 /* The "id" that distinguishes this CU/TU.
669 .debug_info calls this "dwo_id", .debug_types calls this "signature".
670 Since signatures came first, we stick with it for consistency. */
673 /* The section this CU/TU lives in, in the DWO file. */
674 struct dwarf2_section_info
*section
;
676 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
677 sect_offset sect_off
;
680 /* For types, offset in the type's DIE of the type defined by this TU. */
681 cu_offset type_offset_in_tu
;
684 /* include/dwarf2.h defines the DWP section codes.
685 It defines a max value but it doesn't define a min value, which we
686 use for error checking, so provide one. */
688 enum dwp_v2_section_ids
693 /* Data for one DWO file.
695 This includes virtual DWO files (a virtual DWO file is a DWO file as it
696 appears in a DWP file). DWP files don't really have DWO files per se -
697 comdat folding of types "loses" the DWO file they came from, and from
698 a high level view DWP files appear to contain a mass of random types.
699 However, to maintain consistency with the non-DWP case we pretend DWP
700 files contain virtual DWO files, and we assign each TU with one virtual
701 DWO file (generally based on the line and abbrev section offsets -
702 a heuristic that seems to work in practice). */
706 dwo_file () = default;
707 DISABLE_COPY_AND_ASSIGN (dwo_file
);
711 gdb_bfd_unref (dbfd
);
713 VEC_free (dwarf2_section_info_def
, sections
.types
);
716 /* The DW_AT_GNU_dwo_name attribute.
717 For virtual DWO files the name is constructed from the section offsets
718 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
719 from related CU+TUs. */
720 const char *dwo_name
= nullptr;
722 /* The DW_AT_comp_dir attribute. */
723 const char *comp_dir
= nullptr;
725 /* The bfd, when the file is open. Otherwise this is NULL.
726 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
729 /* The sections that make up this DWO file.
730 Remember that for virtual DWO files in DWP V2, these are virtual
731 sections (for lack of a better name). */
732 struct dwo_sections sections
{};
734 /* The CUs in the file.
735 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
736 an extension to handle LLVM's Link Time Optimization output (where
737 multiple source files may be compiled into a single object/dwo pair). */
740 /* Table of TUs in the file.
741 Each element is a struct dwo_unit. */
745 /* These sections are what may appear in a DWP file. */
749 /* These are used by both DWP version 1 and 2. */
750 struct dwarf2_section_info str
;
751 struct dwarf2_section_info cu_index
;
752 struct dwarf2_section_info tu_index
;
754 /* These are only used by DWP version 2 files.
755 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
756 sections are referenced by section number, and are not recorded here.
757 In DWP version 2 there is at most one copy of all these sections, each
758 section being (effectively) comprised of the concatenation of all of the
759 individual sections that exist in the version 1 format.
760 To keep the code simple we treat each of these concatenated pieces as a
761 section itself (a virtual section?). */
762 struct dwarf2_section_info abbrev
;
763 struct dwarf2_section_info info
;
764 struct dwarf2_section_info line
;
765 struct dwarf2_section_info loc
;
766 struct dwarf2_section_info macinfo
;
767 struct dwarf2_section_info macro
;
768 struct dwarf2_section_info str_offsets
;
769 struct dwarf2_section_info types
;
772 /* These sections are what may appear in a virtual DWO file in DWP version 1.
773 A virtual DWO file is a DWO file as it appears in a DWP file. */
775 struct virtual_v1_dwo_sections
777 struct dwarf2_section_info abbrev
;
778 struct dwarf2_section_info line
;
779 struct dwarf2_section_info loc
;
780 struct dwarf2_section_info macinfo
;
781 struct dwarf2_section_info macro
;
782 struct dwarf2_section_info str_offsets
;
783 /* Each DWP hash table entry records one CU or one TU.
784 That is recorded here, and copied to dwo_unit.section. */
785 struct dwarf2_section_info info_or_types
;
788 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
789 In version 2, the sections of the DWO files are concatenated together
790 and stored in one section of that name. Thus each ELF section contains
791 several "virtual" sections. */
793 struct virtual_v2_dwo_sections
795 bfd_size_type abbrev_offset
;
796 bfd_size_type abbrev_size
;
798 bfd_size_type line_offset
;
799 bfd_size_type line_size
;
801 bfd_size_type loc_offset
;
802 bfd_size_type loc_size
;
804 bfd_size_type macinfo_offset
;
805 bfd_size_type macinfo_size
;
807 bfd_size_type macro_offset
;
808 bfd_size_type macro_size
;
810 bfd_size_type str_offsets_offset
;
811 bfd_size_type str_offsets_size
;
813 /* Each DWP hash table entry records one CU or one TU.
814 That is recorded here, and copied to dwo_unit.section. */
815 bfd_size_type info_or_types_offset
;
816 bfd_size_type info_or_types_size
;
819 /* Contents of DWP hash tables. */
821 struct dwp_hash_table
823 uint32_t version
, nr_columns
;
824 uint32_t nr_units
, nr_slots
;
825 const gdb_byte
*hash_table
, *unit_table
;
830 const gdb_byte
*indices
;
834 /* This is indexed by column number and gives the id of the section
836 #define MAX_NR_V2_DWO_SECTIONS \
837 (1 /* .debug_info or .debug_types */ \
838 + 1 /* .debug_abbrev */ \
839 + 1 /* .debug_line */ \
840 + 1 /* .debug_loc */ \
841 + 1 /* .debug_str_offsets */ \
842 + 1 /* .debug_macro or .debug_macinfo */)
843 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
844 const gdb_byte
*offsets
;
845 const gdb_byte
*sizes
;
850 /* Data for one DWP file. */
854 dwp_file (const char *name_
, gdb_bfd_ref_ptr
&&abfd
)
856 dbfd (std::move (abfd
))
860 /* Name of the file. */
863 /* File format version. */
867 gdb_bfd_ref_ptr dbfd
;
869 /* Section info for this file. */
870 struct dwp_sections sections
{};
872 /* Table of CUs in the file. */
873 const struct dwp_hash_table
*cus
= nullptr;
875 /* Table of TUs in the file. */
876 const struct dwp_hash_table
*tus
= nullptr;
878 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
879 htab_t loaded_cus
{};
880 htab_t loaded_tus
{};
882 /* Table to map ELF section numbers to their sections.
883 This is only needed for the DWP V1 file format. */
884 unsigned int num_sections
= 0;
885 asection
**elf_sections
= nullptr;
888 /* Struct used to pass misc. parameters to read_die_and_children, et
889 al. which are used for both .debug_info and .debug_types dies.
890 All parameters here are unchanging for the life of the call. This
891 struct exists to abstract away the constant parameters of die reading. */
893 struct die_reader_specs
895 /* The bfd of die_section. */
898 /* The CU of the DIE we are parsing. */
899 struct dwarf2_cu
*cu
;
901 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
902 struct dwo_file
*dwo_file
;
904 /* The section the die comes from.
905 This is either .debug_info or .debug_types, or the .dwo variants. */
906 struct dwarf2_section_info
*die_section
;
908 /* die_section->buffer. */
909 const gdb_byte
*buffer
;
911 /* The end of the buffer. */
912 const gdb_byte
*buffer_end
;
914 /* The value of the DW_AT_comp_dir attribute. */
915 const char *comp_dir
;
917 /* The abbreviation table to use when reading the DIEs. */
918 struct abbrev_table
*abbrev_table
;
921 /* Type of function passed to init_cutu_and_read_dies, et.al. */
922 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
923 const gdb_byte
*info_ptr
,
924 struct die_info
*comp_unit_die
,
928 /* A 1-based directory index. This is a strong typedef to prevent
929 accidentally using a directory index as a 0-based index into an
931 enum class dir_index
: unsigned int {};
933 /* Likewise, a 1-based file name index. */
934 enum class file_name_index
: unsigned int {};
938 file_entry () = default;
940 file_entry (const char *name_
, dir_index d_index_
,
941 unsigned int mod_time_
, unsigned int length_
)
944 mod_time (mod_time_
),
948 /* Return the include directory at D_INDEX stored in LH. Returns
949 NULL if D_INDEX is out of bounds. */
950 const char *include_dir (const line_header
*lh
) const;
952 /* The file name. Note this is an observing pointer. The memory is
953 owned by debug_line_buffer. */
956 /* The directory index (1-based). */
957 dir_index d_index
{};
959 unsigned int mod_time
{};
961 unsigned int length
{};
963 /* True if referenced by the Line Number Program. */
966 /* The associated symbol table, if any. */
967 struct symtab
*symtab
{};
970 /* The line number information for a compilation unit (found in the
971 .debug_line section) begins with a "statement program header",
972 which contains the following information. */
979 /* Add an entry to the include directory table. */
980 void add_include_dir (const char *include_dir
);
982 /* Add an entry to the file name table. */
983 void add_file_name (const char *name
, dir_index d_index
,
984 unsigned int mod_time
, unsigned int length
);
986 /* Return the include dir at INDEX (1-based). Returns NULL if INDEX
988 const char *include_dir_at (dir_index index
) const
990 /* Convert directory index number (1-based) to vector index
992 size_t vec_index
= to_underlying (index
) - 1;
994 if (vec_index
>= include_dirs
.size ())
996 return include_dirs
[vec_index
];
999 /* Return the file name at INDEX (1-based). Returns NULL if INDEX
1000 is out of bounds. */
1001 file_entry
*file_name_at (file_name_index index
)
1003 /* Convert file name index number (1-based) to vector index
1005 size_t vec_index
= to_underlying (index
) - 1;
1007 if (vec_index
>= file_names
.size ())
1009 return &file_names
[vec_index
];
1012 /* Offset of line number information in .debug_line section. */
1013 sect_offset sect_off
{};
1015 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1016 unsigned offset_in_dwz
: 1; /* Can't initialize bitfields in-class. */
1018 unsigned int total_length
{};
1019 unsigned short version
{};
1020 unsigned int header_length
{};
1021 unsigned char minimum_instruction_length
{};
1022 unsigned char maximum_ops_per_instruction
{};
1023 unsigned char default_is_stmt
{};
1025 unsigned char line_range
{};
1026 unsigned char opcode_base
{};
1028 /* standard_opcode_lengths[i] is the number of operands for the
1029 standard opcode whose value is i. This means that
1030 standard_opcode_lengths[0] is unused, and the last meaningful
1031 element is standard_opcode_lengths[opcode_base - 1]. */
1032 std::unique_ptr
<unsigned char[]> standard_opcode_lengths
;
1034 /* The include_directories table. Note these are observing
1035 pointers. The memory is owned by debug_line_buffer. */
1036 std::vector
<const char *> include_dirs
;
1038 /* The file_names table. */
1039 std::vector
<file_entry
> file_names
;
1041 /* The start and end of the statement program following this
1042 header. These point into dwarf2_per_objfile->line_buffer. */
1043 const gdb_byte
*statement_program_start
{}, *statement_program_end
{};
1046 typedef std::unique_ptr
<line_header
> line_header_up
;
1049 file_entry::include_dir (const line_header
*lh
) const
1051 return lh
->include_dir_at (d_index
);
1054 /* When we construct a partial symbol table entry we only
1055 need this much information. */
1056 struct partial_die_info
: public allocate_on_obstack
1058 partial_die_info (sect_offset sect_off
, struct abbrev_info
*abbrev
);
1060 /* Disable assign but still keep copy ctor, which is needed
1061 load_partial_dies. */
1062 partial_die_info
& operator=(const partial_die_info
& rhs
) = delete;
1064 /* Adjust the partial die before generating a symbol for it. This
1065 function may set the is_external flag or change the DIE's
1067 void fixup (struct dwarf2_cu
*cu
);
1069 /* Read a minimal amount of information into the minimal die
1071 const gdb_byte
*read (const struct die_reader_specs
*reader
,
1072 const struct abbrev_info
&abbrev
,
1073 const gdb_byte
*info_ptr
);
1075 /* Offset of this DIE. */
1076 const sect_offset sect_off
;
1078 /* DWARF-2 tag for this DIE. */
1079 const ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1081 /* Assorted flags describing the data found in this DIE. */
1082 const unsigned int has_children
: 1;
1084 unsigned int is_external
: 1;
1085 unsigned int is_declaration
: 1;
1086 unsigned int has_type
: 1;
1087 unsigned int has_specification
: 1;
1088 unsigned int has_pc_info
: 1;
1089 unsigned int may_be_inlined
: 1;
1091 /* This DIE has been marked DW_AT_main_subprogram. */
1092 unsigned int main_subprogram
: 1;
1094 /* Flag set if the SCOPE field of this structure has been
1096 unsigned int scope_set
: 1;
1098 /* Flag set if the DIE has a byte_size attribute. */
1099 unsigned int has_byte_size
: 1;
1101 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1102 unsigned int has_const_value
: 1;
1104 /* Flag set if any of the DIE's children are template arguments. */
1105 unsigned int has_template_arguments
: 1;
1107 /* Flag set if fixup has been called on this die. */
1108 unsigned int fixup_called
: 1;
1110 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1111 unsigned int is_dwz
: 1;
1113 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1114 unsigned int spec_is_dwz
: 1;
1116 /* The name of this DIE. Normally the value of DW_AT_name, but
1117 sometimes a default name for unnamed DIEs. */
1118 const char *name
= nullptr;
1120 /* The linkage name, if present. */
1121 const char *linkage_name
= nullptr;
1123 /* The scope to prepend to our children. This is generally
1124 allocated on the comp_unit_obstack, so will disappear
1125 when this compilation unit leaves the cache. */
1126 const char *scope
= nullptr;
1128 /* Some data associated with the partial DIE. The tag determines
1129 which field is live. */
1132 /* The location description associated with this DIE, if any. */
1133 struct dwarf_block
*locdesc
;
1134 /* The offset of an import, for DW_TAG_imported_unit. */
1135 sect_offset sect_off
;
1138 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1139 CORE_ADDR lowpc
= 0;
1140 CORE_ADDR highpc
= 0;
1142 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1143 DW_AT_sibling, if any. */
1144 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1145 could return DW_AT_sibling values to its caller load_partial_dies. */
1146 const gdb_byte
*sibling
= nullptr;
1148 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1149 DW_AT_specification (or DW_AT_abstract_origin or
1150 DW_AT_extension). */
1151 sect_offset spec_offset
{};
1153 /* Pointers to this DIE's parent, first child, and next sibling,
1155 struct partial_die_info
*die_parent
= nullptr;
1156 struct partial_die_info
*die_child
= nullptr;
1157 struct partial_die_info
*die_sibling
= nullptr;
1159 friend struct partial_die_info
*
1160 dwarf2_cu::find_partial_die (sect_offset sect_off
);
1163 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1164 partial_die_info (sect_offset sect_off
)
1165 : partial_die_info (sect_off
, DW_TAG_padding
, 0)
1169 partial_die_info (sect_offset sect_off_
, enum dwarf_tag tag_
,
1171 : sect_off (sect_off_
), tag (tag_
), has_children (has_children_
)
1176 has_specification
= 0;
1179 main_subprogram
= 0;
1182 has_const_value
= 0;
1183 has_template_arguments
= 0;
1190 /* This data structure holds the information of an abbrev. */
1193 unsigned int number
; /* number identifying abbrev */
1194 enum dwarf_tag tag
; /* dwarf tag */
1195 unsigned short has_children
; /* boolean */
1196 unsigned short num_attrs
; /* number of attributes */
1197 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1198 struct abbrev_info
*next
; /* next in chain */
1203 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1204 ENUM_BITFIELD(dwarf_form
) form
: 16;
1206 /* It is valid only if FORM is DW_FORM_implicit_const. */
1207 LONGEST implicit_const
;
1210 /* Size of abbrev_table.abbrev_hash_table. */
1211 #define ABBREV_HASH_SIZE 121
1213 /* Top level data structure to contain an abbreviation table. */
1217 explicit abbrev_table (sect_offset off
)
1221 XOBNEWVEC (&abbrev_obstack
, struct abbrev_info
*, ABBREV_HASH_SIZE
);
1222 memset (m_abbrevs
, 0, ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
1225 DISABLE_COPY_AND_ASSIGN (abbrev_table
);
1227 /* Allocate space for a struct abbrev_info object in
1229 struct abbrev_info
*alloc_abbrev ();
1231 /* Add an abbreviation to the table. */
1232 void add_abbrev (unsigned int abbrev_number
, struct abbrev_info
*abbrev
);
1234 /* Look up an abbrev in the table.
1235 Returns NULL if the abbrev is not found. */
1237 struct abbrev_info
*lookup_abbrev (unsigned int abbrev_number
);
1240 /* Where the abbrev table came from.
1241 This is used as a sanity check when the table is used. */
1242 const sect_offset sect_off
;
1244 /* Storage for the abbrev table. */
1245 auto_obstack abbrev_obstack
;
1249 /* Hash table of abbrevs.
1250 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1251 It could be statically allocated, but the previous code didn't so we
1253 struct abbrev_info
**m_abbrevs
;
1256 typedef std::unique_ptr
<struct abbrev_table
> abbrev_table_up
;
1258 /* Attributes have a name and a value. */
1261 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1262 ENUM_BITFIELD(dwarf_form
) form
: 15;
1264 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1265 field should be in u.str (existing only for DW_STRING) but it is kept
1266 here for better struct attribute alignment. */
1267 unsigned int string_is_canonical
: 1;
1272 struct dwarf_block
*blk
;
1281 /* This data structure holds a complete die structure. */
1284 /* DWARF-2 tag for this DIE. */
1285 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1287 /* Number of attributes */
1288 unsigned char num_attrs
;
1290 /* True if we're presently building the full type name for the
1291 type derived from this DIE. */
1292 unsigned char building_fullname
: 1;
1294 /* True if this die is in process. PR 16581. */
1295 unsigned char in_process
: 1;
1298 unsigned int abbrev
;
1300 /* Offset in .debug_info or .debug_types section. */
1301 sect_offset sect_off
;
1303 /* The dies in a compilation unit form an n-ary tree. PARENT
1304 points to this die's parent; CHILD points to the first child of
1305 this node; and all the children of a given node are chained
1306 together via their SIBLING fields. */
1307 struct die_info
*child
; /* Its first child, if any. */
1308 struct die_info
*sibling
; /* Its next sibling, if any. */
1309 struct die_info
*parent
; /* Its parent, if any. */
1311 /* An array of attributes, with NUM_ATTRS elements. There may be
1312 zero, but it's not common and zero-sized arrays are not
1313 sufficiently portable C. */
1314 struct attribute attrs
[1];
1317 /* Get at parts of an attribute structure. */
1319 #define DW_STRING(attr) ((attr)->u.str)
1320 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1321 #define DW_UNSND(attr) ((attr)->u.unsnd)
1322 #define DW_BLOCK(attr) ((attr)->u.blk)
1323 #define DW_SND(attr) ((attr)->u.snd)
1324 #define DW_ADDR(attr) ((attr)->u.addr)
1325 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1327 /* Blocks are a bunch of untyped bytes. */
1332 /* Valid only if SIZE is not zero. */
1333 const gdb_byte
*data
;
1336 #ifndef ATTR_ALLOC_CHUNK
1337 #define ATTR_ALLOC_CHUNK 4
1340 /* Allocate fields for structs, unions and enums in this size. */
1341 #ifndef DW_FIELD_ALLOC_CHUNK
1342 #define DW_FIELD_ALLOC_CHUNK 4
1345 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1346 but this would require a corresponding change in unpack_field_as_long
1348 static int bits_per_byte
= 8;
1350 /* When reading a variant or variant part, we track a bit more
1351 information about the field, and store it in an object of this
1354 struct variant_field
1356 /* If we see a DW_TAG_variant, then this will be the discriminant
1358 ULONGEST discriminant_value
;
1359 /* If we see a DW_TAG_variant, then this will be set if this is the
1361 bool default_branch
;
1362 /* While reading a DW_TAG_variant_part, this will be set if this
1363 field is the discriminant. */
1364 bool is_discriminant
;
1369 int accessibility
= 0;
1371 /* Extra information to describe a variant or variant part. */
1372 struct variant_field variant
{};
1373 struct field field
{};
1378 const char *name
= nullptr;
1379 std::vector
<struct fn_field
> fnfields
;
1382 /* The routines that read and process dies for a C struct or C++ class
1383 pass lists of data member fields and lists of member function fields
1384 in an instance of a field_info structure, as defined below. */
1387 /* List of data member and baseclasses fields. */
1388 std::vector
<struct nextfield
> fields
;
1389 std::vector
<struct nextfield
> baseclasses
;
1391 /* Number of fields (including baseclasses). */
1394 /* Set if the accesibility of one of the fields is not public. */
1395 int non_public_fields
= 0;
1397 /* Member function fieldlist array, contains name of possibly overloaded
1398 member function, number of overloaded member functions and a pointer
1399 to the head of the member function field chain. */
1400 std::vector
<struct fnfieldlist
> fnfieldlists
;
1402 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1403 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1404 std::vector
<struct decl_field
> typedef_field_list
;
1406 /* Nested types defined by this class and the number of elements in this
1408 std::vector
<struct decl_field
> nested_types_list
;
1411 /* One item on the queue of compilation units to read in full symbols
1413 struct dwarf2_queue_item
1415 struct dwarf2_per_cu_data
*per_cu
;
1416 enum language pretend_language
;
1417 struct dwarf2_queue_item
*next
;
1420 /* The current queue. */
1421 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1423 /* Loaded secondary compilation units are kept in memory until they
1424 have not been referenced for the processing of this many
1425 compilation units. Set this to zero to disable caching. Cache
1426 sizes of up to at least twenty will improve startup time for
1427 typical inter-CU-reference binaries, at an obvious memory cost. */
1428 static int dwarf_max_cache_age
= 5;
1430 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1431 struct cmd_list_element
*c
, const char *value
)
1433 fprintf_filtered (file
, _("The upper bound on the age of cached "
1434 "DWARF compilation units is %s.\n"),
1438 /* local function prototypes */
1440 static const char *get_section_name (const struct dwarf2_section_info
*);
1442 static const char *get_section_file_name (const struct dwarf2_section_info
*);
1444 static void dwarf2_find_base_address (struct die_info
*die
,
1445 struct dwarf2_cu
*cu
);
1447 static struct partial_symtab
*create_partial_symtab
1448 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1450 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1451 const gdb_byte
*info_ptr
,
1452 struct die_info
*type_unit_die
,
1453 int has_children
, void *data
);
1455 static void dwarf2_build_psymtabs_hard
1456 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1458 static void scan_partial_symbols (struct partial_die_info
*,
1459 CORE_ADDR
*, CORE_ADDR
*,
1460 int, struct dwarf2_cu
*);
1462 static void add_partial_symbol (struct partial_die_info
*,
1463 struct dwarf2_cu
*);
1465 static void add_partial_namespace (struct partial_die_info
*pdi
,
1466 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1467 int set_addrmap
, struct dwarf2_cu
*cu
);
1469 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1470 CORE_ADDR
*highpc
, int set_addrmap
,
1471 struct dwarf2_cu
*cu
);
1473 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1474 struct dwarf2_cu
*cu
);
1476 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1477 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1478 int need_pc
, struct dwarf2_cu
*cu
);
1480 static void dwarf2_read_symtab (struct partial_symtab
*,
1483 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1485 static abbrev_table_up abbrev_table_read_table
1486 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, struct dwarf2_section_info
*,
1489 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1491 static struct partial_die_info
*load_partial_dies
1492 (const struct die_reader_specs
*, const gdb_byte
*, int);
1494 /* A pair of partial_die_info and compilation unit. */
1495 struct cu_partial_die_info
1497 /* The compilation unit of the partial_die_info. */
1498 struct dwarf2_cu
*cu
;
1499 /* A partial_die_info. */
1500 struct partial_die_info
*pdi
;
1502 cu_partial_die_info (struct dwarf2_cu
*cu
, struct partial_die_info
*pdi
)
1508 cu_partial_die_info () = delete;
1511 static const struct cu_partial_die_info
find_partial_die (sect_offset
, int,
1512 struct dwarf2_cu
*);
1514 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1515 struct attribute
*, struct attr_abbrev
*,
1518 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1520 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1522 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1524 /* Read the next three bytes (little-endian order) as an unsigned integer. */
1525 static unsigned int read_3_bytes (bfd
*, const gdb_byte
*);
1527 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1529 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1531 static CORE_ADDR
read_address (bfd
*, const gdb_byte
*ptr
, struct dwarf2_cu
*,
1534 static LONGEST
read_initial_length (bfd
*, const gdb_byte
*, unsigned int *);
1536 static LONGEST read_checked_initial_length_and_offset
1537 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1538 unsigned int *, unsigned int *);
1540 static LONGEST
read_offset (bfd
*, const gdb_byte
*,
1541 const struct comp_unit_head
*,
1544 static LONGEST
read_offset_1 (bfd
*, const gdb_byte
*, unsigned int);
1546 static sect_offset read_abbrev_offset
1547 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1548 struct dwarf2_section_info
*, sect_offset
);
1550 static const gdb_byte
*read_n_bytes (bfd
*, const gdb_byte
*, unsigned int);
1552 static const char *read_direct_string (bfd
*, const gdb_byte
*, unsigned int *);
1554 static const char *read_indirect_string
1555 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*, const gdb_byte
*,
1556 const struct comp_unit_head
*, unsigned int *);
1558 static const char *read_indirect_line_string
1559 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*, const gdb_byte
*,
1560 const struct comp_unit_head
*, unsigned int *);
1562 static const char *read_indirect_string_at_offset
1563 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
1564 LONGEST str_offset
);
1566 static const char *read_indirect_string_from_dwz
1567 (struct objfile
*objfile
, struct dwz_file
*, LONGEST
);
1569 static LONGEST
read_signed_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1571 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1575 static const char *read_str_index (const struct die_reader_specs
*reader
,
1576 ULONGEST str_index
);
1578 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1580 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1581 struct dwarf2_cu
*);
1583 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1586 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1587 struct dwarf2_cu
*cu
);
1589 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1590 struct dwarf2_cu
*cu
);
1592 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1594 static struct die_info
*die_specification (struct die_info
*die
,
1595 struct dwarf2_cu
**);
1597 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1598 struct dwarf2_cu
*cu
);
1600 static void dwarf_decode_lines (struct line_header
*, const char *,
1601 struct dwarf2_cu
*, struct partial_symtab
*,
1602 CORE_ADDR
, int decode_mapping
);
1604 static void dwarf2_start_subfile (struct dwarf2_cu
*, const char *,
1607 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1608 struct dwarf2_cu
*, struct symbol
* = NULL
);
1610 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1611 struct dwarf2_cu
*);
1613 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1616 struct obstack
*obstack
,
1617 struct dwarf2_cu
*cu
, LONGEST
*value
,
1618 const gdb_byte
**bytes
,
1619 struct dwarf2_locexpr_baton
**baton
);
1621 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1623 static int need_gnat_info (struct dwarf2_cu
*);
1625 static struct type
*die_descriptive_type (struct die_info
*,
1626 struct dwarf2_cu
*);
1628 static void set_descriptive_type (struct type
*, struct die_info
*,
1629 struct dwarf2_cu
*);
1631 static struct type
*die_containing_type (struct die_info
*,
1632 struct dwarf2_cu
*);
1634 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1635 struct dwarf2_cu
*);
1637 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1639 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1641 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1643 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1644 const char *suffix
, int physname
,
1645 struct dwarf2_cu
*cu
);
1647 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1649 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1651 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1653 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1655 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1657 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1659 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1660 struct dwarf2_cu
*, struct partial_symtab
*);
1662 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1663 values. Keep the items ordered with increasing constraints compliance. */
1666 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1667 PC_BOUNDS_NOT_PRESENT
,
1669 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1670 were present but they do not form a valid range of PC addresses. */
1673 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1676 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1680 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1681 CORE_ADDR
*, CORE_ADDR
*,
1683 struct partial_symtab
*);
1685 static void get_scope_pc_bounds (struct die_info
*,
1686 CORE_ADDR
*, CORE_ADDR
*,
1687 struct dwarf2_cu
*);
1689 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1690 CORE_ADDR
, struct dwarf2_cu
*);
1692 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1693 struct dwarf2_cu
*);
1695 static void dwarf2_attach_fields_to_type (struct field_info
*,
1696 struct type
*, struct dwarf2_cu
*);
1698 static void dwarf2_add_member_fn (struct field_info
*,
1699 struct die_info
*, struct type
*,
1700 struct dwarf2_cu
*);
1702 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1704 struct dwarf2_cu
*);
1706 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1708 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1710 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1712 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1714 static struct using_direct
**using_directives (struct dwarf2_cu
*cu
);
1716 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1718 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1720 static struct type
*read_module_type (struct die_info
*die
,
1721 struct dwarf2_cu
*cu
);
1723 static const char *namespace_name (struct die_info
*die
,
1724 int *is_anonymous
, struct dwarf2_cu
*);
1726 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1728 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1730 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1731 struct dwarf2_cu
*);
1733 static struct die_info
*read_die_and_siblings_1
1734 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1737 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1738 const gdb_byte
*info_ptr
,
1739 const gdb_byte
**new_info_ptr
,
1740 struct die_info
*parent
);
1742 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1743 struct die_info
**, const gdb_byte
*,
1746 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1747 struct die_info
**, const gdb_byte
*,
1750 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1752 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1755 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1757 static const char *dwarf2_full_name (const char *name
,
1758 struct die_info
*die
,
1759 struct dwarf2_cu
*cu
);
1761 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1762 struct dwarf2_cu
*cu
);
1764 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1765 struct dwarf2_cu
**);
1767 static const char *dwarf_tag_name (unsigned int);
1769 static const char *dwarf_attr_name (unsigned int);
1771 static const char *dwarf_form_name (unsigned int);
1773 static const char *dwarf_bool_name (unsigned int);
1775 static const char *dwarf_type_encoding_name (unsigned int);
1777 static struct die_info
*sibling_die (struct die_info
*);
1779 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1781 static void dump_die_for_error (struct die_info
*);
1783 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1786 /*static*/ void dump_die (struct die_info
*, int max_level
);
1788 static void store_in_ref_table (struct die_info
*,
1789 struct dwarf2_cu
*);
1791 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
1793 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
1795 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1796 const struct attribute
*,
1797 struct dwarf2_cu
**);
1799 static struct die_info
*follow_die_ref (struct die_info
*,
1800 const struct attribute
*,
1801 struct dwarf2_cu
**);
1803 static struct die_info
*follow_die_sig (struct die_info
*,
1804 const struct attribute
*,
1805 struct dwarf2_cu
**);
1807 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1808 struct dwarf2_cu
*);
1810 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1811 const struct attribute
*,
1812 struct dwarf2_cu
*);
1814 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1816 static void read_signatured_type (struct signatured_type
*);
1818 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1819 struct die_info
*die
, struct dwarf2_cu
*cu
,
1820 struct dynamic_prop
*prop
);
1822 /* memory allocation interface */
1824 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1826 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1828 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1830 static int attr_form_is_block (const struct attribute
*);
1832 static int attr_form_is_section_offset (const struct attribute
*);
1834 static int attr_form_is_constant (const struct attribute
*);
1836 static int attr_form_is_ref (const struct attribute
*);
1838 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1839 struct dwarf2_loclist_baton
*baton
,
1840 const struct attribute
*attr
);
1842 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1844 struct dwarf2_cu
*cu
,
1847 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1848 const gdb_byte
*info_ptr
,
1849 struct abbrev_info
*abbrev
);
1851 static hashval_t
partial_die_hash (const void *item
);
1853 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1855 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1856 (sect_offset sect_off
, unsigned int offset_in_dwz
,
1857 struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1859 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1860 struct die_info
*comp_unit_die
,
1861 enum language pretend_language
);
1863 static void age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1865 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1867 static struct type
*set_die_type (struct die_info
*, struct type
*,
1868 struct dwarf2_cu
*);
1870 static void create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1872 static int create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1874 static void load_full_comp_unit (struct dwarf2_per_cu_data
*, bool,
1877 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1880 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1883 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1884 struct dwarf2_per_cu_data
*);
1886 static void dwarf2_mark (struct dwarf2_cu
*);
1888 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1890 static struct type
*get_die_type_at_offset (sect_offset
,
1891 struct dwarf2_per_cu_data
*);
1893 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1895 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1896 enum language pretend_language
);
1898 static void process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1900 /* Class, the destructor of which frees all allocated queue entries. This
1901 will only have work to do if an error was thrown while processing the
1902 dwarf. If no error was thrown then the queue entries should have all
1903 been processed, and freed, as we went along. */
1905 class dwarf2_queue_guard
1908 dwarf2_queue_guard () = default;
1910 /* Free any entries remaining on the queue. There should only be
1911 entries left if we hit an error while processing the dwarf. */
1912 ~dwarf2_queue_guard ()
1914 struct dwarf2_queue_item
*item
, *last
;
1916 item
= dwarf2_queue
;
1919 /* Anything still marked queued is likely to be in an
1920 inconsistent state, so discard it. */
1921 if (item
->per_cu
->queued
)
1923 if (item
->per_cu
->cu
!= NULL
)
1924 free_one_cached_comp_unit (item
->per_cu
);
1925 item
->per_cu
->queued
= 0;
1933 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
1937 /* The return type of find_file_and_directory. Note, the enclosed
1938 string pointers are only valid while this object is valid. */
1940 struct file_and_directory
1942 /* The filename. This is never NULL. */
1945 /* The compilation directory. NULL if not known. If we needed to
1946 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1947 points directly to the DW_AT_comp_dir string attribute owned by
1948 the obstack that owns the DIE. */
1949 const char *comp_dir
;
1951 /* If we needed to build a new string for comp_dir, this is what
1952 owns the storage. */
1953 std::string comp_dir_storage
;
1956 static file_and_directory
find_file_and_directory (struct die_info
*die
,
1957 struct dwarf2_cu
*cu
);
1959 static char *file_full_name (int file
, struct line_header
*lh
,
1960 const char *comp_dir
);
1962 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
1963 enum class rcuh_kind
{ COMPILE
, TYPE
};
1965 static const gdb_byte
*read_and_check_comp_unit_head
1966 (struct dwarf2_per_objfile
* dwarf2_per_objfile
,
1967 struct comp_unit_head
*header
,
1968 struct dwarf2_section_info
*section
,
1969 struct dwarf2_section_info
*abbrev_section
, const gdb_byte
*info_ptr
,
1970 rcuh_kind section_kind
);
1972 static void init_cutu_and_read_dies
1973 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
1974 int use_existing_cu
, int keep
, bool skip_partial
,
1975 die_reader_func_ftype
*die_reader_func
, void *data
);
1977 static void init_cutu_and_read_dies_simple
1978 (struct dwarf2_per_cu_data
*this_cu
,
1979 die_reader_func_ftype
*die_reader_func
, void *data
);
1981 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1983 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1985 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1986 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1987 struct dwp_file
*dwp_file
, const char *comp_dir
,
1988 ULONGEST signature
, int is_debug_types
);
1990 static struct dwp_file
*get_dwp_file
1991 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1993 static struct dwo_unit
*lookup_dwo_comp_unit
1994 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
1996 static struct dwo_unit
*lookup_dwo_type_unit
1997 (struct signatured_type
*, const char *, const char *);
1999 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
2001 /* A unique pointer to a dwo_file. */
2003 typedef std::unique_ptr
<struct dwo_file
> dwo_file_up
;
2005 static void process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2007 static void check_producer (struct dwarf2_cu
*cu
);
2009 static void free_line_header_voidp (void *arg
);
2011 /* Various complaints about symbol reading that don't abort the process. */
2014 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2016 complaint (_("statement list doesn't fit in .debug_line section"));
2020 dwarf2_debug_line_missing_file_complaint (void)
2022 complaint (_(".debug_line section has line data without a file"));
2026 dwarf2_debug_line_missing_end_sequence_complaint (void)
2028 complaint (_(".debug_line section has line "
2029 "program sequence without an end"));
2033 dwarf2_complex_location_expr_complaint (void)
2035 complaint (_("location expression too complex"));
2039 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
2042 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
2047 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
2049 complaint (_("debug info runs off end of %s section"
2051 get_section_name (section
),
2052 get_section_file_name (section
));
2056 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
2058 complaint (_("macro debug info contains a "
2059 "malformed macro definition:\n`%s'"),
2064 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
2066 complaint (_("invalid attribute class or form for '%s' in '%s'"),
2070 /* Hash function for line_header_hash. */
2073 line_header_hash (const struct line_header
*ofs
)
2075 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
2078 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2081 line_header_hash_voidp (const void *item
)
2083 const struct line_header
*ofs
= (const struct line_header
*) item
;
2085 return line_header_hash (ofs
);
2088 /* Equality function for line_header_hash. */
2091 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
2093 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
2094 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
2096 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
2097 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
2102 /* Read the given attribute value as an address, taking the attribute's
2103 form into account. */
2106 attr_value_as_address (struct attribute
*attr
)
2110 if (attr
->form
!= DW_FORM_addr
&& attr
->form
!= DW_FORM_addrx
2111 && attr
->form
!= DW_FORM_GNU_addr_index
)
2113 /* Aside from a few clearly defined exceptions, attributes that
2114 contain an address must always be in DW_FORM_addr form.
2115 Unfortunately, some compilers happen to be violating this
2116 requirement by encoding addresses using other forms, such
2117 as DW_FORM_data4 for example. For those broken compilers,
2118 we try to do our best, without any guarantee of success,
2119 to interpret the address correctly. It would also be nice
2120 to generate a complaint, but that would require us to maintain
2121 a list of legitimate cases where a non-address form is allowed,
2122 as well as update callers to pass in at least the CU's DWARF
2123 version. This is more overhead than what we're willing to
2124 expand for a pretty rare case. */
2125 addr
= DW_UNSND (attr
);
2128 addr
= DW_ADDR (attr
);
2133 /* See declaration. */
2135 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile
*objfile_
,
2136 const dwarf2_debug_sections
*names
)
2137 : objfile (objfile_
)
2140 names
= &dwarf2_elf_names
;
2142 bfd
*obfd
= objfile
->obfd
;
2144 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2145 locate_sections (obfd
, sec
, *names
);
2148 dwarf2_per_objfile::~dwarf2_per_objfile ()
2150 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
2151 free_cached_comp_units ();
2153 if (quick_file_names_table
)
2154 htab_delete (quick_file_names_table
);
2156 if (line_header_hash
)
2157 htab_delete (line_header_hash
);
2159 for (dwarf2_per_cu_data
*per_cu
: all_comp_units
)
2160 VEC_free (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
);
2162 for (signatured_type
*sig_type
: all_type_units
)
2163 VEC_free (dwarf2_per_cu_ptr
, sig_type
->per_cu
.imported_symtabs
);
2165 VEC_free (dwarf2_section_info_def
, types
);
2167 /* Everything else should be on the objfile obstack. */
2170 /* See declaration. */
2173 dwarf2_per_objfile::free_cached_comp_units ()
2175 dwarf2_per_cu_data
*per_cu
= read_in_chain
;
2176 dwarf2_per_cu_data
**last_chain
= &read_in_chain
;
2177 while (per_cu
!= NULL
)
2179 dwarf2_per_cu_data
*next_cu
= per_cu
->cu
->read_in_chain
;
2182 *last_chain
= next_cu
;
2187 /* A helper class that calls free_cached_comp_units on
2190 class free_cached_comp_units
2194 explicit free_cached_comp_units (dwarf2_per_objfile
*per_objfile
)
2195 : m_per_objfile (per_objfile
)
2199 ~free_cached_comp_units ()
2201 m_per_objfile
->free_cached_comp_units ();
2204 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units
);
2208 dwarf2_per_objfile
*m_per_objfile
;
2211 /* Try to locate the sections we need for DWARF 2 debugging
2212 information and return true if we have enough to do something.
2213 NAMES points to the dwarf2 section names, or is NULL if the standard
2214 ELF names are used. */
2217 dwarf2_has_info (struct objfile
*objfile
,
2218 const struct dwarf2_debug_sections
*names
)
2220 if (objfile
->flags
& OBJF_READNEVER
)
2223 struct dwarf2_per_objfile
*dwarf2_per_objfile
2224 = get_dwarf2_per_objfile (objfile
);
2226 if (dwarf2_per_objfile
== NULL
)
2227 dwarf2_per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
,
2230 return (!dwarf2_per_objfile
->info
.is_virtual
2231 && dwarf2_per_objfile
->info
.s
.section
!= NULL
2232 && !dwarf2_per_objfile
->abbrev
.is_virtual
2233 && dwarf2_per_objfile
->abbrev
.s
.section
!= NULL
);
2236 /* Return the containing section of virtual section SECTION. */
2238 static struct dwarf2_section_info
*
2239 get_containing_section (const struct dwarf2_section_info
*section
)
2241 gdb_assert (section
->is_virtual
);
2242 return section
->s
.containing_section
;
2245 /* Return the bfd owner of SECTION. */
2248 get_section_bfd_owner (const struct dwarf2_section_info
*section
)
2250 if (section
->is_virtual
)
2252 section
= get_containing_section (section
);
2253 gdb_assert (!section
->is_virtual
);
2255 return section
->s
.section
->owner
;
2258 /* Return the bfd section of SECTION.
2259 Returns NULL if the section is not present. */
2262 get_section_bfd_section (const struct dwarf2_section_info
*section
)
2264 if (section
->is_virtual
)
2266 section
= get_containing_section (section
);
2267 gdb_assert (!section
->is_virtual
);
2269 return section
->s
.section
;
2272 /* Return the name of SECTION. */
2275 get_section_name (const struct dwarf2_section_info
*section
)
2277 asection
*sectp
= get_section_bfd_section (section
);
2279 gdb_assert (sectp
!= NULL
);
2280 return bfd_section_name (get_section_bfd_owner (section
), sectp
);
2283 /* Return the name of the file SECTION is in. */
2286 get_section_file_name (const struct dwarf2_section_info
*section
)
2288 bfd
*abfd
= get_section_bfd_owner (section
);
2290 return bfd_get_filename (abfd
);
2293 /* Return the id of SECTION.
2294 Returns 0 if SECTION doesn't exist. */
2297 get_section_id (const struct dwarf2_section_info
*section
)
2299 asection
*sectp
= get_section_bfd_section (section
);
2306 /* Return the flags of SECTION.
2307 SECTION (or containing section if this is a virtual section) must exist. */
2310 get_section_flags (const struct dwarf2_section_info
*section
)
2312 asection
*sectp
= get_section_bfd_section (section
);
2314 gdb_assert (sectp
!= NULL
);
2315 return bfd_get_section_flags (sectp
->owner
, sectp
);
2318 /* When loading sections, we look either for uncompressed section or for
2319 compressed section names. */
2322 section_is_p (const char *section_name
,
2323 const struct dwarf2_section_names
*names
)
2325 if (names
->normal
!= NULL
2326 && strcmp (section_name
, names
->normal
) == 0)
2328 if (names
->compressed
!= NULL
2329 && strcmp (section_name
, names
->compressed
) == 0)
2334 /* See declaration. */
2337 dwarf2_per_objfile::locate_sections (bfd
*abfd
, asection
*sectp
,
2338 const dwarf2_debug_sections
&names
)
2340 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
2342 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2345 else if (section_is_p (sectp
->name
, &names
.info
))
2347 this->info
.s
.section
= sectp
;
2348 this->info
.size
= bfd_get_section_size (sectp
);
2350 else if (section_is_p (sectp
->name
, &names
.abbrev
))
2352 this->abbrev
.s
.section
= sectp
;
2353 this->abbrev
.size
= bfd_get_section_size (sectp
);
2355 else if (section_is_p (sectp
->name
, &names
.line
))
2357 this->line
.s
.section
= sectp
;
2358 this->line
.size
= bfd_get_section_size (sectp
);
2360 else if (section_is_p (sectp
->name
, &names
.loc
))
2362 this->loc
.s
.section
= sectp
;
2363 this->loc
.size
= bfd_get_section_size (sectp
);
2365 else if (section_is_p (sectp
->name
, &names
.loclists
))
2367 this->loclists
.s
.section
= sectp
;
2368 this->loclists
.size
= bfd_get_section_size (sectp
);
2370 else if (section_is_p (sectp
->name
, &names
.macinfo
))
2372 this->macinfo
.s
.section
= sectp
;
2373 this->macinfo
.size
= bfd_get_section_size (sectp
);
2375 else if (section_is_p (sectp
->name
, &names
.macro
))
2377 this->macro
.s
.section
= sectp
;
2378 this->macro
.size
= bfd_get_section_size (sectp
);
2380 else if (section_is_p (sectp
->name
, &names
.str
))
2382 this->str
.s
.section
= sectp
;
2383 this->str
.size
= bfd_get_section_size (sectp
);
2385 else if (section_is_p (sectp
->name
, &names
.line_str
))
2387 this->line_str
.s
.section
= sectp
;
2388 this->line_str
.size
= bfd_get_section_size (sectp
);
2390 else if (section_is_p (sectp
->name
, &names
.addr
))
2392 this->addr
.s
.section
= sectp
;
2393 this->addr
.size
= bfd_get_section_size (sectp
);
2395 else if (section_is_p (sectp
->name
, &names
.frame
))
2397 this->frame
.s
.section
= sectp
;
2398 this->frame
.size
= bfd_get_section_size (sectp
);
2400 else if (section_is_p (sectp
->name
, &names
.eh_frame
))
2402 this->eh_frame
.s
.section
= sectp
;
2403 this->eh_frame
.size
= bfd_get_section_size (sectp
);
2405 else if (section_is_p (sectp
->name
, &names
.ranges
))
2407 this->ranges
.s
.section
= sectp
;
2408 this->ranges
.size
= bfd_get_section_size (sectp
);
2410 else if (section_is_p (sectp
->name
, &names
.rnglists
))
2412 this->rnglists
.s
.section
= sectp
;
2413 this->rnglists
.size
= bfd_get_section_size (sectp
);
2415 else if (section_is_p (sectp
->name
, &names
.types
))
2417 struct dwarf2_section_info type_section
;
2419 memset (&type_section
, 0, sizeof (type_section
));
2420 type_section
.s
.section
= sectp
;
2421 type_section
.size
= bfd_get_section_size (sectp
);
2423 VEC_safe_push (dwarf2_section_info_def
, this->types
,
2426 else if (section_is_p (sectp
->name
, &names
.gdb_index
))
2428 this->gdb_index
.s
.section
= sectp
;
2429 this->gdb_index
.size
= bfd_get_section_size (sectp
);
2431 else if (section_is_p (sectp
->name
, &names
.debug_names
))
2433 this->debug_names
.s
.section
= sectp
;
2434 this->debug_names
.size
= bfd_get_section_size (sectp
);
2436 else if (section_is_p (sectp
->name
, &names
.debug_aranges
))
2438 this->debug_aranges
.s
.section
= sectp
;
2439 this->debug_aranges
.size
= bfd_get_section_size (sectp
);
2442 if ((bfd_get_section_flags (abfd
, sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2443 && bfd_section_vma (abfd
, sectp
) == 0)
2444 this->has_section_at_zero
= true;
2447 /* A helper function that decides whether a section is empty,
2451 dwarf2_section_empty_p (const struct dwarf2_section_info
*section
)
2453 if (section
->is_virtual
)
2454 return section
->size
== 0;
2455 return section
->s
.section
== NULL
|| section
->size
== 0;
2458 /* See dwarf2read.h. */
2461 dwarf2_read_section (struct objfile
*objfile
, dwarf2_section_info
*info
)
2465 gdb_byte
*buf
, *retbuf
;
2469 info
->buffer
= NULL
;
2470 info
->readin
= true;
2472 if (dwarf2_section_empty_p (info
))
2475 sectp
= get_section_bfd_section (info
);
2477 /* If this is a virtual section we need to read in the real one first. */
2478 if (info
->is_virtual
)
2480 struct dwarf2_section_info
*containing_section
=
2481 get_containing_section (info
);
2483 gdb_assert (sectp
!= NULL
);
2484 if ((sectp
->flags
& SEC_RELOC
) != 0)
2486 error (_("Dwarf Error: DWP format V2 with relocations is not"
2487 " supported in section %s [in module %s]"),
2488 get_section_name (info
), get_section_file_name (info
));
2490 dwarf2_read_section (objfile
, containing_section
);
2491 /* Other code should have already caught virtual sections that don't
2493 gdb_assert (info
->virtual_offset
+ info
->size
2494 <= containing_section
->size
);
2495 /* If the real section is empty or there was a problem reading the
2496 section we shouldn't get here. */
2497 gdb_assert (containing_section
->buffer
!= NULL
);
2498 info
->buffer
= containing_section
->buffer
+ info
->virtual_offset
;
2502 /* If the section has relocations, we must read it ourselves.
2503 Otherwise we attach it to the BFD. */
2504 if ((sectp
->flags
& SEC_RELOC
) == 0)
2506 info
->buffer
= gdb_bfd_map_section (sectp
, &info
->size
);
2510 buf
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
2513 /* When debugging .o files, we may need to apply relocations; see
2514 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2515 We never compress sections in .o files, so we only need to
2516 try this when the section is not compressed. */
2517 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
2520 info
->buffer
= retbuf
;
2524 abfd
= get_section_bfd_owner (info
);
2525 gdb_assert (abfd
!= NULL
);
2527 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
2528 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
2530 error (_("Dwarf Error: Can't read DWARF data"
2531 " in section %s [in module %s]"),
2532 bfd_section_name (abfd
, sectp
), bfd_get_filename (abfd
));
2536 /* A helper function that returns the size of a section in a safe way.
2537 If you are positive that the section has been read before using the
2538 size, then it is safe to refer to the dwarf2_section_info object's
2539 "size" field directly. In other cases, you must call this
2540 function, because for compressed sections the size field is not set
2541 correctly until the section has been read. */
2543 static bfd_size_type
2544 dwarf2_section_size (struct objfile
*objfile
,
2545 struct dwarf2_section_info
*info
)
2548 dwarf2_read_section (objfile
, info
);
2552 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2556 dwarf2_get_section_info (struct objfile
*objfile
,
2557 enum dwarf2_section_enum sect
,
2558 asection
**sectp
, const gdb_byte
**bufp
,
2559 bfd_size_type
*sizep
)
2561 struct dwarf2_per_objfile
*data
= dwarf2_objfile_data_key
.get (objfile
);
2562 struct dwarf2_section_info
*info
;
2564 /* We may see an objfile without any DWARF, in which case we just
2575 case DWARF2_DEBUG_FRAME
:
2576 info
= &data
->frame
;
2578 case DWARF2_EH_FRAME
:
2579 info
= &data
->eh_frame
;
2582 gdb_assert_not_reached ("unexpected section");
2585 dwarf2_read_section (objfile
, info
);
2587 *sectp
= get_section_bfd_section (info
);
2588 *bufp
= info
->buffer
;
2589 *sizep
= info
->size
;
2592 /* A helper function to find the sections for a .dwz file. */
2595 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2597 struct dwz_file
*dwz_file
= (struct dwz_file
*) arg
;
2599 /* Note that we only support the standard ELF names, because .dwz
2600 is ELF-only (at the time of writing). */
2601 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2603 dwz_file
->abbrev
.s
.section
= sectp
;
2604 dwz_file
->abbrev
.size
= bfd_get_section_size (sectp
);
2606 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2608 dwz_file
->info
.s
.section
= sectp
;
2609 dwz_file
->info
.size
= bfd_get_section_size (sectp
);
2611 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2613 dwz_file
->str
.s
.section
= sectp
;
2614 dwz_file
->str
.size
= bfd_get_section_size (sectp
);
2616 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2618 dwz_file
->line
.s
.section
= sectp
;
2619 dwz_file
->line
.size
= bfd_get_section_size (sectp
);
2621 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2623 dwz_file
->macro
.s
.section
= sectp
;
2624 dwz_file
->macro
.size
= bfd_get_section_size (sectp
);
2626 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2628 dwz_file
->gdb_index
.s
.section
= sectp
;
2629 dwz_file
->gdb_index
.size
= bfd_get_section_size (sectp
);
2631 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.debug_names
))
2633 dwz_file
->debug_names
.s
.section
= sectp
;
2634 dwz_file
->debug_names
.size
= bfd_get_section_size (sectp
);
2638 /* See dwarf2read.h. */
2641 dwarf2_get_dwz_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
2643 const char *filename
;
2644 bfd_size_type buildid_len_arg
;
2648 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2649 return dwarf2_per_objfile
->dwz_file
.get ();
2651 bfd_set_error (bfd_error_no_error
);
2652 gdb::unique_xmalloc_ptr
<char> data
2653 (bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2654 &buildid_len_arg
, &buildid
));
2657 if (bfd_get_error () == bfd_error_no_error
)
2659 error (_("could not read '.gnu_debugaltlink' section: %s"),
2660 bfd_errmsg (bfd_get_error ()));
2663 gdb::unique_xmalloc_ptr
<bfd_byte
> buildid_holder (buildid
);
2665 buildid_len
= (size_t) buildid_len_arg
;
2667 filename
= data
.get ();
2669 std::string abs_storage
;
2670 if (!IS_ABSOLUTE_PATH (filename
))
2672 gdb::unique_xmalloc_ptr
<char> abs
2673 = gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2675 abs_storage
= ldirname (abs
.get ()) + SLASH_STRING
+ filename
;
2676 filename
= abs_storage
.c_str ();
2679 /* First try the file name given in the section. If that doesn't
2680 work, try to use the build-id instead. */
2681 gdb_bfd_ref_ptr
dwz_bfd (gdb_bfd_open (filename
, gnutarget
, -1));
2682 if (dwz_bfd
!= NULL
)
2684 if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2685 dwz_bfd
.reset (nullptr);
2688 if (dwz_bfd
== NULL
)
2689 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2691 if (dwz_bfd
== NULL
)
2692 error (_("could not find '.gnu_debugaltlink' file for %s"),
2693 objfile_name (dwarf2_per_objfile
->objfile
));
2695 std::unique_ptr
<struct dwz_file
> result
2696 (new struct dwz_file (std::move (dwz_bfd
)));
2698 bfd_map_over_sections (result
->dwz_bfd
.get (), locate_dwz_sections
,
2701 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
,
2702 result
->dwz_bfd
.get ());
2703 dwarf2_per_objfile
->dwz_file
= std::move (result
);
2704 return dwarf2_per_objfile
->dwz_file
.get ();
2707 /* DWARF quick_symbols_functions support. */
2709 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2710 unique line tables, so we maintain a separate table of all .debug_line
2711 derived entries to support the sharing.
2712 All the quick functions need is the list of file names. We discard the
2713 line_header when we're done and don't need to record it here. */
2714 struct quick_file_names
2716 /* The data used to construct the hash key. */
2717 struct stmt_list_hash hash
;
2719 /* The number of entries in file_names, real_names. */
2720 unsigned int num_file_names
;
2722 /* The file names from the line table, after being run through
2724 const char **file_names
;
2726 /* The file names from the line table after being run through
2727 gdb_realpath. These are computed lazily. */
2728 const char **real_names
;
2731 /* When using the index (and thus not using psymtabs), each CU has an
2732 object of this type. This is used to hold information needed by
2733 the various "quick" methods. */
2734 struct dwarf2_per_cu_quick_data
2736 /* The file table. This can be NULL if there was no file table
2737 or it's currently not read in.
2738 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2739 struct quick_file_names
*file_names
;
2741 /* The corresponding symbol table. This is NULL if symbols for this
2742 CU have not yet been read. */
2743 struct compunit_symtab
*compunit_symtab
;
2745 /* A temporary mark bit used when iterating over all CUs in
2746 expand_symtabs_matching. */
2747 unsigned int mark
: 1;
2749 /* True if we've tried to read the file table and found there isn't one.
2750 There will be no point in trying to read it again next time. */
2751 unsigned int no_file_data
: 1;
2754 /* Utility hash function for a stmt_list_hash. */
2757 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2761 if (stmt_list_hash
->dwo_unit
!= NULL
)
2762 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2763 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2767 /* Utility equality function for a stmt_list_hash. */
2770 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2771 const struct stmt_list_hash
*rhs
)
2773 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2775 if (lhs
->dwo_unit
!= NULL
2776 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2779 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2782 /* Hash function for a quick_file_names. */
2785 hash_file_name_entry (const void *e
)
2787 const struct quick_file_names
*file_data
2788 = (const struct quick_file_names
*) e
;
2790 return hash_stmt_list_entry (&file_data
->hash
);
2793 /* Equality function for a quick_file_names. */
2796 eq_file_name_entry (const void *a
, const void *b
)
2798 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2799 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2801 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2804 /* Delete function for a quick_file_names. */
2807 delete_file_name_entry (void *e
)
2809 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2812 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2814 xfree ((void*) file_data
->file_names
[i
]);
2815 if (file_data
->real_names
)
2816 xfree ((void*) file_data
->real_names
[i
]);
2819 /* The space for the struct itself lives on objfile_obstack,
2820 so we don't free it here. */
2823 /* Create a quick_file_names hash table. */
2826 create_quick_file_names_table (unsigned int nr_initial_entries
)
2828 return htab_create_alloc (nr_initial_entries
,
2829 hash_file_name_entry
, eq_file_name_entry
,
2830 delete_file_name_entry
, xcalloc
, xfree
);
2833 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2834 have to be created afterwards. You should call age_cached_comp_units after
2835 processing PER_CU->CU. dw2_setup must have been already called. */
2838 load_cu (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2840 if (per_cu
->is_debug_types
)
2841 load_full_type_unit (per_cu
);
2843 load_full_comp_unit (per_cu
, skip_partial
, language_minimal
);
2845 if (per_cu
->cu
== NULL
)
2846 return; /* Dummy CU. */
2848 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2851 /* Read in the symbols for PER_CU. */
2854 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2856 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
2858 /* Skip type_unit_groups, reading the type units they contain
2859 is handled elsewhere. */
2860 if (IS_TYPE_UNIT_GROUP (per_cu
))
2863 /* The destructor of dwarf2_queue_guard frees any entries left on
2864 the queue. After this point we're guaranteed to leave this function
2865 with the dwarf queue empty. */
2866 dwarf2_queue_guard q_guard
;
2868 if (dwarf2_per_objfile
->using_index
2869 ? per_cu
->v
.quick
->compunit_symtab
== NULL
2870 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2872 queue_comp_unit (per_cu
, language_minimal
);
2873 load_cu (per_cu
, skip_partial
);
2875 /* If we just loaded a CU from a DWO, and we're working with an index
2876 that may badly handle TUs, load all the TUs in that DWO as well.
2877 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2878 if (!per_cu
->is_debug_types
2879 && per_cu
->cu
!= NULL
2880 && per_cu
->cu
->dwo_unit
!= NULL
2881 && dwarf2_per_objfile
->index_table
!= NULL
2882 && dwarf2_per_objfile
->index_table
->version
<= 7
2883 /* DWP files aren't supported yet. */
2884 && get_dwp_file (dwarf2_per_objfile
) == NULL
)
2885 queue_and_load_all_dwo_tus (per_cu
);
2888 process_queue (dwarf2_per_objfile
);
2890 /* Age the cache, releasing compilation units that have not
2891 been used recently. */
2892 age_cached_comp_units (dwarf2_per_objfile
);
2895 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2896 the objfile from which this CU came. Returns the resulting symbol
2899 static struct compunit_symtab
*
2900 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2902 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
2904 gdb_assert (dwarf2_per_objfile
->using_index
);
2905 if (!per_cu
->v
.quick
->compunit_symtab
)
2907 free_cached_comp_units
freer (dwarf2_per_objfile
);
2908 scoped_restore decrementer
= increment_reading_symtab ();
2909 dw2_do_instantiate_symtab (per_cu
, skip_partial
);
2910 process_cu_includes (dwarf2_per_objfile
);
2913 return per_cu
->v
.quick
->compunit_symtab
;
2916 /* See declaration. */
2918 dwarf2_per_cu_data
*
2919 dwarf2_per_objfile::get_cutu (int index
)
2921 if (index
>= this->all_comp_units
.size ())
2923 index
-= this->all_comp_units
.size ();
2924 gdb_assert (index
< this->all_type_units
.size ());
2925 return &this->all_type_units
[index
]->per_cu
;
2928 return this->all_comp_units
[index
];
2931 /* See declaration. */
2933 dwarf2_per_cu_data
*
2934 dwarf2_per_objfile::get_cu (int index
)
2936 gdb_assert (index
>= 0 && index
< this->all_comp_units
.size ());
2938 return this->all_comp_units
[index
];
2941 /* See declaration. */
2944 dwarf2_per_objfile::get_tu (int index
)
2946 gdb_assert (index
>= 0 && index
< this->all_type_units
.size ());
2948 return this->all_type_units
[index
];
2951 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2952 objfile_obstack, and constructed with the specified field
2955 static dwarf2_per_cu_data
*
2956 create_cu_from_index_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2957 struct dwarf2_section_info
*section
,
2959 sect_offset sect_off
, ULONGEST length
)
2961 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2962 dwarf2_per_cu_data
*the_cu
2963 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2964 struct dwarf2_per_cu_data
);
2965 the_cu
->sect_off
= sect_off
;
2966 the_cu
->length
= length
;
2967 the_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
2968 the_cu
->section
= section
;
2969 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2970 struct dwarf2_per_cu_quick_data
);
2971 the_cu
->is_dwz
= is_dwz
;
2975 /* A helper for create_cus_from_index that handles a given list of
2979 create_cus_from_index_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2980 const gdb_byte
*cu_list
, offset_type n_elements
,
2981 struct dwarf2_section_info
*section
,
2984 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
2986 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2988 sect_offset sect_off
2989 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2990 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2993 dwarf2_per_cu_data
*per_cu
2994 = create_cu_from_index_list (dwarf2_per_objfile
, section
, is_dwz
,
2996 dwarf2_per_objfile
->all_comp_units
.push_back (per_cu
);
3000 /* Read the CU list from the mapped index, and use it to create all
3001 the CU objects for this objfile. */
3004 create_cus_from_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3005 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
3006 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
3008 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
3009 dwarf2_per_objfile
->all_comp_units
.reserve
3010 ((cu_list_elements
+ dwz_elements
) / 2);
3012 create_cus_from_index_list (dwarf2_per_objfile
, cu_list
, cu_list_elements
,
3013 &dwarf2_per_objfile
->info
, 0);
3015 if (dwz_elements
== 0)
3018 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
3019 create_cus_from_index_list (dwarf2_per_objfile
, dwz_list
, dwz_elements
,
3023 /* Create the signatured type hash table from the index. */
3026 create_signatured_type_table_from_index
3027 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3028 struct dwarf2_section_info
*section
,
3029 const gdb_byte
*bytes
,
3030 offset_type elements
)
3032 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3034 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
3035 dwarf2_per_objfile
->all_type_units
.reserve (elements
/ 3);
3037 htab_t sig_types_hash
= allocate_signatured_type_table (objfile
);
3039 for (offset_type i
= 0; i
< elements
; i
+= 3)
3041 struct signatured_type
*sig_type
;
3044 cu_offset type_offset_in_tu
;
3046 gdb_static_assert (sizeof (ULONGEST
) >= 8);
3047 sect_offset sect_off
3048 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
3050 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
3052 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
3055 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3056 struct signatured_type
);
3057 sig_type
->signature
= signature
;
3058 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
3059 sig_type
->per_cu
.is_debug_types
= 1;
3060 sig_type
->per_cu
.section
= section
;
3061 sig_type
->per_cu
.sect_off
= sect_off
;
3062 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
3063 sig_type
->per_cu
.v
.quick
3064 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3065 struct dwarf2_per_cu_quick_data
);
3067 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
3070 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
3073 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
3076 /* Create the signatured type hash table from .debug_names. */
3079 create_signatured_type_table_from_debug_names
3080 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3081 const mapped_debug_names
&map
,
3082 struct dwarf2_section_info
*section
,
3083 struct dwarf2_section_info
*abbrev_section
)
3085 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3087 dwarf2_read_section (objfile
, section
);
3088 dwarf2_read_section (objfile
, abbrev_section
);
3090 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
3091 dwarf2_per_objfile
->all_type_units
.reserve (map
.tu_count
);
3093 htab_t sig_types_hash
= allocate_signatured_type_table (objfile
);
3095 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
3097 struct signatured_type
*sig_type
;
3100 sect_offset sect_off
3101 = (sect_offset
) (extract_unsigned_integer
3102 (map
.tu_table_reordered
+ i
* map
.offset_size
,
3104 map
.dwarf5_byte_order
));
3106 comp_unit_head cu_header
;
3107 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
3109 section
->buffer
+ to_underlying (sect_off
),
3112 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3113 struct signatured_type
);
3114 sig_type
->signature
= cu_header
.signature
;
3115 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
3116 sig_type
->per_cu
.is_debug_types
= 1;
3117 sig_type
->per_cu
.section
= section
;
3118 sig_type
->per_cu
.sect_off
= sect_off
;
3119 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
3120 sig_type
->per_cu
.v
.quick
3121 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3122 struct dwarf2_per_cu_quick_data
);
3124 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
3127 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
3130 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
3133 /* Read the address map data from the mapped index, and use it to
3134 populate the objfile's psymtabs_addrmap. */
3137 create_addrmap_from_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3138 struct mapped_index
*index
)
3140 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3141 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3142 const gdb_byte
*iter
, *end
;
3143 struct addrmap
*mutable_map
;
3146 auto_obstack temp_obstack
;
3148 mutable_map
= addrmap_create_mutable (&temp_obstack
);
3150 iter
= index
->address_table
.data ();
3151 end
= iter
+ index
->address_table
.size ();
3153 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3157 ULONGEST hi
, lo
, cu_index
;
3158 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3160 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3162 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
3167 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
3168 hex_string (lo
), hex_string (hi
));
3172 if (cu_index
>= dwarf2_per_objfile
->all_comp_units
.size ())
3174 complaint (_(".gdb_index address table has invalid CU number %u"),
3175 (unsigned) cu_index
);
3179 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
3180 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
3181 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
3182 dwarf2_per_objfile
->get_cu (cu_index
));
3185 objfile
->partial_symtabs
->psymtabs_addrmap
3186 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
3189 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3190 populate the objfile's psymtabs_addrmap. */
3193 create_addrmap_from_aranges (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3194 struct dwarf2_section_info
*section
)
3196 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3197 bfd
*abfd
= objfile
->obfd
;
3198 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3199 const CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
3200 SECT_OFF_TEXT (objfile
));
3202 auto_obstack temp_obstack
;
3203 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
3205 std::unordered_map
<sect_offset
,
3206 dwarf2_per_cu_data
*,
3207 gdb::hash_enum
<sect_offset
>>
3208 debug_info_offset_to_per_cu
;
3209 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
3211 const auto insertpair
3212 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
, per_cu
);
3213 if (!insertpair
.second
)
3215 warning (_("Section .debug_aranges in %s has duplicate "
3216 "debug_info_offset %s, ignoring .debug_aranges."),
3217 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
3222 dwarf2_read_section (objfile
, section
);
3224 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
3226 const gdb_byte
*addr
= section
->buffer
;
3228 while (addr
< section
->buffer
+ section
->size
)
3230 const gdb_byte
*const entry_addr
= addr
;
3231 unsigned int bytes_read
;
3233 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
3237 const gdb_byte
*const entry_end
= addr
+ entry_length
;
3238 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
3239 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
3240 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
3242 warning (_("Section .debug_aranges in %s entry at offset %zu "
3243 "length %s exceeds section length %s, "
3244 "ignoring .debug_aranges."),
3245 objfile_name (objfile
), entry_addr
- section
->buffer
,
3246 plongest (bytes_read
+ entry_length
),
3247 pulongest (section
->size
));
3251 /* The version number. */
3252 const uint16_t version
= read_2_bytes (abfd
, addr
);
3256 warning (_("Section .debug_aranges in %s entry at offset %zu "
3257 "has unsupported version %d, ignoring .debug_aranges."),
3258 objfile_name (objfile
), entry_addr
- section
->buffer
,
3263 const uint64_t debug_info_offset
3264 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
3265 addr
+= offset_size
;
3266 const auto per_cu_it
3267 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
3268 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
3270 warning (_("Section .debug_aranges in %s entry at offset %zu "
3271 "debug_info_offset %s does not exists, "
3272 "ignoring .debug_aranges."),
3273 objfile_name (objfile
), entry_addr
- section
->buffer
,
3274 pulongest (debug_info_offset
));
3277 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
3279 const uint8_t address_size
= *addr
++;
3280 if (address_size
< 1 || address_size
> 8)
3282 warning (_("Section .debug_aranges in %s entry at offset %zu "
3283 "address_size %u is invalid, ignoring .debug_aranges."),
3284 objfile_name (objfile
), entry_addr
- section
->buffer
,
3289 const uint8_t segment_selector_size
= *addr
++;
3290 if (segment_selector_size
!= 0)
3292 warning (_("Section .debug_aranges in %s entry at offset %zu "
3293 "segment_selector_size %u is not supported, "
3294 "ignoring .debug_aranges."),
3295 objfile_name (objfile
), entry_addr
- section
->buffer
,
3296 segment_selector_size
);
3300 /* Must pad to an alignment boundary that is twice the address
3301 size. It is undocumented by the DWARF standard but GCC does
3303 for (size_t padding
= ((-(addr
- section
->buffer
))
3304 & (2 * address_size
- 1));
3305 padding
> 0; padding
--)
3308 warning (_("Section .debug_aranges in %s entry at offset %zu "
3309 "padding is not zero, ignoring .debug_aranges."),
3310 objfile_name (objfile
), entry_addr
- section
->buffer
);
3316 if (addr
+ 2 * address_size
> entry_end
)
3318 warning (_("Section .debug_aranges in %s entry at offset %zu "
3319 "address list is not properly terminated, "
3320 "ignoring .debug_aranges."),
3321 objfile_name (objfile
), entry_addr
- section
->buffer
);
3324 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
3326 addr
+= address_size
;
3327 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
3329 addr
+= address_size
;
3330 if (start
== 0 && length
== 0)
3332 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3334 /* Symbol was eliminated due to a COMDAT group. */
3337 ULONGEST end
= start
+ length
;
3338 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
3340 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
3342 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
3346 objfile
->partial_symtabs
->psymtabs_addrmap
3347 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
3350 /* Find a slot in the mapped index INDEX for the object named NAME.
3351 If NAME is found, set *VEC_OUT to point to the CU vector in the
3352 constant pool and return true. If NAME cannot be found, return
3356 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
3357 offset_type
**vec_out
)
3360 offset_type slot
, step
;
3361 int (*cmp
) (const char *, const char *);
3363 gdb::unique_xmalloc_ptr
<char> without_params
;
3364 if (current_language
->la_language
== language_cplus
3365 || current_language
->la_language
== language_fortran
3366 || current_language
->la_language
== language_d
)
3368 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3371 if (strchr (name
, '(') != NULL
)
3373 without_params
= cp_remove_params (name
);
3375 if (without_params
!= NULL
)
3376 name
= without_params
.get ();
3380 /* Index version 4 did not support case insensitive searches. But the
3381 indices for case insensitive languages are built in lowercase, therefore
3382 simulate our NAME being searched is also lowercased. */
3383 hash
= mapped_index_string_hash ((index
->version
== 4
3384 && case_sensitivity
== case_sensitive_off
3385 ? 5 : index
->version
),
3388 slot
= hash
& (index
->symbol_table
.size () - 1);
3389 step
= ((hash
* 17) & (index
->symbol_table
.size () - 1)) | 1;
3390 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
3396 const auto &bucket
= index
->symbol_table
[slot
];
3397 if (bucket
.name
== 0 && bucket
.vec
== 0)
3400 str
= index
->constant_pool
+ MAYBE_SWAP (bucket
.name
);
3401 if (!cmp (name
, str
))
3403 *vec_out
= (offset_type
*) (index
->constant_pool
3404 + MAYBE_SWAP (bucket
.vec
));
3408 slot
= (slot
+ step
) & (index
->symbol_table
.size () - 1);
3412 /* A helper function that reads the .gdb_index from BUFFER and fills
3413 in MAP. FILENAME is the name of the file containing the data;
3414 it is used for error reporting. DEPRECATED_OK is true if it is
3415 ok to use deprecated sections.
3417 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3418 out parameters that are filled in with information about the CU and
3419 TU lists in the section.
3421 Returns true if all went well, false otherwise. */
3424 read_gdb_index_from_buffer (struct objfile
*objfile
,
3425 const char *filename
,
3427 gdb::array_view
<const gdb_byte
> buffer
,
3428 struct mapped_index
*map
,
3429 const gdb_byte
**cu_list
,
3430 offset_type
*cu_list_elements
,
3431 const gdb_byte
**types_list
,
3432 offset_type
*types_list_elements
)
3434 const gdb_byte
*addr
= &buffer
[0];
3436 /* Version check. */
3437 offset_type version
= MAYBE_SWAP (*(offset_type
*) addr
);
3438 /* Versions earlier than 3 emitted every copy of a psymbol. This
3439 causes the index to behave very poorly for certain requests. Version 3
3440 contained incomplete addrmap. So, it seems better to just ignore such
3444 static int warning_printed
= 0;
3445 if (!warning_printed
)
3447 warning (_("Skipping obsolete .gdb_index section in %s."),
3449 warning_printed
= 1;
3453 /* Index version 4 uses a different hash function than index version
3456 Versions earlier than 6 did not emit psymbols for inlined
3457 functions. Using these files will cause GDB not to be able to
3458 set breakpoints on inlined functions by name, so we ignore these
3459 indices unless the user has done
3460 "set use-deprecated-index-sections on". */
3461 if (version
< 6 && !deprecated_ok
)
3463 static int warning_printed
= 0;
3464 if (!warning_printed
)
3467 Skipping deprecated .gdb_index section in %s.\n\
3468 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3469 to use the section anyway."),
3471 warning_printed
= 1;
3475 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3476 of the TU (for symbols coming from TUs),
3477 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3478 Plus gold-generated indices can have duplicate entries for global symbols,
3479 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3480 These are just performance bugs, and we can't distinguish gdb-generated
3481 indices from gold-generated ones, so issue no warning here. */
3483 /* Indexes with higher version than the one supported by GDB may be no
3484 longer backward compatible. */
3488 map
->version
= version
;
3490 offset_type
*metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3493 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3494 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3498 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3499 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3500 - MAYBE_SWAP (metadata
[i
]))
3504 const gdb_byte
*address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3505 const gdb_byte
*address_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3507 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
3510 const gdb_byte
*symbol_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3511 const gdb_byte
*symbol_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3513 = gdb::array_view
<mapped_index::symbol_table_slot
>
3514 ((mapped_index::symbol_table_slot
*) symbol_table
,
3515 (mapped_index::symbol_table_slot
*) symbol_table_end
);
3518 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3523 /* Callback types for dwarf2_read_gdb_index. */
3525 typedef gdb::function_view
3526 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_objfile
*)>
3527 get_gdb_index_contents_ftype
;
3528 typedef gdb::function_view
3529 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
3530 get_gdb_index_contents_dwz_ftype
;
3532 /* Read .gdb_index. If everything went ok, initialize the "quick"
3533 elements of all the CUs and return 1. Otherwise, return 0. */
3536 dwarf2_read_gdb_index
3537 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3538 get_gdb_index_contents_ftype get_gdb_index_contents
,
3539 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
3541 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3542 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3543 struct dwz_file
*dwz
;
3544 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3546 gdb::array_view
<const gdb_byte
> main_index_contents
3547 = get_gdb_index_contents (objfile
, dwarf2_per_objfile
);
3549 if (main_index_contents
.empty ())
3552 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
3553 if (!read_gdb_index_from_buffer (objfile
, objfile_name (objfile
),
3554 use_deprecated_index_sections
,
3555 main_index_contents
, map
.get (), &cu_list
,
3556 &cu_list_elements
, &types_list
,
3557 &types_list_elements
))
3560 /* Don't use the index if it's empty. */
3561 if (map
->symbol_table
.empty ())
3564 /* If there is a .dwz file, read it so we can get its CU list as
3566 dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
3569 struct mapped_index dwz_map
;
3570 const gdb_byte
*dwz_types_ignore
;
3571 offset_type dwz_types_elements_ignore
;
3573 gdb::array_view
<const gdb_byte
> dwz_index_content
3574 = get_gdb_index_contents_dwz (objfile
, dwz
);
3576 if (dwz_index_content
.empty ())
3579 if (!read_gdb_index_from_buffer (objfile
,
3580 bfd_get_filename (dwz
->dwz_bfd
), 1,
3581 dwz_index_content
, &dwz_map
,
3582 &dwz_list
, &dwz_list_elements
,
3584 &dwz_types_elements_ignore
))
3586 warning (_("could not read '.gdb_index' section from %s; skipping"),
3587 bfd_get_filename (dwz
->dwz_bfd
));
3592 create_cus_from_index (dwarf2_per_objfile
, cu_list
, cu_list_elements
,
3593 dwz_list
, dwz_list_elements
);
3595 if (types_list_elements
)
3597 struct dwarf2_section_info
*section
;
3599 /* We can only handle a single .debug_types when we have an
3601 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
3604 section
= VEC_index (dwarf2_section_info_def
,
3605 dwarf2_per_objfile
->types
, 0);
3607 create_signatured_type_table_from_index (dwarf2_per_objfile
, section
,
3608 types_list
, types_list_elements
);
3611 create_addrmap_from_index (dwarf2_per_objfile
, map
.get ());
3613 dwarf2_per_objfile
->index_table
= std::move (map
);
3614 dwarf2_per_objfile
->using_index
= 1;
3615 dwarf2_per_objfile
->quick_file_names_table
=
3616 create_quick_file_names_table (dwarf2_per_objfile
->all_comp_units
.size ());
3621 /* die_reader_func for dw2_get_file_names. */
3624 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3625 const gdb_byte
*info_ptr
,
3626 struct die_info
*comp_unit_die
,
3630 struct dwarf2_cu
*cu
= reader
->cu
;
3631 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3632 struct dwarf2_per_objfile
*dwarf2_per_objfile
3633 = cu
->per_cu
->dwarf2_per_objfile
;
3634 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3635 struct dwarf2_per_cu_data
*lh_cu
;
3636 struct attribute
*attr
;
3639 struct quick_file_names
*qfn
;
3641 gdb_assert (! this_cu
->is_debug_types
);
3643 /* Our callers never want to match partial units -- instead they
3644 will match the enclosing full CU. */
3645 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3647 this_cu
->v
.quick
->no_file_data
= 1;
3655 sect_offset line_offset
{};
3657 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3660 struct quick_file_names find_entry
;
3662 line_offset
= (sect_offset
) DW_UNSND (attr
);
3664 /* We may have already read in this line header (TU line header sharing).
3665 If we have we're done. */
3666 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3667 find_entry
.hash
.line_sect_off
= line_offset
;
3668 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
3669 &find_entry
, INSERT
);
3672 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3676 lh
= dwarf_decode_line_header (line_offset
, cu
);
3680 lh_cu
->v
.quick
->no_file_data
= 1;
3684 qfn
= XOBNEW (&objfile
->objfile_obstack
, struct quick_file_names
);
3685 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3686 qfn
->hash
.line_sect_off
= line_offset
;
3687 gdb_assert (slot
!= NULL
);
3690 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3692 qfn
->num_file_names
= lh
->file_names
.size ();
3694 XOBNEWVEC (&objfile
->objfile_obstack
, const char *, lh
->file_names
.size ());
3695 for (i
= 0; i
< lh
->file_names
.size (); ++i
)
3696 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
.get (), fnd
.comp_dir
);
3697 qfn
->real_names
= NULL
;
3699 lh_cu
->v
.quick
->file_names
= qfn
;
3702 /* A helper for the "quick" functions which attempts to read the line
3703 table for THIS_CU. */
3705 static struct quick_file_names
*
3706 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
3708 /* This should never be called for TUs. */
3709 gdb_assert (! this_cu
->is_debug_types
);
3710 /* Nor type unit groups. */
3711 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
3713 if (this_cu
->v
.quick
->file_names
!= NULL
)
3714 return this_cu
->v
.quick
->file_names
;
3715 /* If we know there is no line data, no point in looking again. */
3716 if (this_cu
->v
.quick
->no_file_data
)
3719 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
3721 if (this_cu
->v
.quick
->no_file_data
)
3723 return this_cu
->v
.quick
->file_names
;
3726 /* A helper for the "quick" functions which computes and caches the
3727 real path for a given file name from the line table. */
3730 dw2_get_real_path (struct objfile
*objfile
,
3731 struct quick_file_names
*qfn
, int index
)
3733 if (qfn
->real_names
== NULL
)
3734 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3735 qfn
->num_file_names
, const char *);
3737 if (qfn
->real_names
[index
] == NULL
)
3738 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3740 return qfn
->real_names
[index
];
3743 static struct symtab
*
3744 dw2_find_last_source_symtab (struct objfile
*objfile
)
3746 struct dwarf2_per_objfile
*dwarf2_per_objfile
3747 = get_dwarf2_per_objfile (objfile
);
3748 dwarf2_per_cu_data
*dwarf_cu
= dwarf2_per_objfile
->all_comp_units
.back ();
3749 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, false);
3754 return compunit_primary_filetab (cust
);
3757 /* Traversal function for dw2_forget_cached_source_info. */
3760 dw2_free_cached_file_names (void **slot
, void *info
)
3762 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3764 if (file_data
->real_names
)
3768 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3770 xfree ((void*) file_data
->real_names
[i
]);
3771 file_data
->real_names
[i
] = NULL
;
3779 dw2_forget_cached_source_info (struct objfile
*objfile
)
3781 struct dwarf2_per_objfile
*dwarf2_per_objfile
3782 = get_dwarf2_per_objfile (objfile
);
3784 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
3785 dw2_free_cached_file_names
, NULL
);
3788 /* Helper function for dw2_map_symtabs_matching_filename that expands
3789 the symtabs and calls the iterator. */
3792 dw2_map_expand_apply (struct objfile
*objfile
,
3793 struct dwarf2_per_cu_data
*per_cu
,
3794 const char *name
, const char *real_path
,
3795 gdb::function_view
<bool (symtab
*)> callback
)
3797 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3799 /* Don't visit already-expanded CUs. */
3800 if (per_cu
->v
.quick
->compunit_symtab
)
3803 /* This may expand more than one symtab, and we want to iterate over
3805 dw2_instantiate_symtab (per_cu
, false);
3807 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
3808 last_made
, callback
);
3811 /* Implementation of the map_symtabs_matching_filename method. */
3814 dw2_map_symtabs_matching_filename
3815 (struct objfile
*objfile
, const char *name
, const char *real_path
,
3816 gdb::function_view
<bool (symtab
*)> callback
)
3818 const char *name_basename
= lbasename (name
);
3819 struct dwarf2_per_objfile
*dwarf2_per_objfile
3820 = get_dwarf2_per_objfile (objfile
);
3822 /* The rule is CUs specify all the files, including those used by
3823 any TU, so there's no need to scan TUs here. */
3825 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
3827 /* We only need to look at symtabs not already expanded. */
3828 if (per_cu
->v
.quick
->compunit_symtab
)
3831 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
3832 if (file_data
== NULL
)
3835 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3837 const char *this_name
= file_data
->file_names
[j
];
3838 const char *this_real_name
;
3840 if (compare_filenames_for_search (this_name
, name
))
3842 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3848 /* Before we invoke realpath, which can get expensive when many
3849 files are involved, do a quick comparison of the basenames. */
3850 if (! basenames_may_differ
3851 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3854 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3855 if (compare_filenames_for_search (this_real_name
, name
))
3857 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3863 if (real_path
!= NULL
)
3865 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3866 gdb_assert (IS_ABSOLUTE_PATH (name
));
3867 if (this_real_name
!= NULL
3868 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3870 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3882 /* Struct used to manage iterating over all CUs looking for a symbol. */
3884 struct dw2_symtab_iterator
3886 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3887 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
3888 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3889 int want_specific_block
;
3890 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3891 Unused if !WANT_SPECIFIC_BLOCK. */
3893 /* The kind of symbol we're looking for. */
3895 /* The list of CUs from the index entry of the symbol,
3896 or NULL if not found. */
3898 /* The next element in VEC to look at. */
3900 /* The number of elements in VEC, or zero if there is no match. */
3902 /* Have we seen a global version of the symbol?
3903 If so we can ignore all further global instances.
3904 This is to work around gold/15646, inefficient gold-generated
3909 /* Initialize the index symtab iterator ITER.
3910 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3911 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3914 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3915 struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3916 int want_specific_block
,
3921 iter
->dwarf2_per_objfile
= dwarf2_per_objfile
;
3922 iter
->want_specific_block
= want_specific_block
;
3923 iter
->block_index
= block_index
;
3924 iter
->domain
= domain
;
3926 iter
->global_seen
= 0;
3928 mapped_index
*index
= dwarf2_per_objfile
->index_table
.get ();
3930 /* index is NULL if OBJF_READNOW. */
3931 if (index
!= NULL
&& find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3932 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3940 /* Return the next matching CU or NULL if there are no more. */
3942 static struct dwarf2_per_cu_data
*
3943 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3945 struct dwarf2_per_objfile
*dwarf2_per_objfile
= iter
->dwarf2_per_objfile
;
3947 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3949 offset_type cu_index_and_attrs
=
3950 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3951 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3952 int want_static
= iter
->block_index
!= GLOBAL_BLOCK
;
3953 /* This value is only valid for index versions >= 7. */
3954 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3955 gdb_index_symbol_kind symbol_kind
=
3956 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3957 /* Only check the symbol attributes if they're present.
3958 Indices prior to version 7 don't record them,
3959 and indices >= 7 may elide them for certain symbols
3960 (gold does this). */
3962 (dwarf2_per_objfile
->index_table
->version
>= 7
3963 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3965 /* Don't crash on bad data. */
3966 if (cu_index
>= (dwarf2_per_objfile
->all_comp_units
.size ()
3967 + dwarf2_per_objfile
->all_type_units
.size ()))
3969 complaint (_(".gdb_index entry has bad CU index"
3971 objfile_name (dwarf2_per_objfile
->objfile
));
3975 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (cu_index
);
3977 /* Skip if already read in. */
3978 if (per_cu
->v
.quick
->compunit_symtab
)
3981 /* Check static vs global. */
3984 if (iter
->want_specific_block
3985 && want_static
!= is_static
)
3987 /* Work around gold/15646. */
3988 if (!is_static
&& iter
->global_seen
)
3991 iter
->global_seen
= 1;
3994 /* Only check the symbol's kind if it has one. */
3997 switch (iter
->domain
)
4000 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
4001 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
4002 /* Some types are also in VAR_DOMAIN. */
4003 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4007 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4011 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4026 static struct compunit_symtab
*
4027 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
4028 const char *name
, domain_enum domain
)
4030 struct compunit_symtab
*stab_best
= NULL
;
4031 struct dwarf2_per_objfile
*dwarf2_per_objfile
4032 = get_dwarf2_per_objfile (objfile
);
4034 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
4036 struct dw2_symtab_iterator iter
;
4037 struct dwarf2_per_cu_data
*per_cu
;
4039 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, 1, block_index
, domain
, name
);
4041 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
4043 struct symbol
*sym
, *with_opaque
= NULL
;
4044 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
, false);
4045 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
4046 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
4048 sym
= block_find_symbol (block
, name
, domain
,
4049 block_find_non_opaque_type_preferred
,
4052 /* Some caution must be observed with overloaded functions
4053 and methods, since the index will not contain any overload
4054 information (but NAME might contain it). */
4057 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
4059 if (with_opaque
!= NULL
4060 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
4063 /* Keep looking through other CUs. */
4070 dw2_print_stats (struct objfile
*objfile
)
4072 struct dwarf2_per_objfile
*dwarf2_per_objfile
4073 = get_dwarf2_per_objfile (objfile
);
4074 int total
= (dwarf2_per_objfile
->all_comp_units
.size ()
4075 + dwarf2_per_objfile
->all_type_units
.size ());
4078 for (int i
= 0; i
< total
; ++i
)
4080 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
4082 if (!per_cu
->v
.quick
->compunit_symtab
)
4085 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
4086 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
4089 /* This dumps minimal information about the index.
4090 It is called via "mt print objfiles".
4091 One use is to verify .gdb_index has been loaded by the
4092 gdb.dwarf2/gdb-index.exp testcase. */
4095 dw2_dump (struct objfile
*objfile
)
4097 struct dwarf2_per_objfile
*dwarf2_per_objfile
4098 = get_dwarf2_per_objfile (objfile
);
4100 gdb_assert (dwarf2_per_objfile
->using_index
);
4101 printf_filtered (".gdb_index:");
4102 if (dwarf2_per_objfile
->index_table
!= NULL
)
4104 printf_filtered (" version %d\n",
4105 dwarf2_per_objfile
->index_table
->version
);
4108 printf_filtered (" faked for \"readnow\"\n");
4109 printf_filtered ("\n");
4113 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
4114 const char *func_name
)
4116 struct dwarf2_per_objfile
*dwarf2_per_objfile
4117 = get_dwarf2_per_objfile (objfile
);
4119 struct dw2_symtab_iterator iter
;
4120 struct dwarf2_per_cu_data
*per_cu
;
4122 /* Note: It doesn't matter what we pass for block_index here. */
4123 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, 0, GLOBAL_BLOCK
, VAR_DOMAIN
,
4126 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
4127 dw2_instantiate_symtab (per_cu
, false);
4132 dw2_expand_all_symtabs (struct objfile
*objfile
)
4134 struct dwarf2_per_objfile
*dwarf2_per_objfile
4135 = get_dwarf2_per_objfile (objfile
);
4136 int total_units
= (dwarf2_per_objfile
->all_comp_units
.size ()
4137 + dwarf2_per_objfile
->all_type_units
.size ());
4139 for (int i
= 0; i
< total_units
; ++i
)
4141 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
4143 /* We don't want to directly expand a partial CU, because if we
4144 read it with the wrong language, then assertion failures can
4145 be triggered later on. See PR symtab/23010. So, tell
4146 dw2_instantiate_symtab to skip partial CUs -- any important
4147 partial CU will be read via DW_TAG_imported_unit anyway. */
4148 dw2_instantiate_symtab (per_cu
, true);
4153 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
4154 const char *fullname
)
4156 struct dwarf2_per_objfile
*dwarf2_per_objfile
4157 = get_dwarf2_per_objfile (objfile
);
4159 /* We don't need to consider type units here.
4160 This is only called for examining code, e.g. expand_line_sal.
4161 There can be an order of magnitude (or more) more type units
4162 than comp units, and we avoid them if we can. */
4164 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
4166 /* We only need to look at symtabs not already expanded. */
4167 if (per_cu
->v
.quick
->compunit_symtab
)
4170 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
4171 if (file_data
== NULL
)
4174 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4176 const char *this_fullname
= file_data
->file_names
[j
];
4178 if (filename_cmp (this_fullname
, fullname
) == 0)
4180 dw2_instantiate_symtab (per_cu
, false);
4188 dw2_map_matching_symbols (struct objfile
*objfile
,
4189 const char * name
, domain_enum domain
,
4191 int (*callback
) (const struct block
*,
4192 struct symbol
*, void *),
4193 void *data
, symbol_name_match_type match
,
4194 symbol_compare_ftype
*ordered_compare
)
4196 /* Currently unimplemented; used for Ada. The function can be called if the
4197 current language is Ada for a non-Ada objfile using GNU index. As Ada
4198 does not look for non-Ada symbols this function should just return. */
4201 /* Symbol name matcher for .gdb_index names.
4203 Symbol names in .gdb_index have a few particularities:
4205 - There's no indication of which is the language of each symbol.
4207 Since each language has its own symbol name matching algorithm,
4208 and we don't know which language is the right one, we must match
4209 each symbol against all languages. This would be a potential
4210 performance problem if it were not mitigated by the
4211 mapped_index::name_components lookup table, which significantly
4212 reduces the number of times we need to call into this matcher,
4213 making it a non-issue.
4215 - Symbol names in the index have no overload (parameter)
4216 information. I.e., in C++, "foo(int)" and "foo(long)" both
4217 appear as "foo" in the index, for example.
4219 This means that the lookup names passed to the symbol name
4220 matcher functions must have no parameter information either
4221 because (e.g.) symbol search name "foo" does not match
4222 lookup-name "foo(int)" [while swapping search name for lookup
4225 class gdb_index_symbol_name_matcher
4228 /* Prepares the vector of comparison functions for LOOKUP_NAME. */
4229 gdb_index_symbol_name_matcher (const lookup_name_info
&lookup_name
);
4231 /* Walk all the matcher routines and match SYMBOL_NAME against them.
4232 Returns true if any matcher matches. */
4233 bool matches (const char *symbol_name
);
4236 /* A reference to the lookup name we're matching against. */
4237 const lookup_name_info
&m_lookup_name
;
4239 /* A vector holding all the different symbol name matchers, for all
4241 std::vector
<symbol_name_matcher_ftype
*> m_symbol_name_matcher_funcs
;
4244 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4245 (const lookup_name_info
&lookup_name
)
4246 : m_lookup_name (lookup_name
)
4248 /* Prepare the vector of comparison functions upfront, to avoid
4249 doing the same work for each symbol. Care is taken to avoid
4250 matching with the same matcher more than once if/when multiple
4251 languages use the same matcher function. */
4252 auto &matchers
= m_symbol_name_matcher_funcs
;
4253 matchers
.reserve (nr_languages
);
4255 matchers
.push_back (default_symbol_name_matcher
);
4257 for (int i
= 0; i
< nr_languages
; i
++)
4259 const language_defn
*lang
= language_def ((enum language
) i
);
4260 symbol_name_matcher_ftype
*name_matcher
4261 = get_symbol_name_matcher (lang
, m_lookup_name
);
4263 /* Don't insert the same comparison routine more than once.
4264 Note that we do this linear walk instead of a seemingly
4265 cheaper sorted insert, or use a std::set or something like
4266 that, because relative order of function addresses is not
4267 stable. This is not a problem in practice because the number
4268 of supported languages is low, and the cost here is tiny
4269 compared to the number of searches we'll do afterwards using
4271 if (name_matcher
!= default_symbol_name_matcher
4272 && (std::find (matchers
.begin (), matchers
.end (), name_matcher
)
4273 == matchers
.end ()))
4274 matchers
.push_back (name_matcher
);
4279 gdb_index_symbol_name_matcher::matches (const char *symbol_name
)
4281 for (auto matches_name
: m_symbol_name_matcher_funcs
)
4282 if (matches_name (symbol_name
, m_lookup_name
, NULL
))
4288 /* Starting from a search name, return the string that finds the upper
4289 bound of all strings that start with SEARCH_NAME in a sorted name
4290 list. Returns the empty string to indicate that the upper bound is
4291 the end of the list. */
4294 make_sort_after_prefix_name (const char *search_name
)
4296 /* When looking to complete "func", we find the upper bound of all
4297 symbols that start with "func" by looking for where we'd insert
4298 the closest string that would follow "func" in lexicographical
4299 order. Usually, that's "func"-with-last-character-incremented,
4300 i.e. "fund". Mind non-ASCII characters, though. Usually those
4301 will be UTF-8 multi-byte sequences, but we can't be certain.
4302 Especially mind the 0xff character, which is a valid character in
4303 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4304 rule out compilers allowing it in identifiers. Note that
4305 conveniently, strcmp/strcasecmp are specified to compare
4306 characters interpreted as unsigned char. So what we do is treat
4307 the whole string as a base 256 number composed of a sequence of
4308 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4309 to 0, and carries 1 to the following more-significant position.
4310 If the very first character in SEARCH_NAME ends up incremented
4311 and carries/overflows, then the upper bound is the end of the
4312 list. The string after the empty string is also the empty
4315 Some examples of this operation:
4317 SEARCH_NAME => "+1" RESULT
4321 "\xff" "a" "\xff" => "\xff" "b"
4326 Then, with these symbols for example:
4332 completing "func" looks for symbols between "func" and
4333 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4334 which finds "func" and "func1", but not "fund".
4338 funcÿ (Latin1 'ÿ' [0xff])
4342 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4343 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4347 ÿÿ (Latin1 'ÿ' [0xff])
4350 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4351 the end of the list.
4353 std::string after
= search_name
;
4354 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
4356 if (!after
.empty ())
4357 after
.back () = (unsigned char) after
.back () + 1;
4361 /* See declaration. */
4363 std::pair
<std::vector
<name_component
>::const_iterator
,
4364 std::vector
<name_component
>::const_iterator
>
4365 mapped_index_base::find_name_components_bounds
4366 (const lookup_name_info
&lookup_name_without_params
) const
4369 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4372 = lookup_name_without_params
.cplus ().lookup_name ().c_str ();
4374 /* Comparison function object for lower_bound that matches against a
4375 given symbol name. */
4376 auto lookup_compare_lower
= [&] (const name_component
&elem
,
4379 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4380 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4381 return name_cmp (elem_name
, name
) < 0;
4384 /* Comparison function object for upper_bound that matches against a
4385 given symbol name. */
4386 auto lookup_compare_upper
= [&] (const char *name
,
4387 const name_component
&elem
)
4389 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4390 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4391 return name_cmp (name
, elem_name
) < 0;
4394 auto begin
= this->name_components
.begin ();
4395 auto end
= this->name_components
.end ();
4397 /* Find the lower bound. */
4400 if (lookup_name_without_params
.completion_mode () && cplus
[0] == '\0')
4403 return std::lower_bound (begin
, end
, cplus
, lookup_compare_lower
);
4406 /* Find the upper bound. */
4409 if (lookup_name_without_params
.completion_mode ())
4411 /* In completion mode, we want UPPER to point past all
4412 symbols names that have the same prefix. I.e., with
4413 these symbols, and completing "func":
4415 function << lower bound
4417 other_function << upper bound
4419 We find the upper bound by looking for the insertion
4420 point of "func"-with-last-character-incremented,
4422 std::string after
= make_sort_after_prefix_name (cplus
);
4425 return std::lower_bound (lower
, end
, after
.c_str (),
4426 lookup_compare_lower
);
4429 return std::upper_bound (lower
, end
, cplus
, lookup_compare_upper
);
4432 return {lower
, upper
};
4435 /* See declaration. */
4438 mapped_index_base::build_name_components ()
4440 if (!this->name_components
.empty ())
4443 this->name_components_casing
= case_sensitivity
;
4445 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4447 /* The code below only knows how to break apart components of C++
4448 symbol names (and other languages that use '::' as
4449 namespace/module separator). If we add support for wild matching
4450 to some language that uses some other operator (E.g., Ada, Go and
4451 D use '.'), then we'll need to try splitting the symbol name
4452 according to that language too. Note that Ada does support wild
4453 matching, but doesn't currently support .gdb_index. */
4454 auto count
= this->symbol_name_count ();
4455 for (offset_type idx
= 0; idx
< count
; idx
++)
4457 if (this->symbol_name_slot_invalid (idx
))
4460 const char *name
= this->symbol_name_at (idx
);
4462 /* Add each name component to the name component table. */
4463 unsigned int previous_len
= 0;
4464 for (unsigned int current_len
= cp_find_first_component (name
);
4465 name
[current_len
] != '\0';
4466 current_len
+= cp_find_first_component (name
+ current_len
))
4468 gdb_assert (name
[current_len
] == ':');
4469 this->name_components
.push_back ({previous_len
, idx
});
4470 /* Skip the '::'. */
4472 previous_len
= current_len
;
4474 this->name_components
.push_back ({previous_len
, idx
});
4477 /* Sort name_components elements by name. */
4478 auto name_comp_compare
= [&] (const name_component
&left
,
4479 const name_component
&right
)
4481 const char *left_qualified
= this->symbol_name_at (left
.idx
);
4482 const char *right_qualified
= this->symbol_name_at (right
.idx
);
4484 const char *left_name
= left_qualified
+ left
.name_offset
;
4485 const char *right_name
= right_qualified
+ right
.name_offset
;
4487 return name_cmp (left_name
, right_name
) < 0;
4490 std::sort (this->name_components
.begin (),
4491 this->name_components
.end (),
4495 /* Helper for dw2_expand_symtabs_matching that works with a
4496 mapped_index_base instead of the containing objfile. This is split
4497 to a separate function in order to be able to unit test the
4498 name_components matching using a mock mapped_index_base. For each
4499 symbol name that matches, calls MATCH_CALLBACK, passing it the
4500 symbol's index in the mapped_index_base symbol table. */
4503 dw2_expand_symtabs_matching_symbol
4504 (mapped_index_base
&index
,
4505 const lookup_name_info
&lookup_name_in
,
4506 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4507 enum search_domain kind
,
4508 gdb::function_view
<void (offset_type
)> match_callback
)
4510 lookup_name_info lookup_name_without_params
4511 = lookup_name_in
.make_ignore_params ();
4512 gdb_index_symbol_name_matcher lookup_name_matcher
4513 (lookup_name_without_params
);
4515 /* Build the symbol name component sorted vector, if we haven't
4517 index
.build_name_components ();
4519 auto bounds
= index
.find_name_components_bounds (lookup_name_without_params
);
4521 /* Now for each symbol name in range, check to see if we have a name
4522 match, and if so, call the MATCH_CALLBACK callback. */
4524 /* The same symbol may appear more than once in the range though.
4525 E.g., if we're looking for symbols that complete "w", and we have
4526 a symbol named "w1::w2", we'll find the two name components for
4527 that same symbol in the range. To be sure we only call the
4528 callback once per symbol, we first collect the symbol name
4529 indexes that matched in a temporary vector and ignore
4531 std::vector
<offset_type
> matches
;
4532 matches
.reserve (std::distance (bounds
.first
, bounds
.second
));
4534 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
4536 const char *qualified
= index
.symbol_name_at (bounds
.first
->idx
);
4538 if (!lookup_name_matcher
.matches (qualified
)
4539 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
4542 matches
.push_back (bounds
.first
->idx
);
4545 std::sort (matches
.begin (), matches
.end ());
4547 /* Finally call the callback, once per match. */
4549 for (offset_type idx
: matches
)
4553 match_callback (idx
);
4558 /* Above we use a type wider than idx's for 'prev', since 0 and
4559 (offset_type)-1 are both possible values. */
4560 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
4565 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
4567 /* A mock .gdb_index/.debug_names-like name index table, enough to
4568 exercise dw2_expand_symtabs_matching_symbol, which works with the
4569 mapped_index_base interface. Builds an index from the symbol list
4570 passed as parameter to the constructor. */
4571 class mock_mapped_index
: public mapped_index_base
4574 mock_mapped_index (gdb::array_view
<const char *> symbols
)
4575 : m_symbol_table (symbols
)
4578 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
4580 /* Return the number of names in the symbol table. */
4581 size_t symbol_name_count () const override
4583 return m_symbol_table
.size ();
4586 /* Get the name of the symbol at IDX in the symbol table. */
4587 const char *symbol_name_at (offset_type idx
) const override
4589 return m_symbol_table
[idx
];
4593 gdb::array_view
<const char *> m_symbol_table
;
4596 /* Convenience function that converts a NULL pointer to a "<null>"
4597 string, to pass to print routines. */
4600 string_or_null (const char *str
)
4602 return str
!= NULL
? str
: "<null>";
4605 /* Check if a lookup_name_info built from
4606 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4607 index. EXPECTED_LIST is the list of expected matches, in expected
4608 matching order. If no match expected, then an empty list is
4609 specified. Returns true on success. On failure prints a warning
4610 indicating the file:line that failed, and returns false. */
4613 check_match (const char *file
, int line
,
4614 mock_mapped_index
&mock_index
,
4615 const char *name
, symbol_name_match_type match_type
,
4616 bool completion_mode
,
4617 std::initializer_list
<const char *> expected_list
)
4619 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4621 bool matched
= true;
4623 auto mismatch
= [&] (const char *expected_str
,
4626 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4627 "expected=\"%s\", got=\"%s\"\n"),
4629 (match_type
== symbol_name_match_type::FULL
4631 name
, string_or_null (expected_str
), string_or_null (got
));
4635 auto expected_it
= expected_list
.begin ();
4636 auto expected_end
= expected_list
.end ();
4638 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
4640 [&] (offset_type idx
)
4642 const char *matched_name
= mock_index
.symbol_name_at (idx
);
4643 const char *expected_str
4644 = expected_it
== expected_end
? NULL
: *expected_it
++;
4646 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4647 mismatch (expected_str
, matched_name
);
4650 const char *expected_str
4651 = expected_it
== expected_end
? NULL
: *expected_it
++;
4652 if (expected_str
!= NULL
)
4653 mismatch (expected_str
, NULL
);
4658 /* The symbols added to the mock mapped_index for testing (in
4660 static const char *test_symbols
[] = {
4669 "ns2::tmpl<int>::foo2",
4670 "(anonymous namespace)::A::B::C",
4672 /* These are used to check that the increment-last-char in the
4673 matching algorithm for completion doesn't match "t1_fund" when
4674 completing "t1_func". */
4680 /* A UTF-8 name with multi-byte sequences to make sure that
4681 cp-name-parser understands this as a single identifier ("função"
4682 is "function" in PT). */
4685 /* \377 (0xff) is Latin1 'ÿ'. */
4688 /* \377 (0xff) is Latin1 'ÿ'. */
4692 /* A name with all sorts of complications. Starts with "z" to make
4693 it easier for the completion tests below. */
4694 #define Z_SYM_NAME \
4695 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4696 "::tuple<(anonymous namespace)::ui*, " \
4697 "std::default_delete<(anonymous namespace)::ui>, void>"
4702 /* Returns true if the mapped_index_base::find_name_component_bounds
4703 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4704 in completion mode. */
4707 check_find_bounds_finds (mapped_index_base
&index
,
4708 const char *search_name
,
4709 gdb::array_view
<const char *> expected_syms
)
4711 lookup_name_info
lookup_name (search_name
,
4712 symbol_name_match_type::FULL
, true);
4714 auto bounds
= index
.find_name_components_bounds (lookup_name
);
4716 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
4717 if (distance
!= expected_syms
.size ())
4720 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
4722 auto nc_elem
= bounds
.first
+ exp_elem
;
4723 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
);
4724 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
4731 /* Test the lower-level mapped_index::find_name_component_bounds
4735 test_mapped_index_find_name_component_bounds ()
4737 mock_mapped_index
mock_index (test_symbols
);
4739 mock_index
.build_name_components ();
4741 /* Test the lower-level mapped_index::find_name_component_bounds
4742 method in completion mode. */
4744 static const char *expected_syms
[] = {
4749 SELF_CHECK (check_find_bounds_finds (mock_index
,
4750 "t1_func", expected_syms
));
4753 /* Check that the increment-last-char in the name matching algorithm
4754 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4756 static const char *expected_syms1
[] = {
4760 SELF_CHECK (check_find_bounds_finds (mock_index
,
4761 "\377", expected_syms1
));
4763 static const char *expected_syms2
[] = {
4766 SELF_CHECK (check_find_bounds_finds (mock_index
,
4767 "\377\377", expected_syms2
));
4771 /* Test dw2_expand_symtabs_matching_symbol. */
4774 test_dw2_expand_symtabs_matching_symbol ()
4776 mock_mapped_index
mock_index (test_symbols
);
4778 /* We let all tests run until the end even if some fails, for debug
4780 bool any_mismatch
= false;
4782 /* Create the expected symbols list (an initializer_list). Needed
4783 because lists have commas, and we need to pass them to CHECK,
4784 which is a macro. */
4785 #define EXPECT(...) { __VA_ARGS__ }
4787 /* Wrapper for check_match that passes down the current
4788 __FILE__/__LINE__. */
4789 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4790 any_mismatch |= !check_match (__FILE__, __LINE__, \
4792 NAME, MATCH_TYPE, COMPLETION_MODE, \
4795 /* Identity checks. */
4796 for (const char *sym
: test_symbols
)
4798 /* Should be able to match all existing symbols. */
4799 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4802 /* Should be able to match all existing symbols with
4804 std::string with_params
= std::string (sym
) + "(int)";
4805 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4808 /* Should be able to match all existing symbols with
4809 parameters and qualifiers. */
4810 with_params
= std::string (sym
) + " ( int ) const";
4811 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4814 /* This should really find sym, but cp-name-parser.y doesn't
4815 know about lvalue/rvalue qualifiers yet. */
4816 with_params
= std::string (sym
) + " ( int ) &&";
4817 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4821 /* Check that the name matching algorithm for completion doesn't get
4822 confused with Latin1 'ÿ' / 0xff. */
4824 static const char str
[] = "\377";
4825 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4826 EXPECT ("\377", "\377\377123"));
4829 /* Check that the increment-last-char in the matching algorithm for
4830 completion doesn't match "t1_fund" when completing "t1_func". */
4832 static const char str
[] = "t1_func";
4833 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4834 EXPECT ("t1_func", "t1_func1"));
4837 /* Check that completion mode works at each prefix of the expected
4840 static const char str
[] = "function(int)";
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 ("function"));
4852 /* While "w" is a prefix of both components, the match function
4853 should still only be called once. */
4855 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4857 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4861 /* Same, with a "complicated" symbol. */
4863 static const char str
[] = Z_SYM_NAME
;
4864 size_t len
= strlen (str
);
4867 for (size_t i
= 1; i
< len
; i
++)
4869 lookup
.assign (str
, i
);
4870 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4871 EXPECT (Z_SYM_NAME
));
4875 /* In FULL mode, an incomplete symbol doesn't match. */
4877 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4881 /* A complete symbol with parameters matches any overload, since the
4882 index has no overload info. */
4884 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4885 EXPECT ("std::zfunction", "std::zfunction2"));
4886 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4887 EXPECT ("std::zfunction", "std::zfunction2"));
4888 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4889 EXPECT ("std::zfunction", "std::zfunction2"));
4892 /* Check that whitespace is ignored appropriately. A symbol with a
4893 template argument list. */
4895 static const char expected
[] = "ns::foo<int>";
4896 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4898 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4902 /* Check that whitespace is ignored appropriately. A symbol with a
4903 template argument list that includes a pointer. */
4905 static const char expected
[] = "ns::foo<char*>";
4906 /* Try both completion and non-completion modes. */
4907 static const bool completion_mode
[2] = {false, true};
4908 for (size_t i
= 0; i
< 2; i
++)
4910 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4911 completion_mode
[i
], EXPECT (expected
));
4912 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4913 completion_mode
[i
], EXPECT (expected
));
4915 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4916 completion_mode
[i
], EXPECT (expected
));
4917 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4918 completion_mode
[i
], EXPECT (expected
));
4923 /* Check method qualifiers are ignored. */
4924 static const char expected
[] = "ns::foo<char*>";
4925 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4926 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4927 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4928 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4929 CHECK_MATCH ("foo < char * > ( int ) const",
4930 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4931 CHECK_MATCH ("foo < char * > ( int ) &&",
4932 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4935 /* Test lookup names that don't match anything. */
4937 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4940 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4944 /* Some wild matching tests, exercising "(anonymous namespace)",
4945 which should not be confused with a parameter list. */
4947 static const char *syms
[] = {
4951 "A :: B :: C ( int )",
4956 for (const char *s
: syms
)
4958 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4959 EXPECT ("(anonymous namespace)::A::B::C"));
4964 static const char expected
[] = "ns2::tmpl<int>::foo2";
4965 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4967 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4971 SELF_CHECK (!any_mismatch
);
4980 test_mapped_index_find_name_component_bounds ();
4981 test_dw2_expand_symtabs_matching_symbol ();
4984 }} // namespace selftests::dw2_expand_symtabs_matching
4986 #endif /* GDB_SELF_TEST */
4988 /* If FILE_MATCHER is NULL or if PER_CU has
4989 dwarf2_per_cu_quick_data::MARK set (see
4990 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4991 EXPANSION_NOTIFY on it. */
4994 dw2_expand_symtabs_matching_one
4995 (struct dwarf2_per_cu_data
*per_cu
,
4996 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4997 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4999 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
5001 bool symtab_was_null
5002 = (per_cu
->v
.quick
->compunit_symtab
== NULL
);
5004 dw2_instantiate_symtab (per_cu
, false);
5006 if (expansion_notify
!= NULL
5008 && per_cu
->v
.quick
->compunit_symtab
!= NULL
)
5009 expansion_notify (per_cu
->v
.quick
->compunit_symtab
);
5013 /* Helper for dw2_expand_matching symtabs. Called on each symbol
5014 matched, to expand corresponding CUs that were marked. IDX is the
5015 index of the symbol name that matched. */
5018 dw2_expand_marked_cus
5019 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, offset_type idx
,
5020 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5021 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5024 offset_type
*vec
, vec_len
, vec_idx
;
5025 bool global_seen
= false;
5026 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
5028 vec
= (offset_type
*) (index
.constant_pool
5029 + MAYBE_SWAP (index
.symbol_table
[idx
].vec
));
5030 vec_len
= MAYBE_SWAP (vec
[0]);
5031 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
5033 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
5034 /* This value is only valid for index versions >= 7. */
5035 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
5036 gdb_index_symbol_kind symbol_kind
=
5037 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
5038 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
5039 /* Only check the symbol attributes if they're present.
5040 Indices prior to version 7 don't record them,
5041 and indices >= 7 may elide them for certain symbols
5042 (gold does this). */
5045 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
5047 /* Work around gold/15646. */
5050 if (!is_static
&& global_seen
)
5056 /* Only check the symbol's kind if it has one. */
5061 case VARIABLES_DOMAIN
:
5062 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
5065 case FUNCTIONS_DOMAIN
:
5066 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
5070 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
5078 /* Don't crash on bad data. */
5079 if (cu_index
>= (dwarf2_per_objfile
->all_comp_units
.size ()
5080 + dwarf2_per_objfile
->all_type_units
.size ()))
5082 complaint (_(".gdb_index entry has bad CU index"
5084 objfile_name (dwarf2_per_objfile
->objfile
));
5088 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (cu_index
);
5089 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
5094 /* If FILE_MATCHER is non-NULL, set all the
5095 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5096 that match FILE_MATCHER. */
5099 dw_expand_symtabs_matching_file_matcher
5100 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5101 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
5103 if (file_matcher
== NULL
)
5106 objfile
*const objfile
= dwarf2_per_objfile
->objfile
;
5108 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
5110 NULL
, xcalloc
, xfree
));
5111 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
5113 NULL
, xcalloc
, xfree
));
5115 /* The rule is CUs specify all the files, including those used by
5116 any TU, so there's no need to scan TUs here. */
5118 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5122 per_cu
->v
.quick
->mark
= 0;
5124 /* We only need to look at symtabs not already expanded. */
5125 if (per_cu
->v
.quick
->compunit_symtab
)
5128 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
5129 if (file_data
== NULL
)
5132 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
5134 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
5136 per_cu
->v
.quick
->mark
= 1;
5140 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5142 const char *this_real_name
;
5144 if (file_matcher (file_data
->file_names
[j
], false))
5146 per_cu
->v
.quick
->mark
= 1;
5150 /* Before we invoke realpath, which can get expensive when many
5151 files are involved, do a quick comparison of the basenames. */
5152 if (!basenames_may_differ
5153 && !file_matcher (lbasename (file_data
->file_names
[j
]),
5157 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
5158 if (file_matcher (this_real_name
, false))
5160 per_cu
->v
.quick
->mark
= 1;
5165 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
5166 ? visited_found
.get ()
5167 : visited_not_found
.get (),
5174 dw2_expand_symtabs_matching
5175 (struct objfile
*objfile
,
5176 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5177 const lookup_name_info
&lookup_name
,
5178 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5179 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5180 enum search_domain kind
)
5182 struct dwarf2_per_objfile
*dwarf2_per_objfile
5183 = get_dwarf2_per_objfile (objfile
);
5185 /* index_table is NULL if OBJF_READNOW. */
5186 if (!dwarf2_per_objfile
->index_table
)
5189 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
5191 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
5193 dw2_expand_symtabs_matching_symbol (index
, lookup_name
,
5195 kind
, [&] (offset_type idx
)
5197 dw2_expand_marked_cus (dwarf2_per_objfile
, idx
, file_matcher
,
5198 expansion_notify
, kind
);
5202 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5205 static struct compunit_symtab
*
5206 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
5211 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
5212 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
5215 if (cust
->includes
== NULL
)
5218 for (i
= 0; cust
->includes
[i
]; ++i
)
5220 struct compunit_symtab
*s
= cust
->includes
[i
];
5222 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
5230 static struct compunit_symtab
*
5231 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
5232 struct bound_minimal_symbol msymbol
,
5234 struct obj_section
*section
,
5237 struct dwarf2_per_cu_data
*data
;
5238 struct compunit_symtab
*result
;
5240 if (!objfile
->partial_symtabs
->psymtabs_addrmap
)
5243 CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
5244 SECT_OFF_TEXT (objfile
));
5245 data
= (struct dwarf2_per_cu_data
*) addrmap_find
5246 (objfile
->partial_symtabs
->psymtabs_addrmap
, pc
- baseaddr
);
5250 if (warn_if_readin
&& data
->v
.quick
->compunit_symtab
)
5251 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5252 paddress (get_objfile_arch (objfile
), pc
));
5255 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data
,
5258 gdb_assert (result
!= NULL
);
5263 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
5264 void *data
, int need_fullname
)
5266 struct dwarf2_per_objfile
*dwarf2_per_objfile
5267 = get_dwarf2_per_objfile (objfile
);
5269 if (!dwarf2_per_objfile
->filenames_cache
)
5271 dwarf2_per_objfile
->filenames_cache
.emplace ();
5273 htab_up
visited (htab_create_alloc (10,
5274 htab_hash_pointer
, htab_eq_pointer
,
5275 NULL
, xcalloc
, xfree
));
5277 /* The rule is CUs specify all the files, including those used
5278 by any TU, so there's no need to scan TUs here. We can
5279 ignore file names coming from already-expanded CUs. */
5281 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5283 if (per_cu
->v
.quick
->compunit_symtab
)
5285 void **slot
= htab_find_slot (visited
.get (),
5286 per_cu
->v
.quick
->file_names
,
5289 *slot
= per_cu
->v
.quick
->file_names
;
5293 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5295 /* We only need to look at symtabs not already expanded. */
5296 if (per_cu
->v
.quick
->compunit_symtab
)
5299 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
5300 if (file_data
== NULL
)
5303 void **slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
5306 /* Already visited. */
5311 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5313 const char *filename
= file_data
->file_names
[j
];
5314 dwarf2_per_objfile
->filenames_cache
->seen (filename
);
5319 dwarf2_per_objfile
->filenames_cache
->traverse ([&] (const char *filename
)
5321 gdb::unique_xmalloc_ptr
<char> this_real_name
;
5324 this_real_name
= gdb_realpath (filename
);
5325 (*fun
) (filename
, this_real_name
.get (), data
);
5330 dw2_has_symbols (struct objfile
*objfile
)
5335 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
5338 dw2_find_last_source_symtab
,
5339 dw2_forget_cached_source_info
,
5340 dw2_map_symtabs_matching_filename
,
5344 dw2_expand_symtabs_for_function
,
5345 dw2_expand_all_symtabs
,
5346 dw2_expand_symtabs_with_fullname
,
5347 dw2_map_matching_symbols
,
5348 dw2_expand_symtabs_matching
,
5349 dw2_find_pc_sect_compunit_symtab
,
5351 dw2_map_symbol_filenames
5354 /* DWARF-5 debug_names reader. */
5356 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5357 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
5359 /* A helper function that reads the .debug_names section in SECTION
5360 and fills in MAP. FILENAME is the name of the file containing the
5361 section; it is used for error reporting.
5363 Returns true if all went well, false otherwise. */
5366 read_debug_names_from_section (struct objfile
*objfile
,
5367 const char *filename
,
5368 struct dwarf2_section_info
*section
,
5369 mapped_debug_names
&map
)
5371 if (dwarf2_section_empty_p (section
))
5374 /* Older elfutils strip versions could keep the section in the main
5375 executable while splitting it for the separate debug info file. */
5376 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
5379 dwarf2_read_section (objfile
, section
);
5381 map
.dwarf5_byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
5383 const gdb_byte
*addr
= section
->buffer
;
5385 bfd
*const abfd
= get_section_bfd_owner (section
);
5387 unsigned int bytes_read
;
5388 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
5391 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
5392 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
5393 if (bytes_read
+ length
!= section
->size
)
5395 /* There may be multiple per-CU indices. */
5396 warning (_("Section .debug_names in %s length %s does not match "
5397 "section length %s, ignoring .debug_names."),
5398 filename
, plongest (bytes_read
+ length
),
5399 pulongest (section
->size
));
5403 /* The version number. */
5404 uint16_t version
= read_2_bytes (abfd
, addr
);
5408 warning (_("Section .debug_names in %s has unsupported version %d, "
5409 "ignoring .debug_names."),
5415 uint16_t padding
= read_2_bytes (abfd
, addr
);
5419 warning (_("Section .debug_names in %s has unsupported padding %d, "
5420 "ignoring .debug_names."),
5425 /* comp_unit_count - The number of CUs in the CU list. */
5426 map
.cu_count
= read_4_bytes (abfd
, addr
);
5429 /* local_type_unit_count - The number of TUs in the local TU
5431 map
.tu_count
= read_4_bytes (abfd
, addr
);
5434 /* foreign_type_unit_count - The number of TUs in the foreign TU
5436 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
5438 if (foreign_tu_count
!= 0)
5440 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5441 "ignoring .debug_names."),
5442 filename
, static_cast<unsigned long> (foreign_tu_count
));
5446 /* bucket_count - The number of hash buckets in the hash lookup
5448 map
.bucket_count
= read_4_bytes (abfd
, addr
);
5451 /* name_count - The number of unique names in the index. */
5452 map
.name_count
= read_4_bytes (abfd
, addr
);
5455 /* abbrev_table_size - The size in bytes of the abbreviations
5457 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
5460 /* augmentation_string_size - The size in bytes of the augmentation
5461 string. This value is rounded up to a multiple of 4. */
5462 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
5464 map
.augmentation_is_gdb
= ((augmentation_string_size
5465 == sizeof (dwarf5_augmentation
))
5466 && memcmp (addr
, dwarf5_augmentation
,
5467 sizeof (dwarf5_augmentation
)) == 0);
5468 augmentation_string_size
+= (-augmentation_string_size
) & 3;
5469 addr
+= augmentation_string_size
;
5472 map
.cu_table_reordered
= addr
;
5473 addr
+= map
.cu_count
* map
.offset_size
;
5475 /* List of Local TUs */
5476 map
.tu_table_reordered
= addr
;
5477 addr
+= map
.tu_count
* map
.offset_size
;
5479 /* Hash Lookup Table */
5480 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5481 addr
+= map
.bucket_count
* 4;
5482 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5483 addr
+= map
.name_count
* 4;
5486 map
.name_table_string_offs_reordered
= addr
;
5487 addr
+= map
.name_count
* map
.offset_size
;
5488 map
.name_table_entry_offs_reordered
= addr
;
5489 addr
+= map
.name_count
* map
.offset_size
;
5491 const gdb_byte
*abbrev_table_start
= addr
;
5494 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5499 const auto insertpair
5500 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
5501 if (!insertpair
.second
)
5503 warning (_("Section .debug_names in %s has duplicate index %s, "
5504 "ignoring .debug_names."),
5505 filename
, pulongest (index_num
));
5508 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
5509 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5514 mapped_debug_names::index_val::attr attr
;
5515 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5517 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5519 if (attr
.form
== DW_FORM_implicit_const
)
5521 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
5525 if (attr
.dw_idx
== 0 && attr
.form
== 0)
5527 indexval
.attr_vec
.push_back (std::move (attr
));
5530 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
5532 warning (_("Section .debug_names in %s has abbreviation_table "
5533 "of size %zu vs. written as %u, ignoring .debug_names."),
5534 filename
, addr
- abbrev_table_start
, abbrev_table_size
);
5537 map
.entry_pool
= addr
;
5542 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5546 create_cus_from_debug_names_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5547 const mapped_debug_names
&map
,
5548 dwarf2_section_info
§ion
,
5551 sect_offset sect_off_prev
;
5552 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
5554 sect_offset sect_off_next
;
5555 if (i
< map
.cu_count
)
5558 = (sect_offset
) (extract_unsigned_integer
5559 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5561 map
.dwarf5_byte_order
));
5564 sect_off_next
= (sect_offset
) section
.size
;
5567 const ULONGEST length
= sect_off_next
- sect_off_prev
;
5568 dwarf2_per_cu_data
*per_cu
5569 = create_cu_from_index_list (dwarf2_per_objfile
, §ion
, is_dwz
,
5570 sect_off_prev
, length
);
5571 dwarf2_per_objfile
->all_comp_units
.push_back (per_cu
);
5573 sect_off_prev
= sect_off_next
;
5577 /* Read the CU list from the mapped index, and use it to create all
5578 the CU objects for this dwarf2_per_objfile. */
5581 create_cus_from_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5582 const mapped_debug_names
&map
,
5583 const mapped_debug_names
&dwz_map
)
5585 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
5586 dwarf2_per_objfile
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
5588 create_cus_from_debug_names_list (dwarf2_per_objfile
, map
,
5589 dwarf2_per_objfile
->info
,
5590 false /* is_dwz */);
5592 if (dwz_map
.cu_count
== 0)
5595 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5596 create_cus_from_debug_names_list (dwarf2_per_objfile
, dwz_map
, dwz
->info
,
5600 /* Read .debug_names. If everything went ok, initialize the "quick"
5601 elements of all the CUs and return true. Otherwise, return false. */
5604 dwarf2_read_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
5606 std::unique_ptr
<mapped_debug_names
> map
5607 (new mapped_debug_names (dwarf2_per_objfile
));
5608 mapped_debug_names
dwz_map (dwarf2_per_objfile
);
5609 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5611 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
5612 &dwarf2_per_objfile
->debug_names
,
5616 /* Don't use the index if it's empty. */
5617 if (map
->name_count
== 0)
5620 /* If there is a .dwz file, read it so we can get its CU list as
5622 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5625 if (!read_debug_names_from_section (objfile
,
5626 bfd_get_filename (dwz
->dwz_bfd
),
5627 &dwz
->debug_names
, dwz_map
))
5629 warning (_("could not read '.debug_names' section from %s; skipping"),
5630 bfd_get_filename (dwz
->dwz_bfd
));
5635 create_cus_from_debug_names (dwarf2_per_objfile
, *map
, dwz_map
);
5637 if (map
->tu_count
!= 0)
5639 /* We can only handle a single .debug_types when we have an
5641 if (VEC_length (dwarf2_section_info_def
, dwarf2_per_objfile
->types
) != 1)
5644 dwarf2_section_info
*section
= VEC_index (dwarf2_section_info_def
,
5645 dwarf2_per_objfile
->types
, 0);
5647 create_signatured_type_table_from_debug_names
5648 (dwarf2_per_objfile
, *map
, section
, &dwarf2_per_objfile
->abbrev
);
5651 create_addrmap_from_aranges (dwarf2_per_objfile
,
5652 &dwarf2_per_objfile
->debug_aranges
);
5654 dwarf2_per_objfile
->debug_names_table
= std::move (map
);
5655 dwarf2_per_objfile
->using_index
= 1;
5656 dwarf2_per_objfile
->quick_file_names_table
=
5657 create_quick_file_names_table (dwarf2_per_objfile
->all_comp_units
.size ());
5662 /* Type used to manage iterating over all CUs looking for a symbol for
5665 class dw2_debug_names_iterator
5668 /* If WANT_SPECIFIC_BLOCK is true, only look for symbols in block
5669 BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
5670 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5671 bool want_specific_block
,
5672 block_enum block_index
, domain_enum domain
,
5674 : m_map (map
), m_want_specific_block (want_specific_block
),
5675 m_block_index (block_index
), m_domain (domain
),
5676 m_addr (find_vec_in_debug_names (map
, name
))
5679 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5680 search_domain search
, uint32_t namei
)
5683 m_addr (find_vec_in_debug_names (map
, namei
))
5686 /* Return the next matching CU or NULL if there are no more. */
5687 dwarf2_per_cu_data
*next ();
5690 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5692 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5695 /* The internalized form of .debug_names. */
5696 const mapped_debug_names
&m_map
;
5698 /* If true, only look for symbols that match BLOCK_INDEX. */
5699 const bool m_want_specific_block
= false;
5701 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
5702 Unused if !WANT_SPECIFIC_BLOCK - FIRST_LOCAL_BLOCK is an invalid
5704 const block_enum m_block_index
= FIRST_LOCAL_BLOCK
;
5706 /* The kind of symbol we're looking for. */
5707 const domain_enum m_domain
= UNDEF_DOMAIN
;
5708 const search_domain m_search
= ALL_DOMAIN
;
5710 /* The list of CUs from the index entry of the symbol, or NULL if
5712 const gdb_byte
*m_addr
;
5716 mapped_debug_names::namei_to_name (uint32_t namei
) const
5718 const ULONGEST namei_string_offs
5719 = extract_unsigned_integer ((name_table_string_offs_reordered
5720 + namei
* offset_size
),
5723 return read_indirect_string_at_offset
5724 (dwarf2_per_objfile
, dwarf2_per_objfile
->objfile
->obfd
, namei_string_offs
);
5727 /* Find a slot in .debug_names for the object named NAME. If NAME is
5728 found, return pointer to its pool data. If NAME cannot be found,
5732 dw2_debug_names_iterator::find_vec_in_debug_names
5733 (const mapped_debug_names
&map
, const char *name
)
5735 int (*cmp
) (const char *, const char *);
5737 if (current_language
->la_language
== language_cplus
5738 || current_language
->la_language
== language_fortran
5739 || current_language
->la_language
== language_d
)
5741 /* NAME is already canonical. Drop any qualifiers as
5742 .debug_names does not contain any. */
5744 if (strchr (name
, '(') != NULL
)
5746 gdb::unique_xmalloc_ptr
<char> without_params
5747 = cp_remove_params (name
);
5749 if (without_params
!= NULL
)
5751 name
= without_params
.get();
5756 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
5758 const uint32_t full_hash
= dwarf5_djb_hash (name
);
5760 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5761 (map
.bucket_table_reordered
5762 + (full_hash
% map
.bucket_count
)), 4,
5763 map
.dwarf5_byte_order
);
5767 if (namei
>= map
.name_count
)
5769 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5771 namei
, map
.name_count
,
5772 objfile_name (map
.dwarf2_per_objfile
->objfile
));
5778 const uint32_t namei_full_hash
5779 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5780 (map
.hash_table_reordered
+ namei
), 4,
5781 map
.dwarf5_byte_order
);
5782 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
5785 if (full_hash
== namei_full_hash
)
5787 const char *const namei_string
= map
.namei_to_name (namei
);
5789 #if 0 /* An expensive sanity check. */
5790 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
5792 complaint (_("Wrong .debug_names hash for string at index %u "
5794 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
5799 if (cmp (namei_string
, name
) == 0)
5801 const ULONGEST namei_entry_offs
5802 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5803 + namei
* map
.offset_size
),
5804 map
.offset_size
, map
.dwarf5_byte_order
);
5805 return map
.entry_pool
+ namei_entry_offs
;
5810 if (namei
>= map
.name_count
)
5816 dw2_debug_names_iterator::find_vec_in_debug_names
5817 (const mapped_debug_names
&map
, uint32_t namei
)
5819 if (namei
>= map
.name_count
)
5821 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5823 namei
, map
.name_count
,
5824 objfile_name (map
.dwarf2_per_objfile
->objfile
));
5828 const ULONGEST namei_entry_offs
5829 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5830 + namei
* map
.offset_size
),
5831 map
.offset_size
, map
.dwarf5_byte_order
);
5832 return map
.entry_pool
+ namei_entry_offs
;
5835 /* See dw2_debug_names_iterator. */
5837 dwarf2_per_cu_data
*
5838 dw2_debug_names_iterator::next ()
5843 struct dwarf2_per_objfile
*dwarf2_per_objfile
= m_map
.dwarf2_per_objfile
;
5844 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5845 bfd
*const abfd
= objfile
->obfd
;
5849 unsigned int bytes_read
;
5850 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5851 m_addr
+= bytes_read
;
5855 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5856 if (indexval_it
== m_map
.abbrev_map
.cend ())
5858 complaint (_("Wrong .debug_names undefined abbrev code %s "
5860 pulongest (abbrev
), objfile_name (objfile
));
5863 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5864 bool have_is_static
= false;
5866 dwarf2_per_cu_data
*per_cu
= NULL
;
5867 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5872 case DW_FORM_implicit_const
:
5873 ull
= attr
.implicit_const
;
5875 case DW_FORM_flag_present
:
5879 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5880 m_addr
+= bytes_read
;
5883 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5884 dwarf_form_name (attr
.form
),
5885 objfile_name (objfile
));
5888 switch (attr
.dw_idx
)
5890 case DW_IDX_compile_unit
:
5891 /* Don't crash on bad data. */
5892 if (ull
>= dwarf2_per_objfile
->all_comp_units
.size ())
5894 complaint (_(".debug_names entry has bad CU index %s"
5897 objfile_name (dwarf2_per_objfile
->objfile
));
5900 per_cu
= dwarf2_per_objfile
->get_cutu (ull
);
5902 case DW_IDX_type_unit
:
5903 /* Don't crash on bad data. */
5904 if (ull
>= dwarf2_per_objfile
->all_type_units
.size ())
5906 complaint (_(".debug_names entry has bad TU index %s"
5909 objfile_name (dwarf2_per_objfile
->objfile
));
5912 per_cu
= &dwarf2_per_objfile
->get_tu (ull
)->per_cu
;
5914 case DW_IDX_GNU_internal
:
5915 if (!m_map
.augmentation_is_gdb
)
5917 have_is_static
= true;
5920 case DW_IDX_GNU_external
:
5921 if (!m_map
.augmentation_is_gdb
)
5923 have_is_static
= true;
5929 /* Skip if already read in. */
5930 if (per_cu
->v
.quick
->compunit_symtab
)
5933 /* Check static vs global. */
5936 const bool want_static
= m_block_index
!= GLOBAL_BLOCK
;
5937 if (m_want_specific_block
&& want_static
!= is_static
)
5941 /* Match dw2_symtab_iter_next, symbol_kind
5942 and debug_names::psymbol_tag. */
5946 switch (indexval
.dwarf_tag
)
5948 case DW_TAG_variable
:
5949 case DW_TAG_subprogram
:
5950 /* Some types are also in VAR_DOMAIN. */
5951 case DW_TAG_typedef
:
5952 case DW_TAG_structure_type
:
5959 switch (indexval
.dwarf_tag
)
5961 case DW_TAG_typedef
:
5962 case DW_TAG_structure_type
:
5969 switch (indexval
.dwarf_tag
)
5972 case DW_TAG_variable
:
5982 /* Match dw2_expand_symtabs_matching, symbol_kind and
5983 debug_names::psymbol_tag. */
5986 case VARIABLES_DOMAIN
:
5987 switch (indexval
.dwarf_tag
)
5989 case DW_TAG_variable
:
5995 case FUNCTIONS_DOMAIN
:
5996 switch (indexval
.dwarf_tag
)
5998 case DW_TAG_subprogram
:
6005 switch (indexval
.dwarf_tag
)
6007 case DW_TAG_typedef
:
6008 case DW_TAG_structure_type
:
6021 static struct compunit_symtab
*
6022 dw2_debug_names_lookup_symbol (struct objfile
*objfile
, int block_index_int
,
6023 const char *name
, domain_enum domain
)
6025 const block_enum block_index
= static_cast<block_enum
> (block_index_int
);
6026 struct dwarf2_per_objfile
*dwarf2_per_objfile
6027 = get_dwarf2_per_objfile (objfile
);
6029 const auto &mapp
= dwarf2_per_objfile
->debug_names_table
;
6032 /* index is NULL if OBJF_READNOW. */
6035 const auto &map
= *mapp
;
6037 dw2_debug_names_iterator
iter (map
, true /* want_specific_block */,
6038 block_index
, domain
, name
);
6040 struct compunit_symtab
*stab_best
= NULL
;
6041 struct dwarf2_per_cu_data
*per_cu
;
6042 while ((per_cu
= iter
.next ()) != NULL
)
6044 struct symbol
*sym
, *with_opaque
= NULL
;
6045 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
, false);
6046 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
6047 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
6049 sym
= block_find_symbol (block
, name
, domain
,
6050 block_find_non_opaque_type_preferred
,
6053 /* Some caution must be observed with overloaded functions and
6054 methods, since the index will not contain any overload
6055 information (but NAME might contain it). */
6058 && strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
6060 if (with_opaque
!= NULL
6061 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque
), name
) == 0)
6064 /* Keep looking through other CUs. */
6070 /* This dumps minimal information about .debug_names. It is called
6071 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
6072 uses this to verify that .debug_names has been loaded. */
6075 dw2_debug_names_dump (struct objfile
*objfile
)
6077 struct dwarf2_per_objfile
*dwarf2_per_objfile
6078 = get_dwarf2_per_objfile (objfile
);
6080 gdb_assert (dwarf2_per_objfile
->using_index
);
6081 printf_filtered (".debug_names:");
6082 if (dwarf2_per_objfile
->debug_names_table
)
6083 printf_filtered (" exists\n");
6085 printf_filtered (" faked for \"readnow\"\n");
6086 printf_filtered ("\n");
6090 dw2_debug_names_expand_symtabs_for_function (struct objfile
*objfile
,
6091 const char *func_name
)
6093 struct dwarf2_per_objfile
*dwarf2_per_objfile
6094 = get_dwarf2_per_objfile (objfile
);
6096 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
6097 if (dwarf2_per_objfile
->debug_names_table
)
6099 const mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6101 /* Note: It doesn't matter what we pass for block_index here. */
6102 dw2_debug_names_iterator
iter (map
, false /* want_specific_block */,
6103 GLOBAL_BLOCK
, VAR_DOMAIN
, func_name
);
6105 struct dwarf2_per_cu_data
*per_cu
;
6106 while ((per_cu
= iter
.next ()) != NULL
)
6107 dw2_instantiate_symtab (per_cu
, false);
6112 dw2_debug_names_expand_symtabs_matching
6113 (struct objfile
*objfile
,
6114 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
6115 const lookup_name_info
&lookup_name
,
6116 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
6117 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
6118 enum search_domain kind
)
6120 struct dwarf2_per_objfile
*dwarf2_per_objfile
6121 = get_dwarf2_per_objfile (objfile
);
6123 /* debug_names_table is NULL if OBJF_READNOW. */
6124 if (!dwarf2_per_objfile
->debug_names_table
)
6127 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
6129 mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6131 dw2_expand_symtabs_matching_symbol (map
, lookup_name
,
6133 kind
, [&] (offset_type namei
)
6135 /* The name was matched, now expand corresponding CUs that were
6137 dw2_debug_names_iterator
iter (map
, kind
, namei
);
6139 struct dwarf2_per_cu_data
*per_cu
;
6140 while ((per_cu
= iter
.next ()) != NULL
)
6141 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
6146 const struct quick_symbol_functions dwarf2_debug_names_functions
=
6149 dw2_find_last_source_symtab
,
6150 dw2_forget_cached_source_info
,
6151 dw2_map_symtabs_matching_filename
,
6152 dw2_debug_names_lookup_symbol
,
6154 dw2_debug_names_dump
,
6155 dw2_debug_names_expand_symtabs_for_function
,
6156 dw2_expand_all_symtabs
,
6157 dw2_expand_symtabs_with_fullname
,
6158 dw2_map_matching_symbols
,
6159 dw2_debug_names_expand_symtabs_matching
,
6160 dw2_find_pc_sect_compunit_symtab
,
6162 dw2_map_symbol_filenames
6165 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
6166 to either a dwarf2_per_objfile or dwz_file object. */
6168 template <typename T
>
6169 static gdb::array_view
<const gdb_byte
>
6170 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
6172 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
6174 if (dwarf2_section_empty_p (section
))
6177 /* Older elfutils strip versions could keep the section in the main
6178 executable while splitting it for the separate debug info file. */
6179 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
6182 dwarf2_read_section (obj
, section
);
6184 /* dwarf2_section_info::size is a bfd_size_type, while
6185 gdb::array_view works with size_t. On 32-bit hosts, with
6186 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6187 is 32-bit. So we need an explicit narrowing conversion here.
6188 This is fine, because it's impossible to allocate or mmap an
6189 array/buffer larger than what size_t can represent. */
6190 return gdb::make_array_view (section
->buffer
, section
->size
);
6193 /* Lookup the index cache for the contents of the index associated to
6196 static gdb::array_view
<const gdb_byte
>
6197 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_objfile
*dwarf2_obj
)
6199 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
6200 if (build_id
== nullptr)
6203 return global_index_cache
.lookup_gdb_index (build_id
,
6204 &dwarf2_obj
->index_cache_res
);
6207 /* Same as the above, but for DWZ. */
6209 static gdb::array_view
<const gdb_byte
>
6210 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
6212 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
6213 if (build_id
== nullptr)
6216 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
6219 /* See symfile.h. */
6222 dwarf2_initialize_objfile (struct objfile
*objfile
, dw_index_kind
*index_kind
)
6224 struct dwarf2_per_objfile
*dwarf2_per_objfile
6225 = get_dwarf2_per_objfile (objfile
);
6227 /* If we're about to read full symbols, don't bother with the
6228 indices. In this case we also don't care if some other debug
6229 format is making psymtabs, because they are all about to be
6231 if ((objfile
->flags
& OBJF_READNOW
))
6233 dwarf2_per_objfile
->using_index
= 1;
6234 create_all_comp_units (dwarf2_per_objfile
);
6235 create_all_type_units (dwarf2_per_objfile
);
6236 dwarf2_per_objfile
->quick_file_names_table
6237 = create_quick_file_names_table
6238 (dwarf2_per_objfile
->all_comp_units
.size ());
6240 for (int i
= 0; i
< (dwarf2_per_objfile
->all_comp_units
.size ()
6241 + dwarf2_per_objfile
->all_type_units
.size ()); ++i
)
6243 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
6245 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6246 struct dwarf2_per_cu_quick_data
);
6249 /* Return 1 so that gdb sees the "quick" functions. However,
6250 these functions will be no-ops because we will have expanded
6252 *index_kind
= dw_index_kind::GDB_INDEX
;
6256 if (dwarf2_read_debug_names (dwarf2_per_objfile
))
6258 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6262 if (dwarf2_read_gdb_index (dwarf2_per_objfile
,
6263 get_gdb_index_contents_from_section
<struct dwarf2_per_objfile
>,
6264 get_gdb_index_contents_from_section
<dwz_file
>))
6266 *index_kind
= dw_index_kind::GDB_INDEX
;
6270 /* ... otherwise, try to find the index in the index cache. */
6271 if (dwarf2_read_gdb_index (dwarf2_per_objfile
,
6272 get_gdb_index_contents_from_cache
,
6273 get_gdb_index_contents_from_cache_dwz
))
6275 global_index_cache
.hit ();
6276 *index_kind
= dw_index_kind::GDB_INDEX
;
6280 global_index_cache
.miss ();
6286 /* Build a partial symbol table. */
6289 dwarf2_build_psymtabs (struct objfile
*objfile
)
6291 struct dwarf2_per_objfile
*dwarf2_per_objfile
6292 = get_dwarf2_per_objfile (objfile
);
6294 init_psymbol_list (objfile
, 1024);
6298 /* This isn't really ideal: all the data we allocate on the
6299 objfile's obstack is still uselessly kept around. However,
6300 freeing it seems unsafe. */
6301 psymtab_discarder
psymtabs (objfile
);
6302 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
);
6305 /* (maybe) store an index in the cache. */
6306 global_index_cache
.store (dwarf2_per_objfile
);
6308 catch (const gdb_exception_error
&except
)
6310 exception_print (gdb_stderr
, except
);
6314 /* Return the total length of the CU described by HEADER. */
6317 get_cu_length (const struct comp_unit_head
*header
)
6319 return header
->initial_length_size
+ header
->length
;
6322 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6325 offset_in_cu_p (const comp_unit_head
*cu_header
, sect_offset sect_off
)
6327 sect_offset bottom
= cu_header
->sect_off
;
6328 sect_offset top
= cu_header
->sect_off
+ get_cu_length (cu_header
);
6330 return sect_off
>= bottom
&& sect_off
< top
;
6333 /* Find the base address of the compilation unit for range lists and
6334 location lists. It will normally be specified by DW_AT_low_pc.
6335 In DWARF-3 draft 4, the base address could be overridden by
6336 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6337 compilation units with discontinuous ranges. */
6340 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
6342 struct attribute
*attr
;
6345 cu
->base_address
= 0;
6347 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
6350 cu
->base_address
= attr_value_as_address (attr
);
6355 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6358 cu
->base_address
= attr_value_as_address (attr
);
6364 /* Read in the comp unit header information from the debug_info at info_ptr.
6365 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6366 NOTE: This leaves members offset, first_die_offset to be filled in
6369 static const gdb_byte
*
6370 read_comp_unit_head (struct comp_unit_head
*cu_header
,
6371 const gdb_byte
*info_ptr
,
6372 struct dwarf2_section_info
*section
,
6373 rcuh_kind section_kind
)
6376 unsigned int bytes_read
;
6377 const char *filename
= get_section_file_name (section
);
6378 bfd
*abfd
= get_section_bfd_owner (section
);
6380 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
6381 cu_header
->initial_length_size
= bytes_read
;
6382 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
6383 info_ptr
+= bytes_read
;
6384 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
6385 if (cu_header
->version
< 2 || cu_header
->version
> 5)
6386 error (_("Dwarf Error: wrong version in compilation unit header "
6387 "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6388 cu_header
->version
, filename
);
6390 if (cu_header
->version
< 5)
6391 switch (section_kind
)
6393 case rcuh_kind::COMPILE
:
6394 cu_header
->unit_type
= DW_UT_compile
;
6396 case rcuh_kind::TYPE
:
6397 cu_header
->unit_type
= DW_UT_type
;
6400 internal_error (__FILE__
, __LINE__
,
6401 _("read_comp_unit_head: invalid section_kind"));
6405 cu_header
->unit_type
= static_cast<enum dwarf_unit_type
>
6406 (read_1_byte (abfd
, info_ptr
));
6408 switch (cu_header
->unit_type
)
6411 if (section_kind
!= rcuh_kind::COMPILE
)
6412 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6413 "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6417 section_kind
= rcuh_kind::TYPE
;
6420 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6421 "(is %d, should be %d or %d) [in module %s]"),
6422 cu_header
->unit_type
, DW_UT_compile
, DW_UT_type
, filename
);
6425 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
6428 cu_header
->abbrev_sect_off
= (sect_offset
) read_offset (abfd
, info_ptr
,
6431 info_ptr
+= bytes_read
;
6432 if (cu_header
->version
< 5)
6434 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
6437 signed_addr
= bfd_get_sign_extend_vma (abfd
);
6438 if (signed_addr
< 0)
6439 internal_error (__FILE__
, __LINE__
,
6440 _("read_comp_unit_head: dwarf from non elf file"));
6441 cu_header
->signed_addr_p
= signed_addr
;
6443 if (section_kind
== rcuh_kind::TYPE
)
6445 LONGEST type_offset
;
6447 cu_header
->signature
= read_8_bytes (abfd
, info_ptr
);
6450 type_offset
= read_offset (abfd
, info_ptr
, cu_header
, &bytes_read
);
6451 info_ptr
+= bytes_read
;
6452 cu_header
->type_cu_offset_in_tu
= (cu_offset
) type_offset
;
6453 if (to_underlying (cu_header
->type_cu_offset_in_tu
) != type_offset
)
6454 error (_("Dwarf Error: Too big type_offset in compilation unit "
6455 "header (is %s) [in module %s]"), plongest (type_offset
),
6462 /* Helper function that returns the proper abbrev section for
6465 static struct dwarf2_section_info
*
6466 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
6468 struct dwarf2_section_info
*abbrev
;
6469 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
6471 if (this_cu
->is_dwz
)
6472 abbrev
= &dwarf2_get_dwz_file (dwarf2_per_objfile
)->abbrev
;
6474 abbrev
= &dwarf2_per_objfile
->abbrev
;
6479 /* Subroutine of read_and_check_comp_unit_head and
6480 read_and_check_type_unit_head to simplify them.
6481 Perform various error checking on the header. */
6484 error_check_comp_unit_head (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6485 struct comp_unit_head
*header
,
6486 struct dwarf2_section_info
*section
,
6487 struct dwarf2_section_info
*abbrev_section
)
6489 const char *filename
= get_section_file_name (section
);
6491 if (to_underlying (header
->abbrev_sect_off
)
6492 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
6493 error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6494 "(offset %s + 6) [in module %s]"),
6495 sect_offset_str (header
->abbrev_sect_off
),
6496 sect_offset_str (header
->sect_off
),
6499 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6500 avoid potential 32-bit overflow. */
6501 if (((ULONGEST
) header
->sect_off
+ get_cu_length (header
))
6503 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6504 "(offset %s + 0) [in module %s]"),
6505 header
->length
, sect_offset_str (header
->sect_off
),
6509 /* Read in a CU/TU header and perform some basic error checking.
6510 The contents of the header are stored in HEADER.
6511 The result is a pointer to the start of the first DIE. */
6513 static const gdb_byte
*
6514 read_and_check_comp_unit_head (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6515 struct comp_unit_head
*header
,
6516 struct dwarf2_section_info
*section
,
6517 struct dwarf2_section_info
*abbrev_section
,
6518 const gdb_byte
*info_ptr
,
6519 rcuh_kind section_kind
)
6521 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
6523 header
->sect_off
= (sect_offset
) (beg_of_comp_unit
- section
->buffer
);
6525 info_ptr
= read_comp_unit_head (header
, info_ptr
, section
, section_kind
);
6527 header
->first_die_cu_offset
= (cu_offset
) (info_ptr
- beg_of_comp_unit
);
6529 error_check_comp_unit_head (dwarf2_per_objfile
, header
, section
,
6535 /* Fetch the abbreviation table offset from a comp or type unit header. */
6538 read_abbrev_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6539 struct dwarf2_section_info
*section
,
6540 sect_offset sect_off
)
6542 bfd
*abfd
= get_section_bfd_owner (section
);
6543 const gdb_byte
*info_ptr
;
6544 unsigned int initial_length_size
, offset_size
;
6547 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
6548 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
6549 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6550 offset_size
= initial_length_size
== 4 ? 4 : 8;
6551 info_ptr
+= initial_length_size
;
6553 version
= read_2_bytes (abfd
, info_ptr
);
6557 /* Skip unit type and address size. */
6561 return (sect_offset
) read_offset_1 (abfd
, info_ptr
, offset_size
);
6564 /* Allocate a new partial symtab for file named NAME and mark this new
6565 partial symtab as being an include of PST. */
6568 dwarf2_create_include_psymtab (const char *name
, struct partial_symtab
*pst
,
6569 struct objfile
*objfile
)
6571 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
6573 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
6575 /* It shares objfile->objfile_obstack. */
6576 subpst
->dirname
= pst
->dirname
;
6579 subpst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (1);
6580 subpst
->dependencies
[0] = pst
;
6581 subpst
->number_of_dependencies
= 1;
6583 subpst
->read_symtab
= pst
->read_symtab
;
6585 /* No private part is necessary for include psymtabs. This property
6586 can be used to differentiate between such include psymtabs and
6587 the regular ones. */
6588 subpst
->read_symtab_private
= NULL
;
6591 /* Read the Line Number Program data and extract the list of files
6592 included by the source file represented by PST. Build an include
6593 partial symtab for each of these included files. */
6596 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
6597 struct die_info
*die
,
6598 struct partial_symtab
*pst
)
6601 struct attribute
*attr
;
6603 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6605 lh
= dwarf_decode_line_header ((sect_offset
) DW_UNSND (attr
), cu
);
6607 return; /* No linetable, so no includes. */
6609 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6610 that we pass in the raw text_low here; that is ok because we're
6611 only decoding the line table to make include partial symtabs, and
6612 so the addresses aren't really used. */
6613 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
6614 pst
->raw_text_low (), 1);
6618 hash_signatured_type (const void *item
)
6620 const struct signatured_type
*sig_type
6621 = (const struct signatured_type
*) item
;
6623 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6624 return sig_type
->signature
;
6628 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6630 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6631 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6633 return lhs
->signature
== rhs
->signature
;
6636 /* Allocate a hash table for signatured types. */
6639 allocate_signatured_type_table (struct objfile
*objfile
)
6641 return htab_create_alloc_ex (41,
6642 hash_signatured_type
,
6645 &objfile
->objfile_obstack
,
6646 hashtab_obstack_allocate
,
6647 dummy_obstack_deallocate
);
6650 /* A helper function to add a signatured type CU to a table. */
6653 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6655 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6656 std::vector
<signatured_type
*> *all_type_units
6657 = (std::vector
<signatured_type
*> *) datum
;
6659 all_type_units
->push_back (sigt
);
6664 /* A helper for create_debug_types_hash_table. Read types from SECTION
6665 and fill them into TYPES_HTAB. It will process only type units,
6666 therefore DW_UT_type. */
6669 create_debug_type_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6670 struct dwo_file
*dwo_file
,
6671 dwarf2_section_info
*section
, htab_t
&types_htab
,
6672 rcuh_kind section_kind
)
6674 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6675 struct dwarf2_section_info
*abbrev_section
;
6677 const gdb_byte
*info_ptr
, *end_ptr
;
6679 abbrev_section
= (dwo_file
!= NULL
6680 ? &dwo_file
->sections
.abbrev
6681 : &dwarf2_per_objfile
->abbrev
);
6683 if (dwarf_read_debug
)
6684 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
6685 get_section_name (section
),
6686 get_section_file_name (abbrev_section
));
6688 dwarf2_read_section (objfile
, section
);
6689 info_ptr
= section
->buffer
;
6691 if (info_ptr
== NULL
)
6694 /* We can't set abfd until now because the section may be empty or
6695 not present, in which case the bfd is unknown. */
6696 abfd
= get_section_bfd_owner (section
);
6698 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6699 because we don't need to read any dies: the signature is in the
6702 end_ptr
= info_ptr
+ section
->size
;
6703 while (info_ptr
< end_ptr
)
6705 struct signatured_type
*sig_type
;
6706 struct dwo_unit
*dwo_tu
;
6708 const gdb_byte
*ptr
= info_ptr
;
6709 struct comp_unit_head header
;
6710 unsigned int length
;
6712 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
6714 /* Initialize it due to a false compiler warning. */
6715 header
.signature
= -1;
6716 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
6718 /* We need to read the type's signature in order to build the hash
6719 table, but we don't need anything else just yet. */
6721 ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
, &header
, section
,
6722 abbrev_section
, ptr
, section_kind
);
6724 length
= get_cu_length (&header
);
6726 /* Skip dummy type units. */
6727 if (ptr
>= info_ptr
+ length
6728 || peek_abbrev_code (abfd
, ptr
) == 0
6729 || header
.unit_type
!= DW_UT_type
)
6735 if (types_htab
== NULL
)
6738 types_htab
= allocate_dwo_unit_table (objfile
);
6740 types_htab
= allocate_signatured_type_table (objfile
);
6746 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6748 dwo_tu
->dwo_file
= dwo_file
;
6749 dwo_tu
->signature
= header
.signature
;
6750 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6751 dwo_tu
->section
= section
;
6752 dwo_tu
->sect_off
= sect_off
;
6753 dwo_tu
->length
= length
;
6757 /* N.B.: type_offset is not usable if this type uses a DWO file.
6758 The real type_offset is in the DWO file. */
6760 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6761 struct signatured_type
);
6762 sig_type
->signature
= header
.signature
;
6763 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6764 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
6765 sig_type
->per_cu
.is_debug_types
= 1;
6766 sig_type
->per_cu
.section
= section
;
6767 sig_type
->per_cu
.sect_off
= sect_off
;
6768 sig_type
->per_cu
.length
= length
;
6771 slot
= htab_find_slot (types_htab
,
6772 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
6774 gdb_assert (slot
!= NULL
);
6777 sect_offset dup_sect_off
;
6781 const struct dwo_unit
*dup_tu
6782 = (const struct dwo_unit
*) *slot
;
6784 dup_sect_off
= dup_tu
->sect_off
;
6788 const struct signatured_type
*dup_tu
6789 = (const struct signatured_type
*) *slot
;
6791 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
6794 complaint (_("debug type entry at offset %s is duplicate to"
6795 " the entry at offset %s, signature %s"),
6796 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
6797 hex_string (header
.signature
));
6799 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
6801 if (dwarf_read_debug
> 1)
6802 fprintf_unfiltered (gdb_stdlog
, " offset %s, signature %s\n",
6803 sect_offset_str (sect_off
),
6804 hex_string (header
.signature
));
6810 /* Create the hash table of all entries in the .debug_types
6811 (or .debug_types.dwo) section(s).
6812 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6813 otherwise it is NULL.
6815 The result is a pointer to the hash table or NULL if there are no types.
6817 Note: This function processes DWO files only, not DWP files. */
6820 create_debug_types_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6821 struct dwo_file
*dwo_file
,
6822 VEC (dwarf2_section_info_def
) *types
,
6826 struct dwarf2_section_info
*section
;
6828 if (VEC_empty (dwarf2_section_info_def
, types
))
6832 VEC_iterate (dwarf2_section_info_def
, types
, ix
, section
);
6834 create_debug_type_hash_table (dwarf2_per_objfile
, dwo_file
, section
,
6835 types_htab
, rcuh_kind::TYPE
);
6838 /* Create the hash table of all entries in the .debug_types section,
6839 and initialize all_type_units.
6840 The result is zero if there is an error (e.g. missing .debug_types section),
6841 otherwise non-zero. */
6844 create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
6846 htab_t types_htab
= NULL
;
6848 create_debug_type_hash_table (dwarf2_per_objfile
, NULL
,
6849 &dwarf2_per_objfile
->info
, types_htab
,
6850 rcuh_kind::COMPILE
);
6851 create_debug_types_hash_table (dwarf2_per_objfile
, NULL
,
6852 dwarf2_per_objfile
->types
, types_htab
);
6853 if (types_htab
== NULL
)
6855 dwarf2_per_objfile
->signatured_types
= NULL
;
6859 dwarf2_per_objfile
->signatured_types
= types_htab
;
6861 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
6862 dwarf2_per_objfile
->all_type_units
.reserve (htab_elements (types_htab
));
6864 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
,
6865 &dwarf2_per_objfile
->all_type_units
);
6870 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6871 If SLOT is non-NULL, it is the entry to use in the hash table.
6872 Otherwise we find one. */
6874 static struct signatured_type
*
6875 add_type_unit (struct dwarf2_per_objfile
*dwarf2_per_objfile
, ULONGEST sig
,
6878 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6880 if (dwarf2_per_objfile
->all_type_units
.size ()
6881 == dwarf2_per_objfile
->all_type_units
.capacity ())
6882 ++dwarf2_per_objfile
->tu_stats
.nr_all_type_units_reallocs
;
6884 signatured_type
*sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6885 struct signatured_type
);
6887 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
6888 sig_type
->signature
= sig
;
6889 sig_type
->per_cu
.is_debug_types
= 1;
6890 if (dwarf2_per_objfile
->using_index
)
6892 sig_type
->per_cu
.v
.quick
=
6893 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6894 struct dwarf2_per_cu_quick_data
);
6899 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
6902 gdb_assert (*slot
== NULL
);
6904 /* The rest of sig_type must be filled in by the caller. */
6908 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6909 Fill in SIG_ENTRY with DWO_ENTRY. */
6912 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6913 struct signatured_type
*sig_entry
,
6914 struct dwo_unit
*dwo_entry
)
6916 /* Make sure we're not clobbering something we don't expect to. */
6917 gdb_assert (! sig_entry
->per_cu
.queued
);
6918 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
6919 if (dwarf2_per_objfile
->using_index
)
6921 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
6922 gdb_assert (sig_entry
->per_cu
.v
.quick
->compunit_symtab
== NULL
);
6925 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
6926 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
6927 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
6928 gdb_assert (sig_entry
->type_unit_group
== NULL
);
6929 gdb_assert (sig_entry
->dwo_unit
== NULL
);
6931 sig_entry
->per_cu
.section
= dwo_entry
->section
;
6932 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
6933 sig_entry
->per_cu
.length
= dwo_entry
->length
;
6934 sig_entry
->per_cu
.reading_dwo_directly
= 1;
6935 sig_entry
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
6936 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
6937 sig_entry
->dwo_unit
= dwo_entry
;
6940 /* Subroutine of lookup_signatured_type.
6941 If we haven't read the TU yet, create the signatured_type data structure
6942 for a TU to be read in directly from a DWO file, bypassing the stub.
6943 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6944 using .gdb_index, then when reading a CU we want to stay in the DWO file
6945 containing that CU. Otherwise we could end up reading several other DWO
6946 files (due to comdat folding) to process the transitive closure of all the
6947 mentioned TUs, and that can be slow. The current DWO file will have every
6948 type signature that it needs.
6949 We only do this for .gdb_index because in the psymtab case we already have
6950 to read all the DWOs to build the type unit groups. */
6952 static struct signatured_type
*
6953 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6955 struct dwarf2_per_objfile
*dwarf2_per_objfile
6956 = cu
->per_cu
->dwarf2_per_objfile
;
6957 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6958 struct dwo_file
*dwo_file
;
6959 struct dwo_unit find_dwo_entry
, *dwo_entry
;
6960 struct signatured_type find_sig_entry
, *sig_entry
;
6963 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
6965 /* If TU skeletons have been removed then we may not have read in any
6967 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6969 dwarf2_per_objfile
->signatured_types
6970 = allocate_signatured_type_table (objfile
);
6973 /* We only ever need to read in one copy of a signatured type.
6974 Use the global signatured_types array to do our own comdat-folding
6975 of types. If this is the first time we're reading this TU, and
6976 the TU has an entry in .gdb_index, replace the recorded data from
6977 .gdb_index with this TU. */
6979 find_sig_entry
.signature
= sig
;
6980 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
6981 &find_sig_entry
, INSERT
);
6982 sig_entry
= (struct signatured_type
*) *slot
;
6984 /* We can get here with the TU already read, *or* in the process of being
6985 read. Don't reassign the global entry to point to this DWO if that's
6986 the case. Also note that if the TU is already being read, it may not
6987 have come from a DWO, the program may be a mix of Fission-compiled
6988 code and non-Fission-compiled code. */
6990 /* Have we already tried to read this TU?
6991 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6992 needn't exist in the global table yet). */
6993 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
6996 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6997 dwo_unit of the TU itself. */
6998 dwo_file
= cu
->dwo_unit
->dwo_file
;
7000 /* Ok, this is the first time we're reading this TU. */
7001 if (dwo_file
->tus
== NULL
)
7003 find_dwo_entry
.signature
= sig
;
7004 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_entry
);
7005 if (dwo_entry
== NULL
)
7008 /* If the global table doesn't have an entry for this TU, add one. */
7009 if (sig_entry
== NULL
)
7010 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
7012 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
7013 sig_entry
->per_cu
.tu_read
= 1;
7017 /* Subroutine of lookup_signatured_type.
7018 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7019 then try the DWP file. If the TU stub (skeleton) has been removed then
7020 it won't be in .gdb_index. */
7022 static struct signatured_type
*
7023 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7025 struct dwarf2_per_objfile
*dwarf2_per_objfile
7026 = cu
->per_cu
->dwarf2_per_objfile
;
7027 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7028 struct dwp_file
*dwp_file
= get_dwp_file (dwarf2_per_objfile
);
7029 struct dwo_unit
*dwo_entry
;
7030 struct signatured_type find_sig_entry
, *sig_entry
;
7033 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
7034 gdb_assert (dwp_file
!= NULL
);
7036 /* If TU skeletons have been removed then we may not have read in any
7038 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7040 dwarf2_per_objfile
->signatured_types
7041 = allocate_signatured_type_table (objfile
);
7044 find_sig_entry
.signature
= sig
;
7045 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
7046 &find_sig_entry
, INSERT
);
7047 sig_entry
= (struct signatured_type
*) *slot
;
7049 /* Have we already tried to read this TU?
7050 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7051 needn't exist in the global table yet). */
7052 if (sig_entry
!= NULL
)
7055 if (dwp_file
->tus
== NULL
)
7057 dwo_entry
= lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, NULL
,
7058 sig
, 1 /* is_debug_types */);
7059 if (dwo_entry
== NULL
)
7062 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
7063 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
7068 /* Lookup a signature based type for DW_FORM_ref_sig8.
7069 Returns NULL if signature SIG is not present in the table.
7070 It is up to the caller to complain about this. */
7072 static struct signatured_type
*
7073 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7075 struct dwarf2_per_objfile
*dwarf2_per_objfile
7076 = cu
->per_cu
->dwarf2_per_objfile
;
7079 && dwarf2_per_objfile
->using_index
)
7081 /* We're in a DWO/DWP file, and we're using .gdb_index.
7082 These cases require special processing. */
7083 if (get_dwp_file (dwarf2_per_objfile
) == NULL
)
7084 return lookup_dwo_signatured_type (cu
, sig
);
7086 return lookup_dwp_signatured_type (cu
, sig
);
7090 struct signatured_type find_entry
, *entry
;
7092 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7094 find_entry
.signature
= sig
;
7095 entry
= ((struct signatured_type
*)
7096 htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
));
7101 /* Low level DIE reading support. */
7103 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7106 init_cu_die_reader (struct die_reader_specs
*reader
,
7107 struct dwarf2_cu
*cu
,
7108 struct dwarf2_section_info
*section
,
7109 struct dwo_file
*dwo_file
,
7110 struct abbrev_table
*abbrev_table
)
7112 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
7113 reader
->abfd
= get_section_bfd_owner (section
);
7115 reader
->dwo_file
= dwo_file
;
7116 reader
->die_section
= section
;
7117 reader
->buffer
= section
->buffer
;
7118 reader
->buffer_end
= section
->buffer
+ section
->size
;
7119 reader
->comp_dir
= NULL
;
7120 reader
->abbrev_table
= abbrev_table
;
7123 /* Subroutine of init_cutu_and_read_dies to simplify it.
7124 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7125 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7128 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7129 from it to the DIE in the DWO. If NULL we are skipping the stub.
7130 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7131 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7132 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7133 STUB_COMP_DIR may be non-NULL.
7134 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7135 are filled in with the info of the DIE from the DWO file.
7136 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7137 from the dwo. Since *RESULT_READER references this abbrev table, it must be
7138 kept around for at least as long as *RESULT_READER.
7140 The result is non-zero if a valid (non-dummy) DIE was found. */
7143 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
7144 struct dwo_unit
*dwo_unit
,
7145 struct die_info
*stub_comp_unit_die
,
7146 const char *stub_comp_dir
,
7147 struct die_reader_specs
*result_reader
,
7148 const gdb_byte
**result_info_ptr
,
7149 struct die_info
**result_comp_unit_die
,
7150 int *result_has_children
,
7151 abbrev_table_up
*result_dwo_abbrev_table
)
7153 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7154 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7155 struct dwarf2_cu
*cu
= this_cu
->cu
;
7157 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7158 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
7159 int i
,num_extra_attrs
;
7160 struct dwarf2_section_info
*dwo_abbrev_section
;
7161 struct attribute
*attr
;
7162 struct die_info
*comp_unit_die
;
7164 /* At most one of these may be provided. */
7165 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
7167 /* These attributes aren't processed until later:
7168 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7169 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7170 referenced later. However, these attributes are found in the stub
7171 which we won't have later. In order to not impose this complication
7172 on the rest of the code, we read them here and copy them to the
7181 if (stub_comp_unit_die
!= NULL
)
7183 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7185 if (! this_cu
->is_debug_types
)
7186 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
7187 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
7188 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
7189 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
7190 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
7192 /* There should be a DW_AT_addr_base attribute here (if needed).
7193 We need the value before we can process DW_FORM_GNU_addr_index
7194 or DW_FORM_addrx. */
7196 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
7198 cu
->addr_base
= DW_UNSND (attr
);
7200 /* There should be a DW_AT_ranges_base attribute here (if needed).
7201 We need the value before we can process DW_AT_ranges. */
7202 cu
->ranges_base
= 0;
7203 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
7205 cu
->ranges_base
= DW_UNSND (attr
);
7207 else if (stub_comp_dir
!= NULL
)
7209 /* Reconstruct the comp_dir attribute to simplify the code below. */
7210 comp_dir
= XOBNEW (&cu
->comp_unit_obstack
, struct attribute
);
7211 comp_dir
->name
= DW_AT_comp_dir
;
7212 comp_dir
->form
= DW_FORM_string
;
7213 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
7214 DW_STRING (comp_dir
) = stub_comp_dir
;
7217 /* Set up for reading the DWO CU/TU. */
7218 cu
->dwo_unit
= dwo_unit
;
7219 dwarf2_section_info
*section
= dwo_unit
->section
;
7220 dwarf2_read_section (objfile
, section
);
7221 abfd
= get_section_bfd_owner (section
);
7222 begin_info_ptr
= info_ptr
= (section
->buffer
7223 + to_underlying (dwo_unit
->sect_off
));
7224 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
7226 if (this_cu
->is_debug_types
)
7228 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
7230 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7231 &cu
->header
, section
,
7233 info_ptr
, rcuh_kind::TYPE
);
7234 /* This is not an assert because it can be caused by bad debug info. */
7235 if (sig_type
->signature
!= cu
->header
.signature
)
7237 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7238 " TU at offset %s [in module %s]"),
7239 hex_string (sig_type
->signature
),
7240 hex_string (cu
->header
.signature
),
7241 sect_offset_str (dwo_unit
->sect_off
),
7242 bfd_get_filename (abfd
));
7244 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7245 /* For DWOs coming from DWP files, we don't know the CU length
7246 nor the type's offset in the TU until now. */
7247 dwo_unit
->length
= get_cu_length (&cu
->header
);
7248 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
7250 /* Establish the type offset that can be used to lookup the type.
7251 For DWO files, we don't know it until now. */
7252 sig_type
->type_offset_in_section
7253 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
7257 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7258 &cu
->header
, section
,
7260 info_ptr
, rcuh_kind::COMPILE
);
7261 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7262 /* For DWOs coming from DWP files, we don't know the CU length
7264 dwo_unit
->length
= get_cu_length (&cu
->header
);
7267 *result_dwo_abbrev_table
7268 = abbrev_table_read_table (dwarf2_per_objfile
, dwo_abbrev_section
,
7269 cu
->header
.abbrev_sect_off
);
7270 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
7271 result_dwo_abbrev_table
->get ());
7273 /* Read in the die, but leave space to copy over the attributes
7274 from the stub. This has the benefit of simplifying the rest of
7275 the code - all the work to maintain the illusion of a single
7276 DW_TAG_{compile,type}_unit DIE is done here. */
7277 num_extra_attrs
= ((stmt_list
!= NULL
)
7281 + (comp_dir
!= NULL
));
7282 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
7283 result_has_children
, num_extra_attrs
);
7285 /* Copy over the attributes from the stub to the DIE we just read in. */
7286 comp_unit_die
= *result_comp_unit_die
;
7287 i
= comp_unit_die
->num_attrs
;
7288 if (stmt_list
!= NULL
)
7289 comp_unit_die
->attrs
[i
++] = *stmt_list
;
7291 comp_unit_die
->attrs
[i
++] = *low_pc
;
7292 if (high_pc
!= NULL
)
7293 comp_unit_die
->attrs
[i
++] = *high_pc
;
7295 comp_unit_die
->attrs
[i
++] = *ranges
;
7296 if (comp_dir
!= NULL
)
7297 comp_unit_die
->attrs
[i
++] = *comp_dir
;
7298 comp_unit_die
->num_attrs
+= num_extra_attrs
;
7300 if (dwarf_die_debug
)
7302 fprintf_unfiltered (gdb_stdlog
,
7303 "Read die from %s@0x%x of %s:\n",
7304 get_section_name (section
),
7305 (unsigned) (begin_info_ptr
- section
->buffer
),
7306 bfd_get_filename (abfd
));
7307 dump_die (comp_unit_die
, dwarf_die_debug
);
7310 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7311 TUs by skipping the stub and going directly to the entry in the DWO file.
7312 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7313 to get it via circuitous means. Blech. */
7314 if (comp_dir
!= NULL
)
7315 result_reader
->comp_dir
= DW_STRING (comp_dir
);
7317 /* Skip dummy compilation units. */
7318 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
7319 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7322 *result_info_ptr
= info_ptr
;
7326 /* Subroutine of init_cutu_and_read_dies to simplify it.
7327 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7328 Returns NULL if the specified DWO unit cannot be found. */
7330 static struct dwo_unit
*
7331 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
7332 struct die_info
*comp_unit_die
)
7334 struct dwarf2_cu
*cu
= this_cu
->cu
;
7336 struct dwo_unit
*dwo_unit
;
7337 const char *comp_dir
, *dwo_name
;
7339 gdb_assert (cu
!= NULL
);
7341 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7342 dwo_name
= dwarf2_string_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
7343 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7345 if (this_cu
->is_debug_types
)
7347 struct signatured_type
*sig_type
;
7349 /* Since this_cu is the first member of struct signatured_type,
7350 we can go from a pointer to one to a pointer to the other. */
7351 sig_type
= (struct signatured_type
*) this_cu
;
7352 signature
= sig_type
->signature
;
7353 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
7357 struct attribute
*attr
;
7359 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
7361 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7363 dwo_name
, objfile_name (this_cu
->dwarf2_per_objfile
->objfile
));
7364 signature
= DW_UNSND (attr
);
7365 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
7372 /* Subroutine of init_cutu_and_read_dies to simplify it.
7373 See it for a description of the parameters.
7374 Read a TU directly from a DWO file, bypassing the stub. */
7377 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
7378 int use_existing_cu
, int keep
,
7379 die_reader_func_ftype
*die_reader_func
,
7382 std::unique_ptr
<dwarf2_cu
> new_cu
;
7383 struct signatured_type
*sig_type
;
7384 struct die_reader_specs reader
;
7385 const gdb_byte
*info_ptr
;
7386 struct die_info
*comp_unit_die
;
7388 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7390 /* Verify we can do the following downcast, and that we have the
7392 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
7393 sig_type
= (struct signatured_type
*) this_cu
;
7394 gdb_assert (sig_type
->dwo_unit
!= NULL
);
7396 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
7398 gdb_assert (this_cu
->cu
->dwo_unit
== sig_type
->dwo_unit
);
7399 /* There's no need to do the rereading_dwo_cu handling that
7400 init_cutu_and_read_dies does since we don't read the stub. */
7404 /* If !use_existing_cu, this_cu->cu must be NULL. */
7405 gdb_assert (this_cu
->cu
== NULL
);
7406 new_cu
.reset (new dwarf2_cu (this_cu
));
7409 /* A future optimization, if needed, would be to use an existing
7410 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7411 could share abbrev tables. */
7413 /* The abbreviation table used by READER, this must live at least as long as
7415 abbrev_table_up dwo_abbrev_table
;
7417 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
7418 NULL
/* stub_comp_unit_die */,
7419 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
7421 &comp_unit_die
, &has_children
,
7422 &dwo_abbrev_table
) == 0)
7428 /* All the "real" work is done here. */
7429 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7431 /* This duplicates the code in init_cutu_and_read_dies,
7432 but the alternative is making the latter more complex.
7433 This function is only for the special case of using DWO files directly:
7434 no point in overly complicating the general case just to handle this. */
7435 if (new_cu
!= NULL
&& keep
)
7437 /* Link this CU into read_in_chain. */
7438 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
7439 dwarf2_per_objfile
->read_in_chain
= this_cu
;
7440 /* The chain owns it now. */
7445 /* Initialize a CU (or TU) and read its DIEs.
7446 If the CU defers to a DWO file, read the DWO file as well.
7448 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7449 Otherwise the table specified in the comp unit header is read in and used.
7450 This is an optimization for when we already have the abbrev table.
7452 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7453 Otherwise, a new CU is allocated with xmalloc.
7455 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7456 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7458 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7459 linker) then DIE_READER_FUNC will not get called. */
7462 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
7463 struct abbrev_table
*abbrev_table
,
7464 int use_existing_cu
, int keep
,
7466 die_reader_func_ftype
*die_reader_func
,
7469 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7470 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7471 struct dwarf2_section_info
*section
= this_cu
->section
;
7472 bfd
*abfd
= get_section_bfd_owner (section
);
7473 struct dwarf2_cu
*cu
;
7474 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7475 struct die_reader_specs reader
;
7476 struct die_info
*comp_unit_die
;
7478 struct attribute
*attr
;
7479 struct signatured_type
*sig_type
= NULL
;
7480 struct dwarf2_section_info
*abbrev_section
;
7481 /* Non-zero if CU currently points to a DWO file and we need to
7482 reread it. When this happens we need to reread the skeleton die
7483 before we can reread the DWO file (this only applies to CUs, not TUs). */
7484 int rereading_dwo_cu
= 0;
7486 if (dwarf_die_debug
)
7487 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7488 this_cu
->is_debug_types
? "type" : "comp",
7489 sect_offset_str (this_cu
->sect_off
));
7491 if (use_existing_cu
)
7494 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7495 file (instead of going through the stub), short-circuit all of this. */
7496 if (this_cu
->reading_dwo_directly
)
7498 /* Narrow down the scope of possibilities to have to understand. */
7499 gdb_assert (this_cu
->is_debug_types
);
7500 gdb_assert (abbrev_table
== NULL
);
7501 init_tu_and_read_dwo_dies (this_cu
, use_existing_cu
, keep
,
7502 die_reader_func
, data
);
7506 /* This is cheap if the section is already read in. */
7507 dwarf2_read_section (objfile
, section
);
7509 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7511 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
7513 std::unique_ptr
<dwarf2_cu
> new_cu
;
7514 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
7517 /* If this CU is from a DWO file we need to start over, we need to
7518 refetch the attributes from the skeleton CU.
7519 This could be optimized by retrieving those attributes from when we
7520 were here the first time: the previous comp_unit_die was stored in
7521 comp_unit_obstack. But there's no data yet that we need this
7523 if (cu
->dwo_unit
!= NULL
)
7524 rereading_dwo_cu
= 1;
7528 /* If !use_existing_cu, this_cu->cu must be NULL. */
7529 gdb_assert (this_cu
->cu
== NULL
);
7530 new_cu
.reset (new dwarf2_cu (this_cu
));
7534 /* Get the header. */
7535 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
7537 /* We already have the header, there's no need to read it in again. */
7538 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
7542 if (this_cu
->is_debug_types
)
7544 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7545 &cu
->header
, section
,
7546 abbrev_section
, info_ptr
,
7549 /* Since per_cu is the first member of struct signatured_type,
7550 we can go from a pointer to one to a pointer to the other. */
7551 sig_type
= (struct signatured_type
*) this_cu
;
7552 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
7553 gdb_assert (sig_type
->type_offset_in_tu
7554 == cu
->header
.type_cu_offset_in_tu
);
7555 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7557 /* LENGTH has not been set yet for type units if we're
7558 using .gdb_index. */
7559 this_cu
->length
= get_cu_length (&cu
->header
);
7561 /* Establish the type offset that can be used to lookup the type. */
7562 sig_type
->type_offset_in_section
=
7563 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
7565 this_cu
->dwarf_version
= cu
->header
.version
;
7569 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7570 &cu
->header
, section
,
7573 rcuh_kind::COMPILE
);
7575 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7576 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
7577 this_cu
->dwarf_version
= cu
->header
.version
;
7581 /* Skip dummy compilation units. */
7582 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7583 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7586 /* If we don't have them yet, read the abbrevs for this compilation unit.
7587 And if we need to read them now, make sure they're freed when we're
7588 done (own the table through ABBREV_TABLE_HOLDER). */
7589 abbrev_table_up abbrev_table_holder
;
7590 if (abbrev_table
!= NULL
)
7591 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
7595 = abbrev_table_read_table (dwarf2_per_objfile
, abbrev_section
,
7596 cu
->header
.abbrev_sect_off
);
7597 abbrev_table
= abbrev_table_holder
.get ();
7600 /* Read the top level CU/TU die. */
7601 init_cu_die_reader (&reader
, cu
, section
, NULL
, abbrev_table
);
7602 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
7604 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
7607 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7608 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7609 table from the DWO file and pass the ownership over to us. It will be
7610 referenced from READER, so we must make sure to free it after we're done
7613 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7614 DWO CU, that this test will fail (the attribute will not be present). */
7615 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
7616 abbrev_table_up dwo_abbrev_table
;
7619 struct dwo_unit
*dwo_unit
;
7620 struct die_info
*dwo_comp_unit_die
;
7624 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7625 " has children (offset %s) [in module %s]"),
7626 sect_offset_str (this_cu
->sect_off
),
7627 bfd_get_filename (abfd
));
7629 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
7630 if (dwo_unit
!= NULL
)
7632 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
7633 comp_unit_die
, NULL
,
7635 &dwo_comp_unit_die
, &has_children
,
7636 &dwo_abbrev_table
) == 0)
7641 comp_unit_die
= dwo_comp_unit_die
;
7645 /* Yikes, we couldn't find the rest of the DIE, we only have
7646 the stub. A complaint has already been logged. There's
7647 not much more we can do except pass on the stub DIE to
7648 die_reader_func. We don't want to throw an error on bad
7653 /* All of the above is setup for this call. Yikes. */
7654 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7656 /* Done, clean up. */
7657 if (new_cu
!= NULL
&& keep
)
7659 /* Link this CU into read_in_chain. */
7660 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
7661 dwarf2_per_objfile
->read_in_chain
= this_cu
;
7662 /* The chain owns it now. */
7667 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7668 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7669 to have already done the lookup to find the DWO file).
7671 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7672 THIS_CU->is_debug_types, but nothing else.
7674 We fill in THIS_CU->length.
7676 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7677 linker) then DIE_READER_FUNC will not get called.
7679 THIS_CU->cu is always freed when done.
7680 This is done in order to not leave THIS_CU->cu in a state where we have
7681 to care whether it refers to the "main" CU or the DWO CU. */
7684 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
7685 struct dwo_file
*dwo_file
,
7686 die_reader_func_ftype
*die_reader_func
,
7689 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7690 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7691 struct dwarf2_section_info
*section
= this_cu
->section
;
7692 bfd
*abfd
= get_section_bfd_owner (section
);
7693 struct dwarf2_section_info
*abbrev_section
;
7694 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7695 struct die_reader_specs reader
;
7696 struct die_info
*comp_unit_die
;
7699 if (dwarf_die_debug
)
7700 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7701 this_cu
->is_debug_types
? "type" : "comp",
7702 sect_offset_str (this_cu
->sect_off
));
7704 gdb_assert (this_cu
->cu
== NULL
);
7706 abbrev_section
= (dwo_file
!= NULL
7707 ? &dwo_file
->sections
.abbrev
7708 : get_abbrev_section_for_cu (this_cu
));
7710 /* This is cheap if the section is already read in. */
7711 dwarf2_read_section (objfile
, section
);
7713 struct dwarf2_cu
cu (this_cu
);
7715 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7716 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7717 &cu
.header
, section
,
7718 abbrev_section
, info_ptr
,
7719 (this_cu
->is_debug_types
7721 : rcuh_kind::COMPILE
));
7723 this_cu
->length
= get_cu_length (&cu
.header
);
7725 /* Skip dummy compilation units. */
7726 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7727 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7730 abbrev_table_up abbrev_table
7731 = abbrev_table_read_table (dwarf2_per_objfile
, abbrev_section
,
7732 cu
.header
.abbrev_sect_off
);
7734 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
, abbrev_table
.get ());
7735 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
7737 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7740 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7741 does not lookup the specified DWO file.
7742 This cannot be used to read DWO files.
7744 THIS_CU->cu is always freed when done.
7745 This is done in order to not leave THIS_CU->cu in a state where we have
7746 to care whether it refers to the "main" CU or the DWO CU.
7747 We can revisit this if the data shows there's a performance issue. */
7750 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
7751 die_reader_func_ftype
*die_reader_func
,
7754 init_cutu_and_read_dies_no_follow (this_cu
, NULL
, die_reader_func
, data
);
7757 /* Type Unit Groups.
7759 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7760 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7761 so that all types coming from the same compilation (.o file) are grouped
7762 together. A future step could be to put the types in the same symtab as
7763 the CU the types ultimately came from. */
7766 hash_type_unit_group (const void *item
)
7768 const struct type_unit_group
*tu_group
7769 = (const struct type_unit_group
*) item
;
7771 return hash_stmt_list_entry (&tu_group
->hash
);
7775 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
7777 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
7778 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
7780 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
7783 /* Allocate a hash table for type unit groups. */
7786 allocate_type_unit_groups_table (struct objfile
*objfile
)
7788 return htab_create_alloc_ex (3,
7789 hash_type_unit_group
,
7792 &objfile
->objfile_obstack
,
7793 hashtab_obstack_allocate
,
7794 dummy_obstack_deallocate
);
7797 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7798 partial symtabs. We combine several TUs per psymtab to not let the size
7799 of any one psymtab grow too big. */
7800 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7801 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7803 /* Helper routine for get_type_unit_group.
7804 Create the type_unit_group object used to hold one or more TUs. */
7806 static struct type_unit_group
*
7807 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
7809 struct dwarf2_per_objfile
*dwarf2_per_objfile
7810 = cu
->per_cu
->dwarf2_per_objfile
;
7811 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7812 struct dwarf2_per_cu_data
*per_cu
;
7813 struct type_unit_group
*tu_group
;
7815 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7816 struct type_unit_group
);
7817 per_cu
= &tu_group
->per_cu
;
7818 per_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
7820 if (dwarf2_per_objfile
->using_index
)
7822 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7823 struct dwarf2_per_cu_quick_data
);
7827 unsigned int line_offset
= to_underlying (line_offset_struct
);
7828 struct partial_symtab
*pst
;
7831 /* Give the symtab a useful name for debug purposes. */
7832 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
7833 name
= string_printf ("<type_units_%d>",
7834 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
7836 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
7838 pst
= create_partial_symtab (per_cu
, name
.c_str ());
7842 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
7843 tu_group
->hash
.line_sect_off
= line_offset_struct
;
7848 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7849 STMT_LIST is a DW_AT_stmt_list attribute. */
7851 static struct type_unit_group
*
7852 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
7854 struct dwarf2_per_objfile
*dwarf2_per_objfile
7855 = cu
->per_cu
->dwarf2_per_objfile
;
7856 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
7857 struct type_unit_group
*tu_group
;
7859 unsigned int line_offset
;
7860 struct type_unit_group type_unit_group_for_lookup
;
7862 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
7864 dwarf2_per_objfile
->type_unit_groups
=
7865 allocate_type_unit_groups_table (dwarf2_per_objfile
->objfile
);
7868 /* Do we need to create a new group, or can we use an existing one? */
7872 line_offset
= DW_UNSND (stmt_list
);
7873 ++tu_stats
->nr_symtab_sharers
;
7877 /* Ugh, no stmt_list. Rare, but we have to handle it.
7878 We can do various things here like create one group per TU or
7879 spread them over multiple groups to split up the expansion work.
7880 To avoid worst case scenarios (too many groups or too large groups)
7881 we, umm, group them in bunches. */
7882 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7883 | (tu_stats
->nr_stmt_less_type_units
7884 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
7885 ++tu_stats
->nr_stmt_less_type_units
;
7888 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
7889 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
7890 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
7891 &type_unit_group_for_lookup
, INSERT
);
7894 tu_group
= (struct type_unit_group
*) *slot
;
7895 gdb_assert (tu_group
!= NULL
);
7899 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
7900 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
7902 ++tu_stats
->nr_symtabs
;
7908 /* Partial symbol tables. */
7910 /* Create a psymtab named NAME and assign it to PER_CU.
7912 The caller must fill in the following details:
7913 dirname, textlow, texthigh. */
7915 static struct partial_symtab
*
7916 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
7918 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
7919 struct partial_symtab
*pst
;
7921 pst
= start_psymtab_common (objfile
, name
, 0);
7923 pst
->psymtabs_addrmap_supported
= 1;
7925 /* This is the glue that links PST into GDB's symbol API. */
7926 pst
->read_symtab_private
= per_cu
;
7927 pst
->read_symtab
= dwarf2_read_symtab
;
7928 per_cu
->v
.psymtab
= pst
;
7933 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7936 struct process_psymtab_comp_unit_data
7938 /* True if we are reading a DW_TAG_partial_unit. */
7940 int want_partial_unit
;
7942 /* The "pretend" language that is used if the CU doesn't declare a
7945 enum language pretend_language
;
7948 /* die_reader_func for process_psymtab_comp_unit. */
7951 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
7952 const gdb_byte
*info_ptr
,
7953 struct die_info
*comp_unit_die
,
7957 struct dwarf2_cu
*cu
= reader
->cu
;
7958 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
7959 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7960 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7962 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
7963 struct partial_symtab
*pst
;
7964 enum pc_bounds_kind cu_bounds_kind
;
7965 const char *filename
;
7966 struct process_psymtab_comp_unit_data
*info
7967 = (struct process_psymtab_comp_unit_data
*) data
;
7969 if (comp_unit_die
->tag
== DW_TAG_partial_unit
&& !info
->want_partial_unit
)
7972 gdb_assert (! per_cu
->is_debug_types
);
7974 prepare_one_comp_unit (cu
, comp_unit_die
, info
->pretend_language
);
7976 /* Allocate a new partial symbol table structure. */
7977 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
7978 if (filename
== NULL
)
7981 pst
= create_partial_symtab (per_cu
, filename
);
7983 /* This must be done before calling dwarf2_build_include_psymtabs. */
7984 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7986 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7988 dwarf2_find_base_address (comp_unit_die
, cu
);
7990 /* Possibly set the default values of LOWPC and HIGHPC from
7992 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
7993 &best_highpc
, cu
, pst
);
7994 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
7997 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
8000 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
8002 /* Store the contiguous range if it is not empty; it can be
8003 empty for CUs with no code. */
8004 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
8008 /* Check if comp unit has_children.
8009 If so, read the rest of the partial symbols from this comp unit.
8010 If not, there's no more debug_info for this comp unit. */
8013 struct partial_die_info
*first_die
;
8014 CORE_ADDR lowpc
, highpc
;
8016 lowpc
= ((CORE_ADDR
) -1);
8017 highpc
= ((CORE_ADDR
) 0);
8019 first_die
= load_partial_dies (reader
, info_ptr
, 1);
8021 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
8022 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
8024 /* If we didn't find a lowpc, set it to highpc to avoid
8025 complaints from `maint check'. */
8026 if (lowpc
== ((CORE_ADDR
) -1))
8029 /* If the compilation unit didn't have an explicit address range,
8030 then use the information extracted from its child dies. */
8031 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
8034 best_highpc
= highpc
;
8037 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
8038 best_lowpc
+ baseaddr
)
8040 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
8041 best_highpc
+ baseaddr
)
8044 end_psymtab_common (objfile
, pst
);
8046 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
8049 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
8050 struct dwarf2_per_cu_data
*iter
;
8052 /* Fill in 'dependencies' here; we fill in 'users' in a
8054 pst
->number_of_dependencies
= len
;
8056 = objfile
->partial_symtabs
->allocate_dependencies (len
);
8058 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
8061 pst
->dependencies
[i
] = iter
->v
.psymtab
;
8063 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
8066 /* Get the list of files included in the current compilation unit,
8067 and build a psymtab for each of them. */
8068 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
8070 if (dwarf_read_debug
)
8071 fprintf_unfiltered (gdb_stdlog
,
8072 "Psymtab for %s unit @%s: %s - %s"
8073 ", %d global, %d static syms\n",
8074 per_cu
->is_debug_types
? "type" : "comp",
8075 sect_offset_str (per_cu
->sect_off
),
8076 paddress (gdbarch
, pst
->text_low (objfile
)),
8077 paddress (gdbarch
, pst
->text_high (objfile
)),
8078 pst
->n_global_syms
, pst
->n_static_syms
);
8081 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8082 Process compilation unit THIS_CU for a psymtab. */
8085 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
8086 int want_partial_unit
,
8087 enum language pretend_language
)
8089 /* If this compilation unit was already read in, free the
8090 cached copy in order to read it in again. This is
8091 necessary because we skipped some symbols when we first
8092 read in the compilation unit (see load_partial_dies).
8093 This problem could be avoided, but the benefit is unclear. */
8094 if (this_cu
->cu
!= NULL
)
8095 free_one_cached_comp_unit (this_cu
);
8097 if (this_cu
->is_debug_types
)
8098 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0, false,
8099 build_type_psymtabs_reader
, NULL
);
8102 process_psymtab_comp_unit_data info
;
8103 info
.want_partial_unit
= want_partial_unit
;
8104 info
.pretend_language
= pretend_language
;
8105 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0, false,
8106 process_psymtab_comp_unit_reader
, &info
);
8109 /* Age out any secondary CUs. */
8110 age_cached_comp_units (this_cu
->dwarf2_per_objfile
);
8113 /* Reader function for build_type_psymtabs. */
8116 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
8117 const gdb_byte
*info_ptr
,
8118 struct die_info
*type_unit_die
,
8122 struct dwarf2_per_objfile
*dwarf2_per_objfile
8123 = reader
->cu
->per_cu
->dwarf2_per_objfile
;
8124 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8125 struct dwarf2_cu
*cu
= reader
->cu
;
8126 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
8127 struct signatured_type
*sig_type
;
8128 struct type_unit_group
*tu_group
;
8129 struct attribute
*attr
;
8130 struct partial_die_info
*first_die
;
8131 CORE_ADDR lowpc
, highpc
;
8132 struct partial_symtab
*pst
;
8134 gdb_assert (data
== NULL
);
8135 gdb_assert (per_cu
->is_debug_types
);
8136 sig_type
= (struct signatured_type
*) per_cu
;
8141 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
8142 tu_group
= get_type_unit_group (cu
, attr
);
8144 VEC_safe_push (sig_type_ptr
, tu_group
->tus
, sig_type
);
8146 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
8147 pst
= create_partial_symtab (per_cu
, "");
8150 first_die
= load_partial_dies (reader
, info_ptr
, 1);
8152 lowpc
= (CORE_ADDR
) -1;
8153 highpc
= (CORE_ADDR
) 0;
8154 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
8156 end_psymtab_common (objfile
, pst
);
8159 /* Struct used to sort TUs by their abbreviation table offset. */
8161 struct tu_abbrev_offset
8163 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
8164 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
8167 signatured_type
*sig_type
;
8168 sect_offset abbrev_offset
;
8171 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
8174 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset
&a
,
8175 const struct tu_abbrev_offset
&b
)
8177 return a
.abbrev_offset
< b
.abbrev_offset
;
8180 /* Efficiently read all the type units.
8181 This does the bulk of the work for build_type_psymtabs.
8183 The efficiency is because we sort TUs by the abbrev table they use and
8184 only read each abbrev table once. In one program there are 200K TUs
8185 sharing 8K abbrev tables.
8187 The main purpose of this function is to support building the
8188 dwarf2_per_objfile->type_unit_groups table.
8189 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8190 can collapse the search space by grouping them by stmt_list.
8191 The savings can be significant, in the same program from above the 200K TUs
8192 share 8K stmt_list tables.
8194 FUNC is expected to call get_type_unit_group, which will create the
8195 struct type_unit_group if necessary and add it to
8196 dwarf2_per_objfile->type_unit_groups. */
8199 build_type_psymtabs_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8201 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
8202 abbrev_table_up abbrev_table
;
8203 sect_offset abbrev_offset
;
8205 /* It's up to the caller to not call us multiple times. */
8206 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
8208 if (dwarf2_per_objfile
->all_type_units
.empty ())
8211 /* TUs typically share abbrev tables, and there can be way more TUs than
8212 abbrev tables. Sort by abbrev table to reduce the number of times we
8213 read each abbrev table in.
8214 Alternatives are to punt or to maintain a cache of abbrev tables.
8215 This is simpler and efficient enough for now.
8217 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8218 symtab to use). Typically TUs with the same abbrev offset have the same
8219 stmt_list value too so in practice this should work well.
8221 The basic algorithm here is:
8223 sort TUs by abbrev table
8224 for each TU with same abbrev table:
8225 read abbrev table if first user
8226 read TU top level DIE
8227 [IWBN if DWO skeletons had DW_AT_stmt_list]
8230 if (dwarf_read_debug
)
8231 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
8233 /* Sort in a separate table to maintain the order of all_type_units
8234 for .gdb_index: TU indices directly index all_type_units. */
8235 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
8236 sorted_by_abbrev
.reserve (dwarf2_per_objfile
->all_type_units
.size ());
8238 for (signatured_type
*sig_type
: dwarf2_per_objfile
->all_type_units
)
8239 sorted_by_abbrev
.emplace_back
8240 (sig_type
, read_abbrev_offset (dwarf2_per_objfile
,
8241 sig_type
->per_cu
.section
,
8242 sig_type
->per_cu
.sect_off
));
8244 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end (),
8245 sort_tu_by_abbrev_offset
);
8247 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
8249 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
8251 /* Switch to the next abbrev table if necessary. */
8252 if (abbrev_table
== NULL
8253 || tu
.abbrev_offset
!= abbrev_offset
)
8255 abbrev_offset
= tu
.abbrev_offset
;
8257 abbrev_table_read_table (dwarf2_per_objfile
,
8258 &dwarf2_per_objfile
->abbrev
,
8260 ++tu_stats
->nr_uniq_abbrev_tables
;
8263 init_cutu_and_read_dies (&tu
.sig_type
->per_cu
, abbrev_table
.get (),
8264 0, 0, false, build_type_psymtabs_reader
, NULL
);
8268 /* Print collected type unit statistics. */
8271 print_tu_stats (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8273 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
8275 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
8276 fprintf_unfiltered (gdb_stdlog
, " %zu TUs\n",
8277 dwarf2_per_objfile
->all_type_units
.size ());
8278 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
8279 tu_stats
->nr_uniq_abbrev_tables
);
8280 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
8281 tu_stats
->nr_symtabs
);
8282 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
8283 tu_stats
->nr_symtab_sharers
);
8284 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
8285 tu_stats
->nr_stmt_less_type_units
);
8286 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
8287 tu_stats
->nr_all_type_units_reallocs
);
8290 /* Traversal function for build_type_psymtabs. */
8293 build_type_psymtab_dependencies (void **slot
, void *info
)
8295 struct dwarf2_per_objfile
*dwarf2_per_objfile
8296 = (struct dwarf2_per_objfile
*) info
;
8297 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8298 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
8299 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
8300 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8301 int len
= VEC_length (sig_type_ptr
, tu_group
->tus
);
8302 struct signatured_type
*iter
;
8305 gdb_assert (len
> 0);
8306 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
8308 pst
->number_of_dependencies
= len
;
8309 pst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (len
);
8311 VEC_iterate (sig_type_ptr
, tu_group
->tus
, i
, iter
);
8314 gdb_assert (iter
->per_cu
.is_debug_types
);
8315 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
8316 iter
->type_unit_group
= tu_group
;
8319 VEC_free (sig_type_ptr
, tu_group
->tus
);
8324 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8325 Build partial symbol tables for the .debug_types comp-units. */
8328 build_type_psymtabs (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8330 if (! create_all_type_units (dwarf2_per_objfile
))
8333 build_type_psymtabs_1 (dwarf2_per_objfile
);
8336 /* Traversal function for process_skeletonless_type_unit.
8337 Read a TU in a DWO file and build partial symbols for it. */
8340 process_skeletonless_type_unit (void **slot
, void *info
)
8342 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
8343 struct dwarf2_per_objfile
*dwarf2_per_objfile
8344 = (struct dwarf2_per_objfile
*) info
;
8345 struct signatured_type find_entry
, *entry
;
8347 /* If this TU doesn't exist in the global table, add it and read it in. */
8349 if (dwarf2_per_objfile
->signatured_types
== NULL
)
8351 dwarf2_per_objfile
->signatured_types
8352 = allocate_signatured_type_table (dwarf2_per_objfile
->objfile
);
8355 find_entry
.signature
= dwo_unit
->signature
;
8356 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
, &find_entry
,
8358 /* If we've already seen this type there's nothing to do. What's happening
8359 is we're doing our own version of comdat-folding here. */
8363 /* This does the job that create_all_type_units would have done for
8365 entry
= add_type_unit (dwarf2_per_objfile
, dwo_unit
->signature
, slot
);
8366 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, entry
, dwo_unit
);
8369 /* This does the job that build_type_psymtabs_1 would have done. */
8370 init_cutu_and_read_dies (&entry
->per_cu
, NULL
, 0, 0, false,
8371 build_type_psymtabs_reader
, NULL
);
8376 /* Traversal function for process_skeletonless_type_units. */
8379 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
8381 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
8383 if (dwo_file
->tus
!= NULL
)
8385 htab_traverse_noresize (dwo_file
->tus
,
8386 process_skeletonless_type_unit
, info
);
8392 /* Scan all TUs of DWO files, verifying we've processed them.
8393 This is needed in case a TU was emitted without its skeleton.
8394 Note: This can't be done until we know what all the DWO files are. */
8397 process_skeletonless_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8399 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8400 if (get_dwp_file (dwarf2_per_objfile
) == NULL
8401 && dwarf2_per_objfile
->dwo_files
!= NULL
)
8403 htab_traverse_noresize (dwarf2_per_objfile
->dwo_files
.get (),
8404 process_dwo_file_for_skeletonless_type_units
,
8405 dwarf2_per_objfile
);
8409 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8412 set_partial_user (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8414 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
8416 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8421 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
8423 /* Set the 'user' field only if it is not already set. */
8424 if (pst
->dependencies
[j
]->user
== NULL
)
8425 pst
->dependencies
[j
]->user
= pst
;
8430 /* Build the partial symbol table by doing a quick pass through the
8431 .debug_info and .debug_abbrev sections. */
8434 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8436 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8438 if (dwarf_read_debug
)
8440 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
8441 objfile_name (objfile
));
8444 dwarf2_per_objfile
->reading_partial_symbols
= 1;
8446 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
8448 /* Any cached compilation units will be linked by the per-objfile
8449 read_in_chain. Make sure to free them when we're done. */
8450 free_cached_comp_units
freer (dwarf2_per_objfile
);
8452 build_type_psymtabs (dwarf2_per_objfile
);
8454 create_all_comp_units (dwarf2_per_objfile
);
8456 /* Create a temporary address map on a temporary obstack. We later
8457 copy this to the final obstack. */
8458 auto_obstack temp_obstack
;
8460 scoped_restore save_psymtabs_addrmap
8461 = make_scoped_restore (&objfile
->partial_symtabs
->psymtabs_addrmap
,
8462 addrmap_create_mutable (&temp_obstack
));
8464 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
8465 process_psymtab_comp_unit (per_cu
, 0, language_minimal
);
8467 /* This has to wait until we read the CUs, we need the list of DWOs. */
8468 process_skeletonless_type_units (dwarf2_per_objfile
);
8470 /* Now that all TUs have been processed we can fill in the dependencies. */
8471 if (dwarf2_per_objfile
->type_unit_groups
!= NULL
)
8473 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
8474 build_type_psymtab_dependencies
, dwarf2_per_objfile
);
8477 if (dwarf_read_debug
)
8478 print_tu_stats (dwarf2_per_objfile
);
8480 set_partial_user (dwarf2_per_objfile
);
8482 objfile
->partial_symtabs
->psymtabs_addrmap
8483 = addrmap_create_fixed (objfile
->partial_symtabs
->psymtabs_addrmap
,
8484 objfile
->partial_symtabs
->obstack ());
8485 /* At this point we want to keep the address map. */
8486 save_psymtabs_addrmap
.release ();
8488 if (dwarf_read_debug
)
8489 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
8490 objfile_name (objfile
));
8493 /* die_reader_func for load_partial_comp_unit. */
8496 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
8497 const gdb_byte
*info_ptr
,
8498 struct die_info
*comp_unit_die
,
8502 struct dwarf2_cu
*cu
= reader
->cu
;
8504 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
8506 /* Check if comp unit has_children.
8507 If so, read the rest of the partial symbols from this comp unit.
8508 If not, there's no more debug_info for this comp unit. */
8510 load_partial_dies (reader
, info_ptr
, 0);
8513 /* Load the partial DIEs for a secondary CU into memory.
8514 This is also used when rereading a primary CU with load_all_dies. */
8517 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
8519 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1, false,
8520 load_partial_comp_unit_reader
, NULL
);
8524 read_comp_units_from_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
8525 struct dwarf2_section_info
*section
,
8526 struct dwarf2_section_info
*abbrev_section
,
8527 unsigned int is_dwz
)
8529 const gdb_byte
*info_ptr
;
8530 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8532 if (dwarf_read_debug
)
8533 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
8534 get_section_name (section
),
8535 get_section_file_name (section
));
8537 dwarf2_read_section (objfile
, section
);
8539 info_ptr
= section
->buffer
;
8541 while (info_ptr
< section
->buffer
+ section
->size
)
8543 struct dwarf2_per_cu_data
*this_cu
;
8545 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
8547 comp_unit_head cu_header
;
8548 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
8549 abbrev_section
, info_ptr
,
8550 rcuh_kind::COMPILE
);
8552 /* Save the compilation unit for later lookup. */
8553 if (cu_header
.unit_type
!= DW_UT_type
)
8555 this_cu
= XOBNEW (&objfile
->objfile_obstack
,
8556 struct dwarf2_per_cu_data
);
8557 memset (this_cu
, 0, sizeof (*this_cu
));
8561 auto sig_type
= XOBNEW (&objfile
->objfile_obstack
,
8562 struct signatured_type
);
8563 memset (sig_type
, 0, sizeof (*sig_type
));
8564 sig_type
->signature
= cu_header
.signature
;
8565 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
8566 this_cu
= &sig_type
->per_cu
;
8568 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
8569 this_cu
->sect_off
= sect_off
;
8570 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
8571 this_cu
->is_dwz
= is_dwz
;
8572 this_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
8573 this_cu
->section
= section
;
8575 dwarf2_per_objfile
->all_comp_units
.push_back (this_cu
);
8577 info_ptr
= info_ptr
+ this_cu
->length
;
8581 /* Create a list of all compilation units in OBJFILE.
8582 This is only done for -readnow and building partial symtabs. */
8585 create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8587 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
8588 read_comp_units_from_section (dwarf2_per_objfile
, &dwarf2_per_objfile
->info
,
8589 &dwarf2_per_objfile
->abbrev
, 0);
8591 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
8593 read_comp_units_from_section (dwarf2_per_objfile
, &dwz
->info
, &dwz
->abbrev
,
8597 /* Process all loaded DIEs for compilation unit CU, starting at
8598 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8599 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8600 DW_AT_ranges). See the comments of add_partial_subprogram on how
8601 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8604 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
8605 CORE_ADDR
*highpc
, int set_addrmap
,
8606 struct dwarf2_cu
*cu
)
8608 struct partial_die_info
*pdi
;
8610 /* Now, march along the PDI's, descending into ones which have
8611 interesting children but skipping the children of the other ones,
8612 until we reach the end of the compilation unit. */
8620 /* Anonymous namespaces or modules have no name but have interesting
8621 children, so we need to look at them. Ditto for anonymous
8624 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
8625 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
8626 || pdi
->tag
== DW_TAG_imported_unit
8627 || pdi
->tag
== DW_TAG_inlined_subroutine
)
8631 case DW_TAG_subprogram
:
8632 case DW_TAG_inlined_subroutine
:
8633 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8635 case DW_TAG_constant
:
8636 case DW_TAG_variable
:
8637 case DW_TAG_typedef
:
8638 case DW_TAG_union_type
:
8639 if (!pdi
->is_declaration
)
8641 add_partial_symbol (pdi
, cu
);
8644 case DW_TAG_class_type
:
8645 case DW_TAG_interface_type
:
8646 case DW_TAG_structure_type
:
8647 if (!pdi
->is_declaration
)
8649 add_partial_symbol (pdi
, cu
);
8651 if ((cu
->language
== language_rust
8652 || cu
->language
== language_cplus
) && pdi
->has_children
)
8653 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8656 case DW_TAG_enumeration_type
:
8657 if (!pdi
->is_declaration
)
8658 add_partial_enumeration (pdi
, cu
);
8660 case DW_TAG_base_type
:
8661 case DW_TAG_subrange_type
:
8662 /* File scope base type definitions are added to the partial
8664 add_partial_symbol (pdi
, cu
);
8666 case DW_TAG_namespace
:
8667 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8670 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8672 case DW_TAG_imported_unit
:
8674 struct dwarf2_per_cu_data
*per_cu
;
8676 /* For now we don't handle imported units in type units. */
8677 if (cu
->per_cu
->is_debug_types
)
8679 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8680 " supported in type units [in module %s]"),
8681 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
8684 per_cu
= dwarf2_find_containing_comp_unit
8685 (pdi
->d
.sect_off
, pdi
->is_dwz
,
8686 cu
->per_cu
->dwarf2_per_objfile
);
8688 /* Go read the partial unit, if needed. */
8689 if (per_cu
->v
.psymtab
== NULL
)
8690 process_psymtab_comp_unit (per_cu
, 1, cu
->language
);
8692 VEC_safe_push (dwarf2_per_cu_ptr
,
8693 cu
->per_cu
->imported_symtabs
, per_cu
);
8696 case DW_TAG_imported_declaration
:
8697 add_partial_symbol (pdi
, cu
);
8704 /* If the die has a sibling, skip to the sibling. */
8706 pdi
= pdi
->die_sibling
;
8710 /* Functions used to compute the fully scoped name of a partial DIE.
8712 Normally, this is simple. For C++, the parent DIE's fully scoped
8713 name is concatenated with "::" and the partial DIE's name.
8714 Enumerators are an exception; they use the scope of their parent
8715 enumeration type, i.e. the name of the enumeration type is not
8716 prepended to the enumerator.
8718 There are two complexities. One is DW_AT_specification; in this
8719 case "parent" means the parent of the target of the specification,
8720 instead of the direct parent of the DIE. The other is compilers
8721 which do not emit DW_TAG_namespace; in this case we try to guess
8722 the fully qualified name of structure types from their members'
8723 linkage names. This must be done using the DIE's children rather
8724 than the children of any DW_AT_specification target. We only need
8725 to do this for structures at the top level, i.e. if the target of
8726 any DW_AT_specification (if any; otherwise the DIE itself) does not
8729 /* Compute the scope prefix associated with PDI's parent, in
8730 compilation unit CU. The result will be allocated on CU's
8731 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8732 field. NULL is returned if no prefix is necessary. */
8734 partial_die_parent_scope (struct partial_die_info
*pdi
,
8735 struct dwarf2_cu
*cu
)
8737 const char *grandparent_scope
;
8738 struct partial_die_info
*parent
, *real_pdi
;
8740 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8741 then this means the parent of the specification DIE. */
8744 while (real_pdi
->has_specification
)
8746 auto res
= find_partial_die (real_pdi
->spec_offset
,
8747 real_pdi
->spec_is_dwz
, cu
);
8752 parent
= real_pdi
->die_parent
;
8756 if (parent
->scope_set
)
8757 return parent
->scope
;
8761 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
8763 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8764 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8765 Work around this problem here. */
8766 if (cu
->language
== language_cplus
8767 && parent
->tag
== DW_TAG_namespace
8768 && strcmp (parent
->name
, "::") == 0
8769 && grandparent_scope
== NULL
)
8771 parent
->scope
= NULL
;
8772 parent
->scope_set
= 1;
8776 if (pdi
->tag
== DW_TAG_enumerator
)
8777 /* Enumerators should not get the name of the enumeration as a prefix. */
8778 parent
->scope
= grandparent_scope
;
8779 else if (parent
->tag
== DW_TAG_namespace
8780 || parent
->tag
== DW_TAG_module
8781 || parent
->tag
== DW_TAG_structure_type
8782 || parent
->tag
== DW_TAG_class_type
8783 || parent
->tag
== DW_TAG_interface_type
8784 || parent
->tag
== DW_TAG_union_type
8785 || parent
->tag
== DW_TAG_enumeration_type
)
8787 if (grandparent_scope
== NULL
)
8788 parent
->scope
= parent
->name
;
8790 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
8792 parent
->name
, 0, cu
);
8796 /* FIXME drow/2004-04-01: What should we be doing with
8797 function-local names? For partial symbols, we should probably be
8799 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8800 dwarf_tag_name (parent
->tag
),
8801 sect_offset_str (pdi
->sect_off
));
8802 parent
->scope
= grandparent_scope
;
8805 parent
->scope_set
= 1;
8806 return parent
->scope
;
8809 /* Return the fully scoped name associated with PDI, from compilation unit
8810 CU. The result will be allocated with malloc. */
8813 partial_die_full_name (struct partial_die_info
*pdi
,
8814 struct dwarf2_cu
*cu
)
8816 const char *parent_scope
;
8818 /* If this is a template instantiation, we can not work out the
8819 template arguments from partial DIEs. So, unfortunately, we have
8820 to go through the full DIEs. At least any work we do building
8821 types here will be reused if full symbols are loaded later. */
8822 if (pdi
->has_template_arguments
)
8826 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
8828 struct die_info
*die
;
8829 struct attribute attr
;
8830 struct dwarf2_cu
*ref_cu
= cu
;
8832 /* DW_FORM_ref_addr is using section offset. */
8833 attr
.name
= (enum dwarf_attribute
) 0;
8834 attr
.form
= DW_FORM_ref_addr
;
8835 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
8836 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
8838 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
8842 parent_scope
= partial_die_parent_scope (pdi
, cu
);
8843 if (parent_scope
== NULL
)
8846 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
8850 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
8852 struct dwarf2_per_objfile
*dwarf2_per_objfile
8853 = cu
->per_cu
->dwarf2_per_objfile
;
8854 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8855 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8857 const char *actual_name
= NULL
;
8859 char *built_actual_name
;
8861 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8863 built_actual_name
= partial_die_full_name (pdi
, cu
);
8864 if (built_actual_name
!= NULL
)
8865 actual_name
= built_actual_name
;
8867 if (actual_name
== NULL
)
8868 actual_name
= pdi
->name
;
8872 case DW_TAG_inlined_subroutine
:
8873 case DW_TAG_subprogram
:
8874 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
8876 if (pdi
->is_external
|| cu
->language
== language_ada
)
8878 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8879 of the global scope. But in Ada, we want to be able to access
8880 nested procedures globally. So all Ada subprograms are stored
8881 in the global scope. */
8882 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8883 built_actual_name
!= NULL
,
8884 VAR_DOMAIN
, LOC_BLOCK
,
8885 SECT_OFF_TEXT (objfile
),
8886 psymbol_placement::GLOBAL
,
8888 cu
->language
, objfile
);
8892 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8893 built_actual_name
!= NULL
,
8894 VAR_DOMAIN
, LOC_BLOCK
,
8895 SECT_OFF_TEXT (objfile
),
8896 psymbol_placement::STATIC
,
8897 addr
, cu
->language
, objfile
);
8900 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8901 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
8903 case DW_TAG_constant
:
8904 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8905 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
8906 -1, (pdi
->is_external
8907 ? psymbol_placement::GLOBAL
8908 : psymbol_placement::STATIC
),
8909 0, cu
->language
, objfile
);
8911 case DW_TAG_variable
:
8913 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
8917 && !dwarf2_per_objfile
->has_section_at_zero
)
8919 /* A global or static variable may also have been stripped
8920 out by the linker if unused, in which case its address
8921 will be nullified; do not add such variables into partial
8922 symbol table then. */
8924 else if (pdi
->is_external
)
8927 Don't enter into the minimal symbol tables as there is
8928 a minimal symbol table entry from the ELF symbols already.
8929 Enter into partial symbol table if it has a location
8930 descriptor or a type.
8931 If the location descriptor is missing, new_symbol will create
8932 a LOC_UNRESOLVED symbol, the address of the variable will then
8933 be determined from the minimal symbol table whenever the variable
8935 The address for the partial symbol table entry is not
8936 used by GDB, but it comes in handy for debugging partial symbol
8939 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8940 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8941 built_actual_name
!= NULL
,
8942 VAR_DOMAIN
, LOC_STATIC
,
8943 SECT_OFF_TEXT (objfile
),
8944 psymbol_placement::GLOBAL
,
8945 addr
, cu
->language
, objfile
);
8949 int has_loc
= pdi
->d
.locdesc
!= NULL
;
8951 /* Static Variable. Skip symbols whose value we cannot know (those
8952 without location descriptors or constant values). */
8953 if (!has_loc
&& !pdi
->has_const_value
)
8955 xfree (built_actual_name
);
8959 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8960 built_actual_name
!= NULL
,
8961 VAR_DOMAIN
, LOC_STATIC
,
8962 SECT_OFF_TEXT (objfile
),
8963 psymbol_placement::STATIC
,
8965 cu
->language
, objfile
);
8968 case DW_TAG_typedef
:
8969 case DW_TAG_base_type
:
8970 case DW_TAG_subrange_type
:
8971 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8972 built_actual_name
!= NULL
,
8973 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
8974 psymbol_placement::STATIC
,
8975 0, cu
->language
, objfile
);
8977 case DW_TAG_imported_declaration
:
8978 case DW_TAG_namespace
:
8979 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8980 built_actual_name
!= NULL
,
8981 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
8982 psymbol_placement::GLOBAL
,
8983 0, cu
->language
, objfile
);
8986 /* With Fortran 77 there might be a "BLOCK DATA" module
8987 available without any name. If so, we skip the module as it
8988 doesn't bring any value. */
8989 if (actual_name
!= nullptr)
8990 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8991 built_actual_name
!= NULL
,
8992 MODULE_DOMAIN
, LOC_TYPEDEF
, -1,
8993 psymbol_placement::GLOBAL
,
8994 0, cu
->language
, objfile
);
8996 case DW_TAG_class_type
:
8997 case DW_TAG_interface_type
:
8998 case DW_TAG_structure_type
:
8999 case DW_TAG_union_type
:
9000 case DW_TAG_enumeration_type
:
9001 /* Skip external references. The DWARF standard says in the section
9002 about "Structure, Union, and Class Type Entries": "An incomplete
9003 structure, union or class type is represented by a structure,
9004 union or class entry that does not have a byte size attribute
9005 and that has a DW_AT_declaration attribute." */
9006 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
9008 xfree (built_actual_name
);
9012 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9013 static vs. global. */
9014 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9015 built_actual_name
!= NULL
,
9016 STRUCT_DOMAIN
, LOC_TYPEDEF
, -1,
9017 cu
->language
== language_cplus
9018 ? psymbol_placement::GLOBAL
9019 : psymbol_placement::STATIC
,
9020 0, cu
->language
, objfile
);
9023 case DW_TAG_enumerator
:
9024 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9025 built_actual_name
!= NULL
,
9026 VAR_DOMAIN
, LOC_CONST
, -1,
9027 cu
->language
== language_cplus
9028 ? psymbol_placement::GLOBAL
9029 : psymbol_placement::STATIC
,
9030 0, cu
->language
, objfile
);
9036 xfree (built_actual_name
);
9039 /* Read a partial die corresponding to a namespace; also, add a symbol
9040 corresponding to that namespace to the symbol table. NAMESPACE is
9041 the name of the enclosing namespace. */
9044 add_partial_namespace (struct partial_die_info
*pdi
,
9045 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9046 int set_addrmap
, struct dwarf2_cu
*cu
)
9048 /* Add a symbol for the namespace. */
9050 add_partial_symbol (pdi
, cu
);
9052 /* Now scan partial symbols in that namespace. */
9054 if (pdi
->has_children
)
9055 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
9058 /* Read a partial die corresponding to a Fortran module. */
9061 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
9062 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
9064 /* Add a symbol for the namespace. */
9066 add_partial_symbol (pdi
, cu
);
9068 /* Now scan partial symbols in that module. */
9070 if (pdi
->has_children
)
9071 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
9074 /* Read a partial die corresponding to a subprogram or an inlined
9075 subprogram and create a partial symbol for that subprogram.
9076 When the CU language allows it, this routine also defines a partial
9077 symbol for each nested subprogram that this subprogram contains.
9078 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9079 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9081 PDI may also be a lexical block, in which case we simply search
9082 recursively for subprograms defined inside that lexical block.
9083 Again, this is only performed when the CU language allows this
9084 type of definitions. */
9087 add_partial_subprogram (struct partial_die_info
*pdi
,
9088 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9089 int set_addrmap
, struct dwarf2_cu
*cu
)
9091 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
9093 if (pdi
->has_pc_info
)
9095 if (pdi
->lowpc
< *lowpc
)
9096 *lowpc
= pdi
->lowpc
;
9097 if (pdi
->highpc
> *highpc
)
9098 *highpc
= pdi
->highpc
;
9101 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9102 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9104 CORE_ADDR this_highpc
;
9105 CORE_ADDR this_lowpc
;
9107 baseaddr
= ANOFFSET (objfile
->section_offsets
,
9108 SECT_OFF_TEXT (objfile
));
9110 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
9111 pdi
->lowpc
+ baseaddr
)
9114 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
9115 pdi
->highpc
+ baseaddr
)
9117 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
9118 this_lowpc
, this_highpc
- 1,
9119 cu
->per_cu
->v
.psymtab
);
9123 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
9125 if (!pdi
->is_declaration
)
9126 /* Ignore subprogram DIEs that do not have a name, they are
9127 illegal. Do not emit a complaint at this point, we will
9128 do so when we convert this psymtab into a symtab. */
9130 add_partial_symbol (pdi
, cu
);
9134 if (! pdi
->has_children
)
9137 if (cu
->language
== language_ada
)
9139 pdi
= pdi
->die_child
;
9143 if (pdi
->tag
== DW_TAG_subprogram
9144 || pdi
->tag
== DW_TAG_inlined_subroutine
9145 || pdi
->tag
== DW_TAG_lexical_block
)
9146 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
9147 pdi
= pdi
->die_sibling
;
9152 /* Read a partial die corresponding to an enumeration type. */
9155 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
9156 struct dwarf2_cu
*cu
)
9158 struct partial_die_info
*pdi
;
9160 if (enum_pdi
->name
!= NULL
)
9161 add_partial_symbol (enum_pdi
, cu
);
9163 pdi
= enum_pdi
->die_child
;
9166 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
9167 complaint (_("malformed enumerator DIE ignored"));
9169 add_partial_symbol (pdi
, cu
);
9170 pdi
= pdi
->die_sibling
;
9174 /* Return the initial uleb128 in the die at INFO_PTR. */
9177 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
9179 unsigned int bytes_read
;
9181 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9184 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9185 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
9187 Return the corresponding abbrev, or NULL if the number is zero (indicating
9188 an empty DIE). In either case *BYTES_READ will be set to the length of
9189 the initial number. */
9191 static struct abbrev_info
*
9192 peek_die_abbrev (const die_reader_specs
&reader
,
9193 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
9195 dwarf2_cu
*cu
= reader
.cu
;
9196 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
9197 unsigned int abbrev_number
9198 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
9200 if (abbrev_number
== 0)
9203 abbrev_info
*abbrev
= reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
9206 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9207 " at offset %s [in module %s]"),
9208 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
9209 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
9215 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9216 Returns a pointer to the end of a series of DIEs, terminated by an empty
9217 DIE. Any children of the skipped DIEs will also be skipped. */
9219 static const gdb_byte
*
9220 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
9224 unsigned int bytes_read
;
9225 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
9228 return info_ptr
+ bytes_read
;
9230 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
9234 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9235 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9236 abbrev corresponding to that skipped uleb128 should be passed in
9237 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9240 static const gdb_byte
*
9241 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
9242 struct abbrev_info
*abbrev
)
9244 unsigned int bytes_read
;
9245 struct attribute attr
;
9246 bfd
*abfd
= reader
->abfd
;
9247 struct dwarf2_cu
*cu
= reader
->cu
;
9248 const gdb_byte
*buffer
= reader
->buffer
;
9249 const gdb_byte
*buffer_end
= reader
->buffer_end
;
9250 unsigned int form
, i
;
9252 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
9254 /* The only abbrev we care about is DW_AT_sibling. */
9255 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
9257 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
9258 if (attr
.form
== DW_FORM_ref_addr
)
9259 complaint (_("ignoring absolute DW_AT_sibling"));
9262 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
9263 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
9265 if (sibling_ptr
< info_ptr
)
9266 complaint (_("DW_AT_sibling points backwards"));
9267 else if (sibling_ptr
> reader
->buffer_end
)
9268 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
9274 /* If it isn't DW_AT_sibling, skip this attribute. */
9275 form
= abbrev
->attrs
[i
].form
;
9279 case DW_FORM_ref_addr
:
9280 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9281 and later it is offset sized. */
9282 if (cu
->header
.version
== 2)
9283 info_ptr
+= cu
->header
.addr_size
;
9285 info_ptr
+= cu
->header
.offset_size
;
9287 case DW_FORM_GNU_ref_alt
:
9288 info_ptr
+= cu
->header
.offset_size
;
9291 info_ptr
+= cu
->header
.addr_size
;
9298 case DW_FORM_flag_present
:
9299 case DW_FORM_implicit_const
:
9311 case DW_FORM_ref_sig8
:
9314 case DW_FORM_data16
:
9317 case DW_FORM_string
:
9318 read_direct_string (abfd
, info_ptr
, &bytes_read
);
9319 info_ptr
+= bytes_read
;
9321 case DW_FORM_sec_offset
:
9323 case DW_FORM_GNU_strp_alt
:
9324 info_ptr
+= cu
->header
.offset_size
;
9326 case DW_FORM_exprloc
:
9328 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9329 info_ptr
+= bytes_read
;
9331 case DW_FORM_block1
:
9332 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
9334 case DW_FORM_block2
:
9335 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
9337 case DW_FORM_block4
:
9338 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
9344 case DW_FORM_ref_udata
:
9345 case DW_FORM_GNU_addr_index
:
9346 case DW_FORM_GNU_str_index
:
9347 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
9349 case DW_FORM_indirect
:
9350 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9351 info_ptr
+= bytes_read
;
9352 /* We need to continue parsing from here, so just go back to
9354 goto skip_attribute
;
9357 error (_("Dwarf Error: Cannot handle %s "
9358 "in DWARF reader [in module %s]"),
9359 dwarf_form_name (form
),
9360 bfd_get_filename (abfd
));
9364 if (abbrev
->has_children
)
9365 return skip_children (reader
, info_ptr
);
9370 /* Locate ORIG_PDI's sibling.
9371 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9373 static const gdb_byte
*
9374 locate_pdi_sibling (const struct die_reader_specs
*reader
,
9375 struct partial_die_info
*orig_pdi
,
9376 const gdb_byte
*info_ptr
)
9378 /* Do we know the sibling already? */
9380 if (orig_pdi
->sibling
)
9381 return orig_pdi
->sibling
;
9383 /* Are there any children to deal with? */
9385 if (!orig_pdi
->has_children
)
9388 /* Skip the children the long way. */
9390 return skip_children (reader
, info_ptr
);
9393 /* Expand this partial symbol table into a full symbol table. SELF is
9397 dwarf2_read_symtab (struct partial_symtab
*self
,
9398 struct objfile
*objfile
)
9400 struct dwarf2_per_objfile
*dwarf2_per_objfile
9401 = get_dwarf2_per_objfile (objfile
);
9405 warning (_("bug: psymtab for %s is already read in."),
9412 printf_filtered (_("Reading in symbols for %s..."),
9414 gdb_flush (gdb_stdout
);
9417 /* If this psymtab is constructed from a debug-only objfile, the
9418 has_section_at_zero flag will not necessarily be correct. We
9419 can get the correct value for this flag by looking at the data
9420 associated with the (presumably stripped) associated objfile. */
9421 if (objfile
->separate_debug_objfile_backlink
)
9423 struct dwarf2_per_objfile
*dpo_backlink
9424 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
9426 dwarf2_per_objfile
->has_section_at_zero
9427 = dpo_backlink
->has_section_at_zero
;
9430 dwarf2_per_objfile
->reading_partial_symbols
= 0;
9432 psymtab_to_symtab_1 (self
);
9434 /* Finish up the debug error message. */
9436 printf_filtered (_("done.\n"));
9439 process_cu_includes (dwarf2_per_objfile
);
9442 /* Reading in full CUs. */
9444 /* Add PER_CU to the queue. */
9447 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
9448 enum language pretend_language
)
9450 struct dwarf2_queue_item
*item
;
9453 item
= XNEW (struct dwarf2_queue_item
);
9454 item
->per_cu
= per_cu
;
9455 item
->pretend_language
= pretend_language
;
9458 if (dwarf2_queue
== NULL
)
9459 dwarf2_queue
= item
;
9461 dwarf2_queue_tail
->next
= item
;
9463 dwarf2_queue_tail
= item
;
9466 /* If PER_CU is not yet queued, add it to the queue.
9467 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9469 The result is non-zero if PER_CU was queued, otherwise the result is zero
9470 meaning either PER_CU is already queued or it is already loaded.
9472 N.B. There is an invariant here that if a CU is queued then it is loaded.
9473 The caller is required to load PER_CU if we return non-zero. */
9476 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
9477 struct dwarf2_per_cu_data
*per_cu
,
9478 enum language pretend_language
)
9480 /* We may arrive here during partial symbol reading, if we need full
9481 DIEs to process an unusual case (e.g. template arguments). Do
9482 not queue PER_CU, just tell our caller to load its DIEs. */
9483 if (per_cu
->dwarf2_per_objfile
->reading_partial_symbols
)
9485 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
9490 /* Mark the dependence relation so that we don't flush PER_CU
9492 if (dependent_cu
!= NULL
)
9493 dwarf2_add_dependence (dependent_cu
, per_cu
);
9495 /* If it's already on the queue, we have nothing to do. */
9499 /* If the compilation unit is already loaded, just mark it as
9501 if (per_cu
->cu
!= NULL
)
9503 per_cu
->cu
->last_used
= 0;
9507 /* Add it to the queue. */
9508 queue_comp_unit (per_cu
, pretend_language
);
9513 /* Process the queue. */
9516 process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
9518 struct dwarf2_queue_item
*item
, *next_item
;
9520 if (dwarf_read_debug
)
9522 fprintf_unfiltered (gdb_stdlog
,
9523 "Expanding one or more symtabs of objfile %s ...\n",
9524 objfile_name (dwarf2_per_objfile
->objfile
));
9527 /* The queue starts out with one item, but following a DIE reference
9528 may load a new CU, adding it to the end of the queue. */
9529 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
9531 if ((dwarf2_per_objfile
->using_index
9532 ? !item
->per_cu
->v
.quick
->compunit_symtab
9533 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
9534 /* Skip dummy CUs. */
9535 && item
->per_cu
->cu
!= NULL
)
9537 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
9538 unsigned int debug_print_threshold
;
9541 if (per_cu
->is_debug_types
)
9543 struct signatured_type
*sig_type
=
9544 (struct signatured_type
*) per_cu
;
9546 sprintf (buf
, "TU %s at offset %s",
9547 hex_string (sig_type
->signature
),
9548 sect_offset_str (per_cu
->sect_off
));
9549 /* There can be 100s of TUs.
9550 Only print them in verbose mode. */
9551 debug_print_threshold
= 2;
9555 sprintf (buf
, "CU at offset %s",
9556 sect_offset_str (per_cu
->sect_off
));
9557 debug_print_threshold
= 1;
9560 if (dwarf_read_debug
>= debug_print_threshold
)
9561 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
9563 if (per_cu
->is_debug_types
)
9564 process_full_type_unit (per_cu
, item
->pretend_language
);
9566 process_full_comp_unit (per_cu
, item
->pretend_language
);
9568 if (dwarf_read_debug
>= debug_print_threshold
)
9569 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
9572 item
->per_cu
->queued
= 0;
9573 next_item
= item
->next
;
9577 dwarf2_queue_tail
= NULL
;
9579 if (dwarf_read_debug
)
9581 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
9582 objfile_name (dwarf2_per_objfile
->objfile
));
9586 /* Read in full symbols for PST, and anything it depends on. */
9589 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
9591 struct dwarf2_per_cu_data
*per_cu
;
9597 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
9598 if (!pst
->dependencies
[i
]->readin
9599 && pst
->dependencies
[i
]->user
== NULL
)
9601 /* Inform about additional files that need to be read in. */
9604 /* FIXME: i18n: Need to make this a single string. */
9605 fputs_filtered (" ", gdb_stdout
);
9607 fputs_filtered ("and ", gdb_stdout
);
9609 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
9610 wrap_here (""); /* Flush output. */
9611 gdb_flush (gdb_stdout
);
9613 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
9616 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
9620 /* It's an include file, no symbols to read for it.
9621 Everything is in the parent symtab. */
9626 dw2_do_instantiate_symtab (per_cu
, false);
9629 /* Trivial hash function for die_info: the hash value of a DIE
9630 is its offset in .debug_info for this objfile. */
9633 die_hash (const void *item
)
9635 const struct die_info
*die
= (const struct die_info
*) item
;
9637 return to_underlying (die
->sect_off
);
9640 /* Trivial comparison function for die_info structures: two DIEs
9641 are equal if they have the same offset. */
9644 die_eq (const void *item_lhs
, const void *item_rhs
)
9646 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
9647 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
9649 return die_lhs
->sect_off
== die_rhs
->sect_off
;
9652 /* die_reader_func for load_full_comp_unit.
9653 This is identical to read_signatured_type_reader,
9654 but is kept separate for now. */
9657 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
9658 const gdb_byte
*info_ptr
,
9659 struct die_info
*comp_unit_die
,
9663 struct dwarf2_cu
*cu
= reader
->cu
;
9664 enum language
*language_ptr
= (enum language
*) data
;
9666 gdb_assert (cu
->die_hash
== NULL
);
9668 htab_create_alloc_ex (cu
->header
.length
/ 12,
9672 &cu
->comp_unit_obstack
,
9673 hashtab_obstack_allocate
,
9674 dummy_obstack_deallocate
);
9677 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
9678 &info_ptr
, comp_unit_die
);
9679 cu
->dies
= comp_unit_die
;
9680 /* comp_unit_die is not stored in die_hash, no need. */
9682 /* We try not to read any attributes in this function, because not
9683 all CUs needed for references have been loaded yet, and symbol
9684 table processing isn't initialized. But we have to set the CU language,
9685 or we won't be able to build types correctly.
9686 Similarly, if we do not read the producer, we can not apply
9687 producer-specific interpretation. */
9688 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
9691 /* Load the DIEs associated with PER_CU into memory. */
9694 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
9696 enum language pretend_language
)
9698 gdb_assert (! this_cu
->is_debug_types
);
9700 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1, skip_partial
,
9701 load_full_comp_unit_reader
, &pretend_language
);
9704 /* Add a DIE to the delayed physname list. */
9707 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
9708 const char *name
, struct die_info
*die
,
9709 struct dwarf2_cu
*cu
)
9711 struct delayed_method_info mi
;
9713 mi
.fnfield_index
= fnfield_index
;
9717 cu
->method_list
.push_back (mi
);
9720 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9721 "const" / "volatile". If so, decrements LEN by the length of the
9722 modifier and return true. Otherwise return false. */
9726 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
9728 size_t mod_len
= sizeof (mod
) - 1;
9729 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
9737 /* Compute the physnames of any methods on the CU's method list.
9739 The computation of method physnames is delayed in order to avoid the
9740 (bad) condition that one of the method's formal parameters is of an as yet
9744 compute_delayed_physnames (struct dwarf2_cu
*cu
)
9746 /* Only C++ delays computing physnames. */
9747 if (cu
->method_list
.empty ())
9749 gdb_assert (cu
->language
== language_cplus
);
9751 for (const delayed_method_info
&mi
: cu
->method_list
)
9753 const char *physname
;
9754 struct fn_fieldlist
*fn_flp
9755 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
9756 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
9757 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
9758 = physname
? physname
: "";
9760 /* Since there's no tag to indicate whether a method is a
9761 const/volatile overload, extract that information out of the
9763 if (physname
!= NULL
)
9765 size_t len
= strlen (physname
);
9769 if (physname
[len
] == ')') /* shortcut */
9771 else if (check_modifier (physname
, len
, " const"))
9772 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
9773 else if (check_modifier (physname
, len
, " volatile"))
9774 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
9781 /* The list is no longer needed. */
9782 cu
->method_list
.clear ();
9785 /* Go objects should be embedded in a DW_TAG_module DIE,
9786 and it's not clear if/how imported objects will appear.
9787 To keep Go support simple until that's worked out,
9788 go back through what we've read and create something usable.
9789 We could do this while processing each DIE, and feels kinda cleaner,
9790 but that way is more invasive.
9791 This is to, for example, allow the user to type "p var" or "b main"
9792 without having to specify the package name, and allow lookups
9793 of module.object to work in contexts that use the expression
9797 fixup_go_packaging (struct dwarf2_cu
*cu
)
9799 char *package_name
= NULL
;
9800 struct pending
*list
;
9803 for (list
= *cu
->get_builder ()->get_global_symbols ();
9807 for (i
= 0; i
< list
->nsyms
; ++i
)
9809 struct symbol
*sym
= list
->symbol
[i
];
9811 if (SYMBOL_LANGUAGE (sym
) == language_go
9812 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
9814 char *this_package_name
= go_symbol_package_name (sym
);
9816 if (this_package_name
== NULL
)
9818 if (package_name
== NULL
)
9819 package_name
= this_package_name
;
9822 struct objfile
*objfile
9823 = cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9824 if (strcmp (package_name
, this_package_name
) != 0)
9825 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9826 (symbol_symtab (sym
) != NULL
9827 ? symtab_to_filename_for_display
9828 (symbol_symtab (sym
))
9829 : objfile_name (objfile
)),
9830 this_package_name
, package_name
);
9831 xfree (this_package_name
);
9837 if (package_name
!= NULL
)
9839 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9840 const char *saved_package_name
9841 = (const char *) obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
9843 strlen (package_name
));
9844 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9845 saved_package_name
);
9848 sym
= allocate_symbol (objfile
);
9849 SYMBOL_SET_LANGUAGE (sym
, language_go
, &objfile
->objfile_obstack
);
9850 SYMBOL_SET_NAMES (sym
, saved_package_name
,
9851 strlen (saved_package_name
), 0, objfile
);
9852 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9853 e.g., "main" finds the "main" module and not C's main(). */
9854 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9855 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9856 SYMBOL_TYPE (sym
) = type
;
9858 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
9860 xfree (package_name
);
9864 /* Allocate a fully-qualified name consisting of the two parts on the
9868 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
9870 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
9873 /* A helper that allocates a struct discriminant_info to attach to a
9876 static struct discriminant_info
*
9877 alloc_discriminant_info (struct type
*type
, int discriminant_index
,
9880 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
9881 gdb_assert (discriminant_index
== -1
9882 || (discriminant_index
>= 0
9883 && discriminant_index
< TYPE_NFIELDS (type
)));
9884 gdb_assert (default_index
== -1
9885 || (default_index
>= 0 && default_index
< TYPE_NFIELDS (type
)));
9887 TYPE_FLAG_DISCRIMINATED_UNION (type
) = 1;
9889 struct discriminant_info
*disc
9890 = ((struct discriminant_info
*)
9892 offsetof (struct discriminant_info
, discriminants
)
9893 + TYPE_NFIELDS (type
) * sizeof (disc
->discriminants
[0])));
9894 disc
->default_index
= default_index
;
9895 disc
->discriminant_index
= discriminant_index
;
9897 struct dynamic_prop prop
;
9898 prop
.kind
= PROP_UNDEFINED
;
9899 prop
.data
.baton
= disc
;
9901 add_dyn_prop (DYN_PROP_DISCRIMINATED
, prop
, type
);
9906 /* Some versions of rustc emitted enums in an unusual way.
9908 Ordinary enums were emitted as unions. The first element of each
9909 structure in the union was named "RUST$ENUM$DISR". This element
9910 held the discriminant.
9912 These versions of Rust also implemented the "non-zero"
9913 optimization. When the enum had two values, and one is empty and
9914 the other holds a pointer that cannot be zero, the pointer is used
9915 as the discriminant, with a zero value meaning the empty variant.
9916 Here, the union's first member is of the form
9917 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9918 where the fieldnos are the indices of the fields that should be
9919 traversed in order to find the field (which may be several fields deep)
9920 and the variantname is the name of the variant of the case when the
9923 This function recognizes whether TYPE is of one of these forms,
9924 and, if so, smashes it to be a variant type. */
9927 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
9929 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
9931 /* We don't need to deal with empty enums. */
9932 if (TYPE_NFIELDS (type
) == 0)
9935 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9936 if (TYPE_NFIELDS (type
) == 1
9937 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
9939 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
9941 /* Decode the field name to find the offset of the
9943 ULONGEST bit_offset
= 0;
9944 struct type
*field_type
= TYPE_FIELD_TYPE (type
, 0);
9945 while (name
[0] >= '0' && name
[0] <= '9')
9948 unsigned long index
= strtoul (name
, &tail
, 10);
9951 || index
>= TYPE_NFIELDS (field_type
)
9952 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
9953 != FIELD_LOC_KIND_BITPOS
))
9955 complaint (_("Could not parse Rust enum encoding string \"%s\""
9957 TYPE_FIELD_NAME (type
, 0),
9958 objfile_name (objfile
));
9963 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
9964 field_type
= TYPE_FIELD_TYPE (field_type
, index
);
9967 /* Make a union to hold the variants. */
9968 struct type
*union_type
= alloc_type (objfile
);
9969 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
9970 TYPE_NFIELDS (union_type
) = 3;
9971 TYPE_FIELDS (union_type
)
9972 = (struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
));
9973 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
9974 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
9976 /* Put the discriminant must at index 0. */
9977 TYPE_FIELD_TYPE (union_type
, 0) = field_type
;
9978 TYPE_FIELD_ARTIFICIAL (union_type
, 0) = 1;
9979 TYPE_FIELD_NAME (union_type
, 0) = "<<discriminant>>";
9980 SET_FIELD_BITPOS (TYPE_FIELD (union_type
, 0), bit_offset
);
9982 /* The order of fields doesn't really matter, so put the real
9983 field at index 1 and the data-less field at index 2. */
9984 struct discriminant_info
*disc
9985 = alloc_discriminant_info (union_type
, 0, 1);
9986 TYPE_FIELD (union_type
, 1) = TYPE_FIELD (type
, 0);
9987 TYPE_FIELD_NAME (union_type
, 1)
9988 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type
, 1)));
9989 TYPE_NAME (TYPE_FIELD_TYPE (union_type
, 1))
9990 = rust_fully_qualify (&objfile
->objfile_obstack
, TYPE_NAME (type
),
9991 TYPE_FIELD_NAME (union_type
, 1));
9993 const char *dataless_name
9994 = rust_fully_qualify (&objfile
->objfile_obstack
, TYPE_NAME (type
),
9996 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
9998 TYPE_FIELD_TYPE (union_type
, 2) = dataless_type
;
9999 /* NAME points into the original discriminant name, which
10000 already has the correct lifetime. */
10001 TYPE_FIELD_NAME (union_type
, 2) = name
;
10002 SET_FIELD_BITPOS (TYPE_FIELD (union_type
, 2), 0);
10003 disc
->discriminants
[2] = 0;
10005 /* Smash this type to be a structure type. We have to do this
10006 because the type has already been recorded. */
10007 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10008 TYPE_NFIELDS (type
) = 1;
10010 = (struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
));
10012 /* Install the variant part. */
10013 TYPE_FIELD_TYPE (type
, 0) = union_type
;
10014 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10015 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10017 else if (TYPE_NFIELDS (type
) == 1)
10019 /* We assume that a union with a single field is a univariant
10021 /* Smash this type to be a structure type. We have to do this
10022 because the type has already been recorded. */
10023 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10025 /* Make a union to hold the variants. */
10026 struct type
*union_type
= alloc_type (objfile
);
10027 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
10028 TYPE_NFIELDS (union_type
) = TYPE_NFIELDS (type
);
10029 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
10030 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
10031 TYPE_FIELDS (union_type
) = TYPE_FIELDS (type
);
10033 struct type
*field_type
= TYPE_FIELD_TYPE (union_type
, 0);
10034 const char *variant_name
10035 = rust_last_path_segment (TYPE_NAME (field_type
));
10036 TYPE_FIELD_NAME (union_type
, 0) = variant_name
;
10037 TYPE_NAME (field_type
)
10038 = rust_fully_qualify (&objfile
->objfile_obstack
,
10039 TYPE_NAME (type
), variant_name
);
10041 /* Install the union in the outer struct type. */
10042 TYPE_NFIELDS (type
) = 1;
10044 = (struct field
*) TYPE_ZALLOC (union_type
, sizeof (struct field
));
10045 TYPE_FIELD_TYPE (type
, 0) = union_type
;
10046 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10047 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10049 alloc_discriminant_info (union_type
, -1, 0);
10053 struct type
*disr_type
= nullptr;
10054 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
10056 disr_type
= TYPE_FIELD_TYPE (type
, i
);
10058 if (TYPE_CODE (disr_type
) != TYPE_CODE_STRUCT
)
10060 /* All fields of a true enum will be structs. */
10063 else if (TYPE_NFIELDS (disr_type
) == 0)
10065 /* Could be data-less variant, so keep going. */
10066 disr_type
= nullptr;
10068 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
10069 "RUST$ENUM$DISR") != 0)
10071 /* Not a Rust enum. */
10081 /* If we got here without a discriminant, then it's probably
10083 if (disr_type
== nullptr)
10086 /* Smash this type to be a structure type. We have to do this
10087 because the type has already been recorded. */
10088 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10090 /* Make a union to hold the variants. */
10091 struct field
*disr_field
= &TYPE_FIELD (disr_type
, 0);
10092 struct type
*union_type
= alloc_type (objfile
);
10093 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
10094 TYPE_NFIELDS (union_type
) = 1 + TYPE_NFIELDS (type
);
10095 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
10096 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
10097 TYPE_FIELDS (union_type
)
10098 = (struct field
*) TYPE_ZALLOC (union_type
,
10099 (TYPE_NFIELDS (union_type
)
10100 * sizeof (struct field
)));
10102 memcpy (TYPE_FIELDS (union_type
) + 1, TYPE_FIELDS (type
),
10103 TYPE_NFIELDS (type
) * sizeof (struct field
));
10105 /* Install the discriminant at index 0 in the union. */
10106 TYPE_FIELD (union_type
, 0) = *disr_field
;
10107 TYPE_FIELD_ARTIFICIAL (union_type
, 0) = 1;
10108 TYPE_FIELD_NAME (union_type
, 0) = "<<discriminant>>";
10110 /* Install the union in the outer struct type. */
10111 TYPE_FIELD_TYPE (type
, 0) = union_type
;
10112 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10113 TYPE_NFIELDS (type
) = 1;
10115 /* Set the size and offset of the union type. */
10116 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10118 /* We need a way to find the correct discriminant given a
10119 variant name. For convenience we build a map here. */
10120 struct type
*enum_type
= FIELD_TYPE (*disr_field
);
10121 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
10122 for (int i
= 0; i
< TYPE_NFIELDS (enum_type
); ++i
)
10124 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
10127 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
10128 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
10132 int n_fields
= TYPE_NFIELDS (union_type
);
10133 struct discriminant_info
*disc
10134 = alloc_discriminant_info (union_type
, 0, -1);
10135 /* Skip the discriminant here. */
10136 for (int i
= 1; i
< n_fields
; ++i
)
10138 /* Find the final word in the name of this variant's type.
10139 That name can be used to look up the correct
10141 const char *variant_name
10142 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type
,
10145 auto iter
= discriminant_map
.find (variant_name
);
10146 if (iter
!= discriminant_map
.end ())
10147 disc
->discriminants
[i
] = iter
->second
;
10149 /* Remove the discriminant field, if it exists. */
10150 struct type
*sub_type
= TYPE_FIELD_TYPE (union_type
, i
);
10151 if (TYPE_NFIELDS (sub_type
) > 0)
10153 --TYPE_NFIELDS (sub_type
);
10154 ++TYPE_FIELDS (sub_type
);
10156 TYPE_FIELD_NAME (union_type
, i
) = variant_name
;
10157 TYPE_NAME (sub_type
)
10158 = rust_fully_qualify (&objfile
->objfile_obstack
,
10159 TYPE_NAME (type
), variant_name
);
10164 /* Rewrite some Rust unions to be structures with variants parts. */
10167 rust_union_quirks (struct dwarf2_cu
*cu
)
10169 gdb_assert (cu
->language
== language_rust
);
10170 for (type
*type_
: cu
->rust_unions
)
10171 quirk_rust_enum (type_
, cu
->per_cu
->dwarf2_per_objfile
->objfile
);
10172 /* We don't need this any more. */
10173 cu
->rust_unions
.clear ();
10176 /* Return the symtab for PER_CU. This works properly regardless of
10177 whether we're using the index or psymtabs. */
10179 static struct compunit_symtab
*
10180 get_compunit_symtab (struct dwarf2_per_cu_data
*per_cu
)
10182 return (per_cu
->dwarf2_per_objfile
->using_index
10183 ? per_cu
->v
.quick
->compunit_symtab
10184 : per_cu
->v
.psymtab
->compunit_symtab
);
10187 /* A helper function for computing the list of all symbol tables
10188 included by PER_CU. */
10191 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
10192 htab_t all_children
, htab_t all_type_symtabs
,
10193 struct dwarf2_per_cu_data
*per_cu
,
10194 struct compunit_symtab
*immediate_parent
)
10198 struct compunit_symtab
*cust
;
10199 struct dwarf2_per_cu_data
*iter
;
10201 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
10204 /* This inclusion and its children have been processed. */
10209 /* Only add a CU if it has a symbol table. */
10210 cust
= get_compunit_symtab (per_cu
);
10213 /* If this is a type unit only add its symbol table if we haven't
10214 seen it yet (type unit per_cu's can share symtabs). */
10215 if (per_cu
->is_debug_types
)
10217 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
10221 result
->push_back (cust
);
10222 if (cust
->user
== NULL
)
10223 cust
->user
= immediate_parent
;
10228 result
->push_back (cust
);
10229 if (cust
->user
== NULL
)
10230 cust
->user
= immediate_parent
;
10235 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
10238 recursively_compute_inclusions (result
, all_children
,
10239 all_type_symtabs
, iter
, cust
);
10243 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10247 compute_compunit_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
10249 gdb_assert (! per_cu
->is_debug_types
);
10251 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
10254 struct dwarf2_per_cu_data
*per_cu_iter
;
10255 std::vector
<compunit_symtab
*> result_symtabs
;
10256 htab_t all_children
, all_type_symtabs
;
10257 struct compunit_symtab
*cust
= get_compunit_symtab (per_cu
);
10259 /* If we don't have a symtab, we can just skip this case. */
10263 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
10264 NULL
, xcalloc
, xfree
);
10265 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
10266 NULL
, xcalloc
, xfree
);
10269 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
10273 recursively_compute_inclusions (&result_symtabs
, all_children
,
10274 all_type_symtabs
, per_cu_iter
,
10278 /* Now we have a transitive closure of all the included symtabs. */
10279 len
= result_symtabs
.size ();
10281 = XOBNEWVEC (&per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
,
10282 struct compunit_symtab
*, len
+ 1);
10283 memcpy (cust
->includes
, result_symtabs
.data (),
10284 len
* sizeof (compunit_symtab
*));
10285 cust
->includes
[len
] = NULL
;
10287 htab_delete (all_children
);
10288 htab_delete (all_type_symtabs
);
10292 /* Compute the 'includes' field for the symtabs of all the CUs we just
10296 process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
10298 for (dwarf2_per_cu_data
*iter
: dwarf2_per_objfile
->just_read_cus
)
10300 if (! iter
->is_debug_types
)
10301 compute_compunit_symtab_includes (iter
);
10304 dwarf2_per_objfile
->just_read_cus
.clear ();
10307 /* Generate full symbol information for PER_CU, whose DIEs have
10308 already been loaded into memory. */
10311 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
10312 enum language pretend_language
)
10314 struct dwarf2_cu
*cu
= per_cu
->cu
;
10315 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
10316 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10317 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10318 CORE_ADDR lowpc
, highpc
;
10319 struct compunit_symtab
*cust
;
10320 CORE_ADDR baseaddr
;
10321 struct block
*static_block
;
10324 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10326 /* Clear the list here in case something was left over. */
10327 cu
->method_list
.clear ();
10329 cu
->language
= pretend_language
;
10330 cu
->language_defn
= language_def (cu
->language
);
10332 /* Do line number decoding in read_file_scope () */
10333 process_die (cu
->dies
, cu
);
10335 /* For now fudge the Go package. */
10336 if (cu
->language
== language_go
)
10337 fixup_go_packaging (cu
);
10339 /* Now that we have processed all the DIEs in the CU, all the types
10340 should be complete, and it should now be safe to compute all of the
10342 compute_delayed_physnames (cu
);
10344 if (cu
->language
== language_rust
)
10345 rust_union_quirks (cu
);
10347 /* Some compilers don't define a DW_AT_high_pc attribute for the
10348 compilation unit. If the DW_AT_high_pc is missing, synthesize
10349 it, by scanning the DIE's below the compilation unit. */
10350 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
10352 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
10353 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
10355 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10356 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10357 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10358 addrmap to help ensure it has an accurate map of pc values belonging to
10360 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
10362 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
10363 SECT_OFF_TEXT (objfile
),
10368 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
10370 /* Set symtab language to language from DW_AT_language. If the
10371 compilation is from a C file generated by language preprocessors, do
10372 not set the language if it was already deduced by start_subfile. */
10373 if (!(cu
->language
== language_c
10374 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
10375 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10377 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10378 produce DW_AT_location with location lists but it can be possibly
10379 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10380 there were bugs in prologue debug info, fixed later in GCC-4.5
10381 by "unwind info for epilogues" patch (which is not directly related).
10383 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10384 needed, it would be wrong due to missing DW_AT_producer there.
10386 Still one can confuse GDB by using non-standard GCC compilation
10387 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10389 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
10390 cust
->locations_valid
= 1;
10392 if (gcc_4_minor
>= 5)
10393 cust
->epilogue_unwind_valid
= 1;
10395 cust
->call_site_htab
= cu
->call_site_htab
;
10398 if (dwarf2_per_objfile
->using_index
)
10399 per_cu
->v
.quick
->compunit_symtab
= cust
;
10402 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
10403 pst
->compunit_symtab
= cust
;
10407 /* Push it for inclusion processing later. */
10408 dwarf2_per_objfile
->just_read_cus
.push_back (per_cu
);
10410 /* Not needed any more. */
10411 cu
->reset_builder ();
10414 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10415 already been loaded into memory. */
10418 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
10419 enum language pretend_language
)
10421 struct dwarf2_cu
*cu
= per_cu
->cu
;
10422 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
10423 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10424 struct compunit_symtab
*cust
;
10425 struct signatured_type
*sig_type
;
10427 gdb_assert (per_cu
->is_debug_types
);
10428 sig_type
= (struct signatured_type
*) per_cu
;
10430 /* Clear the list here in case something was left over. */
10431 cu
->method_list
.clear ();
10433 cu
->language
= pretend_language
;
10434 cu
->language_defn
= language_def (cu
->language
);
10436 /* The symbol tables are set up in read_type_unit_scope. */
10437 process_die (cu
->dies
, cu
);
10439 /* For now fudge the Go package. */
10440 if (cu
->language
== language_go
)
10441 fixup_go_packaging (cu
);
10443 /* Now that we have processed all the DIEs in the CU, all the types
10444 should be complete, and it should now be safe to compute all of the
10446 compute_delayed_physnames (cu
);
10448 if (cu
->language
== language_rust
)
10449 rust_union_quirks (cu
);
10451 /* TUs share symbol tables.
10452 If this is the first TU to use this symtab, complete the construction
10453 of it with end_expandable_symtab. Otherwise, complete the addition of
10454 this TU's symbols to the existing symtab. */
10455 if (sig_type
->type_unit_group
->compunit_symtab
== NULL
)
10457 buildsym_compunit
*builder
= cu
->get_builder ();
10458 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
10459 sig_type
->type_unit_group
->compunit_symtab
= cust
;
10463 /* Set symtab language to language from DW_AT_language. If the
10464 compilation is from a C file generated by language preprocessors,
10465 do not set the language if it was already deduced by
10467 if (!(cu
->language
== language_c
10468 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
10469 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10474 cu
->get_builder ()->augment_type_symtab ();
10475 cust
= sig_type
->type_unit_group
->compunit_symtab
;
10478 if (dwarf2_per_objfile
->using_index
)
10479 per_cu
->v
.quick
->compunit_symtab
= cust
;
10482 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
10483 pst
->compunit_symtab
= cust
;
10487 /* Not needed any more. */
10488 cu
->reset_builder ();
10491 /* Process an imported unit DIE. */
10494 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10496 struct attribute
*attr
;
10498 /* For now we don't handle imported units in type units. */
10499 if (cu
->per_cu
->is_debug_types
)
10501 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10502 " supported in type units [in module %s]"),
10503 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
10506 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10509 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
10510 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
10511 dwarf2_per_cu_data
*per_cu
10512 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
,
10513 cu
->per_cu
->dwarf2_per_objfile
);
10515 /* If necessary, add it to the queue and load its DIEs. */
10516 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
10517 load_full_comp_unit (per_cu
, false, cu
->language
);
10519 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
10524 /* RAII object that represents a process_die scope: i.e.,
10525 starts/finishes processing a DIE. */
10526 class process_die_scope
10529 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
10530 : m_die (die
), m_cu (cu
)
10532 /* We should only be processing DIEs not already in process. */
10533 gdb_assert (!m_die
->in_process
);
10534 m_die
->in_process
= true;
10537 ~process_die_scope ()
10539 m_die
->in_process
= false;
10541 /* If we're done processing the DIE for the CU that owns the line
10542 header, we don't need the line header anymore. */
10543 if (m_cu
->line_header_die_owner
== m_die
)
10545 delete m_cu
->line_header
;
10546 m_cu
->line_header
= NULL
;
10547 m_cu
->line_header_die_owner
= NULL
;
10556 /* Process a die and its children. */
10559 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10561 process_die_scope
scope (die
, cu
);
10565 case DW_TAG_padding
:
10567 case DW_TAG_compile_unit
:
10568 case DW_TAG_partial_unit
:
10569 read_file_scope (die
, cu
);
10571 case DW_TAG_type_unit
:
10572 read_type_unit_scope (die
, cu
);
10574 case DW_TAG_subprogram
:
10575 case DW_TAG_inlined_subroutine
:
10576 read_func_scope (die
, cu
);
10578 case DW_TAG_lexical_block
:
10579 case DW_TAG_try_block
:
10580 case DW_TAG_catch_block
:
10581 read_lexical_block_scope (die
, cu
);
10583 case DW_TAG_call_site
:
10584 case DW_TAG_GNU_call_site
:
10585 read_call_site_scope (die
, cu
);
10587 case DW_TAG_class_type
:
10588 case DW_TAG_interface_type
:
10589 case DW_TAG_structure_type
:
10590 case DW_TAG_union_type
:
10591 process_structure_scope (die
, cu
);
10593 case DW_TAG_enumeration_type
:
10594 process_enumeration_scope (die
, cu
);
10597 /* These dies have a type, but processing them does not create
10598 a symbol or recurse to process the children. Therefore we can
10599 read them on-demand through read_type_die. */
10600 case DW_TAG_subroutine_type
:
10601 case DW_TAG_set_type
:
10602 case DW_TAG_array_type
:
10603 case DW_TAG_pointer_type
:
10604 case DW_TAG_ptr_to_member_type
:
10605 case DW_TAG_reference_type
:
10606 case DW_TAG_rvalue_reference_type
:
10607 case DW_TAG_string_type
:
10610 case DW_TAG_base_type
:
10611 case DW_TAG_subrange_type
:
10612 case DW_TAG_typedef
:
10613 /* Add a typedef symbol for the type definition, if it has a
10615 new_symbol (die
, read_type_die (die
, cu
), cu
);
10617 case DW_TAG_common_block
:
10618 read_common_block (die
, cu
);
10620 case DW_TAG_common_inclusion
:
10622 case DW_TAG_namespace
:
10623 cu
->processing_has_namespace_info
= true;
10624 read_namespace (die
, cu
);
10626 case DW_TAG_module
:
10627 cu
->processing_has_namespace_info
= true;
10628 read_module (die
, cu
);
10630 case DW_TAG_imported_declaration
:
10631 cu
->processing_has_namespace_info
= true;
10632 if (read_namespace_alias (die
, cu
))
10634 /* The declaration is not a global namespace alias. */
10635 /* Fall through. */
10636 case DW_TAG_imported_module
:
10637 cu
->processing_has_namespace_info
= true;
10638 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
10639 || cu
->language
!= language_fortran
))
10640 complaint (_("Tag '%s' has unexpected children"),
10641 dwarf_tag_name (die
->tag
));
10642 read_import_statement (die
, cu
);
10645 case DW_TAG_imported_unit
:
10646 process_imported_unit_die (die
, cu
);
10649 case DW_TAG_variable
:
10650 read_variable (die
, cu
);
10654 new_symbol (die
, NULL
, cu
);
10659 /* DWARF name computation. */
10661 /* A helper function for dwarf2_compute_name which determines whether DIE
10662 needs to have the name of the scope prepended to the name listed in the
10666 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
10668 struct attribute
*attr
;
10672 case DW_TAG_namespace
:
10673 case DW_TAG_typedef
:
10674 case DW_TAG_class_type
:
10675 case DW_TAG_interface_type
:
10676 case DW_TAG_structure_type
:
10677 case DW_TAG_union_type
:
10678 case DW_TAG_enumeration_type
:
10679 case DW_TAG_enumerator
:
10680 case DW_TAG_subprogram
:
10681 case DW_TAG_inlined_subroutine
:
10682 case DW_TAG_member
:
10683 case DW_TAG_imported_declaration
:
10686 case DW_TAG_variable
:
10687 case DW_TAG_constant
:
10688 /* We only need to prefix "globally" visible variables. These include
10689 any variable marked with DW_AT_external or any variable that
10690 lives in a namespace. [Variables in anonymous namespaces
10691 require prefixing, but they are not DW_AT_external.] */
10693 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
10695 struct dwarf2_cu
*spec_cu
= cu
;
10697 return die_needs_namespace (die_specification (die
, &spec_cu
),
10701 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
10702 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
10703 && die
->parent
->tag
!= DW_TAG_module
)
10705 /* A variable in a lexical block of some kind does not need a
10706 namespace, even though in C++ such variables may be external
10707 and have a mangled name. */
10708 if (die
->parent
->tag
== DW_TAG_lexical_block
10709 || die
->parent
->tag
== DW_TAG_try_block
10710 || die
->parent
->tag
== DW_TAG_catch_block
10711 || die
->parent
->tag
== DW_TAG_subprogram
)
10720 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10721 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10722 defined for the given DIE. */
10724 static struct attribute
*
10725 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
10727 struct attribute
*attr
;
10729 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
10731 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10736 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10737 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10738 defined for the given DIE. */
10740 static const char *
10741 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10743 const char *linkage_name
;
10745 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
10746 if (linkage_name
== NULL
)
10747 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10749 return linkage_name
;
10752 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10753 compute the physname for the object, which include a method's:
10754 - formal parameters (C++),
10755 - receiver type (Go),
10757 The term "physname" is a bit confusing.
10758 For C++, for example, it is the demangled name.
10759 For Go, for example, it's the mangled name.
10761 For Ada, return the DIE's linkage name rather than the fully qualified
10762 name. PHYSNAME is ignored..
10764 The result is allocated on the objfile_obstack and canonicalized. */
10766 static const char *
10767 dwarf2_compute_name (const char *name
,
10768 struct die_info
*die
, struct dwarf2_cu
*cu
,
10771 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
10774 name
= dwarf2_name (die
, cu
);
10776 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10777 but otherwise compute it by typename_concat inside GDB.
10778 FIXME: Actually this is not really true, or at least not always true.
10779 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
10780 Fortran names because there is no mangling standard. So new_symbol
10781 will set the demangled name to the result of dwarf2_full_name, and it is
10782 the demangled name that GDB uses if it exists. */
10783 if (cu
->language
== language_ada
10784 || (cu
->language
== language_fortran
&& physname
))
10786 /* For Ada unit, we prefer the linkage name over the name, as
10787 the former contains the exported name, which the user expects
10788 to be able to reference. Ideally, we want the user to be able
10789 to reference this entity using either natural or linkage name,
10790 but we haven't started looking at this enhancement yet. */
10791 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10793 if (linkage_name
!= NULL
)
10794 return linkage_name
;
10797 /* These are the only languages we know how to qualify names in. */
10799 && (cu
->language
== language_cplus
10800 || cu
->language
== language_fortran
|| cu
->language
== language_d
10801 || cu
->language
== language_rust
))
10803 if (die_needs_namespace (die
, cu
))
10805 const char *prefix
;
10806 const char *canonical_name
= NULL
;
10810 prefix
= determine_prefix (die
, cu
);
10811 if (*prefix
!= '\0')
10813 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
10816 buf
.puts (prefixed_name
);
10817 xfree (prefixed_name
);
10822 /* Template parameters may be specified in the DIE's DW_AT_name, or
10823 as children with DW_TAG_template_type_param or
10824 DW_TAG_value_type_param. If the latter, add them to the name
10825 here. If the name already has template parameters, then
10826 skip this step; some versions of GCC emit both, and
10827 it is more efficient to use the pre-computed name.
10829 Something to keep in mind about this process: it is very
10830 unlikely, or in some cases downright impossible, to produce
10831 something that will match the mangled name of a function.
10832 If the definition of the function has the same debug info,
10833 we should be able to match up with it anyway. But fallbacks
10834 using the minimal symbol, for instance to find a method
10835 implemented in a stripped copy of libstdc++, will not work.
10836 If we do not have debug info for the definition, we will have to
10837 match them up some other way.
10839 When we do name matching there is a related problem with function
10840 templates; two instantiated function templates are allowed to
10841 differ only by their return types, which we do not add here. */
10843 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
10845 struct attribute
*attr
;
10846 struct die_info
*child
;
10849 die
->building_fullname
= 1;
10851 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
10855 const gdb_byte
*bytes
;
10856 struct dwarf2_locexpr_baton
*baton
;
10859 if (child
->tag
!= DW_TAG_template_type_param
10860 && child
->tag
!= DW_TAG_template_value_param
)
10871 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10874 complaint (_("template parameter missing DW_AT_type"));
10875 buf
.puts ("UNKNOWN_TYPE");
10878 type
= die_type (child
, cu
);
10880 if (child
->tag
== DW_TAG_template_type_param
)
10882 c_print_type (type
, "", &buf
, -1, 0, cu
->language
,
10883 &type_print_raw_options
);
10887 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10890 complaint (_("template parameter missing "
10891 "DW_AT_const_value"));
10892 buf
.puts ("UNKNOWN_VALUE");
10896 dwarf2_const_value_attr (attr
, type
, name
,
10897 &cu
->comp_unit_obstack
, cu
,
10898 &value
, &bytes
, &baton
);
10900 if (TYPE_NOSIGN (type
))
10901 /* GDB prints characters as NUMBER 'CHAR'. If that's
10902 changed, this can use value_print instead. */
10903 c_printchar (value
, type
, &buf
);
10906 struct value_print_options opts
;
10909 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
10913 else if (bytes
!= NULL
)
10915 v
= allocate_value (type
);
10916 memcpy (value_contents_writeable (v
), bytes
,
10917 TYPE_LENGTH (type
));
10920 v
= value_from_longest (type
, value
);
10922 /* Specify decimal so that we do not depend on
10924 get_formatted_print_options (&opts
, 'd');
10926 value_print (v
, &buf
, &opts
);
10931 die
->building_fullname
= 0;
10935 /* Close the argument list, with a space if necessary
10936 (nested templates). */
10937 if (!buf
.empty () && buf
.string ().back () == '>')
10944 /* For C++ methods, append formal parameter type
10945 information, if PHYSNAME. */
10947 if (physname
&& die
->tag
== DW_TAG_subprogram
10948 && cu
->language
== language_cplus
)
10950 struct type
*type
= read_type_die (die
, cu
);
10952 c_type_print_args (type
, &buf
, 1, cu
->language
,
10953 &type_print_raw_options
);
10955 if (cu
->language
== language_cplus
)
10957 /* Assume that an artificial first parameter is
10958 "this", but do not crash if it is not. RealView
10959 marks unnamed (and thus unused) parameters as
10960 artificial; there is no way to differentiate
10962 if (TYPE_NFIELDS (type
) > 0
10963 && TYPE_FIELD_ARTIFICIAL (type
, 0)
10964 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
10965 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
10967 buf
.puts (" const");
10971 const std::string
&intermediate_name
= buf
.string ();
10973 if (cu
->language
== language_cplus
)
10975 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
10976 &objfile
->per_bfd
->storage_obstack
);
10978 /* If we only computed INTERMEDIATE_NAME, or if
10979 INTERMEDIATE_NAME is already canonical, then we need to
10980 copy it to the appropriate obstack. */
10981 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
10982 name
= ((const char *)
10983 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
10984 intermediate_name
.c_str (),
10985 intermediate_name
.length ()));
10987 name
= canonical_name
;
10994 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10995 If scope qualifiers are appropriate they will be added. The result
10996 will be allocated on the storage_obstack, or NULL if the DIE does
10997 not have a name. NAME may either be from a previous call to
10998 dwarf2_name or NULL.
11000 The output string will be canonicalized (if C++). */
11002 static const char *
11003 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
11005 return dwarf2_compute_name (name
, die
, cu
, 0);
11008 /* Construct a physname for the given DIE in CU. NAME may either be
11009 from a previous call to dwarf2_name or NULL. The result will be
11010 allocated on the objfile_objstack or NULL if the DIE does not have a
11013 The output string will be canonicalized (if C++). */
11015 static const char *
11016 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
11018 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
11019 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
11022 /* In this case dwarf2_compute_name is just a shortcut not building anything
11024 if (!die_needs_namespace (die
, cu
))
11025 return dwarf2_compute_name (name
, die
, cu
, 1);
11027 mangled
= dw2_linkage_name (die
, cu
);
11029 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
11030 See https://github.com/rust-lang/rust/issues/32925. */
11031 if (cu
->language
== language_rust
&& mangled
!= NULL
11032 && strchr (mangled
, '{') != NULL
)
11035 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11037 gdb::unique_xmalloc_ptr
<char> demangled
;
11038 if (mangled
!= NULL
)
11041 if (language_def (cu
->language
)->la_store_sym_names_in_linkage_form_p
)
11043 /* Do nothing (do not demangle the symbol name). */
11045 else if (cu
->language
== language_go
)
11047 /* This is a lie, but we already lie to the caller new_symbol.
11048 new_symbol assumes we return the mangled name.
11049 This just undoes that lie until things are cleaned up. */
11053 /* Use DMGL_RET_DROP for C++ template functions to suppress
11054 their return type. It is easier for GDB users to search
11055 for such functions as `name(params)' than `long name(params)'.
11056 In such case the minimal symbol names do not match the full
11057 symbol names but for template functions there is never a need
11058 to look up their definition from their declaration so
11059 the only disadvantage remains the minimal symbol variant
11060 `long name(params)' does not have the proper inferior type. */
11061 demangled
.reset (gdb_demangle (mangled
,
11062 (DMGL_PARAMS
| DMGL_ANSI
11063 | DMGL_RET_DROP
)));
11066 canon
= demangled
.get ();
11074 if (canon
== NULL
|| check_physname
)
11076 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
11078 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
11080 /* It may not mean a bug in GDB. The compiler could also
11081 compute DW_AT_linkage_name incorrectly. But in such case
11082 GDB would need to be bug-to-bug compatible. */
11084 complaint (_("Computed physname <%s> does not match demangled <%s> "
11085 "(from linkage <%s>) - DIE at %s [in module %s]"),
11086 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
11087 objfile_name (objfile
));
11089 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11090 is available here - over computed PHYSNAME. It is safer
11091 against both buggy GDB and buggy compilers. */
11105 retval
= ((const char *)
11106 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
11107 retval
, strlen (retval
)));
11112 /* Inspect DIE in CU for a namespace alias. If one exists, record
11113 a new symbol for it.
11115 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11118 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
11120 struct attribute
*attr
;
11122 /* If the die does not have a name, this is not a namespace
11124 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
11128 struct die_info
*d
= die
;
11129 struct dwarf2_cu
*imported_cu
= cu
;
11131 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11132 keep inspecting DIEs until we hit the underlying import. */
11133 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11134 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
11136 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
11140 d
= follow_die_ref (d
, attr
, &imported_cu
);
11141 if (d
->tag
!= DW_TAG_imported_declaration
)
11145 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
11147 complaint (_("DIE at %s has too many recursively imported "
11148 "declarations"), sect_offset_str (d
->sect_off
));
11155 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
11157 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
11158 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
11160 /* This declaration is a global namespace alias. Add
11161 a symbol for it whose type is the aliased namespace. */
11162 new_symbol (die
, type
, cu
);
11171 /* Return the using directives repository (global or local?) to use in the
11172 current context for CU.
11174 For Ada, imported declarations can materialize renamings, which *may* be
11175 global. However it is impossible (for now?) in DWARF to distinguish
11176 "external" imported declarations and "static" ones. As all imported
11177 declarations seem to be static in all other languages, make them all CU-wide
11178 global only in Ada. */
11180 static struct using_direct
**
11181 using_directives (struct dwarf2_cu
*cu
)
11183 if (cu
->language
== language_ada
11184 && cu
->get_builder ()->outermost_context_p ())
11185 return cu
->get_builder ()->get_global_using_directives ();
11187 return cu
->get_builder ()->get_local_using_directives ();
11190 /* Read the import statement specified by the given die and record it. */
11193 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
11195 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
11196 struct attribute
*import_attr
;
11197 struct die_info
*imported_die
, *child_die
;
11198 struct dwarf2_cu
*imported_cu
;
11199 const char *imported_name
;
11200 const char *imported_name_prefix
;
11201 const char *canonical_name
;
11202 const char *import_alias
;
11203 const char *imported_declaration
= NULL
;
11204 const char *import_prefix
;
11205 std::vector
<const char *> excludes
;
11207 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
11208 if (import_attr
== NULL
)
11210 complaint (_("Tag '%s' has no DW_AT_import"),
11211 dwarf_tag_name (die
->tag
));
11216 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
11217 imported_name
= dwarf2_name (imported_die
, imported_cu
);
11218 if (imported_name
== NULL
)
11220 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11222 The import in the following code:
11236 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11237 <52> DW_AT_decl_file : 1
11238 <53> DW_AT_decl_line : 6
11239 <54> DW_AT_import : <0x75>
11240 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11241 <59> DW_AT_name : B
11242 <5b> DW_AT_decl_file : 1
11243 <5c> DW_AT_decl_line : 2
11244 <5d> DW_AT_type : <0x6e>
11246 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11247 <76> DW_AT_byte_size : 4
11248 <77> DW_AT_encoding : 5 (signed)
11250 imports the wrong die ( 0x75 instead of 0x58 ).
11251 This case will be ignored until the gcc bug is fixed. */
11255 /* Figure out the local name after import. */
11256 import_alias
= dwarf2_name (die
, cu
);
11258 /* Figure out where the statement is being imported to. */
11259 import_prefix
= determine_prefix (die
, cu
);
11261 /* Figure out what the scope of the imported die is and prepend it
11262 to the name of the imported die. */
11263 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
11265 if (imported_die
->tag
!= DW_TAG_namespace
11266 && imported_die
->tag
!= DW_TAG_module
)
11268 imported_declaration
= imported_name
;
11269 canonical_name
= imported_name_prefix
;
11271 else if (strlen (imported_name_prefix
) > 0)
11272 canonical_name
= obconcat (&objfile
->objfile_obstack
,
11273 imported_name_prefix
,
11274 (cu
->language
== language_d
? "." : "::"),
11275 imported_name
, (char *) NULL
);
11277 canonical_name
= imported_name
;
11279 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
11280 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
11281 child_die
= sibling_die (child_die
))
11283 /* DWARF-4: A Fortran use statement with a “rename list” may be
11284 represented by an imported module entry with an import attribute
11285 referring to the module and owned entries corresponding to those
11286 entities that are renamed as part of being imported. */
11288 if (child_die
->tag
!= DW_TAG_imported_declaration
)
11290 complaint (_("child DW_TAG_imported_declaration expected "
11291 "- DIE at %s [in module %s]"),
11292 sect_offset_str (child_die
->sect_off
),
11293 objfile_name (objfile
));
11297 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
11298 if (import_attr
== NULL
)
11300 complaint (_("Tag '%s' has no DW_AT_import"),
11301 dwarf_tag_name (child_die
->tag
));
11306 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
11308 imported_name
= dwarf2_name (imported_die
, imported_cu
);
11309 if (imported_name
== NULL
)
11311 complaint (_("child DW_TAG_imported_declaration has unknown "
11312 "imported name - DIE at %s [in module %s]"),
11313 sect_offset_str (child_die
->sect_off
),
11314 objfile_name (objfile
));
11318 excludes
.push_back (imported_name
);
11320 process_die (child_die
, cu
);
11323 add_using_directive (using_directives (cu
),
11327 imported_declaration
,
11330 &objfile
->objfile_obstack
);
11333 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11334 types, but gives them a size of zero. Starting with version 14,
11335 ICC is compatible with GCC. */
11338 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
11340 if (!cu
->checked_producer
)
11341 check_producer (cu
);
11343 return cu
->producer_is_icc_lt_14
;
11346 /* ICC generates a DW_AT_type for C void functions. This was observed on
11347 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11348 which says that void functions should not have a DW_AT_type. */
11351 producer_is_icc (struct dwarf2_cu
*cu
)
11353 if (!cu
->checked_producer
)
11354 check_producer (cu
);
11356 return cu
->producer_is_icc
;
11359 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11360 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11361 this, it was first present in GCC release 4.3.0. */
11364 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
11366 if (!cu
->checked_producer
)
11367 check_producer (cu
);
11369 return cu
->producer_is_gcc_lt_4_3
;
11372 static file_and_directory
11373 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
11375 file_and_directory res
;
11377 /* Find the filename. Do not use dwarf2_name here, since the filename
11378 is not a source language identifier. */
11379 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
11380 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
11382 if (res
.comp_dir
== NULL
11383 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
11384 && IS_ABSOLUTE_PATH (res
.name
))
11386 res
.comp_dir_storage
= ldirname (res
.name
);
11387 if (!res
.comp_dir_storage
.empty ())
11388 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
11390 if (res
.comp_dir
!= NULL
)
11392 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11393 directory, get rid of it. */
11394 const char *cp
= strchr (res
.comp_dir
, ':');
11396 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
11397 res
.comp_dir
= cp
+ 1;
11400 if (res
.name
== NULL
)
11401 res
.name
= "<unknown>";
11406 /* Handle DW_AT_stmt_list for a compilation unit.
11407 DIE is the DW_TAG_compile_unit die for CU.
11408 COMP_DIR is the compilation directory. LOWPC is passed to
11409 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11412 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
11413 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
11415 struct dwarf2_per_objfile
*dwarf2_per_objfile
11416 = cu
->per_cu
->dwarf2_per_objfile
;
11417 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11418 struct attribute
*attr
;
11419 struct line_header line_header_local
;
11420 hashval_t line_header_local_hash
;
11422 int decode_mapping
;
11424 gdb_assert (! cu
->per_cu
->is_debug_types
);
11426 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
11430 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
11432 /* The line header hash table is only created if needed (it exists to
11433 prevent redundant reading of the line table for partial_units).
11434 If we're given a partial_unit, we'll need it. If we're given a
11435 compile_unit, then use the line header hash table if it's already
11436 created, but don't create one just yet. */
11438 if (dwarf2_per_objfile
->line_header_hash
== NULL
11439 && die
->tag
== DW_TAG_partial_unit
)
11441 dwarf2_per_objfile
->line_header_hash
11442 = htab_create_alloc_ex (127, line_header_hash_voidp
,
11443 line_header_eq_voidp
,
11444 free_line_header_voidp
,
11445 &objfile
->objfile_obstack
,
11446 hashtab_obstack_allocate
,
11447 dummy_obstack_deallocate
);
11450 line_header_local
.sect_off
= line_offset
;
11451 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
11452 line_header_local_hash
= line_header_hash (&line_header_local
);
11453 if (dwarf2_per_objfile
->line_header_hash
!= NULL
)
11455 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
11456 &line_header_local
,
11457 line_header_local_hash
, NO_INSERT
);
11459 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11460 is not present in *SLOT (since if there is something in *SLOT then
11461 it will be for a partial_unit). */
11462 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
11464 gdb_assert (*slot
!= NULL
);
11465 cu
->line_header
= (struct line_header
*) *slot
;
11470 /* dwarf_decode_line_header does not yet provide sufficient information.
11471 We always have to call also dwarf_decode_lines for it. */
11472 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
11476 cu
->line_header
= lh
.release ();
11477 cu
->line_header_die_owner
= die
;
11479 if (dwarf2_per_objfile
->line_header_hash
== NULL
)
11483 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
11484 &line_header_local
,
11485 line_header_local_hash
, INSERT
);
11486 gdb_assert (slot
!= NULL
);
11488 if (slot
!= NULL
&& *slot
== NULL
)
11490 /* This newly decoded line number information unit will be owned
11491 by line_header_hash hash table. */
11492 *slot
= cu
->line_header
;
11493 cu
->line_header_die_owner
= NULL
;
11497 /* We cannot free any current entry in (*slot) as that struct line_header
11498 may be already used by multiple CUs. Create only temporary decoded
11499 line_header for this CU - it may happen at most once for each line
11500 number information unit. And if we're not using line_header_hash
11501 then this is what we want as well. */
11502 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
11504 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
11505 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
11510 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11513 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11515 struct dwarf2_per_objfile
*dwarf2_per_objfile
11516 = cu
->per_cu
->dwarf2_per_objfile
;
11517 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11518 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11519 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
11520 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
11521 struct attribute
*attr
;
11522 struct die_info
*child_die
;
11523 CORE_ADDR baseaddr
;
11525 prepare_one_comp_unit (cu
, die
, cu
->language
);
11526 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11528 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
11530 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11531 from finish_block. */
11532 if (lowpc
== ((CORE_ADDR
) -1))
11534 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11536 file_and_directory fnd
= find_file_and_directory (die
, cu
);
11538 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11539 standardised yet. As a workaround for the language detection we fall
11540 back to the DW_AT_producer string. */
11541 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
11542 cu
->language
= language_opencl
;
11544 /* Similar hack for Go. */
11545 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
11546 set_cu_language (DW_LANG_Go
, cu
);
11548 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
11550 /* Decode line number information if present. We do this before
11551 processing child DIEs, so that the line header table is available
11552 for DW_AT_decl_file. */
11553 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
11555 /* Process all dies in compilation unit. */
11556 if (die
->child
!= NULL
)
11558 child_die
= die
->child
;
11559 while (child_die
&& child_die
->tag
)
11561 process_die (child_die
, cu
);
11562 child_die
= sibling_die (child_die
);
11566 /* Decode macro information, if present. Dwarf 2 macro information
11567 refers to information in the line number info statement program
11568 header, so we can only read it if we've read the header
11570 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
11572 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
11573 if (attr
&& cu
->line_header
)
11575 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
11576 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11578 dwarf_decode_macros (cu
, DW_UNSND (attr
), 1);
11582 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
11583 if (attr
&& cu
->line_header
)
11585 unsigned int macro_offset
= DW_UNSND (attr
);
11587 dwarf_decode_macros (cu
, macro_offset
, 0);
11593 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
11595 struct type_unit_group
*tu_group
;
11597 struct attribute
*attr
;
11599 struct signatured_type
*sig_type
;
11601 gdb_assert (per_cu
->is_debug_types
);
11602 sig_type
= (struct signatured_type
*) per_cu
;
11604 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
11606 /* If we're using .gdb_index (includes -readnow) then
11607 per_cu->type_unit_group may not have been set up yet. */
11608 if (sig_type
->type_unit_group
== NULL
)
11609 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
11610 tu_group
= sig_type
->type_unit_group
;
11612 /* If we've already processed this stmt_list there's no real need to
11613 do it again, we could fake it and just recreate the part we need
11614 (file name,index -> symtab mapping). If data shows this optimization
11615 is useful we can do it then. */
11616 first_time
= tu_group
->compunit_symtab
== NULL
;
11618 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11623 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
11624 lh
= dwarf_decode_line_header (line_offset
, this);
11629 start_symtab ("", NULL
, 0);
11632 gdb_assert (tu_group
->symtabs
== NULL
);
11633 gdb_assert (m_builder
== nullptr);
11634 struct compunit_symtab
*cust
= tu_group
->compunit_symtab
;
11635 m_builder
.reset (new struct buildsym_compunit
11636 (COMPUNIT_OBJFILE (cust
), "",
11637 COMPUNIT_DIRNAME (cust
),
11638 compunit_language (cust
),
11644 line_header
= lh
.release ();
11645 line_header_die_owner
= die
;
11649 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
11651 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11652 still initializing it, and our caller (a few levels up)
11653 process_full_type_unit still needs to know if this is the first
11656 tu_group
->num_symtabs
= line_header
->file_names
.size ();
11657 tu_group
->symtabs
= XNEWVEC (struct symtab
*,
11658 line_header
->file_names
.size ());
11660 for (i
= 0; i
< line_header
->file_names
.size (); ++i
)
11662 file_entry
&fe
= line_header
->file_names
[i
];
11664 dwarf2_start_subfile (this, fe
.name
,
11665 fe
.include_dir (line_header
));
11666 buildsym_compunit
*b
= get_builder ();
11667 if (b
->get_current_subfile ()->symtab
== NULL
)
11669 /* NOTE: start_subfile will recognize when it's been
11670 passed a file it has already seen. So we can't
11671 assume there's a simple mapping from
11672 cu->line_header->file_names to subfiles, plus
11673 cu->line_header->file_names may contain dups. */
11674 b
->get_current_subfile ()->symtab
11675 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
11678 fe
.symtab
= b
->get_current_subfile ()->symtab
;
11679 tu_group
->symtabs
[i
] = fe
.symtab
;
11684 gdb_assert (m_builder
== nullptr);
11685 struct compunit_symtab
*cust
= tu_group
->compunit_symtab
;
11686 m_builder
.reset (new struct buildsym_compunit
11687 (COMPUNIT_OBJFILE (cust
), "",
11688 COMPUNIT_DIRNAME (cust
),
11689 compunit_language (cust
),
11692 for (i
= 0; i
< line_header
->file_names
.size (); ++i
)
11694 file_entry
&fe
= line_header
->file_names
[i
];
11696 fe
.symtab
= tu_group
->symtabs
[i
];
11700 /* The main symtab is allocated last. Type units don't have DW_AT_name
11701 so they don't have a "real" (so to speak) symtab anyway.
11702 There is later code that will assign the main symtab to all symbols
11703 that don't have one. We need to handle the case of a symbol with a
11704 missing symtab (DW_AT_decl_file) anyway. */
11707 /* Process DW_TAG_type_unit.
11708 For TUs we want to skip the first top level sibling if it's not the
11709 actual type being defined by this TU. In this case the first top
11710 level sibling is there to provide context only. */
11713 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11715 struct die_info
*child_die
;
11717 prepare_one_comp_unit (cu
, die
, language_minimal
);
11719 /* Initialize (or reinitialize) the machinery for building symtabs.
11720 We do this before processing child DIEs, so that the line header table
11721 is available for DW_AT_decl_file. */
11722 cu
->setup_type_unit_groups (die
);
11724 if (die
->child
!= NULL
)
11726 child_die
= die
->child
;
11727 while (child_die
&& child_die
->tag
)
11729 process_die (child_die
, cu
);
11730 child_die
= sibling_die (child_die
);
11737 http://gcc.gnu.org/wiki/DebugFission
11738 http://gcc.gnu.org/wiki/DebugFissionDWP
11740 To simplify handling of both DWO files ("object" files with the DWARF info)
11741 and DWP files (a file with the DWOs packaged up into one file), we treat
11742 DWP files as having a collection of virtual DWO files. */
11745 hash_dwo_file (const void *item
)
11747 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
11750 hash
= htab_hash_string (dwo_file
->dwo_name
);
11751 if (dwo_file
->comp_dir
!= NULL
)
11752 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11757 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11759 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11760 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11762 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11764 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11765 return lhs
->comp_dir
== rhs
->comp_dir
;
11766 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11769 /* Allocate a hash table for DWO files. */
11772 allocate_dwo_file_hash_table (struct objfile
*objfile
)
11774 auto delete_dwo_file
= [] (void *item
)
11776 struct dwo_file
*dwo_file
= (struct dwo_file
*) item
;
11781 return htab_up (htab_create_alloc_ex (41,
11785 &objfile
->objfile_obstack
,
11786 hashtab_obstack_allocate
,
11787 dummy_obstack_deallocate
));
11790 /* Lookup DWO file DWO_NAME. */
11793 lookup_dwo_file_slot (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11794 const char *dwo_name
,
11795 const char *comp_dir
)
11797 struct dwo_file find_entry
;
11800 if (dwarf2_per_objfile
->dwo_files
== NULL
)
11801 dwarf2_per_objfile
->dwo_files
11802 = allocate_dwo_file_hash_table (dwarf2_per_objfile
->objfile
);
11804 find_entry
.dwo_name
= dwo_name
;
11805 find_entry
.comp_dir
= comp_dir
;
11806 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
.get (), &find_entry
,
11813 hash_dwo_unit (const void *item
)
11815 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11817 /* This drops the top 32 bits of the id, but is ok for a hash. */
11818 return dwo_unit
->signature
;
11822 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11824 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11825 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11827 /* The signature is assumed to be unique within the DWO file.
11828 So while object file CU dwo_id's always have the value zero,
11829 that's OK, assuming each object file DWO file has only one CU,
11830 and that's the rule for now. */
11831 return lhs
->signature
== rhs
->signature
;
11834 /* Allocate a hash table for DWO CUs,TUs.
11835 There is one of these tables for each of CUs,TUs for each DWO file. */
11838 allocate_dwo_unit_table (struct objfile
*objfile
)
11840 /* Start out with a pretty small number.
11841 Generally DWO files contain only one CU and maybe some TUs. */
11842 return htab_create_alloc_ex (3,
11846 &objfile
->objfile_obstack
,
11847 hashtab_obstack_allocate
,
11848 dummy_obstack_deallocate
);
11851 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11853 struct create_dwo_cu_data
11855 struct dwo_file
*dwo_file
;
11856 struct dwo_unit dwo_unit
;
11859 /* die_reader_func for create_dwo_cu. */
11862 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
11863 const gdb_byte
*info_ptr
,
11864 struct die_info
*comp_unit_die
,
11868 struct dwarf2_cu
*cu
= reader
->cu
;
11869 sect_offset sect_off
= cu
->per_cu
->sect_off
;
11870 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
11871 struct create_dwo_cu_data
*data
= (struct create_dwo_cu_data
*) datap
;
11872 struct dwo_file
*dwo_file
= data
->dwo_file
;
11873 struct dwo_unit
*dwo_unit
= &data
->dwo_unit
;
11874 struct attribute
*attr
;
11876 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
11879 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11880 " its dwo_id [in module %s]"),
11881 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
11885 dwo_unit
->dwo_file
= dwo_file
;
11886 dwo_unit
->signature
= DW_UNSND (attr
);
11887 dwo_unit
->section
= section
;
11888 dwo_unit
->sect_off
= sect_off
;
11889 dwo_unit
->length
= cu
->per_cu
->length
;
11891 if (dwarf_read_debug
)
11892 fprintf_unfiltered (gdb_stdlog
, " offset %s, dwo_id %s\n",
11893 sect_offset_str (sect_off
),
11894 hex_string (dwo_unit
->signature
));
11897 /* Create the dwo_units for the CUs in a DWO_FILE.
11898 Note: This function processes DWO files only, not DWP files. */
11901 create_cus_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11902 struct dwo_file
&dwo_file
, dwarf2_section_info
§ion
,
11905 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11906 const gdb_byte
*info_ptr
, *end_ptr
;
11908 dwarf2_read_section (objfile
, §ion
);
11909 info_ptr
= section
.buffer
;
11911 if (info_ptr
== NULL
)
11914 if (dwarf_read_debug
)
11916 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
11917 get_section_name (§ion
),
11918 get_section_file_name (§ion
));
11921 end_ptr
= info_ptr
+ section
.size
;
11922 while (info_ptr
< end_ptr
)
11924 struct dwarf2_per_cu_data per_cu
;
11925 struct create_dwo_cu_data create_dwo_cu_data
;
11926 struct dwo_unit
*dwo_unit
;
11928 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
11930 memset (&create_dwo_cu_data
.dwo_unit
, 0,
11931 sizeof (create_dwo_cu_data
.dwo_unit
));
11932 memset (&per_cu
, 0, sizeof (per_cu
));
11933 per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
11934 per_cu
.is_debug_types
= 0;
11935 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
11936 per_cu
.section
= §ion
;
11937 create_dwo_cu_data
.dwo_file
= &dwo_file
;
11939 init_cutu_and_read_dies_no_follow (
11940 &per_cu
, &dwo_file
, create_dwo_cu_reader
, &create_dwo_cu_data
);
11941 info_ptr
+= per_cu
.length
;
11943 // If the unit could not be parsed, skip it.
11944 if (create_dwo_cu_data
.dwo_unit
.dwo_file
== NULL
)
11947 if (cus_htab
== NULL
)
11948 cus_htab
= allocate_dwo_unit_table (objfile
);
11950 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
11951 *dwo_unit
= create_dwo_cu_data
.dwo_unit
;
11952 slot
= htab_find_slot (cus_htab
, dwo_unit
, INSERT
);
11953 gdb_assert (slot
!= NULL
);
11956 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
11957 sect_offset dup_sect_off
= dup_cu
->sect_off
;
11959 complaint (_("debug cu entry at offset %s is duplicate to"
11960 " the entry at offset %s, signature %s"),
11961 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
11962 hex_string (dwo_unit
->signature
));
11964 *slot
= (void *)dwo_unit
;
11968 /* DWP file .debug_{cu,tu}_index section format:
11969 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11973 Both index sections have the same format, and serve to map a 64-bit
11974 signature to a set of section numbers. Each section begins with a header,
11975 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11976 indexes, and a pool of 32-bit section numbers. The index sections will be
11977 aligned at 8-byte boundaries in the file.
11979 The index section header consists of:
11981 V, 32 bit version number
11983 N, 32 bit number of compilation units or type units in the index
11984 M, 32 bit number of slots in the hash table
11986 Numbers are recorded using the byte order of the application binary.
11988 The hash table begins at offset 16 in the section, and consists of an array
11989 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11990 order of the application binary). Unused slots in the hash table are 0.
11991 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11993 The parallel table begins immediately after the hash table
11994 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11995 array of 32-bit indexes (using the byte order of the application binary),
11996 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11997 table contains a 32-bit index into the pool of section numbers. For unused
11998 hash table slots, the corresponding entry in the parallel table will be 0.
12000 The pool of section numbers begins immediately following the hash table
12001 (at offset 16 + 12 * M from the beginning of the section). The pool of
12002 section numbers consists of an array of 32-bit words (using the byte order
12003 of the application binary). Each item in the array is indexed starting
12004 from 0. The hash table entry provides the index of the first section
12005 number in the set. Additional section numbers in the set follow, and the
12006 set is terminated by a 0 entry (section number 0 is not used in ELF).
12008 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12009 section must be the first entry in the set, and the .debug_abbrev.dwo must
12010 be the second entry. Other members of the set may follow in any order.
12016 DWP Version 2 combines all the .debug_info, etc. sections into one,
12017 and the entries in the index tables are now offsets into these sections.
12018 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
12021 Index Section Contents:
12023 Hash Table of Signatures dwp_hash_table.hash_table
12024 Parallel Table of Indices dwp_hash_table.unit_table
12025 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
12026 Table of Section Sizes dwp_hash_table.v2.sizes
12028 The index section header consists of:
12030 V, 32 bit version number
12031 L, 32 bit number of columns in the table of section offsets
12032 N, 32 bit number of compilation units or type units in the index
12033 M, 32 bit number of slots in the hash table
12035 Numbers are recorded using the byte order of the application binary.
12037 The hash table has the same format as version 1.
12038 The parallel table of indices has the same format as version 1,
12039 except that the entries are origin-1 indices into the table of sections
12040 offsets and the table of section sizes.
12042 The table of offsets begins immediately following the parallel table
12043 (at offset 16 + 12 * M from the beginning of the section). The table is
12044 a two-dimensional array of 32-bit words (using the byte order of the
12045 application binary), with L columns and N+1 rows, in row-major order.
12046 Each row in the array is indexed starting from 0. The first row provides
12047 a key to the remaining rows: each column in this row provides an identifier
12048 for a debug section, and the offsets in the same column of subsequent rows
12049 refer to that section. The section identifiers are:
12051 DW_SECT_INFO 1 .debug_info.dwo
12052 DW_SECT_TYPES 2 .debug_types.dwo
12053 DW_SECT_ABBREV 3 .debug_abbrev.dwo
12054 DW_SECT_LINE 4 .debug_line.dwo
12055 DW_SECT_LOC 5 .debug_loc.dwo
12056 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
12057 DW_SECT_MACINFO 7 .debug_macinfo.dwo
12058 DW_SECT_MACRO 8 .debug_macro.dwo
12060 The offsets provided by the CU and TU index sections are the base offsets
12061 for the contributions made by each CU or TU to the corresponding section
12062 in the package file. Each CU and TU header contains an abbrev_offset
12063 field, used to find the abbreviations table for that CU or TU within the
12064 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12065 be interpreted as relative to the base offset given in the index section.
12066 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12067 should be interpreted as relative to the base offset for .debug_line.dwo,
12068 and offsets into other debug sections obtained from DWARF attributes should
12069 also be interpreted as relative to the corresponding base offset.
12071 The table of sizes begins immediately following the table of offsets.
12072 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12073 with L columns and N rows, in row-major order. Each row in the array is
12074 indexed starting from 1 (row 0 is shared by the two tables).
12078 Hash table lookup is handled the same in version 1 and 2:
12080 We assume that N and M will not exceed 2^32 - 1.
12081 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12083 Given a 64-bit compilation unit signature or a type signature S, an entry
12084 in the hash table is located as follows:
12086 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12087 the low-order k bits all set to 1.
12089 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12091 3) If the hash table entry at index H matches the signature, use that
12092 entry. If the hash table entry at index H is unused (all zeroes),
12093 terminate the search: the signature is not present in the table.
12095 4) Let H = (H + H') modulo M. Repeat at Step 3.
12097 Because M > N and H' and M are relatively prime, the search is guaranteed
12098 to stop at an unused slot or find the match. */
12100 /* Create a hash table to map DWO IDs to their CU/TU entry in
12101 .debug_{info,types}.dwo in DWP_FILE.
12102 Returns NULL if there isn't one.
12103 Note: This function processes DWP files only, not DWO files. */
12105 static struct dwp_hash_table
*
12106 create_dwp_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12107 struct dwp_file
*dwp_file
, int is_debug_types
)
12109 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12110 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12111 const gdb_byte
*index_ptr
, *index_end
;
12112 struct dwarf2_section_info
*index
;
12113 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
12114 struct dwp_hash_table
*htab
;
12116 if (is_debug_types
)
12117 index
= &dwp_file
->sections
.tu_index
;
12119 index
= &dwp_file
->sections
.cu_index
;
12121 if (dwarf2_section_empty_p (index
))
12123 dwarf2_read_section (objfile
, index
);
12125 index_ptr
= index
->buffer
;
12126 index_end
= index_ptr
+ index
->size
;
12128 version
= read_4_bytes (dbfd
, index_ptr
);
12131 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
12135 nr_units
= read_4_bytes (dbfd
, index_ptr
);
12137 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
12140 if (version
!= 1 && version
!= 2)
12142 error (_("Dwarf Error: unsupported DWP file version (%s)"
12143 " [in module %s]"),
12144 pulongest (version
), dwp_file
->name
);
12146 if (nr_slots
!= (nr_slots
& -nr_slots
))
12148 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12149 " is not power of 2 [in module %s]"),
12150 pulongest (nr_slots
), dwp_file
->name
);
12153 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
12154 htab
->version
= version
;
12155 htab
->nr_columns
= nr_columns
;
12156 htab
->nr_units
= nr_units
;
12157 htab
->nr_slots
= nr_slots
;
12158 htab
->hash_table
= index_ptr
;
12159 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
12161 /* Exit early if the table is empty. */
12162 if (nr_slots
== 0 || nr_units
== 0
12163 || (version
== 2 && nr_columns
== 0))
12165 /* All must be zero. */
12166 if (nr_slots
!= 0 || nr_units
!= 0
12167 || (version
== 2 && nr_columns
!= 0))
12169 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12170 " all zero [in modules %s]"),
12178 htab
->section_pool
.v1
.indices
=
12179 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
12180 /* It's harder to decide whether the section is too small in v1.
12181 V1 is deprecated anyway so we punt. */
12185 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
12186 int *ids
= htab
->section_pool
.v2
.section_ids
;
12187 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
12188 /* Reverse map for error checking. */
12189 int ids_seen
[DW_SECT_MAX
+ 1];
12192 if (nr_columns
< 2)
12194 error (_("Dwarf Error: bad DWP hash table, too few columns"
12195 " in section table [in module %s]"),
12198 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
12200 error (_("Dwarf Error: bad DWP hash table, too many columns"
12201 " in section table [in module %s]"),
12204 memset (ids
, 255, sizeof_ids
);
12205 memset (ids_seen
, 255, sizeof (ids_seen
));
12206 for (i
= 0; i
< nr_columns
; ++i
)
12208 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
12210 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
12212 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12213 " in section table [in module %s]"),
12214 id
, dwp_file
->name
);
12216 if (ids_seen
[id
] != -1)
12218 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12219 " id %d in section table [in module %s]"),
12220 id
, dwp_file
->name
);
12225 /* Must have exactly one info or types section. */
12226 if (((ids_seen
[DW_SECT_INFO
] != -1)
12227 + (ids_seen
[DW_SECT_TYPES
] != -1))
12230 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12231 " DWO info/types section [in module %s]"),
12234 /* Must have an abbrev section. */
12235 if (ids_seen
[DW_SECT_ABBREV
] == -1)
12237 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12238 " section [in module %s]"),
12241 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
12242 htab
->section_pool
.v2
.sizes
=
12243 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
12244 * nr_units
* nr_columns
);
12245 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
12246 * nr_units
* nr_columns
))
12249 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12250 " [in module %s]"),
12258 /* Update SECTIONS with the data from SECTP.
12260 This function is like the other "locate" section routines that are
12261 passed to bfd_map_over_sections, but in this context the sections to
12262 read comes from the DWP V1 hash table, not the full ELF section table.
12264 The result is non-zero for success, or zero if an error was found. */
12267 locate_v1_virtual_dwo_sections (asection
*sectp
,
12268 struct virtual_v1_dwo_sections
*sections
)
12270 const struct dwop_section_names
*names
= &dwop_section_names
;
12272 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12274 /* There can be only one. */
12275 if (sections
->abbrev
.s
.section
!= NULL
)
12277 sections
->abbrev
.s
.section
= sectp
;
12278 sections
->abbrev
.size
= bfd_get_section_size (sectp
);
12280 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
12281 || section_is_p (sectp
->name
, &names
->types_dwo
))
12283 /* There can be only one. */
12284 if (sections
->info_or_types
.s
.section
!= NULL
)
12286 sections
->info_or_types
.s
.section
= sectp
;
12287 sections
->info_or_types
.size
= bfd_get_section_size (sectp
);
12289 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12291 /* There can be only one. */
12292 if (sections
->line
.s
.section
!= NULL
)
12294 sections
->line
.s
.section
= sectp
;
12295 sections
->line
.size
= bfd_get_section_size (sectp
);
12297 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12299 /* There can be only one. */
12300 if (sections
->loc
.s
.section
!= NULL
)
12302 sections
->loc
.s
.section
= sectp
;
12303 sections
->loc
.size
= bfd_get_section_size (sectp
);
12305 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12307 /* There can be only one. */
12308 if (sections
->macinfo
.s
.section
!= NULL
)
12310 sections
->macinfo
.s
.section
= sectp
;
12311 sections
->macinfo
.size
= bfd_get_section_size (sectp
);
12313 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12315 /* There can be only one. */
12316 if (sections
->macro
.s
.section
!= NULL
)
12318 sections
->macro
.s
.section
= sectp
;
12319 sections
->macro
.size
= bfd_get_section_size (sectp
);
12321 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12323 /* There can be only one. */
12324 if (sections
->str_offsets
.s
.section
!= NULL
)
12326 sections
->str_offsets
.s
.section
= sectp
;
12327 sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
12331 /* No other kind of section is valid. */
12338 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12339 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12340 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12341 This is for DWP version 1 files. */
12343 static struct dwo_unit
*
12344 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12345 struct dwp_file
*dwp_file
,
12346 uint32_t unit_index
,
12347 const char *comp_dir
,
12348 ULONGEST signature
, int is_debug_types
)
12350 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12351 const struct dwp_hash_table
*dwp_htab
=
12352 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12353 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12354 const char *kind
= is_debug_types
? "TU" : "CU";
12355 struct dwo_file
*dwo_file
;
12356 struct dwo_unit
*dwo_unit
;
12357 struct virtual_v1_dwo_sections sections
;
12358 void **dwo_file_slot
;
12361 gdb_assert (dwp_file
->version
== 1);
12363 if (dwarf_read_debug
)
12365 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
12367 pulongest (unit_index
), hex_string (signature
),
12371 /* Fetch the sections of this DWO unit.
12372 Put a limit on the number of sections we look for so that bad data
12373 doesn't cause us to loop forever. */
12375 #define MAX_NR_V1_DWO_SECTIONS \
12376 (1 /* .debug_info or .debug_types */ \
12377 + 1 /* .debug_abbrev */ \
12378 + 1 /* .debug_line */ \
12379 + 1 /* .debug_loc */ \
12380 + 1 /* .debug_str_offsets */ \
12381 + 1 /* .debug_macro or .debug_macinfo */ \
12382 + 1 /* trailing zero */)
12384 memset (§ions
, 0, sizeof (sections
));
12386 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
12389 uint32_t section_nr
=
12390 read_4_bytes (dbfd
,
12391 dwp_htab
->section_pool
.v1
.indices
12392 + (unit_index
+ i
) * sizeof (uint32_t));
12394 if (section_nr
== 0)
12396 if (section_nr
>= dwp_file
->num_sections
)
12398 error (_("Dwarf Error: bad DWP hash table, section number too large"
12399 " [in module %s]"),
12403 sectp
= dwp_file
->elf_sections
[section_nr
];
12404 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
12406 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12407 " [in module %s]"),
12413 || dwarf2_section_empty_p (§ions
.info_or_types
)
12414 || dwarf2_section_empty_p (§ions
.abbrev
))
12416 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12417 " [in module %s]"),
12420 if (i
== MAX_NR_V1_DWO_SECTIONS
)
12422 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12423 " [in module %s]"),
12427 /* It's easier for the rest of the code if we fake a struct dwo_file and
12428 have dwo_unit "live" in that. At least for now.
12430 The DWP file can be made up of a random collection of CUs and TUs.
12431 However, for each CU + set of TUs that came from the same original DWO
12432 file, we can combine them back into a virtual DWO file to save space
12433 (fewer struct dwo_file objects to allocate). Remember that for really
12434 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12436 std::string virtual_dwo_name
=
12437 string_printf ("virtual-dwo/%d-%d-%d-%d",
12438 get_section_id (§ions
.abbrev
),
12439 get_section_id (§ions
.line
),
12440 get_section_id (§ions
.loc
),
12441 get_section_id (§ions
.str_offsets
));
12442 /* Can we use an existing virtual DWO file? */
12443 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
12444 virtual_dwo_name
.c_str (),
12446 /* Create one if necessary. */
12447 if (*dwo_file_slot
== NULL
)
12449 if (dwarf_read_debug
)
12451 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12452 virtual_dwo_name
.c_str ());
12454 dwo_file
= new struct dwo_file
;
12456 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
12457 virtual_dwo_name
.c_str (),
12458 virtual_dwo_name
.size ());
12459 dwo_file
->comp_dir
= comp_dir
;
12460 dwo_file
->sections
.abbrev
= sections
.abbrev
;
12461 dwo_file
->sections
.line
= sections
.line
;
12462 dwo_file
->sections
.loc
= sections
.loc
;
12463 dwo_file
->sections
.macinfo
= sections
.macinfo
;
12464 dwo_file
->sections
.macro
= sections
.macro
;
12465 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
12466 /* The "str" section is global to the entire DWP file. */
12467 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12468 /* The info or types section is assigned below to dwo_unit,
12469 there's no need to record it in dwo_file.
12470 Also, we can't simply record type sections in dwo_file because
12471 we record a pointer into the vector in dwo_unit. As we collect more
12472 types we'll grow the vector and eventually have to reallocate space
12473 for it, invalidating all copies of pointers into the previous
12475 *dwo_file_slot
= dwo_file
;
12479 if (dwarf_read_debug
)
12481 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12482 virtual_dwo_name
.c_str ());
12484 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12487 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12488 dwo_unit
->dwo_file
= dwo_file
;
12489 dwo_unit
->signature
= signature
;
12490 dwo_unit
->section
=
12491 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
12492 *dwo_unit
->section
= sections
.info_or_types
;
12493 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12498 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12499 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12500 piece within that section used by a TU/CU, return a virtual section
12501 of just that piece. */
12503 static struct dwarf2_section_info
12504 create_dwp_v2_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12505 struct dwarf2_section_info
*section
,
12506 bfd_size_type offset
, bfd_size_type size
)
12508 struct dwarf2_section_info result
;
12511 gdb_assert (section
!= NULL
);
12512 gdb_assert (!section
->is_virtual
);
12514 memset (&result
, 0, sizeof (result
));
12515 result
.s
.containing_section
= section
;
12516 result
.is_virtual
= true;
12521 sectp
= get_section_bfd_section (section
);
12523 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12524 bounds of the real section. This is a pretty-rare event, so just
12525 flag an error (easier) instead of a warning and trying to cope. */
12527 || offset
+ size
> bfd_get_section_size (sectp
))
12529 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12530 " in section %s [in module %s]"),
12531 sectp
? bfd_section_name (abfd
, sectp
) : "<unknown>",
12532 objfile_name (dwarf2_per_objfile
->objfile
));
12535 result
.virtual_offset
= offset
;
12536 result
.size
= size
;
12540 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12541 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12542 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12543 This is for DWP version 2 files. */
12545 static struct dwo_unit
*
12546 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12547 struct dwp_file
*dwp_file
,
12548 uint32_t unit_index
,
12549 const char *comp_dir
,
12550 ULONGEST signature
, int is_debug_types
)
12552 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12553 const struct dwp_hash_table
*dwp_htab
=
12554 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12555 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12556 const char *kind
= is_debug_types
? "TU" : "CU";
12557 struct dwo_file
*dwo_file
;
12558 struct dwo_unit
*dwo_unit
;
12559 struct virtual_v2_dwo_sections sections
;
12560 void **dwo_file_slot
;
12563 gdb_assert (dwp_file
->version
== 2);
12565 if (dwarf_read_debug
)
12567 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
12569 pulongest (unit_index
), hex_string (signature
),
12573 /* Fetch the section offsets of this DWO unit. */
12575 memset (§ions
, 0, sizeof (sections
));
12577 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12579 uint32_t offset
= read_4_bytes (dbfd
,
12580 dwp_htab
->section_pool
.v2
.offsets
12581 + (((unit_index
- 1) * dwp_htab
->nr_columns
12583 * sizeof (uint32_t)));
12584 uint32_t size
= read_4_bytes (dbfd
,
12585 dwp_htab
->section_pool
.v2
.sizes
12586 + (((unit_index
- 1) * dwp_htab
->nr_columns
12588 * sizeof (uint32_t)));
12590 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
12593 case DW_SECT_TYPES
:
12594 sections
.info_or_types_offset
= offset
;
12595 sections
.info_or_types_size
= size
;
12597 case DW_SECT_ABBREV
:
12598 sections
.abbrev_offset
= offset
;
12599 sections
.abbrev_size
= size
;
12602 sections
.line_offset
= offset
;
12603 sections
.line_size
= size
;
12606 sections
.loc_offset
= offset
;
12607 sections
.loc_size
= size
;
12609 case DW_SECT_STR_OFFSETS
:
12610 sections
.str_offsets_offset
= offset
;
12611 sections
.str_offsets_size
= size
;
12613 case DW_SECT_MACINFO
:
12614 sections
.macinfo_offset
= offset
;
12615 sections
.macinfo_size
= size
;
12617 case DW_SECT_MACRO
:
12618 sections
.macro_offset
= offset
;
12619 sections
.macro_size
= size
;
12624 /* It's easier for the rest of the code if we fake a struct dwo_file and
12625 have dwo_unit "live" in that. At least for now.
12627 The DWP file can be made up of a random collection of CUs and TUs.
12628 However, for each CU + set of TUs that came from the same original DWO
12629 file, we can combine them back into a virtual DWO file to save space
12630 (fewer struct dwo_file objects to allocate). Remember that for really
12631 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12633 std::string virtual_dwo_name
=
12634 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12635 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12636 (long) (sections
.line_size
? sections
.line_offset
: 0),
12637 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
12638 (long) (sections
.str_offsets_size
12639 ? sections
.str_offsets_offset
: 0));
12640 /* Can we use an existing virtual DWO file? */
12641 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
12642 virtual_dwo_name
.c_str (),
12644 /* Create one if necessary. */
12645 if (*dwo_file_slot
== NULL
)
12647 if (dwarf_read_debug
)
12649 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12650 virtual_dwo_name
.c_str ());
12652 dwo_file
= new struct dwo_file
;
12654 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
12655 virtual_dwo_name
.c_str (),
12656 virtual_dwo_name
.size ());
12657 dwo_file
->comp_dir
= comp_dir
;
12658 dwo_file
->sections
.abbrev
=
12659 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.abbrev
,
12660 sections
.abbrev_offset
, sections
.abbrev_size
);
12661 dwo_file
->sections
.line
=
12662 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.line
,
12663 sections
.line_offset
, sections
.line_size
);
12664 dwo_file
->sections
.loc
=
12665 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.loc
,
12666 sections
.loc_offset
, sections
.loc_size
);
12667 dwo_file
->sections
.macinfo
=
12668 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macinfo
,
12669 sections
.macinfo_offset
, sections
.macinfo_size
);
12670 dwo_file
->sections
.macro
=
12671 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macro
,
12672 sections
.macro_offset
, sections
.macro_size
);
12673 dwo_file
->sections
.str_offsets
=
12674 create_dwp_v2_section (dwarf2_per_objfile
,
12675 &dwp_file
->sections
.str_offsets
,
12676 sections
.str_offsets_offset
,
12677 sections
.str_offsets_size
);
12678 /* The "str" section is global to the entire DWP file. */
12679 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12680 /* The info or types section is assigned below to dwo_unit,
12681 there's no need to record it in dwo_file.
12682 Also, we can't simply record type sections in dwo_file because
12683 we record a pointer into the vector in dwo_unit. As we collect more
12684 types we'll grow the vector and eventually have to reallocate space
12685 for it, invalidating all copies of pointers into the previous
12687 *dwo_file_slot
= dwo_file
;
12691 if (dwarf_read_debug
)
12693 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12694 virtual_dwo_name
.c_str ());
12696 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12699 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12700 dwo_unit
->dwo_file
= dwo_file
;
12701 dwo_unit
->signature
= signature
;
12702 dwo_unit
->section
=
12703 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
12704 *dwo_unit
->section
= create_dwp_v2_section (dwarf2_per_objfile
,
12706 ? &dwp_file
->sections
.types
12707 : &dwp_file
->sections
.info
,
12708 sections
.info_or_types_offset
,
12709 sections
.info_or_types_size
);
12710 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12715 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12716 Returns NULL if the signature isn't found. */
12718 static struct dwo_unit
*
12719 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12720 struct dwp_file
*dwp_file
, const char *comp_dir
,
12721 ULONGEST signature
, int is_debug_types
)
12723 const struct dwp_hash_table
*dwp_htab
=
12724 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12725 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12726 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12727 uint32_t hash
= signature
& mask
;
12728 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12731 struct dwo_unit find_dwo_cu
;
12733 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12734 find_dwo_cu
.signature
= signature
;
12735 slot
= htab_find_slot (is_debug_types
12736 ? dwp_file
->loaded_tus
12737 : dwp_file
->loaded_cus
,
12738 &find_dwo_cu
, INSERT
);
12741 return (struct dwo_unit
*) *slot
;
12743 /* Use a for loop so that we don't loop forever on bad debug info. */
12744 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12746 ULONGEST signature_in_table
;
12748 signature_in_table
=
12749 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12750 if (signature_in_table
== signature
)
12752 uint32_t unit_index
=
12753 read_4_bytes (dbfd
,
12754 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12756 if (dwp_file
->version
== 1)
12758 *slot
= create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
,
12759 dwp_file
, unit_index
,
12760 comp_dir
, signature
,
12765 *slot
= create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
,
12766 dwp_file
, unit_index
,
12767 comp_dir
, signature
,
12770 return (struct dwo_unit
*) *slot
;
12772 if (signature_in_table
== 0)
12774 hash
= (hash
+ hash2
) & mask
;
12777 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12778 " [in module %s]"),
12782 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12783 Open the file specified by FILE_NAME and hand it off to BFD for
12784 preliminary analysis. Return a newly initialized bfd *, which
12785 includes a canonicalized copy of FILE_NAME.
12786 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12787 SEARCH_CWD is true if the current directory is to be searched.
12788 It will be searched before debug-file-directory.
12789 If successful, the file is added to the bfd include table of the
12790 objfile's bfd (see gdb_bfd_record_inclusion).
12791 If unable to find/open the file, return NULL.
12792 NOTE: This function is derived from symfile_bfd_open. */
12794 static gdb_bfd_ref_ptr
12795 try_open_dwop_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12796 const char *file_name
, int is_dwp
, int search_cwd
)
12799 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12800 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12801 to debug_file_directory. */
12802 const char *search_path
;
12803 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12805 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12808 if (*debug_file_directory
!= '\0')
12810 search_path_holder
.reset (concat (".", dirname_separator_string
,
12811 debug_file_directory
,
12813 search_path
= search_path_holder
.get ();
12819 search_path
= debug_file_directory
;
12821 openp_flags flags
= OPF_RETURN_REALPATH
;
12823 flags
|= OPF_SEARCH_IN_PATH
;
12825 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12826 desc
= openp (search_path
, flags
, file_name
,
12827 O_RDONLY
| O_BINARY
, &absolute_name
);
12831 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12833 if (sym_bfd
== NULL
)
12835 bfd_set_cacheable (sym_bfd
.get (), 1);
12837 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12840 /* Success. Record the bfd as having been included by the objfile's bfd.
12841 This is important because things like demangled_names_hash lives in the
12842 objfile's per_bfd space and may have references to things like symbol
12843 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12844 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12849 /* Try to open DWO file FILE_NAME.
12850 COMP_DIR is the DW_AT_comp_dir attribute.
12851 The result is the bfd handle of the file.
12852 If there is a problem finding or opening the file, return NULL.
12853 Upon success, the canonicalized path of the file is stored in the bfd,
12854 same as symfile_bfd_open. */
12856 static gdb_bfd_ref_ptr
12857 open_dwo_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12858 const char *file_name
, const char *comp_dir
)
12860 if (IS_ABSOLUTE_PATH (file_name
))
12861 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12862 0 /*is_dwp*/, 0 /*search_cwd*/);
12864 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12866 if (comp_dir
!= NULL
)
12868 char *path_to_try
= concat (comp_dir
, SLASH_STRING
,
12869 file_name
, (char *) NULL
);
12871 /* NOTE: If comp_dir is a relative path, this will also try the
12872 search path, which seems useful. */
12873 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
,
12876 1 /*search_cwd*/));
12877 xfree (path_to_try
);
12882 /* That didn't work, try debug-file-directory, which, despite its name,
12883 is a list of paths. */
12885 if (*debug_file_directory
== '\0')
12888 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12889 0 /*is_dwp*/, 1 /*search_cwd*/);
12892 /* This function is mapped across the sections and remembers the offset and
12893 size of each of the DWO debugging sections we are interested in. */
12896 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
12898 struct dwo_sections
*dwo_sections
= (struct dwo_sections
*) dwo_sections_ptr
;
12899 const struct dwop_section_names
*names
= &dwop_section_names
;
12901 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12903 dwo_sections
->abbrev
.s
.section
= sectp
;
12904 dwo_sections
->abbrev
.size
= bfd_get_section_size (sectp
);
12906 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12908 dwo_sections
->info
.s
.section
= sectp
;
12909 dwo_sections
->info
.size
= bfd_get_section_size (sectp
);
12911 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12913 dwo_sections
->line
.s
.section
= sectp
;
12914 dwo_sections
->line
.size
= bfd_get_section_size (sectp
);
12916 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12918 dwo_sections
->loc
.s
.section
= sectp
;
12919 dwo_sections
->loc
.size
= bfd_get_section_size (sectp
);
12921 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12923 dwo_sections
->macinfo
.s
.section
= sectp
;
12924 dwo_sections
->macinfo
.size
= bfd_get_section_size (sectp
);
12926 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12928 dwo_sections
->macro
.s
.section
= sectp
;
12929 dwo_sections
->macro
.size
= bfd_get_section_size (sectp
);
12931 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
12933 dwo_sections
->str
.s
.section
= sectp
;
12934 dwo_sections
->str
.size
= bfd_get_section_size (sectp
);
12936 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12938 dwo_sections
->str_offsets
.s
.section
= sectp
;
12939 dwo_sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
12941 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
12943 struct dwarf2_section_info type_section
;
12945 memset (&type_section
, 0, sizeof (type_section
));
12946 type_section
.s
.section
= sectp
;
12947 type_section
.size
= bfd_get_section_size (sectp
);
12948 VEC_safe_push (dwarf2_section_info_def
, dwo_sections
->types
,
12953 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12954 by PER_CU. This is for the non-DWP case.
12955 The result is NULL if DWO_NAME can't be found. */
12957 static struct dwo_file
*
12958 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
12959 const char *dwo_name
, const char *comp_dir
)
12961 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
12963 gdb_bfd_ref_ptr
dbfd (open_dwo_file (dwarf2_per_objfile
, dwo_name
, comp_dir
));
12966 if (dwarf_read_debug
)
12967 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
12971 dwo_file_up
dwo_file (new struct dwo_file
);
12972 dwo_file
->dwo_name
= dwo_name
;
12973 dwo_file
->comp_dir
= comp_dir
;
12974 dwo_file
->dbfd
= dbfd
.release ();
12976 bfd_map_over_sections (dwo_file
->dbfd
, dwarf2_locate_dwo_sections
,
12977 &dwo_file
->sections
);
12979 create_cus_hash_table (dwarf2_per_objfile
, *dwo_file
, dwo_file
->sections
.info
,
12982 create_debug_types_hash_table (dwarf2_per_objfile
, dwo_file
.get (),
12983 dwo_file
->sections
.types
, dwo_file
->tus
);
12985 if (dwarf_read_debug
)
12986 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
12988 return dwo_file
.release ();
12991 /* This function is mapped across the sections and remembers the offset and
12992 size of each of the DWP debugging sections common to version 1 and 2 that
12993 we are interested in. */
12996 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
12997 void *dwp_file_ptr
)
12999 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
13000 const struct dwop_section_names
*names
= &dwop_section_names
;
13001 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
13003 /* Record the ELF section number for later lookup: this is what the
13004 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13005 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
13006 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
13008 /* Look for specific sections that we need. */
13009 if (section_is_p (sectp
->name
, &names
->str_dwo
))
13011 dwp_file
->sections
.str
.s
.section
= sectp
;
13012 dwp_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
13014 else if (section_is_p (sectp
->name
, &names
->cu_index
))
13016 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
13017 dwp_file
->sections
.cu_index
.size
= bfd_get_section_size (sectp
);
13019 else if (section_is_p (sectp
->name
, &names
->tu_index
))
13021 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
13022 dwp_file
->sections
.tu_index
.size
= bfd_get_section_size (sectp
);
13026 /* This function is mapped across the sections and remembers the offset and
13027 size of each of the DWP version 2 debugging sections that we are interested
13028 in. This is split into a separate function because we don't know if we
13029 have version 1 or 2 until we parse the cu_index/tu_index sections. */
13032 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
13034 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
13035 const struct dwop_section_names
*names
= &dwop_section_names
;
13036 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
13038 /* Record the ELF section number for later lookup: this is what the
13039 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13040 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
13041 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
13043 /* Look for specific sections that we need. */
13044 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
13046 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
13047 dwp_file
->sections
.abbrev
.size
= bfd_get_section_size (sectp
);
13049 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
13051 dwp_file
->sections
.info
.s
.section
= sectp
;
13052 dwp_file
->sections
.info
.size
= bfd_get_section_size (sectp
);
13054 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
13056 dwp_file
->sections
.line
.s
.section
= sectp
;
13057 dwp_file
->sections
.line
.size
= bfd_get_section_size (sectp
);
13059 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
13061 dwp_file
->sections
.loc
.s
.section
= sectp
;
13062 dwp_file
->sections
.loc
.size
= bfd_get_section_size (sectp
);
13064 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
13066 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
13067 dwp_file
->sections
.macinfo
.size
= bfd_get_section_size (sectp
);
13069 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
13071 dwp_file
->sections
.macro
.s
.section
= sectp
;
13072 dwp_file
->sections
.macro
.size
= bfd_get_section_size (sectp
);
13074 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
13076 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
13077 dwp_file
->sections
.str_offsets
.size
= bfd_get_section_size (sectp
);
13079 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
13081 dwp_file
->sections
.types
.s
.section
= sectp
;
13082 dwp_file
->sections
.types
.size
= bfd_get_section_size (sectp
);
13086 /* Hash function for dwp_file loaded CUs/TUs. */
13089 hash_dwp_loaded_cutus (const void *item
)
13091 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
13093 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13094 return dwo_unit
->signature
;
13097 /* Equality function for dwp_file loaded CUs/TUs. */
13100 eq_dwp_loaded_cutus (const void *a
, const void *b
)
13102 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
13103 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
13105 return dua
->signature
== dub
->signature
;
13108 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13111 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
13113 return htab_create_alloc_ex (3,
13114 hash_dwp_loaded_cutus
,
13115 eq_dwp_loaded_cutus
,
13117 &objfile
->objfile_obstack
,
13118 hashtab_obstack_allocate
,
13119 dummy_obstack_deallocate
);
13122 /* Try to open DWP file FILE_NAME.
13123 The result is the bfd handle of the file.
13124 If there is a problem finding or opening the file, return NULL.
13125 Upon success, the canonicalized path of the file is stored in the bfd,
13126 same as symfile_bfd_open. */
13128 static gdb_bfd_ref_ptr
13129 open_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
13130 const char *file_name
)
13132 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
, file_name
,
13134 1 /*search_cwd*/));
13138 /* Work around upstream bug 15652.
13139 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13140 [Whether that's a "bug" is debatable, but it is getting in our way.]
13141 We have no real idea where the dwp file is, because gdb's realpath-ing
13142 of the executable's path may have discarded the needed info.
13143 [IWBN if the dwp file name was recorded in the executable, akin to
13144 .gnu_debuglink, but that doesn't exist yet.]
13145 Strip the directory from FILE_NAME and search again. */
13146 if (*debug_file_directory
!= '\0')
13148 /* Don't implicitly search the current directory here.
13149 If the user wants to search "." to handle this case,
13150 it must be added to debug-file-directory. */
13151 return try_open_dwop_file (dwarf2_per_objfile
,
13152 lbasename (file_name
), 1 /*is_dwp*/,
13159 /* Initialize the use of the DWP file for the current objfile.
13160 By convention the name of the DWP file is ${objfile}.dwp.
13161 The result is NULL if it can't be found. */
13163 static std::unique_ptr
<struct dwp_file
>
13164 open_and_init_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
13166 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13168 /* Try to find first .dwp for the binary file before any symbolic links
13171 /* If the objfile is a debug file, find the name of the real binary
13172 file and get the name of dwp file from there. */
13173 std::string dwp_name
;
13174 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
13176 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
13177 const char *backlink_basename
= lbasename (backlink
->original_name
);
13179 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
13182 dwp_name
= objfile
->original_name
;
13184 dwp_name
+= ".dwp";
13186 gdb_bfd_ref_ptr
dbfd (open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ()));
13188 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
13190 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13191 dwp_name
= objfile_name (objfile
);
13192 dwp_name
+= ".dwp";
13193 dbfd
= open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ());
13198 if (dwarf_read_debug
)
13199 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
.c_str ());
13200 return std::unique_ptr
<dwp_file
> ();
13203 const char *name
= bfd_get_filename (dbfd
.get ());
13204 std::unique_ptr
<struct dwp_file
> dwp_file
13205 (new struct dwp_file (name
, std::move (dbfd
)));
13207 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
13208 dwp_file
->elf_sections
=
13209 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
13210 dwp_file
->num_sections
, asection
*);
13212 bfd_map_over_sections (dwp_file
->dbfd
.get (),
13213 dwarf2_locate_common_dwp_sections
,
13216 dwp_file
->cus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
.get (),
13219 dwp_file
->tus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
.get (),
13222 /* The DWP file version is stored in the hash table. Oh well. */
13223 if (dwp_file
->cus
&& dwp_file
->tus
13224 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
13226 /* Technically speaking, we should try to limp along, but this is
13227 pretty bizarre. We use pulongest here because that's the established
13228 portability solution (e.g, we cannot use %u for uint32_t). */
13229 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13230 " TU version %s [in DWP file %s]"),
13231 pulongest (dwp_file
->cus
->version
),
13232 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
13236 dwp_file
->version
= dwp_file
->cus
->version
;
13237 else if (dwp_file
->tus
)
13238 dwp_file
->version
= dwp_file
->tus
->version
;
13240 dwp_file
->version
= 2;
13242 if (dwp_file
->version
== 2)
13243 bfd_map_over_sections (dwp_file
->dbfd
.get (),
13244 dwarf2_locate_v2_dwp_sections
,
13247 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table (objfile
);
13248 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table (objfile
);
13250 if (dwarf_read_debug
)
13252 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
13253 fprintf_unfiltered (gdb_stdlog
,
13254 " %s CUs, %s TUs\n",
13255 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
13256 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
13262 /* Wrapper around open_and_init_dwp_file, only open it once. */
13264 static struct dwp_file
*
13265 get_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
13267 if (! dwarf2_per_objfile
->dwp_checked
)
13269 dwarf2_per_objfile
->dwp_file
13270 = open_and_init_dwp_file (dwarf2_per_objfile
);
13271 dwarf2_per_objfile
->dwp_checked
= 1;
13273 return dwarf2_per_objfile
->dwp_file
.get ();
13276 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13277 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13278 or in the DWP file for the objfile, referenced by THIS_UNIT.
13279 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13280 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13282 This is called, for example, when wanting to read a variable with a
13283 complex location. Therefore we don't want to do file i/o for every call.
13284 Therefore we don't want to look for a DWO file on every call.
13285 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13286 then we check if we've already seen DWO_NAME, and only THEN do we check
13289 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13290 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13292 static struct dwo_unit
*
13293 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
13294 const char *dwo_name
, const char *comp_dir
,
13295 ULONGEST signature
, int is_debug_types
)
13297 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_unit
->dwarf2_per_objfile
;
13298 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13299 const char *kind
= is_debug_types
? "TU" : "CU";
13300 void **dwo_file_slot
;
13301 struct dwo_file
*dwo_file
;
13302 struct dwp_file
*dwp_file
;
13304 /* First see if there's a DWP file.
13305 If we have a DWP file but didn't find the DWO inside it, don't
13306 look for the original DWO file. It makes gdb behave differently
13307 depending on whether one is debugging in the build tree. */
13309 dwp_file
= get_dwp_file (dwarf2_per_objfile
);
13310 if (dwp_file
!= NULL
)
13312 const struct dwp_hash_table
*dwp_htab
=
13313 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
13315 if (dwp_htab
!= NULL
)
13317 struct dwo_unit
*dwo_cutu
=
13318 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, comp_dir
,
13319 signature
, is_debug_types
);
13321 if (dwo_cutu
!= NULL
)
13323 if (dwarf_read_debug
)
13325 fprintf_unfiltered (gdb_stdlog
,
13326 "Virtual DWO %s %s found: @%s\n",
13327 kind
, hex_string (signature
),
13328 host_address_to_string (dwo_cutu
));
13336 /* No DWP file, look for the DWO file. */
13338 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
13339 dwo_name
, comp_dir
);
13340 if (*dwo_file_slot
== NULL
)
13342 /* Read in the file and build a table of the CUs/TUs it contains. */
13343 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
13345 /* NOTE: This will be NULL if unable to open the file. */
13346 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
13348 if (dwo_file
!= NULL
)
13350 struct dwo_unit
*dwo_cutu
= NULL
;
13352 if (is_debug_types
&& dwo_file
->tus
)
13354 struct dwo_unit find_dwo_cutu
;
13356 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13357 find_dwo_cutu
.signature
= signature
;
13359 = (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_cutu
);
13361 else if (!is_debug_types
&& dwo_file
->cus
)
13363 struct dwo_unit find_dwo_cutu
;
13365 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13366 find_dwo_cutu
.signature
= signature
;
13367 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
,
13371 if (dwo_cutu
!= NULL
)
13373 if (dwarf_read_debug
)
13375 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
13376 kind
, dwo_name
, hex_string (signature
),
13377 host_address_to_string (dwo_cutu
));
13384 /* We didn't find it. This could mean a dwo_id mismatch, or
13385 someone deleted the DWO/DWP file, or the search path isn't set up
13386 correctly to find the file. */
13388 if (dwarf_read_debug
)
13390 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
13391 kind
, dwo_name
, hex_string (signature
));
13394 /* This is a warning and not a complaint because it can be caused by
13395 pilot error (e.g., user accidentally deleting the DWO). */
13397 /* Print the name of the DWP file if we looked there, helps the user
13398 better diagnose the problem. */
13399 std::string dwp_text
;
13401 if (dwp_file
!= NULL
)
13402 dwp_text
= string_printf (" [in DWP file %s]",
13403 lbasename (dwp_file
->name
));
13405 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13406 " [in module %s]"),
13407 kind
, dwo_name
, hex_string (signature
),
13409 this_unit
->is_debug_types
? "TU" : "CU",
13410 sect_offset_str (this_unit
->sect_off
), objfile_name (objfile
));
13415 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13416 See lookup_dwo_cutu_unit for details. */
13418 static struct dwo_unit
*
13419 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
13420 const char *dwo_name
, const char *comp_dir
,
13421 ULONGEST signature
)
13423 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
13426 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13427 See lookup_dwo_cutu_unit for details. */
13429 static struct dwo_unit
*
13430 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
13431 const char *dwo_name
, const char *comp_dir
)
13433 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
13436 /* Traversal function for queue_and_load_all_dwo_tus. */
13439 queue_and_load_dwo_tu (void **slot
, void *info
)
13441 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
13442 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
13443 ULONGEST signature
= dwo_unit
->signature
;
13444 struct signatured_type
*sig_type
=
13445 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
13447 if (sig_type
!= NULL
)
13449 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
13451 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13452 a real dependency of PER_CU on SIG_TYPE. That is detected later
13453 while processing PER_CU. */
13454 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
13455 load_full_type_unit (sig_cu
);
13456 VEC_safe_push (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, sig_cu
);
13462 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13463 The DWO may have the only definition of the type, though it may not be
13464 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13465 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13468 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
13470 struct dwo_unit
*dwo_unit
;
13471 struct dwo_file
*dwo_file
;
13473 gdb_assert (!per_cu
->is_debug_types
);
13474 gdb_assert (get_dwp_file (per_cu
->dwarf2_per_objfile
) == NULL
);
13475 gdb_assert (per_cu
->cu
!= NULL
);
13477 dwo_unit
= per_cu
->cu
->dwo_unit
;
13478 gdb_assert (dwo_unit
!= NULL
);
13480 dwo_file
= dwo_unit
->dwo_file
;
13481 if (dwo_file
->tus
!= NULL
)
13482 htab_traverse_noresize (dwo_file
->tus
, queue_and_load_dwo_tu
, per_cu
);
13485 /* Read in various DIEs. */
13487 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13488 Inherit only the children of the DW_AT_abstract_origin DIE not being
13489 already referenced by DW_AT_abstract_origin from the children of the
13493 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
13495 struct die_info
*child_die
;
13496 sect_offset
*offsetp
;
13497 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13498 struct die_info
*origin_die
;
13499 /* Iterator of the ORIGIN_DIE children. */
13500 struct die_info
*origin_child_die
;
13501 struct attribute
*attr
;
13502 struct dwarf2_cu
*origin_cu
;
13503 struct pending
**origin_previous_list_in_scope
;
13505 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13509 /* Note that following die references may follow to a die in a
13513 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
13515 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13517 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
13518 origin_cu
->list_in_scope
= cu
->list_in_scope
;
13520 if (die
->tag
!= origin_die
->tag
13521 && !(die
->tag
== DW_TAG_inlined_subroutine
13522 && origin_die
->tag
== DW_TAG_subprogram
))
13523 complaint (_("DIE %s and its abstract origin %s have different tags"),
13524 sect_offset_str (die
->sect_off
),
13525 sect_offset_str (origin_die
->sect_off
));
13527 std::vector
<sect_offset
> offsets
;
13529 for (child_die
= die
->child
;
13530 child_die
&& child_die
->tag
;
13531 child_die
= sibling_die (child_die
))
13533 struct die_info
*child_origin_die
;
13534 struct dwarf2_cu
*child_origin_cu
;
13536 /* We are trying to process concrete instance entries:
13537 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13538 it's not relevant to our analysis here. i.e. detecting DIEs that are
13539 present in the abstract instance but not referenced in the concrete
13541 if (child_die
->tag
== DW_TAG_call_site
13542 || child_die
->tag
== DW_TAG_GNU_call_site
)
13545 /* For each CHILD_DIE, find the corresponding child of
13546 ORIGIN_DIE. If there is more than one layer of
13547 DW_AT_abstract_origin, follow them all; there shouldn't be,
13548 but GCC versions at least through 4.4 generate this (GCC PR
13550 child_origin_die
= child_die
;
13551 child_origin_cu
= cu
;
13554 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
13558 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
13562 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13563 counterpart may exist. */
13564 if (child_origin_die
!= child_die
)
13566 if (child_die
->tag
!= child_origin_die
->tag
13567 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13568 && child_origin_die
->tag
== DW_TAG_subprogram
))
13569 complaint (_("Child DIE %s and its abstract origin %s have "
13571 sect_offset_str (child_die
->sect_off
),
13572 sect_offset_str (child_origin_die
->sect_off
));
13573 if (child_origin_die
->parent
!= origin_die
)
13574 complaint (_("Child DIE %s and its abstract origin %s have "
13575 "different parents"),
13576 sect_offset_str (child_die
->sect_off
),
13577 sect_offset_str (child_origin_die
->sect_off
));
13579 offsets
.push_back (child_origin_die
->sect_off
);
13582 std::sort (offsets
.begin (), offsets
.end ());
13583 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13584 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13585 if (offsetp
[-1] == *offsetp
)
13586 complaint (_("Multiple children of DIE %s refer "
13587 "to DIE %s as their abstract origin"),
13588 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
13590 offsetp
= offsets
.data ();
13591 origin_child_die
= origin_die
->child
;
13592 while (origin_child_die
&& origin_child_die
->tag
)
13594 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13595 while (offsetp
< offsets_end
13596 && *offsetp
< origin_child_die
->sect_off
)
13598 if (offsetp
>= offsets_end
13599 || *offsetp
> origin_child_die
->sect_off
)
13601 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13602 Check whether we're already processing ORIGIN_CHILD_DIE.
13603 This can happen with mutually referenced abstract_origins.
13605 if (!origin_child_die
->in_process
)
13606 process_die (origin_child_die
, origin_cu
);
13608 origin_child_die
= sibling_die (origin_child_die
);
13610 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13614 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13616 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13617 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13618 struct context_stack
*newobj
;
13621 struct die_info
*child_die
;
13622 struct attribute
*attr
, *call_line
, *call_file
;
13624 CORE_ADDR baseaddr
;
13625 struct block
*block
;
13626 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13627 std::vector
<struct symbol
*> template_args
;
13628 struct template_symbol
*templ_func
= NULL
;
13632 /* If we do not have call site information, we can't show the
13633 caller of this inlined function. That's too confusing, so
13634 only use the scope for local variables. */
13635 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13636 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13637 if (call_line
== NULL
|| call_file
== NULL
)
13639 read_lexical_block_scope (die
, cu
);
13644 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13646 name
= dwarf2_name (die
, cu
);
13648 /* Ignore functions with missing or empty names. These are actually
13649 illegal according to the DWARF standard. */
13652 complaint (_("missing name for subprogram DIE at %s"),
13653 sect_offset_str (die
->sect_off
));
13657 /* Ignore functions with missing or invalid low and high pc attributes. */
13658 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13659 <= PC_BOUNDS_INVALID
)
13661 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13662 if (!attr
|| !DW_UNSND (attr
))
13663 complaint (_("cannot get low and high bounds "
13664 "for subprogram DIE at %s"),
13665 sect_offset_str (die
->sect_off
));
13669 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13670 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13672 /* If we have any template arguments, then we must allocate a
13673 different sort of symbol. */
13674 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
13676 if (child_die
->tag
== DW_TAG_template_type_param
13677 || child_die
->tag
== DW_TAG_template_value_param
)
13679 templ_func
= allocate_template_symbol (objfile
);
13680 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13685 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13686 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13687 (struct symbol
*) templ_func
);
13689 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13690 set_objfile_main_name (objfile
, SYMBOL_LINKAGE_NAME (newobj
->name
),
13693 /* If there is a location expression for DW_AT_frame_base, record
13695 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13697 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13699 /* If there is a location for the static link, record it. */
13700 newobj
->static_link
= NULL
;
13701 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13704 newobj
->static_link
13705 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13706 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
);
13709 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13711 if (die
->child
!= NULL
)
13713 child_die
= die
->child
;
13714 while (child_die
&& child_die
->tag
)
13716 if (child_die
->tag
== DW_TAG_template_type_param
13717 || child_die
->tag
== DW_TAG_template_value_param
)
13719 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13722 template_args
.push_back (arg
);
13725 process_die (child_die
, cu
);
13726 child_die
= sibling_die (child_die
);
13730 inherit_abstract_dies (die
, cu
);
13732 /* If we have a DW_AT_specification, we might need to import using
13733 directives from the context of the specification DIE. See the
13734 comment in determine_prefix. */
13735 if (cu
->language
== language_cplus
13736 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13738 struct dwarf2_cu
*spec_cu
= cu
;
13739 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13743 child_die
= spec_die
->child
;
13744 while (child_die
&& child_die
->tag
)
13746 if (child_die
->tag
== DW_TAG_imported_module
)
13747 process_die (child_die
, spec_cu
);
13748 child_die
= sibling_die (child_die
);
13751 /* In some cases, GCC generates specification DIEs that
13752 themselves contain DW_AT_specification attributes. */
13753 spec_die
= die_specification (spec_die
, &spec_cu
);
13757 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13758 /* Make a block for the local symbols within. */
13759 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13760 cstk
.static_link
, lowpc
, highpc
);
13762 /* For C++, set the block's scope. */
13763 if ((cu
->language
== language_cplus
13764 || cu
->language
== language_fortran
13765 || cu
->language
== language_d
13766 || cu
->language
== language_rust
)
13767 && cu
->processing_has_namespace_info
)
13768 block_set_scope (block
, determine_prefix (die
, cu
),
13769 &objfile
->objfile_obstack
);
13771 /* If we have address ranges, record them. */
13772 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13774 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13776 /* Attach template arguments to function. */
13777 if (!template_args
.empty ())
13779 gdb_assert (templ_func
!= NULL
);
13781 templ_func
->n_template_arguments
= template_args
.size ();
13782 templ_func
->template_arguments
13783 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13784 templ_func
->n_template_arguments
);
13785 memcpy (templ_func
->template_arguments
,
13786 template_args
.data (),
13787 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13789 /* Make sure that the symtab is set on the new symbols. Even
13790 though they don't appear in this symtab directly, other parts
13791 of gdb assume that symbols do, and this is reasonably
13793 for (symbol
*sym
: template_args
)
13794 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13797 /* In C++, we can have functions nested inside functions (e.g., when
13798 a function declares a class that has methods). This means that
13799 when we finish processing a function scope, we may need to go
13800 back to building a containing block's symbol lists. */
13801 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13802 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13804 /* If we've finished processing a top-level function, subsequent
13805 symbols go in the file symbol list. */
13806 if (cu
->get_builder ()->outermost_context_p ())
13807 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13810 /* Process all the DIES contained within a lexical block scope. Start
13811 a new scope, process the dies, and then close the scope. */
13814 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13816 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13817 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13818 CORE_ADDR lowpc
, highpc
;
13819 struct die_info
*child_die
;
13820 CORE_ADDR baseaddr
;
13822 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13824 /* Ignore blocks with missing or invalid low and high pc attributes. */
13825 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13826 as multiple lexical blocks? Handling children in a sane way would
13827 be nasty. Might be easier to properly extend generic blocks to
13828 describe ranges. */
13829 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13831 case PC_BOUNDS_NOT_PRESENT
:
13832 /* DW_TAG_lexical_block has no attributes, process its children as if
13833 there was no wrapping by that DW_TAG_lexical_block.
13834 GCC does no longer produces such DWARF since GCC r224161. */
13835 for (child_die
= die
->child
;
13836 child_die
!= NULL
&& child_die
->tag
;
13837 child_die
= sibling_die (child_die
))
13838 process_die (child_die
, cu
);
13840 case PC_BOUNDS_INVALID
:
13843 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13844 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13846 cu
->get_builder ()->push_context (0, lowpc
);
13847 if (die
->child
!= NULL
)
13849 child_die
= die
->child
;
13850 while (child_die
&& child_die
->tag
)
13852 process_die (child_die
, cu
);
13853 child_die
= sibling_die (child_die
);
13856 inherit_abstract_dies (die
, cu
);
13857 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13859 if (*cu
->get_builder ()->get_local_symbols () != NULL
13860 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13862 struct block
*block
13863 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13864 cstk
.start_addr
, highpc
);
13866 /* Note that recording ranges after traversing children, as we
13867 do here, means that recording a parent's ranges entails
13868 walking across all its children's ranges as they appear in
13869 the address map, which is quadratic behavior.
13871 It would be nicer to record the parent's ranges before
13872 traversing its children, simply overriding whatever you find
13873 there. But since we don't even decide whether to create a
13874 block until after we've traversed its children, that's hard
13876 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13878 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13879 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13882 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13885 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13887 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13888 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13889 CORE_ADDR pc
, baseaddr
;
13890 struct attribute
*attr
;
13891 struct call_site
*call_site
, call_site_local
;
13894 struct die_info
*child_die
;
13896 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13898 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13901 /* This was a pre-DWARF-5 GNU extension alias
13902 for DW_AT_call_return_pc. */
13903 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13907 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13908 "DIE %s [in module %s]"),
13909 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13912 pc
= attr_value_as_address (attr
) + baseaddr
;
13913 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13915 if (cu
->call_site_htab
== NULL
)
13916 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13917 NULL
, &objfile
->objfile_obstack
,
13918 hashtab_obstack_allocate
, NULL
);
13919 call_site_local
.pc
= pc
;
13920 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13923 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13924 "DIE %s [in module %s]"),
13925 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13926 objfile_name (objfile
));
13930 /* Count parameters at the caller. */
13933 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13934 child_die
= sibling_die (child_die
))
13936 if (child_die
->tag
!= DW_TAG_call_site_parameter
13937 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13939 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13940 "DW_TAG_call_site child DIE %s [in module %s]"),
13941 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
13942 objfile_name (objfile
));
13950 = ((struct call_site
*)
13951 obstack_alloc (&objfile
->objfile_obstack
,
13952 sizeof (*call_site
)
13953 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
13955 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
13956 call_site
->pc
= pc
;
13958 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
13959 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
13961 struct die_info
*func_die
;
13963 /* Skip also over DW_TAG_inlined_subroutine. */
13964 for (func_die
= die
->parent
;
13965 func_die
&& func_die
->tag
!= DW_TAG_subprogram
13966 && func_die
->tag
!= DW_TAG_subroutine_type
;
13967 func_die
= func_die
->parent
);
13969 /* DW_AT_call_all_calls is a superset
13970 of DW_AT_call_all_tail_calls. */
13972 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
13973 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
13974 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
13975 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
13977 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13978 not complete. But keep CALL_SITE for look ups via call_site_htab,
13979 both the initial caller containing the real return address PC and
13980 the final callee containing the current PC of a chain of tail
13981 calls do not need to have the tail call list complete. But any
13982 function candidate for a virtual tail call frame searched via
13983 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13984 determined unambiguously. */
13988 struct type
*func_type
= NULL
;
13991 func_type
= get_die_type (func_die
, cu
);
13992 if (func_type
!= NULL
)
13994 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
13996 /* Enlist this call site to the function. */
13997 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
13998 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
14001 complaint (_("Cannot find function owning DW_TAG_call_site "
14002 "DIE %s [in module %s]"),
14003 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14007 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
14009 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
14011 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
14014 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
14015 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14017 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
14018 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
14019 /* Keep NULL DWARF_BLOCK. */;
14020 else if (attr_form_is_block (attr
))
14022 struct dwarf2_locexpr_baton
*dlbaton
;
14024 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
14025 dlbaton
->data
= DW_BLOCK (attr
)->data
;
14026 dlbaton
->size
= DW_BLOCK (attr
)->size
;
14027 dlbaton
->per_cu
= cu
->per_cu
;
14029 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
14031 else if (attr_form_is_ref (attr
))
14033 struct dwarf2_cu
*target_cu
= cu
;
14034 struct die_info
*target_die
;
14036 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14037 gdb_assert (target_cu
->per_cu
->dwarf2_per_objfile
->objfile
== objfile
);
14038 if (die_is_declaration (target_die
, target_cu
))
14040 const char *target_physname
;
14042 /* Prefer the mangled name; otherwise compute the demangled one. */
14043 target_physname
= dw2_linkage_name (target_die
, target_cu
);
14044 if (target_physname
== NULL
)
14045 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
14046 if (target_physname
== NULL
)
14047 complaint (_("DW_AT_call_target target DIE has invalid "
14048 "physname, for referencing DIE %s [in module %s]"),
14049 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14051 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
14057 /* DW_AT_entry_pc should be preferred. */
14058 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
14059 <= PC_BOUNDS_INVALID
)
14060 complaint (_("DW_AT_call_target target DIE has invalid "
14061 "low pc, for referencing DIE %s [in module %s]"),
14062 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14065 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
14066 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
14071 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14072 "block nor reference, for DIE %s [in module %s]"),
14073 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14075 call_site
->per_cu
= cu
->per_cu
;
14077 for (child_die
= die
->child
;
14078 child_die
&& child_die
->tag
;
14079 child_die
= sibling_die (child_die
))
14081 struct call_site_parameter
*parameter
;
14082 struct attribute
*loc
, *origin
;
14084 if (child_die
->tag
!= DW_TAG_call_site_parameter
14085 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14087 /* Already printed the complaint above. */
14091 gdb_assert (call_site
->parameter_count
< nparams
);
14092 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
14094 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14095 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14096 register is contained in DW_AT_call_value. */
14098 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
14099 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
14100 if (origin
== NULL
)
14102 /* This was a pre-DWARF-5 GNU extension alias
14103 for DW_AT_call_parameter. */
14104 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
14106 if (loc
== NULL
&& origin
!= NULL
&& attr_form_is_ref (origin
))
14108 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
14110 sect_offset sect_off
14111 = (sect_offset
) dwarf2_get_ref_die_offset (origin
);
14112 if (!offset_in_cu_p (&cu
->header
, sect_off
))
14114 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14115 binding can be done only inside one CU. Such referenced DIE
14116 therefore cannot be even moved to DW_TAG_partial_unit. */
14117 complaint (_("DW_AT_call_parameter offset is not in CU for "
14118 "DW_TAG_call_site child DIE %s [in module %s]"),
14119 sect_offset_str (child_die
->sect_off
),
14120 objfile_name (objfile
));
14123 parameter
->u
.param_cu_off
14124 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
14126 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
14128 complaint (_("No DW_FORM_block* DW_AT_location for "
14129 "DW_TAG_call_site child DIE %s [in module %s]"),
14130 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
14135 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
14136 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
14137 if (parameter
->u
.dwarf_reg
!= -1)
14138 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
14139 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
14140 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
14141 ¶meter
->u
.fb_offset
))
14142 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
14145 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14146 "for DW_FORM_block* DW_AT_location is supported for "
14147 "DW_TAG_call_site child DIE %s "
14149 sect_offset_str (child_die
->sect_off
),
14150 objfile_name (objfile
));
14155 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
14157 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
14158 if (!attr_form_is_block (attr
))
14160 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14161 "DW_TAG_call_site child DIE %s [in module %s]"),
14162 sect_offset_str (child_die
->sect_off
),
14163 objfile_name (objfile
));
14166 parameter
->value
= DW_BLOCK (attr
)->data
;
14167 parameter
->value_size
= DW_BLOCK (attr
)->size
;
14169 /* Parameters are not pre-cleared by memset above. */
14170 parameter
->data_value
= NULL
;
14171 parameter
->data_value_size
= 0;
14172 call_site
->parameter_count
++;
14174 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
14176 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
14179 if (!attr_form_is_block (attr
))
14180 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14181 "DW_TAG_call_site child DIE %s [in module %s]"),
14182 sect_offset_str (child_die
->sect_off
),
14183 objfile_name (objfile
));
14186 parameter
->data_value
= DW_BLOCK (attr
)->data
;
14187 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
14193 /* Helper function for read_variable. If DIE represents a virtual
14194 table, then return the type of the concrete object that is
14195 associated with the virtual table. Otherwise, return NULL. */
14197 static struct type
*
14198 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14200 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
14204 /* Find the type DIE. */
14205 struct die_info
*type_die
= NULL
;
14206 struct dwarf2_cu
*type_cu
= cu
;
14208 if (attr_form_is_ref (attr
))
14209 type_die
= follow_die_ref (die
, attr
, &type_cu
);
14210 if (type_die
== NULL
)
14213 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
14215 return die_containing_type (type_die
, type_cu
);
14218 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14221 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
14223 struct rust_vtable_symbol
*storage
= NULL
;
14225 if (cu
->language
== language_rust
)
14227 struct type
*containing_type
= rust_containing_type (die
, cu
);
14229 if (containing_type
!= NULL
)
14231 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14233 storage
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
14234 struct rust_vtable_symbol
);
14235 initialize_objfile_symbol (storage
);
14236 storage
->concrete_type
= containing_type
;
14237 storage
->subclass
= SYMBOL_RUST_VTABLE
;
14241 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
14242 struct attribute
*abstract_origin
14243 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14244 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
14245 if (res
== NULL
&& loc
&& abstract_origin
)
14247 /* We have a variable without a name, but with a location and an abstract
14248 origin. This may be a concrete instance of an abstract variable
14249 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14251 struct dwarf2_cu
*origin_cu
= cu
;
14252 struct die_info
*origin_die
14253 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
14254 dwarf2_per_objfile
*dpo
= cu
->per_cu
->dwarf2_per_objfile
;
14255 dpo
->abstract_to_concrete
[origin_die
->sect_off
].push_back (die
->sect_off
);
14259 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14260 reading .debug_rnglists.
14261 Callback's type should be:
14262 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14263 Return true if the attributes are present and valid, otherwise,
14266 template <typename Callback
>
14268 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
14269 Callback
&&callback
)
14271 struct dwarf2_per_objfile
*dwarf2_per_objfile
14272 = cu
->per_cu
->dwarf2_per_objfile
;
14273 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14274 bfd
*obfd
= objfile
->obfd
;
14275 /* Base address selection entry. */
14278 const gdb_byte
*buffer
;
14279 CORE_ADDR baseaddr
;
14280 bool overflow
= false;
14282 found_base
= cu
->base_known
;
14283 base
= cu
->base_address
;
14285 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->rnglists
);
14286 if (offset
>= dwarf2_per_objfile
->rnglists
.size
)
14288 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14292 buffer
= dwarf2_per_objfile
->rnglists
.buffer
+ offset
;
14294 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14298 /* Initialize it due to a false compiler warning. */
14299 CORE_ADDR range_beginning
= 0, range_end
= 0;
14300 const gdb_byte
*buf_end
= (dwarf2_per_objfile
->rnglists
.buffer
14301 + dwarf2_per_objfile
->rnglists
.size
);
14302 unsigned int bytes_read
;
14304 if (buffer
== buf_end
)
14309 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
14312 case DW_RLE_end_of_list
:
14314 case DW_RLE_base_address
:
14315 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14320 base
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14322 buffer
+= bytes_read
;
14324 case DW_RLE_start_length
:
14325 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14330 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14331 buffer
+= bytes_read
;
14332 range_end
= (range_beginning
14333 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14334 buffer
+= bytes_read
;
14335 if (buffer
> buf_end
)
14341 case DW_RLE_offset_pair
:
14342 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14343 buffer
+= bytes_read
;
14344 if (buffer
> buf_end
)
14349 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14350 buffer
+= bytes_read
;
14351 if (buffer
> buf_end
)
14357 case DW_RLE_start_end
:
14358 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
14363 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14364 buffer
+= bytes_read
;
14365 range_end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14366 buffer
+= bytes_read
;
14369 complaint (_("Invalid .debug_rnglists data (no base address)"));
14372 if (rlet
== DW_RLE_end_of_list
|| overflow
)
14374 if (rlet
== DW_RLE_base_address
)
14379 /* We have no valid base address for the ranges
14381 complaint (_("Invalid .debug_rnglists data (no base address)"));
14385 if (range_beginning
> range_end
)
14387 /* Inverted range entries are invalid. */
14388 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14392 /* Empty range entries have no effect. */
14393 if (range_beginning
== range_end
)
14396 range_beginning
+= base
;
14399 /* A not-uncommon case of bad debug info.
14400 Don't pollute the addrmap with bad data. */
14401 if (range_beginning
+ baseaddr
== 0
14402 && !dwarf2_per_objfile
->has_section_at_zero
)
14404 complaint (_(".debug_rnglists entry has start address of zero"
14405 " [in module %s]"), objfile_name (objfile
));
14409 callback (range_beginning
, range_end
);
14414 complaint (_("Offset %d is not terminated "
14415 "for DW_AT_ranges attribute"),
14423 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14424 Callback's type should be:
14425 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14426 Return 1 if the attributes are present and valid, otherwise, return 0. */
14428 template <typename Callback
>
14430 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
,
14431 Callback
&&callback
)
14433 struct dwarf2_per_objfile
*dwarf2_per_objfile
14434 = cu
->per_cu
->dwarf2_per_objfile
;
14435 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14436 struct comp_unit_head
*cu_header
= &cu
->header
;
14437 bfd
*obfd
= objfile
->obfd
;
14438 unsigned int addr_size
= cu_header
->addr_size
;
14439 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
14440 /* Base address selection entry. */
14443 unsigned int dummy
;
14444 const gdb_byte
*buffer
;
14445 CORE_ADDR baseaddr
;
14447 if (cu_header
->version
>= 5)
14448 return dwarf2_rnglists_process (offset
, cu
, callback
);
14450 found_base
= cu
->base_known
;
14451 base
= cu
->base_address
;
14453 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
14454 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
14456 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14460 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
14462 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14466 CORE_ADDR range_beginning
, range_end
;
14468 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
14469 buffer
+= addr_size
;
14470 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
14471 buffer
+= addr_size
;
14472 offset
+= 2 * addr_size
;
14474 /* An end of list marker is a pair of zero addresses. */
14475 if (range_beginning
== 0 && range_end
== 0)
14476 /* Found the end of list entry. */
14479 /* Each base address selection entry is a pair of 2 values.
14480 The first is the largest possible address, the second is
14481 the base address. Check for a base address here. */
14482 if ((range_beginning
& mask
) == mask
)
14484 /* If we found the largest possible address, then we already
14485 have the base address in range_end. */
14493 /* We have no valid base address for the ranges
14495 complaint (_("Invalid .debug_ranges data (no base address)"));
14499 if (range_beginning
> range_end
)
14501 /* Inverted range entries are invalid. */
14502 complaint (_("Invalid .debug_ranges data (inverted range)"));
14506 /* Empty range entries have no effect. */
14507 if (range_beginning
== range_end
)
14510 range_beginning
+= base
;
14513 /* A not-uncommon case of bad debug info.
14514 Don't pollute the addrmap with bad data. */
14515 if (range_beginning
+ baseaddr
== 0
14516 && !dwarf2_per_objfile
->has_section_at_zero
)
14518 complaint (_(".debug_ranges entry has start address of zero"
14519 " [in module %s]"), objfile_name (objfile
));
14523 callback (range_beginning
, range_end
);
14529 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14530 Return 1 if the attributes are present and valid, otherwise, return 0.
14531 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14534 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14535 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14536 struct partial_symtab
*ranges_pst
)
14538 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14539 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14540 const CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
14541 SECT_OFF_TEXT (objfile
));
14544 CORE_ADDR high
= 0;
14547 retval
= dwarf2_ranges_process (offset
, cu
,
14548 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14550 if (ranges_pst
!= NULL
)
14555 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14556 range_beginning
+ baseaddr
)
14558 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14559 range_end
+ baseaddr
)
14561 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
14562 lowpc
, highpc
- 1, ranges_pst
);
14565 /* FIXME: This is recording everything as a low-high
14566 segment of consecutive addresses. We should have a
14567 data structure for discontiguous block ranges
14571 low
= range_beginning
;
14577 if (range_beginning
< low
)
14578 low
= range_beginning
;
14579 if (range_end
> high
)
14587 /* If the first entry is an end-of-list marker, the range
14588 describes an empty scope, i.e. no instructions. */
14594 *high_return
= high
;
14598 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14599 definition for the return value. *LOWPC and *HIGHPC are set iff
14600 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14602 static enum pc_bounds_kind
14603 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14604 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14605 struct partial_symtab
*pst
)
14607 struct dwarf2_per_objfile
*dwarf2_per_objfile
14608 = cu
->per_cu
->dwarf2_per_objfile
;
14609 struct attribute
*attr
;
14610 struct attribute
*attr_high
;
14612 CORE_ADDR high
= 0;
14613 enum pc_bounds_kind ret
;
14615 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14618 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14621 low
= attr_value_as_address (attr
);
14622 high
= attr_value_as_address (attr_high
);
14623 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
14627 /* Found high w/o low attribute. */
14628 return PC_BOUNDS_INVALID
;
14630 /* Found consecutive range of addresses. */
14631 ret
= PC_BOUNDS_HIGH_LOW
;
14635 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14638 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14639 We take advantage of the fact that DW_AT_ranges does not appear
14640 in DW_TAG_compile_unit of DWO files. */
14641 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
14642 unsigned int ranges_offset
= (DW_UNSND (attr
)
14643 + (need_ranges_base
14647 /* Value of the DW_AT_ranges attribute is the offset in the
14648 .debug_ranges section. */
14649 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
14650 return PC_BOUNDS_INVALID
;
14651 /* Found discontinuous range of addresses. */
14652 ret
= PC_BOUNDS_RANGES
;
14655 return PC_BOUNDS_NOT_PRESENT
;
14658 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14660 return PC_BOUNDS_INVALID
;
14662 /* When using the GNU linker, .gnu.linkonce. sections are used to
14663 eliminate duplicate copies of functions and vtables and such.
14664 The linker will arbitrarily choose one and discard the others.
14665 The AT_*_pc values for such functions refer to local labels in
14666 these sections. If the section from that file was discarded, the
14667 labels are not in the output, so the relocs get a value of 0.
14668 If this is a discarded function, mark the pc bounds as invalid,
14669 so that GDB will ignore it. */
14670 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
14671 return PC_BOUNDS_INVALID
;
14679 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14680 its low and high PC addresses. Do nothing if these addresses could not
14681 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14682 and HIGHPC to the high address if greater than HIGHPC. */
14685 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14686 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14687 struct dwarf2_cu
*cu
)
14689 CORE_ADDR low
, high
;
14690 struct die_info
*child
= die
->child
;
14692 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14694 *lowpc
= std::min (*lowpc
, low
);
14695 *highpc
= std::max (*highpc
, high
);
14698 /* If the language does not allow nested subprograms (either inside
14699 subprograms or lexical blocks), we're done. */
14700 if (cu
->language
!= language_ada
)
14703 /* Check all the children of the given DIE. If it contains nested
14704 subprograms, then check their pc bounds. Likewise, we need to
14705 check lexical blocks as well, as they may also contain subprogram
14707 while (child
&& child
->tag
)
14709 if (child
->tag
== DW_TAG_subprogram
14710 || child
->tag
== DW_TAG_lexical_block
)
14711 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14712 child
= sibling_die (child
);
14716 /* Get the low and high pc's represented by the scope DIE, and store
14717 them in *LOWPC and *HIGHPC. If the correct values can't be
14718 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14721 get_scope_pc_bounds (struct die_info
*die
,
14722 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14723 struct dwarf2_cu
*cu
)
14725 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14726 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14727 CORE_ADDR current_low
, current_high
;
14729 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14730 >= PC_BOUNDS_RANGES
)
14732 best_low
= current_low
;
14733 best_high
= current_high
;
14737 struct die_info
*child
= die
->child
;
14739 while (child
&& child
->tag
)
14741 switch (child
->tag
) {
14742 case DW_TAG_subprogram
:
14743 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14745 case DW_TAG_namespace
:
14746 case DW_TAG_module
:
14747 /* FIXME: carlton/2004-01-16: Should we do this for
14748 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14749 that current GCC's always emit the DIEs corresponding
14750 to definitions of methods of classes as children of a
14751 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14752 the DIEs giving the declarations, which could be
14753 anywhere). But I don't see any reason why the
14754 standards says that they have to be there. */
14755 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14757 if (current_low
!= ((CORE_ADDR
) -1))
14759 best_low
= std::min (best_low
, current_low
);
14760 best_high
= std::max (best_high
, current_high
);
14768 child
= sibling_die (child
);
14773 *highpc
= best_high
;
14776 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14780 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14781 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14783 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14784 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14785 struct attribute
*attr
;
14786 struct attribute
*attr_high
;
14788 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14791 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14794 CORE_ADDR low
= attr_value_as_address (attr
);
14795 CORE_ADDR high
= attr_value_as_address (attr_high
);
14797 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
14800 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14801 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14802 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14806 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14809 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14810 We take advantage of the fact that DW_AT_ranges does not appear
14811 in DW_TAG_compile_unit of DWO files. */
14812 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
14814 /* The value of the DW_AT_ranges attribute is the offset of the
14815 address range list in the .debug_ranges section. */
14816 unsigned long offset
= (DW_UNSND (attr
)
14817 + (need_ranges_base
? cu
->ranges_base
: 0));
14819 std::vector
<blockrange
> blockvec
;
14820 dwarf2_ranges_process (offset
, cu
,
14821 [&] (CORE_ADDR start
, CORE_ADDR end
)
14825 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14826 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14827 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14828 blockvec
.emplace_back (start
, end
);
14831 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14835 /* Check whether the producer field indicates either of GCC < 4.6, or the
14836 Intel C/C++ compiler, and cache the result in CU. */
14839 check_producer (struct dwarf2_cu
*cu
)
14843 if (cu
->producer
== NULL
)
14845 /* For unknown compilers expect their behavior is DWARF version
14848 GCC started to support .debug_types sections by -gdwarf-4 since
14849 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14850 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14851 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14852 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14854 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14856 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14857 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14859 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14861 cu
->producer_is_icc
= true;
14862 cu
->producer_is_icc_lt_14
= major
< 14;
14864 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14865 cu
->producer_is_codewarrior
= true;
14868 /* For other non-GCC compilers, expect their behavior is DWARF version
14872 cu
->checked_producer
= true;
14875 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14876 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14877 during 4.6.0 experimental. */
14880 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14882 if (!cu
->checked_producer
)
14883 check_producer (cu
);
14885 return cu
->producer_is_gxx_lt_4_6
;
14889 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14890 with incorrect is_stmt attributes. */
14893 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14895 if (!cu
->checked_producer
)
14896 check_producer (cu
);
14898 return cu
->producer_is_codewarrior
;
14901 /* Return the default accessibility type if it is not overriden by
14902 DW_AT_accessibility. */
14904 static enum dwarf_access_attribute
14905 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14907 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14909 /* The default DWARF 2 accessibility for members is public, the default
14910 accessibility for inheritance is private. */
14912 if (die
->tag
!= DW_TAG_inheritance
)
14913 return DW_ACCESS_public
;
14915 return DW_ACCESS_private
;
14919 /* DWARF 3+ defines the default accessibility a different way. The same
14920 rules apply now for DW_TAG_inheritance as for the members and it only
14921 depends on the container kind. */
14923 if (die
->parent
->tag
== DW_TAG_class_type
)
14924 return DW_ACCESS_private
;
14926 return DW_ACCESS_public
;
14930 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14931 offset. If the attribute was not found return 0, otherwise return
14932 1. If it was found but could not properly be handled, set *OFFSET
14936 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14939 struct attribute
*attr
;
14941 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14946 /* Note that we do not check for a section offset first here.
14947 This is because DW_AT_data_member_location is new in DWARF 4,
14948 so if we see it, we can assume that a constant form is really
14949 a constant and not a section offset. */
14950 if (attr_form_is_constant (attr
))
14951 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
14952 else if (attr_form_is_section_offset (attr
))
14953 dwarf2_complex_location_expr_complaint ();
14954 else if (attr_form_is_block (attr
))
14955 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
14957 dwarf2_complex_location_expr_complaint ();
14965 /* Add an aggregate field to the field list. */
14968 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
14969 struct dwarf2_cu
*cu
)
14971 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14972 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14973 struct nextfield
*new_field
;
14974 struct attribute
*attr
;
14976 const char *fieldname
= "";
14978 if (die
->tag
== DW_TAG_inheritance
)
14980 fip
->baseclasses
.emplace_back ();
14981 new_field
= &fip
->baseclasses
.back ();
14985 fip
->fields
.emplace_back ();
14986 new_field
= &fip
->fields
.back ();
14991 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14993 new_field
->accessibility
= DW_UNSND (attr
);
14995 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
14996 if (new_field
->accessibility
!= DW_ACCESS_public
)
14997 fip
->non_public_fields
= 1;
14999 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15001 new_field
->virtuality
= DW_UNSND (attr
);
15003 new_field
->virtuality
= DW_VIRTUALITY_none
;
15005 fp
= &new_field
->field
;
15007 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
15011 /* Data member other than a C++ static data member. */
15013 /* Get type of field. */
15014 fp
->type
= die_type (die
, cu
);
15016 SET_FIELD_BITPOS (*fp
, 0);
15018 /* Get bit size of field (zero if none). */
15019 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
15022 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
15026 FIELD_BITSIZE (*fp
) = 0;
15029 /* Get bit offset of field. */
15030 if (handle_data_member_location (die
, cu
, &offset
))
15031 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
15032 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
15035 if (gdbarch_bits_big_endian (gdbarch
))
15037 /* For big endian bits, the DW_AT_bit_offset gives the
15038 additional bit offset from the MSB of the containing
15039 anonymous object to the MSB of the field. We don't
15040 have to do anything special since we don't need to
15041 know the size of the anonymous object. */
15042 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
15046 /* For little endian bits, compute the bit offset to the
15047 MSB of the anonymous object, subtract off the number of
15048 bits from the MSB of the field to the MSB of the
15049 object, and then subtract off the number of bits of
15050 the field itself. The result is the bit offset of
15051 the LSB of the field. */
15052 int anonymous_size
;
15053 int bit_offset
= DW_UNSND (attr
);
15055 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15058 /* The size of the anonymous object containing
15059 the bit field is explicit, so use the
15060 indicated size (in bytes). */
15061 anonymous_size
= DW_UNSND (attr
);
15065 /* The size of the anonymous object containing
15066 the bit field must be inferred from the type
15067 attribute of the data member containing the
15069 anonymous_size
= TYPE_LENGTH (fp
->type
);
15071 SET_FIELD_BITPOS (*fp
,
15072 (FIELD_BITPOS (*fp
)
15073 + anonymous_size
* bits_per_byte
15074 - bit_offset
- FIELD_BITSIZE (*fp
)));
15077 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
15079 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15080 + dwarf2_get_attr_constant_value (attr
, 0)));
15082 /* Get name of field. */
15083 fieldname
= dwarf2_name (die
, cu
);
15084 if (fieldname
== NULL
)
15087 /* The name is already allocated along with this objfile, so we don't
15088 need to duplicate it for the type. */
15089 fp
->name
= fieldname
;
15091 /* Change accessibility for artificial fields (e.g. virtual table
15092 pointer or virtual base class pointer) to private. */
15093 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
15095 FIELD_ARTIFICIAL (*fp
) = 1;
15096 new_field
->accessibility
= DW_ACCESS_private
;
15097 fip
->non_public_fields
= 1;
15100 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
15102 /* C++ static member. */
15104 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15105 is a declaration, but all versions of G++ as of this writing
15106 (so through at least 3.2.1) incorrectly generate
15107 DW_TAG_variable tags. */
15109 const char *physname
;
15111 /* Get name of field. */
15112 fieldname
= dwarf2_name (die
, cu
);
15113 if (fieldname
== NULL
)
15116 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15118 /* Only create a symbol if this is an external value.
15119 new_symbol checks this and puts the value in the global symbol
15120 table, which we want. If it is not external, new_symbol
15121 will try to put the value in cu->list_in_scope which is wrong. */
15122 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
15124 /* A static const member, not much different than an enum as far as
15125 we're concerned, except that we can support more types. */
15126 new_symbol (die
, NULL
, cu
);
15129 /* Get physical name. */
15130 physname
= dwarf2_physname (fieldname
, die
, cu
);
15132 /* The name is already allocated along with this objfile, so we don't
15133 need to duplicate it for the type. */
15134 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
15135 FIELD_TYPE (*fp
) = die_type (die
, cu
);
15136 FIELD_NAME (*fp
) = fieldname
;
15138 else if (die
->tag
== DW_TAG_inheritance
)
15142 /* C++ base class field. */
15143 if (handle_data_member_location (die
, cu
, &offset
))
15144 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
15145 FIELD_BITSIZE (*fp
) = 0;
15146 FIELD_TYPE (*fp
) = die_type (die
, cu
);
15147 FIELD_NAME (*fp
) = TYPE_NAME (fp
->type
);
15149 else if (die
->tag
== DW_TAG_variant_part
)
15151 /* process_structure_scope will treat this DIE as a union. */
15152 process_structure_scope (die
, cu
);
15154 /* The variant part is relative to the start of the enclosing
15156 SET_FIELD_BITPOS (*fp
, 0);
15157 fp
->type
= get_die_type (die
, cu
);
15158 fp
->artificial
= 1;
15159 fp
->name
= "<<variant>>";
15161 /* Normally a DW_TAG_variant_part won't have a size, but our
15162 representation requires one, so set it to the maximum of the
15164 if (TYPE_LENGTH (fp
->type
) == 0)
15167 for (int i
= 0; i
< TYPE_NFIELDS (fp
->type
); ++i
)
15168 if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp
->type
, i
)) > max
)
15169 max
= TYPE_LENGTH (TYPE_FIELD_TYPE (fp
->type
, i
));
15170 TYPE_LENGTH (fp
->type
) = max
;
15174 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15177 /* Can the type given by DIE define another type? */
15180 type_can_define_types (const struct die_info
*die
)
15184 case DW_TAG_typedef
:
15185 case DW_TAG_class_type
:
15186 case DW_TAG_structure_type
:
15187 case DW_TAG_union_type
:
15188 case DW_TAG_enumeration_type
:
15196 /* Add a type definition defined in the scope of the FIP's class. */
15199 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
15200 struct dwarf2_cu
*cu
)
15202 struct decl_field fp
;
15203 memset (&fp
, 0, sizeof (fp
));
15205 gdb_assert (type_can_define_types (die
));
15207 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15208 fp
.name
= dwarf2_name (die
, cu
);
15209 fp
.type
= read_type_die (die
, cu
);
15211 /* Save accessibility. */
15212 enum dwarf_access_attribute accessibility
;
15213 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15215 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
15217 accessibility
= dwarf2_default_access_attribute (die
, cu
);
15218 switch (accessibility
)
15220 case DW_ACCESS_public
:
15221 /* The assumed value if neither private nor protected. */
15223 case DW_ACCESS_private
:
15226 case DW_ACCESS_protected
:
15227 fp
.is_protected
= 1;
15230 complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility
);
15233 if (die
->tag
== DW_TAG_typedef
)
15234 fip
->typedef_field_list
.push_back (fp
);
15236 fip
->nested_types_list
.push_back (fp
);
15239 /* Create the vector of fields, and attach it to the type. */
15242 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
15243 struct dwarf2_cu
*cu
)
15245 int nfields
= fip
->nfields
;
15247 /* Record the field count, allocate space for the array of fields,
15248 and create blank accessibility bitfields if necessary. */
15249 TYPE_NFIELDS (type
) = nfields
;
15250 TYPE_FIELDS (type
) = (struct field
*)
15251 TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
);
15253 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
15255 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15257 TYPE_FIELD_PRIVATE_BITS (type
) =
15258 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15259 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
15261 TYPE_FIELD_PROTECTED_BITS (type
) =
15262 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15263 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
15265 TYPE_FIELD_IGNORE_BITS (type
) =
15266 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15267 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
15270 /* If the type has baseclasses, allocate and clear a bit vector for
15271 TYPE_FIELD_VIRTUAL_BITS. */
15272 if (!fip
->baseclasses
.empty () && cu
->language
!= language_ada
)
15274 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
15275 unsigned char *pointer
;
15277 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15278 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
15279 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
15280 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
15281 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
15284 if (TYPE_FLAG_DISCRIMINATED_UNION (type
))
15286 struct discriminant_info
*di
= alloc_discriminant_info (type
, -1, -1);
15288 for (int index
= 0; index
< nfields
; ++index
)
15290 struct nextfield
&field
= fip
->fields
[index
];
15292 if (field
.variant
.is_discriminant
)
15293 di
->discriminant_index
= index
;
15294 else if (field
.variant
.default_branch
)
15295 di
->default_index
= index
;
15297 di
->discriminants
[index
] = field
.variant
.discriminant_value
;
15301 /* Copy the saved-up fields into the field vector. */
15302 for (int i
= 0; i
< nfields
; ++i
)
15304 struct nextfield
&field
15305 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
15306 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
15308 TYPE_FIELD (type
, i
) = field
.field
;
15309 switch (field
.accessibility
)
15311 case DW_ACCESS_private
:
15312 if (cu
->language
!= language_ada
)
15313 SET_TYPE_FIELD_PRIVATE (type
, i
);
15316 case DW_ACCESS_protected
:
15317 if (cu
->language
!= language_ada
)
15318 SET_TYPE_FIELD_PROTECTED (type
, i
);
15321 case DW_ACCESS_public
:
15325 /* Unknown accessibility. Complain and treat it as public. */
15327 complaint (_("unsupported accessibility %d"),
15328 field
.accessibility
);
15332 if (i
< fip
->baseclasses
.size ())
15334 switch (field
.virtuality
)
15336 case DW_VIRTUALITY_virtual
:
15337 case DW_VIRTUALITY_pure_virtual
:
15338 if (cu
->language
== language_ada
)
15339 error (_("unexpected virtuality in component of Ada type"));
15340 SET_TYPE_FIELD_VIRTUAL (type
, i
);
15347 /* Return true if this member function is a constructor, false
15351 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15353 const char *fieldname
;
15354 const char *type_name
;
15357 if (die
->parent
== NULL
)
15360 if (die
->parent
->tag
!= DW_TAG_structure_type
15361 && die
->parent
->tag
!= DW_TAG_union_type
15362 && die
->parent
->tag
!= DW_TAG_class_type
)
15365 fieldname
= dwarf2_name (die
, cu
);
15366 type_name
= dwarf2_name (die
->parent
, cu
);
15367 if (fieldname
== NULL
|| type_name
== NULL
)
15370 len
= strlen (fieldname
);
15371 return (strncmp (fieldname
, type_name
, len
) == 0
15372 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15375 /* Add a member function to the proper fieldlist. */
15378 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15379 struct type
*type
, struct dwarf2_cu
*cu
)
15381 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15382 struct attribute
*attr
;
15384 struct fnfieldlist
*flp
= nullptr;
15385 struct fn_field
*fnp
;
15386 const char *fieldname
;
15387 struct type
*this_type
;
15388 enum dwarf_access_attribute accessibility
;
15390 if (cu
->language
== language_ada
)
15391 error (_("unexpected member function in Ada type"));
15393 /* Get name of member function. */
15394 fieldname
= dwarf2_name (die
, cu
);
15395 if (fieldname
== NULL
)
15398 /* Look up member function name in fieldlist. */
15399 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15401 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15403 flp
= &fip
->fnfieldlists
[i
];
15408 /* Create a new fnfieldlist if necessary. */
15409 if (flp
== nullptr)
15411 fip
->fnfieldlists
.emplace_back ();
15412 flp
= &fip
->fnfieldlists
.back ();
15413 flp
->name
= fieldname
;
15414 i
= fip
->fnfieldlists
.size () - 1;
15417 /* Create a new member function field and add it to the vector of
15419 flp
->fnfields
.emplace_back ();
15420 fnp
= &flp
->fnfields
.back ();
15422 /* Delay processing of the physname until later. */
15423 if (cu
->language
== language_cplus
)
15424 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15428 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15429 fnp
->physname
= physname
? physname
: "";
15432 fnp
->type
= alloc_type (objfile
);
15433 this_type
= read_type_die (die
, cu
);
15434 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
15436 int nparams
= TYPE_NFIELDS (this_type
);
15438 /* TYPE is the domain of this method, and THIS_TYPE is the type
15439 of the method itself (TYPE_CODE_METHOD). */
15440 smash_to_method_type (fnp
->type
, type
,
15441 TYPE_TARGET_TYPE (this_type
),
15442 TYPE_FIELDS (this_type
),
15443 TYPE_NFIELDS (this_type
),
15444 TYPE_VARARGS (this_type
));
15446 /* Handle static member functions.
15447 Dwarf2 has no clean way to discern C++ static and non-static
15448 member functions. G++ helps GDB by marking the first
15449 parameter for non-static member functions (which is the this
15450 pointer) as artificial. We obtain this information from
15451 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15452 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15453 fnp
->voffset
= VOFFSET_STATIC
;
15456 complaint (_("member function type missing for '%s'"),
15457 dwarf2_full_name (fieldname
, die
, cu
));
15459 /* Get fcontext from DW_AT_containing_type if present. */
15460 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15461 fnp
->fcontext
= die_containing_type (die
, cu
);
15463 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15464 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15466 /* Get accessibility. */
15467 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15469 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
15471 accessibility
= dwarf2_default_access_attribute (die
, cu
);
15472 switch (accessibility
)
15474 case DW_ACCESS_private
:
15475 fnp
->is_private
= 1;
15477 case DW_ACCESS_protected
:
15478 fnp
->is_protected
= 1;
15482 /* Check for artificial methods. */
15483 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15484 if (attr
&& DW_UNSND (attr
) != 0)
15485 fnp
->is_artificial
= 1;
15487 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15489 /* Get index in virtual function table if it is a virtual member
15490 function. For older versions of GCC, this is an offset in the
15491 appropriate virtual table, as specified by DW_AT_containing_type.
15492 For everyone else, it is an expression to be evaluated relative
15493 to the object address. */
15495 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15498 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
15500 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
15502 /* Old-style GCC. */
15503 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
15505 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
15506 || (DW_BLOCK (attr
)->size
> 1
15507 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
15508 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
15510 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
15511 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15512 dwarf2_complex_location_expr_complaint ();
15514 fnp
->voffset
/= cu
->header
.addr_size
;
15518 dwarf2_complex_location_expr_complaint ();
15520 if (!fnp
->fcontext
)
15522 /* If there is no `this' field and no DW_AT_containing_type,
15523 we cannot actually find a base class context for the
15525 if (TYPE_NFIELDS (this_type
) == 0
15526 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15528 complaint (_("cannot determine context for virtual member "
15529 "function \"%s\" (offset %s)"),
15530 fieldname
, sect_offset_str (die
->sect_off
));
15535 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
15539 else if (attr_form_is_section_offset (attr
))
15541 dwarf2_complex_location_expr_complaint ();
15545 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15551 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15552 if (attr
&& DW_UNSND (attr
))
15554 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15555 complaint (_("Member function \"%s\" (offset %s) is virtual "
15556 "but the vtable offset is not specified"),
15557 fieldname
, sect_offset_str (die
->sect_off
));
15558 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15559 TYPE_CPLUS_DYNAMIC (type
) = 1;
15564 /* Create the vector of member function fields, and attach it to the type. */
15567 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15568 struct dwarf2_cu
*cu
)
15570 if (cu
->language
== language_ada
)
15571 error (_("unexpected member functions in Ada type"));
15573 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15574 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15576 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15578 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15580 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15581 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15583 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15584 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15585 fn_flp
->fn_fields
= (struct fn_field
*)
15586 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15588 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15589 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15592 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15595 /* Returns non-zero if NAME is the name of a vtable member in CU's
15596 language, zero otherwise. */
15598 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15600 static const char vptr
[] = "_vptr";
15602 /* Look for the C++ form of the vtable. */
15603 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15609 /* GCC outputs unnamed structures that are really pointers to member
15610 functions, with the ABI-specified layout. If TYPE describes
15611 such a structure, smash it into a member function type.
15613 GCC shouldn't do this; it should just output pointer to member DIEs.
15614 This is GCC PR debug/28767. */
15617 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15619 struct type
*pfn_type
, *self_type
, *new_type
;
15621 /* Check for a structure with no name and two children. */
15622 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
15625 /* Check for __pfn and __delta members. */
15626 if (TYPE_FIELD_NAME (type
, 0) == NULL
15627 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15628 || TYPE_FIELD_NAME (type
, 1) == NULL
15629 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15632 /* Find the type of the method. */
15633 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
15634 if (pfn_type
== NULL
15635 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
15636 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
15639 /* Look for the "this" argument. */
15640 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15641 if (TYPE_NFIELDS (pfn_type
) == 0
15642 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15643 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
15646 self_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
15647 new_type
= alloc_type (objfile
);
15648 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15649 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
15650 TYPE_VARARGS (pfn_type
));
15651 smash_to_methodptr_type (type
, new_type
);
15654 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15655 appropriate error checking and issuing complaints if there is a
15659 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
15661 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
15663 if (attr
== nullptr)
15666 if (!attr_form_is_constant (attr
))
15668 complaint (_("DW_AT_alignment must have constant form"
15669 " - DIE at %s [in module %s]"),
15670 sect_offset_str (die
->sect_off
),
15671 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15676 if (attr
->form
== DW_FORM_sdata
)
15678 LONGEST val
= DW_SND (attr
);
15681 complaint (_("DW_AT_alignment value must not be negative"
15682 " - DIE at %s [in module %s]"),
15683 sect_offset_str (die
->sect_off
),
15684 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15690 align
= DW_UNSND (attr
);
15694 complaint (_("DW_AT_alignment value must not be zero"
15695 " - DIE at %s [in module %s]"),
15696 sect_offset_str (die
->sect_off
),
15697 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15700 if ((align
& (align
- 1)) != 0)
15702 complaint (_("DW_AT_alignment value must be a power of 2"
15703 " - DIE at %s [in module %s]"),
15704 sect_offset_str (die
->sect_off
),
15705 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15712 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15713 the alignment for TYPE. */
15716 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
15719 if (!set_type_align (type
, get_alignment (cu
, die
)))
15720 complaint (_("DW_AT_alignment value too large"
15721 " - DIE at %s [in module %s]"),
15722 sect_offset_str (die
->sect_off
),
15723 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15726 /* Called when we find the DIE that starts a structure or union scope
15727 (definition) to create a type for the structure or union. Fill in
15728 the type's name and general properties; the members will not be
15729 processed until process_structure_scope. A symbol table entry for
15730 the type will also not be done until process_structure_scope (assuming
15731 the type has a name).
15733 NOTE: we need to call these functions regardless of whether or not the
15734 DIE has a DW_AT_name attribute, since it might be an anonymous
15735 structure or union. This gets the type entered into our set of
15736 user defined types. */
15738 static struct type
*
15739 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15741 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15743 struct attribute
*attr
;
15746 /* If the definition of this type lives in .debug_types, read that type.
15747 Don't follow DW_AT_specification though, that will take us back up
15748 the chain and we want to go down. */
15749 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
15752 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15754 /* The type's CU may not be the same as CU.
15755 Ensure TYPE is recorded with CU in die_type_hash. */
15756 return set_die_type (die
, type
, cu
);
15759 type
= alloc_type (objfile
);
15760 INIT_CPLUS_SPECIFIC (type
);
15762 name
= dwarf2_name (die
, cu
);
15765 if (cu
->language
== language_cplus
15766 || cu
->language
== language_d
15767 || cu
->language
== language_rust
)
15769 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
15771 /* dwarf2_full_name might have already finished building the DIE's
15772 type. If so, there is no need to continue. */
15773 if (get_die_type (die
, cu
) != NULL
)
15774 return get_die_type (die
, cu
);
15776 TYPE_NAME (type
) = full_name
;
15780 /* The name is already allocated along with this objfile, so
15781 we don't need to duplicate it for the type. */
15782 TYPE_NAME (type
) = name
;
15786 if (die
->tag
== DW_TAG_structure_type
)
15788 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15790 else if (die
->tag
== DW_TAG_union_type
)
15792 TYPE_CODE (type
) = TYPE_CODE_UNION
;
15794 else if (die
->tag
== DW_TAG_variant_part
)
15796 TYPE_CODE (type
) = TYPE_CODE_UNION
;
15797 TYPE_FLAG_DISCRIMINATED_UNION (type
) = 1;
15801 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15804 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
15805 TYPE_DECLARED_CLASS (type
) = 1;
15807 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15810 if (attr_form_is_constant (attr
))
15811 TYPE_LENGTH (type
) = DW_UNSND (attr
);
15814 /* For the moment, dynamic type sizes are not supported
15815 by GDB's struct type. The actual size is determined
15816 on-demand when resolving the type of a given object,
15817 so set the type's length to zero for now. Otherwise,
15818 we record an expression as the length, and that expression
15819 could lead to a very large value, which could eventually
15820 lead to us trying to allocate that much memory when creating
15821 a value of that type. */
15822 TYPE_LENGTH (type
) = 0;
15827 TYPE_LENGTH (type
) = 0;
15830 maybe_set_alignment (cu
, die
, type
);
15832 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
15834 /* ICC<14 does not output the required DW_AT_declaration on
15835 incomplete types, but gives them a size of zero. */
15836 TYPE_STUB (type
) = 1;
15839 TYPE_STUB_SUPPORTED (type
) = 1;
15841 if (die_is_declaration (die
, cu
))
15842 TYPE_STUB (type
) = 1;
15843 else if (attr
== NULL
&& die
->child
== NULL
15844 && producer_is_realview (cu
->producer
))
15845 /* RealView does not output the required DW_AT_declaration
15846 on incomplete types. */
15847 TYPE_STUB (type
) = 1;
15849 /* We need to add the type field to the die immediately so we don't
15850 infinitely recurse when dealing with pointers to the structure
15851 type within the structure itself. */
15852 set_die_type (die
, type
, cu
);
15854 /* set_die_type should be already done. */
15855 set_descriptive_type (type
, die
, cu
);
15860 /* A helper for process_structure_scope that handles a single member
15864 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
15865 struct field_info
*fi
,
15866 std::vector
<struct symbol
*> *template_args
,
15867 struct dwarf2_cu
*cu
)
15869 if (child_die
->tag
== DW_TAG_member
15870 || child_die
->tag
== DW_TAG_variable
15871 || child_die
->tag
== DW_TAG_variant_part
)
15873 /* NOTE: carlton/2002-11-05: A C++ static data member
15874 should be a DW_TAG_member that is a declaration, but
15875 all versions of G++ as of this writing (so through at
15876 least 3.2.1) incorrectly generate DW_TAG_variable
15877 tags for them instead. */
15878 dwarf2_add_field (fi
, child_die
, cu
);
15880 else if (child_die
->tag
== DW_TAG_subprogram
)
15882 /* Rust doesn't have member functions in the C++ sense.
15883 However, it does emit ordinary functions as children
15884 of a struct DIE. */
15885 if (cu
->language
== language_rust
)
15886 read_func_scope (child_die
, cu
);
15889 /* C++ member function. */
15890 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
15893 else if (child_die
->tag
== DW_TAG_inheritance
)
15895 /* C++ base class field. */
15896 dwarf2_add_field (fi
, child_die
, cu
);
15898 else if (type_can_define_types (child_die
))
15899 dwarf2_add_type_defn (fi
, child_die
, cu
);
15900 else if (child_die
->tag
== DW_TAG_template_type_param
15901 || child_die
->tag
== DW_TAG_template_value_param
)
15903 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
15906 template_args
->push_back (arg
);
15908 else if (child_die
->tag
== DW_TAG_variant
)
15910 /* In a variant we want to get the discriminant and also add a
15911 field for our sole member child. */
15912 struct attribute
*discr
= dwarf2_attr (child_die
, DW_AT_discr_value
, cu
);
15914 for (die_info
*variant_child
= child_die
->child
;
15915 variant_child
!= NULL
;
15916 variant_child
= sibling_die (variant_child
))
15918 if (variant_child
->tag
== DW_TAG_member
)
15920 handle_struct_member_die (variant_child
, type
, fi
,
15921 template_args
, cu
);
15922 /* Only handle the one. */
15927 /* We don't handle this but we might as well report it if we see
15929 if (dwarf2_attr (child_die
, DW_AT_discr_list
, cu
) != nullptr)
15930 complaint (_("DW_AT_discr_list is not supported yet"
15931 " - DIE at %s [in module %s]"),
15932 sect_offset_str (child_die
->sect_off
),
15933 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15935 /* The first field was just added, so we can stash the
15936 discriminant there. */
15937 gdb_assert (!fi
->fields
.empty ());
15939 fi
->fields
.back ().variant
.default_branch
= true;
15941 fi
->fields
.back ().variant
.discriminant_value
= DW_UNSND (discr
);
15945 /* Finish creating a structure or union type, including filling in
15946 its members and creating a symbol for it. */
15949 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
15951 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15952 struct die_info
*child_die
;
15955 type
= get_die_type (die
, cu
);
15957 type
= read_structure_type (die
, cu
);
15959 /* When reading a DW_TAG_variant_part, we need to notice when we
15960 read the discriminant member, so we can record it later in the
15961 discriminant_info. */
15962 bool is_variant_part
= TYPE_FLAG_DISCRIMINATED_UNION (type
);
15963 sect_offset discr_offset
;
15964 bool has_template_parameters
= false;
15966 if (is_variant_part
)
15968 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
15971 /* Maybe it's a univariant form, an extension we support.
15972 In this case arrange not to check the offset. */
15973 is_variant_part
= false;
15975 else if (attr_form_is_ref (discr
))
15977 struct dwarf2_cu
*target_cu
= cu
;
15978 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
15980 discr_offset
= target_die
->sect_off
;
15984 complaint (_("DW_AT_discr does not have DIE reference form"
15985 " - DIE at %s [in module %s]"),
15986 sect_offset_str (die
->sect_off
),
15987 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15988 is_variant_part
= false;
15992 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
15994 struct field_info fi
;
15995 std::vector
<struct symbol
*> template_args
;
15997 child_die
= die
->child
;
15999 while (child_die
&& child_die
->tag
)
16001 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
16003 if (is_variant_part
&& discr_offset
== child_die
->sect_off
)
16004 fi
.fields
.back ().variant
.is_discriminant
= true;
16006 child_die
= sibling_die (child_die
);
16009 /* Attach template arguments to type. */
16010 if (!template_args
.empty ())
16012 has_template_parameters
= true;
16013 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16014 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
16015 TYPE_TEMPLATE_ARGUMENTS (type
)
16016 = XOBNEWVEC (&objfile
->objfile_obstack
,
16018 TYPE_N_TEMPLATE_ARGUMENTS (type
));
16019 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
16020 template_args
.data (),
16021 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
16022 * sizeof (struct symbol
*)));
16025 /* Attach fields and member functions to the type. */
16027 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
16028 if (!fi
.fnfieldlists
.empty ())
16030 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
16032 /* Get the type which refers to the base class (possibly this
16033 class itself) which contains the vtable pointer for the current
16034 class from the DW_AT_containing_type attribute. This use of
16035 DW_AT_containing_type is a GNU extension. */
16037 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
16039 struct type
*t
= die_containing_type (die
, cu
);
16041 set_type_vptr_basetype (type
, t
);
16046 /* Our own class provides vtbl ptr. */
16047 for (i
= TYPE_NFIELDS (t
) - 1;
16048 i
>= TYPE_N_BASECLASSES (t
);
16051 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
16053 if (is_vtable_name (fieldname
, cu
))
16055 set_type_vptr_fieldno (type
, i
);
16060 /* Complain if virtual function table field not found. */
16061 if (i
< TYPE_N_BASECLASSES (t
))
16062 complaint (_("virtual function table pointer "
16063 "not found when defining class '%s'"),
16064 TYPE_NAME (type
) ? TYPE_NAME (type
) : "");
16068 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
16071 else if (cu
->producer
16072 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
16074 /* The IBM XLC compiler does not provide direct indication
16075 of the containing type, but the vtable pointer is
16076 always named __vfp. */
16080 for (i
= TYPE_NFIELDS (type
) - 1;
16081 i
>= TYPE_N_BASECLASSES (type
);
16084 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
16086 set_type_vptr_fieldno (type
, i
);
16087 set_type_vptr_basetype (type
, type
);
16094 /* Copy fi.typedef_field_list linked list elements content into the
16095 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16096 if (!fi
.typedef_field_list
.empty ())
16098 int count
= fi
.typedef_field_list
.size ();
16100 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16101 TYPE_TYPEDEF_FIELD_ARRAY (type
)
16102 = ((struct decl_field
*)
16104 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
16105 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
16107 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
16108 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
16111 /* Copy fi.nested_types_list linked list elements content into the
16112 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16113 if (!fi
.nested_types_list
.empty () && cu
->language
!= language_ada
)
16115 int count
= fi
.nested_types_list
.size ();
16117 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16118 TYPE_NESTED_TYPES_ARRAY (type
)
16119 = ((struct decl_field
*)
16120 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
16121 TYPE_NESTED_TYPES_COUNT (type
) = count
;
16123 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
16124 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
16128 quirk_gcc_member_function_pointer (type
, objfile
);
16129 if (cu
->language
== language_rust
&& die
->tag
== DW_TAG_union_type
)
16130 cu
->rust_unions
.push_back (type
);
16132 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16133 snapshots) has been known to create a die giving a declaration
16134 for a class that has, as a child, a die giving a definition for a
16135 nested class. So we have to process our children even if the
16136 current die is a declaration. Normally, of course, a declaration
16137 won't have any children at all. */
16139 child_die
= die
->child
;
16141 while (child_die
!= NULL
&& child_die
->tag
)
16143 if (child_die
->tag
== DW_TAG_member
16144 || child_die
->tag
== DW_TAG_variable
16145 || child_die
->tag
== DW_TAG_inheritance
16146 || child_die
->tag
== DW_TAG_template_value_param
16147 || child_die
->tag
== DW_TAG_template_type_param
)
16152 process_die (child_die
, cu
);
16154 child_die
= sibling_die (child_die
);
16157 /* Do not consider external references. According to the DWARF standard,
16158 these DIEs are identified by the fact that they have no byte_size
16159 attribute, and a declaration attribute. */
16160 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16161 || !die_is_declaration (die
, cu
))
16163 struct symbol
*sym
= new_symbol (die
, type
, cu
);
16165 if (has_template_parameters
)
16167 struct symtab
*symtab
;
16168 if (sym
!= nullptr)
16169 symtab
= symbol_symtab (sym
);
16170 else if (cu
->line_header
!= nullptr)
16172 /* Any related symtab will do. */
16174 = cu
->line_header
->file_name_at (file_name_index (1))->symtab
;
16179 complaint (_("could not find suitable "
16180 "symtab for template parameter"
16181 " - DIE at %s [in module %s]"),
16182 sect_offset_str (die
->sect_off
),
16183 objfile_name (objfile
));
16186 if (symtab
!= nullptr)
16188 /* Make sure that the symtab is set on the new symbols.
16189 Even though they don't appear in this symtab directly,
16190 other parts of gdb assume that symbols do, and this is
16191 reasonably true. */
16192 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
16193 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
16199 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16200 update TYPE using some information only available in DIE's children. */
16203 update_enumeration_type_from_children (struct die_info
*die
,
16205 struct dwarf2_cu
*cu
)
16207 struct die_info
*child_die
;
16208 int unsigned_enum
= 1;
16212 auto_obstack obstack
;
16214 for (child_die
= die
->child
;
16215 child_die
!= NULL
&& child_die
->tag
;
16216 child_die
= sibling_die (child_die
))
16218 struct attribute
*attr
;
16220 const gdb_byte
*bytes
;
16221 struct dwarf2_locexpr_baton
*baton
;
16224 if (child_die
->tag
!= DW_TAG_enumerator
)
16227 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16231 name
= dwarf2_name (child_die
, cu
);
16233 name
= "<anonymous enumerator>";
16235 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16236 &value
, &bytes
, &baton
);
16242 else if ((mask
& value
) != 0)
16247 /* If we already know that the enum type is neither unsigned, nor
16248 a flag type, no need to look at the rest of the enumerates. */
16249 if (!unsigned_enum
&& !flag_enum
)
16254 TYPE_UNSIGNED (type
) = 1;
16256 TYPE_FLAG_ENUM (type
) = 1;
16259 /* Given a DW_AT_enumeration_type die, set its type. We do not
16260 complete the type's fields yet, or create any symbols. */
16262 static struct type
*
16263 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16265 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16267 struct attribute
*attr
;
16270 /* If the definition of this type lives in .debug_types, read that type.
16271 Don't follow DW_AT_specification though, that will take us back up
16272 the chain and we want to go down. */
16273 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
16276 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16278 /* The type's CU may not be the same as CU.
16279 Ensure TYPE is recorded with CU in die_type_hash. */
16280 return set_die_type (die
, type
, cu
);
16283 type
= alloc_type (objfile
);
16285 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
16286 name
= dwarf2_full_name (NULL
, die
, cu
);
16288 TYPE_NAME (type
) = name
;
16290 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16293 struct type
*underlying_type
= die_type (die
, cu
);
16295 TYPE_TARGET_TYPE (type
) = underlying_type
;
16298 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16301 TYPE_LENGTH (type
) = DW_UNSND (attr
);
16305 TYPE_LENGTH (type
) = 0;
16308 maybe_set_alignment (cu
, die
, type
);
16310 /* The enumeration DIE can be incomplete. In Ada, any type can be
16311 declared as private in the package spec, and then defined only
16312 inside the package body. Such types are known as Taft Amendment
16313 Types. When another package uses such a type, an incomplete DIE
16314 may be generated by the compiler. */
16315 if (die_is_declaration (die
, cu
))
16316 TYPE_STUB (type
) = 1;
16318 /* Finish the creation of this type by using the enum's children.
16319 We must call this even when the underlying type has been provided
16320 so that we can determine if we're looking at a "flag" enum. */
16321 update_enumeration_type_from_children (die
, type
, cu
);
16323 /* If this type has an underlying type that is not a stub, then we
16324 may use its attributes. We always use the "unsigned" attribute
16325 in this situation, because ordinarily we guess whether the type
16326 is unsigned -- but the guess can be wrong and the underlying type
16327 can tell us the reality. However, we defer to a local size
16328 attribute if one exists, because this lets the compiler override
16329 the underlying type if needed. */
16330 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_STUB (TYPE_TARGET_TYPE (type
)))
16332 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
));
16333 if (TYPE_LENGTH (type
) == 0)
16334 TYPE_LENGTH (type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
16335 if (TYPE_RAW_ALIGN (type
) == 0
16336 && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type
)) != 0)
16337 set_type_align (type
, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type
)));
16340 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
16342 return set_die_type (die
, type
, cu
);
16345 /* Given a pointer to a die which begins an enumeration, process all
16346 the dies that define the members of the enumeration, and create the
16347 symbol for the enumeration type.
16349 NOTE: We reverse the order of the element list. */
16352 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16354 struct type
*this_type
;
16356 this_type
= get_die_type (die
, cu
);
16357 if (this_type
== NULL
)
16358 this_type
= read_enumeration_type (die
, cu
);
16360 if (die
->child
!= NULL
)
16362 struct die_info
*child_die
;
16363 struct symbol
*sym
;
16364 struct field
*fields
= NULL
;
16365 int num_fields
= 0;
16368 child_die
= die
->child
;
16369 while (child_die
&& child_die
->tag
)
16371 if (child_die
->tag
!= DW_TAG_enumerator
)
16373 process_die (child_die
, cu
);
16377 name
= dwarf2_name (child_die
, cu
);
16380 sym
= new_symbol (child_die
, this_type
, cu
);
16382 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
16384 fields
= (struct field
*)
16386 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
16387 * sizeof (struct field
));
16390 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
16391 FIELD_TYPE (fields
[num_fields
]) = NULL
;
16392 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
16393 FIELD_BITSIZE (fields
[num_fields
]) = 0;
16399 child_die
= sibling_die (child_die
);
16404 TYPE_NFIELDS (this_type
) = num_fields
;
16405 TYPE_FIELDS (this_type
) = (struct field
*)
16406 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
16407 memcpy (TYPE_FIELDS (this_type
), fields
,
16408 sizeof (struct field
) * num_fields
);
16413 /* If we are reading an enum from a .debug_types unit, and the enum
16414 is a declaration, and the enum is not the signatured type in the
16415 unit, then we do not want to add a symbol for it. Adding a
16416 symbol would in some cases obscure the true definition of the
16417 enum, giving users an incomplete type when the definition is
16418 actually available. Note that we do not want to do this for all
16419 enums which are just declarations, because C++0x allows forward
16420 enum declarations. */
16421 if (cu
->per_cu
->is_debug_types
16422 && die_is_declaration (die
, cu
))
16424 struct signatured_type
*sig_type
;
16426 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16427 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16428 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16432 new_symbol (die
, this_type
, cu
);
16435 /* Extract all information from a DW_TAG_array_type DIE and put it in
16436 the DIE's type field. For now, this only handles one dimensional
16439 static struct type
*
16440 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16442 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16443 struct die_info
*child_die
;
16445 struct type
*element_type
, *range_type
, *index_type
;
16446 struct attribute
*attr
;
16448 struct dynamic_prop
*byte_stride_prop
= NULL
;
16449 unsigned int bit_stride
= 0;
16451 element_type
= die_type (die
, cu
);
16453 /* The die_type call above may have already set the type for this DIE. */
16454 type
= get_die_type (die
, cu
);
16458 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
16464 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
16465 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
);
16468 complaint (_("unable to read array DW_AT_byte_stride "
16469 " - DIE at %s [in module %s]"),
16470 sect_offset_str (die
->sect_off
),
16471 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
16472 /* Ignore this attribute. We will likely not be able to print
16473 arrays of this type correctly, but there is little we can do
16474 to help if we cannot read the attribute's value. */
16475 byte_stride_prop
= NULL
;
16479 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
16481 bit_stride
= DW_UNSND (attr
);
16483 /* Irix 6.2 native cc creates array types without children for
16484 arrays with unspecified length. */
16485 if (die
->child
== NULL
)
16487 index_type
= objfile_type (objfile
)->builtin_int
;
16488 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
16489 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
16490 byte_stride_prop
, bit_stride
);
16491 return set_die_type (die
, type
, cu
);
16494 std::vector
<struct type
*> range_types
;
16495 child_die
= die
->child
;
16496 while (child_die
&& child_die
->tag
)
16498 if (child_die
->tag
== DW_TAG_subrange_type
)
16500 struct type
*child_type
= read_type_die (child_die
, cu
);
16502 if (child_type
!= NULL
)
16504 /* The range type was succesfully read. Save it for the
16505 array type creation. */
16506 range_types
.push_back (child_type
);
16509 child_die
= sibling_die (child_die
);
16512 /* Dwarf2 dimensions are output from left to right, create the
16513 necessary array types in backwards order. */
16515 type
= element_type
;
16517 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
16521 while (i
< range_types
.size ())
16522 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
16523 byte_stride_prop
, bit_stride
);
16527 size_t ndim
= range_types
.size ();
16529 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
16530 byte_stride_prop
, bit_stride
);
16533 /* Understand Dwarf2 support for vector types (like they occur on
16534 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16535 array type. This is not part of the Dwarf2/3 standard yet, but a
16536 custom vendor extension. The main difference between a regular
16537 array and the vector variant is that vectors are passed by value
16539 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
16541 make_vector_type (type
);
16543 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16544 implementation may choose to implement triple vectors using this
16546 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16549 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
16550 TYPE_LENGTH (type
) = DW_UNSND (attr
);
16552 complaint (_("DW_AT_byte_size for array type smaller "
16553 "than the total size of elements"));
16556 name
= dwarf2_name (die
, cu
);
16558 TYPE_NAME (type
) = name
;
16560 maybe_set_alignment (cu
, die
, type
);
16562 /* Install the type in the die. */
16563 set_die_type (die
, type
, cu
);
16565 /* set_die_type should be already done. */
16566 set_descriptive_type (type
, die
, cu
);
16571 static enum dwarf_array_dim_ordering
16572 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
16574 struct attribute
*attr
;
16576 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
16579 return (enum dwarf_array_dim_ordering
) DW_SND (attr
);
16581 /* GNU F77 is a special case, as at 08/2004 array type info is the
16582 opposite order to the dwarf2 specification, but data is still
16583 laid out as per normal fortran.
16585 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16586 version checking. */
16588 if (cu
->language
== language_fortran
16589 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
16591 return DW_ORD_row_major
;
16594 switch (cu
->language_defn
->la_array_ordering
)
16596 case array_column_major
:
16597 return DW_ORD_col_major
;
16598 case array_row_major
:
16600 return DW_ORD_row_major
;
16604 /* Extract all information from a DW_TAG_set_type DIE and put it in
16605 the DIE's type field. */
16607 static struct type
*
16608 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16610 struct type
*domain_type
, *set_type
;
16611 struct attribute
*attr
;
16613 domain_type
= die_type (die
, cu
);
16615 /* The die_type call above may have already set the type for this DIE. */
16616 set_type
= get_die_type (die
, cu
);
16620 set_type
= create_set_type (NULL
, domain_type
);
16622 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16624 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
16626 maybe_set_alignment (cu
, die
, set_type
);
16628 return set_die_type (die
, set_type
, cu
);
16631 /* A helper for read_common_block that creates a locexpr baton.
16632 SYM is the symbol which we are marking as computed.
16633 COMMON_DIE is the DIE for the common block.
16634 COMMON_LOC is the location expression attribute for the common
16636 MEMBER_LOC is the location expression attribute for the particular
16637 member of the common block that we are processing.
16638 CU is the CU from which the above come. */
16641 mark_common_block_symbol_computed (struct symbol
*sym
,
16642 struct die_info
*common_die
,
16643 struct attribute
*common_loc
,
16644 struct attribute
*member_loc
,
16645 struct dwarf2_cu
*cu
)
16647 struct dwarf2_per_objfile
*dwarf2_per_objfile
16648 = cu
->per_cu
->dwarf2_per_objfile
;
16649 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16650 struct dwarf2_locexpr_baton
*baton
;
16652 unsigned int cu_off
;
16653 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
16654 LONGEST offset
= 0;
16656 gdb_assert (common_loc
&& member_loc
);
16657 gdb_assert (attr_form_is_block (common_loc
));
16658 gdb_assert (attr_form_is_block (member_loc
)
16659 || attr_form_is_constant (member_loc
));
16661 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
16662 baton
->per_cu
= cu
->per_cu
;
16663 gdb_assert (baton
->per_cu
);
16665 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16667 if (attr_form_is_constant (member_loc
))
16669 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
16670 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
16673 baton
->size
+= DW_BLOCK (member_loc
)->size
;
16675 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
16678 *ptr
++ = DW_OP_call4
;
16679 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
16680 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
16683 if (attr_form_is_constant (member_loc
))
16685 *ptr
++ = DW_OP_addr
;
16686 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
16687 ptr
+= cu
->header
.addr_size
;
16691 /* We have to copy the data here, because DW_OP_call4 will only
16692 use a DW_AT_location attribute. */
16693 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
16694 ptr
+= DW_BLOCK (member_loc
)->size
;
16697 *ptr
++ = DW_OP_plus
;
16698 gdb_assert (ptr
- baton
->data
== baton
->size
);
16700 SYMBOL_LOCATION_BATON (sym
) = baton
;
16701 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
16704 /* Create appropriate locally-scoped variables for all the
16705 DW_TAG_common_block entries. Also create a struct common_block
16706 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16707 is used to sepate the common blocks name namespace from regular
16711 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
16713 struct attribute
*attr
;
16715 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16718 /* Support the .debug_loc offsets. */
16719 if (attr_form_is_block (attr
))
16723 else if (attr_form_is_section_offset (attr
))
16725 dwarf2_complex_location_expr_complaint ();
16730 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16731 "common block member");
16736 if (die
->child
!= NULL
)
16738 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16739 struct die_info
*child_die
;
16740 size_t n_entries
= 0, size
;
16741 struct common_block
*common_block
;
16742 struct symbol
*sym
;
16744 for (child_die
= die
->child
;
16745 child_die
&& child_die
->tag
;
16746 child_die
= sibling_die (child_die
))
16749 size
= (sizeof (struct common_block
)
16750 + (n_entries
- 1) * sizeof (struct symbol
*));
16752 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
16754 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
16755 common_block
->n_entries
= 0;
16757 for (child_die
= die
->child
;
16758 child_die
&& child_die
->tag
;
16759 child_die
= sibling_die (child_die
))
16761 /* Create the symbol in the DW_TAG_common_block block in the current
16763 sym
= new_symbol (child_die
, NULL
, cu
);
16766 struct attribute
*member_loc
;
16768 common_block
->contents
[common_block
->n_entries
++] = sym
;
16770 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
16774 /* GDB has handled this for a long time, but it is
16775 not specified by DWARF. It seems to have been
16776 emitted by gfortran at least as recently as:
16777 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16778 complaint (_("Variable in common block has "
16779 "DW_AT_data_member_location "
16780 "- DIE at %s [in module %s]"),
16781 sect_offset_str (child_die
->sect_off
),
16782 objfile_name (objfile
));
16784 if (attr_form_is_section_offset (member_loc
))
16785 dwarf2_complex_location_expr_complaint ();
16786 else if (attr_form_is_constant (member_loc
)
16787 || attr_form_is_block (member_loc
))
16790 mark_common_block_symbol_computed (sym
, die
, attr
,
16794 dwarf2_complex_location_expr_complaint ();
16799 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
16800 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
16804 /* Create a type for a C++ namespace. */
16806 static struct type
*
16807 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16809 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16810 const char *previous_prefix
, *name
;
16814 /* For extensions, reuse the type of the original namespace. */
16815 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
16817 struct die_info
*ext_die
;
16818 struct dwarf2_cu
*ext_cu
= cu
;
16820 ext_die
= dwarf2_extension (die
, &ext_cu
);
16821 type
= read_type_die (ext_die
, ext_cu
);
16823 /* EXT_CU may not be the same as CU.
16824 Ensure TYPE is recorded with CU in die_type_hash. */
16825 return set_die_type (die
, type
, cu
);
16828 name
= namespace_name (die
, &is_anonymous
, cu
);
16830 /* Now build the name of the current namespace. */
16832 previous_prefix
= determine_prefix (die
, cu
);
16833 if (previous_prefix
[0] != '\0')
16834 name
= typename_concat (&objfile
->objfile_obstack
,
16835 previous_prefix
, name
, 0, cu
);
16837 /* Create the type. */
16838 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
16840 return set_die_type (die
, type
, cu
);
16843 /* Read a namespace scope. */
16846 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
16848 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16851 /* Add a symbol associated to this if we haven't seen the namespace
16852 before. Also, add a using directive if it's an anonymous
16855 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
16859 type
= read_type_die (die
, cu
);
16860 new_symbol (die
, type
, cu
);
16862 namespace_name (die
, &is_anonymous
, cu
);
16865 const char *previous_prefix
= determine_prefix (die
, cu
);
16867 std::vector
<const char *> excludes
;
16868 add_using_directive (using_directives (cu
),
16869 previous_prefix
, TYPE_NAME (type
), NULL
,
16870 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
16874 if (die
->child
!= NULL
)
16876 struct die_info
*child_die
= die
->child
;
16878 while (child_die
&& child_die
->tag
)
16880 process_die (child_die
, cu
);
16881 child_die
= sibling_die (child_die
);
16886 /* Read a Fortran module as type. This DIE can be only a declaration used for
16887 imported module. Still we need that type as local Fortran "use ... only"
16888 declaration imports depend on the created type in determine_prefix. */
16890 static struct type
*
16891 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16893 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16894 const char *module_name
;
16897 module_name
= dwarf2_name (die
, cu
);
16898 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
16900 return set_die_type (die
, type
, cu
);
16903 /* Read a Fortran module. */
16906 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
16908 struct die_info
*child_die
= die
->child
;
16911 type
= read_type_die (die
, cu
);
16912 new_symbol (die
, type
, cu
);
16914 while (child_die
&& child_die
->tag
)
16916 process_die (child_die
, cu
);
16917 child_die
= sibling_die (child_die
);
16921 /* Return the name of the namespace represented by DIE. Set
16922 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16925 static const char *
16926 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
16928 struct die_info
*current_die
;
16929 const char *name
= NULL
;
16931 /* Loop through the extensions until we find a name. */
16933 for (current_die
= die
;
16934 current_die
!= NULL
;
16935 current_die
= dwarf2_extension (die
, &cu
))
16937 /* We don't use dwarf2_name here so that we can detect the absence
16938 of a name -> anonymous namespace. */
16939 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
16945 /* Is it an anonymous namespace? */
16947 *is_anonymous
= (name
== NULL
);
16949 name
= CP_ANONYMOUS_NAMESPACE_STR
;
16954 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16955 the user defined type vector. */
16957 static struct type
*
16958 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16960 struct gdbarch
*gdbarch
16961 = get_objfile_arch (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
16962 struct comp_unit_head
*cu_header
= &cu
->header
;
16964 struct attribute
*attr_byte_size
;
16965 struct attribute
*attr_address_class
;
16966 int byte_size
, addr_class
;
16967 struct type
*target_type
;
16969 target_type
= die_type (die
, cu
);
16971 /* The die_type call above may have already set the type for this DIE. */
16972 type
= get_die_type (die
, cu
);
16976 type
= lookup_pointer_type (target_type
);
16978 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16979 if (attr_byte_size
)
16980 byte_size
= DW_UNSND (attr_byte_size
);
16982 byte_size
= cu_header
->addr_size
;
16984 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
16985 if (attr_address_class
)
16986 addr_class
= DW_UNSND (attr_address_class
);
16988 addr_class
= DW_ADDR_none
;
16990 ULONGEST alignment
= get_alignment (cu
, die
);
16992 /* If the pointer size, alignment, or address class is different
16993 than the default, create a type variant marked as such and set
16994 the length accordingly. */
16995 if (TYPE_LENGTH (type
) != byte_size
16996 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
16997 && alignment
!= TYPE_RAW_ALIGN (type
))
16998 || addr_class
!= DW_ADDR_none
)
17000 if (gdbarch_address_class_type_flags_p (gdbarch
))
17004 type_flags
= gdbarch_address_class_type_flags
17005 (gdbarch
, byte_size
, addr_class
);
17006 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
17008 type
= make_type_with_address_space (type
, type_flags
);
17010 else if (TYPE_LENGTH (type
) != byte_size
)
17012 complaint (_("invalid pointer size %d"), byte_size
);
17014 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17016 complaint (_("Invalid DW_AT_alignment"
17017 " - DIE at %s [in module %s]"),
17018 sect_offset_str (die
->sect_off
),
17019 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17023 /* Should we also complain about unhandled address classes? */
17027 TYPE_LENGTH (type
) = byte_size
;
17028 set_type_align (type
, alignment
);
17029 return set_die_type (die
, type
, cu
);
17032 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17033 the user defined type vector. */
17035 static struct type
*
17036 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17039 struct type
*to_type
;
17040 struct type
*domain
;
17042 to_type
= die_type (die
, cu
);
17043 domain
= die_containing_type (die
, cu
);
17045 /* The calls above may have already set the type for this DIE. */
17046 type
= get_die_type (die
, cu
);
17050 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
17051 type
= lookup_methodptr_type (to_type
);
17052 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
17054 struct type
*new_type
17055 = alloc_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
17057 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17058 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
17059 TYPE_VARARGS (to_type
));
17060 type
= lookup_methodptr_type (new_type
);
17063 type
= lookup_memberptr_type (to_type
, domain
);
17065 return set_die_type (die
, type
, cu
);
17068 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17069 the user defined type vector. */
17071 static struct type
*
17072 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17073 enum type_code refcode
)
17075 struct comp_unit_head
*cu_header
= &cu
->header
;
17076 struct type
*type
, *target_type
;
17077 struct attribute
*attr
;
17079 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17081 target_type
= die_type (die
, cu
);
17083 /* The die_type call above may have already set the type for this DIE. */
17084 type
= get_die_type (die
, cu
);
17088 type
= lookup_reference_type (target_type
, refcode
);
17089 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17092 TYPE_LENGTH (type
) = DW_UNSND (attr
);
17096 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17098 maybe_set_alignment (cu
, die
, type
);
17099 return set_die_type (die
, type
, cu
);
17102 /* Add the given cv-qualifiers to the element type of the array. GCC
17103 outputs DWARF type qualifiers that apply to an array, not the
17104 element type. But GDB relies on the array element type to carry
17105 the cv-qualifiers. This mimics section 6.7.3 of the C99
17108 static struct type
*
17109 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17110 struct type
*base_type
, int cnst
, int voltl
)
17112 struct type
*el_type
, *inner_array
;
17114 base_type
= copy_type (base_type
);
17115 inner_array
= base_type
;
17117 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
17119 TYPE_TARGET_TYPE (inner_array
) =
17120 copy_type (TYPE_TARGET_TYPE (inner_array
));
17121 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17124 el_type
= TYPE_TARGET_TYPE (inner_array
);
17125 cnst
|= TYPE_CONST (el_type
);
17126 voltl
|= TYPE_VOLATILE (el_type
);
17127 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17129 return set_die_type (die
, base_type
, cu
);
17132 static struct type
*
17133 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17135 struct type
*base_type
, *cv_type
;
17137 base_type
= die_type (die
, cu
);
17139 /* The die_type call above may have already set the type for this DIE. */
17140 cv_type
= get_die_type (die
, cu
);
17144 /* In case the const qualifier is applied to an array type, the element type
17145 is so qualified, not the array type (section 6.7.3 of C99). */
17146 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
17147 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17149 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17150 return set_die_type (die
, cv_type
, cu
);
17153 static struct type
*
17154 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17156 struct type
*base_type
, *cv_type
;
17158 base_type
= die_type (die
, cu
);
17160 /* The die_type call above may have already set the type for this DIE. */
17161 cv_type
= get_die_type (die
, cu
);
17165 /* In case the volatile qualifier is applied to an array type, the
17166 element type is so qualified, not the array type (section 6.7.3
17168 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
17169 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17171 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17172 return set_die_type (die
, cv_type
, cu
);
17175 /* Handle DW_TAG_restrict_type. */
17177 static struct type
*
17178 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17180 struct type
*base_type
, *cv_type
;
17182 base_type
= die_type (die
, cu
);
17184 /* The die_type call above may have already set the type for this DIE. */
17185 cv_type
= get_die_type (die
, cu
);
17189 cv_type
= make_restrict_type (base_type
);
17190 return set_die_type (die
, cv_type
, cu
);
17193 /* Handle DW_TAG_atomic_type. */
17195 static struct type
*
17196 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17198 struct type
*base_type
, *cv_type
;
17200 base_type
= die_type (die
, cu
);
17202 /* The die_type call above may have already set the type for this DIE. */
17203 cv_type
= get_die_type (die
, cu
);
17207 cv_type
= make_atomic_type (base_type
);
17208 return set_die_type (die
, cv_type
, cu
);
17211 /* Extract all information from a DW_TAG_string_type DIE and add to
17212 the user defined type vector. It isn't really a user defined type,
17213 but it behaves like one, with other DIE's using an AT_user_def_type
17214 attribute to reference it. */
17216 static struct type
*
17217 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17219 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17220 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17221 struct type
*type
, *range_type
, *index_type
, *char_type
;
17222 struct attribute
*attr
;
17223 unsigned int length
;
17225 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17228 length
= DW_UNSND (attr
);
17232 /* Check for the DW_AT_byte_size attribute. */
17233 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17236 length
= DW_UNSND (attr
);
17244 index_type
= objfile_type (objfile
)->builtin_int
;
17245 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17246 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17247 type
= create_string_type (NULL
, char_type
, range_type
);
17249 return set_die_type (die
, type
, cu
);
17252 /* Assuming that DIE corresponds to a function, returns nonzero
17253 if the function is prototyped. */
17256 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17258 struct attribute
*attr
;
17260 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17261 if (attr
&& (DW_UNSND (attr
) != 0))
17264 /* The DWARF standard implies that the DW_AT_prototyped attribute
17265 is only meaninful for C, but the concept also extends to other
17266 languages that allow unprototyped functions (Eg: Objective C).
17267 For all other languages, assume that functions are always
17269 if (cu
->language
!= language_c
17270 && cu
->language
!= language_objc
17271 && cu
->language
!= language_opencl
)
17274 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17275 prototyped and unprototyped functions; default to prototyped,
17276 since that is more common in modern code (and RealView warns
17277 about unprototyped functions). */
17278 if (producer_is_realview (cu
->producer
))
17284 /* Handle DIES due to C code like:
17288 int (*funcp)(int a, long l);
17292 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17294 static struct type
*
17295 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17297 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17298 struct type
*type
; /* Type that this function returns. */
17299 struct type
*ftype
; /* Function that returns above type. */
17300 struct attribute
*attr
;
17302 type
= die_type (die
, cu
);
17304 /* The die_type call above may have already set the type for this DIE. */
17305 ftype
= get_die_type (die
, cu
);
17309 ftype
= lookup_function_type (type
);
17311 if (prototyped_function_p (die
, cu
))
17312 TYPE_PROTOTYPED (ftype
) = 1;
17314 /* Store the calling convention in the type if it's available in
17315 the subroutine die. Otherwise set the calling convention to
17316 the default value DW_CC_normal. */
17317 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
17319 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
17320 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
17321 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
17323 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
17325 /* Record whether the function returns normally to its caller or not
17326 if the DWARF producer set that information. */
17327 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
17328 if (attr
&& (DW_UNSND (attr
) != 0))
17329 TYPE_NO_RETURN (ftype
) = 1;
17331 /* We need to add the subroutine type to the die immediately so
17332 we don't infinitely recurse when dealing with parameters
17333 declared as the same subroutine type. */
17334 set_die_type (die
, ftype
, cu
);
17336 if (die
->child
!= NULL
)
17338 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
17339 struct die_info
*child_die
;
17340 int nparams
, iparams
;
17342 /* Count the number of parameters.
17343 FIXME: GDB currently ignores vararg functions, but knows about
17344 vararg member functions. */
17346 child_die
= die
->child
;
17347 while (child_die
&& child_die
->tag
)
17349 if (child_die
->tag
== DW_TAG_formal_parameter
)
17351 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
17352 TYPE_VARARGS (ftype
) = 1;
17353 child_die
= sibling_die (child_die
);
17356 /* Allocate storage for parameters and fill them in. */
17357 TYPE_NFIELDS (ftype
) = nparams
;
17358 TYPE_FIELDS (ftype
) = (struct field
*)
17359 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
17361 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17362 even if we error out during the parameters reading below. */
17363 for (iparams
= 0; iparams
< nparams
; iparams
++)
17364 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
17367 child_die
= die
->child
;
17368 while (child_die
&& child_die
->tag
)
17370 if (child_die
->tag
== DW_TAG_formal_parameter
)
17372 struct type
*arg_type
;
17374 /* DWARF version 2 has no clean way to discern C++
17375 static and non-static member functions. G++ helps
17376 GDB by marking the first parameter for non-static
17377 member functions (which is the this pointer) as
17378 artificial. We pass this information to
17379 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17381 DWARF version 3 added DW_AT_object_pointer, which GCC
17382 4.5 does not yet generate. */
17383 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
17385 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
17387 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
17388 arg_type
= die_type (child_die
, cu
);
17390 /* RealView does not mark THIS as const, which the testsuite
17391 expects. GCC marks THIS as const in method definitions,
17392 but not in the class specifications (GCC PR 43053). */
17393 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
17394 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
17397 struct dwarf2_cu
*arg_cu
= cu
;
17398 const char *name
= dwarf2_name (child_die
, cu
);
17400 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
17403 /* If the compiler emits this, use it. */
17404 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
17407 else if (name
&& strcmp (name
, "this") == 0)
17408 /* Function definitions will have the argument names. */
17410 else if (name
== NULL
&& iparams
== 0)
17411 /* Declarations may not have the names, so like
17412 elsewhere in GDB, assume an artificial first
17413 argument is "this". */
17417 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
17421 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
17424 child_die
= sibling_die (child_die
);
17431 static struct type
*
17432 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
17434 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17435 const char *name
= NULL
;
17436 struct type
*this_type
, *target_type
;
17438 name
= dwarf2_full_name (NULL
, die
, cu
);
17439 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
17440 TYPE_TARGET_STUB (this_type
) = 1;
17441 set_die_type (die
, this_type
, cu
);
17442 target_type
= die_type (die
, cu
);
17443 if (target_type
!= this_type
)
17444 TYPE_TARGET_TYPE (this_type
) = target_type
;
17447 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17448 spec and cause infinite loops in GDB. */
17449 complaint (_("Self-referential DW_TAG_typedef "
17450 "- DIE at %s [in module %s]"),
17451 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
17452 TYPE_TARGET_TYPE (this_type
) = NULL
;
17457 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17458 (which may be different from NAME) to the architecture back-end to allow
17459 it to guess the correct format if necessary. */
17461 static struct type
*
17462 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
17463 const char *name_hint
)
17465 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17466 const struct floatformat
**format
;
17469 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
17471 type
= init_float_type (objfile
, bits
, name
, format
);
17473 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17478 /* Allocate an integer type of size BITS and name NAME. */
17480 static struct type
*
17481 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
17482 int bits
, int unsigned_p
, const char *name
)
17486 /* Versions of Intel's C Compiler generate an integer type called "void"
17487 instead of using DW_TAG_unspecified_type. This has been seen on
17488 at least versions 14, 17, and 18. */
17489 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
17490 && strcmp (name
, "void") == 0)
17491 type
= objfile_type (objfile
)->builtin_void
;
17493 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
17498 /* Initialise and return a floating point type of size BITS suitable for
17499 use as a component of a complex number. The NAME_HINT is passed through
17500 when initialising the floating point type and is the name of the complex
17503 As DWARF doesn't currently provide an explicit name for the components
17504 of a complex number, but it can be helpful to have these components
17505 named, we try to select a suitable name based on the size of the
17507 static struct type
*
17508 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
17509 struct objfile
*objfile
,
17510 int bits
, const char *name_hint
)
17512 gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17513 struct type
*tt
= nullptr;
17515 /* Try to find a suitable floating point builtin type of size BITS.
17516 We're going to use the name of this type as the name for the complex
17517 target type that we are about to create. */
17518 switch (cu
->language
)
17520 case language_fortran
:
17524 tt
= builtin_f_type (gdbarch
)->builtin_real
;
17527 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
17529 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17531 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
17539 tt
= builtin_type (gdbarch
)->builtin_float
;
17542 tt
= builtin_type (gdbarch
)->builtin_double
;
17544 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17546 tt
= builtin_type (gdbarch
)->builtin_long_double
;
17552 /* If the type we found doesn't match the size we were looking for, then
17553 pretend we didn't find a type at all, the complex target type we
17554 create will then be nameless. */
17555 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
17558 const char *name
= (tt
== nullptr) ? nullptr : TYPE_NAME (tt
);
17559 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
);
17562 /* Find a representation of a given base type and install
17563 it in the TYPE field of the die. */
17565 static struct type
*
17566 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17568 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17570 struct attribute
*attr
;
17571 int encoding
= 0, bits
= 0;
17574 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
17577 encoding
= DW_UNSND (attr
);
17579 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17582 bits
= DW_UNSND (attr
) * TARGET_CHAR_BIT
;
17584 name
= dwarf2_name (die
, cu
);
17587 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17592 case DW_ATE_address
:
17593 /* Turn DW_ATE_address into a void * pointer. */
17594 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
17595 type
= init_pointer_type (objfile
, bits
, name
, type
);
17597 case DW_ATE_boolean
:
17598 type
= init_boolean_type (objfile
, bits
, 1, name
);
17600 case DW_ATE_complex_float
:
17601 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
);
17602 type
= init_complex_type (objfile
, name
, type
);
17604 case DW_ATE_decimal_float
:
17605 type
= init_decfloat_type (objfile
, bits
, name
);
17608 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
);
17610 case DW_ATE_signed
:
17611 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
17613 case DW_ATE_unsigned
:
17614 if (cu
->language
== language_fortran
17616 && startswith (name
, "character("))
17617 type
= init_character_type (objfile
, bits
, 1, name
);
17619 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17621 case DW_ATE_signed_char
:
17622 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17623 || cu
->language
== language_pascal
17624 || cu
->language
== language_fortran
)
17625 type
= init_character_type (objfile
, bits
, 0, name
);
17627 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
17629 case DW_ATE_unsigned_char
:
17630 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17631 || cu
->language
== language_pascal
17632 || cu
->language
== language_fortran
17633 || cu
->language
== language_rust
)
17634 type
= init_character_type (objfile
, bits
, 1, name
);
17636 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17640 gdbarch
*arch
= get_objfile_arch (objfile
);
17643 type
= builtin_type (arch
)->builtin_char16
;
17644 else if (bits
== 32)
17645 type
= builtin_type (arch
)->builtin_char32
;
17648 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17650 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17652 return set_die_type (die
, type
, cu
);
17657 complaint (_("unsupported DW_AT_encoding: '%s'"),
17658 dwarf_type_encoding_name (encoding
));
17659 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17663 if (name
&& strcmp (name
, "char") == 0)
17664 TYPE_NOSIGN (type
) = 1;
17666 maybe_set_alignment (cu
, die
, type
);
17668 return set_die_type (die
, type
, cu
);
17671 /* Parse dwarf attribute if it's a block, reference or constant and put the
17672 resulting value of the attribute into struct bound_prop.
17673 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17676 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
17677 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
)
17679 struct dwarf2_property_baton
*baton
;
17680 struct obstack
*obstack
17681 = &cu
->per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
;
17683 if (attr
== NULL
|| prop
== NULL
)
17686 if (attr_form_is_block (attr
))
17688 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17689 baton
->referenced_type
= NULL
;
17690 baton
->locexpr
.per_cu
= cu
->per_cu
;
17691 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
17692 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
17693 prop
->data
.baton
= baton
;
17694 prop
->kind
= PROP_LOCEXPR
;
17695 gdb_assert (prop
->data
.baton
!= NULL
);
17697 else if (attr_form_is_ref (attr
))
17699 struct dwarf2_cu
*target_cu
= cu
;
17700 struct die_info
*target_die
;
17701 struct attribute
*target_attr
;
17703 target_die
= follow_die_ref (die
, attr
, &target_cu
);
17704 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
17705 if (target_attr
== NULL
)
17706 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
17708 if (target_attr
== NULL
)
17711 switch (target_attr
->name
)
17713 case DW_AT_location
:
17714 if (attr_form_is_section_offset (target_attr
))
17716 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17717 baton
->referenced_type
= die_type (target_die
, target_cu
);
17718 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
17719 prop
->data
.baton
= baton
;
17720 prop
->kind
= PROP_LOCLIST
;
17721 gdb_assert (prop
->data
.baton
!= NULL
);
17723 else if (attr_form_is_block (target_attr
))
17725 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17726 baton
->referenced_type
= die_type (target_die
, target_cu
);
17727 baton
->locexpr
.per_cu
= cu
->per_cu
;
17728 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
17729 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
17730 prop
->data
.baton
= baton
;
17731 prop
->kind
= PROP_LOCEXPR
;
17732 gdb_assert (prop
->data
.baton
!= NULL
);
17736 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17737 "dynamic property");
17741 case DW_AT_data_member_location
:
17745 if (!handle_data_member_location (target_die
, target_cu
,
17749 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17750 baton
->referenced_type
= read_type_die (target_die
->parent
,
17752 baton
->offset_info
.offset
= offset
;
17753 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
17754 prop
->data
.baton
= baton
;
17755 prop
->kind
= PROP_ADDR_OFFSET
;
17760 else if (attr_form_is_constant (attr
))
17762 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
17763 prop
->kind
= PROP_CONST
;
17767 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
17768 dwarf2_name (die
, cu
));
17775 /* Read the given DW_AT_subrange DIE. */
17777 static struct type
*
17778 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17780 struct type
*base_type
, *orig_base_type
;
17781 struct type
*range_type
;
17782 struct attribute
*attr
;
17783 struct dynamic_prop low
, high
;
17784 int low_default_is_valid
;
17785 int high_bound_is_count
= 0;
17787 ULONGEST negative_mask
;
17789 orig_base_type
= die_type (die
, cu
);
17790 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17791 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17792 creating the range type, but we use the result of check_typedef
17793 when examining properties of the type. */
17794 base_type
= check_typedef (orig_base_type
);
17796 /* The die_type call above may have already set the type for this DIE. */
17797 range_type
= get_die_type (die
, cu
);
17801 low
.kind
= PROP_CONST
;
17802 high
.kind
= PROP_CONST
;
17803 high
.data
.const_val
= 0;
17805 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17806 omitting DW_AT_lower_bound. */
17807 switch (cu
->language
)
17810 case language_cplus
:
17811 low
.data
.const_val
= 0;
17812 low_default_is_valid
= 1;
17814 case language_fortran
:
17815 low
.data
.const_val
= 1;
17816 low_default_is_valid
= 1;
17819 case language_objc
:
17820 case language_rust
:
17821 low
.data
.const_val
= 0;
17822 low_default_is_valid
= (cu
->header
.version
>= 4);
17826 case language_pascal
:
17827 low
.data
.const_val
= 1;
17828 low_default_is_valid
= (cu
->header
.version
>= 4);
17831 low
.data
.const_val
= 0;
17832 low_default_is_valid
= 0;
17836 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
17838 attr_to_dynamic_prop (attr
, die
, cu
, &low
);
17839 else if (!low_default_is_valid
)
17840 complaint (_("Missing DW_AT_lower_bound "
17841 "- DIE at %s [in module %s]"),
17842 sect_offset_str (die
->sect_off
),
17843 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17845 struct attribute
*attr_ub
, *attr_count
;
17846 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
17847 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
))
17849 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
17850 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
))
17852 /* If bounds are constant do the final calculation here. */
17853 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
17854 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
17856 high_bound_is_count
= 1;
17860 if (attr_ub
!= NULL
)
17861 complaint (_("Unresolved DW_AT_upper_bound "
17862 "- DIE at %s [in module %s]"),
17863 sect_offset_str (die
->sect_off
),
17864 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17865 if (attr_count
!= NULL
)
17866 complaint (_("Unresolved DW_AT_count "
17867 "- DIE at %s [in module %s]"),
17868 sect_offset_str (die
->sect_off
),
17869 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17874 /* Dwarf-2 specifications explicitly allows to create subrange types
17875 without specifying a base type.
17876 In that case, the base type must be set to the type of
17877 the lower bound, upper bound or count, in that order, if any of these
17878 three attributes references an object that has a type.
17879 If no base type is found, the Dwarf-2 specifications say that
17880 a signed integer type of size equal to the size of an address should
17882 For the following C code: `extern char gdb_int [];'
17883 GCC produces an empty range DIE.
17884 FIXME: muller/2010-05-28: Possible references to object for low bound,
17885 high bound or count are not yet handled by this code. */
17886 if (TYPE_CODE (base_type
) == TYPE_CODE_VOID
)
17888 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17889 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17890 int addr_size
= gdbarch_addr_bit (gdbarch
) /8;
17891 struct type
*int_type
= objfile_type (objfile
)->builtin_int
;
17893 /* Test "int", "long int", and "long long int" objfile types,
17894 and select the first one having a size above or equal to the
17895 architecture address size. */
17896 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
17897 base_type
= int_type
;
17900 int_type
= objfile_type (objfile
)->builtin_long
;
17901 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
17902 base_type
= int_type
;
17905 int_type
= objfile_type (objfile
)->builtin_long_long
;
17906 if (int_type
&& TYPE_LENGTH (int_type
) >= addr_size
)
17907 base_type
= int_type
;
17912 /* Normally, the DWARF producers are expected to use a signed
17913 constant form (Eg. DW_FORM_sdata) to express negative bounds.
17914 But this is unfortunately not always the case, as witnessed
17915 with GCC, for instance, where the ambiguous DW_FORM_dataN form
17916 is used instead. To work around that ambiguity, we treat
17917 the bounds as signed, and thus sign-extend their values, when
17918 the base type is signed. */
17920 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
17921 if (low
.kind
== PROP_CONST
17922 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
17923 low
.data
.const_val
|= negative_mask
;
17924 if (high
.kind
== PROP_CONST
17925 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
17926 high
.data
.const_val
|= negative_mask
;
17928 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
);
17930 if (high_bound_is_count
)
17931 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
17933 /* Ada expects an empty array on no boundary attributes. */
17934 if (attr
== NULL
&& cu
->language
!= language_ada
)
17935 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
17937 name
= dwarf2_name (die
, cu
);
17939 TYPE_NAME (range_type
) = name
;
17941 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17943 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
17945 maybe_set_alignment (cu
, die
, range_type
);
17947 set_die_type (die
, range_type
, cu
);
17949 /* set_die_type should be already done. */
17950 set_descriptive_type (range_type
, die
, cu
);
17955 static struct type
*
17956 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17960 type
= init_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
, TYPE_CODE_VOID
,0,
17962 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
17964 /* In Ada, an unspecified type is typically used when the description
17965 of the type is defered to a different unit. When encountering
17966 such a type, we treat it as a stub, and try to resolve it later on,
17968 if (cu
->language
== language_ada
)
17969 TYPE_STUB (type
) = 1;
17971 return set_die_type (die
, type
, cu
);
17974 /* Read a single die and all its descendents. Set the die's sibling
17975 field to NULL; set other fields in the die correctly, and set all
17976 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
17977 location of the info_ptr after reading all of those dies. PARENT
17978 is the parent of the die in question. */
17980 static struct die_info
*
17981 read_die_and_children (const struct die_reader_specs
*reader
,
17982 const gdb_byte
*info_ptr
,
17983 const gdb_byte
**new_info_ptr
,
17984 struct die_info
*parent
)
17986 struct die_info
*die
;
17987 const gdb_byte
*cur_ptr
;
17990 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
17993 *new_info_ptr
= cur_ptr
;
17996 store_in_ref_table (die
, reader
->cu
);
17999 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
18003 *new_info_ptr
= cur_ptr
;
18006 die
->sibling
= NULL
;
18007 die
->parent
= parent
;
18011 /* Read a die, all of its descendents, and all of its siblings; set
18012 all of the fields of all of the dies correctly. Arguments are as
18013 in read_die_and_children. */
18015 static struct die_info
*
18016 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
18017 const gdb_byte
*info_ptr
,
18018 const gdb_byte
**new_info_ptr
,
18019 struct die_info
*parent
)
18021 struct die_info
*first_die
, *last_sibling
;
18022 const gdb_byte
*cur_ptr
;
18024 cur_ptr
= info_ptr
;
18025 first_die
= last_sibling
= NULL
;
18029 struct die_info
*die
18030 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
18034 *new_info_ptr
= cur_ptr
;
18041 last_sibling
->sibling
= die
;
18043 last_sibling
= die
;
18047 /* Read a die, all of its descendents, and all of its siblings; set
18048 all of the fields of all of the dies correctly. Arguments are as
18049 in read_die_and_children.
18050 This the main entry point for reading a DIE and all its children. */
18052 static struct die_info
*
18053 read_die_and_siblings (const struct die_reader_specs
*reader
,
18054 const gdb_byte
*info_ptr
,
18055 const gdb_byte
**new_info_ptr
,
18056 struct die_info
*parent
)
18058 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
18059 new_info_ptr
, parent
);
18061 if (dwarf_die_debug
)
18063 fprintf_unfiltered (gdb_stdlog
,
18064 "Read die from %s@0x%x of %s:\n",
18065 get_section_name (reader
->die_section
),
18066 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18067 bfd_get_filename (reader
->abfd
));
18068 dump_die (die
, dwarf_die_debug
);
18074 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18076 The caller is responsible for filling in the extra attributes
18077 and updating (*DIEP)->num_attrs.
18078 Set DIEP to point to a newly allocated die with its information,
18079 except for its child, sibling, and parent fields.
18080 Set HAS_CHILDREN to tell whether the die has children or not. */
18082 static const gdb_byte
*
18083 read_full_die_1 (const struct die_reader_specs
*reader
,
18084 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18085 int *has_children
, int num_extra_attrs
)
18087 unsigned int abbrev_number
, bytes_read
, i
;
18088 struct abbrev_info
*abbrev
;
18089 struct die_info
*die
;
18090 struct dwarf2_cu
*cu
= reader
->cu
;
18091 bfd
*abfd
= reader
->abfd
;
18093 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
18094 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18095 info_ptr
+= bytes_read
;
18096 if (!abbrev_number
)
18103 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
18105 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18107 bfd_get_filename (abfd
));
18109 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
18110 die
->sect_off
= sect_off
;
18111 die
->tag
= abbrev
->tag
;
18112 die
->abbrev
= abbrev_number
;
18114 /* Make the result usable.
18115 The caller needs to update num_attrs after adding the extra
18117 die
->num_attrs
= abbrev
->num_attrs
;
18119 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18120 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
18124 *has_children
= abbrev
->has_children
;
18128 /* Read a die and all its attributes.
18129 Set DIEP to point to a newly allocated die with its information,
18130 except for its child, sibling, and parent fields.
18131 Set HAS_CHILDREN to tell whether the die has children or not. */
18133 static const gdb_byte
*
18134 read_full_die (const struct die_reader_specs
*reader
,
18135 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18138 const gdb_byte
*result
;
18140 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
18142 if (dwarf_die_debug
)
18144 fprintf_unfiltered (gdb_stdlog
,
18145 "Read die from %s@0x%x of %s:\n",
18146 get_section_name (reader
->die_section
),
18147 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18148 bfd_get_filename (reader
->abfd
));
18149 dump_die (*diep
, dwarf_die_debug
);
18155 /* Abbreviation tables.
18157 In DWARF version 2, the description of the debugging information is
18158 stored in a separate .debug_abbrev section. Before we read any
18159 dies from a section we read in all abbreviations and install them
18160 in a hash table. */
18162 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18164 struct abbrev_info
*
18165 abbrev_table::alloc_abbrev ()
18167 struct abbrev_info
*abbrev
;
18169 abbrev
= XOBNEW (&abbrev_obstack
, struct abbrev_info
);
18170 memset (abbrev
, 0, sizeof (struct abbrev_info
));
18175 /* Add an abbreviation to the table. */
18178 abbrev_table::add_abbrev (unsigned int abbrev_number
,
18179 struct abbrev_info
*abbrev
)
18181 unsigned int hash_number
;
18183 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
18184 abbrev
->next
= m_abbrevs
[hash_number
];
18185 m_abbrevs
[hash_number
] = abbrev
;
18188 /* Look up an abbrev in the table.
18189 Returns NULL if the abbrev is not found. */
18191 struct abbrev_info
*
18192 abbrev_table::lookup_abbrev (unsigned int abbrev_number
)
18194 unsigned int hash_number
;
18195 struct abbrev_info
*abbrev
;
18197 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
18198 abbrev
= m_abbrevs
[hash_number
];
18202 if (abbrev
->number
== abbrev_number
)
18204 abbrev
= abbrev
->next
;
18209 /* Read in an abbrev table. */
18211 static abbrev_table_up
18212 abbrev_table_read_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
18213 struct dwarf2_section_info
*section
,
18214 sect_offset sect_off
)
18216 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18217 bfd
*abfd
= get_section_bfd_owner (section
);
18218 const gdb_byte
*abbrev_ptr
;
18219 struct abbrev_info
*cur_abbrev
;
18220 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
18221 unsigned int abbrev_form
;
18222 struct attr_abbrev
*cur_attrs
;
18223 unsigned int allocated_attrs
;
18225 abbrev_table_up
abbrev_table (new struct abbrev_table (sect_off
));
18227 dwarf2_read_section (objfile
, section
);
18228 abbrev_ptr
= section
->buffer
+ to_underlying (sect_off
);
18229 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18230 abbrev_ptr
+= bytes_read
;
18232 allocated_attrs
= ATTR_ALLOC_CHUNK
;
18233 cur_attrs
= XNEWVEC (struct attr_abbrev
, allocated_attrs
);
18235 /* Loop until we reach an abbrev number of 0. */
18236 while (abbrev_number
)
18238 cur_abbrev
= abbrev_table
->alloc_abbrev ();
18240 /* read in abbrev header */
18241 cur_abbrev
->number
= abbrev_number
;
18243 = (enum dwarf_tag
) read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18244 abbrev_ptr
+= bytes_read
;
18245 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
18248 /* now read in declarations */
18251 LONGEST implicit_const
;
18253 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18254 abbrev_ptr
+= bytes_read
;
18255 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18256 abbrev_ptr
+= bytes_read
;
18257 if (abbrev_form
== DW_FORM_implicit_const
)
18259 implicit_const
= read_signed_leb128 (abfd
, abbrev_ptr
,
18261 abbrev_ptr
+= bytes_read
;
18265 /* Initialize it due to a false compiler warning. */
18266 implicit_const
= -1;
18269 if (abbrev_name
== 0)
18272 if (cur_abbrev
->num_attrs
== allocated_attrs
)
18274 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
18276 = XRESIZEVEC (struct attr_abbrev
, cur_attrs
, allocated_attrs
);
18279 cur_attrs
[cur_abbrev
->num_attrs
].name
18280 = (enum dwarf_attribute
) abbrev_name
;
18281 cur_attrs
[cur_abbrev
->num_attrs
].form
18282 = (enum dwarf_form
) abbrev_form
;
18283 cur_attrs
[cur_abbrev
->num_attrs
].implicit_const
= implicit_const
;
18284 ++cur_abbrev
->num_attrs
;
18287 cur_abbrev
->attrs
=
18288 XOBNEWVEC (&abbrev_table
->abbrev_obstack
, struct attr_abbrev
,
18289 cur_abbrev
->num_attrs
);
18290 memcpy (cur_abbrev
->attrs
, cur_attrs
,
18291 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
18293 abbrev_table
->add_abbrev (abbrev_number
, cur_abbrev
);
18295 /* Get next abbreviation.
18296 Under Irix6 the abbreviations for a compilation unit are not
18297 always properly terminated with an abbrev number of 0.
18298 Exit loop if we encounter an abbreviation which we have
18299 already read (which means we are about to read the abbreviations
18300 for the next compile unit) or if the end of the abbreviation
18301 table is reached. */
18302 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
18304 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18305 abbrev_ptr
+= bytes_read
;
18306 if (abbrev_table
->lookup_abbrev (abbrev_number
) != NULL
)
18311 return abbrev_table
;
18314 /* Returns nonzero if TAG represents a type that we might generate a partial
18318 is_type_tag_for_partial (int tag
)
18323 /* Some types that would be reasonable to generate partial symbols for,
18324 that we don't at present. */
18325 case DW_TAG_array_type
:
18326 case DW_TAG_file_type
:
18327 case DW_TAG_ptr_to_member_type
:
18328 case DW_TAG_set_type
:
18329 case DW_TAG_string_type
:
18330 case DW_TAG_subroutine_type
:
18332 case DW_TAG_base_type
:
18333 case DW_TAG_class_type
:
18334 case DW_TAG_interface_type
:
18335 case DW_TAG_enumeration_type
:
18336 case DW_TAG_structure_type
:
18337 case DW_TAG_subrange_type
:
18338 case DW_TAG_typedef
:
18339 case DW_TAG_union_type
:
18346 /* Load all DIEs that are interesting for partial symbols into memory. */
18348 static struct partial_die_info
*
18349 load_partial_dies (const struct die_reader_specs
*reader
,
18350 const gdb_byte
*info_ptr
, int building_psymtab
)
18352 struct dwarf2_cu
*cu
= reader
->cu
;
18353 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
18354 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
18355 unsigned int bytes_read
;
18356 unsigned int load_all
= 0;
18357 int nesting_level
= 1;
18362 gdb_assert (cu
->per_cu
!= NULL
);
18363 if (cu
->per_cu
->load_all_dies
)
18367 = htab_create_alloc_ex (cu
->header
.length
/ 12,
18371 &cu
->comp_unit_obstack
,
18372 hashtab_obstack_allocate
,
18373 dummy_obstack_deallocate
);
18377 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
18379 /* A NULL abbrev means the end of a series of children. */
18380 if (abbrev
== NULL
)
18382 if (--nesting_level
== 0)
18385 info_ptr
+= bytes_read
;
18386 last_die
= parent_die
;
18387 parent_die
= parent_die
->die_parent
;
18391 /* Check for template arguments. We never save these; if
18392 they're seen, we just mark the parent, and go on our way. */
18393 if (parent_die
!= NULL
18394 && cu
->language
== language_cplus
18395 && (abbrev
->tag
== DW_TAG_template_type_param
18396 || abbrev
->tag
== DW_TAG_template_value_param
))
18398 parent_die
->has_template_arguments
= 1;
18402 /* We don't need a partial DIE for the template argument. */
18403 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18408 /* We only recurse into c++ subprograms looking for template arguments.
18409 Skip their other children. */
18411 && cu
->language
== language_cplus
18412 && parent_die
!= NULL
18413 && parent_die
->tag
== DW_TAG_subprogram
)
18415 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18419 /* Check whether this DIE is interesting enough to save. Normally
18420 we would not be interested in members here, but there may be
18421 later variables referencing them via DW_AT_specification (for
18422 static members). */
18424 && !is_type_tag_for_partial (abbrev
->tag
)
18425 && abbrev
->tag
!= DW_TAG_constant
18426 && abbrev
->tag
!= DW_TAG_enumerator
18427 && abbrev
->tag
!= DW_TAG_subprogram
18428 && abbrev
->tag
!= DW_TAG_inlined_subroutine
18429 && abbrev
->tag
!= DW_TAG_lexical_block
18430 && abbrev
->tag
!= DW_TAG_variable
18431 && abbrev
->tag
!= DW_TAG_namespace
18432 && abbrev
->tag
!= DW_TAG_module
18433 && abbrev
->tag
!= DW_TAG_member
18434 && abbrev
->tag
!= DW_TAG_imported_unit
18435 && abbrev
->tag
!= DW_TAG_imported_declaration
)
18437 /* Otherwise we skip to the next sibling, if any. */
18438 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18442 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
18445 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
18447 /* This two-pass algorithm for processing partial symbols has a
18448 high cost in cache pressure. Thus, handle some simple cases
18449 here which cover the majority of C partial symbols. DIEs
18450 which neither have specification tags in them, nor could have
18451 specification tags elsewhere pointing at them, can simply be
18452 processed and discarded.
18454 This segment is also optional; scan_partial_symbols and
18455 add_partial_symbol will handle these DIEs if we chain
18456 them in normally. When compilers which do not emit large
18457 quantities of duplicate debug information are more common,
18458 this code can probably be removed. */
18460 /* Any complete simple types at the top level (pretty much all
18461 of them, for a language without namespaces), can be processed
18463 if (parent_die
== NULL
18464 && pdi
.has_specification
== 0
18465 && pdi
.is_declaration
== 0
18466 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
18467 || pdi
.tag
== DW_TAG_base_type
18468 || pdi
.tag
== DW_TAG_subrange_type
))
18470 if (building_psymtab
&& pdi
.name
!= NULL
)
18471 add_psymbol_to_list (pdi
.name
, strlen (pdi
.name
), 0,
18472 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
18473 psymbol_placement::STATIC
,
18474 0, cu
->language
, objfile
);
18475 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18479 /* The exception for DW_TAG_typedef with has_children above is
18480 a workaround of GCC PR debug/47510. In the case of this complaint
18481 type_name_or_error will error on such types later.
18483 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18484 it could not find the child DIEs referenced later, this is checked
18485 above. In correct DWARF DW_TAG_typedef should have no children. */
18487 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
18488 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18489 "- DIE at %s [in module %s]"),
18490 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
18492 /* If we're at the second level, and we're an enumerator, and
18493 our parent has no specification (meaning possibly lives in a
18494 namespace elsewhere), then we can add the partial symbol now
18495 instead of queueing it. */
18496 if (pdi
.tag
== DW_TAG_enumerator
18497 && parent_die
!= NULL
18498 && parent_die
->die_parent
== NULL
18499 && parent_die
->tag
== DW_TAG_enumeration_type
18500 && parent_die
->has_specification
== 0)
18502 if (pdi
.name
== NULL
)
18503 complaint (_("malformed enumerator DIE ignored"));
18504 else if (building_psymtab
)
18505 add_psymbol_to_list (pdi
.name
, strlen (pdi
.name
), 0,
18506 VAR_DOMAIN
, LOC_CONST
, -1,
18507 cu
->language
== language_cplus
18508 ? psymbol_placement::GLOBAL
18509 : psymbol_placement::STATIC
,
18510 0, cu
->language
, objfile
);
18512 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18516 struct partial_die_info
*part_die
18517 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
18519 /* We'll save this DIE so link it in. */
18520 part_die
->die_parent
= parent_die
;
18521 part_die
->die_sibling
= NULL
;
18522 part_die
->die_child
= NULL
;
18524 if (last_die
&& last_die
== parent_die
)
18525 last_die
->die_child
= part_die
;
18527 last_die
->die_sibling
= part_die
;
18529 last_die
= part_die
;
18531 if (first_die
== NULL
)
18532 first_die
= part_die
;
18534 /* Maybe add the DIE to the hash table. Not all DIEs that we
18535 find interesting need to be in the hash table, because we
18536 also have the parent/sibling/child chains; only those that we
18537 might refer to by offset later during partial symbol reading.
18539 For now this means things that might have be the target of a
18540 DW_AT_specification, DW_AT_abstract_origin, or
18541 DW_AT_extension. DW_AT_extension will refer only to
18542 namespaces; DW_AT_abstract_origin refers to functions (and
18543 many things under the function DIE, but we do not recurse
18544 into function DIEs during partial symbol reading) and
18545 possibly variables as well; DW_AT_specification refers to
18546 declarations. Declarations ought to have the DW_AT_declaration
18547 flag. It happens that GCC forgets to put it in sometimes, but
18548 only for functions, not for types.
18550 Adding more things than necessary to the hash table is harmless
18551 except for the performance cost. Adding too few will result in
18552 wasted time in find_partial_die, when we reread the compilation
18553 unit with load_all_dies set. */
18556 || abbrev
->tag
== DW_TAG_constant
18557 || abbrev
->tag
== DW_TAG_subprogram
18558 || abbrev
->tag
== DW_TAG_variable
18559 || abbrev
->tag
== DW_TAG_namespace
18560 || part_die
->is_declaration
)
18564 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
18565 to_underlying (part_die
->sect_off
),
18570 /* For some DIEs we want to follow their children (if any). For C
18571 we have no reason to follow the children of structures; for other
18572 languages we have to, so that we can get at method physnames
18573 to infer fully qualified class names, for DW_AT_specification,
18574 and for C++ template arguments. For C++, we also look one level
18575 inside functions to find template arguments (if the name of the
18576 function does not already contain the template arguments).
18578 For Ada, we need to scan the children of subprograms and lexical
18579 blocks as well because Ada allows the definition of nested
18580 entities that could be interesting for the debugger, such as
18581 nested subprograms for instance. */
18582 if (last_die
->has_children
18584 || last_die
->tag
== DW_TAG_namespace
18585 || last_die
->tag
== DW_TAG_module
18586 || last_die
->tag
== DW_TAG_enumeration_type
18587 || (cu
->language
== language_cplus
18588 && last_die
->tag
== DW_TAG_subprogram
18589 && (last_die
->name
== NULL
18590 || strchr (last_die
->name
, '<') == NULL
))
18591 || (cu
->language
!= language_c
18592 && (last_die
->tag
== DW_TAG_class_type
18593 || last_die
->tag
== DW_TAG_interface_type
18594 || last_die
->tag
== DW_TAG_structure_type
18595 || last_die
->tag
== DW_TAG_union_type
))
18596 || (cu
->language
== language_ada
18597 && (last_die
->tag
== DW_TAG_subprogram
18598 || last_die
->tag
== DW_TAG_lexical_block
))))
18601 parent_die
= last_die
;
18605 /* Otherwise we skip to the next sibling, if any. */
18606 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
18608 /* Back to the top, do it again. */
18612 partial_die_info::partial_die_info (sect_offset sect_off_
,
18613 struct abbrev_info
*abbrev
)
18614 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
18618 /* Read a minimal amount of information into the minimal die structure.
18619 INFO_PTR should point just after the initial uleb128 of a DIE. */
18622 partial_die_info::read (const struct die_reader_specs
*reader
,
18623 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
18625 struct dwarf2_cu
*cu
= reader
->cu
;
18626 struct dwarf2_per_objfile
*dwarf2_per_objfile
18627 = cu
->per_cu
->dwarf2_per_objfile
;
18629 int has_low_pc_attr
= 0;
18630 int has_high_pc_attr
= 0;
18631 int high_pc_relative
= 0;
18633 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
18635 struct attribute attr
;
18637 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
18639 /* Store the data if it is of an attribute we want to keep in a
18640 partial symbol table. */
18646 case DW_TAG_compile_unit
:
18647 case DW_TAG_partial_unit
:
18648 case DW_TAG_type_unit
:
18649 /* Compilation units have a DW_AT_name that is a filename, not
18650 a source language identifier. */
18651 case DW_TAG_enumeration_type
:
18652 case DW_TAG_enumerator
:
18653 /* These tags always have simple identifiers already; no need
18654 to canonicalize them. */
18655 name
= DW_STRING (&attr
);
18659 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18662 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
18663 &objfile
->per_bfd
->storage_obstack
);
18668 case DW_AT_linkage_name
:
18669 case DW_AT_MIPS_linkage_name
:
18670 /* Note that both forms of linkage name might appear. We
18671 assume they will be the same, and we only store the last
18673 if (cu
->language
== language_ada
)
18674 name
= DW_STRING (&attr
);
18675 linkage_name
= DW_STRING (&attr
);
18678 has_low_pc_attr
= 1;
18679 lowpc
= attr_value_as_address (&attr
);
18681 case DW_AT_high_pc
:
18682 has_high_pc_attr
= 1;
18683 highpc
= attr_value_as_address (&attr
);
18684 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
18685 high_pc_relative
= 1;
18687 case DW_AT_location
:
18688 /* Support the .debug_loc offsets. */
18689 if (attr_form_is_block (&attr
))
18691 d
.locdesc
= DW_BLOCK (&attr
);
18693 else if (attr_form_is_section_offset (&attr
))
18695 dwarf2_complex_location_expr_complaint ();
18699 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18700 "partial symbol information");
18703 case DW_AT_external
:
18704 is_external
= DW_UNSND (&attr
);
18706 case DW_AT_declaration
:
18707 is_declaration
= DW_UNSND (&attr
);
18712 case DW_AT_abstract_origin
:
18713 case DW_AT_specification
:
18714 case DW_AT_extension
:
18715 has_specification
= 1;
18716 spec_offset
= dwarf2_get_ref_die_offset (&attr
);
18717 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
18718 || cu
->per_cu
->is_dwz
);
18720 case DW_AT_sibling
:
18721 /* Ignore absolute siblings, they might point outside of
18722 the current compile unit. */
18723 if (attr
.form
== DW_FORM_ref_addr
)
18724 complaint (_("ignoring absolute DW_AT_sibling"));
18727 const gdb_byte
*buffer
= reader
->buffer
;
18728 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
18729 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
18731 if (sibling_ptr
< info_ptr
)
18732 complaint (_("DW_AT_sibling points backwards"));
18733 else if (sibling_ptr
> reader
->buffer_end
)
18734 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
18736 sibling
= sibling_ptr
;
18739 case DW_AT_byte_size
:
18742 case DW_AT_const_value
:
18743 has_const_value
= 1;
18745 case DW_AT_calling_convention
:
18746 /* DWARF doesn't provide a way to identify a program's source-level
18747 entry point. DW_AT_calling_convention attributes are only meant
18748 to describe functions' calling conventions.
18750 However, because it's a necessary piece of information in
18751 Fortran, and before DWARF 4 DW_CC_program was the only
18752 piece of debugging information whose definition refers to
18753 a 'main program' at all, several compilers marked Fortran
18754 main programs with DW_CC_program --- even when those
18755 functions use the standard calling conventions.
18757 Although DWARF now specifies a way to provide this
18758 information, we support this practice for backward
18760 if (DW_UNSND (&attr
) == DW_CC_program
18761 && cu
->language
== language_fortran
)
18762 main_subprogram
= 1;
18765 if (DW_UNSND (&attr
) == DW_INL_inlined
18766 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
18767 may_be_inlined
= 1;
18771 if (tag
== DW_TAG_imported_unit
)
18773 d
.sect_off
= dwarf2_get_ref_die_offset (&attr
);
18774 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
18775 || cu
->per_cu
->is_dwz
);
18779 case DW_AT_main_subprogram
:
18780 main_subprogram
= DW_UNSND (&attr
);
18785 /* It would be nice to reuse dwarf2_get_pc_bounds here,
18786 but that requires a full DIE, so instead we just
18788 int need_ranges_base
= tag
!= DW_TAG_compile_unit
;
18789 unsigned int ranges_offset
= (DW_UNSND (&attr
)
18790 + (need_ranges_base
18794 /* Value of the DW_AT_ranges attribute is the offset in the
18795 .debug_ranges section. */
18796 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
18807 if (high_pc_relative
)
18810 if (has_low_pc_attr
&& has_high_pc_attr
)
18812 /* When using the GNU linker, .gnu.linkonce. sections are used to
18813 eliminate duplicate copies of functions and vtables and such.
18814 The linker will arbitrarily choose one and discard the others.
18815 The AT_*_pc values for such functions refer to local labels in
18816 these sections. If the section from that file was discarded, the
18817 labels are not in the output, so the relocs get a value of 0.
18818 If this is a discarded function, mark the pc bounds as invalid,
18819 so that GDB will ignore it. */
18820 if (lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
18822 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18823 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18825 complaint (_("DW_AT_low_pc %s is zero "
18826 "for DIE at %s [in module %s]"),
18827 paddress (gdbarch
, lowpc
),
18828 sect_offset_str (sect_off
),
18829 objfile_name (objfile
));
18831 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18832 else if (lowpc
>= highpc
)
18834 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18835 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18837 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18838 "for DIE at %s [in module %s]"),
18839 paddress (gdbarch
, lowpc
),
18840 paddress (gdbarch
, highpc
),
18841 sect_offset_str (sect_off
),
18842 objfile_name (objfile
));
18851 /* Find a cached partial DIE at OFFSET in CU. */
18853 struct partial_die_info
*
18854 dwarf2_cu::find_partial_die (sect_offset sect_off
)
18856 struct partial_die_info
*lookup_die
= NULL
;
18857 struct partial_die_info
part_die (sect_off
);
18859 lookup_die
= ((struct partial_die_info
*)
18860 htab_find_with_hash (partial_dies
, &part_die
,
18861 to_underlying (sect_off
)));
18866 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18867 except in the case of .debug_types DIEs which do not reference
18868 outside their CU (they do however referencing other types via
18869 DW_FORM_ref_sig8). */
18871 static const struct cu_partial_die_info
18872 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
18874 struct dwarf2_per_objfile
*dwarf2_per_objfile
18875 = cu
->per_cu
->dwarf2_per_objfile
;
18876 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18877 struct dwarf2_per_cu_data
*per_cu
= NULL
;
18878 struct partial_die_info
*pd
= NULL
;
18880 if (offset_in_dwz
== cu
->per_cu
->is_dwz
18881 && offset_in_cu_p (&cu
->header
, sect_off
))
18883 pd
= cu
->find_partial_die (sect_off
);
18886 /* We missed recording what we needed.
18887 Load all dies and try again. */
18888 per_cu
= cu
->per_cu
;
18892 /* TUs don't reference other CUs/TUs (except via type signatures). */
18893 if (cu
->per_cu
->is_debug_types
)
18895 error (_("Dwarf Error: Type Unit at offset %s contains"
18896 " external reference to offset %s [in module %s].\n"),
18897 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
18898 bfd_get_filename (objfile
->obfd
));
18900 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
18901 dwarf2_per_objfile
);
18903 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
18904 load_partial_comp_unit (per_cu
);
18906 per_cu
->cu
->last_used
= 0;
18907 pd
= per_cu
->cu
->find_partial_die (sect_off
);
18910 /* If we didn't find it, and not all dies have been loaded,
18911 load them all and try again. */
18913 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
18915 per_cu
->load_all_dies
= 1;
18917 /* This is nasty. When we reread the DIEs, somewhere up the call chain
18918 THIS_CU->cu may already be in use. So we can't just free it and
18919 replace its DIEs with the ones we read in. Instead, we leave those
18920 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18921 and clobber THIS_CU->cu->partial_dies with the hash table for the new
18923 load_partial_comp_unit (per_cu
);
18925 pd
= per_cu
->cu
->find_partial_die (sect_off
);
18929 internal_error (__FILE__
, __LINE__
,
18930 _("could not find partial DIE %s "
18931 "in cache [from module %s]\n"),
18932 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
18933 return { per_cu
->cu
, pd
};
18936 /* See if we can figure out if the class lives in a namespace. We do
18937 this by looking for a member function; its demangled name will
18938 contain namespace info, if there is any. */
18941 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
18942 struct dwarf2_cu
*cu
)
18944 /* NOTE: carlton/2003-10-07: Getting the info this way changes
18945 what template types look like, because the demangler
18946 frequently doesn't give the same name as the debug info. We
18947 could fix this by only using the demangled name to get the
18948 prefix (but see comment in read_structure_type). */
18950 struct partial_die_info
*real_pdi
;
18951 struct partial_die_info
*child_pdi
;
18953 /* If this DIE (this DIE's specification, if any) has a parent, then
18954 we should not do this. We'll prepend the parent's fully qualified
18955 name when we create the partial symbol. */
18957 real_pdi
= struct_pdi
;
18958 while (real_pdi
->has_specification
)
18960 auto res
= find_partial_die (real_pdi
->spec_offset
,
18961 real_pdi
->spec_is_dwz
, cu
);
18962 real_pdi
= res
.pdi
;
18966 if (real_pdi
->die_parent
!= NULL
)
18969 for (child_pdi
= struct_pdi
->die_child
;
18971 child_pdi
= child_pdi
->die_sibling
)
18973 if (child_pdi
->tag
== DW_TAG_subprogram
18974 && child_pdi
->linkage_name
!= NULL
)
18976 char *actual_class_name
18977 = language_class_name_from_physname (cu
->language_defn
,
18978 child_pdi
->linkage_name
);
18979 if (actual_class_name
!= NULL
)
18981 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
18984 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
18986 strlen (actual_class_name
)));
18987 xfree (actual_class_name
);
18995 partial_die_info::fixup (struct dwarf2_cu
*cu
)
18997 /* Once we've fixed up a die, there's no point in doing so again.
18998 This also avoids a memory leak if we were to call
18999 guess_partial_die_structure_name multiple times. */
19003 /* If we found a reference attribute and the DIE has no name, try
19004 to find a name in the referred to DIE. */
19006 if (name
== NULL
&& has_specification
)
19008 struct partial_die_info
*spec_die
;
19010 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19011 spec_die
= res
.pdi
;
19014 spec_die
->fixup (cu
);
19016 if (spec_die
->name
)
19018 name
= spec_die
->name
;
19020 /* Copy DW_AT_external attribute if it is set. */
19021 if (spec_die
->is_external
)
19022 is_external
= spec_die
->is_external
;
19026 /* Set default names for some unnamed DIEs. */
19028 if (name
== NULL
&& tag
== DW_TAG_namespace
)
19029 name
= CP_ANONYMOUS_NAMESPACE_STR
;
19031 /* If there is no parent die to provide a namespace, and there are
19032 children, see if we can determine the namespace from their linkage
19034 if (cu
->language
== language_cplus
19035 && !VEC_empty (dwarf2_section_info_def
,
19036 cu
->per_cu
->dwarf2_per_objfile
->types
)
19037 && die_parent
== NULL
19039 && (tag
== DW_TAG_class_type
19040 || tag
== DW_TAG_structure_type
19041 || tag
== DW_TAG_union_type
))
19042 guess_partial_die_structure_name (this, cu
);
19044 /* GCC might emit a nameless struct or union that has a linkage
19045 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19047 && (tag
== DW_TAG_class_type
19048 || tag
== DW_TAG_interface_type
19049 || tag
== DW_TAG_structure_type
19050 || tag
== DW_TAG_union_type
)
19051 && linkage_name
!= NULL
)
19055 demangled
= gdb_demangle (linkage_name
, DMGL_TYPES
);
19060 /* Strip any leading namespaces/classes, keep only the base name.
19061 DW_AT_name for named DIEs does not contain the prefixes. */
19062 base
= strrchr (demangled
, ':');
19063 if (base
&& base
> demangled
&& base
[-1] == ':')
19068 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
19071 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
19072 base
, strlen (base
)));
19080 /* Read an attribute value described by an attribute form. */
19082 static const gdb_byte
*
19083 read_attribute_value (const struct die_reader_specs
*reader
,
19084 struct attribute
*attr
, unsigned form
,
19085 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
19087 struct dwarf2_cu
*cu
= reader
->cu
;
19088 struct dwarf2_per_objfile
*dwarf2_per_objfile
19089 = cu
->per_cu
->dwarf2_per_objfile
;
19090 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19091 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
19092 bfd
*abfd
= reader
->abfd
;
19093 struct comp_unit_head
*cu_header
= &cu
->header
;
19094 unsigned int bytes_read
;
19095 struct dwarf_block
*blk
;
19097 attr
->form
= (enum dwarf_form
) form
;
19100 case DW_FORM_ref_addr
:
19101 if (cu
->header
.version
== 2)
19102 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
19104 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
19105 &cu
->header
, &bytes_read
);
19106 info_ptr
+= bytes_read
;
19108 case DW_FORM_GNU_ref_alt
:
19109 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
19110 info_ptr
+= bytes_read
;
19113 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
19114 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
19115 info_ptr
+= bytes_read
;
19117 case DW_FORM_block2
:
19118 blk
= dwarf_alloc_block (cu
);
19119 blk
->size
= read_2_bytes (abfd
, info_ptr
);
19121 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19122 info_ptr
+= blk
->size
;
19123 DW_BLOCK (attr
) = blk
;
19125 case DW_FORM_block4
:
19126 blk
= dwarf_alloc_block (cu
);
19127 blk
->size
= read_4_bytes (abfd
, info_ptr
);
19129 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19130 info_ptr
+= blk
->size
;
19131 DW_BLOCK (attr
) = blk
;
19133 case DW_FORM_data2
:
19134 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
19137 case DW_FORM_data4
:
19138 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
19141 case DW_FORM_data8
:
19142 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
19145 case DW_FORM_data16
:
19146 blk
= dwarf_alloc_block (cu
);
19148 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
19150 DW_BLOCK (attr
) = blk
;
19152 case DW_FORM_sec_offset
:
19153 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
19154 info_ptr
+= bytes_read
;
19156 case DW_FORM_string
:
19157 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
19158 DW_STRING_IS_CANONICAL (attr
) = 0;
19159 info_ptr
+= bytes_read
;
19162 if (!cu
->per_cu
->is_dwz
)
19164 DW_STRING (attr
) = read_indirect_string (dwarf2_per_objfile
,
19165 abfd
, info_ptr
, cu_header
,
19167 DW_STRING_IS_CANONICAL (attr
) = 0;
19168 info_ptr
+= bytes_read
;
19172 case DW_FORM_line_strp
:
19173 if (!cu
->per_cu
->is_dwz
)
19175 DW_STRING (attr
) = read_indirect_line_string (dwarf2_per_objfile
,
19177 cu_header
, &bytes_read
);
19178 DW_STRING_IS_CANONICAL (attr
) = 0;
19179 info_ptr
+= bytes_read
;
19183 case DW_FORM_GNU_strp_alt
:
19185 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
19186 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
19189 DW_STRING (attr
) = read_indirect_string_from_dwz (objfile
,
19191 DW_STRING_IS_CANONICAL (attr
) = 0;
19192 info_ptr
+= bytes_read
;
19195 case DW_FORM_exprloc
:
19196 case DW_FORM_block
:
19197 blk
= dwarf_alloc_block (cu
);
19198 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19199 info_ptr
+= bytes_read
;
19200 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19201 info_ptr
+= blk
->size
;
19202 DW_BLOCK (attr
) = blk
;
19204 case DW_FORM_block1
:
19205 blk
= dwarf_alloc_block (cu
);
19206 blk
->size
= read_1_byte (abfd
, info_ptr
);
19208 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19209 info_ptr
+= blk
->size
;
19210 DW_BLOCK (attr
) = blk
;
19212 case DW_FORM_data1
:
19213 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
19217 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
19220 case DW_FORM_flag_present
:
19221 DW_UNSND (attr
) = 1;
19223 case DW_FORM_sdata
:
19224 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19225 info_ptr
+= bytes_read
;
19227 case DW_FORM_udata
:
19228 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19229 info_ptr
+= bytes_read
;
19232 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19233 + read_1_byte (abfd
, info_ptr
));
19237 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19238 + read_2_bytes (abfd
, info_ptr
));
19242 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19243 + read_4_bytes (abfd
, info_ptr
));
19247 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19248 + read_8_bytes (abfd
, info_ptr
));
19251 case DW_FORM_ref_sig8
:
19252 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
19255 case DW_FORM_ref_udata
:
19256 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19257 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
19258 info_ptr
+= bytes_read
;
19260 case DW_FORM_indirect
:
19261 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19262 info_ptr
+= bytes_read
;
19263 if (form
== DW_FORM_implicit_const
)
19265 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19266 info_ptr
+= bytes_read
;
19268 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
19271 case DW_FORM_implicit_const
:
19272 DW_SND (attr
) = implicit_const
;
19274 case DW_FORM_addrx
:
19275 case DW_FORM_GNU_addr_index
:
19276 if (reader
->dwo_file
== NULL
)
19278 /* For now flag a hard error.
19279 Later we can turn this into a complaint. */
19280 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19281 dwarf_form_name (form
),
19282 bfd_get_filename (abfd
));
19284 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
19285 info_ptr
+= bytes_read
;
19288 case DW_FORM_strx1
:
19289 case DW_FORM_strx2
:
19290 case DW_FORM_strx3
:
19291 case DW_FORM_strx4
:
19292 case DW_FORM_GNU_str_index
:
19293 if (reader
->dwo_file
== NULL
)
19295 /* For now flag a hard error.
19296 Later we can turn this into a complaint if warranted. */
19297 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19298 dwarf_form_name (form
),
19299 bfd_get_filename (abfd
));
19302 ULONGEST str_index
;
19303 if (form
== DW_FORM_strx1
)
19305 str_index
= read_1_byte (abfd
, info_ptr
);
19308 else if (form
== DW_FORM_strx2
)
19310 str_index
= read_2_bytes (abfd
, info_ptr
);
19313 else if (form
== DW_FORM_strx3
)
19315 str_index
= read_3_bytes (abfd
, info_ptr
);
19318 else if (form
== DW_FORM_strx4
)
19320 str_index
= read_4_bytes (abfd
, info_ptr
);
19325 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19326 info_ptr
+= bytes_read
;
19328 DW_STRING (attr
) = read_str_index (reader
, str_index
);
19329 DW_STRING_IS_CANONICAL (attr
) = 0;
19333 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19334 dwarf_form_name (form
),
19335 bfd_get_filename (abfd
));
19339 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
19340 attr
->form
= DW_FORM_GNU_ref_alt
;
19342 /* We have seen instances where the compiler tried to emit a byte
19343 size attribute of -1 which ended up being encoded as an unsigned
19344 0xffffffff. Although 0xffffffff is technically a valid size value,
19345 an object of this size seems pretty unlikely so we can relatively
19346 safely treat these cases as if the size attribute was invalid and
19347 treat them as zero by default. */
19348 if (attr
->name
== DW_AT_byte_size
19349 && form
== DW_FORM_data4
19350 && DW_UNSND (attr
) >= 0xffffffff)
19353 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19354 hex_string (DW_UNSND (attr
)));
19355 DW_UNSND (attr
) = 0;
19361 /* Read an attribute described by an abbreviated attribute. */
19363 static const gdb_byte
*
19364 read_attribute (const struct die_reader_specs
*reader
,
19365 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
19366 const gdb_byte
*info_ptr
)
19368 attr
->name
= abbrev
->name
;
19369 return read_attribute_value (reader
, attr
, abbrev
->form
,
19370 abbrev
->implicit_const
, info_ptr
);
19373 /* Read dwarf information from a buffer. */
19375 static unsigned int
19376 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
19378 return bfd_get_8 (abfd
, buf
);
19382 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
19384 return bfd_get_signed_8 (abfd
, buf
);
19387 static unsigned int
19388 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19390 return bfd_get_16 (abfd
, buf
);
19394 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19396 return bfd_get_signed_16 (abfd
, buf
);
19399 static unsigned int
19400 read_3_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19402 unsigned int result
= 0;
19403 for (int i
= 0; i
< 3; ++i
)
19405 unsigned char byte
= bfd_get_8 (abfd
, buf
);
19407 result
|= ((unsigned int) byte
<< (i
* 8));
19412 static unsigned int
19413 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19415 return bfd_get_32 (abfd
, buf
);
19419 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19421 return bfd_get_signed_32 (abfd
, buf
);
19425 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19427 return bfd_get_64 (abfd
, buf
);
19431 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
19432 unsigned int *bytes_read
)
19434 struct comp_unit_head
*cu_header
= &cu
->header
;
19435 CORE_ADDR retval
= 0;
19437 if (cu_header
->signed_addr_p
)
19439 switch (cu_header
->addr_size
)
19442 retval
= bfd_get_signed_16 (abfd
, buf
);
19445 retval
= bfd_get_signed_32 (abfd
, buf
);
19448 retval
= bfd_get_signed_64 (abfd
, buf
);
19451 internal_error (__FILE__
, __LINE__
,
19452 _("read_address: bad switch, signed [in module %s]"),
19453 bfd_get_filename (abfd
));
19458 switch (cu_header
->addr_size
)
19461 retval
= bfd_get_16 (abfd
, buf
);
19464 retval
= bfd_get_32 (abfd
, buf
);
19467 retval
= bfd_get_64 (abfd
, buf
);
19470 internal_error (__FILE__
, __LINE__
,
19471 _("read_address: bad switch, "
19472 "unsigned [in module %s]"),
19473 bfd_get_filename (abfd
));
19477 *bytes_read
= cu_header
->addr_size
;
19481 /* Read the initial length from a section. The (draft) DWARF 3
19482 specification allows the initial length to take up either 4 bytes
19483 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19484 bytes describe the length and all offsets will be 8 bytes in length
19487 An older, non-standard 64-bit format is also handled by this
19488 function. The older format in question stores the initial length
19489 as an 8-byte quantity without an escape value. Lengths greater
19490 than 2^32 aren't very common which means that the initial 4 bytes
19491 is almost always zero. Since a length value of zero doesn't make
19492 sense for the 32-bit format, this initial zero can be considered to
19493 be an escape value which indicates the presence of the older 64-bit
19494 format. As written, the code can't detect (old format) lengths
19495 greater than 4GB. If it becomes necessary to handle lengths
19496 somewhat larger than 4GB, we could allow other small values (such
19497 as the non-sensical values of 1, 2, and 3) to also be used as
19498 escape values indicating the presence of the old format.
19500 The value returned via bytes_read should be used to increment the
19501 relevant pointer after calling read_initial_length().
19503 [ Note: read_initial_length() and read_offset() are based on the
19504 document entitled "DWARF Debugging Information Format", revision
19505 3, draft 8, dated November 19, 2001. This document was obtained
19508 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19510 This document is only a draft and is subject to change. (So beware.)
19512 Details regarding the older, non-standard 64-bit format were
19513 determined empirically by examining 64-bit ELF files produced by
19514 the SGI toolchain on an IRIX 6.5 machine.
19516 - Kevin, July 16, 2002
19520 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
19522 LONGEST length
= bfd_get_32 (abfd
, buf
);
19524 if (length
== 0xffffffff)
19526 length
= bfd_get_64 (abfd
, buf
+ 4);
19529 else if (length
== 0)
19531 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19532 length
= bfd_get_64 (abfd
, buf
);
19543 /* Cover function for read_initial_length.
19544 Returns the length of the object at BUF, and stores the size of the
19545 initial length in *BYTES_READ and stores the size that offsets will be in
19547 If the initial length size is not equivalent to that specified in
19548 CU_HEADER then issue a complaint.
19549 This is useful when reading non-comp-unit headers. */
19552 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
19553 const struct comp_unit_head
*cu_header
,
19554 unsigned int *bytes_read
,
19555 unsigned int *offset_size
)
19557 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
19559 gdb_assert (cu_header
->initial_length_size
== 4
19560 || cu_header
->initial_length_size
== 8
19561 || cu_header
->initial_length_size
== 12);
19563 if (cu_header
->initial_length_size
!= *bytes_read
)
19564 complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19566 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
19570 /* Read an offset from the data stream. The size of the offset is
19571 given by cu_header->offset_size. */
19574 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
19575 const struct comp_unit_head
*cu_header
,
19576 unsigned int *bytes_read
)
19578 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
19580 *bytes_read
= cu_header
->offset_size
;
19584 /* Read an offset from the data stream. */
19587 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
19589 LONGEST retval
= 0;
19591 switch (offset_size
)
19594 retval
= bfd_get_32 (abfd
, buf
);
19597 retval
= bfd_get_64 (abfd
, buf
);
19600 internal_error (__FILE__
, __LINE__
,
19601 _("read_offset_1: bad switch [in module %s]"),
19602 bfd_get_filename (abfd
));
19608 static const gdb_byte
*
19609 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
19611 /* If the size of a host char is 8 bits, we can return a pointer
19612 to the buffer, otherwise we have to copy the data to a buffer
19613 allocated on the temporary obstack. */
19614 gdb_assert (HOST_CHAR_BIT
== 8);
19618 static const char *
19619 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
19620 unsigned int *bytes_read_ptr
)
19622 /* If the size of a host char is 8 bits, we can return a pointer
19623 to the string, otherwise we have to copy the string to a buffer
19624 allocated on the temporary obstack. */
19625 gdb_assert (HOST_CHAR_BIT
== 8);
19628 *bytes_read_ptr
= 1;
19631 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
19632 return (const char *) buf
;
19635 /* Return pointer to string at section SECT offset STR_OFFSET with error
19636 reporting strings FORM_NAME and SECT_NAME. */
19638 static const char *
19639 read_indirect_string_at_offset_from (struct objfile
*objfile
,
19640 bfd
*abfd
, LONGEST str_offset
,
19641 struct dwarf2_section_info
*sect
,
19642 const char *form_name
,
19643 const char *sect_name
)
19645 dwarf2_read_section (objfile
, sect
);
19646 if (sect
->buffer
== NULL
)
19647 error (_("%s used without %s section [in module %s]"),
19648 form_name
, sect_name
, bfd_get_filename (abfd
));
19649 if (str_offset
>= sect
->size
)
19650 error (_("%s pointing outside of %s section [in module %s]"),
19651 form_name
, sect_name
, bfd_get_filename (abfd
));
19652 gdb_assert (HOST_CHAR_BIT
== 8);
19653 if (sect
->buffer
[str_offset
] == '\0')
19655 return (const char *) (sect
->buffer
+ str_offset
);
19658 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19660 static const char *
19661 read_indirect_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19662 bfd
*abfd
, LONGEST str_offset
)
19664 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
19666 &dwarf2_per_objfile
->str
,
19667 "DW_FORM_strp", ".debug_str");
19670 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
19672 static const char *
19673 read_indirect_line_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19674 bfd
*abfd
, LONGEST str_offset
)
19676 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
19678 &dwarf2_per_objfile
->line_str
,
19679 "DW_FORM_line_strp",
19680 ".debug_line_str");
19683 /* Read a string at offset STR_OFFSET in the .debug_str section from
19684 the .dwz file DWZ. Throw an error if the offset is too large. If
19685 the string consists of a single NUL byte, return NULL; otherwise
19686 return a pointer to the string. */
19688 static const char *
19689 read_indirect_string_from_dwz (struct objfile
*objfile
, struct dwz_file
*dwz
,
19690 LONGEST str_offset
)
19692 dwarf2_read_section (objfile
, &dwz
->str
);
19694 if (dwz
->str
.buffer
== NULL
)
19695 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19696 "section [in module %s]"),
19697 bfd_get_filename (dwz
->dwz_bfd
));
19698 if (str_offset
>= dwz
->str
.size
)
19699 error (_("DW_FORM_GNU_strp_alt pointing outside of "
19700 ".debug_str section [in module %s]"),
19701 bfd_get_filename (dwz
->dwz_bfd
));
19702 gdb_assert (HOST_CHAR_BIT
== 8);
19703 if (dwz
->str
.buffer
[str_offset
] == '\0')
19705 return (const char *) (dwz
->str
.buffer
+ str_offset
);
19708 /* Return pointer to string at .debug_str offset as read from BUF.
19709 BUF is assumed to be in a compilation unit described by CU_HEADER.
19710 Return *BYTES_READ_PTR count of bytes read from BUF. */
19712 static const char *
19713 read_indirect_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
19714 const gdb_byte
*buf
,
19715 const struct comp_unit_head
*cu_header
,
19716 unsigned int *bytes_read_ptr
)
19718 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
19720 return read_indirect_string_at_offset (dwarf2_per_objfile
, abfd
, str_offset
);
19723 /* Return pointer to string at .debug_line_str offset as read from BUF.
19724 BUF is assumed to be in a compilation unit described by CU_HEADER.
19725 Return *BYTES_READ_PTR count of bytes read from BUF. */
19727 static const char *
19728 read_indirect_line_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19729 bfd
*abfd
, const gdb_byte
*buf
,
19730 const struct comp_unit_head
*cu_header
,
19731 unsigned int *bytes_read_ptr
)
19733 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
19735 return read_indirect_line_string_at_offset (dwarf2_per_objfile
, abfd
,
19740 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
19741 unsigned int *bytes_read_ptr
)
19744 unsigned int num_read
;
19746 unsigned char byte
;
19753 byte
= bfd_get_8 (abfd
, buf
);
19756 result
|= ((ULONGEST
) (byte
& 127) << shift
);
19757 if ((byte
& 128) == 0)
19763 *bytes_read_ptr
= num_read
;
19768 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
19769 unsigned int *bytes_read_ptr
)
19772 int shift
, num_read
;
19773 unsigned char byte
;
19780 byte
= bfd_get_8 (abfd
, buf
);
19783 result
|= ((ULONGEST
) (byte
& 127) << shift
);
19785 if ((byte
& 128) == 0)
19790 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
19791 result
|= -(((ULONGEST
) 1) << shift
);
19792 *bytes_read_ptr
= num_read
;
19796 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19797 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19798 ADDR_SIZE is the size of addresses from the CU header. */
19801 read_addr_index_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19802 unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
19804 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19805 bfd
*abfd
= objfile
->obfd
;
19806 const gdb_byte
*info_ptr
;
19808 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
19809 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
19810 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19811 objfile_name (objfile
));
19812 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
19813 error (_("DW_FORM_addr_index pointing outside of "
19814 ".debug_addr section [in module %s]"),
19815 objfile_name (objfile
));
19816 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
19817 + addr_base
+ addr_index
* addr_size
);
19818 if (addr_size
== 4)
19819 return bfd_get_32 (abfd
, info_ptr
);
19821 return bfd_get_64 (abfd
, info_ptr
);
19824 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
19827 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
19829 return read_addr_index_1 (cu
->per_cu
->dwarf2_per_objfile
, addr_index
,
19830 cu
->addr_base
, cu
->header
.addr_size
);
19833 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
19836 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
19837 unsigned int *bytes_read
)
19839 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
19840 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
19842 return read_addr_index (cu
, addr_index
);
19845 /* Data structure to pass results from dwarf2_read_addr_index_reader
19846 back to dwarf2_read_addr_index. */
19848 struct dwarf2_read_addr_index_data
19850 ULONGEST addr_base
;
19854 /* die_reader_func for dwarf2_read_addr_index. */
19857 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
19858 const gdb_byte
*info_ptr
,
19859 struct die_info
*comp_unit_die
,
19863 struct dwarf2_cu
*cu
= reader
->cu
;
19864 struct dwarf2_read_addr_index_data
*aidata
=
19865 (struct dwarf2_read_addr_index_data
*) data
;
19867 aidata
->addr_base
= cu
->addr_base
;
19868 aidata
->addr_size
= cu
->header
.addr_size
;
19871 /* Given an index in .debug_addr, fetch the value.
19872 NOTE: This can be called during dwarf expression evaluation,
19873 long after the debug information has been read, and thus per_cu->cu
19874 may no longer exist. */
19877 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
19878 unsigned int addr_index
)
19880 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
19881 struct dwarf2_cu
*cu
= per_cu
->cu
;
19882 ULONGEST addr_base
;
19885 /* We need addr_base and addr_size.
19886 If we don't have PER_CU->cu, we have to get it.
19887 Nasty, but the alternative is storing the needed info in PER_CU,
19888 which at this point doesn't seem justified: it's not clear how frequently
19889 it would get used and it would increase the size of every PER_CU.
19890 Entry points like dwarf2_per_cu_addr_size do a similar thing
19891 so we're not in uncharted territory here.
19892 Alas we need to be a bit more complicated as addr_base is contained
19895 We don't need to read the entire CU(/TU).
19896 We just need the header and top level die.
19898 IWBN to use the aging mechanism to let us lazily later discard the CU.
19899 For now we skip this optimization. */
19903 addr_base
= cu
->addr_base
;
19904 addr_size
= cu
->header
.addr_size
;
19908 struct dwarf2_read_addr_index_data aidata
;
19910 /* Note: We can't use init_cutu_and_read_dies_simple here,
19911 we need addr_base. */
19912 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0, false,
19913 dwarf2_read_addr_index_reader
, &aidata
);
19914 addr_base
= aidata
.addr_base
;
19915 addr_size
= aidata
.addr_size
;
19918 return read_addr_index_1 (dwarf2_per_objfile
, addr_index
, addr_base
,
19922 /* Given a DW_FORM_GNU_str_index or DW_FORM_strx, fetch the string.
19923 This is only used by the Fission support. */
19925 static const char *
19926 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
19928 struct dwarf2_cu
*cu
= reader
->cu
;
19929 struct dwarf2_per_objfile
*dwarf2_per_objfile
19930 = cu
->per_cu
->dwarf2_per_objfile
;
19931 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19932 const char *objf_name
= objfile_name (objfile
);
19933 bfd
*abfd
= objfile
->obfd
;
19934 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
19935 struct dwarf2_section_info
*str_offsets_section
=
19936 &reader
->dwo_file
->sections
.str_offsets
;
19937 const gdb_byte
*info_ptr
;
19938 ULONGEST str_offset
;
19939 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
19941 dwarf2_read_section (objfile
, str_section
);
19942 dwarf2_read_section (objfile
, str_offsets_section
);
19943 if (str_section
->buffer
== NULL
)
19944 error (_("%s used without .debug_str.dwo section"
19945 " in CU at offset %s [in module %s]"),
19946 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
19947 if (str_offsets_section
->buffer
== NULL
)
19948 error (_("%s used without .debug_str_offsets.dwo section"
19949 " in CU at offset %s [in module %s]"),
19950 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
19951 if (str_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
19952 error (_("%s pointing outside of .debug_str_offsets.dwo"
19953 " section in CU at offset %s [in module %s]"),
19954 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
19955 info_ptr
= (str_offsets_section
->buffer
19956 + str_index
* cu
->header
.offset_size
);
19957 if (cu
->header
.offset_size
== 4)
19958 str_offset
= bfd_get_32 (abfd
, info_ptr
);
19960 str_offset
= bfd_get_64 (abfd
, info_ptr
);
19961 if (str_offset
>= str_section
->size
)
19962 error (_("Offset from %s pointing outside of"
19963 " .debug_str.dwo section in CU at offset %s [in module %s]"),
19964 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
19965 return (const char *) (str_section
->buffer
+ str_offset
);
19968 /* Return the length of an LEB128 number in BUF. */
19971 leb128_size (const gdb_byte
*buf
)
19973 const gdb_byte
*begin
= buf
;
19979 if ((byte
& 128) == 0)
19980 return buf
- begin
;
19985 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
19994 cu
->language
= language_c
;
19997 case DW_LANG_C_plus_plus
:
19998 case DW_LANG_C_plus_plus_11
:
19999 case DW_LANG_C_plus_plus_14
:
20000 cu
->language
= language_cplus
;
20003 cu
->language
= language_d
;
20005 case DW_LANG_Fortran77
:
20006 case DW_LANG_Fortran90
:
20007 case DW_LANG_Fortran95
:
20008 case DW_LANG_Fortran03
:
20009 case DW_LANG_Fortran08
:
20010 cu
->language
= language_fortran
;
20013 cu
->language
= language_go
;
20015 case DW_LANG_Mips_Assembler
:
20016 cu
->language
= language_asm
;
20018 case DW_LANG_Ada83
:
20019 case DW_LANG_Ada95
:
20020 cu
->language
= language_ada
;
20022 case DW_LANG_Modula2
:
20023 cu
->language
= language_m2
;
20025 case DW_LANG_Pascal83
:
20026 cu
->language
= language_pascal
;
20029 cu
->language
= language_objc
;
20032 case DW_LANG_Rust_old
:
20033 cu
->language
= language_rust
;
20035 case DW_LANG_Cobol74
:
20036 case DW_LANG_Cobol85
:
20038 cu
->language
= language_minimal
;
20041 cu
->language_defn
= language_def (cu
->language
);
20044 /* Return the named attribute or NULL if not there. */
20046 static struct attribute
*
20047 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20052 struct attribute
*spec
= NULL
;
20054 for (i
= 0; i
< die
->num_attrs
; ++i
)
20056 if (die
->attrs
[i
].name
== name
)
20057 return &die
->attrs
[i
];
20058 if (die
->attrs
[i
].name
== DW_AT_specification
20059 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
20060 spec
= &die
->attrs
[i
];
20066 die
= follow_die_ref (die
, spec
, &cu
);
20072 /* Return the named attribute or NULL if not there,
20073 but do not follow DW_AT_specification, etc.
20074 This is for use in contexts where we're reading .debug_types dies.
20075 Following DW_AT_specification, DW_AT_abstract_origin will take us
20076 back up the chain, and we want to go down. */
20078 static struct attribute
*
20079 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
20083 for (i
= 0; i
< die
->num_attrs
; ++i
)
20084 if (die
->attrs
[i
].name
== name
)
20085 return &die
->attrs
[i
];
20090 /* Return the string associated with a string-typed attribute, or NULL if it
20091 is either not found or is of an incorrect type. */
20093 static const char *
20094 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20096 struct attribute
*attr
;
20097 const char *str
= NULL
;
20099 attr
= dwarf2_attr (die
, name
, cu
);
20103 if (attr
->form
== DW_FORM_strp
|| attr
->form
== DW_FORM_line_strp
20104 || attr
->form
== DW_FORM_string
20105 || attr
->form
== DW_FORM_strx
20106 || attr
->form
== DW_FORM_GNU_str_index
20107 || attr
->form
== DW_FORM_GNU_strp_alt
)
20108 str
= DW_STRING (attr
);
20110 complaint (_("string type expected for attribute %s for "
20111 "DIE at %s in module %s"),
20112 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
20113 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
20119 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20120 and holds a non-zero value. This function should only be used for
20121 DW_FORM_flag or DW_FORM_flag_present attributes. */
20124 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
20126 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
20128 return (attr
&& DW_UNSND (attr
));
20132 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
20134 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20135 which value is non-zero. However, we have to be careful with
20136 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20137 (via dwarf2_flag_true_p) follows this attribute. So we may
20138 end up accidently finding a declaration attribute that belongs
20139 to a different DIE referenced by the specification attribute,
20140 even though the given DIE does not have a declaration attribute. */
20141 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
20142 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
20145 /* Return the die giving the specification for DIE, if there is
20146 one. *SPEC_CU is the CU containing DIE on input, and the CU
20147 containing the return value on output. If there is no
20148 specification, but there is an abstract origin, that is
20151 static struct die_info
*
20152 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
20154 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
20157 if (spec_attr
== NULL
)
20158 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
20160 if (spec_attr
== NULL
)
20163 return follow_die_ref (die
, spec_attr
, spec_cu
);
20166 /* Stub for free_line_header to match void * callback types. */
20169 free_line_header_voidp (void *arg
)
20171 struct line_header
*lh
= (struct line_header
*) arg
;
20177 line_header::add_include_dir (const char *include_dir
)
20179 if (dwarf_line_debug
>= 2)
20180 fprintf_unfiltered (gdb_stdlog
, "Adding dir %zu: %s\n",
20181 include_dirs
.size () + 1, include_dir
);
20183 include_dirs
.push_back (include_dir
);
20187 line_header::add_file_name (const char *name
,
20189 unsigned int mod_time
,
20190 unsigned int length
)
20192 if (dwarf_line_debug
>= 2)
20193 fprintf_unfiltered (gdb_stdlog
, "Adding file %u: %s\n",
20194 (unsigned) file_names
.size () + 1, name
);
20196 file_names
.emplace_back (name
, d_index
, mod_time
, length
);
20199 /* A convenience function to find the proper .debug_line section for a CU. */
20201 static struct dwarf2_section_info
*
20202 get_debug_line_section (struct dwarf2_cu
*cu
)
20204 struct dwarf2_section_info
*section
;
20205 struct dwarf2_per_objfile
*dwarf2_per_objfile
20206 = cu
->per_cu
->dwarf2_per_objfile
;
20208 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20210 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20211 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
20212 else if (cu
->per_cu
->is_dwz
)
20214 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
20216 section
= &dwz
->line
;
20219 section
= &dwarf2_per_objfile
->line
;
20224 /* Read directory or file name entry format, starting with byte of
20225 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20226 entries count and the entries themselves in the described entry
20230 read_formatted_entries (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
20231 bfd
*abfd
, const gdb_byte
**bufp
,
20232 struct line_header
*lh
,
20233 const struct comp_unit_head
*cu_header
,
20234 void (*callback
) (struct line_header
*lh
,
20237 unsigned int mod_time
,
20238 unsigned int length
))
20240 gdb_byte format_count
, formati
;
20241 ULONGEST data_count
, datai
;
20242 const gdb_byte
*buf
= *bufp
;
20243 const gdb_byte
*format_header_data
;
20244 unsigned int bytes_read
;
20246 format_count
= read_1_byte (abfd
, buf
);
20248 format_header_data
= buf
;
20249 for (formati
= 0; formati
< format_count
; formati
++)
20251 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20253 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20257 data_count
= read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20259 for (datai
= 0; datai
< data_count
; datai
++)
20261 const gdb_byte
*format
= format_header_data
;
20262 struct file_entry fe
;
20264 for (formati
= 0; formati
< format_count
; formati
++)
20266 ULONGEST content_type
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
20267 format
+= bytes_read
;
20269 ULONGEST form
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
20270 format
+= bytes_read
;
20272 gdb::optional
<const char *> string
;
20273 gdb::optional
<unsigned int> uint
;
20277 case DW_FORM_string
:
20278 string
.emplace (read_direct_string (abfd
, buf
, &bytes_read
));
20282 case DW_FORM_line_strp
:
20283 string
.emplace (read_indirect_line_string (dwarf2_per_objfile
,
20290 case DW_FORM_data1
:
20291 uint
.emplace (read_1_byte (abfd
, buf
));
20295 case DW_FORM_data2
:
20296 uint
.emplace (read_2_bytes (abfd
, buf
));
20300 case DW_FORM_data4
:
20301 uint
.emplace (read_4_bytes (abfd
, buf
));
20305 case DW_FORM_data8
:
20306 uint
.emplace (read_8_bytes (abfd
, buf
));
20310 case DW_FORM_udata
:
20311 uint
.emplace (read_unsigned_leb128 (abfd
, buf
, &bytes_read
));
20315 case DW_FORM_block
:
20316 /* It is valid only for DW_LNCT_timestamp which is ignored by
20321 switch (content_type
)
20324 if (string
.has_value ())
20327 case DW_LNCT_directory_index
:
20328 if (uint
.has_value ())
20329 fe
.d_index
= (dir_index
) *uint
;
20331 case DW_LNCT_timestamp
:
20332 if (uint
.has_value ())
20333 fe
.mod_time
= *uint
;
20336 if (uint
.has_value ())
20342 complaint (_("Unknown format content type %s"),
20343 pulongest (content_type
));
20347 callback (lh
, fe
.name
, fe
.d_index
, fe
.mod_time
, fe
.length
);
20353 /* Read the statement program header starting at OFFSET in
20354 .debug_line, or .debug_line.dwo. Return a pointer
20355 to a struct line_header, allocated using xmalloc.
20356 Returns NULL if there is a problem reading the header, e.g., if it
20357 has a version we don't understand.
20359 NOTE: the strings in the include directory and file name tables of
20360 the returned object point into the dwarf line section buffer,
20361 and must not be freed. */
20363 static line_header_up
20364 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
20366 const gdb_byte
*line_ptr
;
20367 unsigned int bytes_read
, offset_size
;
20369 const char *cur_dir
, *cur_file
;
20370 struct dwarf2_section_info
*section
;
20372 struct dwarf2_per_objfile
*dwarf2_per_objfile
20373 = cu
->per_cu
->dwarf2_per_objfile
;
20375 section
= get_debug_line_section (cu
);
20376 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
20377 if (section
->buffer
== NULL
)
20379 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20380 complaint (_("missing .debug_line.dwo section"));
20382 complaint (_("missing .debug_line section"));
20386 /* We can't do this until we know the section is non-empty.
20387 Only then do we know we have such a section. */
20388 abfd
= get_section_bfd_owner (section
);
20390 /* Make sure that at least there's room for the total_length field.
20391 That could be 12 bytes long, but we're just going to fudge that. */
20392 if (to_underlying (sect_off
) + 4 >= section
->size
)
20394 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20398 line_header_up
lh (new line_header ());
20400 lh
->sect_off
= sect_off
;
20401 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
20403 line_ptr
= section
->buffer
+ to_underlying (sect_off
);
20405 /* Read in the header. */
20407 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
20408 &bytes_read
, &offset_size
);
20409 line_ptr
+= bytes_read
;
20410 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
20412 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20415 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
20416 lh
->version
= read_2_bytes (abfd
, line_ptr
);
20418 if (lh
->version
> 5)
20420 /* This is a version we don't understand. The format could have
20421 changed in ways we don't handle properly so just punt. */
20422 complaint (_("unsupported version in .debug_line section"));
20425 if (lh
->version
>= 5)
20427 gdb_byte segment_selector_size
;
20429 /* Skip address size. */
20430 read_1_byte (abfd
, line_ptr
);
20433 segment_selector_size
= read_1_byte (abfd
, line_ptr
);
20435 if (segment_selector_size
!= 0)
20437 complaint (_("unsupported segment selector size %u "
20438 "in .debug_line section"),
20439 segment_selector_size
);
20443 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
20444 line_ptr
+= offset_size
;
20445 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
20447 if (lh
->version
>= 4)
20449 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
20453 lh
->maximum_ops_per_instruction
= 1;
20455 if (lh
->maximum_ops_per_instruction
== 0)
20457 lh
->maximum_ops_per_instruction
= 1;
20458 complaint (_("invalid maximum_ops_per_instruction "
20459 "in `.debug_line' section"));
20462 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
20464 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
20466 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
20468 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
20470 lh
->standard_opcode_lengths
.reset (new unsigned char[lh
->opcode_base
]);
20472 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
20473 for (i
= 1; i
< lh
->opcode_base
; ++i
)
20475 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
20479 if (lh
->version
>= 5)
20481 /* Read directory table. */
20482 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
20484 [] (struct line_header
*header
, const char *name
,
20485 dir_index d_index
, unsigned int mod_time
,
20486 unsigned int length
)
20488 header
->add_include_dir (name
);
20491 /* Read file name table. */
20492 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
20494 [] (struct line_header
*header
, const char *name
,
20495 dir_index d_index
, unsigned int mod_time
,
20496 unsigned int length
)
20498 header
->add_file_name (name
, d_index
, mod_time
, length
);
20503 /* Read directory table. */
20504 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
20506 line_ptr
+= bytes_read
;
20507 lh
->add_include_dir (cur_dir
);
20509 line_ptr
+= bytes_read
;
20511 /* Read file name table. */
20512 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
20514 unsigned int mod_time
, length
;
20517 line_ptr
+= bytes_read
;
20518 d_index
= (dir_index
) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20519 line_ptr
+= bytes_read
;
20520 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20521 line_ptr
+= bytes_read
;
20522 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20523 line_ptr
+= bytes_read
;
20525 lh
->add_file_name (cur_file
, d_index
, mod_time
, length
);
20527 line_ptr
+= bytes_read
;
20529 lh
->statement_program_start
= line_ptr
;
20531 if (line_ptr
> (section
->buffer
+ section
->size
))
20532 complaint (_("line number info header doesn't "
20533 "fit in `.debug_line' section"));
20538 /* Subroutine of dwarf_decode_lines to simplify it.
20539 Return the file name of the psymtab for included file FILE_INDEX
20540 in line header LH of PST.
20541 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20542 If space for the result is malloc'd, *NAME_HOLDER will be set.
20543 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20545 static const char *
20546 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
20547 const struct partial_symtab
*pst
,
20548 const char *comp_dir
,
20549 gdb::unique_xmalloc_ptr
<char> *name_holder
)
20551 const file_entry
&fe
= lh
->file_names
[file_index
];
20552 const char *include_name
= fe
.name
;
20553 const char *include_name_to_compare
= include_name
;
20554 const char *pst_filename
;
20557 const char *dir_name
= fe
.include_dir (lh
);
20559 gdb::unique_xmalloc_ptr
<char> hold_compare
;
20560 if (!IS_ABSOLUTE_PATH (include_name
)
20561 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
20563 /* Avoid creating a duplicate psymtab for PST.
20564 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20565 Before we do the comparison, however, we need to account
20566 for DIR_NAME and COMP_DIR.
20567 First prepend dir_name (if non-NULL). If we still don't
20568 have an absolute path prepend comp_dir (if non-NULL).
20569 However, the directory we record in the include-file's
20570 psymtab does not contain COMP_DIR (to match the
20571 corresponding symtab(s)).
20576 bash$ gcc -g ./hello.c
20577 include_name = "hello.c"
20579 DW_AT_comp_dir = comp_dir = "/tmp"
20580 DW_AT_name = "./hello.c"
20584 if (dir_name
!= NULL
)
20586 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
20587 include_name
, (char *) NULL
));
20588 include_name
= name_holder
->get ();
20589 include_name_to_compare
= include_name
;
20591 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
20593 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
20594 include_name
, (char *) NULL
));
20595 include_name_to_compare
= hold_compare
.get ();
20599 pst_filename
= pst
->filename
;
20600 gdb::unique_xmalloc_ptr
<char> copied_name
;
20601 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
20603 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
20604 pst_filename
, (char *) NULL
));
20605 pst_filename
= copied_name
.get ();
20608 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
20612 return include_name
;
20615 /* State machine to track the state of the line number program. */
20617 class lnp_state_machine
20620 /* Initialize a machine state for the start of a line number
20622 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
20623 bool record_lines_p
);
20625 file_entry
*current_file ()
20627 /* lh->file_names is 0-based, but the file name numbers in the
20628 statement program are 1-based. */
20629 return m_line_header
->file_name_at (m_file
);
20632 /* Record the line in the state machine. END_SEQUENCE is true if
20633 we're processing the end of a sequence. */
20634 void record_line (bool end_sequence
);
20636 /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20637 nop-out rest of the lines in this sequence. */
20638 void check_line_address (struct dwarf2_cu
*cu
,
20639 const gdb_byte
*line_ptr
,
20640 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
20642 void handle_set_discriminator (unsigned int discriminator
)
20644 m_discriminator
= discriminator
;
20645 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
20648 /* Handle DW_LNE_set_address. */
20649 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
20652 address
+= baseaddr
;
20653 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
20656 /* Handle DW_LNS_advance_pc. */
20657 void handle_advance_pc (CORE_ADDR adjust
);
20659 /* Handle a special opcode. */
20660 void handle_special_opcode (unsigned char op_code
);
20662 /* Handle DW_LNS_advance_line. */
20663 void handle_advance_line (int line_delta
)
20665 advance_line (line_delta
);
20668 /* Handle DW_LNS_set_file. */
20669 void handle_set_file (file_name_index file
);
20671 /* Handle DW_LNS_negate_stmt. */
20672 void handle_negate_stmt ()
20674 m_is_stmt
= !m_is_stmt
;
20677 /* Handle DW_LNS_const_add_pc. */
20678 void handle_const_add_pc ();
20680 /* Handle DW_LNS_fixed_advance_pc. */
20681 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
20683 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20687 /* Handle DW_LNS_copy. */
20688 void handle_copy ()
20690 record_line (false);
20691 m_discriminator
= 0;
20694 /* Handle DW_LNE_end_sequence. */
20695 void handle_end_sequence ()
20697 m_currently_recording_lines
= true;
20701 /* Advance the line by LINE_DELTA. */
20702 void advance_line (int line_delta
)
20704 m_line
+= line_delta
;
20706 if (line_delta
!= 0)
20707 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20710 struct dwarf2_cu
*m_cu
;
20712 gdbarch
*m_gdbarch
;
20714 /* True if we're recording lines.
20715 Otherwise we're building partial symtabs and are just interested in
20716 finding include files mentioned by the line number program. */
20717 bool m_record_lines_p
;
20719 /* The line number header. */
20720 line_header
*m_line_header
;
20722 /* These are part of the standard DWARF line number state machine,
20723 and initialized according to the DWARF spec. */
20725 unsigned char m_op_index
= 0;
20726 /* The line table index (1-based) of the current file. */
20727 file_name_index m_file
= (file_name_index
) 1;
20728 unsigned int m_line
= 1;
20730 /* These are initialized in the constructor. */
20732 CORE_ADDR m_address
;
20734 unsigned int m_discriminator
;
20736 /* Additional bits of state we need to track. */
20738 /* The last file that we called dwarf2_start_subfile for.
20739 This is only used for TLLs. */
20740 unsigned int m_last_file
= 0;
20741 /* The last file a line number was recorded for. */
20742 struct subfile
*m_last_subfile
= NULL
;
20744 /* When true, record the lines we decode. */
20745 bool m_currently_recording_lines
= false;
20747 /* The last line number that was recorded, used to coalesce
20748 consecutive entries for the same line. This can happen, for
20749 example, when discriminators are present. PR 17276. */
20750 unsigned int m_last_line
= 0;
20751 bool m_line_has_non_zero_discriminator
= false;
20755 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
20757 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
20758 / m_line_header
->maximum_ops_per_instruction
)
20759 * m_line_header
->minimum_instruction_length
);
20760 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20761 m_op_index
= ((m_op_index
+ adjust
)
20762 % m_line_header
->maximum_ops_per_instruction
);
20766 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
20768 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
20769 CORE_ADDR addr_adj
= (((m_op_index
20770 + (adj_opcode
/ m_line_header
->line_range
))
20771 / m_line_header
->maximum_ops_per_instruction
)
20772 * m_line_header
->minimum_instruction_length
);
20773 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20774 m_op_index
= ((m_op_index
+ (adj_opcode
/ m_line_header
->line_range
))
20775 % m_line_header
->maximum_ops_per_instruction
);
20777 int line_delta
= (m_line_header
->line_base
20778 + (adj_opcode
% m_line_header
->line_range
));
20779 advance_line (line_delta
);
20780 record_line (false);
20781 m_discriminator
= 0;
20785 lnp_state_machine::handle_set_file (file_name_index file
)
20789 const file_entry
*fe
= current_file ();
20791 dwarf2_debug_line_missing_file_complaint ();
20792 else if (m_record_lines_p
)
20794 const char *dir
= fe
->include_dir (m_line_header
);
20796 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20797 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20798 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
20803 lnp_state_machine::handle_const_add_pc ()
20806 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
20809 = (((m_op_index
+ adjust
)
20810 / m_line_header
->maximum_ops_per_instruction
)
20811 * m_line_header
->minimum_instruction_length
);
20813 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20814 m_op_index
= ((m_op_index
+ adjust
)
20815 % m_line_header
->maximum_ops_per_instruction
);
20818 /* Return non-zero if we should add LINE to the line number table.
20819 LINE is the line to add, LAST_LINE is the last line that was added,
20820 LAST_SUBFILE is the subfile for LAST_LINE.
20821 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20822 had a non-zero discriminator.
20824 We have to be careful in the presence of discriminators.
20825 E.g., for this line:
20827 for (i = 0; i < 100000; i++);
20829 clang can emit four line number entries for that one line,
20830 each with a different discriminator.
20831 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20833 However, we want gdb to coalesce all four entries into one.
20834 Otherwise the user could stepi into the middle of the line and
20835 gdb would get confused about whether the pc really was in the
20836 middle of the line.
20838 Things are further complicated by the fact that two consecutive
20839 line number entries for the same line is a heuristic used by gcc
20840 to denote the end of the prologue. So we can't just discard duplicate
20841 entries, we have to be selective about it. The heuristic we use is
20842 that we only collapse consecutive entries for the same line if at least
20843 one of those entries has a non-zero discriminator. PR 17276.
20845 Note: Addresses in the line number state machine can never go backwards
20846 within one sequence, thus this coalescing is ok. */
20849 dwarf_record_line_p (struct dwarf2_cu
*cu
,
20850 unsigned int line
, unsigned int last_line
,
20851 int line_has_non_zero_discriminator
,
20852 struct subfile
*last_subfile
)
20854 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
20856 if (line
!= last_line
)
20858 /* Same line for the same file that we've seen already.
20859 As a last check, for pr 17276, only record the line if the line
20860 has never had a non-zero discriminator. */
20861 if (!line_has_non_zero_discriminator
)
20866 /* Use the CU's builder to record line number LINE beginning at
20867 address ADDRESS in the line table of subfile SUBFILE. */
20870 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20871 unsigned int line
, CORE_ADDR address
,
20872 struct dwarf2_cu
*cu
)
20874 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
20876 if (dwarf_line_debug
)
20878 fprintf_unfiltered (gdb_stdlog
,
20879 "Recording line %u, file %s, address %s\n",
20880 line
, lbasename (subfile
->name
),
20881 paddress (gdbarch
, address
));
20885 cu
->get_builder ()->record_line (subfile
, line
, addr
);
20888 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20889 Mark the end of a set of line number records.
20890 The arguments are the same as for dwarf_record_line_1.
20891 If SUBFILE is NULL the request is ignored. */
20894 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20895 CORE_ADDR address
, struct dwarf2_cu
*cu
)
20897 if (subfile
== NULL
)
20900 if (dwarf_line_debug
)
20902 fprintf_unfiltered (gdb_stdlog
,
20903 "Finishing current line, file %s, address %s\n",
20904 lbasename (subfile
->name
),
20905 paddress (gdbarch
, address
));
20908 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, cu
);
20912 lnp_state_machine::record_line (bool end_sequence
)
20914 if (dwarf_line_debug
)
20916 fprintf_unfiltered (gdb_stdlog
,
20917 "Processing actual line %u: file %u,"
20918 " address %s, is_stmt %u, discrim %u\n",
20919 m_line
, to_underlying (m_file
),
20920 paddress (m_gdbarch
, m_address
),
20921 m_is_stmt
, m_discriminator
);
20924 file_entry
*fe
= current_file ();
20927 dwarf2_debug_line_missing_file_complaint ();
20928 /* For now we ignore lines not starting on an instruction boundary.
20929 But not when processing end_sequence for compatibility with the
20930 previous version of the code. */
20931 else if (m_op_index
== 0 || end_sequence
)
20933 fe
->included_p
= 1;
20934 if (m_record_lines_p
&& (producer_is_codewarrior (m_cu
) || m_is_stmt
))
20936 if (m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ()
20939 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
20940 m_currently_recording_lines
? m_cu
: nullptr);
20945 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
20946 m_line_has_non_zero_discriminator
,
20949 buildsym_compunit
*builder
= m_cu
->get_builder ();
20950 dwarf_record_line_1 (m_gdbarch
,
20951 builder
->get_current_subfile (),
20953 m_currently_recording_lines
? m_cu
: nullptr);
20955 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20956 m_last_line
= m_line
;
20962 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
20963 line_header
*lh
, bool record_lines_p
)
20967 m_record_lines_p
= record_lines_p
;
20968 m_line_header
= lh
;
20970 m_currently_recording_lines
= true;
20972 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20973 was a line entry for it so that the backend has a chance to adjust it
20974 and also record it in case it needs it. This is currently used by MIPS
20975 code, cf. `mips_adjust_dwarf2_line'. */
20976 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
20977 m_is_stmt
= lh
->default_is_stmt
;
20978 m_discriminator
= 0;
20982 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
20983 const gdb_byte
*line_ptr
,
20984 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
20986 /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
20987 the pc range of the CU. However, we restrict the test to only ADDRESS
20988 values of zero to preserve GDB's previous behaviour which is to handle
20989 the specific case of a function being GC'd by the linker. */
20991 if (address
== 0 && address
< unrelocated_lowpc
)
20993 /* This line table is for a function which has been
20994 GCd by the linker. Ignore it. PR gdb/12528 */
20996 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
20997 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
20999 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21000 line_offset
, objfile_name (objfile
));
21001 m_currently_recording_lines
= false;
21002 /* Note: m_currently_recording_lines is left as false until we see
21003 DW_LNE_end_sequence. */
21007 /* Subroutine of dwarf_decode_lines to simplify it.
21008 Process the line number information in LH.
21009 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21010 program in order to set included_p for every referenced header. */
21013 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
21014 const int decode_for_pst_p
, CORE_ADDR lowpc
)
21016 const gdb_byte
*line_ptr
, *extended_end
;
21017 const gdb_byte
*line_end
;
21018 unsigned int bytes_read
, extended_len
;
21019 unsigned char op_code
, extended_op
;
21020 CORE_ADDR baseaddr
;
21021 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21022 bfd
*abfd
= objfile
->obfd
;
21023 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
21024 /* True if we're recording line info (as opposed to building partial
21025 symtabs and just interested in finding include files mentioned by
21026 the line number program). */
21027 bool record_lines_p
= !decode_for_pst_p
;
21029 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21031 line_ptr
= lh
->statement_program_start
;
21032 line_end
= lh
->statement_program_end
;
21034 /* Read the statement sequences until there's nothing left. */
21035 while (line_ptr
< line_end
)
21037 /* The DWARF line number program state machine. Reset the state
21038 machine at the start of each sequence. */
21039 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
21040 bool end_sequence
= false;
21042 if (record_lines_p
)
21044 /* Start a subfile for the current file of the state
21046 const file_entry
*fe
= state_machine
.current_file ();
21049 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
21052 /* Decode the table. */
21053 while (line_ptr
< line_end
&& !end_sequence
)
21055 op_code
= read_1_byte (abfd
, line_ptr
);
21058 if (op_code
>= lh
->opcode_base
)
21060 /* Special opcode. */
21061 state_machine
.handle_special_opcode (op_code
);
21063 else switch (op_code
)
21065 case DW_LNS_extended_op
:
21066 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
21068 line_ptr
+= bytes_read
;
21069 extended_end
= line_ptr
+ extended_len
;
21070 extended_op
= read_1_byte (abfd
, line_ptr
);
21072 switch (extended_op
)
21074 case DW_LNE_end_sequence
:
21075 state_machine
.handle_end_sequence ();
21076 end_sequence
= true;
21078 case DW_LNE_set_address
:
21081 = read_address (abfd
, line_ptr
, cu
, &bytes_read
);
21082 line_ptr
+= bytes_read
;
21084 state_machine
.check_line_address (cu
, line_ptr
,
21085 lowpc
- baseaddr
, address
);
21086 state_machine
.handle_set_address (baseaddr
, address
);
21089 case DW_LNE_define_file
:
21091 const char *cur_file
;
21092 unsigned int mod_time
, length
;
21095 cur_file
= read_direct_string (abfd
, line_ptr
,
21097 line_ptr
+= bytes_read
;
21098 dindex
= (dir_index
)
21099 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21100 line_ptr
+= bytes_read
;
21102 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21103 line_ptr
+= bytes_read
;
21105 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21106 line_ptr
+= bytes_read
;
21107 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21110 case DW_LNE_set_discriminator
:
21112 /* The discriminator is not interesting to the
21113 debugger; just ignore it. We still need to
21114 check its value though:
21115 if there are consecutive entries for the same
21116 (non-prologue) line we want to coalesce them.
21119 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21120 line_ptr
+= bytes_read
;
21122 state_machine
.handle_set_discriminator (discr
);
21126 complaint (_("mangled .debug_line section"));
21129 /* Make sure that we parsed the extended op correctly. If e.g.
21130 we expected a different address size than the producer used,
21131 we may have read the wrong number of bytes. */
21132 if (line_ptr
!= extended_end
)
21134 complaint (_("mangled .debug_line section"));
21139 state_machine
.handle_copy ();
21141 case DW_LNS_advance_pc
:
21144 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21145 line_ptr
+= bytes_read
;
21147 state_machine
.handle_advance_pc (adjust
);
21150 case DW_LNS_advance_line
:
21153 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21154 line_ptr
+= bytes_read
;
21156 state_machine
.handle_advance_line (line_delta
);
21159 case DW_LNS_set_file
:
21161 file_name_index file
21162 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21164 line_ptr
+= bytes_read
;
21166 state_machine
.handle_set_file (file
);
21169 case DW_LNS_set_column
:
21170 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21171 line_ptr
+= bytes_read
;
21173 case DW_LNS_negate_stmt
:
21174 state_machine
.handle_negate_stmt ();
21176 case DW_LNS_set_basic_block
:
21178 /* Add to the address register of the state machine the
21179 address increment value corresponding to special opcode
21180 255. I.e., this value is scaled by the minimum
21181 instruction length since special opcode 255 would have
21182 scaled the increment. */
21183 case DW_LNS_const_add_pc
:
21184 state_machine
.handle_const_add_pc ();
21186 case DW_LNS_fixed_advance_pc
:
21188 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21191 state_machine
.handle_fixed_advance_pc (addr_adj
);
21196 /* Unknown standard opcode, ignore it. */
21199 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21201 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21202 line_ptr
+= bytes_read
;
21209 dwarf2_debug_line_missing_end_sequence_complaint ();
21211 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21212 in which case we still finish recording the last line). */
21213 state_machine
.record_line (true);
21217 /* Decode the Line Number Program (LNP) for the given line_header
21218 structure and CU. The actual information extracted and the type
21219 of structures created from the LNP depends on the value of PST.
21221 1. If PST is NULL, then this procedure uses the data from the program
21222 to create all necessary symbol tables, and their linetables.
21224 2. If PST is not NULL, this procedure reads the program to determine
21225 the list of files included by the unit represented by PST, and
21226 builds all the associated partial symbol tables.
21228 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21229 It is used for relative paths in the line table.
21230 NOTE: When processing partial symtabs (pst != NULL),
21231 comp_dir == pst->dirname.
21233 NOTE: It is important that psymtabs have the same file name (via strcmp)
21234 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21235 symtab we don't use it in the name of the psymtabs we create.
21236 E.g. expand_line_sal requires this when finding psymtabs to expand.
21237 A good testcase for this is mb-inline.exp.
21239 LOWPC is the lowest address in CU (or 0 if not known).
21241 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21242 for its PC<->lines mapping information. Otherwise only the filename
21243 table is read in. */
21246 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21247 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
21248 CORE_ADDR lowpc
, int decode_mapping
)
21250 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21251 const int decode_for_pst_p
= (pst
!= NULL
);
21253 if (decode_mapping
)
21254 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21256 if (decode_for_pst_p
)
21260 /* Now that we're done scanning the Line Header Program, we can
21261 create the psymtab of each included file. */
21262 for (file_index
= 0; file_index
< lh
->file_names
.size (); file_index
++)
21263 if (lh
->file_names
[file_index
].included_p
== 1)
21265 gdb::unique_xmalloc_ptr
<char> name_holder
;
21266 const char *include_name
=
21267 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
,
21269 if (include_name
!= NULL
)
21270 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
21275 /* Make sure a symtab is created for every file, even files
21276 which contain only variables (i.e. no code with associated
21278 buildsym_compunit
*builder
= cu
->get_builder ();
21279 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21282 for (i
= 0; i
< lh
->file_names
.size (); i
++)
21284 file_entry
&fe
= lh
->file_names
[i
];
21286 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21288 if (builder
->get_current_subfile ()->symtab
== NULL
)
21290 builder
->get_current_subfile ()->symtab
21291 = allocate_symtab (cust
,
21292 builder
->get_current_subfile ()->name
);
21294 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21299 /* Start a subfile for DWARF. FILENAME is the name of the file and
21300 DIRNAME the name of the source directory which contains FILENAME
21301 or NULL if not known.
21302 This routine tries to keep line numbers from identical absolute and
21303 relative file names in a common subfile.
21305 Using the `list' example from the GDB testsuite, which resides in
21306 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21307 of /srcdir/list0.c yields the following debugging information for list0.c:
21309 DW_AT_name: /srcdir/list0.c
21310 DW_AT_comp_dir: /compdir
21311 files.files[0].name: list0.h
21312 files.files[0].dir: /srcdir
21313 files.files[1].name: list0.c
21314 files.files[1].dir: /srcdir
21316 The line number information for list0.c has to end up in a single
21317 subfile, so that `break /srcdir/list0.c:1' works as expected.
21318 start_subfile will ensure that this happens provided that we pass the
21319 concatenation of files.files[1].dir and files.files[1].name as the
21323 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
21324 const char *dirname
)
21328 /* In order not to lose the line information directory,
21329 we concatenate it to the filename when it makes sense.
21330 Note that the Dwarf3 standard says (speaking of filenames in line
21331 information): ``The directory index is ignored for file names
21332 that represent full path names''. Thus ignoring dirname in the
21333 `else' branch below isn't an issue. */
21335 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
21337 copy
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
21341 cu
->get_builder ()->start_subfile (filename
);
21347 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21348 buildsym_compunit constructor. */
21350 struct compunit_symtab
*
21351 dwarf2_cu::start_symtab (const char *name
, const char *comp_dir
,
21354 gdb_assert (m_builder
== nullptr);
21356 m_builder
.reset (new struct buildsym_compunit
21357 (per_cu
->dwarf2_per_objfile
->objfile
,
21358 name
, comp_dir
, language
, low_pc
));
21360 list_in_scope
= get_builder ()->get_file_symbols ();
21362 get_builder ()->record_debugformat ("DWARF 2");
21363 get_builder ()->record_producer (producer
);
21365 processing_has_namespace_info
= false;
21367 return get_builder ()->get_compunit_symtab ();
21371 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
21372 struct dwarf2_cu
*cu
)
21374 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21375 struct comp_unit_head
*cu_header
= &cu
->header
;
21377 /* NOTE drow/2003-01-30: There used to be a comment and some special
21378 code here to turn a symbol with DW_AT_external and a
21379 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21380 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21381 with some versions of binutils) where shared libraries could have
21382 relocations against symbols in their debug information - the
21383 minimal symbol would have the right address, but the debug info
21384 would not. It's no longer necessary, because we will explicitly
21385 apply relocations when we read in the debug information now. */
21387 /* A DW_AT_location attribute with no contents indicates that a
21388 variable has been optimized away. */
21389 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
21391 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21395 /* Handle one degenerate form of location expression specially, to
21396 preserve GDB's previous behavior when section offsets are
21397 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
21398 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
21400 if (attr_form_is_block (attr
)
21401 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
21402 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
21403 || ((DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
21404 || DW_BLOCK (attr
)->data
[0] == DW_OP_addrx
)
21405 && (DW_BLOCK (attr
)->size
21406 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
21408 unsigned int dummy
;
21410 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
21411 SYMBOL_VALUE_ADDRESS (sym
) =
21412 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
21414 SYMBOL_VALUE_ADDRESS (sym
) =
21415 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
21416 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
21417 fixup_symbol_section (sym
, objfile
);
21418 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
21419 SYMBOL_SECTION (sym
));
21423 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21424 expression evaluator, and use LOC_COMPUTED only when necessary
21425 (i.e. when the value of a register or memory location is
21426 referenced, or a thread-local block, etc.). Then again, it might
21427 not be worthwhile. I'm assuming that it isn't unless performance
21428 or memory numbers show me otherwise. */
21430 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
21432 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
21433 cu
->has_loclist
= true;
21436 /* Given a pointer to a DWARF information entry, figure out if we need
21437 to make a symbol table entry for it, and if so, create a new entry
21438 and return a pointer to it.
21439 If TYPE is NULL, determine symbol type from the die, otherwise
21440 used the passed type.
21441 If SPACE is not NULL, use it to hold the new symbol. If it is
21442 NULL, allocate a new symbol on the objfile's obstack. */
21444 static struct symbol
*
21445 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
21446 struct symbol
*space
)
21448 struct dwarf2_per_objfile
*dwarf2_per_objfile
21449 = cu
->per_cu
->dwarf2_per_objfile
;
21450 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21451 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
21452 struct symbol
*sym
= NULL
;
21454 struct attribute
*attr
= NULL
;
21455 struct attribute
*attr2
= NULL
;
21456 CORE_ADDR baseaddr
;
21457 struct pending
**list_to_add
= NULL
;
21459 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
21461 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21463 name
= dwarf2_name (die
, cu
);
21466 const char *linkagename
;
21467 int suppress_add
= 0;
21472 sym
= allocate_symbol (objfile
);
21473 OBJSTAT (objfile
, n_syms
++);
21475 /* Cache this symbol's name and the name's demangled form (if any). */
21476 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
21477 linkagename
= dwarf2_physname (name
, die
, cu
);
21478 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
21480 /* Fortran does not have mangling standard and the mangling does differ
21481 between gfortran, iFort etc. */
21482 if (cu
->language
== language_fortran
21483 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
21484 symbol_set_demangled_name (&(sym
->ginfo
),
21485 dwarf2_full_name (name
, die
, cu
),
21488 /* Default assumptions.
21489 Use the passed type or decode it from the die. */
21490 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21491 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21493 SYMBOL_TYPE (sym
) = type
;
21495 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
21496 attr
= dwarf2_attr (die
,
21497 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
21501 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
21504 attr
= dwarf2_attr (die
,
21505 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
21509 file_name_index file_index
= (file_name_index
) DW_UNSND (attr
);
21510 struct file_entry
*fe
;
21512 if (cu
->line_header
!= NULL
)
21513 fe
= cu
->line_header
->file_name_at (file_index
);
21518 complaint (_("file index out of range"));
21520 symbol_set_symtab (sym
, fe
->symtab
);
21526 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
21531 addr
= attr_value_as_address (attr
);
21532 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
21533 SYMBOL_VALUE_ADDRESS (sym
) = addr
;
21535 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
21536 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
21537 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
21538 add_symbol_to_list (sym
, cu
->list_in_scope
);
21540 case DW_TAG_subprogram
:
21541 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21543 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21544 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21545 if ((attr2
&& (DW_UNSND (attr2
) != 0))
21546 || cu
->language
== language_ada
)
21548 /* Subprograms marked external are stored as a global symbol.
21549 Ada subprograms, whether marked external or not, are always
21550 stored as a global symbol, because we want to be able to
21551 access them globally. For instance, we want to be able
21552 to break on a nested subprogram without having to
21553 specify the context. */
21554 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21558 list_to_add
= cu
->list_in_scope
;
21561 case DW_TAG_inlined_subroutine
:
21562 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21564 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21565 SYMBOL_INLINED (sym
) = 1;
21566 list_to_add
= cu
->list_in_scope
;
21568 case DW_TAG_template_value_param
:
21570 /* Fall through. */
21571 case DW_TAG_constant
:
21572 case DW_TAG_variable
:
21573 case DW_TAG_member
:
21574 /* Compilation with minimal debug info may result in
21575 variables with missing type entries. Change the
21576 misleading `void' type to something sensible. */
21577 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
21578 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
21580 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21581 /* In the case of DW_TAG_member, we should only be called for
21582 static const members. */
21583 if (die
->tag
== DW_TAG_member
)
21585 /* dwarf2_add_field uses die_is_declaration,
21586 so we do the same. */
21587 gdb_assert (die_is_declaration (die
, cu
));
21592 dwarf2_const_value (attr
, sym
, cu
);
21593 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21596 if (attr2
&& (DW_UNSND (attr2
) != 0))
21597 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21599 list_to_add
= cu
->list_in_scope
;
21603 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21606 var_decode_location (attr
, sym
, cu
);
21607 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21609 /* Fortran explicitly imports any global symbols to the local
21610 scope by DW_TAG_common_block. */
21611 if (cu
->language
== language_fortran
&& die
->parent
21612 && die
->parent
->tag
== DW_TAG_common_block
)
21615 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21616 && SYMBOL_VALUE_ADDRESS (sym
) == 0
21617 && !dwarf2_per_objfile
->has_section_at_zero
)
21619 /* When a static variable is eliminated by the linker,
21620 the corresponding debug information is not stripped
21621 out, but the variable address is set to null;
21622 do not add such variables into symbol table. */
21624 else if (attr2
&& (DW_UNSND (attr2
) != 0))
21626 /* Workaround gfortran PR debug/40040 - it uses
21627 DW_AT_location for variables in -fPIC libraries which may
21628 get overriden by other libraries/executable and get
21629 a different address. Resolve it by the minimal symbol
21630 which may come from inferior's executable using copy
21631 relocation. Make this workaround only for gfortran as for
21632 other compilers GDB cannot guess the minimal symbol
21633 Fortran mangling kind. */
21634 if (cu
->language
== language_fortran
&& die
->parent
21635 && die
->parent
->tag
== DW_TAG_module
21637 && startswith (cu
->producer
, "GNU Fortran"))
21638 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21640 /* A variable with DW_AT_external is never static,
21641 but it may be block-scoped. */
21643 = ((cu
->list_in_scope
21644 == cu
->get_builder ()->get_file_symbols ())
21645 ? cu
->get_builder ()->get_global_symbols ()
21646 : cu
->list_in_scope
);
21649 list_to_add
= cu
->list_in_scope
;
21653 /* We do not know the address of this symbol.
21654 If it is an external symbol and we have type information
21655 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21656 The address of the variable will then be determined from
21657 the minimal symbol table whenever the variable is
21659 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21661 /* Fortran explicitly imports any global symbols to the local
21662 scope by DW_TAG_common_block. */
21663 if (cu
->language
== language_fortran
&& die
->parent
21664 && die
->parent
->tag
== DW_TAG_common_block
)
21666 /* SYMBOL_CLASS doesn't matter here because
21667 read_common_block is going to reset it. */
21669 list_to_add
= cu
->list_in_scope
;
21671 else if (attr2
&& (DW_UNSND (attr2
) != 0)
21672 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
21674 /* A variable with DW_AT_external is never static, but it
21675 may be block-scoped. */
21677 = ((cu
->list_in_scope
21678 == cu
->get_builder ()->get_file_symbols ())
21679 ? cu
->get_builder ()->get_global_symbols ()
21680 : cu
->list_in_scope
);
21682 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21684 else if (!die_is_declaration (die
, cu
))
21686 /* Use the default LOC_OPTIMIZED_OUT class. */
21687 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
21689 list_to_add
= cu
->list_in_scope
;
21693 case DW_TAG_formal_parameter
:
21695 /* If we are inside a function, mark this as an argument. If
21696 not, we might be looking at an argument to an inlined function
21697 when we do not have enough information to show inlined frames;
21698 pretend it's a local variable in that case so that the user can
21700 struct context_stack
*curr
21701 = cu
->get_builder ()->get_current_context_stack ();
21702 if (curr
!= nullptr && curr
->name
!= nullptr)
21703 SYMBOL_IS_ARGUMENT (sym
) = 1;
21704 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21707 var_decode_location (attr
, sym
, cu
);
21709 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21712 dwarf2_const_value (attr
, sym
, cu
);
21715 list_to_add
= cu
->list_in_scope
;
21718 case DW_TAG_unspecified_parameters
:
21719 /* From varargs functions; gdb doesn't seem to have any
21720 interest in this information, so just ignore it for now.
21723 case DW_TAG_template_type_param
:
21725 /* Fall through. */
21726 case DW_TAG_class_type
:
21727 case DW_TAG_interface_type
:
21728 case DW_TAG_structure_type
:
21729 case DW_TAG_union_type
:
21730 case DW_TAG_set_type
:
21731 case DW_TAG_enumeration_type
:
21732 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21733 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
21736 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21737 really ever be static objects: otherwise, if you try
21738 to, say, break of a class's method and you're in a file
21739 which doesn't mention that class, it won't work unless
21740 the check for all static symbols in lookup_symbol_aux
21741 saves you. See the OtherFileClass tests in
21742 gdb.c++/namespace.exp. */
21746 buildsym_compunit
*builder
= cu
->get_builder ();
21748 = (cu
->list_in_scope
== builder
->get_file_symbols ()
21749 && cu
->language
== language_cplus
21750 ? builder
->get_global_symbols ()
21751 : cu
->list_in_scope
);
21753 /* The semantics of C++ state that "struct foo {
21754 ... }" also defines a typedef for "foo". */
21755 if (cu
->language
== language_cplus
21756 || cu
->language
== language_ada
21757 || cu
->language
== language_d
21758 || cu
->language
== language_rust
)
21760 /* The symbol's name is already allocated along
21761 with this objfile, so we don't need to
21762 duplicate it for the type. */
21763 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
21764 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
21769 case DW_TAG_typedef
:
21770 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21771 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21772 list_to_add
= cu
->list_in_scope
;
21774 case DW_TAG_base_type
:
21775 case DW_TAG_subrange_type
:
21776 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21777 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21778 list_to_add
= cu
->list_in_scope
;
21780 case DW_TAG_enumerator
:
21781 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21784 dwarf2_const_value (attr
, sym
, cu
);
21787 /* NOTE: carlton/2003-11-10: See comment above in the
21788 DW_TAG_class_type, etc. block. */
21791 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
21792 && cu
->language
== language_cplus
21793 ? cu
->get_builder ()->get_global_symbols ()
21794 : cu
->list_in_scope
);
21797 case DW_TAG_imported_declaration
:
21798 case DW_TAG_namespace
:
21799 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21800 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21802 case DW_TAG_module
:
21803 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21804 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
21805 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21807 case DW_TAG_common_block
:
21808 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
21809 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
21810 add_symbol_to_list (sym
, cu
->list_in_scope
);
21813 /* Not a tag we recognize. Hopefully we aren't processing
21814 trash data, but since we must specifically ignore things
21815 we don't recognize, there is nothing else we should do at
21817 complaint (_("unsupported tag: '%s'"),
21818 dwarf_tag_name (die
->tag
));
21824 sym
->hash_next
= objfile
->template_symbols
;
21825 objfile
->template_symbols
= sym
;
21826 list_to_add
= NULL
;
21829 if (list_to_add
!= NULL
)
21830 add_symbol_to_list (sym
, list_to_add
);
21832 /* For the benefit of old versions of GCC, check for anonymous
21833 namespaces based on the demangled name. */
21834 if (!cu
->processing_has_namespace_info
21835 && cu
->language
== language_cplus
)
21836 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
21841 /* Given an attr with a DW_FORM_dataN value in host byte order,
21842 zero-extend it as appropriate for the symbol's type. The DWARF
21843 standard (v4) is not entirely clear about the meaning of using
21844 DW_FORM_dataN for a constant with a signed type, where the type is
21845 wider than the data. The conclusion of a discussion on the DWARF
21846 list was that this is unspecified. We choose to always zero-extend
21847 because that is the interpretation long in use by GCC. */
21850 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
21851 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
21853 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21854 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
21855 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
21856 LONGEST l
= DW_UNSND (attr
);
21858 if (bits
< sizeof (*value
) * 8)
21860 l
&= ((LONGEST
) 1 << bits
) - 1;
21863 else if (bits
== sizeof (*value
) * 8)
21867 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
21868 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
21875 /* Read a constant value from an attribute. Either set *VALUE, or if
21876 the value does not fit in *VALUE, set *BYTES - either already
21877 allocated on the objfile obstack, or newly allocated on OBSTACK,
21878 or, set *BATON, if we translated the constant to a location
21882 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
21883 const char *name
, struct obstack
*obstack
,
21884 struct dwarf2_cu
*cu
,
21885 LONGEST
*value
, const gdb_byte
**bytes
,
21886 struct dwarf2_locexpr_baton
**baton
)
21888 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21889 struct comp_unit_head
*cu_header
= &cu
->header
;
21890 struct dwarf_block
*blk
;
21891 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
21892 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
21898 switch (attr
->form
)
21901 case DW_FORM_addrx
:
21902 case DW_FORM_GNU_addr_index
:
21906 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
21907 dwarf2_const_value_length_mismatch_complaint (name
,
21908 cu_header
->addr_size
,
21909 TYPE_LENGTH (type
));
21910 /* Symbols of this form are reasonably rare, so we just
21911 piggyback on the existing location code rather than writing
21912 a new implementation of symbol_computed_ops. */
21913 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
21914 (*baton
)->per_cu
= cu
->per_cu
;
21915 gdb_assert ((*baton
)->per_cu
);
21917 (*baton
)->size
= 2 + cu_header
->addr_size
;
21918 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
21919 (*baton
)->data
= data
;
21921 data
[0] = DW_OP_addr
;
21922 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
21923 byte_order
, DW_ADDR (attr
));
21924 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
21927 case DW_FORM_string
:
21930 case DW_FORM_GNU_str_index
:
21931 case DW_FORM_GNU_strp_alt
:
21932 /* DW_STRING is already allocated on the objfile obstack, point
21934 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
21936 case DW_FORM_block1
:
21937 case DW_FORM_block2
:
21938 case DW_FORM_block4
:
21939 case DW_FORM_block
:
21940 case DW_FORM_exprloc
:
21941 case DW_FORM_data16
:
21942 blk
= DW_BLOCK (attr
);
21943 if (TYPE_LENGTH (type
) != blk
->size
)
21944 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
21945 TYPE_LENGTH (type
));
21946 *bytes
= blk
->data
;
21949 /* The DW_AT_const_value attributes are supposed to carry the
21950 symbol's value "represented as it would be on the target
21951 architecture." By the time we get here, it's already been
21952 converted to host endianness, so we just need to sign- or
21953 zero-extend it as appropriate. */
21954 case DW_FORM_data1
:
21955 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
21957 case DW_FORM_data2
:
21958 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
21960 case DW_FORM_data4
:
21961 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
21963 case DW_FORM_data8
:
21964 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
21967 case DW_FORM_sdata
:
21968 case DW_FORM_implicit_const
:
21969 *value
= DW_SND (attr
);
21972 case DW_FORM_udata
:
21973 *value
= DW_UNSND (attr
);
21977 complaint (_("unsupported const value attribute form: '%s'"),
21978 dwarf_form_name (attr
->form
));
21985 /* Copy constant value from an attribute to a symbol. */
21988 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
21989 struct dwarf2_cu
*cu
)
21991 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21993 const gdb_byte
*bytes
;
21994 struct dwarf2_locexpr_baton
*baton
;
21996 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
21997 SYMBOL_PRINT_NAME (sym
),
21998 &objfile
->objfile_obstack
, cu
,
21999 &value
, &bytes
, &baton
);
22003 SYMBOL_LOCATION_BATON (sym
) = baton
;
22004 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
22006 else if (bytes
!= NULL
)
22008 SYMBOL_VALUE_BYTES (sym
) = bytes
;
22009 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
22013 SYMBOL_VALUE (sym
) = value
;
22014 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
22018 /* Return the type of the die in question using its DW_AT_type attribute. */
22020 static struct type
*
22021 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22023 struct attribute
*type_attr
;
22025 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
22028 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22029 /* A missing DW_AT_type represents a void type. */
22030 return objfile_type (objfile
)->builtin_void
;
22033 return lookup_die_type (die
, type_attr
, cu
);
22036 /* True iff CU's producer generates GNAT Ada auxiliary information
22037 that allows to find parallel types through that information instead
22038 of having to do expensive parallel lookups by type name. */
22041 need_gnat_info (struct dwarf2_cu
*cu
)
22043 /* Assume that the Ada compiler was GNAT, which always produces
22044 the auxiliary information. */
22045 return (cu
->language
== language_ada
);
22048 /* Return the auxiliary type of the die in question using its
22049 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
22050 attribute is not present. */
22052 static struct type
*
22053 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22055 struct attribute
*type_attr
;
22057 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22061 return lookup_die_type (die
, type_attr
, cu
);
22064 /* If DIE has a descriptive_type attribute, then set the TYPE's
22065 descriptive type accordingly. */
22068 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22069 struct dwarf2_cu
*cu
)
22071 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22073 if (descriptive_type
)
22075 ALLOCATE_GNAT_AUX_TYPE (type
);
22076 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22080 /* Return the containing type of the die in question using its
22081 DW_AT_containing_type attribute. */
22083 static struct type
*
22084 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22086 struct attribute
*type_attr
;
22087 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22089 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22091 error (_("Dwarf Error: Problem turning containing type into gdb type "
22092 "[in module %s]"), objfile_name (objfile
));
22094 return lookup_die_type (die
, type_attr
, cu
);
22097 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22099 static struct type
*
22100 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22102 struct dwarf2_per_objfile
*dwarf2_per_objfile
22103 = cu
->per_cu
->dwarf2_per_objfile
;
22104 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22107 std::string message
22108 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22109 objfile_name (objfile
),
22110 sect_offset_str (cu
->header
.sect_off
),
22111 sect_offset_str (die
->sect_off
));
22112 saved
= (char *) obstack_copy0 (&objfile
->objfile_obstack
,
22113 message
.c_str (), message
.length ());
22115 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22118 /* Look up the type of DIE in CU using its type attribute ATTR.
22119 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22120 DW_AT_containing_type.
22121 If there is no type substitute an error marker. */
22123 static struct type
*
22124 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22125 struct dwarf2_cu
*cu
)
22127 struct dwarf2_per_objfile
*dwarf2_per_objfile
22128 = cu
->per_cu
->dwarf2_per_objfile
;
22129 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22130 struct type
*this_type
;
22132 gdb_assert (attr
->name
== DW_AT_type
22133 || attr
->name
== DW_AT_GNAT_descriptive_type
22134 || attr
->name
== DW_AT_containing_type
);
22136 /* First see if we have it cached. */
22138 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22140 struct dwarf2_per_cu_data
*per_cu
;
22141 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
22143 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1,
22144 dwarf2_per_objfile
);
22145 this_type
= get_die_type_at_offset (sect_off
, per_cu
);
22147 else if (attr_form_is_ref (attr
))
22149 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
22151 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
22153 else if (attr
->form
== DW_FORM_ref_sig8
)
22155 ULONGEST signature
= DW_SIGNATURE (attr
);
22157 return get_signatured_type (die
, signature
, cu
);
22161 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22162 " at %s [in module %s]"),
22163 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22164 objfile_name (objfile
));
22165 return build_error_marker_type (cu
, die
);
22168 /* If not cached we need to read it in. */
22170 if (this_type
== NULL
)
22172 struct die_info
*type_die
= NULL
;
22173 struct dwarf2_cu
*type_cu
= cu
;
22175 if (attr_form_is_ref (attr
))
22176 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22177 if (type_die
== NULL
)
22178 return build_error_marker_type (cu
, die
);
22179 /* If we find the type now, it's probably because the type came
22180 from an inter-CU reference and the type's CU got expanded before
22182 this_type
= read_type_die (type_die
, type_cu
);
22185 /* If we still don't have a type use an error marker. */
22187 if (this_type
== NULL
)
22188 return build_error_marker_type (cu
, die
);
22193 /* Return the type in DIE, CU.
22194 Returns NULL for invalid types.
22196 This first does a lookup in die_type_hash,
22197 and only reads the die in if necessary.
22199 NOTE: This can be called when reading in partial or full symbols. */
22201 static struct type
*
22202 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22204 struct type
*this_type
;
22206 this_type
= get_die_type (die
, cu
);
22210 return read_type_die_1 (die
, cu
);
22213 /* Read the type in DIE, CU.
22214 Returns NULL for invalid types. */
22216 static struct type
*
22217 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22219 struct type
*this_type
= NULL
;
22223 case DW_TAG_class_type
:
22224 case DW_TAG_interface_type
:
22225 case DW_TAG_structure_type
:
22226 case DW_TAG_union_type
:
22227 this_type
= read_structure_type (die
, cu
);
22229 case DW_TAG_enumeration_type
:
22230 this_type
= read_enumeration_type (die
, cu
);
22232 case DW_TAG_subprogram
:
22233 case DW_TAG_subroutine_type
:
22234 case DW_TAG_inlined_subroutine
:
22235 this_type
= read_subroutine_type (die
, cu
);
22237 case DW_TAG_array_type
:
22238 this_type
= read_array_type (die
, cu
);
22240 case DW_TAG_set_type
:
22241 this_type
= read_set_type (die
, cu
);
22243 case DW_TAG_pointer_type
:
22244 this_type
= read_tag_pointer_type (die
, cu
);
22246 case DW_TAG_ptr_to_member_type
:
22247 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22249 case DW_TAG_reference_type
:
22250 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22252 case DW_TAG_rvalue_reference_type
:
22253 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22255 case DW_TAG_const_type
:
22256 this_type
= read_tag_const_type (die
, cu
);
22258 case DW_TAG_volatile_type
:
22259 this_type
= read_tag_volatile_type (die
, cu
);
22261 case DW_TAG_restrict_type
:
22262 this_type
= read_tag_restrict_type (die
, cu
);
22264 case DW_TAG_string_type
:
22265 this_type
= read_tag_string_type (die
, cu
);
22267 case DW_TAG_typedef
:
22268 this_type
= read_typedef (die
, cu
);
22270 case DW_TAG_subrange_type
:
22271 this_type
= read_subrange_type (die
, cu
);
22273 case DW_TAG_base_type
:
22274 this_type
= read_base_type (die
, cu
);
22276 case DW_TAG_unspecified_type
:
22277 this_type
= read_unspecified_type (die
, cu
);
22279 case DW_TAG_namespace
:
22280 this_type
= read_namespace_type (die
, cu
);
22282 case DW_TAG_module
:
22283 this_type
= read_module_type (die
, cu
);
22285 case DW_TAG_atomic_type
:
22286 this_type
= read_tag_atomic_type (die
, cu
);
22289 complaint (_("unexpected tag in read_type_die: '%s'"),
22290 dwarf_tag_name (die
->tag
));
22297 /* See if we can figure out if the class lives in a namespace. We do
22298 this by looking for a member function; its demangled name will
22299 contain namespace info, if there is any.
22300 Return the computed name or NULL.
22301 Space for the result is allocated on the objfile's obstack.
22302 This is the full-die version of guess_partial_die_structure_name.
22303 In this case we know DIE has no useful parent. */
22306 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22308 struct die_info
*spec_die
;
22309 struct dwarf2_cu
*spec_cu
;
22310 struct die_info
*child
;
22311 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22314 spec_die
= die_specification (die
, &spec_cu
);
22315 if (spec_die
!= NULL
)
22321 for (child
= die
->child
;
22323 child
= child
->sibling
)
22325 if (child
->tag
== DW_TAG_subprogram
)
22327 const char *linkage_name
= dw2_linkage_name (child
, cu
);
22329 if (linkage_name
!= NULL
)
22332 = language_class_name_from_physname (cu
->language_defn
,
22336 if (actual_name
!= NULL
)
22338 const char *die_name
= dwarf2_name (die
, cu
);
22340 if (die_name
!= NULL
22341 && strcmp (die_name
, actual_name
) != 0)
22343 /* Strip off the class name from the full name.
22344 We want the prefix. */
22345 int die_name_len
= strlen (die_name
);
22346 int actual_name_len
= strlen (actual_name
);
22348 /* Test for '::' as a sanity check. */
22349 if (actual_name_len
> die_name_len
+ 2
22350 && actual_name
[actual_name_len
22351 - die_name_len
- 1] == ':')
22352 name
= (char *) obstack_copy0 (
22353 &objfile
->per_bfd
->storage_obstack
,
22354 actual_name
, actual_name_len
- die_name_len
- 2);
22357 xfree (actual_name
);
22366 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22367 prefix part in such case. See
22368 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22370 static const char *
22371 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22373 struct attribute
*attr
;
22376 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
22377 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
22380 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
22383 attr
= dw2_linkage_name_attr (die
, cu
);
22384 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
22387 /* dwarf2_name had to be already called. */
22388 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
22390 /* Strip the base name, keep any leading namespaces/classes. */
22391 base
= strrchr (DW_STRING (attr
), ':');
22392 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
22395 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22396 return (char *) obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
22398 &base
[-1] - DW_STRING (attr
));
22401 /* Return the name of the namespace/class that DIE is defined within,
22402 or "" if we can't tell. The caller should not xfree the result.
22404 For example, if we're within the method foo() in the following
22414 then determine_prefix on foo's die will return "N::C". */
22416 static const char *
22417 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22419 struct dwarf2_per_objfile
*dwarf2_per_objfile
22420 = cu
->per_cu
->dwarf2_per_objfile
;
22421 struct die_info
*parent
, *spec_die
;
22422 struct dwarf2_cu
*spec_cu
;
22423 struct type
*parent_type
;
22424 const char *retval
;
22426 if (cu
->language
!= language_cplus
22427 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
22428 && cu
->language
!= language_rust
)
22431 retval
= anonymous_struct_prefix (die
, cu
);
22435 /* We have to be careful in the presence of DW_AT_specification.
22436 For example, with GCC 3.4, given the code
22440 // Definition of N::foo.
22444 then we'll have a tree of DIEs like this:
22446 1: DW_TAG_compile_unit
22447 2: DW_TAG_namespace // N
22448 3: DW_TAG_subprogram // declaration of N::foo
22449 4: DW_TAG_subprogram // definition of N::foo
22450 DW_AT_specification // refers to die #3
22452 Thus, when processing die #4, we have to pretend that we're in
22453 the context of its DW_AT_specification, namely the contex of die
22456 spec_die
= die_specification (die
, &spec_cu
);
22457 if (spec_die
== NULL
)
22458 parent
= die
->parent
;
22461 parent
= spec_die
->parent
;
22465 if (parent
== NULL
)
22467 else if (parent
->building_fullname
)
22470 const char *parent_name
;
22472 /* It has been seen on RealView 2.2 built binaries,
22473 DW_TAG_template_type_param types actually _defined_ as
22474 children of the parent class:
22477 template class <class Enum> Class{};
22478 Class<enum E> class_e;
22480 1: DW_TAG_class_type (Class)
22481 2: DW_TAG_enumeration_type (E)
22482 3: DW_TAG_enumerator (enum1:0)
22483 3: DW_TAG_enumerator (enum2:1)
22485 2: DW_TAG_template_type_param
22486 DW_AT_type DW_FORM_ref_udata (E)
22488 Besides being broken debug info, it can put GDB into an
22489 infinite loop. Consider:
22491 When we're building the full name for Class<E>, we'll start
22492 at Class, and go look over its template type parameters,
22493 finding E. We'll then try to build the full name of E, and
22494 reach here. We're now trying to build the full name of E,
22495 and look over the parent DIE for containing scope. In the
22496 broken case, if we followed the parent DIE of E, we'd again
22497 find Class, and once again go look at its template type
22498 arguments, etc., etc. Simply don't consider such parent die
22499 as source-level parent of this die (it can't be, the language
22500 doesn't allow it), and break the loop here. */
22501 name
= dwarf2_name (die
, cu
);
22502 parent_name
= dwarf2_name (parent
, cu
);
22503 complaint (_("template param type '%s' defined within parent '%s'"),
22504 name
? name
: "<unknown>",
22505 parent_name
? parent_name
: "<unknown>");
22509 switch (parent
->tag
)
22511 case DW_TAG_namespace
:
22512 parent_type
= read_type_die (parent
, cu
);
22513 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22514 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22515 Work around this problem here. */
22516 if (cu
->language
== language_cplus
22517 && strcmp (TYPE_NAME (parent_type
), "::") == 0)
22519 /* We give a name to even anonymous namespaces. */
22520 return TYPE_NAME (parent_type
);
22521 case DW_TAG_class_type
:
22522 case DW_TAG_interface_type
:
22523 case DW_TAG_structure_type
:
22524 case DW_TAG_union_type
:
22525 case DW_TAG_module
:
22526 parent_type
= read_type_die (parent
, cu
);
22527 if (TYPE_NAME (parent_type
) != NULL
)
22528 return TYPE_NAME (parent_type
);
22530 /* An anonymous structure is only allowed non-static data
22531 members; no typedefs, no member functions, et cetera.
22532 So it does not need a prefix. */
22534 case DW_TAG_compile_unit
:
22535 case DW_TAG_partial_unit
:
22536 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22537 if (cu
->language
== language_cplus
22538 && !VEC_empty (dwarf2_section_info_def
, dwarf2_per_objfile
->types
)
22539 && die
->child
!= NULL
22540 && (die
->tag
== DW_TAG_class_type
22541 || die
->tag
== DW_TAG_structure_type
22542 || die
->tag
== DW_TAG_union_type
))
22544 char *name
= guess_full_die_structure_name (die
, cu
);
22549 case DW_TAG_enumeration_type
:
22550 parent_type
= read_type_die (parent
, cu
);
22551 if (TYPE_DECLARED_CLASS (parent_type
))
22553 if (TYPE_NAME (parent_type
) != NULL
)
22554 return TYPE_NAME (parent_type
);
22557 /* Fall through. */
22559 return determine_prefix (parent
, cu
);
22563 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22564 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22565 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22566 an obconcat, otherwise allocate storage for the result. The CU argument is
22567 used to determine the language and hence, the appropriate separator. */
22569 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22572 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
22573 int physname
, struct dwarf2_cu
*cu
)
22575 const char *lead
= "";
22578 if (suffix
== NULL
|| suffix
[0] == '\0'
22579 || prefix
== NULL
|| prefix
[0] == '\0')
22581 else if (cu
->language
== language_d
)
22583 /* For D, the 'main' function could be defined in any module, but it
22584 should never be prefixed. */
22585 if (strcmp (suffix
, "D main") == 0)
22593 else if (cu
->language
== language_fortran
&& physname
)
22595 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22596 DW_AT_MIPS_linkage_name is preferred and used instead. */
22604 if (prefix
== NULL
)
22606 if (suffix
== NULL
)
22613 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
22615 strcpy (retval
, lead
);
22616 strcat (retval
, prefix
);
22617 strcat (retval
, sep
);
22618 strcat (retval
, suffix
);
22623 /* We have an obstack. */
22624 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
22628 /* Return sibling of die, NULL if no sibling. */
22630 static struct die_info
*
22631 sibling_die (struct die_info
*die
)
22633 return die
->sibling
;
22636 /* Get name of a die, return NULL if not found. */
22638 static const char *
22639 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
22640 struct obstack
*obstack
)
22642 if (name
&& cu
->language
== language_cplus
)
22644 std::string canon_name
= cp_canonicalize_string (name
);
22646 if (!canon_name
.empty ())
22648 if (canon_name
!= name
)
22649 name
= (const char *) obstack_copy0 (obstack
,
22650 canon_name
.c_str (),
22651 canon_name
.length ());
22658 /* Get name of a die, return NULL if not found.
22659 Anonymous namespaces are converted to their magic string. */
22661 static const char *
22662 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22664 struct attribute
*attr
;
22665 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22667 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
22668 if ((!attr
|| !DW_STRING (attr
))
22669 && die
->tag
!= DW_TAG_namespace
22670 && die
->tag
!= DW_TAG_class_type
22671 && die
->tag
!= DW_TAG_interface_type
22672 && die
->tag
!= DW_TAG_structure_type
22673 && die
->tag
!= DW_TAG_union_type
)
22678 case DW_TAG_compile_unit
:
22679 case DW_TAG_partial_unit
:
22680 /* Compilation units have a DW_AT_name that is a filename, not
22681 a source language identifier. */
22682 case DW_TAG_enumeration_type
:
22683 case DW_TAG_enumerator
:
22684 /* These tags always have simple identifiers already; no need
22685 to canonicalize them. */
22686 return DW_STRING (attr
);
22688 case DW_TAG_namespace
:
22689 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
22690 return DW_STRING (attr
);
22691 return CP_ANONYMOUS_NAMESPACE_STR
;
22693 case DW_TAG_class_type
:
22694 case DW_TAG_interface_type
:
22695 case DW_TAG_structure_type
:
22696 case DW_TAG_union_type
:
22697 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22698 structures or unions. These were of the form "._%d" in GCC 4.1,
22699 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22700 and GCC 4.4. We work around this problem by ignoring these. */
22701 if (attr
&& DW_STRING (attr
)
22702 && (startswith (DW_STRING (attr
), "._")
22703 || startswith (DW_STRING (attr
), "<anonymous")))
22706 /* GCC might emit a nameless typedef that has a linkage name. See
22707 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22708 if (!attr
|| DW_STRING (attr
) == NULL
)
22710 char *demangled
= NULL
;
22712 attr
= dw2_linkage_name_attr (die
, cu
);
22713 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
22716 /* Avoid demangling DW_STRING (attr) the second time on a second
22717 call for the same DIE. */
22718 if (!DW_STRING_IS_CANONICAL (attr
))
22719 demangled
= gdb_demangle (DW_STRING (attr
), DMGL_TYPES
);
22725 /* FIXME: we already did this for the partial symbol... */
22728 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
22729 demangled
, strlen (demangled
)));
22730 DW_STRING_IS_CANONICAL (attr
) = 1;
22733 /* Strip any leading namespaces/classes, keep only the base name.
22734 DW_AT_name for named DIEs does not contain the prefixes. */
22735 base
= strrchr (DW_STRING (attr
), ':');
22736 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
22739 return DW_STRING (attr
);
22748 if (!DW_STRING_IS_CANONICAL (attr
))
22751 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
22752 &objfile
->per_bfd
->storage_obstack
);
22753 DW_STRING_IS_CANONICAL (attr
) = 1;
22755 return DW_STRING (attr
);
22758 /* Return the die that this die in an extension of, or NULL if there
22759 is none. *EXT_CU is the CU containing DIE on input, and the CU
22760 containing the return value on output. */
22762 static struct die_info
*
22763 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
22765 struct attribute
*attr
;
22767 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
22771 return follow_die_ref (die
, attr
, ext_cu
);
22774 /* A convenience function that returns an "unknown" DWARF name,
22775 including the value of V. STR is the name of the entity being
22776 printed, e.g., "TAG". */
22778 static const char *
22779 dwarf_unknown (const char *str
, unsigned v
)
22781 char *cell
= get_print_cell ();
22782 xsnprintf (cell
, PRINT_CELL_SIZE
, "DW_%s_<unknown: %u>", str
, v
);
22786 /* Convert a DIE tag into its string name. */
22788 static const char *
22789 dwarf_tag_name (unsigned tag
)
22791 const char *name
= get_DW_TAG_name (tag
);
22794 return dwarf_unknown ("TAG", tag
);
22799 /* Convert a DWARF attribute code into its string name. */
22801 static const char *
22802 dwarf_attr_name (unsigned attr
)
22806 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22807 if (attr
== DW_AT_MIPS_fde
)
22808 return "DW_AT_MIPS_fde";
22810 if (attr
== DW_AT_HP_block_index
)
22811 return "DW_AT_HP_block_index";
22814 name
= get_DW_AT_name (attr
);
22817 return dwarf_unknown ("AT", attr
);
22822 /* Convert a DWARF value form code into its string name. */
22824 static const char *
22825 dwarf_form_name (unsigned form
)
22827 const char *name
= get_DW_FORM_name (form
);
22830 return dwarf_unknown ("FORM", form
);
22835 static const char *
22836 dwarf_bool_name (unsigned mybool
)
22844 /* Convert a DWARF type code into its string name. */
22846 static const char *
22847 dwarf_type_encoding_name (unsigned enc
)
22849 const char *name
= get_DW_ATE_name (enc
);
22852 return dwarf_unknown ("ATE", enc
);
22858 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
22862 print_spaces (indent
, f
);
22863 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
22864 dwarf_tag_name (die
->tag
), die
->abbrev
,
22865 sect_offset_str (die
->sect_off
));
22867 if (die
->parent
!= NULL
)
22869 print_spaces (indent
, f
);
22870 fprintf_unfiltered (f
, " parent at offset: %s\n",
22871 sect_offset_str (die
->parent
->sect_off
));
22874 print_spaces (indent
, f
);
22875 fprintf_unfiltered (f
, " has children: %s\n",
22876 dwarf_bool_name (die
->child
!= NULL
));
22878 print_spaces (indent
, f
);
22879 fprintf_unfiltered (f
, " attributes:\n");
22881 for (i
= 0; i
< die
->num_attrs
; ++i
)
22883 print_spaces (indent
, f
);
22884 fprintf_unfiltered (f
, " %s (%s) ",
22885 dwarf_attr_name (die
->attrs
[i
].name
),
22886 dwarf_form_name (die
->attrs
[i
].form
));
22888 switch (die
->attrs
[i
].form
)
22891 case DW_FORM_addrx
:
22892 case DW_FORM_GNU_addr_index
:
22893 fprintf_unfiltered (f
, "address: ");
22894 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
22896 case DW_FORM_block2
:
22897 case DW_FORM_block4
:
22898 case DW_FORM_block
:
22899 case DW_FORM_block1
:
22900 fprintf_unfiltered (f
, "block: size %s",
22901 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
22903 case DW_FORM_exprloc
:
22904 fprintf_unfiltered (f
, "expression: size %s",
22905 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
22907 case DW_FORM_data16
:
22908 fprintf_unfiltered (f
, "constant of 16 bytes");
22910 case DW_FORM_ref_addr
:
22911 fprintf_unfiltered (f
, "ref address: ");
22912 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
22914 case DW_FORM_GNU_ref_alt
:
22915 fprintf_unfiltered (f
, "alt ref address: ");
22916 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
22922 case DW_FORM_ref_udata
:
22923 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
22924 (long) (DW_UNSND (&die
->attrs
[i
])));
22926 case DW_FORM_data1
:
22927 case DW_FORM_data2
:
22928 case DW_FORM_data4
:
22929 case DW_FORM_data8
:
22930 case DW_FORM_udata
:
22931 case DW_FORM_sdata
:
22932 fprintf_unfiltered (f
, "constant: %s",
22933 pulongest (DW_UNSND (&die
->attrs
[i
])));
22935 case DW_FORM_sec_offset
:
22936 fprintf_unfiltered (f
, "section offset: %s",
22937 pulongest (DW_UNSND (&die
->attrs
[i
])));
22939 case DW_FORM_ref_sig8
:
22940 fprintf_unfiltered (f
, "signature: %s",
22941 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
22943 case DW_FORM_string
:
22945 case DW_FORM_line_strp
:
22947 case DW_FORM_GNU_str_index
:
22948 case DW_FORM_GNU_strp_alt
:
22949 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
22950 DW_STRING (&die
->attrs
[i
])
22951 ? DW_STRING (&die
->attrs
[i
]) : "",
22952 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
22955 if (DW_UNSND (&die
->attrs
[i
]))
22956 fprintf_unfiltered (f
, "flag: TRUE");
22958 fprintf_unfiltered (f
, "flag: FALSE");
22960 case DW_FORM_flag_present
:
22961 fprintf_unfiltered (f
, "flag: TRUE");
22963 case DW_FORM_indirect
:
22964 /* The reader will have reduced the indirect form to
22965 the "base form" so this form should not occur. */
22966 fprintf_unfiltered (f
,
22967 "unexpected attribute form: DW_FORM_indirect");
22969 case DW_FORM_implicit_const
:
22970 fprintf_unfiltered (f
, "constant: %s",
22971 plongest (DW_SND (&die
->attrs
[i
])));
22974 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
22975 die
->attrs
[i
].form
);
22978 fprintf_unfiltered (f
, "\n");
22983 dump_die_for_error (struct die_info
*die
)
22985 dump_die_shallow (gdb_stderr
, 0, die
);
22989 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
22991 int indent
= level
* 4;
22993 gdb_assert (die
!= NULL
);
22995 if (level
>= max_level
)
22998 dump_die_shallow (f
, indent
, die
);
23000 if (die
->child
!= NULL
)
23002 print_spaces (indent
, f
);
23003 fprintf_unfiltered (f
, " Children:");
23004 if (level
+ 1 < max_level
)
23006 fprintf_unfiltered (f
, "\n");
23007 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
23011 fprintf_unfiltered (f
,
23012 " [not printed, max nesting level reached]\n");
23016 if (die
->sibling
!= NULL
&& level
> 0)
23018 dump_die_1 (f
, level
, max_level
, die
->sibling
);
23022 /* This is called from the pdie macro in gdbinit.in.
23023 It's not static so gcc will keep a copy callable from gdb. */
23026 dump_die (struct die_info
*die
, int max_level
)
23028 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
23032 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
23036 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
23037 to_underlying (die
->sect_off
),
23043 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
23047 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
23049 if (attr_form_is_ref (attr
))
23050 return (sect_offset
) DW_UNSND (attr
);
23052 complaint (_("unsupported die ref attribute form: '%s'"),
23053 dwarf_form_name (attr
->form
));
23057 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
23058 * the value held by the attribute is not constant. */
23061 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
23063 if (attr
->form
== DW_FORM_sdata
|| attr
->form
== DW_FORM_implicit_const
)
23064 return DW_SND (attr
);
23065 else if (attr
->form
== DW_FORM_udata
23066 || attr
->form
== DW_FORM_data1
23067 || attr
->form
== DW_FORM_data2
23068 || attr
->form
== DW_FORM_data4
23069 || attr
->form
== DW_FORM_data8
)
23070 return DW_UNSND (attr
);
23073 /* For DW_FORM_data16 see attr_form_is_constant. */
23074 complaint (_("Attribute value is not a constant (%s)"),
23075 dwarf_form_name (attr
->form
));
23076 return default_value
;
23080 /* Follow reference or signature attribute ATTR of SRC_DIE.
23081 On entry *REF_CU is the CU of SRC_DIE.
23082 On exit *REF_CU is the CU of the result. */
23084 static struct die_info
*
23085 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23086 struct dwarf2_cu
**ref_cu
)
23088 struct die_info
*die
;
23090 if (attr_form_is_ref (attr
))
23091 die
= follow_die_ref (src_die
, attr
, ref_cu
);
23092 else if (attr
->form
== DW_FORM_ref_sig8
)
23093 die
= follow_die_sig (src_die
, attr
, ref_cu
);
23096 dump_die_for_error (src_die
);
23097 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23098 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23104 /* Follow reference OFFSET.
23105 On entry *REF_CU is the CU of the source die referencing OFFSET.
23106 On exit *REF_CU is the CU of the result.
23107 Returns NULL if OFFSET is invalid. */
23109 static struct die_info
*
23110 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
23111 struct dwarf2_cu
**ref_cu
)
23113 struct die_info temp_die
;
23114 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
23115 struct dwarf2_per_objfile
*dwarf2_per_objfile
23116 = cu
->per_cu
->dwarf2_per_objfile
;
23118 gdb_assert (cu
->per_cu
!= NULL
);
23122 if (cu
->per_cu
->is_debug_types
)
23124 /* .debug_types CUs cannot reference anything outside their CU.
23125 If they need to, they have to reference a signatured type via
23126 DW_FORM_ref_sig8. */
23127 if (!offset_in_cu_p (&cu
->header
, sect_off
))
23130 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
23131 || !offset_in_cu_p (&cu
->header
, sect_off
))
23133 struct dwarf2_per_cu_data
*per_cu
;
23135 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
23136 dwarf2_per_objfile
);
23138 /* If necessary, add it to the queue and load its DIEs. */
23139 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
23140 load_full_comp_unit (per_cu
, false, cu
->language
);
23142 target_cu
= per_cu
->cu
;
23144 else if (cu
->dies
== NULL
)
23146 /* We're loading full DIEs during partial symbol reading. */
23147 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
23148 load_full_comp_unit (cu
->per_cu
, false, language_minimal
);
23151 *ref_cu
= target_cu
;
23152 temp_die
.sect_off
= sect_off
;
23154 if (target_cu
!= cu
)
23155 target_cu
->ancestor
= cu
;
23157 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
23159 to_underlying (sect_off
));
23162 /* Follow reference attribute ATTR of SRC_DIE.
23163 On entry *REF_CU is the CU of SRC_DIE.
23164 On exit *REF_CU is the CU of the result. */
23166 static struct die_info
*
23167 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
23168 struct dwarf2_cu
**ref_cu
)
23170 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
23171 struct dwarf2_cu
*cu
= *ref_cu
;
23172 struct die_info
*die
;
23174 die
= follow_die_offset (sect_off
,
23175 (attr
->form
== DW_FORM_GNU_ref_alt
23176 || cu
->per_cu
->is_dwz
),
23179 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23180 "at %s [in module %s]"),
23181 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
23182 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
23187 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23188 Returned value is intended for DW_OP_call*. Returned
23189 dwarf2_locexpr_baton->data has lifetime of
23190 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
23192 struct dwarf2_locexpr_baton
23193 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
23194 struct dwarf2_per_cu_data
*per_cu
,
23195 CORE_ADDR (*get_frame_pc
) (void *baton
),
23196 void *baton
, bool resolve_abstract_p
)
23198 struct dwarf2_cu
*cu
;
23199 struct die_info
*die
;
23200 struct attribute
*attr
;
23201 struct dwarf2_locexpr_baton retval
;
23202 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
23203 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
23205 if (per_cu
->cu
== NULL
)
23206 load_cu (per_cu
, false);
23210 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23211 Instead just throw an error, not much else we can do. */
23212 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23213 sect_offset_str (sect_off
), objfile_name (objfile
));
23216 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23218 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23219 sect_offset_str (sect_off
), objfile_name (objfile
));
23221 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23222 if (!attr
&& resolve_abstract_p
23223 && (dwarf2_per_objfile
->abstract_to_concrete
.find (die
->sect_off
)
23224 != dwarf2_per_objfile
->abstract_to_concrete
.end ()))
23226 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
23228 for (const auto &cand_off
23229 : dwarf2_per_objfile
->abstract_to_concrete
[die
->sect_off
])
23231 struct dwarf2_cu
*cand_cu
= cu
;
23232 struct die_info
*cand
23233 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23236 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23239 CORE_ADDR pc_low
, pc_high
;
23240 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23241 if (pc_low
== ((CORE_ADDR
) -1)
23242 || !(pc_low
<= pc
&& pc
< pc_high
))
23246 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23253 /* DWARF: "If there is no such attribute, then there is no effect.".
23254 DATA is ignored if SIZE is 0. */
23256 retval
.data
= NULL
;
23259 else if (attr_form_is_section_offset (attr
))
23261 struct dwarf2_loclist_baton loclist_baton
;
23262 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
23265 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23267 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23269 retval
.size
= size
;
23273 if (!attr_form_is_block (attr
))
23274 error (_("Dwarf Error: DIE at %s referenced in module %s "
23275 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23276 sect_offset_str (sect_off
), objfile_name (objfile
));
23278 retval
.data
= DW_BLOCK (attr
)->data
;
23279 retval
.size
= DW_BLOCK (attr
)->size
;
23281 retval
.per_cu
= cu
->per_cu
;
23283 age_cached_comp_units (dwarf2_per_objfile
);
23288 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23291 struct dwarf2_locexpr_baton
23292 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23293 struct dwarf2_per_cu_data
*per_cu
,
23294 CORE_ADDR (*get_frame_pc
) (void *baton
),
23297 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23299 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, get_frame_pc
, baton
);
23302 /* Write a constant of a given type as target-ordered bytes into
23305 static const gdb_byte
*
23306 write_constant_as_bytes (struct obstack
*obstack
,
23307 enum bfd_endian byte_order
,
23314 *len
= TYPE_LENGTH (type
);
23315 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23316 store_unsigned_integer (result
, *len
, byte_order
, value
);
23321 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23322 pointer to the constant bytes and set LEN to the length of the
23323 data. If memory is needed, allocate it on OBSTACK. If the DIE
23324 does not have a DW_AT_const_value, return NULL. */
23327 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23328 struct dwarf2_per_cu_data
*per_cu
,
23329 struct obstack
*obstack
,
23332 struct dwarf2_cu
*cu
;
23333 struct die_info
*die
;
23334 struct attribute
*attr
;
23335 const gdb_byte
*result
= NULL
;
23338 enum bfd_endian byte_order
;
23339 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
23341 if (per_cu
->cu
== NULL
)
23342 load_cu (per_cu
, false);
23346 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23347 Instead just throw an error, not much else we can do. */
23348 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23349 sect_offset_str (sect_off
), objfile_name (objfile
));
23352 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23354 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23355 sect_offset_str (sect_off
), objfile_name (objfile
));
23357 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23361 byte_order
= (bfd_big_endian (objfile
->obfd
)
23362 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23364 switch (attr
->form
)
23367 case DW_FORM_addrx
:
23368 case DW_FORM_GNU_addr_index
:
23372 *len
= cu
->header
.addr_size
;
23373 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23374 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
23378 case DW_FORM_string
:
23381 case DW_FORM_GNU_str_index
:
23382 case DW_FORM_GNU_strp_alt
:
23383 /* DW_STRING is already allocated on the objfile obstack, point
23385 result
= (const gdb_byte
*) DW_STRING (attr
);
23386 *len
= strlen (DW_STRING (attr
));
23388 case DW_FORM_block1
:
23389 case DW_FORM_block2
:
23390 case DW_FORM_block4
:
23391 case DW_FORM_block
:
23392 case DW_FORM_exprloc
:
23393 case DW_FORM_data16
:
23394 result
= DW_BLOCK (attr
)->data
;
23395 *len
= DW_BLOCK (attr
)->size
;
23398 /* The DW_AT_const_value attributes are supposed to carry the
23399 symbol's value "represented as it would be on the target
23400 architecture." By the time we get here, it's already been
23401 converted to host endianness, so we just need to sign- or
23402 zero-extend it as appropriate. */
23403 case DW_FORM_data1
:
23404 type
= die_type (die
, cu
);
23405 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23406 if (result
== NULL
)
23407 result
= write_constant_as_bytes (obstack
, byte_order
,
23410 case DW_FORM_data2
:
23411 type
= die_type (die
, cu
);
23412 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23413 if (result
== NULL
)
23414 result
= write_constant_as_bytes (obstack
, byte_order
,
23417 case DW_FORM_data4
:
23418 type
= die_type (die
, cu
);
23419 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23420 if (result
== NULL
)
23421 result
= write_constant_as_bytes (obstack
, byte_order
,
23424 case DW_FORM_data8
:
23425 type
= die_type (die
, cu
);
23426 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23427 if (result
== NULL
)
23428 result
= write_constant_as_bytes (obstack
, byte_order
,
23432 case DW_FORM_sdata
:
23433 case DW_FORM_implicit_const
:
23434 type
= die_type (die
, cu
);
23435 result
= write_constant_as_bytes (obstack
, byte_order
,
23436 type
, DW_SND (attr
), len
);
23439 case DW_FORM_udata
:
23440 type
= die_type (die
, cu
);
23441 result
= write_constant_as_bytes (obstack
, byte_order
,
23442 type
, DW_UNSND (attr
), len
);
23446 complaint (_("unsupported const value attribute form: '%s'"),
23447 dwarf_form_name (attr
->form
));
23454 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23455 valid type for this die is found. */
23458 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
23459 struct dwarf2_per_cu_data
*per_cu
)
23461 struct dwarf2_cu
*cu
;
23462 struct die_info
*die
;
23464 if (per_cu
->cu
== NULL
)
23465 load_cu (per_cu
, false);
23470 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23474 return die_type (die
, cu
);
23477 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23481 dwarf2_get_die_type (cu_offset die_offset
,
23482 struct dwarf2_per_cu_data
*per_cu
)
23484 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
23485 return get_die_type_at_offset (die_offset_sect
, per_cu
);
23488 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23489 On entry *REF_CU is the CU of SRC_DIE.
23490 On exit *REF_CU is the CU of the result.
23491 Returns NULL if the referenced DIE isn't found. */
23493 static struct die_info
*
23494 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
23495 struct dwarf2_cu
**ref_cu
)
23497 struct die_info temp_die
;
23498 struct dwarf2_cu
*sig_cu
, *cu
= *ref_cu
;
23499 struct die_info
*die
;
23501 /* While it might be nice to assert sig_type->type == NULL here,
23502 we can get here for DW_AT_imported_declaration where we need
23503 the DIE not the type. */
23505 /* If necessary, add it to the queue and load its DIEs. */
23507 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
23508 read_signatured_type (sig_type
);
23510 sig_cu
= sig_type
->per_cu
.cu
;
23511 gdb_assert (sig_cu
!= NULL
);
23512 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
23513 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
23514 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
23515 to_underlying (temp_die
.sect_off
));
23518 struct dwarf2_per_objfile
*dwarf2_per_objfile
23519 = (*ref_cu
)->per_cu
->dwarf2_per_objfile
;
23521 /* For .gdb_index version 7 keep track of included TUs.
23522 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23523 if (dwarf2_per_objfile
->index_table
!= NULL
23524 && dwarf2_per_objfile
->index_table
->version
<= 7)
23526 VEC_safe_push (dwarf2_per_cu_ptr
,
23527 (*ref_cu
)->per_cu
->imported_symtabs
,
23533 sig_cu
->ancestor
= cu
;
23541 /* Follow signatured type referenced by ATTR in SRC_DIE.
23542 On entry *REF_CU is the CU of SRC_DIE.
23543 On exit *REF_CU is the CU of the result.
23544 The result is the DIE of the type.
23545 If the referenced type cannot be found an error is thrown. */
23547 static struct die_info
*
23548 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23549 struct dwarf2_cu
**ref_cu
)
23551 ULONGEST signature
= DW_SIGNATURE (attr
);
23552 struct signatured_type
*sig_type
;
23553 struct die_info
*die
;
23555 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
23557 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
23558 /* sig_type will be NULL if the signatured type is missing from
23560 if (sig_type
== NULL
)
23562 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23563 " from DIE at %s [in module %s]"),
23564 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23565 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23568 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
23571 dump_die_for_error (src_die
);
23572 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23573 " from DIE at %s [in module %s]"),
23574 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23575 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23581 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23582 reading in and processing the type unit if necessary. */
23584 static struct type
*
23585 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
23586 struct dwarf2_cu
*cu
)
23588 struct dwarf2_per_objfile
*dwarf2_per_objfile
23589 = cu
->per_cu
->dwarf2_per_objfile
;
23590 struct signatured_type
*sig_type
;
23591 struct dwarf2_cu
*type_cu
;
23592 struct die_info
*type_die
;
23595 sig_type
= lookup_signatured_type (cu
, signature
);
23596 /* sig_type will be NULL if the signatured type is missing from
23598 if (sig_type
== NULL
)
23600 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23601 " from DIE at %s [in module %s]"),
23602 hex_string (signature
), sect_offset_str (die
->sect_off
),
23603 objfile_name (dwarf2_per_objfile
->objfile
));
23604 return build_error_marker_type (cu
, die
);
23607 /* If we already know the type we're done. */
23608 if (sig_type
->type
!= NULL
)
23609 return sig_type
->type
;
23612 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
23613 if (type_die
!= NULL
)
23615 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23616 is created. This is important, for example, because for c++ classes
23617 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23618 type
= read_type_die (type_die
, type_cu
);
23621 complaint (_("Dwarf Error: Cannot build signatured type %s"
23622 " referenced from DIE at %s [in module %s]"),
23623 hex_string (signature
), sect_offset_str (die
->sect_off
),
23624 objfile_name (dwarf2_per_objfile
->objfile
));
23625 type
= build_error_marker_type (cu
, die
);
23630 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23631 " from DIE at %s [in module %s]"),
23632 hex_string (signature
), sect_offset_str (die
->sect_off
),
23633 objfile_name (dwarf2_per_objfile
->objfile
));
23634 type
= build_error_marker_type (cu
, die
);
23636 sig_type
->type
= type
;
23641 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23642 reading in and processing the type unit if necessary. */
23644 static struct type
*
23645 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
23646 struct dwarf2_cu
*cu
) /* ARI: editCase function */
23648 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23649 if (attr_form_is_ref (attr
))
23651 struct dwarf2_cu
*type_cu
= cu
;
23652 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
23654 return read_type_die (type_die
, type_cu
);
23656 else if (attr
->form
== DW_FORM_ref_sig8
)
23658 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
23662 struct dwarf2_per_objfile
*dwarf2_per_objfile
23663 = cu
->per_cu
->dwarf2_per_objfile
;
23665 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23666 " at %s [in module %s]"),
23667 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
23668 objfile_name (dwarf2_per_objfile
->objfile
));
23669 return build_error_marker_type (cu
, die
);
23673 /* Load the DIEs associated with type unit PER_CU into memory. */
23676 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
23678 struct signatured_type
*sig_type
;
23680 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23681 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
23683 /* We have the per_cu, but we need the signatured_type.
23684 Fortunately this is an easy translation. */
23685 gdb_assert (per_cu
->is_debug_types
);
23686 sig_type
= (struct signatured_type
*) per_cu
;
23688 gdb_assert (per_cu
->cu
== NULL
);
23690 read_signatured_type (sig_type
);
23692 gdb_assert (per_cu
->cu
!= NULL
);
23695 /* die_reader_func for read_signatured_type.
23696 This is identical to load_full_comp_unit_reader,
23697 but is kept separate for now. */
23700 read_signatured_type_reader (const struct die_reader_specs
*reader
,
23701 const gdb_byte
*info_ptr
,
23702 struct die_info
*comp_unit_die
,
23706 struct dwarf2_cu
*cu
= reader
->cu
;
23708 gdb_assert (cu
->die_hash
== NULL
);
23710 htab_create_alloc_ex (cu
->header
.length
/ 12,
23714 &cu
->comp_unit_obstack
,
23715 hashtab_obstack_allocate
,
23716 dummy_obstack_deallocate
);
23719 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
23720 &info_ptr
, comp_unit_die
);
23721 cu
->dies
= comp_unit_die
;
23722 /* comp_unit_die is not stored in die_hash, no need. */
23724 /* We try not to read any attributes in this function, because not
23725 all CUs needed for references have been loaded yet, and symbol
23726 table processing isn't initialized. But we have to set the CU language,
23727 or we won't be able to build types correctly.
23728 Similarly, if we do not read the producer, we can not apply
23729 producer-specific interpretation. */
23730 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
23733 /* Read in a signatured type and build its CU and DIEs.
23734 If the type is a stub for the real type in a DWO file,
23735 read in the real type from the DWO file as well. */
23738 read_signatured_type (struct signatured_type
*sig_type
)
23740 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
23742 gdb_assert (per_cu
->is_debug_types
);
23743 gdb_assert (per_cu
->cu
== NULL
);
23745 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1, false,
23746 read_signatured_type_reader
, NULL
);
23747 sig_type
->per_cu
.tu_read
= 1;
23750 /* Decode simple location descriptions.
23751 Given a pointer to a dwarf block that defines a location, compute
23752 the location and return the value.
23754 NOTE drow/2003-11-18: This function is called in two situations
23755 now: for the address of static or global variables (partial symbols
23756 only) and for offsets into structures which are expected to be
23757 (more or less) constant. The partial symbol case should go away,
23758 and only the constant case should remain. That will let this
23759 function complain more accurately. A few special modes are allowed
23760 without complaint for global variables (for instance, global
23761 register values and thread-local values).
23763 A location description containing no operations indicates that the
23764 object is optimized out. The return value is 0 for that case.
23765 FIXME drow/2003-11-16: No callers check for this case any more; soon all
23766 callers will only want a very basic result and this can become a
23769 Note that stack[0] is unused except as a default error return. */
23772 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
23774 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
23776 size_t size
= blk
->size
;
23777 const gdb_byte
*data
= blk
->data
;
23778 CORE_ADDR stack
[64];
23780 unsigned int bytes_read
, unsnd
;
23786 stack
[++stacki
] = 0;
23825 stack
[++stacki
] = op
- DW_OP_lit0
;
23860 stack
[++stacki
] = op
- DW_OP_reg0
;
23862 dwarf2_complex_location_expr_complaint ();
23866 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
23868 stack
[++stacki
] = unsnd
;
23870 dwarf2_complex_location_expr_complaint ();
23874 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
23879 case DW_OP_const1u
:
23880 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
23884 case DW_OP_const1s
:
23885 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
23889 case DW_OP_const2u
:
23890 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
23894 case DW_OP_const2s
:
23895 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
23899 case DW_OP_const4u
:
23900 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
23904 case DW_OP_const4s
:
23905 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
23909 case DW_OP_const8u
:
23910 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
23915 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
23921 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
23926 stack
[stacki
+ 1] = stack
[stacki
];
23931 stack
[stacki
- 1] += stack
[stacki
];
23935 case DW_OP_plus_uconst
:
23936 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
23942 stack
[stacki
- 1] -= stack
[stacki
];
23947 /* If we're not the last op, then we definitely can't encode
23948 this using GDB's address_class enum. This is valid for partial
23949 global symbols, although the variable's address will be bogus
23952 dwarf2_complex_location_expr_complaint ();
23955 case DW_OP_GNU_push_tls_address
:
23956 case DW_OP_form_tls_address
:
23957 /* The top of the stack has the offset from the beginning
23958 of the thread control block at which the variable is located. */
23959 /* Nothing should follow this operator, so the top of stack would
23961 /* This is valid for partial global symbols, but the variable's
23962 address will be bogus in the psymtab. Make it always at least
23963 non-zero to not look as a variable garbage collected by linker
23964 which have DW_OP_addr 0. */
23966 dwarf2_complex_location_expr_complaint ();
23970 case DW_OP_GNU_uninit
:
23974 case DW_OP_GNU_addr_index
:
23975 case DW_OP_GNU_const_index
:
23976 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
23983 const char *name
= get_DW_OP_name (op
);
23986 complaint (_("unsupported stack op: '%s'"),
23989 complaint (_("unsupported stack op: '%02x'"),
23993 return (stack
[stacki
]);
23996 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23997 outside of the allocated space. Also enforce minimum>0. */
23998 if (stacki
>= ARRAY_SIZE (stack
) - 1)
24000 complaint (_("location description stack overflow"));
24006 complaint (_("location description stack underflow"));
24010 return (stack
[stacki
]);
24013 /* memory allocation interface */
24015 static struct dwarf_block
*
24016 dwarf_alloc_block (struct dwarf2_cu
*cu
)
24018 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
24021 static struct die_info
*
24022 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
24024 struct die_info
*die
;
24025 size_t size
= sizeof (struct die_info
);
24028 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
24030 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
24031 memset (die
, 0, sizeof (struct die_info
));
24036 /* Macro support. */
24038 /* Return file name relative to the compilation directory of file number I in
24039 *LH's file name table. The result is allocated using xmalloc; the caller is
24040 responsible for freeing it. */
24043 file_file_name (int file
, struct line_header
*lh
)
24045 /* Is the file number a valid index into the line header's file name
24046 table? Remember that file numbers start with one, not zero. */
24047 if (1 <= file
&& file
<= lh
->file_names
.size ())
24049 const file_entry
&fe
= lh
->file_names
[file
- 1];
24051 if (!IS_ABSOLUTE_PATH (fe
.name
))
24053 const char *dir
= fe
.include_dir (lh
);
24055 return concat (dir
, SLASH_STRING
, fe
.name
, (char *) NULL
);
24057 return xstrdup (fe
.name
);
24061 /* The compiler produced a bogus file number. We can at least
24062 record the macro definitions made in the file, even if we
24063 won't be able to find the file by name. */
24064 char fake_name
[80];
24066 xsnprintf (fake_name
, sizeof (fake_name
),
24067 "<bad macro file number %d>", file
);
24069 complaint (_("bad file number in macro information (%d)"),
24072 return xstrdup (fake_name
);
24076 /* Return the full name of file number I in *LH's file name table.
24077 Use COMP_DIR as the name of the current directory of the
24078 compilation. The result is allocated using xmalloc; the caller is
24079 responsible for freeing it. */
24081 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
24083 /* Is the file number a valid index into the line header's file name
24084 table? Remember that file numbers start with one, not zero. */
24085 if (1 <= file
&& file
<= lh
->file_names
.size ())
24087 char *relative
= file_file_name (file
, lh
);
24089 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
24091 return reconcat (relative
, comp_dir
, SLASH_STRING
,
24092 relative
, (char *) NULL
);
24095 return file_file_name (file
, lh
);
24099 static struct macro_source_file
*
24100 macro_start_file (struct dwarf2_cu
*cu
,
24101 int file
, int line
,
24102 struct macro_source_file
*current_file
,
24103 struct line_header
*lh
)
24105 /* File name relative to the compilation directory of this source file. */
24106 char *file_name
= file_file_name (file
, lh
);
24108 if (! current_file
)
24110 /* Note: We don't create a macro table for this compilation unit
24111 at all until we actually get a filename. */
24112 struct macro_table
*macro_table
= cu
->get_builder ()->get_macro_table ();
24114 /* If we have no current file, then this must be the start_file
24115 directive for the compilation unit's main source file. */
24116 current_file
= macro_set_main (macro_table
, file_name
);
24117 macro_define_special (macro_table
);
24120 current_file
= macro_include (current_file
, line
, file_name
);
24124 return current_file
;
24127 static const char *
24128 consume_improper_spaces (const char *p
, const char *body
)
24132 complaint (_("macro definition contains spaces "
24133 "in formal argument list:\n`%s'"),
24145 parse_macro_definition (struct macro_source_file
*file
, int line
,
24150 /* The body string takes one of two forms. For object-like macro
24151 definitions, it should be:
24153 <macro name> " " <definition>
24155 For function-like macro definitions, it should be:
24157 <macro name> "() " <definition>
24159 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24161 Spaces may appear only where explicitly indicated, and in the
24164 The Dwarf 2 spec says that an object-like macro's name is always
24165 followed by a space, but versions of GCC around March 2002 omit
24166 the space when the macro's definition is the empty string.
24168 The Dwarf 2 spec says that there should be no spaces between the
24169 formal arguments in a function-like macro's formal argument list,
24170 but versions of GCC around March 2002 include spaces after the
24174 /* Find the extent of the macro name. The macro name is terminated
24175 by either a space or null character (for an object-like macro) or
24176 an opening paren (for a function-like macro). */
24177 for (p
= body
; *p
; p
++)
24178 if (*p
== ' ' || *p
== '(')
24181 if (*p
== ' ' || *p
== '\0')
24183 /* It's an object-like macro. */
24184 int name_len
= p
- body
;
24185 char *name
= savestring (body
, name_len
);
24186 const char *replacement
;
24189 replacement
= body
+ name_len
+ 1;
24192 dwarf2_macro_malformed_definition_complaint (body
);
24193 replacement
= body
+ name_len
;
24196 macro_define_object (file
, line
, name
, replacement
);
24200 else if (*p
== '(')
24202 /* It's a function-like macro. */
24203 char *name
= savestring (body
, p
- body
);
24206 char **argv
= XNEWVEC (char *, argv_size
);
24210 p
= consume_improper_spaces (p
, body
);
24212 /* Parse the formal argument list. */
24213 while (*p
&& *p
!= ')')
24215 /* Find the extent of the current argument name. */
24216 const char *arg_start
= p
;
24218 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
24221 if (! *p
|| p
== arg_start
)
24222 dwarf2_macro_malformed_definition_complaint (body
);
24225 /* Make sure argv has room for the new argument. */
24226 if (argc
>= argv_size
)
24229 argv
= XRESIZEVEC (char *, argv
, argv_size
);
24232 argv
[argc
++] = savestring (arg_start
, p
- arg_start
);
24235 p
= consume_improper_spaces (p
, body
);
24237 /* Consume the comma, if present. */
24242 p
= consume_improper_spaces (p
, body
);
24251 /* Perfectly formed definition, no complaints. */
24252 macro_define_function (file
, line
, name
,
24253 argc
, (const char **) argv
,
24255 else if (*p
== '\0')
24257 /* Complain, but do define it. */
24258 dwarf2_macro_malformed_definition_complaint (body
);
24259 macro_define_function (file
, line
, name
,
24260 argc
, (const char **) argv
,
24264 /* Just complain. */
24265 dwarf2_macro_malformed_definition_complaint (body
);
24268 /* Just complain. */
24269 dwarf2_macro_malformed_definition_complaint (body
);
24275 for (i
= 0; i
< argc
; i
++)
24281 dwarf2_macro_malformed_definition_complaint (body
);
24284 /* Skip some bytes from BYTES according to the form given in FORM.
24285 Returns the new pointer. */
24287 static const gdb_byte
*
24288 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
24289 enum dwarf_form form
,
24290 unsigned int offset_size
,
24291 struct dwarf2_section_info
*section
)
24293 unsigned int bytes_read
;
24297 case DW_FORM_data1
:
24302 case DW_FORM_data2
:
24306 case DW_FORM_data4
:
24310 case DW_FORM_data8
:
24314 case DW_FORM_data16
:
24318 case DW_FORM_string
:
24319 read_direct_string (abfd
, bytes
, &bytes_read
);
24320 bytes
+= bytes_read
;
24323 case DW_FORM_sec_offset
:
24325 case DW_FORM_GNU_strp_alt
:
24326 bytes
+= offset_size
;
24329 case DW_FORM_block
:
24330 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
24331 bytes
+= bytes_read
;
24334 case DW_FORM_block1
:
24335 bytes
+= 1 + read_1_byte (abfd
, bytes
);
24337 case DW_FORM_block2
:
24338 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
24340 case DW_FORM_block4
:
24341 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
24344 case DW_FORM_addrx
:
24345 case DW_FORM_sdata
:
24347 case DW_FORM_udata
:
24348 case DW_FORM_GNU_addr_index
:
24349 case DW_FORM_GNU_str_index
:
24350 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
24353 dwarf2_section_buffer_overflow_complaint (section
);
24358 case DW_FORM_implicit_const
:
24363 complaint (_("invalid form 0x%x in `%s'"),
24364 form
, get_section_name (section
));
24372 /* A helper for dwarf_decode_macros that handles skipping an unknown
24373 opcode. Returns an updated pointer to the macro data buffer; or,
24374 on error, issues a complaint and returns NULL. */
24376 static const gdb_byte
*
24377 skip_unknown_opcode (unsigned int opcode
,
24378 const gdb_byte
**opcode_definitions
,
24379 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
24381 unsigned int offset_size
,
24382 struct dwarf2_section_info
*section
)
24384 unsigned int bytes_read
, i
;
24386 const gdb_byte
*defn
;
24388 if (opcode_definitions
[opcode
] == NULL
)
24390 complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24395 defn
= opcode_definitions
[opcode
];
24396 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
24397 defn
+= bytes_read
;
24399 for (i
= 0; i
< arg
; ++i
)
24401 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
,
24402 (enum dwarf_form
) defn
[i
], offset_size
,
24404 if (mac_ptr
== NULL
)
24406 /* skip_form_bytes already issued the complaint. */
24414 /* A helper function which parses the header of a macro section.
24415 If the macro section is the extended (for now called "GNU") type,
24416 then this updates *OFFSET_SIZE. Returns a pointer to just after
24417 the header, or issues a complaint and returns NULL on error. */
24419 static const gdb_byte
*
24420 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
24422 const gdb_byte
*mac_ptr
,
24423 unsigned int *offset_size
,
24424 int section_is_gnu
)
24426 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
24428 if (section_is_gnu
)
24430 unsigned int version
, flags
;
24432 version
= read_2_bytes (abfd
, mac_ptr
);
24433 if (version
!= 4 && version
!= 5)
24435 complaint (_("unrecognized version `%d' in .debug_macro section"),
24441 flags
= read_1_byte (abfd
, mac_ptr
);
24443 *offset_size
= (flags
& 1) ? 8 : 4;
24445 if ((flags
& 2) != 0)
24446 /* We don't need the line table offset. */
24447 mac_ptr
+= *offset_size
;
24449 /* Vendor opcode descriptions. */
24450 if ((flags
& 4) != 0)
24452 unsigned int i
, count
;
24454 count
= read_1_byte (abfd
, mac_ptr
);
24456 for (i
= 0; i
< count
; ++i
)
24458 unsigned int opcode
, bytes_read
;
24461 opcode
= read_1_byte (abfd
, mac_ptr
);
24463 opcode_definitions
[opcode
] = mac_ptr
;
24464 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24465 mac_ptr
+= bytes_read
;
24474 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24475 including DW_MACRO_import. */
24478 dwarf_decode_macro_bytes (struct dwarf2_cu
*cu
,
24480 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
24481 struct macro_source_file
*current_file
,
24482 struct line_header
*lh
,
24483 struct dwarf2_section_info
*section
,
24484 int section_is_gnu
, int section_is_dwz
,
24485 unsigned int offset_size
,
24486 htab_t include_hash
)
24488 struct dwarf2_per_objfile
*dwarf2_per_objfile
24489 = cu
->per_cu
->dwarf2_per_objfile
;
24490 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24491 enum dwarf_macro_record_type macinfo_type
;
24492 int at_commandline
;
24493 const gdb_byte
*opcode_definitions
[256];
24495 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
24496 &offset_size
, section_is_gnu
);
24497 if (mac_ptr
== NULL
)
24499 /* We already issued a complaint. */
24503 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24504 GDB is still reading the definitions from command line. First
24505 DW_MACINFO_start_file will need to be ignored as it was already executed
24506 to create CURRENT_FILE for the main source holding also the command line
24507 definitions. On first met DW_MACINFO_start_file this flag is reset to
24508 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24510 at_commandline
= 1;
24514 /* Do we at least have room for a macinfo type byte? */
24515 if (mac_ptr
>= mac_end
)
24517 dwarf2_section_buffer_overflow_complaint (section
);
24521 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
24524 /* Note that we rely on the fact that the corresponding GNU and
24525 DWARF constants are the same. */
24527 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24528 switch (macinfo_type
)
24530 /* A zero macinfo type indicates the end of the macro
24535 case DW_MACRO_define
:
24536 case DW_MACRO_undef
:
24537 case DW_MACRO_define_strp
:
24538 case DW_MACRO_undef_strp
:
24539 case DW_MACRO_define_sup
:
24540 case DW_MACRO_undef_sup
:
24542 unsigned int bytes_read
;
24547 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24548 mac_ptr
+= bytes_read
;
24550 if (macinfo_type
== DW_MACRO_define
24551 || macinfo_type
== DW_MACRO_undef
)
24553 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24554 mac_ptr
+= bytes_read
;
24558 LONGEST str_offset
;
24560 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
24561 mac_ptr
+= offset_size
;
24563 if (macinfo_type
== DW_MACRO_define_sup
24564 || macinfo_type
== DW_MACRO_undef_sup
24567 struct dwz_file
*dwz
24568 = dwarf2_get_dwz_file (dwarf2_per_objfile
);
24570 body
= read_indirect_string_from_dwz (objfile
,
24574 body
= read_indirect_string_at_offset (dwarf2_per_objfile
,
24578 is_define
= (macinfo_type
== DW_MACRO_define
24579 || macinfo_type
== DW_MACRO_define_strp
24580 || macinfo_type
== DW_MACRO_define_sup
);
24581 if (! current_file
)
24583 /* DWARF violation as no main source is present. */
24584 complaint (_("debug info with no main source gives macro %s "
24586 is_define
? _("definition") : _("undefinition"),
24590 if ((line
== 0 && !at_commandline
)
24591 || (line
!= 0 && at_commandline
))
24592 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24593 at_commandline
? _("command-line") : _("in-file"),
24594 is_define
? _("definition") : _("undefinition"),
24595 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
24599 /* Fedora's rpm-build's "debugedit" binary
24600 corrupted .debug_macro sections.
24603 https://bugzilla.redhat.com/show_bug.cgi?id=1708786 */
24604 complaint (_("debug info gives %s invalid macro %s "
24605 "without body (corrupted?) at line %d "
24607 at_commandline
? _("command-line") : _("in-file"),
24608 is_define
? _("definition") : _("undefinition"),
24609 line
, current_file
->filename
);
24611 else if (is_define
)
24612 parse_macro_definition (current_file
, line
, body
);
24615 gdb_assert (macinfo_type
== DW_MACRO_undef
24616 || macinfo_type
== DW_MACRO_undef_strp
24617 || macinfo_type
== DW_MACRO_undef_sup
);
24618 macro_undef (current_file
, line
, body
);
24623 case DW_MACRO_start_file
:
24625 unsigned int bytes_read
;
24628 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24629 mac_ptr
+= bytes_read
;
24630 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24631 mac_ptr
+= bytes_read
;
24633 if ((line
== 0 && !at_commandline
)
24634 || (line
!= 0 && at_commandline
))
24635 complaint (_("debug info gives source %d included "
24636 "from %s at %s line %d"),
24637 file
, at_commandline
? _("command-line") : _("file"),
24638 line
== 0 ? _("zero") : _("non-zero"), line
);
24640 if (at_commandline
)
24642 /* This DW_MACRO_start_file was executed in the
24644 at_commandline
= 0;
24647 current_file
= macro_start_file (cu
, file
, line
, current_file
,
24652 case DW_MACRO_end_file
:
24653 if (! current_file
)
24654 complaint (_("macro debug info has an unmatched "
24655 "`close_file' directive"));
24658 current_file
= current_file
->included_by
;
24659 if (! current_file
)
24661 enum dwarf_macro_record_type next_type
;
24663 /* GCC circa March 2002 doesn't produce the zero
24664 type byte marking the end of the compilation
24665 unit. Complain if it's not there, but exit no
24668 /* Do we at least have room for a macinfo type byte? */
24669 if (mac_ptr
>= mac_end
)
24671 dwarf2_section_buffer_overflow_complaint (section
);
24675 /* We don't increment mac_ptr here, so this is just
24678 = (enum dwarf_macro_record_type
) read_1_byte (abfd
,
24680 if (next_type
!= 0)
24681 complaint (_("no terminating 0-type entry for "
24682 "macros in `.debug_macinfo' section"));
24689 case DW_MACRO_import
:
24690 case DW_MACRO_import_sup
:
24694 bfd
*include_bfd
= abfd
;
24695 struct dwarf2_section_info
*include_section
= section
;
24696 const gdb_byte
*include_mac_end
= mac_end
;
24697 int is_dwz
= section_is_dwz
;
24698 const gdb_byte
*new_mac_ptr
;
24700 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
24701 mac_ptr
+= offset_size
;
24703 if (macinfo_type
== DW_MACRO_import_sup
)
24705 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
24707 dwarf2_read_section (objfile
, &dwz
->macro
);
24709 include_section
= &dwz
->macro
;
24710 include_bfd
= get_section_bfd_owner (include_section
);
24711 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
24715 new_mac_ptr
= include_section
->buffer
+ offset
;
24716 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
24720 /* This has actually happened; see
24721 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
24722 complaint (_("recursive DW_MACRO_import in "
24723 ".debug_macro section"));
24727 *slot
= (void *) new_mac_ptr
;
24729 dwarf_decode_macro_bytes (cu
, include_bfd
, new_mac_ptr
,
24730 include_mac_end
, current_file
, lh
,
24731 section
, section_is_gnu
, is_dwz
,
24732 offset_size
, include_hash
);
24734 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
24739 case DW_MACINFO_vendor_ext
:
24740 if (!section_is_gnu
)
24742 unsigned int bytes_read
;
24744 /* This reads the constant, but since we don't recognize
24745 any vendor extensions, we ignore it. */
24746 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24747 mac_ptr
+= bytes_read
;
24748 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24749 mac_ptr
+= bytes_read
;
24751 /* We don't recognize any vendor extensions. */
24757 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
24758 mac_ptr
, mac_end
, abfd
, offset_size
,
24760 if (mac_ptr
== NULL
)
24765 } while (macinfo_type
!= 0);
24769 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
24770 int section_is_gnu
)
24772 struct dwarf2_per_objfile
*dwarf2_per_objfile
24773 = cu
->per_cu
->dwarf2_per_objfile
;
24774 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24775 struct line_header
*lh
= cu
->line_header
;
24777 const gdb_byte
*mac_ptr
, *mac_end
;
24778 struct macro_source_file
*current_file
= 0;
24779 enum dwarf_macro_record_type macinfo_type
;
24780 unsigned int offset_size
= cu
->header
.offset_size
;
24781 const gdb_byte
*opcode_definitions
[256];
24783 struct dwarf2_section_info
*section
;
24784 const char *section_name
;
24786 if (cu
->dwo_unit
!= NULL
)
24788 if (section_is_gnu
)
24790 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
24791 section_name
= ".debug_macro.dwo";
24795 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
24796 section_name
= ".debug_macinfo.dwo";
24801 if (section_is_gnu
)
24803 section
= &dwarf2_per_objfile
->macro
;
24804 section_name
= ".debug_macro";
24808 section
= &dwarf2_per_objfile
->macinfo
;
24809 section_name
= ".debug_macinfo";
24813 dwarf2_read_section (objfile
, section
);
24814 if (section
->buffer
== NULL
)
24816 complaint (_("missing %s section"), section_name
);
24819 abfd
= get_section_bfd_owner (section
);
24821 /* First pass: Find the name of the base filename.
24822 This filename is needed in order to process all macros whose definition
24823 (or undefinition) comes from the command line. These macros are defined
24824 before the first DW_MACINFO_start_file entry, and yet still need to be
24825 associated to the base file.
24827 To determine the base file name, we scan the macro definitions until we
24828 reach the first DW_MACINFO_start_file entry. We then initialize
24829 CURRENT_FILE accordingly so that any macro definition found before the
24830 first DW_MACINFO_start_file can still be associated to the base file. */
24832 mac_ptr
= section
->buffer
+ offset
;
24833 mac_end
= section
->buffer
+ section
->size
;
24835 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
24836 &offset_size
, section_is_gnu
);
24837 if (mac_ptr
== NULL
)
24839 /* We already issued a complaint. */
24845 /* Do we at least have room for a macinfo type byte? */
24846 if (mac_ptr
>= mac_end
)
24848 /* Complaint is printed during the second pass as GDB will probably
24849 stop the first pass earlier upon finding
24850 DW_MACINFO_start_file. */
24854 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
24857 /* Note that we rely on the fact that the corresponding GNU and
24858 DWARF constants are the same. */
24860 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24861 switch (macinfo_type
)
24863 /* A zero macinfo type indicates the end of the macro
24868 case DW_MACRO_define
:
24869 case DW_MACRO_undef
:
24870 /* Only skip the data by MAC_PTR. */
24872 unsigned int bytes_read
;
24874 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24875 mac_ptr
+= bytes_read
;
24876 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24877 mac_ptr
+= bytes_read
;
24881 case DW_MACRO_start_file
:
24883 unsigned int bytes_read
;
24886 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24887 mac_ptr
+= bytes_read
;
24888 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24889 mac_ptr
+= bytes_read
;
24891 current_file
= macro_start_file (cu
, file
, line
, current_file
, lh
);
24895 case DW_MACRO_end_file
:
24896 /* No data to skip by MAC_PTR. */
24899 case DW_MACRO_define_strp
:
24900 case DW_MACRO_undef_strp
:
24901 case DW_MACRO_define_sup
:
24902 case DW_MACRO_undef_sup
:
24904 unsigned int bytes_read
;
24906 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24907 mac_ptr
+= bytes_read
;
24908 mac_ptr
+= offset_size
;
24912 case DW_MACRO_import
:
24913 case DW_MACRO_import_sup
:
24914 /* Note that, according to the spec, a transparent include
24915 chain cannot call DW_MACRO_start_file. So, we can just
24916 skip this opcode. */
24917 mac_ptr
+= offset_size
;
24920 case DW_MACINFO_vendor_ext
:
24921 /* Only skip the data by MAC_PTR. */
24922 if (!section_is_gnu
)
24924 unsigned int bytes_read
;
24926 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24927 mac_ptr
+= bytes_read
;
24928 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24929 mac_ptr
+= bytes_read
;
24934 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
24935 mac_ptr
, mac_end
, abfd
, offset_size
,
24937 if (mac_ptr
== NULL
)
24942 } while (macinfo_type
!= 0 && current_file
== NULL
);
24944 /* Second pass: Process all entries.
24946 Use the AT_COMMAND_LINE flag to determine whether we are still processing
24947 command-line macro definitions/undefinitions. This flag is unset when we
24948 reach the first DW_MACINFO_start_file entry. */
24950 htab_up
include_hash (htab_create_alloc (1, htab_hash_pointer
,
24952 NULL
, xcalloc
, xfree
));
24953 mac_ptr
= section
->buffer
+ offset
;
24954 slot
= htab_find_slot (include_hash
.get (), mac_ptr
, INSERT
);
24955 *slot
= (void *) mac_ptr
;
24956 dwarf_decode_macro_bytes (cu
, abfd
, mac_ptr
, mac_end
,
24957 current_file
, lh
, section
,
24958 section_is_gnu
, 0, offset_size
,
24959 include_hash
.get ());
24962 /* Check if the attribute's form is a DW_FORM_block*
24963 if so return true else false. */
24966 attr_form_is_block (const struct attribute
*attr
)
24968 return (attr
== NULL
? 0 :
24969 attr
->form
== DW_FORM_block1
24970 || attr
->form
== DW_FORM_block2
24971 || attr
->form
== DW_FORM_block4
24972 || attr
->form
== DW_FORM_block
24973 || attr
->form
== DW_FORM_exprloc
);
24976 /* Return non-zero if ATTR's value is a section offset --- classes
24977 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24978 You may use DW_UNSND (attr) to retrieve such offsets.
24980 Section 7.5.4, "Attribute Encodings", explains that no attribute
24981 may have a value that belongs to more than one of these classes; it
24982 would be ambiguous if we did, because we use the same forms for all
24986 attr_form_is_section_offset (const struct attribute
*attr
)
24988 return (attr
->form
== DW_FORM_data4
24989 || attr
->form
== DW_FORM_data8
24990 || attr
->form
== DW_FORM_sec_offset
);
24993 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24994 zero otherwise. When this function returns true, you can apply
24995 dwarf2_get_attr_constant_value to it.
24997 However, note that for some attributes you must check
24998 attr_form_is_section_offset before using this test. DW_FORM_data4
24999 and DW_FORM_data8 are members of both the constant class, and of
25000 the classes that contain offsets into other debug sections
25001 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
25002 that, if an attribute's can be either a constant or one of the
25003 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
25004 taken as section offsets, not constants.
25006 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
25007 cannot handle that. */
25010 attr_form_is_constant (const struct attribute
*attr
)
25012 switch (attr
->form
)
25014 case DW_FORM_sdata
:
25015 case DW_FORM_udata
:
25016 case DW_FORM_data1
:
25017 case DW_FORM_data2
:
25018 case DW_FORM_data4
:
25019 case DW_FORM_data8
:
25020 case DW_FORM_implicit_const
:
25028 /* DW_ADDR is always stored already as sect_offset; despite for the forms
25029 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
25032 attr_form_is_ref (const struct attribute
*attr
)
25034 switch (attr
->form
)
25036 case DW_FORM_ref_addr
:
25041 case DW_FORM_ref_udata
:
25042 case DW_FORM_GNU_ref_alt
:
25049 /* Return the .debug_loc section to use for CU.
25050 For DWO files use .debug_loc.dwo. */
25052 static struct dwarf2_section_info
*
25053 cu_debug_loc_section (struct dwarf2_cu
*cu
)
25055 struct dwarf2_per_objfile
*dwarf2_per_objfile
25056 = cu
->per_cu
->dwarf2_per_objfile
;
25060 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
25062 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
25064 return (cu
->header
.version
>= 5 ? &dwarf2_per_objfile
->loclists
25065 : &dwarf2_per_objfile
->loc
);
25068 /* A helper function that fills in a dwarf2_loclist_baton. */
25071 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
25072 struct dwarf2_loclist_baton
*baton
,
25073 const struct attribute
*attr
)
25075 struct dwarf2_per_objfile
*dwarf2_per_objfile
25076 = cu
->per_cu
->dwarf2_per_objfile
;
25077 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
25079 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
25081 baton
->per_cu
= cu
->per_cu
;
25082 gdb_assert (baton
->per_cu
);
25083 /* We don't know how long the location list is, but make sure we
25084 don't run off the edge of the section. */
25085 baton
->size
= section
->size
- DW_UNSND (attr
);
25086 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
25087 baton
->base_address
= cu
->base_address
;
25088 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
25092 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
25093 struct dwarf2_cu
*cu
, int is_block
)
25095 struct dwarf2_per_objfile
*dwarf2_per_objfile
25096 = cu
->per_cu
->dwarf2_per_objfile
;
25097 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
25098 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
25100 if (attr_form_is_section_offset (attr
)
25101 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
25102 the section. If so, fall through to the complaint in the
25104 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
25106 struct dwarf2_loclist_baton
*baton
;
25108 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
25110 fill_in_loclist_baton (cu
, baton
, attr
);
25112 if (cu
->base_known
== 0)
25113 complaint (_("Location list used without "
25114 "specifying the CU base address."));
25116 SYMBOL_ACLASS_INDEX (sym
) = (is_block
25117 ? dwarf2_loclist_block_index
25118 : dwarf2_loclist_index
);
25119 SYMBOL_LOCATION_BATON (sym
) = baton
;
25123 struct dwarf2_locexpr_baton
*baton
;
25125 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
25126 baton
->per_cu
= cu
->per_cu
;
25127 gdb_assert (baton
->per_cu
);
25129 if (attr_form_is_block (attr
))
25131 /* Note that we're just copying the block's data pointer
25132 here, not the actual data. We're still pointing into the
25133 info_buffer for SYM's objfile; right now we never release
25134 that buffer, but when we do clean up properly this may
25136 baton
->size
= DW_BLOCK (attr
)->size
;
25137 baton
->data
= DW_BLOCK (attr
)->data
;
25141 dwarf2_invalid_attrib_class_complaint ("location description",
25142 SYMBOL_NATURAL_NAME (sym
));
25146 SYMBOL_ACLASS_INDEX (sym
) = (is_block
25147 ? dwarf2_locexpr_block_index
25148 : dwarf2_locexpr_index
);
25149 SYMBOL_LOCATION_BATON (sym
) = baton
;
25153 /* Return the OBJFILE associated with the compilation unit CU. If CU
25154 came from a separate debuginfo file, then the master objfile is
25158 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
25160 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25162 /* Return the master objfile, so that we can report and look up the
25163 correct file containing this variable. */
25164 if (objfile
->separate_debug_objfile_backlink
)
25165 objfile
= objfile
->separate_debug_objfile_backlink
;
25170 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25171 (CU_HEADERP is unused in such case) or prepare a temporary copy at
25172 CU_HEADERP first. */
25174 static const struct comp_unit_head
*
25175 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
25176 struct dwarf2_per_cu_data
*per_cu
)
25178 const gdb_byte
*info_ptr
;
25181 return &per_cu
->cu
->header
;
25183 info_ptr
= per_cu
->section
->buffer
+ to_underlying (per_cu
->sect_off
);
25185 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
25186 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->section
,
25187 rcuh_kind::COMPILE
);
25192 /* Return the address size given in the compilation unit header for CU. */
25195 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
25197 struct comp_unit_head cu_header_local
;
25198 const struct comp_unit_head
*cu_headerp
;
25200 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25202 return cu_headerp
->addr_size
;
25205 /* Return the offset size given in the compilation unit header for CU. */
25208 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
25210 struct comp_unit_head cu_header_local
;
25211 const struct comp_unit_head
*cu_headerp
;
25213 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25215 return cu_headerp
->offset_size
;
25218 /* See its dwarf2loc.h declaration. */
25221 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
25223 struct comp_unit_head cu_header_local
;
25224 const struct comp_unit_head
*cu_headerp
;
25226 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25228 if (cu_headerp
->version
== 2)
25229 return cu_headerp
->addr_size
;
25231 return cu_headerp
->offset_size
;
25234 /* Return the text offset of the CU. The returned offset comes from
25235 this CU's objfile. If this objfile came from a separate debuginfo
25236 file, then the offset may be different from the corresponding
25237 offset in the parent objfile. */
25240 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
25242 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25244 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
25247 /* Return DWARF version number of PER_CU. */
25250 dwarf2_version (struct dwarf2_per_cu_data
*per_cu
)
25252 return per_cu
->dwarf_version
;
25255 /* Locate the .debug_info compilation unit from CU's objfile which contains
25256 the DIE at OFFSET. Raises an error on failure. */
25258 static struct dwarf2_per_cu_data
*
25259 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
25260 unsigned int offset_in_dwz
,
25261 struct dwarf2_per_objfile
*dwarf2_per_objfile
)
25263 struct dwarf2_per_cu_data
*this_cu
;
25267 high
= dwarf2_per_objfile
->all_comp_units
.size () - 1;
25270 struct dwarf2_per_cu_data
*mid_cu
;
25271 int mid
= low
+ (high
- low
) / 2;
25273 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
25274 if (mid_cu
->is_dwz
> offset_in_dwz
25275 || (mid_cu
->is_dwz
== offset_in_dwz
25276 && mid_cu
->sect_off
+ mid_cu
->length
>= sect_off
))
25281 gdb_assert (low
== high
);
25282 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
25283 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
25285 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
25286 error (_("Dwarf Error: could not find partial DIE containing "
25287 "offset %s [in module %s]"),
25288 sect_offset_str (sect_off
),
25289 bfd_get_filename (dwarf2_per_objfile
->objfile
->obfd
));
25291 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->sect_off
25293 return dwarf2_per_objfile
->all_comp_units
[low
-1];
25297 if (low
== dwarf2_per_objfile
->all_comp_units
.size () - 1
25298 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
25299 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
25300 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
25305 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25307 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data
*per_cu_
)
25308 : per_cu (per_cu_
),
25310 has_loclist (false),
25311 checked_producer (false),
25312 producer_is_gxx_lt_4_6 (false),
25313 producer_is_gcc_lt_4_3 (false),
25314 producer_is_icc (false),
25315 producer_is_icc_lt_14 (false),
25316 producer_is_codewarrior (false),
25317 processing_has_namespace_info (false)
25322 /* Destroy a dwarf2_cu. */
25324 dwarf2_cu::~dwarf2_cu ()
25329 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25332 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
25333 enum language pretend_language
)
25335 struct attribute
*attr
;
25337 /* Set the language we're debugging. */
25338 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
25340 set_cu_language (DW_UNSND (attr
), cu
);
25343 cu
->language
= pretend_language
;
25344 cu
->language_defn
= language_def (cu
->language
);
25347 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
25350 /* Increase the age counter on each cached compilation unit, and free
25351 any that are too old. */
25354 age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
25356 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
25358 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
25359 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25360 while (per_cu
!= NULL
)
25362 per_cu
->cu
->last_used
++;
25363 if (per_cu
->cu
->last_used
<= dwarf_max_cache_age
)
25364 dwarf2_mark (per_cu
->cu
);
25365 per_cu
= per_cu
->cu
->read_in_chain
;
25368 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25369 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
25370 while (per_cu
!= NULL
)
25372 struct dwarf2_per_cu_data
*next_cu
;
25374 next_cu
= per_cu
->cu
->read_in_chain
;
25376 if (!per_cu
->cu
->mark
)
25379 *last_chain
= next_cu
;
25382 last_chain
= &per_cu
->cu
->read_in_chain
;
25388 /* Remove a single compilation unit from the cache. */
25391 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
25393 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
25394 struct dwarf2_per_objfile
*dwarf2_per_objfile
25395 = target_per_cu
->dwarf2_per_objfile
;
25397 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25398 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
25399 while (per_cu
!= NULL
)
25401 struct dwarf2_per_cu_data
*next_cu
;
25403 next_cu
= per_cu
->cu
->read_in_chain
;
25405 if (per_cu
== target_per_cu
)
25409 *last_chain
= next_cu
;
25413 last_chain
= &per_cu
->cu
->read_in_chain
;
25419 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25420 We store these in a hash table separate from the DIEs, and preserve them
25421 when the DIEs are flushed out of cache.
25423 The CU "per_cu" pointer is needed because offset alone is not enough to
25424 uniquely identify the type. A file may have multiple .debug_types sections,
25425 or the type may come from a DWO file. Furthermore, while it's more logical
25426 to use per_cu->section+offset, with Fission the section with the data is in
25427 the DWO file but we don't know that section at the point we need it.
25428 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25429 because we can enter the lookup routine, get_die_type_at_offset, from
25430 outside this file, and thus won't necessarily have PER_CU->cu.
25431 Fortunately, PER_CU is stable for the life of the objfile. */
25433 struct dwarf2_per_cu_offset_and_type
25435 const struct dwarf2_per_cu_data
*per_cu
;
25436 sect_offset sect_off
;
25440 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25443 per_cu_offset_and_type_hash (const void *item
)
25445 const struct dwarf2_per_cu_offset_and_type
*ofs
25446 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
25448 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
25451 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25454 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
25456 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
25457 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
25458 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
25459 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
25461 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
25462 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
25465 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25466 table if necessary. For convenience, return TYPE.
25468 The DIEs reading must have careful ordering to:
25469 * Not cause infite loops trying to read in DIEs as a prerequisite for
25470 reading current DIE.
25471 * Not trying to dereference contents of still incompletely read in types
25472 while reading in other DIEs.
25473 * Enable referencing still incompletely read in types just by a pointer to
25474 the type without accessing its fields.
25476 Therefore caller should follow these rules:
25477 * Try to fetch any prerequisite types we may need to build this DIE type
25478 before building the type and calling set_die_type.
25479 * After building type call set_die_type for current DIE as soon as
25480 possible before fetching more types to complete the current type.
25481 * Make the type as complete as possible before fetching more types. */
25483 static struct type
*
25484 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
25486 struct dwarf2_per_objfile
*dwarf2_per_objfile
25487 = cu
->per_cu
->dwarf2_per_objfile
;
25488 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
25489 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
25490 struct attribute
*attr
;
25491 struct dynamic_prop prop
;
25493 /* For Ada types, make sure that the gnat-specific data is always
25494 initialized (if not already set). There are a few types where
25495 we should not be doing so, because the type-specific area is
25496 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25497 where the type-specific area is used to store the floatformat).
25498 But this is not a problem, because the gnat-specific information
25499 is actually not needed for these types. */
25500 if (need_gnat_info (cu
)
25501 && TYPE_CODE (type
) != TYPE_CODE_FUNC
25502 && TYPE_CODE (type
) != TYPE_CODE_FLT
25503 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
25504 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
25505 && TYPE_CODE (type
) != TYPE_CODE_METHOD
25506 && !HAVE_GNAT_AUX_INFO (type
))
25507 INIT_GNAT_SPECIFIC (type
);
25509 /* Read DW_AT_allocated and set in type. */
25510 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
25511 if (attr_form_is_block (attr
))
25513 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
25514 add_dyn_prop (DYN_PROP_ALLOCATED
, prop
, type
);
25516 else if (attr
!= NULL
)
25518 complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25519 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
25520 sect_offset_str (die
->sect_off
));
25523 /* Read DW_AT_associated and set in type. */
25524 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
25525 if (attr_form_is_block (attr
))
25527 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
25528 add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
, type
);
25530 else if (attr
!= NULL
)
25532 complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25533 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
25534 sect_offset_str (die
->sect_off
));
25537 /* Read DW_AT_data_location and set in type. */
25538 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
25539 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
))
25540 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
);
25542 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
25544 dwarf2_per_objfile
->die_type_hash
=
25545 htab_create_alloc_ex (127,
25546 per_cu_offset_and_type_hash
,
25547 per_cu_offset_and_type_eq
,
25549 &objfile
->objfile_obstack
,
25550 hashtab_obstack_allocate
,
25551 dummy_obstack_deallocate
);
25554 ofs
.per_cu
= cu
->per_cu
;
25555 ofs
.sect_off
= die
->sect_off
;
25557 slot
= (struct dwarf2_per_cu_offset_and_type
**)
25558 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
25560 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25561 sect_offset_str (die
->sect_off
));
25562 *slot
= XOBNEW (&objfile
->objfile_obstack
,
25563 struct dwarf2_per_cu_offset_and_type
);
25568 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25569 or return NULL if the die does not have a saved type. */
25571 static struct type
*
25572 get_die_type_at_offset (sect_offset sect_off
,
25573 struct dwarf2_per_cu_data
*per_cu
)
25575 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
25576 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
25578 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
25581 ofs
.per_cu
= per_cu
;
25582 ofs
.sect_off
= sect_off
;
25583 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
25584 htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
));
25591 /* Look up the type for DIE in CU in die_type_hash,
25592 or return NULL if DIE does not have a saved type. */
25594 static struct type
*
25595 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
25597 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
);
25600 /* Add a dependence relationship from CU to REF_PER_CU. */
25603 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
25604 struct dwarf2_per_cu_data
*ref_per_cu
)
25608 if (cu
->dependencies
== NULL
)
25610 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
25611 NULL
, &cu
->comp_unit_obstack
,
25612 hashtab_obstack_allocate
,
25613 dummy_obstack_deallocate
);
25615 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
25617 *slot
= ref_per_cu
;
25620 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25621 Set the mark field in every compilation unit in the
25622 cache that we must keep because we are keeping CU. */
25625 dwarf2_mark_helper (void **slot
, void *data
)
25627 struct dwarf2_per_cu_data
*per_cu
;
25629 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
25631 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25632 reading of the chain. As such dependencies remain valid it is not much
25633 useful to track and undo them during QUIT cleanups. */
25634 if (per_cu
->cu
== NULL
)
25637 if (per_cu
->cu
->mark
)
25639 per_cu
->cu
->mark
= true;
25641 if (per_cu
->cu
->dependencies
!= NULL
)
25642 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
25647 /* Set the mark field in CU and in every other compilation unit in the
25648 cache that we must keep because we are keeping CU. */
25651 dwarf2_mark (struct dwarf2_cu
*cu
)
25656 if (cu
->dependencies
!= NULL
)
25657 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
25661 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
25665 per_cu
->cu
->mark
= false;
25666 per_cu
= per_cu
->cu
->read_in_chain
;
25670 /* Trivial hash function for partial_die_info: the hash value of a DIE
25671 is its offset in .debug_info for this objfile. */
25674 partial_die_hash (const void *item
)
25676 const struct partial_die_info
*part_die
25677 = (const struct partial_die_info
*) item
;
25679 return to_underlying (part_die
->sect_off
);
25682 /* Trivial comparison function for partial_die_info structures: two DIEs
25683 are equal if they have the same offset. */
25686 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
25688 const struct partial_die_info
*part_die_lhs
25689 = (const struct partial_die_info
*) item_lhs
;
25690 const struct partial_die_info
*part_die_rhs
25691 = (const struct partial_die_info
*) item_rhs
;
25693 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
25696 struct cmd_list_element
*set_dwarf_cmdlist
;
25697 struct cmd_list_element
*show_dwarf_cmdlist
;
25700 set_dwarf_cmd (const char *args
, int from_tty
)
25702 help_list (set_dwarf_cmdlist
, "maintenance set dwarf ", all_commands
,
25707 show_dwarf_cmd (const char *args
, int from_tty
)
25709 cmd_show_list (show_dwarf_cmdlist
, from_tty
, "");
25712 int dwarf_always_disassemble
;
25715 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
25716 struct cmd_list_element
*c
, const char *value
)
25718 fprintf_filtered (file
,
25719 _("Whether to always disassemble "
25720 "DWARF expressions is %s.\n"),
25725 show_check_physname (struct ui_file
*file
, int from_tty
,
25726 struct cmd_list_element
*c
, const char *value
)
25728 fprintf_filtered (file
,
25729 _("Whether to check \"physname\" is %s.\n"),
25734 _initialize_dwarf2_read (void)
25736 add_prefix_cmd ("dwarf", class_maintenance
, set_dwarf_cmd
, _("\
25737 Set DWARF specific variables.\n\
25738 Configure DWARF variables such as the cache size"),
25739 &set_dwarf_cmdlist
, "maintenance set dwarf ",
25740 0/*allow-unknown*/, &maintenance_set_cmdlist
);
25742 add_prefix_cmd ("dwarf", class_maintenance
, show_dwarf_cmd
, _("\
25743 Show DWARF specific variables\n\
25744 Show DWARF variables such as the cache size"),
25745 &show_dwarf_cmdlist
, "maintenance show dwarf ",
25746 0/*allow-unknown*/, &maintenance_show_cmdlist
);
25748 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
25749 &dwarf_max_cache_age
, _("\
25750 Set the upper bound on the age of cached DWARF compilation units."), _("\
25751 Show the upper bound on the age of cached DWARF compilation units."), _("\
25752 A higher limit means that cached compilation units will be stored\n\
25753 in memory longer, and more total memory will be used. Zero disables\n\
25754 caching, which can slow down startup."),
25756 show_dwarf_max_cache_age
,
25757 &set_dwarf_cmdlist
,
25758 &show_dwarf_cmdlist
);
25760 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
25761 &dwarf_always_disassemble
, _("\
25762 Set whether `info address' always disassembles DWARF expressions."), _("\
25763 Show whether `info address' always disassembles DWARF expressions."), _("\
25764 When enabled, DWARF expressions are always printed in an assembly-like\n\
25765 syntax. When disabled, expressions will be printed in a more\n\
25766 conversational style, when possible."),
25768 show_dwarf_always_disassemble
,
25769 &set_dwarf_cmdlist
,
25770 &show_dwarf_cmdlist
);
25772 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
25773 Set debugging of the DWARF reader."), _("\
25774 Show debugging of the DWARF reader."), _("\
25775 When enabled (non-zero), debugging messages are printed during DWARF\n\
25776 reading and symtab expansion. A value of 1 (one) provides basic\n\
25777 information. A value greater than 1 provides more verbose information."),
25780 &setdebuglist
, &showdebuglist
);
25782 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
25783 Set debugging of the DWARF DIE reader."), _("\
25784 Show debugging of the DWARF DIE reader."), _("\
25785 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25786 The value is the maximum depth to print."),
25789 &setdebuglist
, &showdebuglist
);
25791 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
25792 Set debugging of the dwarf line reader."), _("\
25793 Show debugging of the dwarf line reader."), _("\
25794 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25795 A value of 1 (one) provides basic information.\n\
25796 A value greater than 1 provides more verbose information."),
25799 &setdebuglist
, &showdebuglist
);
25801 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
25802 Set cross-checking of \"physname\" code against demangler."), _("\
25803 Show cross-checking of \"physname\" code against demangler."), _("\
25804 When enabled, GDB's internal \"physname\" code is checked against\n\
25806 NULL
, show_check_physname
,
25807 &setdebuglist
, &showdebuglist
);
25809 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25810 no_class
, &use_deprecated_index_sections
, _("\
25811 Set whether to use deprecated gdb_index sections."), _("\
25812 Show whether to use deprecated gdb_index sections."), _("\
25813 When enabled, deprecated .gdb_index sections are used anyway.\n\
25814 Normally they are ignored either because of a missing feature or\n\
25815 performance issue.\n\
25816 Warning: This option must be enabled before gdb reads the file."),
25819 &setlist
, &showlist
);
25821 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25822 &dwarf2_locexpr_funcs
);
25823 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25824 &dwarf2_loclist_funcs
);
25826 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25827 &dwarf2_block_frame_base_locexpr_funcs
);
25828 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25829 &dwarf2_block_frame_base_loclist_funcs
);
25832 selftests::register_test ("dw2_expand_symtabs_matching",
25833 selftests::dw2_expand_symtabs_matching::run_test
);