1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2019 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* FIXME: Various die-reading functions need to be more careful with
28 reading off the end of the section.
29 E.g., load_partial_dies, read_partial_die. */
32 #include "dwarf2read.h"
33 #include "dwarf-index-cache.h"
34 #include "dwarf-index-common.h"
43 #include "gdb-demangle.h"
44 #include "expression.h"
45 #include "filenames.h" /* for DOSish file names */
48 #include "complaints.h"
49 #include "dwarf2expr.h"
50 #include "dwarf2loc.h"
51 #include "cp-support.h"
57 #include "typeprint.h"
60 #include "completer.h"
61 #include "gdbsupport/vec.h"
65 #include "gdbcore.h" /* for gnutarget */
66 #include "gdb/gdb-index.h"
71 #include "gdbsupport/filestuff.h"
73 #include "namespace.h"
74 #include "gdbsupport/gdb_unlinker.h"
75 #include "gdbsupport/function-view.h"
76 #include "gdbsupport/gdb_optional.h"
77 #include "gdbsupport/underlying.h"
78 #include "gdbsupport/byte-vector.h"
79 #include "gdbsupport/hash_enum.h"
80 #include "filename-seen-cache.h"
83 #include <sys/types.h>
85 #include <unordered_set>
86 #include <unordered_map>
87 #include "gdbsupport/selftest.h"
90 #include <forward_list>
91 #include "rust-lang.h"
92 #include "gdbsupport/pathstuff.h"
94 /* When == 1, print basic high level tracing messages.
95 When > 1, be more verbose.
96 This is in contrast to the low level DIE reading of dwarf_die_debug. */
97 static unsigned int dwarf_read_debug
= 0;
99 /* When non-zero, dump DIEs after they are read in. */
100 static unsigned int dwarf_die_debug
= 0;
102 /* When non-zero, dump line number entries as they are read in. */
103 static unsigned int dwarf_line_debug
= 0;
105 /* When 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 std::vector
<dwarf2_section_info
> 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
);
709 /* The DW_AT_GNU_dwo_name attribute.
710 For virtual DWO files the name is constructed from the section offsets
711 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
712 from related CU+TUs. */
713 const char *dwo_name
= nullptr;
715 /* The DW_AT_comp_dir attribute. */
716 const char *comp_dir
= nullptr;
718 /* The bfd, when the file is open. Otherwise this is NULL.
719 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
720 gdb_bfd_ref_ptr dbfd
;
722 /* The sections that make up this DWO file.
723 Remember that for virtual DWO files in DWP V2, these are virtual
724 sections (for lack of a better name). */
725 struct dwo_sections sections
{};
727 /* The CUs in the file.
728 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
729 an extension to handle LLVM's Link Time Optimization output (where
730 multiple source files may be compiled into a single object/dwo pair). */
733 /* Table of TUs in the file.
734 Each element is a struct dwo_unit. */
738 /* These sections are what may appear in a DWP file. */
742 /* These are used by both DWP version 1 and 2. */
743 struct dwarf2_section_info str
;
744 struct dwarf2_section_info cu_index
;
745 struct dwarf2_section_info tu_index
;
747 /* These are only used by DWP version 2 files.
748 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
749 sections are referenced by section number, and are not recorded here.
750 In DWP version 2 there is at most one copy of all these sections, each
751 section being (effectively) comprised of the concatenation of all of the
752 individual sections that exist in the version 1 format.
753 To keep the code simple we treat each of these concatenated pieces as a
754 section itself (a virtual section?). */
755 struct dwarf2_section_info abbrev
;
756 struct dwarf2_section_info info
;
757 struct dwarf2_section_info line
;
758 struct dwarf2_section_info loc
;
759 struct dwarf2_section_info macinfo
;
760 struct dwarf2_section_info macro
;
761 struct dwarf2_section_info str_offsets
;
762 struct dwarf2_section_info types
;
765 /* These sections are what may appear in a virtual DWO file in DWP version 1.
766 A virtual DWO file is a DWO file as it appears in a DWP file. */
768 struct virtual_v1_dwo_sections
770 struct dwarf2_section_info abbrev
;
771 struct dwarf2_section_info line
;
772 struct dwarf2_section_info loc
;
773 struct dwarf2_section_info macinfo
;
774 struct dwarf2_section_info macro
;
775 struct dwarf2_section_info str_offsets
;
776 /* Each DWP hash table entry records one CU or one TU.
777 That is recorded here, and copied to dwo_unit.section. */
778 struct dwarf2_section_info info_or_types
;
781 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
782 In version 2, the sections of the DWO files are concatenated together
783 and stored in one section of that name. Thus each ELF section contains
784 several "virtual" sections. */
786 struct virtual_v2_dwo_sections
788 bfd_size_type abbrev_offset
;
789 bfd_size_type abbrev_size
;
791 bfd_size_type line_offset
;
792 bfd_size_type line_size
;
794 bfd_size_type loc_offset
;
795 bfd_size_type loc_size
;
797 bfd_size_type macinfo_offset
;
798 bfd_size_type macinfo_size
;
800 bfd_size_type macro_offset
;
801 bfd_size_type macro_size
;
803 bfd_size_type str_offsets_offset
;
804 bfd_size_type str_offsets_size
;
806 /* Each DWP hash table entry records one CU or one TU.
807 That is recorded here, and copied to dwo_unit.section. */
808 bfd_size_type info_or_types_offset
;
809 bfd_size_type info_or_types_size
;
812 /* Contents of DWP hash tables. */
814 struct dwp_hash_table
816 uint32_t version
, nr_columns
;
817 uint32_t nr_units
, nr_slots
;
818 const gdb_byte
*hash_table
, *unit_table
;
823 const gdb_byte
*indices
;
827 /* This is indexed by column number and gives the id of the section
829 #define MAX_NR_V2_DWO_SECTIONS \
830 (1 /* .debug_info or .debug_types */ \
831 + 1 /* .debug_abbrev */ \
832 + 1 /* .debug_line */ \
833 + 1 /* .debug_loc */ \
834 + 1 /* .debug_str_offsets */ \
835 + 1 /* .debug_macro or .debug_macinfo */)
836 int section_ids
[MAX_NR_V2_DWO_SECTIONS
];
837 const gdb_byte
*offsets
;
838 const gdb_byte
*sizes
;
843 /* Data for one DWP file. */
847 dwp_file (const char *name_
, gdb_bfd_ref_ptr
&&abfd
)
849 dbfd (std::move (abfd
))
853 /* Name of the file. */
856 /* File format version. */
860 gdb_bfd_ref_ptr dbfd
;
862 /* Section info for this file. */
863 struct dwp_sections sections
{};
865 /* Table of CUs in the file. */
866 const struct dwp_hash_table
*cus
= nullptr;
868 /* Table of TUs in the file. */
869 const struct dwp_hash_table
*tus
= nullptr;
871 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
872 htab_t loaded_cus
{};
873 htab_t loaded_tus
{};
875 /* Table to map ELF section numbers to their sections.
876 This is only needed for the DWP V1 file format. */
877 unsigned int num_sections
= 0;
878 asection
**elf_sections
= nullptr;
881 /* Struct used to pass misc. parameters to read_die_and_children, et
882 al. which are used for both .debug_info and .debug_types dies.
883 All parameters here are unchanging for the life of the call. This
884 struct exists to abstract away the constant parameters of die reading. */
886 struct die_reader_specs
888 /* The bfd of die_section. */
891 /* The CU of the DIE we are parsing. */
892 struct dwarf2_cu
*cu
;
894 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
895 struct dwo_file
*dwo_file
;
897 /* The section the die comes from.
898 This is either .debug_info or .debug_types, or the .dwo variants. */
899 struct dwarf2_section_info
*die_section
;
901 /* die_section->buffer. */
902 const gdb_byte
*buffer
;
904 /* The end of the buffer. */
905 const gdb_byte
*buffer_end
;
907 /* The value of the DW_AT_comp_dir attribute. */
908 const char *comp_dir
;
910 /* The abbreviation table to use when reading the DIEs. */
911 struct abbrev_table
*abbrev_table
;
914 /* Type of function passed to init_cutu_and_read_dies, et.al. */
915 typedef void (die_reader_func_ftype
) (const struct die_reader_specs
*reader
,
916 const gdb_byte
*info_ptr
,
917 struct die_info
*comp_unit_die
,
921 /* A 1-based directory index. This is a strong typedef to prevent
922 accidentally using a directory index as a 0-based index into an
924 enum class dir_index
: unsigned int {};
926 /* Likewise, a 1-based file name index. */
927 enum class file_name_index
: unsigned int {};
931 file_entry () = default;
933 file_entry (const char *name_
, dir_index d_index_
,
934 unsigned int mod_time_
, unsigned int length_
)
937 mod_time (mod_time_
),
941 /* Return the include directory at D_INDEX stored in LH. Returns
942 NULL if D_INDEX is out of bounds. */
943 const char *include_dir (const line_header
*lh
) const;
945 /* The file name. Note this is an observing pointer. The memory is
946 owned by debug_line_buffer. */
949 /* The directory index (1-based). */
950 dir_index d_index
{};
952 unsigned int mod_time
{};
954 unsigned int length
{};
956 /* True if referenced by the Line Number Program. */
959 /* The associated symbol table, if any. */
960 struct symtab
*symtab
{};
963 /* The line number information for a compilation unit (found in the
964 .debug_line section) begins with a "statement program header",
965 which contains the following information. */
972 /* Add an entry to the include directory table. */
973 void add_include_dir (const char *include_dir
);
975 /* Add an entry to the file name table. */
976 void add_file_name (const char *name
, dir_index d_index
,
977 unsigned int mod_time
, unsigned int length
);
979 /* Return the include dir at INDEX (1-based). Returns NULL if INDEX
981 const char *include_dir_at (dir_index index
) const
983 /* Convert directory index number (1-based) to vector index
985 size_t vec_index
= to_underlying (index
) - 1;
987 if (vec_index
>= include_dirs
.size ())
989 return include_dirs
[vec_index
];
992 /* Return the file name at INDEX (1-based). Returns NULL if INDEX
994 file_entry
*file_name_at (file_name_index index
)
996 /* Convert file name index number (1-based) to vector index
998 size_t vec_index
= to_underlying (index
) - 1;
1000 if (vec_index
>= file_names
.size ())
1002 return &file_names
[vec_index
];
1005 /* Offset of line number information in .debug_line section. */
1006 sect_offset sect_off
{};
1008 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1009 unsigned offset_in_dwz
: 1; /* Can't initialize bitfields in-class. */
1011 unsigned int total_length
{};
1012 unsigned short version
{};
1013 unsigned int header_length
{};
1014 unsigned char minimum_instruction_length
{};
1015 unsigned char maximum_ops_per_instruction
{};
1016 unsigned char default_is_stmt
{};
1018 unsigned char line_range
{};
1019 unsigned char opcode_base
{};
1021 /* standard_opcode_lengths[i] is the number of operands for the
1022 standard opcode whose value is i. This means that
1023 standard_opcode_lengths[0] is unused, and the last meaningful
1024 element is standard_opcode_lengths[opcode_base - 1]. */
1025 std::unique_ptr
<unsigned char[]> standard_opcode_lengths
;
1027 /* The include_directories table. Note these are observing
1028 pointers. The memory is owned by debug_line_buffer. */
1029 std::vector
<const char *> include_dirs
;
1031 /* The file_names table. */
1032 std::vector
<file_entry
> file_names
;
1034 /* The start and end of the statement program following this
1035 header. These point into dwarf2_per_objfile->line_buffer. */
1036 const gdb_byte
*statement_program_start
{}, *statement_program_end
{};
1039 typedef std::unique_ptr
<line_header
> line_header_up
;
1042 file_entry::include_dir (const line_header
*lh
) const
1044 return lh
->include_dir_at (d_index
);
1047 /* When we construct a partial symbol table entry we only
1048 need this much information. */
1049 struct partial_die_info
: public allocate_on_obstack
1051 partial_die_info (sect_offset sect_off
, struct abbrev_info
*abbrev
);
1053 /* Disable assign but still keep copy ctor, which is needed
1054 load_partial_dies. */
1055 partial_die_info
& operator=(const partial_die_info
& rhs
) = delete;
1057 /* Adjust the partial die before generating a symbol for it. This
1058 function may set the is_external flag or change the DIE's
1060 void fixup (struct dwarf2_cu
*cu
);
1062 /* Read a minimal amount of information into the minimal die
1064 const gdb_byte
*read (const struct die_reader_specs
*reader
,
1065 const struct abbrev_info
&abbrev
,
1066 const gdb_byte
*info_ptr
);
1068 /* Offset of this DIE. */
1069 const sect_offset sect_off
;
1071 /* DWARF-2 tag for this DIE. */
1072 const ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1074 /* Assorted flags describing the data found in this DIE. */
1075 const unsigned int has_children
: 1;
1077 unsigned int is_external
: 1;
1078 unsigned int is_declaration
: 1;
1079 unsigned int has_type
: 1;
1080 unsigned int has_specification
: 1;
1081 unsigned int has_pc_info
: 1;
1082 unsigned int may_be_inlined
: 1;
1084 /* This DIE has been marked DW_AT_main_subprogram. */
1085 unsigned int main_subprogram
: 1;
1087 /* Flag set if the SCOPE field of this structure has been
1089 unsigned int scope_set
: 1;
1091 /* Flag set if the DIE has a byte_size attribute. */
1092 unsigned int has_byte_size
: 1;
1094 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1095 unsigned int has_const_value
: 1;
1097 /* Flag set if any of the DIE's children are template arguments. */
1098 unsigned int has_template_arguments
: 1;
1100 /* Flag set if fixup has been called on this die. */
1101 unsigned int fixup_called
: 1;
1103 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1104 unsigned int is_dwz
: 1;
1106 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1107 unsigned int spec_is_dwz
: 1;
1109 /* The name of this DIE. Normally the value of DW_AT_name, but
1110 sometimes a default name for unnamed DIEs. */
1111 const char *name
= nullptr;
1113 /* The linkage name, if present. */
1114 const char *linkage_name
= nullptr;
1116 /* The scope to prepend to our children. This is generally
1117 allocated on the comp_unit_obstack, so will disappear
1118 when this compilation unit leaves the cache. */
1119 const char *scope
= nullptr;
1121 /* Some data associated with the partial DIE. The tag determines
1122 which field is live. */
1125 /* The location description associated with this DIE, if any. */
1126 struct dwarf_block
*locdesc
;
1127 /* The offset of an import, for DW_TAG_imported_unit. */
1128 sect_offset sect_off
;
1131 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1132 CORE_ADDR lowpc
= 0;
1133 CORE_ADDR highpc
= 0;
1135 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1136 DW_AT_sibling, if any. */
1137 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1138 could return DW_AT_sibling values to its caller load_partial_dies. */
1139 const gdb_byte
*sibling
= nullptr;
1141 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1142 DW_AT_specification (or DW_AT_abstract_origin or
1143 DW_AT_extension). */
1144 sect_offset spec_offset
{};
1146 /* Pointers to this DIE's parent, first child, and next sibling,
1148 struct partial_die_info
*die_parent
= nullptr;
1149 struct partial_die_info
*die_child
= nullptr;
1150 struct partial_die_info
*die_sibling
= nullptr;
1152 friend struct partial_die_info
*
1153 dwarf2_cu::find_partial_die (sect_offset sect_off
);
1156 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1157 partial_die_info (sect_offset sect_off
)
1158 : partial_die_info (sect_off
, DW_TAG_padding
, 0)
1162 partial_die_info (sect_offset sect_off_
, enum dwarf_tag tag_
,
1164 : sect_off (sect_off_
), tag (tag_
), has_children (has_children_
)
1169 has_specification
= 0;
1172 main_subprogram
= 0;
1175 has_const_value
= 0;
1176 has_template_arguments
= 0;
1183 /* This data structure holds the information of an abbrev. */
1186 unsigned int number
; /* number identifying abbrev */
1187 enum dwarf_tag tag
; /* dwarf tag */
1188 unsigned short has_children
; /* boolean */
1189 unsigned short num_attrs
; /* number of attributes */
1190 struct attr_abbrev
*attrs
; /* an array of attribute descriptions */
1191 struct abbrev_info
*next
; /* next in chain */
1196 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1197 ENUM_BITFIELD(dwarf_form
) form
: 16;
1199 /* It is valid only if FORM is DW_FORM_implicit_const. */
1200 LONGEST implicit_const
;
1203 /* Size of abbrev_table.abbrev_hash_table. */
1204 #define ABBREV_HASH_SIZE 121
1206 /* Top level data structure to contain an abbreviation table. */
1210 explicit abbrev_table (sect_offset off
)
1214 XOBNEWVEC (&abbrev_obstack
, struct abbrev_info
*, ABBREV_HASH_SIZE
);
1215 memset (m_abbrevs
, 0, ABBREV_HASH_SIZE
* sizeof (struct abbrev_info
*));
1218 DISABLE_COPY_AND_ASSIGN (abbrev_table
);
1220 /* Allocate space for a struct abbrev_info object in
1222 struct abbrev_info
*alloc_abbrev ();
1224 /* Add an abbreviation to the table. */
1225 void add_abbrev (unsigned int abbrev_number
, struct abbrev_info
*abbrev
);
1227 /* Look up an abbrev in the table.
1228 Returns NULL if the abbrev is not found. */
1230 struct abbrev_info
*lookup_abbrev (unsigned int abbrev_number
);
1233 /* Where the abbrev table came from.
1234 This is used as a sanity check when the table is used. */
1235 const sect_offset sect_off
;
1237 /* Storage for the abbrev table. */
1238 auto_obstack abbrev_obstack
;
1242 /* Hash table of abbrevs.
1243 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1244 It could be statically allocated, but the previous code didn't so we
1246 struct abbrev_info
**m_abbrevs
;
1249 typedef std::unique_ptr
<struct abbrev_table
> abbrev_table_up
;
1251 /* Attributes have a name and a value. */
1254 ENUM_BITFIELD(dwarf_attribute
) name
: 16;
1255 ENUM_BITFIELD(dwarf_form
) form
: 15;
1257 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1258 field should be in u.str (existing only for DW_STRING) but it is kept
1259 here for better struct attribute alignment. */
1260 unsigned int string_is_canonical
: 1;
1265 struct dwarf_block
*blk
;
1274 /* This data structure holds a complete die structure. */
1277 /* DWARF-2 tag for this DIE. */
1278 ENUM_BITFIELD(dwarf_tag
) tag
: 16;
1280 /* Number of attributes */
1281 unsigned char num_attrs
;
1283 /* True if we're presently building the full type name for the
1284 type derived from this DIE. */
1285 unsigned char building_fullname
: 1;
1287 /* True if this die is in process. PR 16581. */
1288 unsigned char in_process
: 1;
1291 unsigned int abbrev
;
1293 /* Offset in .debug_info or .debug_types section. */
1294 sect_offset sect_off
;
1296 /* The dies in a compilation unit form an n-ary tree. PARENT
1297 points to this die's parent; CHILD points to the first child of
1298 this node; and all the children of a given node are chained
1299 together via their SIBLING fields. */
1300 struct die_info
*child
; /* Its first child, if any. */
1301 struct die_info
*sibling
; /* Its next sibling, if any. */
1302 struct die_info
*parent
; /* Its parent, if any. */
1304 /* An array of attributes, with NUM_ATTRS elements. There may be
1305 zero, but it's not common and zero-sized arrays are not
1306 sufficiently portable C. */
1307 struct attribute attrs
[1];
1310 /* Get at parts of an attribute structure. */
1312 #define DW_STRING(attr) ((attr)->u.str)
1313 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1314 #define DW_UNSND(attr) ((attr)->u.unsnd)
1315 #define DW_BLOCK(attr) ((attr)->u.blk)
1316 #define DW_SND(attr) ((attr)->u.snd)
1317 #define DW_ADDR(attr) ((attr)->u.addr)
1318 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1320 /* Blocks are a bunch of untyped bytes. */
1325 /* Valid only if SIZE is not zero. */
1326 const gdb_byte
*data
;
1329 #ifndef ATTR_ALLOC_CHUNK
1330 #define ATTR_ALLOC_CHUNK 4
1333 /* Allocate fields for structs, unions and enums in this size. */
1334 #ifndef DW_FIELD_ALLOC_CHUNK
1335 #define DW_FIELD_ALLOC_CHUNK 4
1338 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1339 but this would require a corresponding change in unpack_field_as_long
1341 static int bits_per_byte
= 8;
1343 /* When reading a variant or variant part, we track a bit more
1344 information about the field, and store it in an object of this
1347 struct variant_field
1349 /* If we see a DW_TAG_variant, then this will be the discriminant
1351 ULONGEST discriminant_value
;
1352 /* If we see a DW_TAG_variant, then this will be set if this is the
1354 bool default_branch
;
1355 /* While reading a DW_TAG_variant_part, this will be set if this
1356 field is the discriminant. */
1357 bool is_discriminant
;
1362 int accessibility
= 0;
1364 /* Extra information to describe a variant or variant part. */
1365 struct variant_field variant
{};
1366 struct field field
{};
1371 const char *name
= nullptr;
1372 std::vector
<struct fn_field
> fnfields
;
1375 /* The routines that read and process dies for a C struct or C++ class
1376 pass lists of data member fields and lists of member function fields
1377 in an instance of a field_info structure, as defined below. */
1380 /* List of data member and baseclasses fields. */
1381 std::vector
<struct nextfield
> fields
;
1382 std::vector
<struct nextfield
> baseclasses
;
1384 /* Number of fields (including baseclasses). */
1387 /* Set if the accesibility of one of the fields is not public. */
1388 int non_public_fields
= 0;
1390 /* Member function fieldlist array, contains name of possibly overloaded
1391 member function, number of overloaded member functions and a pointer
1392 to the head of the member function field chain. */
1393 std::vector
<struct fnfieldlist
> fnfieldlists
;
1395 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1396 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1397 std::vector
<struct decl_field
> typedef_field_list
;
1399 /* Nested types defined by this class and the number of elements in this
1401 std::vector
<struct decl_field
> nested_types_list
;
1404 /* One item on the queue of compilation units to read in full symbols
1406 struct dwarf2_queue_item
1408 struct dwarf2_per_cu_data
*per_cu
;
1409 enum language pretend_language
;
1410 struct dwarf2_queue_item
*next
;
1413 /* The current queue. */
1414 static struct dwarf2_queue_item
*dwarf2_queue
, *dwarf2_queue_tail
;
1416 /* Loaded secondary compilation units are kept in memory until they
1417 have not been referenced for the processing of this many
1418 compilation units. Set this to zero to disable caching. Cache
1419 sizes of up to at least twenty will improve startup time for
1420 typical inter-CU-reference binaries, at an obvious memory cost. */
1421 static int dwarf_max_cache_age
= 5;
1423 show_dwarf_max_cache_age (struct ui_file
*file
, int from_tty
,
1424 struct cmd_list_element
*c
, const char *value
)
1426 fprintf_filtered (file
, _("The upper bound on the age of cached "
1427 "DWARF compilation units is %s.\n"),
1431 /* local function prototypes */
1433 static const char *get_section_name (const struct dwarf2_section_info
*);
1435 static const char *get_section_file_name (const struct dwarf2_section_info
*);
1437 static void dwarf2_find_base_address (struct die_info
*die
,
1438 struct dwarf2_cu
*cu
);
1440 static struct partial_symtab
*create_partial_symtab
1441 (struct dwarf2_per_cu_data
*per_cu
, const char *name
);
1443 static void build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
1444 const gdb_byte
*info_ptr
,
1445 struct die_info
*type_unit_die
,
1446 int has_children
, void *data
);
1448 static void dwarf2_build_psymtabs_hard
1449 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1451 static void scan_partial_symbols (struct partial_die_info
*,
1452 CORE_ADDR
*, CORE_ADDR
*,
1453 int, struct dwarf2_cu
*);
1455 static void add_partial_symbol (struct partial_die_info
*,
1456 struct dwarf2_cu
*);
1458 static void add_partial_namespace (struct partial_die_info
*pdi
,
1459 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1460 int set_addrmap
, struct dwarf2_cu
*cu
);
1462 static void add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
1463 CORE_ADDR
*highpc
, int set_addrmap
,
1464 struct dwarf2_cu
*cu
);
1466 static void add_partial_enumeration (struct partial_die_info
*enum_pdi
,
1467 struct dwarf2_cu
*cu
);
1469 static void add_partial_subprogram (struct partial_die_info
*pdi
,
1470 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
1471 int need_pc
, struct dwarf2_cu
*cu
);
1473 static void dwarf2_read_symtab (struct partial_symtab
*,
1476 static void psymtab_to_symtab_1 (struct partial_symtab
*);
1478 static abbrev_table_up abbrev_table_read_table
1479 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, struct dwarf2_section_info
*,
1482 static unsigned int peek_abbrev_code (bfd
*, const gdb_byte
*);
1484 static struct partial_die_info
*load_partial_dies
1485 (const struct die_reader_specs
*, const gdb_byte
*, int);
1487 /* A pair of partial_die_info and compilation unit. */
1488 struct cu_partial_die_info
1490 /* The compilation unit of the partial_die_info. */
1491 struct dwarf2_cu
*cu
;
1492 /* A partial_die_info. */
1493 struct partial_die_info
*pdi
;
1495 cu_partial_die_info (struct dwarf2_cu
*cu
, struct partial_die_info
*pdi
)
1501 cu_partial_die_info () = delete;
1504 static const struct cu_partial_die_info
find_partial_die (sect_offset
, int,
1505 struct dwarf2_cu
*);
1507 static const gdb_byte
*read_attribute (const struct die_reader_specs
*,
1508 struct attribute
*, struct attr_abbrev
*,
1511 static unsigned int read_1_byte (bfd
*, const gdb_byte
*);
1513 static int read_1_signed_byte (bfd
*, const gdb_byte
*);
1515 static unsigned int read_2_bytes (bfd
*, const gdb_byte
*);
1517 /* Read the next three bytes (little-endian order) as an unsigned integer. */
1518 static unsigned int read_3_bytes (bfd
*, const gdb_byte
*);
1520 static unsigned int read_4_bytes (bfd
*, const gdb_byte
*);
1522 static ULONGEST
read_8_bytes (bfd
*, const gdb_byte
*);
1524 static CORE_ADDR
read_address (bfd
*, const gdb_byte
*ptr
, struct dwarf2_cu
*,
1527 static LONGEST
read_initial_length (bfd
*, const gdb_byte
*, unsigned int *);
1529 static LONGEST read_checked_initial_length_and_offset
1530 (bfd
*, const gdb_byte
*, const struct comp_unit_head
*,
1531 unsigned int *, unsigned int *);
1533 static LONGEST
read_offset (bfd
*, const gdb_byte
*,
1534 const struct comp_unit_head
*,
1537 static LONGEST
read_offset_1 (bfd
*, const gdb_byte
*, unsigned int);
1539 static sect_offset read_abbrev_offset
1540 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1541 struct dwarf2_section_info
*, sect_offset
);
1543 static const gdb_byte
*read_n_bytes (bfd
*, const gdb_byte
*, unsigned int);
1545 static const char *read_direct_string (bfd
*, const gdb_byte
*, unsigned int *);
1547 static const char *read_indirect_string
1548 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*, const gdb_byte
*,
1549 const struct comp_unit_head
*, unsigned int *);
1551 static const char *read_indirect_line_string
1552 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*, const gdb_byte
*,
1553 const struct comp_unit_head
*, unsigned int *);
1555 static const char *read_indirect_string_at_offset
1556 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
1557 LONGEST str_offset
);
1559 static const char *read_indirect_string_from_dwz
1560 (struct objfile
*objfile
, struct dwz_file
*, LONGEST
);
1562 static LONGEST
read_signed_leb128 (bfd
*, const gdb_byte
*, unsigned int *);
1564 static CORE_ADDR
read_addr_index_from_leb128 (struct dwarf2_cu
*,
1568 static const char *read_str_index (const struct die_reader_specs
*reader
,
1569 ULONGEST str_index
);
1571 static void set_cu_language (unsigned int, struct dwarf2_cu
*);
1573 static struct attribute
*dwarf2_attr (struct die_info
*, unsigned int,
1574 struct dwarf2_cu
*);
1576 static struct attribute
*dwarf2_attr_no_follow (struct die_info
*,
1579 static const char *dwarf2_string_attr (struct die_info
*die
, unsigned int name
,
1580 struct dwarf2_cu
*cu
);
1582 static int dwarf2_flag_true_p (struct die_info
*die
, unsigned name
,
1583 struct dwarf2_cu
*cu
);
1585 static int die_is_declaration (struct die_info
*, struct dwarf2_cu
*cu
);
1587 static struct die_info
*die_specification (struct die_info
*die
,
1588 struct dwarf2_cu
**);
1590 static line_header_up
dwarf_decode_line_header (sect_offset sect_off
,
1591 struct dwarf2_cu
*cu
);
1593 static void dwarf_decode_lines (struct line_header
*, const char *,
1594 struct dwarf2_cu
*, struct partial_symtab
*,
1595 CORE_ADDR
, int decode_mapping
);
1597 static void dwarf2_start_subfile (struct dwarf2_cu
*, const char *,
1600 static struct symbol
*new_symbol (struct die_info
*, struct type
*,
1601 struct dwarf2_cu
*, struct symbol
* = NULL
);
1603 static void dwarf2_const_value (const struct attribute
*, struct symbol
*,
1604 struct dwarf2_cu
*);
1606 static void dwarf2_const_value_attr (const struct attribute
*attr
,
1609 struct obstack
*obstack
,
1610 struct dwarf2_cu
*cu
, LONGEST
*value
,
1611 const gdb_byte
**bytes
,
1612 struct dwarf2_locexpr_baton
**baton
);
1614 static struct type
*die_type (struct die_info
*, struct dwarf2_cu
*);
1616 static int need_gnat_info (struct dwarf2_cu
*);
1618 static struct type
*die_descriptive_type (struct die_info
*,
1619 struct dwarf2_cu
*);
1621 static void set_descriptive_type (struct type
*, struct die_info
*,
1622 struct dwarf2_cu
*);
1624 static struct type
*die_containing_type (struct die_info
*,
1625 struct dwarf2_cu
*);
1627 static struct type
*lookup_die_type (struct die_info
*, const struct attribute
*,
1628 struct dwarf2_cu
*);
1630 static struct type
*read_type_die (struct die_info
*, struct dwarf2_cu
*);
1632 static struct type
*read_type_die_1 (struct die_info
*, struct dwarf2_cu
*);
1634 static const char *determine_prefix (struct die_info
*die
, struct dwarf2_cu
*);
1636 static char *typename_concat (struct obstack
*obs
, const char *prefix
,
1637 const char *suffix
, int physname
,
1638 struct dwarf2_cu
*cu
);
1640 static void read_file_scope (struct die_info
*, struct dwarf2_cu
*);
1642 static void read_type_unit_scope (struct die_info
*, struct dwarf2_cu
*);
1644 static void read_func_scope (struct die_info
*, struct dwarf2_cu
*);
1646 static void read_lexical_block_scope (struct die_info
*, struct dwarf2_cu
*);
1648 static void read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
);
1650 static void read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
);
1652 static int dwarf2_ranges_read (unsigned, CORE_ADDR
*, CORE_ADDR
*,
1653 struct dwarf2_cu
*, struct partial_symtab
*);
1655 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1656 values. Keep the items ordered with increasing constraints compliance. */
1659 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1660 PC_BOUNDS_NOT_PRESENT
,
1662 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1663 were present but they do not form a valid range of PC addresses. */
1666 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1669 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1673 static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info
*,
1674 CORE_ADDR
*, CORE_ADDR
*,
1676 struct partial_symtab
*);
1678 static void get_scope_pc_bounds (struct die_info
*,
1679 CORE_ADDR
*, CORE_ADDR
*,
1680 struct dwarf2_cu
*);
1682 static void dwarf2_record_block_ranges (struct die_info
*, struct block
*,
1683 CORE_ADDR
, struct dwarf2_cu
*);
1685 static void dwarf2_add_field (struct field_info
*, struct die_info
*,
1686 struct dwarf2_cu
*);
1688 static void dwarf2_attach_fields_to_type (struct field_info
*,
1689 struct type
*, struct dwarf2_cu
*);
1691 static void dwarf2_add_member_fn (struct field_info
*,
1692 struct die_info
*, struct type
*,
1693 struct dwarf2_cu
*);
1695 static void dwarf2_attach_fn_fields_to_type (struct field_info
*,
1697 struct dwarf2_cu
*);
1699 static void process_structure_scope (struct die_info
*, struct dwarf2_cu
*);
1701 static void read_common_block (struct die_info
*, struct dwarf2_cu
*);
1703 static void read_namespace (struct die_info
*die
, struct dwarf2_cu
*);
1705 static void read_module (struct die_info
*die
, struct dwarf2_cu
*cu
);
1707 static struct using_direct
**using_directives (struct dwarf2_cu
*cu
);
1709 static void read_import_statement (struct die_info
*die
, struct dwarf2_cu
*);
1711 static int read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
);
1713 static struct type
*read_module_type (struct die_info
*die
,
1714 struct dwarf2_cu
*cu
);
1716 static const char *namespace_name (struct die_info
*die
,
1717 int *is_anonymous
, struct dwarf2_cu
*);
1719 static void process_enumeration_scope (struct die_info
*, struct dwarf2_cu
*);
1721 static CORE_ADDR
decode_locdesc (struct dwarf_block
*, struct dwarf2_cu
*);
1723 static enum dwarf_array_dim_ordering
read_array_order (struct die_info
*,
1724 struct dwarf2_cu
*);
1726 static struct die_info
*read_die_and_siblings_1
1727 (const struct die_reader_specs
*, const gdb_byte
*, const gdb_byte
**,
1730 static struct die_info
*read_die_and_siblings (const struct die_reader_specs
*,
1731 const gdb_byte
*info_ptr
,
1732 const gdb_byte
**new_info_ptr
,
1733 struct die_info
*parent
);
1735 static const gdb_byte
*read_full_die_1 (const struct die_reader_specs
*,
1736 struct die_info
**, const gdb_byte
*,
1739 static const gdb_byte
*read_full_die (const struct die_reader_specs
*,
1740 struct die_info
**, const gdb_byte
*,
1743 static void process_die (struct die_info
*, struct dwarf2_cu
*);
1745 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu
*,
1748 static const char *dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*);
1750 static const char *dwarf2_full_name (const char *name
,
1751 struct die_info
*die
,
1752 struct dwarf2_cu
*cu
);
1754 static const char *dwarf2_physname (const char *name
, struct die_info
*die
,
1755 struct dwarf2_cu
*cu
);
1757 static struct die_info
*dwarf2_extension (struct die_info
*die
,
1758 struct dwarf2_cu
**);
1760 static const char *dwarf_tag_name (unsigned int);
1762 static const char *dwarf_attr_name (unsigned int);
1764 static const char *dwarf_form_name (unsigned int);
1766 static const char *dwarf_bool_name (unsigned int);
1768 static const char *dwarf_type_encoding_name (unsigned int);
1770 static struct die_info
*sibling_die (struct die_info
*);
1772 static void dump_die_shallow (struct ui_file
*, int indent
, struct die_info
*);
1774 static void dump_die_for_error (struct die_info
*);
1776 static void dump_die_1 (struct ui_file
*, int level
, int max_level
,
1779 /*static*/ void dump_die (struct die_info
*, int max_level
);
1781 static void store_in_ref_table (struct die_info
*,
1782 struct dwarf2_cu
*);
1784 static sect_offset
dwarf2_get_ref_die_offset (const struct attribute
*);
1786 static LONGEST
dwarf2_get_attr_constant_value (const struct attribute
*, int);
1788 static struct die_info
*follow_die_ref_or_sig (struct die_info
*,
1789 const struct attribute
*,
1790 struct dwarf2_cu
**);
1792 static struct die_info
*follow_die_ref (struct die_info
*,
1793 const struct attribute
*,
1794 struct dwarf2_cu
**);
1796 static struct die_info
*follow_die_sig (struct die_info
*,
1797 const struct attribute
*,
1798 struct dwarf2_cu
**);
1800 static struct type
*get_signatured_type (struct die_info
*, ULONGEST
,
1801 struct dwarf2_cu
*);
1803 static struct type
*get_DW_AT_signature_type (struct die_info
*,
1804 const struct attribute
*,
1805 struct dwarf2_cu
*);
1807 static void load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
);
1809 static void read_signatured_type (struct signatured_type
*);
1811 static int attr_to_dynamic_prop (const struct attribute
*attr
,
1812 struct die_info
*die
, struct dwarf2_cu
*cu
,
1813 struct dynamic_prop
*prop
, struct type
*type
);
1815 /* memory allocation interface */
1817 static struct dwarf_block
*dwarf_alloc_block (struct dwarf2_cu
*);
1819 static struct die_info
*dwarf_alloc_die (struct dwarf2_cu
*, int);
1821 static void dwarf_decode_macros (struct dwarf2_cu
*, unsigned int, int);
1823 static int attr_form_is_block (const struct attribute
*);
1825 static int attr_form_is_section_offset (const struct attribute
*);
1827 static int attr_form_is_constant (const struct attribute
*);
1829 static int attr_form_is_ref (const struct attribute
*);
1831 static void fill_in_loclist_baton (struct dwarf2_cu
*cu
,
1832 struct dwarf2_loclist_baton
*baton
,
1833 const struct attribute
*attr
);
1835 static void dwarf2_symbol_mark_computed (const struct attribute
*attr
,
1837 struct dwarf2_cu
*cu
,
1840 static const gdb_byte
*skip_one_die (const struct die_reader_specs
*reader
,
1841 const gdb_byte
*info_ptr
,
1842 struct abbrev_info
*abbrev
);
1844 static hashval_t
partial_die_hash (const void *item
);
1846 static int partial_die_eq (const void *item_lhs
, const void *item_rhs
);
1848 static struct dwarf2_per_cu_data
*dwarf2_find_containing_comp_unit
1849 (sect_offset sect_off
, unsigned int offset_in_dwz
,
1850 struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1852 static void prepare_one_comp_unit (struct dwarf2_cu
*cu
,
1853 struct die_info
*comp_unit_die
,
1854 enum language pretend_language
);
1856 static void age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1858 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data
*);
1860 static struct type
*set_die_type (struct die_info
*, struct type
*,
1861 struct dwarf2_cu
*);
1863 static void create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1865 static int create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1867 static void load_full_comp_unit (struct dwarf2_per_cu_data
*, bool,
1870 static void process_full_comp_unit (struct dwarf2_per_cu_data
*,
1873 static void process_full_type_unit (struct dwarf2_per_cu_data
*,
1876 static void dwarf2_add_dependence (struct dwarf2_cu
*,
1877 struct dwarf2_per_cu_data
*);
1879 static void dwarf2_mark (struct dwarf2_cu
*);
1881 static void dwarf2_clear_marks (struct dwarf2_per_cu_data
*);
1883 static struct type
*get_die_type_at_offset (sect_offset
,
1884 struct dwarf2_per_cu_data
*);
1886 static struct type
*get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
);
1888 static void queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
1889 enum language pretend_language
);
1891 static void process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1893 static struct type
*dwarf2_per_cu_addr_type (struct dwarf2_per_cu_data
*per_cu
);
1894 static struct type
*dwarf2_per_cu_addr_sized_int_type
1895 (struct dwarf2_per_cu_data
*per_cu
, bool unsigned_p
);
1897 /* Class, the destructor of which frees all allocated queue entries. This
1898 will only have work to do if an error was thrown while processing the
1899 dwarf. If no error was thrown then the queue entries should have all
1900 been processed, and freed, as we went along. */
1902 class dwarf2_queue_guard
1905 dwarf2_queue_guard () = default;
1907 /* Free any entries remaining on the queue. There should only be
1908 entries left if we hit an error while processing the dwarf. */
1909 ~dwarf2_queue_guard ()
1911 struct dwarf2_queue_item
*item
, *last
;
1913 item
= dwarf2_queue
;
1916 /* Anything still marked queued is likely to be in an
1917 inconsistent state, so discard it. */
1918 if (item
->per_cu
->queued
)
1920 if (item
->per_cu
->cu
!= NULL
)
1921 free_one_cached_comp_unit (item
->per_cu
);
1922 item
->per_cu
->queued
= 0;
1930 dwarf2_queue
= dwarf2_queue_tail
= NULL
;
1934 /* The return type of find_file_and_directory. Note, the enclosed
1935 string pointers are only valid while this object is valid. */
1937 struct file_and_directory
1939 /* The filename. This is never NULL. */
1942 /* The compilation directory. NULL if not known. If we needed to
1943 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1944 points directly to the DW_AT_comp_dir string attribute owned by
1945 the obstack that owns the DIE. */
1946 const char *comp_dir
;
1948 /* If we needed to build a new string for comp_dir, this is what
1949 owns the storage. */
1950 std::string comp_dir_storage
;
1953 static file_and_directory
find_file_and_directory (struct die_info
*die
,
1954 struct dwarf2_cu
*cu
);
1956 static char *file_full_name (int file
, struct line_header
*lh
,
1957 const char *comp_dir
);
1959 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
1960 enum class rcuh_kind
{ COMPILE
, TYPE
};
1962 static const gdb_byte
*read_and_check_comp_unit_head
1963 (struct dwarf2_per_objfile
* dwarf2_per_objfile
,
1964 struct comp_unit_head
*header
,
1965 struct dwarf2_section_info
*section
,
1966 struct dwarf2_section_info
*abbrev_section
, const gdb_byte
*info_ptr
,
1967 rcuh_kind section_kind
);
1969 static void init_cutu_and_read_dies
1970 (struct dwarf2_per_cu_data
*this_cu
, struct abbrev_table
*abbrev_table
,
1971 int use_existing_cu
, int keep
, bool skip_partial
,
1972 die_reader_func_ftype
*die_reader_func
, void *data
);
1974 static void init_cutu_and_read_dies_simple
1975 (struct dwarf2_per_cu_data
*this_cu
,
1976 die_reader_func_ftype
*die_reader_func
, void *data
);
1978 static htab_t
allocate_signatured_type_table (struct objfile
*objfile
);
1980 static htab_t
allocate_dwo_unit_table (struct objfile
*objfile
);
1982 static struct dwo_unit
*lookup_dwo_unit_in_dwp
1983 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1984 struct dwp_file
*dwp_file
, const char *comp_dir
,
1985 ULONGEST signature
, int is_debug_types
);
1987 static struct dwp_file
*get_dwp_file
1988 (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
1990 static struct dwo_unit
*lookup_dwo_comp_unit
1991 (struct dwarf2_per_cu_data
*, const char *, const char *, ULONGEST
);
1993 static struct dwo_unit
*lookup_dwo_type_unit
1994 (struct signatured_type
*, const char *, const char *);
1996 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*);
1998 /* A unique pointer to a dwo_file. */
2000 typedef std::unique_ptr
<struct dwo_file
> dwo_file_up
;
2002 static void process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
);
2004 static void check_producer (struct dwarf2_cu
*cu
);
2006 static void free_line_header_voidp (void *arg
);
2008 /* Various complaints about symbol reading that don't abort the process. */
2011 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2013 complaint (_("statement list doesn't fit in .debug_line section"));
2017 dwarf2_debug_line_missing_file_complaint (void)
2019 complaint (_(".debug_line section has line data without a file"));
2023 dwarf2_debug_line_missing_end_sequence_complaint (void)
2025 complaint (_(".debug_line section has line "
2026 "program sequence without an end"));
2030 dwarf2_complex_location_expr_complaint (void)
2032 complaint (_("location expression too complex"));
2036 dwarf2_const_value_length_mismatch_complaint (const char *arg1
, int arg2
,
2039 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
2044 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info
*section
)
2046 complaint (_("debug info runs off end of %s section"
2048 get_section_name (section
),
2049 get_section_file_name (section
));
2053 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
2055 complaint (_("macro debug info contains a "
2056 "malformed macro definition:\n`%s'"),
2061 dwarf2_invalid_attrib_class_complaint (const char *arg1
, const char *arg2
)
2063 complaint (_("invalid attribute class or form for '%s' in '%s'"),
2067 /* Hash function for line_header_hash. */
2070 line_header_hash (const struct line_header
*ofs
)
2072 return to_underlying (ofs
->sect_off
) ^ ofs
->offset_in_dwz
;
2075 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2078 line_header_hash_voidp (const void *item
)
2080 const struct line_header
*ofs
= (const struct line_header
*) item
;
2082 return line_header_hash (ofs
);
2085 /* Equality function for line_header_hash. */
2088 line_header_eq_voidp (const void *item_lhs
, const void *item_rhs
)
2090 const struct line_header
*ofs_lhs
= (const struct line_header
*) item_lhs
;
2091 const struct line_header
*ofs_rhs
= (const struct line_header
*) item_rhs
;
2093 return (ofs_lhs
->sect_off
== ofs_rhs
->sect_off
2094 && ofs_lhs
->offset_in_dwz
== ofs_rhs
->offset_in_dwz
);
2099 /* Read the given attribute value as an address, taking the attribute's
2100 form into account. */
2103 attr_value_as_address (struct attribute
*attr
)
2107 if (attr
->form
!= DW_FORM_addr
&& attr
->form
!= DW_FORM_addrx
2108 && attr
->form
!= DW_FORM_GNU_addr_index
)
2110 /* Aside from a few clearly defined exceptions, attributes that
2111 contain an address must always be in DW_FORM_addr form.
2112 Unfortunately, some compilers happen to be violating this
2113 requirement by encoding addresses using other forms, such
2114 as DW_FORM_data4 for example. For those broken compilers,
2115 we try to do our best, without any guarantee of success,
2116 to interpret the address correctly. It would also be nice
2117 to generate a complaint, but that would require us to maintain
2118 a list of legitimate cases where a non-address form is allowed,
2119 as well as update callers to pass in at least the CU's DWARF
2120 version. This is more overhead than what we're willing to
2121 expand for a pretty rare case. */
2122 addr
= DW_UNSND (attr
);
2125 addr
= DW_ADDR (attr
);
2130 /* See declaration. */
2132 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile
*objfile_
,
2133 const dwarf2_debug_sections
*names
)
2134 : objfile (objfile_
)
2137 names
= &dwarf2_elf_names
;
2139 bfd
*obfd
= objfile
->obfd
;
2141 for (asection
*sec
= obfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2142 locate_sections (obfd
, sec
, *names
);
2145 dwarf2_per_objfile::~dwarf2_per_objfile ()
2147 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
2148 free_cached_comp_units ();
2150 if (quick_file_names_table
)
2151 htab_delete (quick_file_names_table
);
2153 if (line_header_hash
)
2154 htab_delete (line_header_hash
);
2156 for (dwarf2_per_cu_data
*per_cu
: all_comp_units
)
2157 VEC_free (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
);
2159 for (signatured_type
*sig_type
: all_type_units
)
2160 VEC_free (dwarf2_per_cu_ptr
, sig_type
->per_cu
.imported_symtabs
);
2162 /* Everything else should be on the objfile obstack. */
2165 /* See declaration. */
2168 dwarf2_per_objfile::free_cached_comp_units ()
2170 dwarf2_per_cu_data
*per_cu
= read_in_chain
;
2171 dwarf2_per_cu_data
**last_chain
= &read_in_chain
;
2172 while (per_cu
!= NULL
)
2174 dwarf2_per_cu_data
*next_cu
= per_cu
->cu
->read_in_chain
;
2177 *last_chain
= next_cu
;
2182 /* A helper class that calls free_cached_comp_units on
2185 class free_cached_comp_units
2189 explicit free_cached_comp_units (dwarf2_per_objfile
*per_objfile
)
2190 : m_per_objfile (per_objfile
)
2194 ~free_cached_comp_units ()
2196 m_per_objfile
->free_cached_comp_units ();
2199 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units
);
2203 dwarf2_per_objfile
*m_per_objfile
;
2206 /* Try to locate the sections we need for DWARF 2 debugging
2207 information and return true if we have enough to do something.
2208 NAMES points to the dwarf2 section names, or is NULL if the standard
2209 ELF names are used. */
2212 dwarf2_has_info (struct objfile
*objfile
,
2213 const struct dwarf2_debug_sections
*names
)
2215 if (objfile
->flags
& OBJF_READNEVER
)
2218 struct dwarf2_per_objfile
*dwarf2_per_objfile
2219 = get_dwarf2_per_objfile (objfile
);
2221 if (dwarf2_per_objfile
== NULL
)
2222 dwarf2_per_objfile
= dwarf2_objfile_data_key
.emplace (objfile
, objfile
,
2225 return (!dwarf2_per_objfile
->info
.is_virtual
2226 && dwarf2_per_objfile
->info
.s
.section
!= NULL
2227 && !dwarf2_per_objfile
->abbrev
.is_virtual
2228 && dwarf2_per_objfile
->abbrev
.s
.section
!= NULL
);
2231 /* Return the containing section of virtual section SECTION. */
2233 static struct dwarf2_section_info
*
2234 get_containing_section (const struct dwarf2_section_info
*section
)
2236 gdb_assert (section
->is_virtual
);
2237 return section
->s
.containing_section
;
2240 /* Return the bfd owner of SECTION. */
2243 get_section_bfd_owner (const struct dwarf2_section_info
*section
)
2245 if (section
->is_virtual
)
2247 section
= get_containing_section (section
);
2248 gdb_assert (!section
->is_virtual
);
2250 return section
->s
.section
->owner
;
2253 /* Return the bfd section of SECTION.
2254 Returns NULL if the section is not present. */
2257 get_section_bfd_section (const struct dwarf2_section_info
*section
)
2259 if (section
->is_virtual
)
2261 section
= get_containing_section (section
);
2262 gdb_assert (!section
->is_virtual
);
2264 return section
->s
.section
;
2267 /* Return the name of SECTION. */
2270 get_section_name (const struct dwarf2_section_info
*section
)
2272 asection
*sectp
= get_section_bfd_section (section
);
2274 gdb_assert (sectp
!= NULL
);
2275 return bfd_section_name (get_section_bfd_owner (section
), sectp
);
2278 /* Return the name of the file SECTION is in. */
2281 get_section_file_name (const struct dwarf2_section_info
*section
)
2283 bfd
*abfd
= get_section_bfd_owner (section
);
2285 return bfd_get_filename (abfd
);
2288 /* Return the id of SECTION.
2289 Returns 0 if SECTION doesn't exist. */
2292 get_section_id (const struct dwarf2_section_info
*section
)
2294 asection
*sectp
= get_section_bfd_section (section
);
2301 /* Return the flags of SECTION.
2302 SECTION (or containing section if this is a virtual section) must exist. */
2305 get_section_flags (const struct dwarf2_section_info
*section
)
2307 asection
*sectp
= get_section_bfd_section (section
);
2309 gdb_assert (sectp
!= NULL
);
2310 return bfd_get_section_flags (sectp
->owner
, sectp
);
2313 /* When loading sections, we look either for uncompressed section or for
2314 compressed section names. */
2317 section_is_p (const char *section_name
,
2318 const struct dwarf2_section_names
*names
)
2320 if (names
->normal
!= NULL
2321 && strcmp (section_name
, names
->normal
) == 0)
2323 if (names
->compressed
!= NULL
2324 && strcmp (section_name
, names
->compressed
) == 0)
2329 /* See declaration. */
2332 dwarf2_per_objfile::locate_sections (bfd
*abfd
, asection
*sectp
,
2333 const dwarf2_debug_sections
&names
)
2335 flagword aflag
= bfd_get_section_flags (abfd
, sectp
);
2337 if ((aflag
& SEC_HAS_CONTENTS
) == 0)
2340 else if (section_is_p (sectp
->name
, &names
.info
))
2342 this->info
.s
.section
= sectp
;
2343 this->info
.size
= bfd_get_section_size (sectp
);
2345 else if (section_is_p (sectp
->name
, &names
.abbrev
))
2347 this->abbrev
.s
.section
= sectp
;
2348 this->abbrev
.size
= bfd_get_section_size (sectp
);
2350 else if (section_is_p (sectp
->name
, &names
.line
))
2352 this->line
.s
.section
= sectp
;
2353 this->line
.size
= bfd_get_section_size (sectp
);
2355 else if (section_is_p (sectp
->name
, &names
.loc
))
2357 this->loc
.s
.section
= sectp
;
2358 this->loc
.size
= bfd_get_section_size (sectp
);
2360 else if (section_is_p (sectp
->name
, &names
.loclists
))
2362 this->loclists
.s
.section
= sectp
;
2363 this->loclists
.size
= bfd_get_section_size (sectp
);
2365 else if (section_is_p (sectp
->name
, &names
.macinfo
))
2367 this->macinfo
.s
.section
= sectp
;
2368 this->macinfo
.size
= bfd_get_section_size (sectp
);
2370 else if (section_is_p (sectp
->name
, &names
.macro
))
2372 this->macro
.s
.section
= sectp
;
2373 this->macro
.size
= bfd_get_section_size (sectp
);
2375 else if (section_is_p (sectp
->name
, &names
.str
))
2377 this->str
.s
.section
= sectp
;
2378 this->str
.size
= bfd_get_section_size (sectp
);
2380 else if (section_is_p (sectp
->name
, &names
.line_str
))
2382 this->line_str
.s
.section
= sectp
;
2383 this->line_str
.size
= bfd_get_section_size (sectp
);
2385 else if (section_is_p (sectp
->name
, &names
.addr
))
2387 this->addr
.s
.section
= sectp
;
2388 this->addr
.size
= bfd_get_section_size (sectp
);
2390 else if (section_is_p (sectp
->name
, &names
.frame
))
2392 this->frame
.s
.section
= sectp
;
2393 this->frame
.size
= bfd_get_section_size (sectp
);
2395 else if (section_is_p (sectp
->name
, &names
.eh_frame
))
2397 this->eh_frame
.s
.section
= sectp
;
2398 this->eh_frame
.size
= bfd_get_section_size (sectp
);
2400 else if (section_is_p (sectp
->name
, &names
.ranges
))
2402 this->ranges
.s
.section
= sectp
;
2403 this->ranges
.size
= bfd_get_section_size (sectp
);
2405 else if (section_is_p (sectp
->name
, &names
.rnglists
))
2407 this->rnglists
.s
.section
= sectp
;
2408 this->rnglists
.size
= bfd_get_section_size (sectp
);
2410 else if (section_is_p (sectp
->name
, &names
.types
))
2412 struct dwarf2_section_info type_section
;
2414 memset (&type_section
, 0, sizeof (type_section
));
2415 type_section
.s
.section
= sectp
;
2416 type_section
.size
= bfd_get_section_size (sectp
);
2418 this->types
.push_back (type_section
);
2420 else if (section_is_p (sectp
->name
, &names
.gdb_index
))
2422 this->gdb_index
.s
.section
= sectp
;
2423 this->gdb_index
.size
= bfd_get_section_size (sectp
);
2425 else if (section_is_p (sectp
->name
, &names
.debug_names
))
2427 this->debug_names
.s
.section
= sectp
;
2428 this->debug_names
.size
= bfd_get_section_size (sectp
);
2430 else if (section_is_p (sectp
->name
, &names
.debug_aranges
))
2432 this->debug_aranges
.s
.section
= sectp
;
2433 this->debug_aranges
.size
= bfd_get_section_size (sectp
);
2436 if ((bfd_get_section_flags (abfd
, sectp
) & (SEC_LOAD
| SEC_ALLOC
))
2437 && bfd_section_vma (abfd
, sectp
) == 0)
2438 this->has_section_at_zero
= true;
2441 /* A helper function that decides whether a section is empty,
2445 dwarf2_section_empty_p (const struct dwarf2_section_info
*section
)
2447 if (section
->is_virtual
)
2448 return section
->size
== 0;
2449 return section
->s
.section
== NULL
|| section
->size
== 0;
2452 /* See dwarf2read.h. */
2455 dwarf2_read_section (struct objfile
*objfile
, dwarf2_section_info
*info
)
2459 gdb_byte
*buf
, *retbuf
;
2463 info
->buffer
= NULL
;
2464 info
->readin
= true;
2466 if (dwarf2_section_empty_p (info
))
2469 sectp
= get_section_bfd_section (info
);
2471 /* If this is a virtual section we need to read in the real one first. */
2472 if (info
->is_virtual
)
2474 struct dwarf2_section_info
*containing_section
=
2475 get_containing_section (info
);
2477 gdb_assert (sectp
!= NULL
);
2478 if ((sectp
->flags
& SEC_RELOC
) != 0)
2480 error (_("Dwarf Error: DWP format V2 with relocations is not"
2481 " supported in section %s [in module %s]"),
2482 get_section_name (info
), get_section_file_name (info
));
2484 dwarf2_read_section (objfile
, containing_section
);
2485 /* Other code should have already caught virtual sections that don't
2487 gdb_assert (info
->virtual_offset
+ info
->size
2488 <= containing_section
->size
);
2489 /* If the real section is empty or there was a problem reading the
2490 section we shouldn't get here. */
2491 gdb_assert (containing_section
->buffer
!= NULL
);
2492 info
->buffer
= containing_section
->buffer
+ info
->virtual_offset
;
2496 /* If the section has relocations, we must read it ourselves.
2497 Otherwise we attach it to the BFD. */
2498 if ((sectp
->flags
& SEC_RELOC
) == 0)
2500 info
->buffer
= gdb_bfd_map_section (sectp
, &info
->size
);
2504 buf
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, info
->size
);
2507 /* When debugging .o files, we may need to apply relocations; see
2508 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2509 We never compress sections in .o files, so we only need to
2510 try this when the section is not compressed. */
2511 retbuf
= symfile_relocate_debug_section (objfile
, sectp
, buf
);
2514 info
->buffer
= retbuf
;
2518 abfd
= get_section_bfd_owner (info
);
2519 gdb_assert (abfd
!= NULL
);
2521 if (bfd_seek (abfd
, sectp
->filepos
, SEEK_SET
) != 0
2522 || bfd_bread (buf
, info
->size
, abfd
) != info
->size
)
2524 error (_("Dwarf Error: Can't read DWARF data"
2525 " in section %s [in module %s]"),
2526 bfd_section_name (abfd
, sectp
), bfd_get_filename (abfd
));
2530 /* A helper function that returns the size of a section in a safe way.
2531 If you are positive that the section has been read before using the
2532 size, then it is safe to refer to the dwarf2_section_info object's
2533 "size" field directly. In other cases, you must call this
2534 function, because for compressed sections the size field is not set
2535 correctly until the section has been read. */
2537 static bfd_size_type
2538 dwarf2_section_size (struct objfile
*objfile
,
2539 struct dwarf2_section_info
*info
)
2542 dwarf2_read_section (objfile
, info
);
2546 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2550 dwarf2_get_section_info (struct objfile
*objfile
,
2551 enum dwarf2_section_enum sect
,
2552 asection
**sectp
, const gdb_byte
**bufp
,
2553 bfd_size_type
*sizep
)
2555 struct dwarf2_per_objfile
*data
= dwarf2_objfile_data_key
.get (objfile
);
2556 struct dwarf2_section_info
*info
;
2558 /* We may see an objfile without any DWARF, in which case we just
2569 case DWARF2_DEBUG_FRAME
:
2570 info
= &data
->frame
;
2572 case DWARF2_EH_FRAME
:
2573 info
= &data
->eh_frame
;
2576 gdb_assert_not_reached ("unexpected section");
2579 dwarf2_read_section (objfile
, info
);
2581 *sectp
= get_section_bfd_section (info
);
2582 *bufp
= info
->buffer
;
2583 *sizep
= info
->size
;
2586 /* A helper function to find the sections for a .dwz file. */
2589 locate_dwz_sections (bfd
*abfd
, asection
*sectp
, void *arg
)
2591 struct dwz_file
*dwz_file
= (struct dwz_file
*) arg
;
2593 /* Note that we only support the standard ELF names, because .dwz
2594 is ELF-only (at the time of writing). */
2595 if (section_is_p (sectp
->name
, &dwarf2_elf_names
.abbrev
))
2597 dwz_file
->abbrev
.s
.section
= sectp
;
2598 dwz_file
->abbrev
.size
= bfd_get_section_size (sectp
);
2600 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.info
))
2602 dwz_file
->info
.s
.section
= sectp
;
2603 dwz_file
->info
.size
= bfd_get_section_size (sectp
);
2605 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.str
))
2607 dwz_file
->str
.s
.section
= sectp
;
2608 dwz_file
->str
.size
= bfd_get_section_size (sectp
);
2610 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.line
))
2612 dwz_file
->line
.s
.section
= sectp
;
2613 dwz_file
->line
.size
= bfd_get_section_size (sectp
);
2615 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.macro
))
2617 dwz_file
->macro
.s
.section
= sectp
;
2618 dwz_file
->macro
.size
= bfd_get_section_size (sectp
);
2620 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.gdb_index
))
2622 dwz_file
->gdb_index
.s
.section
= sectp
;
2623 dwz_file
->gdb_index
.size
= bfd_get_section_size (sectp
);
2625 else if (section_is_p (sectp
->name
, &dwarf2_elf_names
.debug_names
))
2627 dwz_file
->debug_names
.s
.section
= sectp
;
2628 dwz_file
->debug_names
.size
= bfd_get_section_size (sectp
);
2632 /* See dwarf2read.h. */
2635 dwarf2_get_dwz_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
2637 const char *filename
;
2638 bfd_size_type buildid_len_arg
;
2642 if (dwarf2_per_objfile
->dwz_file
!= NULL
)
2643 return dwarf2_per_objfile
->dwz_file
.get ();
2645 bfd_set_error (bfd_error_no_error
);
2646 gdb::unique_xmalloc_ptr
<char> data
2647 (bfd_get_alt_debug_link_info (dwarf2_per_objfile
->objfile
->obfd
,
2648 &buildid_len_arg
, &buildid
));
2651 if (bfd_get_error () == bfd_error_no_error
)
2653 error (_("could not read '.gnu_debugaltlink' section: %s"),
2654 bfd_errmsg (bfd_get_error ()));
2657 gdb::unique_xmalloc_ptr
<bfd_byte
> buildid_holder (buildid
);
2659 buildid_len
= (size_t) buildid_len_arg
;
2661 filename
= data
.get ();
2663 std::string abs_storage
;
2664 if (!IS_ABSOLUTE_PATH (filename
))
2666 gdb::unique_xmalloc_ptr
<char> abs
2667 = gdb_realpath (objfile_name (dwarf2_per_objfile
->objfile
));
2669 abs_storage
= ldirname (abs
.get ()) + SLASH_STRING
+ filename
;
2670 filename
= abs_storage
.c_str ();
2673 /* First try the file name given in the section. If that doesn't
2674 work, try to use the build-id instead. */
2675 gdb_bfd_ref_ptr
dwz_bfd (gdb_bfd_open (filename
, gnutarget
, -1));
2676 if (dwz_bfd
!= NULL
)
2678 if (!build_id_verify (dwz_bfd
.get (), buildid_len
, buildid
))
2679 dwz_bfd
.reset (nullptr);
2682 if (dwz_bfd
== NULL
)
2683 dwz_bfd
= build_id_to_debug_bfd (buildid_len
, buildid
);
2685 if (dwz_bfd
== NULL
)
2686 error (_("could not find '.gnu_debugaltlink' file for %s"),
2687 objfile_name (dwarf2_per_objfile
->objfile
));
2689 std::unique_ptr
<struct dwz_file
> result
2690 (new struct dwz_file (std::move (dwz_bfd
)));
2692 bfd_map_over_sections (result
->dwz_bfd
.get (), locate_dwz_sections
,
2695 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
,
2696 result
->dwz_bfd
.get ());
2697 dwarf2_per_objfile
->dwz_file
= std::move (result
);
2698 return dwarf2_per_objfile
->dwz_file
.get ();
2701 /* DWARF quick_symbols_functions support. */
2703 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2704 unique line tables, so we maintain a separate table of all .debug_line
2705 derived entries to support the sharing.
2706 All the quick functions need is the list of file names. We discard the
2707 line_header when we're done and don't need to record it here. */
2708 struct quick_file_names
2710 /* The data used to construct the hash key. */
2711 struct stmt_list_hash hash
;
2713 /* The number of entries in file_names, real_names. */
2714 unsigned int num_file_names
;
2716 /* The file names from the line table, after being run through
2718 const char **file_names
;
2720 /* The file names from the line table after being run through
2721 gdb_realpath. These are computed lazily. */
2722 const char **real_names
;
2725 /* When using the index (and thus not using psymtabs), each CU has an
2726 object of this type. This is used to hold information needed by
2727 the various "quick" methods. */
2728 struct dwarf2_per_cu_quick_data
2730 /* The file table. This can be NULL if there was no file table
2731 or it's currently not read in.
2732 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2733 struct quick_file_names
*file_names
;
2735 /* The corresponding symbol table. This is NULL if symbols for this
2736 CU have not yet been read. */
2737 struct compunit_symtab
*compunit_symtab
;
2739 /* A temporary mark bit used when iterating over all CUs in
2740 expand_symtabs_matching. */
2741 unsigned int mark
: 1;
2743 /* True if we've tried to read the file table and found there isn't one.
2744 There will be no point in trying to read it again next time. */
2745 unsigned int no_file_data
: 1;
2748 /* Utility hash function for a stmt_list_hash. */
2751 hash_stmt_list_entry (const struct stmt_list_hash
*stmt_list_hash
)
2755 if (stmt_list_hash
->dwo_unit
!= NULL
)
2756 v
+= (uintptr_t) stmt_list_hash
->dwo_unit
->dwo_file
;
2757 v
+= to_underlying (stmt_list_hash
->line_sect_off
);
2761 /* Utility equality function for a stmt_list_hash. */
2764 eq_stmt_list_entry (const struct stmt_list_hash
*lhs
,
2765 const struct stmt_list_hash
*rhs
)
2767 if ((lhs
->dwo_unit
!= NULL
) != (rhs
->dwo_unit
!= NULL
))
2769 if (lhs
->dwo_unit
!= NULL
2770 && lhs
->dwo_unit
->dwo_file
!= rhs
->dwo_unit
->dwo_file
)
2773 return lhs
->line_sect_off
== rhs
->line_sect_off
;
2776 /* Hash function for a quick_file_names. */
2779 hash_file_name_entry (const void *e
)
2781 const struct quick_file_names
*file_data
2782 = (const struct quick_file_names
*) e
;
2784 return hash_stmt_list_entry (&file_data
->hash
);
2787 /* Equality function for a quick_file_names. */
2790 eq_file_name_entry (const void *a
, const void *b
)
2792 const struct quick_file_names
*ea
= (const struct quick_file_names
*) a
;
2793 const struct quick_file_names
*eb
= (const struct quick_file_names
*) b
;
2795 return eq_stmt_list_entry (&ea
->hash
, &eb
->hash
);
2798 /* Delete function for a quick_file_names. */
2801 delete_file_name_entry (void *e
)
2803 struct quick_file_names
*file_data
= (struct quick_file_names
*) e
;
2806 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
2808 xfree ((void*) file_data
->file_names
[i
]);
2809 if (file_data
->real_names
)
2810 xfree ((void*) file_data
->real_names
[i
]);
2813 /* The space for the struct itself lives on objfile_obstack,
2814 so we don't free it here. */
2817 /* Create a quick_file_names hash table. */
2820 create_quick_file_names_table (unsigned int nr_initial_entries
)
2822 return htab_create_alloc (nr_initial_entries
,
2823 hash_file_name_entry
, eq_file_name_entry
,
2824 delete_file_name_entry
, xcalloc
, xfree
);
2827 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2828 have to be created afterwards. You should call age_cached_comp_units after
2829 processing PER_CU->CU. dw2_setup must have been already called. */
2832 load_cu (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2834 if (per_cu
->is_debug_types
)
2835 load_full_type_unit (per_cu
);
2837 load_full_comp_unit (per_cu
, skip_partial
, language_minimal
);
2839 if (per_cu
->cu
== NULL
)
2840 return; /* Dummy CU. */
2842 dwarf2_find_base_address (per_cu
->cu
->dies
, per_cu
->cu
);
2845 /* Read in the symbols for PER_CU. */
2848 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2850 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
2852 /* Skip type_unit_groups, reading the type units they contain
2853 is handled elsewhere. */
2854 if (IS_TYPE_UNIT_GROUP (per_cu
))
2857 /* The destructor of dwarf2_queue_guard frees any entries left on
2858 the queue. After this point we're guaranteed to leave this function
2859 with the dwarf queue empty. */
2860 dwarf2_queue_guard q_guard
;
2862 if (dwarf2_per_objfile
->using_index
2863 ? per_cu
->v
.quick
->compunit_symtab
== NULL
2864 : (per_cu
->v
.psymtab
== NULL
|| !per_cu
->v
.psymtab
->readin
))
2866 queue_comp_unit (per_cu
, language_minimal
);
2867 load_cu (per_cu
, skip_partial
);
2869 /* If we just loaded a CU from a DWO, and we're working with an index
2870 that may badly handle TUs, load all the TUs in that DWO as well.
2871 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2872 if (!per_cu
->is_debug_types
2873 && per_cu
->cu
!= NULL
2874 && per_cu
->cu
->dwo_unit
!= NULL
2875 && dwarf2_per_objfile
->index_table
!= NULL
2876 && dwarf2_per_objfile
->index_table
->version
<= 7
2877 /* DWP files aren't supported yet. */
2878 && get_dwp_file (dwarf2_per_objfile
) == NULL
)
2879 queue_and_load_all_dwo_tus (per_cu
);
2882 process_queue (dwarf2_per_objfile
);
2884 /* Age the cache, releasing compilation units that have not
2885 been used recently. */
2886 age_cached_comp_units (dwarf2_per_objfile
);
2889 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2890 the objfile from which this CU came. Returns the resulting symbol
2893 static struct compunit_symtab
*
2894 dw2_instantiate_symtab (struct dwarf2_per_cu_data
*per_cu
, bool skip_partial
)
2896 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
2898 gdb_assert (dwarf2_per_objfile
->using_index
);
2899 if (!per_cu
->v
.quick
->compunit_symtab
)
2901 free_cached_comp_units
freer (dwarf2_per_objfile
);
2902 scoped_restore decrementer
= increment_reading_symtab ();
2903 dw2_do_instantiate_symtab (per_cu
, skip_partial
);
2904 process_cu_includes (dwarf2_per_objfile
);
2907 return per_cu
->v
.quick
->compunit_symtab
;
2910 /* See declaration. */
2912 dwarf2_per_cu_data
*
2913 dwarf2_per_objfile::get_cutu (int index
)
2915 if (index
>= this->all_comp_units
.size ())
2917 index
-= this->all_comp_units
.size ();
2918 gdb_assert (index
< this->all_type_units
.size ());
2919 return &this->all_type_units
[index
]->per_cu
;
2922 return this->all_comp_units
[index
];
2925 /* See declaration. */
2927 dwarf2_per_cu_data
*
2928 dwarf2_per_objfile::get_cu (int index
)
2930 gdb_assert (index
>= 0 && index
< this->all_comp_units
.size ());
2932 return this->all_comp_units
[index
];
2935 /* See declaration. */
2938 dwarf2_per_objfile::get_tu (int index
)
2940 gdb_assert (index
>= 0 && index
< this->all_type_units
.size ());
2942 return this->all_type_units
[index
];
2945 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2946 objfile_obstack, and constructed with the specified field
2949 static dwarf2_per_cu_data
*
2950 create_cu_from_index_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2951 struct dwarf2_section_info
*section
,
2953 sect_offset sect_off
, ULONGEST length
)
2955 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
2956 dwarf2_per_cu_data
*the_cu
2957 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2958 struct dwarf2_per_cu_data
);
2959 the_cu
->sect_off
= sect_off
;
2960 the_cu
->length
= length
;
2961 the_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
2962 the_cu
->section
= section
;
2963 the_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
2964 struct dwarf2_per_cu_quick_data
);
2965 the_cu
->is_dwz
= is_dwz
;
2969 /* A helper for create_cus_from_index that handles a given list of
2973 create_cus_from_index_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2974 const gdb_byte
*cu_list
, offset_type n_elements
,
2975 struct dwarf2_section_info
*section
,
2978 for (offset_type i
= 0; i
< n_elements
; i
+= 2)
2980 gdb_static_assert (sizeof (ULONGEST
) >= 8);
2982 sect_offset sect_off
2983 = (sect_offset
) extract_unsigned_integer (cu_list
, 8, BFD_ENDIAN_LITTLE
);
2984 ULONGEST length
= extract_unsigned_integer (cu_list
+ 8, 8, BFD_ENDIAN_LITTLE
);
2987 dwarf2_per_cu_data
*per_cu
2988 = create_cu_from_index_list (dwarf2_per_objfile
, section
, is_dwz
,
2990 dwarf2_per_objfile
->all_comp_units
.push_back (per_cu
);
2994 /* Read the CU list from the mapped index, and use it to create all
2995 the CU objects for this objfile. */
2998 create_cus_from_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
2999 const gdb_byte
*cu_list
, offset_type cu_list_elements
,
3000 const gdb_byte
*dwz_list
, offset_type dwz_elements
)
3002 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
3003 dwarf2_per_objfile
->all_comp_units
.reserve
3004 ((cu_list_elements
+ dwz_elements
) / 2);
3006 create_cus_from_index_list (dwarf2_per_objfile
, cu_list
, cu_list_elements
,
3007 &dwarf2_per_objfile
->info
, 0);
3009 if (dwz_elements
== 0)
3012 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
3013 create_cus_from_index_list (dwarf2_per_objfile
, dwz_list
, dwz_elements
,
3017 /* Create the signatured type hash table from the index. */
3020 create_signatured_type_table_from_index
3021 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3022 struct dwarf2_section_info
*section
,
3023 const gdb_byte
*bytes
,
3024 offset_type elements
)
3026 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3028 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
3029 dwarf2_per_objfile
->all_type_units
.reserve (elements
/ 3);
3031 htab_t sig_types_hash
= allocate_signatured_type_table (objfile
);
3033 for (offset_type i
= 0; i
< elements
; i
+= 3)
3035 struct signatured_type
*sig_type
;
3038 cu_offset type_offset_in_tu
;
3040 gdb_static_assert (sizeof (ULONGEST
) >= 8);
3041 sect_offset sect_off
3042 = (sect_offset
) extract_unsigned_integer (bytes
, 8, BFD_ENDIAN_LITTLE
);
3044 = (cu_offset
) extract_unsigned_integer (bytes
+ 8, 8,
3046 signature
= extract_unsigned_integer (bytes
+ 16, 8, BFD_ENDIAN_LITTLE
);
3049 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3050 struct signatured_type
);
3051 sig_type
->signature
= signature
;
3052 sig_type
->type_offset_in_tu
= type_offset_in_tu
;
3053 sig_type
->per_cu
.is_debug_types
= 1;
3054 sig_type
->per_cu
.section
= section
;
3055 sig_type
->per_cu
.sect_off
= sect_off
;
3056 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
3057 sig_type
->per_cu
.v
.quick
3058 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3059 struct dwarf2_per_cu_quick_data
);
3061 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
3064 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
3067 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
3070 /* Create the signatured type hash table from .debug_names. */
3073 create_signatured_type_table_from_debug_names
3074 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3075 const mapped_debug_names
&map
,
3076 struct dwarf2_section_info
*section
,
3077 struct dwarf2_section_info
*abbrev_section
)
3079 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3081 dwarf2_read_section (objfile
, section
);
3082 dwarf2_read_section (objfile
, abbrev_section
);
3084 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
3085 dwarf2_per_objfile
->all_type_units
.reserve (map
.tu_count
);
3087 htab_t sig_types_hash
= allocate_signatured_type_table (objfile
);
3089 for (uint32_t i
= 0; i
< map
.tu_count
; ++i
)
3091 struct signatured_type
*sig_type
;
3094 sect_offset sect_off
3095 = (sect_offset
) (extract_unsigned_integer
3096 (map
.tu_table_reordered
+ i
* map
.offset_size
,
3098 map
.dwarf5_byte_order
));
3100 comp_unit_head cu_header
;
3101 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
3103 section
->buffer
+ to_underlying (sect_off
),
3106 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3107 struct signatured_type
);
3108 sig_type
->signature
= cu_header
.signature
;
3109 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
3110 sig_type
->per_cu
.is_debug_types
= 1;
3111 sig_type
->per_cu
.section
= section
;
3112 sig_type
->per_cu
.sect_off
= sect_off
;
3113 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
3114 sig_type
->per_cu
.v
.quick
3115 = OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
3116 struct dwarf2_per_cu_quick_data
);
3118 slot
= htab_find_slot (sig_types_hash
, sig_type
, INSERT
);
3121 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
3124 dwarf2_per_objfile
->signatured_types
= sig_types_hash
;
3127 /* Read the address map data from the mapped index, and use it to
3128 populate the objfile's psymtabs_addrmap. */
3131 create_addrmap_from_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3132 struct mapped_index
*index
)
3134 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3135 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3136 const gdb_byte
*iter
, *end
;
3137 struct addrmap
*mutable_map
;
3140 auto_obstack temp_obstack
;
3142 mutable_map
= addrmap_create_mutable (&temp_obstack
);
3144 iter
= index
->address_table
.data ();
3145 end
= iter
+ index
->address_table
.size ();
3147 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
3151 ULONGEST hi
, lo
, cu_index
;
3152 lo
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3154 hi
= extract_unsigned_integer (iter
, 8, BFD_ENDIAN_LITTLE
);
3156 cu_index
= extract_unsigned_integer (iter
, 4, BFD_ENDIAN_LITTLE
);
3161 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
3162 hex_string (lo
), hex_string (hi
));
3166 if (cu_index
>= dwarf2_per_objfile
->all_comp_units
.size ())
3168 complaint (_(".gdb_index address table has invalid CU number %u"),
3169 (unsigned) cu_index
);
3173 lo
= gdbarch_adjust_dwarf2_addr (gdbarch
, lo
+ baseaddr
) - baseaddr
;
3174 hi
= gdbarch_adjust_dwarf2_addr (gdbarch
, hi
+ baseaddr
) - baseaddr
;
3175 addrmap_set_empty (mutable_map
, lo
, hi
- 1,
3176 dwarf2_per_objfile
->get_cu (cu_index
));
3179 objfile
->partial_symtabs
->psymtabs_addrmap
3180 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
3183 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3184 populate the objfile's psymtabs_addrmap. */
3187 create_addrmap_from_aranges (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3188 struct dwarf2_section_info
*section
)
3190 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3191 bfd
*abfd
= objfile
->obfd
;
3192 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3193 const CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
3194 SECT_OFF_TEXT (objfile
));
3196 auto_obstack temp_obstack
;
3197 addrmap
*mutable_map
= addrmap_create_mutable (&temp_obstack
);
3199 std::unordered_map
<sect_offset
,
3200 dwarf2_per_cu_data
*,
3201 gdb::hash_enum
<sect_offset
>>
3202 debug_info_offset_to_per_cu
;
3203 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
3205 const auto insertpair
3206 = debug_info_offset_to_per_cu
.emplace (per_cu
->sect_off
, per_cu
);
3207 if (!insertpair
.second
)
3209 warning (_("Section .debug_aranges in %s has duplicate "
3210 "debug_info_offset %s, ignoring .debug_aranges."),
3211 objfile_name (objfile
), sect_offset_str (per_cu
->sect_off
));
3216 dwarf2_read_section (objfile
, section
);
3218 const bfd_endian dwarf5_byte_order
= gdbarch_byte_order (gdbarch
);
3220 const gdb_byte
*addr
= section
->buffer
;
3222 while (addr
< section
->buffer
+ section
->size
)
3224 const gdb_byte
*const entry_addr
= addr
;
3225 unsigned int bytes_read
;
3227 const LONGEST entry_length
= read_initial_length (abfd
, addr
,
3231 const gdb_byte
*const entry_end
= addr
+ entry_length
;
3232 const bool dwarf5_is_dwarf64
= bytes_read
!= 4;
3233 const uint8_t offset_size
= dwarf5_is_dwarf64
? 8 : 4;
3234 if (addr
+ entry_length
> section
->buffer
+ section
->size
)
3236 warning (_("Section .debug_aranges in %s entry at offset %s "
3237 "length %s exceeds section length %s, "
3238 "ignoring .debug_aranges."),
3239 objfile_name (objfile
),
3240 plongest (entry_addr
- section
->buffer
),
3241 plongest (bytes_read
+ entry_length
),
3242 pulongest (section
->size
));
3246 /* The version number. */
3247 const uint16_t version
= read_2_bytes (abfd
, addr
);
3251 warning (_("Section .debug_aranges in %s entry at offset %s "
3252 "has unsupported version %d, ignoring .debug_aranges."),
3253 objfile_name (objfile
),
3254 plongest (entry_addr
- section
->buffer
), version
);
3258 const uint64_t debug_info_offset
3259 = extract_unsigned_integer (addr
, offset_size
, dwarf5_byte_order
);
3260 addr
+= offset_size
;
3261 const auto per_cu_it
3262 = debug_info_offset_to_per_cu
.find (sect_offset (debug_info_offset
));
3263 if (per_cu_it
== debug_info_offset_to_per_cu
.cend ())
3265 warning (_("Section .debug_aranges in %s entry at offset %s "
3266 "debug_info_offset %s does not exists, "
3267 "ignoring .debug_aranges."),
3268 objfile_name (objfile
),
3269 plongest (entry_addr
- section
->buffer
),
3270 pulongest (debug_info_offset
));
3273 dwarf2_per_cu_data
*const per_cu
= per_cu_it
->second
;
3275 const uint8_t address_size
= *addr
++;
3276 if (address_size
< 1 || address_size
> 8)
3278 warning (_("Section .debug_aranges in %s entry at offset %s "
3279 "address_size %u is invalid, ignoring .debug_aranges."),
3280 objfile_name (objfile
),
3281 plongest (entry_addr
- section
->buffer
), address_size
);
3285 const uint8_t segment_selector_size
= *addr
++;
3286 if (segment_selector_size
!= 0)
3288 warning (_("Section .debug_aranges in %s entry at offset %s "
3289 "segment_selector_size %u is not supported, "
3290 "ignoring .debug_aranges."),
3291 objfile_name (objfile
),
3292 plongest (entry_addr
- section
->buffer
),
3293 segment_selector_size
);
3297 /* Must pad to an alignment boundary that is twice the address
3298 size. It is undocumented by the DWARF standard but GCC does
3300 for (size_t padding
= ((-(addr
- section
->buffer
))
3301 & (2 * address_size
- 1));
3302 padding
> 0; padding
--)
3305 warning (_("Section .debug_aranges in %s entry at offset %s "
3306 "padding is not zero, ignoring .debug_aranges."),
3307 objfile_name (objfile
),
3308 plongest (entry_addr
- section
->buffer
));
3314 if (addr
+ 2 * address_size
> entry_end
)
3316 warning (_("Section .debug_aranges in %s entry at offset %s "
3317 "address list is not properly terminated, "
3318 "ignoring .debug_aranges."),
3319 objfile_name (objfile
),
3320 plongest (entry_addr
- section
->buffer
));
3323 ULONGEST start
= extract_unsigned_integer (addr
, address_size
,
3325 addr
+= address_size
;
3326 ULONGEST length
= extract_unsigned_integer (addr
, address_size
,
3328 addr
+= address_size
;
3329 if (start
== 0 && length
== 0)
3331 if (start
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
3333 /* Symbol was eliminated due to a COMDAT group. */
3336 ULONGEST end
= start
+ length
;
3337 start
= (gdbarch_adjust_dwarf2_addr (gdbarch
, start
+ baseaddr
)
3339 end
= (gdbarch_adjust_dwarf2_addr (gdbarch
, end
+ baseaddr
)
3341 addrmap_set_empty (mutable_map
, start
, end
- 1, per_cu
);
3345 objfile
->partial_symtabs
->psymtabs_addrmap
3346 = addrmap_create_fixed (mutable_map
, objfile
->partial_symtabs
->obstack ());
3349 /* Find a slot in the mapped index INDEX for the object named NAME.
3350 If NAME is found, set *VEC_OUT to point to the CU vector in the
3351 constant pool and return true. If NAME cannot be found, return
3355 find_slot_in_mapped_hash (struct mapped_index
*index
, const char *name
,
3356 offset_type
**vec_out
)
3359 offset_type slot
, step
;
3360 int (*cmp
) (const char *, const char *);
3362 gdb::unique_xmalloc_ptr
<char> without_params
;
3363 if (current_language
->la_language
== language_cplus
3364 || current_language
->la_language
== language_fortran
3365 || current_language
->la_language
== language_d
)
3367 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3370 if (strchr (name
, '(') != NULL
)
3372 without_params
= cp_remove_params (name
);
3374 if (without_params
!= NULL
)
3375 name
= without_params
.get ();
3379 /* Index version 4 did not support case insensitive searches. But the
3380 indices for case insensitive languages are built in lowercase, therefore
3381 simulate our NAME being searched is also lowercased. */
3382 hash
= mapped_index_string_hash ((index
->version
== 4
3383 && case_sensitivity
== case_sensitive_off
3384 ? 5 : index
->version
),
3387 slot
= hash
& (index
->symbol_table
.size () - 1);
3388 step
= ((hash
* 17) & (index
->symbol_table
.size () - 1)) | 1;
3389 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
3395 const auto &bucket
= index
->symbol_table
[slot
];
3396 if (bucket
.name
== 0 && bucket
.vec
== 0)
3399 str
= index
->constant_pool
+ MAYBE_SWAP (bucket
.name
);
3400 if (!cmp (name
, str
))
3402 *vec_out
= (offset_type
*) (index
->constant_pool
3403 + MAYBE_SWAP (bucket
.vec
));
3407 slot
= (slot
+ step
) & (index
->symbol_table
.size () - 1);
3411 /* A helper function that reads the .gdb_index from BUFFER and fills
3412 in MAP. FILENAME is the name of the file containing the data;
3413 it is used for error reporting. DEPRECATED_OK is true if it is
3414 ok to use deprecated sections.
3416 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3417 out parameters that are filled in with information about the CU and
3418 TU lists in the section.
3420 Returns true if all went well, false otherwise. */
3423 read_gdb_index_from_buffer (struct objfile
*objfile
,
3424 const char *filename
,
3426 gdb::array_view
<const gdb_byte
> buffer
,
3427 struct mapped_index
*map
,
3428 const gdb_byte
**cu_list
,
3429 offset_type
*cu_list_elements
,
3430 const gdb_byte
**types_list
,
3431 offset_type
*types_list_elements
)
3433 const gdb_byte
*addr
= &buffer
[0];
3435 /* Version check. */
3436 offset_type version
= MAYBE_SWAP (*(offset_type
*) addr
);
3437 /* Versions earlier than 3 emitted every copy of a psymbol. This
3438 causes the index to behave very poorly for certain requests. Version 3
3439 contained incomplete addrmap. So, it seems better to just ignore such
3443 static int warning_printed
= 0;
3444 if (!warning_printed
)
3446 warning (_("Skipping obsolete .gdb_index section in %s."),
3448 warning_printed
= 1;
3452 /* Index version 4 uses a different hash function than index version
3455 Versions earlier than 6 did not emit psymbols for inlined
3456 functions. Using these files will cause GDB not to be able to
3457 set breakpoints on inlined functions by name, so we ignore these
3458 indices unless the user has done
3459 "set use-deprecated-index-sections on". */
3460 if (version
< 6 && !deprecated_ok
)
3462 static int warning_printed
= 0;
3463 if (!warning_printed
)
3466 Skipping deprecated .gdb_index section in %s.\n\
3467 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3468 to use the section anyway."),
3470 warning_printed
= 1;
3474 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3475 of the TU (for symbols coming from TUs),
3476 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3477 Plus gold-generated indices can have duplicate entries for global symbols,
3478 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3479 These are just performance bugs, and we can't distinguish gdb-generated
3480 indices from gold-generated ones, so issue no warning here. */
3482 /* Indexes with higher version than the one supported by GDB may be no
3483 longer backward compatible. */
3487 map
->version
= version
;
3489 offset_type
*metadata
= (offset_type
*) (addr
+ sizeof (offset_type
));
3492 *cu_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3493 *cu_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1]) - MAYBE_SWAP (metadata
[i
]))
3497 *types_list
= addr
+ MAYBE_SWAP (metadata
[i
]);
3498 *types_list_elements
= ((MAYBE_SWAP (metadata
[i
+ 1])
3499 - MAYBE_SWAP (metadata
[i
]))
3503 const gdb_byte
*address_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3504 const gdb_byte
*address_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3506 = gdb::array_view
<const gdb_byte
> (address_table
, address_table_end
);
3509 const gdb_byte
*symbol_table
= addr
+ MAYBE_SWAP (metadata
[i
]);
3510 const gdb_byte
*symbol_table_end
= addr
+ MAYBE_SWAP (metadata
[i
+ 1]);
3512 = gdb::array_view
<mapped_index::symbol_table_slot
>
3513 ((mapped_index::symbol_table_slot
*) symbol_table
,
3514 (mapped_index::symbol_table_slot
*) symbol_table_end
);
3517 map
->constant_pool
= (char *) (addr
+ MAYBE_SWAP (metadata
[i
]));
3522 /* Callback types for dwarf2_read_gdb_index. */
3524 typedef gdb::function_view
3525 <gdb::array_view
<const gdb_byte
>(objfile
*, dwarf2_per_objfile
*)>
3526 get_gdb_index_contents_ftype
;
3527 typedef gdb::function_view
3528 <gdb::array_view
<const gdb_byte
>(objfile
*, dwz_file
*)>
3529 get_gdb_index_contents_dwz_ftype
;
3531 /* Read .gdb_index. If everything went ok, initialize the "quick"
3532 elements of all the CUs and return 1. Otherwise, return 0. */
3535 dwarf2_read_gdb_index
3536 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3537 get_gdb_index_contents_ftype get_gdb_index_contents
,
3538 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz
)
3540 const gdb_byte
*cu_list
, *types_list
, *dwz_list
= NULL
;
3541 offset_type cu_list_elements
, types_list_elements
, dwz_list_elements
= 0;
3542 struct dwz_file
*dwz
;
3543 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3545 gdb::array_view
<const gdb_byte
> main_index_contents
3546 = get_gdb_index_contents (objfile
, dwarf2_per_objfile
);
3548 if (main_index_contents
.empty ())
3551 std::unique_ptr
<struct mapped_index
> map (new struct mapped_index
);
3552 if (!read_gdb_index_from_buffer (objfile
, objfile_name (objfile
),
3553 use_deprecated_index_sections
,
3554 main_index_contents
, map
.get (), &cu_list
,
3555 &cu_list_elements
, &types_list
,
3556 &types_list_elements
))
3559 /* Don't use the index if it's empty. */
3560 if (map
->symbol_table
.empty ())
3563 /* If there is a .dwz file, read it so we can get its CU list as
3565 dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
3568 struct mapped_index dwz_map
;
3569 const gdb_byte
*dwz_types_ignore
;
3570 offset_type dwz_types_elements_ignore
;
3572 gdb::array_view
<const gdb_byte
> dwz_index_content
3573 = get_gdb_index_contents_dwz (objfile
, dwz
);
3575 if (dwz_index_content
.empty ())
3578 if (!read_gdb_index_from_buffer (objfile
,
3579 bfd_get_filename (dwz
->dwz_bfd
), 1,
3580 dwz_index_content
, &dwz_map
,
3581 &dwz_list
, &dwz_list_elements
,
3583 &dwz_types_elements_ignore
))
3585 warning (_("could not read '.gdb_index' section from %s; skipping"),
3586 bfd_get_filename (dwz
->dwz_bfd
));
3591 create_cus_from_index (dwarf2_per_objfile
, cu_list
, cu_list_elements
,
3592 dwz_list
, dwz_list_elements
);
3594 if (types_list_elements
)
3596 /* We can only handle a single .debug_types when we have an
3598 if (dwarf2_per_objfile
->types
.size () != 1)
3601 dwarf2_section_info
*section
= &dwarf2_per_objfile
->types
[0];
3603 create_signatured_type_table_from_index (dwarf2_per_objfile
, section
,
3604 types_list
, types_list_elements
);
3607 create_addrmap_from_index (dwarf2_per_objfile
, map
.get ());
3609 dwarf2_per_objfile
->index_table
= std::move (map
);
3610 dwarf2_per_objfile
->using_index
= 1;
3611 dwarf2_per_objfile
->quick_file_names_table
=
3612 create_quick_file_names_table (dwarf2_per_objfile
->all_comp_units
.size ());
3617 /* die_reader_func for dw2_get_file_names. */
3620 dw2_get_file_names_reader (const struct die_reader_specs
*reader
,
3621 const gdb_byte
*info_ptr
,
3622 struct die_info
*comp_unit_die
,
3626 struct dwarf2_cu
*cu
= reader
->cu
;
3627 struct dwarf2_per_cu_data
*this_cu
= cu
->per_cu
;
3628 struct dwarf2_per_objfile
*dwarf2_per_objfile
3629 = cu
->per_cu
->dwarf2_per_objfile
;
3630 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
3631 struct dwarf2_per_cu_data
*lh_cu
;
3632 struct attribute
*attr
;
3635 struct quick_file_names
*qfn
;
3637 gdb_assert (! this_cu
->is_debug_types
);
3639 /* Our callers never want to match partial units -- instead they
3640 will match the enclosing full CU. */
3641 if (comp_unit_die
->tag
== DW_TAG_partial_unit
)
3643 this_cu
->v
.quick
->no_file_data
= 1;
3651 sect_offset line_offset
{};
3653 attr
= dwarf2_attr (comp_unit_die
, DW_AT_stmt_list
, cu
);
3656 struct quick_file_names find_entry
;
3658 line_offset
= (sect_offset
) DW_UNSND (attr
);
3660 /* We may have already read in this line header (TU line header sharing).
3661 If we have we're done. */
3662 find_entry
.hash
.dwo_unit
= cu
->dwo_unit
;
3663 find_entry
.hash
.line_sect_off
= line_offset
;
3664 slot
= htab_find_slot (dwarf2_per_objfile
->quick_file_names_table
,
3665 &find_entry
, INSERT
);
3668 lh_cu
->v
.quick
->file_names
= (struct quick_file_names
*) *slot
;
3672 lh
= dwarf_decode_line_header (line_offset
, cu
);
3676 lh_cu
->v
.quick
->no_file_data
= 1;
3680 qfn
= XOBNEW (&objfile
->objfile_obstack
, struct quick_file_names
);
3681 qfn
->hash
.dwo_unit
= cu
->dwo_unit
;
3682 qfn
->hash
.line_sect_off
= line_offset
;
3683 gdb_assert (slot
!= NULL
);
3686 file_and_directory fnd
= find_file_and_directory (comp_unit_die
, cu
);
3688 qfn
->num_file_names
= lh
->file_names
.size ();
3690 XOBNEWVEC (&objfile
->objfile_obstack
, const char *, lh
->file_names
.size ());
3691 for (i
= 0; i
< lh
->file_names
.size (); ++i
)
3692 qfn
->file_names
[i
] = file_full_name (i
+ 1, lh
.get (), fnd
.comp_dir
);
3693 qfn
->real_names
= NULL
;
3695 lh_cu
->v
.quick
->file_names
= qfn
;
3698 /* A helper for the "quick" functions which attempts to read the line
3699 table for THIS_CU. */
3701 static struct quick_file_names
*
3702 dw2_get_file_names (struct dwarf2_per_cu_data
*this_cu
)
3704 /* This should never be called for TUs. */
3705 gdb_assert (! this_cu
->is_debug_types
);
3706 /* Nor type unit groups. */
3707 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu
));
3709 if (this_cu
->v
.quick
->file_names
!= NULL
)
3710 return this_cu
->v
.quick
->file_names
;
3711 /* If we know there is no line data, no point in looking again. */
3712 if (this_cu
->v
.quick
->no_file_data
)
3715 init_cutu_and_read_dies_simple (this_cu
, dw2_get_file_names_reader
, NULL
);
3717 if (this_cu
->v
.quick
->no_file_data
)
3719 return this_cu
->v
.quick
->file_names
;
3722 /* A helper for the "quick" functions which computes and caches the
3723 real path for a given file name from the line table. */
3726 dw2_get_real_path (struct objfile
*objfile
,
3727 struct quick_file_names
*qfn
, int index
)
3729 if (qfn
->real_names
== NULL
)
3730 qfn
->real_names
= OBSTACK_CALLOC (&objfile
->objfile_obstack
,
3731 qfn
->num_file_names
, const char *);
3733 if (qfn
->real_names
[index
] == NULL
)
3734 qfn
->real_names
[index
] = gdb_realpath (qfn
->file_names
[index
]).release ();
3736 return qfn
->real_names
[index
];
3739 static struct symtab
*
3740 dw2_find_last_source_symtab (struct objfile
*objfile
)
3742 struct dwarf2_per_objfile
*dwarf2_per_objfile
3743 = get_dwarf2_per_objfile (objfile
);
3744 dwarf2_per_cu_data
*dwarf_cu
= dwarf2_per_objfile
->all_comp_units
.back ();
3745 compunit_symtab
*cust
= dw2_instantiate_symtab (dwarf_cu
, false);
3750 return compunit_primary_filetab (cust
);
3753 /* Traversal function for dw2_forget_cached_source_info. */
3756 dw2_free_cached_file_names (void **slot
, void *info
)
3758 struct quick_file_names
*file_data
= (struct quick_file_names
*) *slot
;
3760 if (file_data
->real_names
)
3764 for (i
= 0; i
< file_data
->num_file_names
; ++i
)
3766 xfree ((void*) file_data
->real_names
[i
]);
3767 file_data
->real_names
[i
] = NULL
;
3775 dw2_forget_cached_source_info (struct objfile
*objfile
)
3777 struct dwarf2_per_objfile
*dwarf2_per_objfile
3778 = get_dwarf2_per_objfile (objfile
);
3780 htab_traverse_noresize (dwarf2_per_objfile
->quick_file_names_table
,
3781 dw2_free_cached_file_names
, NULL
);
3784 /* Helper function for dw2_map_symtabs_matching_filename that expands
3785 the symtabs and calls the iterator. */
3788 dw2_map_expand_apply (struct objfile
*objfile
,
3789 struct dwarf2_per_cu_data
*per_cu
,
3790 const char *name
, const char *real_path
,
3791 gdb::function_view
<bool (symtab
*)> callback
)
3793 struct compunit_symtab
*last_made
= objfile
->compunit_symtabs
;
3795 /* Don't visit already-expanded CUs. */
3796 if (per_cu
->v
.quick
->compunit_symtab
)
3799 /* This may expand more than one symtab, and we want to iterate over
3801 dw2_instantiate_symtab (per_cu
, false);
3803 return iterate_over_some_symtabs (name
, real_path
, objfile
->compunit_symtabs
,
3804 last_made
, callback
);
3807 /* Implementation of the map_symtabs_matching_filename method. */
3810 dw2_map_symtabs_matching_filename
3811 (struct objfile
*objfile
, const char *name
, const char *real_path
,
3812 gdb::function_view
<bool (symtab
*)> callback
)
3814 const char *name_basename
= lbasename (name
);
3815 struct dwarf2_per_objfile
*dwarf2_per_objfile
3816 = get_dwarf2_per_objfile (objfile
);
3818 /* The rule is CUs specify all the files, including those used by
3819 any TU, so there's no need to scan TUs here. */
3821 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
3823 /* We only need to look at symtabs not already expanded. */
3824 if (per_cu
->v
.quick
->compunit_symtab
)
3827 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
3828 if (file_data
== NULL
)
3831 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
3833 const char *this_name
= file_data
->file_names
[j
];
3834 const char *this_real_name
;
3836 if (compare_filenames_for_search (this_name
, name
))
3838 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3844 /* Before we invoke realpath, which can get expensive when many
3845 files are involved, do a quick comparison of the basenames. */
3846 if (! basenames_may_differ
3847 && FILENAME_CMP (lbasename (this_name
), name_basename
) != 0)
3850 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
3851 if (compare_filenames_for_search (this_real_name
, name
))
3853 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3859 if (real_path
!= NULL
)
3861 gdb_assert (IS_ABSOLUTE_PATH (real_path
));
3862 gdb_assert (IS_ABSOLUTE_PATH (name
));
3863 if (this_real_name
!= NULL
3864 && FILENAME_CMP (real_path
, this_real_name
) == 0)
3866 if (dw2_map_expand_apply (objfile
, per_cu
, name
, real_path
,
3878 /* Struct used to manage iterating over all CUs looking for a symbol. */
3880 struct dw2_symtab_iterator
3882 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3883 struct dwarf2_per_objfile
*dwarf2_per_objfile
;
3884 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3885 int want_specific_block
;
3886 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3887 Unused if !WANT_SPECIFIC_BLOCK. */
3889 /* The kind of symbol we're looking for. */
3891 /* The list of CUs from the index entry of the symbol,
3892 or NULL if not found. */
3894 /* The next element in VEC to look at. */
3896 /* The number of elements in VEC, or zero if there is no match. */
3898 /* Have we seen a global version of the symbol?
3899 If so we can ignore all further global instances.
3900 This is to work around gold/15646, inefficient gold-generated
3905 /* Initialize the index symtab iterator ITER.
3906 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3907 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3910 dw2_symtab_iter_init (struct dw2_symtab_iterator
*iter
,
3911 struct dwarf2_per_objfile
*dwarf2_per_objfile
,
3912 int want_specific_block
,
3917 iter
->dwarf2_per_objfile
= dwarf2_per_objfile
;
3918 iter
->want_specific_block
= want_specific_block
;
3919 iter
->block_index
= block_index
;
3920 iter
->domain
= domain
;
3922 iter
->global_seen
= 0;
3924 mapped_index
*index
= dwarf2_per_objfile
->index_table
.get ();
3926 /* index is NULL if OBJF_READNOW. */
3927 if (index
!= NULL
&& find_slot_in_mapped_hash (index
, name
, &iter
->vec
))
3928 iter
->length
= MAYBE_SWAP (*iter
->vec
);
3936 /* Return the next matching CU or NULL if there are no more. */
3938 static struct dwarf2_per_cu_data
*
3939 dw2_symtab_iter_next (struct dw2_symtab_iterator
*iter
)
3941 struct dwarf2_per_objfile
*dwarf2_per_objfile
= iter
->dwarf2_per_objfile
;
3943 for ( ; iter
->next
< iter
->length
; ++iter
->next
)
3945 offset_type cu_index_and_attrs
=
3946 MAYBE_SWAP (iter
->vec
[iter
->next
+ 1]);
3947 offset_type cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
3948 int want_static
= iter
->block_index
!= GLOBAL_BLOCK
;
3949 /* This value is only valid for index versions >= 7. */
3950 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
3951 gdb_index_symbol_kind symbol_kind
=
3952 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
3953 /* Only check the symbol attributes if they're present.
3954 Indices prior to version 7 don't record them,
3955 and indices >= 7 may elide them for certain symbols
3956 (gold does this). */
3958 (dwarf2_per_objfile
->index_table
->version
>= 7
3959 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
3961 /* Don't crash on bad data. */
3962 if (cu_index
>= (dwarf2_per_objfile
->all_comp_units
.size ()
3963 + dwarf2_per_objfile
->all_type_units
.size ()))
3965 complaint (_(".gdb_index entry has bad CU index"
3967 objfile_name (dwarf2_per_objfile
->objfile
));
3971 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (cu_index
);
3973 /* Skip if already read in. */
3974 if (per_cu
->v
.quick
->compunit_symtab
)
3977 /* Check static vs global. */
3980 if (iter
->want_specific_block
3981 && want_static
!= is_static
)
3983 /* Work around gold/15646. */
3984 if (!is_static
&& iter
->global_seen
)
3987 iter
->global_seen
= 1;
3990 /* Only check the symbol's kind if it has one. */
3993 switch (iter
->domain
)
3996 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
3997 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
3998 /* Some types are also in VAR_DOMAIN. */
3999 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4003 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
4007 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_OTHER
)
4022 static struct compunit_symtab
*
4023 dw2_lookup_symbol (struct objfile
*objfile
, int block_index
,
4024 const char *name
, domain_enum domain
)
4026 struct compunit_symtab
*stab_best
= NULL
;
4027 struct dwarf2_per_objfile
*dwarf2_per_objfile
4028 = get_dwarf2_per_objfile (objfile
);
4030 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
4032 struct dw2_symtab_iterator iter
;
4033 struct dwarf2_per_cu_data
*per_cu
;
4035 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, 1, block_index
, domain
, name
);
4037 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
4039 struct symbol
*sym
, *with_opaque
= NULL
;
4040 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
, false);
4041 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
4042 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
4044 sym
= block_find_symbol (block
, name
, domain
,
4045 block_find_non_opaque_type_preferred
,
4048 /* Some caution must be observed with overloaded functions
4049 and methods, since the index will not contain any overload
4050 information (but NAME might contain it). */
4053 && SYMBOL_MATCHES_SEARCH_NAME (sym
, lookup_name
))
4055 if (with_opaque
!= NULL
4056 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque
, lookup_name
))
4059 /* Keep looking through other CUs. */
4066 dw2_print_stats (struct objfile
*objfile
)
4068 struct dwarf2_per_objfile
*dwarf2_per_objfile
4069 = get_dwarf2_per_objfile (objfile
);
4070 int total
= (dwarf2_per_objfile
->all_comp_units
.size ()
4071 + dwarf2_per_objfile
->all_type_units
.size ());
4074 for (int i
= 0; i
< total
; ++i
)
4076 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
4078 if (!per_cu
->v
.quick
->compunit_symtab
)
4081 printf_filtered (_(" Number of read CUs: %d\n"), total
- count
);
4082 printf_filtered (_(" Number of unread CUs: %d\n"), count
);
4085 /* This dumps minimal information about the index.
4086 It is called via "mt print objfiles".
4087 One use is to verify .gdb_index has been loaded by the
4088 gdb.dwarf2/gdb-index.exp testcase. */
4091 dw2_dump (struct objfile
*objfile
)
4093 struct dwarf2_per_objfile
*dwarf2_per_objfile
4094 = get_dwarf2_per_objfile (objfile
);
4096 gdb_assert (dwarf2_per_objfile
->using_index
);
4097 printf_filtered (".gdb_index:");
4098 if (dwarf2_per_objfile
->index_table
!= NULL
)
4100 printf_filtered (" version %d\n",
4101 dwarf2_per_objfile
->index_table
->version
);
4104 printf_filtered (" faked for \"readnow\"\n");
4105 printf_filtered ("\n");
4109 dw2_expand_symtabs_for_function (struct objfile
*objfile
,
4110 const char *func_name
)
4112 struct dwarf2_per_objfile
*dwarf2_per_objfile
4113 = get_dwarf2_per_objfile (objfile
);
4115 struct dw2_symtab_iterator iter
;
4116 struct dwarf2_per_cu_data
*per_cu
;
4118 /* Note: It doesn't matter what we pass for block_index here. */
4119 dw2_symtab_iter_init (&iter
, dwarf2_per_objfile
, 0, GLOBAL_BLOCK
, VAR_DOMAIN
,
4122 while ((per_cu
= dw2_symtab_iter_next (&iter
)) != NULL
)
4123 dw2_instantiate_symtab (per_cu
, false);
4128 dw2_expand_all_symtabs (struct objfile
*objfile
)
4130 struct dwarf2_per_objfile
*dwarf2_per_objfile
4131 = get_dwarf2_per_objfile (objfile
);
4132 int total_units
= (dwarf2_per_objfile
->all_comp_units
.size ()
4133 + dwarf2_per_objfile
->all_type_units
.size ());
4135 for (int i
= 0; i
< total_units
; ++i
)
4137 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
4139 /* We don't want to directly expand a partial CU, because if we
4140 read it with the wrong language, then assertion failures can
4141 be triggered later on. See PR symtab/23010. So, tell
4142 dw2_instantiate_symtab to skip partial CUs -- any important
4143 partial CU will be read via DW_TAG_imported_unit anyway. */
4144 dw2_instantiate_symtab (per_cu
, true);
4149 dw2_expand_symtabs_with_fullname (struct objfile
*objfile
,
4150 const char *fullname
)
4152 struct dwarf2_per_objfile
*dwarf2_per_objfile
4153 = get_dwarf2_per_objfile (objfile
);
4155 /* We don't need to consider type units here.
4156 This is only called for examining code, e.g. expand_line_sal.
4157 There can be an order of magnitude (or more) more type units
4158 than comp units, and we avoid them if we can. */
4160 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
4162 /* We only need to look at symtabs not already expanded. */
4163 if (per_cu
->v
.quick
->compunit_symtab
)
4166 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
4167 if (file_data
== NULL
)
4170 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
4172 const char *this_fullname
= file_data
->file_names
[j
];
4174 if (filename_cmp (this_fullname
, fullname
) == 0)
4176 dw2_instantiate_symtab (per_cu
, false);
4184 dw2_map_matching_symbols (struct objfile
*objfile
,
4185 const char * name
, domain_enum domain
,
4187 int (*callback
) (const struct block
*,
4188 struct symbol
*, void *),
4189 void *data
, symbol_name_match_type match
,
4190 symbol_compare_ftype
*ordered_compare
)
4192 /* Currently unimplemented; used for Ada. The function can be called if the
4193 current language is Ada for a non-Ada objfile using GNU index. As Ada
4194 does not look for non-Ada symbols this function should just return. */
4197 /* Symbol name matcher for .gdb_index names.
4199 Symbol names in .gdb_index have a few particularities:
4201 - There's no indication of which is the language of each symbol.
4203 Since each language has its own symbol name matching algorithm,
4204 and we don't know which language is the right one, we must match
4205 each symbol against all languages. This would be a potential
4206 performance problem if it were not mitigated by the
4207 mapped_index::name_components lookup table, which significantly
4208 reduces the number of times we need to call into this matcher,
4209 making it a non-issue.
4211 - Symbol names in the index have no overload (parameter)
4212 information. I.e., in C++, "foo(int)" and "foo(long)" both
4213 appear as "foo" in the index, for example.
4215 This means that the lookup names passed to the symbol name
4216 matcher functions must have no parameter information either
4217 because (e.g.) symbol search name "foo" does not match
4218 lookup-name "foo(int)" [while swapping search name for lookup
4221 class gdb_index_symbol_name_matcher
4224 /* Prepares the vector of comparison functions for LOOKUP_NAME. */
4225 gdb_index_symbol_name_matcher (const lookup_name_info
&lookup_name
);
4227 /* Walk all the matcher routines and match SYMBOL_NAME against them.
4228 Returns true if any matcher matches. */
4229 bool matches (const char *symbol_name
);
4232 /* A reference to the lookup name we're matching against. */
4233 const lookup_name_info
&m_lookup_name
;
4235 /* A vector holding all the different symbol name matchers, for all
4237 std::vector
<symbol_name_matcher_ftype
*> m_symbol_name_matcher_funcs
;
4240 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4241 (const lookup_name_info
&lookup_name
)
4242 : m_lookup_name (lookup_name
)
4244 /* Prepare the vector of comparison functions upfront, to avoid
4245 doing the same work for each symbol. Care is taken to avoid
4246 matching with the same matcher more than once if/when multiple
4247 languages use the same matcher function. */
4248 auto &matchers
= m_symbol_name_matcher_funcs
;
4249 matchers
.reserve (nr_languages
);
4251 matchers
.push_back (default_symbol_name_matcher
);
4253 for (int i
= 0; i
< nr_languages
; i
++)
4255 const language_defn
*lang
= language_def ((enum language
) i
);
4256 symbol_name_matcher_ftype
*name_matcher
4257 = get_symbol_name_matcher (lang
, m_lookup_name
);
4259 /* Don't insert the same comparison routine more than once.
4260 Note that we do this linear walk instead of a seemingly
4261 cheaper sorted insert, or use a std::set or something like
4262 that, because relative order of function addresses is not
4263 stable. This is not a problem in practice because the number
4264 of supported languages is low, and the cost here is tiny
4265 compared to the number of searches we'll do afterwards using
4267 if (name_matcher
!= default_symbol_name_matcher
4268 && (std::find (matchers
.begin (), matchers
.end (), name_matcher
)
4269 == matchers
.end ()))
4270 matchers
.push_back (name_matcher
);
4275 gdb_index_symbol_name_matcher::matches (const char *symbol_name
)
4277 for (auto matches_name
: m_symbol_name_matcher_funcs
)
4278 if (matches_name (symbol_name
, m_lookup_name
, NULL
))
4284 /* Starting from a search name, return the string that finds the upper
4285 bound of all strings that start with SEARCH_NAME in a sorted name
4286 list. Returns the empty string to indicate that the upper bound is
4287 the end of the list. */
4290 make_sort_after_prefix_name (const char *search_name
)
4292 /* When looking to complete "func", we find the upper bound of all
4293 symbols that start with "func" by looking for where we'd insert
4294 the closest string that would follow "func" in lexicographical
4295 order. Usually, that's "func"-with-last-character-incremented,
4296 i.e. "fund". Mind non-ASCII characters, though. Usually those
4297 will be UTF-8 multi-byte sequences, but we can't be certain.
4298 Especially mind the 0xff character, which is a valid character in
4299 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4300 rule out compilers allowing it in identifiers. Note that
4301 conveniently, strcmp/strcasecmp are specified to compare
4302 characters interpreted as unsigned char. So what we do is treat
4303 the whole string as a base 256 number composed of a sequence of
4304 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4305 to 0, and carries 1 to the following more-significant position.
4306 If the very first character in SEARCH_NAME ends up incremented
4307 and carries/overflows, then the upper bound is the end of the
4308 list. The string after the empty string is also the empty
4311 Some examples of this operation:
4313 SEARCH_NAME => "+1" RESULT
4317 "\xff" "a" "\xff" => "\xff" "b"
4322 Then, with these symbols for example:
4328 completing "func" looks for symbols between "func" and
4329 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4330 which finds "func" and "func1", but not "fund".
4334 funcÿ (Latin1 'ÿ' [0xff])
4338 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4339 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4343 ÿÿ (Latin1 'ÿ' [0xff])
4346 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4347 the end of the list.
4349 std::string after
= search_name
;
4350 while (!after
.empty () && (unsigned char) after
.back () == 0xff)
4352 if (!after
.empty ())
4353 after
.back () = (unsigned char) after
.back () + 1;
4357 /* See declaration. */
4359 std::pair
<std::vector
<name_component
>::const_iterator
,
4360 std::vector
<name_component
>::const_iterator
>
4361 mapped_index_base::find_name_components_bounds
4362 (const lookup_name_info
&lookup_name_without_params
) const
4365 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4368 = lookup_name_without_params
.cplus ().lookup_name ().c_str ();
4370 /* Comparison function object for lower_bound that matches against a
4371 given symbol name. */
4372 auto lookup_compare_lower
= [&] (const name_component
&elem
,
4375 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4376 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4377 return name_cmp (elem_name
, name
) < 0;
4380 /* Comparison function object for upper_bound that matches against a
4381 given symbol name. */
4382 auto lookup_compare_upper
= [&] (const char *name
,
4383 const name_component
&elem
)
4385 const char *elem_qualified
= this->symbol_name_at (elem
.idx
);
4386 const char *elem_name
= elem_qualified
+ elem
.name_offset
;
4387 return name_cmp (name
, elem_name
) < 0;
4390 auto begin
= this->name_components
.begin ();
4391 auto end
= this->name_components
.end ();
4393 /* Find the lower bound. */
4396 if (lookup_name_without_params
.completion_mode () && cplus
[0] == '\0')
4399 return std::lower_bound (begin
, end
, cplus
, lookup_compare_lower
);
4402 /* Find the upper bound. */
4405 if (lookup_name_without_params
.completion_mode ())
4407 /* In completion mode, we want UPPER to point past all
4408 symbols names that have the same prefix. I.e., with
4409 these symbols, and completing "func":
4411 function << lower bound
4413 other_function << upper bound
4415 We find the upper bound by looking for the insertion
4416 point of "func"-with-last-character-incremented,
4418 std::string after
= make_sort_after_prefix_name (cplus
);
4421 return std::lower_bound (lower
, end
, after
.c_str (),
4422 lookup_compare_lower
);
4425 return std::upper_bound (lower
, end
, cplus
, lookup_compare_upper
);
4428 return {lower
, upper
};
4431 /* See declaration. */
4434 mapped_index_base::build_name_components ()
4436 if (!this->name_components
.empty ())
4439 this->name_components_casing
= case_sensitivity
;
4441 = this->name_components_casing
== case_sensitive_on
? strcmp
: strcasecmp
;
4443 /* The code below only knows how to break apart components of C++
4444 symbol names (and other languages that use '::' as
4445 namespace/module separator). If we add support for wild matching
4446 to some language that uses some other operator (E.g., Ada, Go and
4447 D use '.'), then we'll need to try splitting the symbol name
4448 according to that language too. Note that Ada does support wild
4449 matching, but doesn't currently support .gdb_index. */
4450 auto count
= this->symbol_name_count ();
4451 for (offset_type idx
= 0; idx
< count
; idx
++)
4453 if (this->symbol_name_slot_invalid (idx
))
4456 const char *name
= this->symbol_name_at (idx
);
4458 /* Add each name component to the name component table. */
4459 unsigned int previous_len
= 0;
4460 for (unsigned int current_len
= cp_find_first_component (name
);
4461 name
[current_len
] != '\0';
4462 current_len
+= cp_find_first_component (name
+ current_len
))
4464 gdb_assert (name
[current_len
] == ':');
4465 this->name_components
.push_back ({previous_len
, idx
});
4466 /* Skip the '::'. */
4468 previous_len
= current_len
;
4470 this->name_components
.push_back ({previous_len
, idx
});
4473 /* Sort name_components elements by name. */
4474 auto name_comp_compare
= [&] (const name_component
&left
,
4475 const name_component
&right
)
4477 const char *left_qualified
= this->symbol_name_at (left
.idx
);
4478 const char *right_qualified
= this->symbol_name_at (right
.idx
);
4480 const char *left_name
= left_qualified
+ left
.name_offset
;
4481 const char *right_name
= right_qualified
+ right
.name_offset
;
4483 return name_cmp (left_name
, right_name
) < 0;
4486 std::sort (this->name_components
.begin (),
4487 this->name_components
.end (),
4491 /* Helper for dw2_expand_symtabs_matching that works with a
4492 mapped_index_base instead of the containing objfile. This is split
4493 to a separate function in order to be able to unit test the
4494 name_components matching using a mock mapped_index_base. For each
4495 symbol name that matches, calls MATCH_CALLBACK, passing it the
4496 symbol's index in the mapped_index_base symbol table. */
4499 dw2_expand_symtabs_matching_symbol
4500 (mapped_index_base
&index
,
4501 const lookup_name_info
&lookup_name_in
,
4502 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
4503 enum search_domain kind
,
4504 gdb::function_view
<void (offset_type
)> match_callback
)
4506 lookup_name_info lookup_name_without_params
4507 = lookup_name_in
.make_ignore_params ();
4508 gdb_index_symbol_name_matcher lookup_name_matcher
4509 (lookup_name_without_params
);
4511 /* Build the symbol name component sorted vector, if we haven't
4513 index
.build_name_components ();
4515 auto bounds
= index
.find_name_components_bounds (lookup_name_without_params
);
4517 /* Now for each symbol name in range, check to see if we have a name
4518 match, and if so, call the MATCH_CALLBACK callback. */
4520 /* The same symbol may appear more than once in the range though.
4521 E.g., if we're looking for symbols that complete "w", and we have
4522 a symbol named "w1::w2", we'll find the two name components for
4523 that same symbol in the range. To be sure we only call the
4524 callback once per symbol, we first collect the symbol name
4525 indexes that matched in a temporary vector and ignore
4527 std::vector
<offset_type
> matches
;
4528 matches
.reserve (std::distance (bounds
.first
, bounds
.second
));
4530 for (; bounds
.first
!= bounds
.second
; ++bounds
.first
)
4532 const char *qualified
= index
.symbol_name_at (bounds
.first
->idx
);
4534 if (!lookup_name_matcher
.matches (qualified
)
4535 || (symbol_matcher
!= NULL
&& !symbol_matcher (qualified
)))
4538 matches
.push_back (bounds
.first
->idx
);
4541 std::sort (matches
.begin (), matches
.end ());
4543 /* Finally call the callback, once per match. */
4545 for (offset_type idx
: matches
)
4549 match_callback (idx
);
4554 /* Above we use a type wider than idx's for 'prev', since 0 and
4555 (offset_type)-1 are both possible values. */
4556 static_assert (sizeof (prev
) > sizeof (offset_type
), "");
4561 namespace selftests
{ namespace dw2_expand_symtabs_matching
{
4563 /* A mock .gdb_index/.debug_names-like name index table, enough to
4564 exercise dw2_expand_symtabs_matching_symbol, which works with the
4565 mapped_index_base interface. Builds an index from the symbol list
4566 passed as parameter to the constructor. */
4567 class mock_mapped_index
: public mapped_index_base
4570 mock_mapped_index (gdb::array_view
<const char *> symbols
)
4571 : m_symbol_table (symbols
)
4574 DISABLE_COPY_AND_ASSIGN (mock_mapped_index
);
4576 /* Return the number of names in the symbol table. */
4577 size_t symbol_name_count () const override
4579 return m_symbol_table
.size ();
4582 /* Get the name of the symbol at IDX in the symbol table. */
4583 const char *symbol_name_at (offset_type idx
) const override
4585 return m_symbol_table
[idx
];
4589 gdb::array_view
<const char *> m_symbol_table
;
4592 /* Convenience function that converts a NULL pointer to a "<null>"
4593 string, to pass to print routines. */
4596 string_or_null (const char *str
)
4598 return str
!= NULL
? str
: "<null>";
4601 /* Check if a lookup_name_info built from
4602 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4603 index. EXPECTED_LIST is the list of expected matches, in expected
4604 matching order. If no match expected, then an empty list is
4605 specified. Returns true on success. On failure prints a warning
4606 indicating the file:line that failed, and returns false. */
4609 check_match (const char *file
, int line
,
4610 mock_mapped_index
&mock_index
,
4611 const char *name
, symbol_name_match_type match_type
,
4612 bool completion_mode
,
4613 std::initializer_list
<const char *> expected_list
)
4615 lookup_name_info
lookup_name (name
, match_type
, completion_mode
);
4617 bool matched
= true;
4619 auto mismatch
= [&] (const char *expected_str
,
4622 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4623 "expected=\"%s\", got=\"%s\"\n"),
4625 (match_type
== symbol_name_match_type::FULL
4627 name
, string_or_null (expected_str
), string_or_null (got
));
4631 auto expected_it
= expected_list
.begin ();
4632 auto expected_end
= expected_list
.end ();
4634 dw2_expand_symtabs_matching_symbol (mock_index
, lookup_name
,
4636 [&] (offset_type idx
)
4638 const char *matched_name
= mock_index
.symbol_name_at (idx
);
4639 const char *expected_str
4640 = expected_it
== expected_end
? NULL
: *expected_it
++;
4642 if (expected_str
== NULL
|| strcmp (expected_str
, matched_name
) != 0)
4643 mismatch (expected_str
, matched_name
);
4646 const char *expected_str
4647 = expected_it
== expected_end
? NULL
: *expected_it
++;
4648 if (expected_str
!= NULL
)
4649 mismatch (expected_str
, NULL
);
4654 /* The symbols added to the mock mapped_index for testing (in
4656 static const char *test_symbols
[] = {
4665 "ns2::tmpl<int>::foo2",
4666 "(anonymous namespace)::A::B::C",
4668 /* These are used to check that the increment-last-char in the
4669 matching algorithm for completion doesn't match "t1_fund" when
4670 completing "t1_func". */
4676 /* A UTF-8 name with multi-byte sequences to make sure that
4677 cp-name-parser understands this as a single identifier ("função"
4678 is "function" in PT). */
4681 /* \377 (0xff) is Latin1 'ÿ'. */
4684 /* \377 (0xff) is Latin1 'ÿ'. */
4688 /* A name with all sorts of complications. Starts with "z" to make
4689 it easier for the completion tests below. */
4690 #define Z_SYM_NAME \
4691 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4692 "::tuple<(anonymous namespace)::ui*, " \
4693 "std::default_delete<(anonymous namespace)::ui>, void>"
4698 /* Returns true if the mapped_index_base::find_name_component_bounds
4699 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4700 in completion mode. */
4703 check_find_bounds_finds (mapped_index_base
&index
,
4704 const char *search_name
,
4705 gdb::array_view
<const char *> expected_syms
)
4707 lookup_name_info
lookup_name (search_name
,
4708 symbol_name_match_type::FULL
, true);
4710 auto bounds
= index
.find_name_components_bounds (lookup_name
);
4712 size_t distance
= std::distance (bounds
.first
, bounds
.second
);
4713 if (distance
!= expected_syms
.size ())
4716 for (size_t exp_elem
= 0; exp_elem
< distance
; exp_elem
++)
4718 auto nc_elem
= bounds
.first
+ exp_elem
;
4719 const char *qualified
= index
.symbol_name_at (nc_elem
->idx
);
4720 if (strcmp (qualified
, expected_syms
[exp_elem
]) != 0)
4727 /* Test the lower-level mapped_index::find_name_component_bounds
4731 test_mapped_index_find_name_component_bounds ()
4733 mock_mapped_index
mock_index (test_symbols
);
4735 mock_index
.build_name_components ();
4737 /* Test the lower-level mapped_index::find_name_component_bounds
4738 method in completion mode. */
4740 static const char *expected_syms
[] = {
4745 SELF_CHECK (check_find_bounds_finds (mock_index
,
4746 "t1_func", expected_syms
));
4749 /* Check that the increment-last-char in the name matching algorithm
4750 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4752 static const char *expected_syms1
[] = {
4756 SELF_CHECK (check_find_bounds_finds (mock_index
,
4757 "\377", expected_syms1
));
4759 static const char *expected_syms2
[] = {
4762 SELF_CHECK (check_find_bounds_finds (mock_index
,
4763 "\377\377", expected_syms2
));
4767 /* Test dw2_expand_symtabs_matching_symbol. */
4770 test_dw2_expand_symtabs_matching_symbol ()
4772 mock_mapped_index
mock_index (test_symbols
);
4774 /* We let all tests run until the end even if some fails, for debug
4776 bool any_mismatch
= false;
4778 /* Create the expected symbols list (an initializer_list). Needed
4779 because lists have commas, and we need to pass them to CHECK,
4780 which is a macro. */
4781 #define EXPECT(...) { __VA_ARGS__ }
4783 /* Wrapper for check_match that passes down the current
4784 __FILE__/__LINE__. */
4785 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4786 any_mismatch |= !check_match (__FILE__, __LINE__, \
4788 NAME, MATCH_TYPE, COMPLETION_MODE, \
4791 /* Identity checks. */
4792 for (const char *sym
: test_symbols
)
4794 /* Should be able to match all existing symbols. */
4795 CHECK_MATCH (sym
, symbol_name_match_type::FULL
, false,
4798 /* Should be able to match all existing symbols with
4800 std::string with_params
= std::string (sym
) + "(int)";
4801 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4804 /* Should be able to match all existing symbols with
4805 parameters and qualifiers. */
4806 with_params
= std::string (sym
) + " ( int ) const";
4807 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4810 /* This should really find sym, but cp-name-parser.y doesn't
4811 know about lvalue/rvalue qualifiers yet. */
4812 with_params
= std::string (sym
) + " ( int ) &&";
4813 CHECK_MATCH (with_params
.c_str (), symbol_name_match_type::FULL
, false,
4817 /* Check that the name matching algorithm for completion doesn't get
4818 confused with Latin1 'ÿ' / 0xff. */
4820 static const char str
[] = "\377";
4821 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4822 EXPECT ("\377", "\377\377123"));
4825 /* Check that the increment-last-char in the matching algorithm for
4826 completion doesn't match "t1_fund" when completing "t1_func". */
4828 static const char str
[] = "t1_func";
4829 CHECK_MATCH (str
, symbol_name_match_type::FULL
, true,
4830 EXPECT ("t1_func", "t1_func1"));
4833 /* Check that completion mode works at each prefix of the expected
4836 static const char str
[] = "function(int)";
4837 size_t len
= strlen (str
);
4840 for (size_t i
= 1; i
< len
; i
++)
4842 lookup
.assign (str
, i
);
4843 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4844 EXPECT ("function"));
4848 /* While "w" is a prefix of both components, the match function
4849 should still only be called once. */
4851 CHECK_MATCH ("w", symbol_name_match_type::FULL
, true,
4853 CHECK_MATCH ("w", symbol_name_match_type::WILD
, true,
4857 /* Same, with a "complicated" symbol. */
4859 static const char str
[] = Z_SYM_NAME
;
4860 size_t len
= strlen (str
);
4863 for (size_t i
= 1; i
< len
; i
++)
4865 lookup
.assign (str
, i
);
4866 CHECK_MATCH (lookup
.c_str (), symbol_name_match_type::FULL
, true,
4867 EXPECT (Z_SYM_NAME
));
4871 /* In FULL mode, an incomplete symbol doesn't match. */
4873 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL
, false,
4877 /* A complete symbol with parameters matches any overload, since the
4878 index has no overload info. */
4880 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL
, true,
4881 EXPECT ("std::zfunction", "std::zfunction2"));
4882 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD
, true,
4883 EXPECT ("std::zfunction", "std::zfunction2"));
4884 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD
, true,
4885 EXPECT ("std::zfunction", "std::zfunction2"));
4888 /* Check that whitespace is ignored appropriately. A symbol with a
4889 template argument list. */
4891 static const char expected
[] = "ns::foo<int>";
4892 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL
, false,
4894 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD
, false,
4898 /* Check that whitespace is ignored appropriately. A symbol with a
4899 template argument list that includes a pointer. */
4901 static const char expected
[] = "ns::foo<char*>";
4902 /* Try both completion and non-completion modes. */
4903 static const bool completion_mode
[2] = {false, true};
4904 for (size_t i
= 0; i
< 2; i
++)
4906 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL
,
4907 completion_mode
[i
], EXPECT (expected
));
4908 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD
,
4909 completion_mode
[i
], EXPECT (expected
));
4911 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL
,
4912 completion_mode
[i
], EXPECT (expected
));
4913 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD
,
4914 completion_mode
[i
], EXPECT (expected
));
4919 /* Check method qualifiers are ignored. */
4920 static const char expected
[] = "ns::foo<char*>";
4921 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4922 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4923 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4924 symbol_name_match_type::FULL
, true, EXPECT (expected
));
4925 CHECK_MATCH ("foo < char * > ( int ) const",
4926 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4927 CHECK_MATCH ("foo < char * > ( int ) &&",
4928 symbol_name_match_type::WILD
, true, EXPECT (expected
));
4931 /* Test lookup names that don't match anything. */
4933 CHECK_MATCH ("bar2", symbol_name_match_type::WILD
, false,
4936 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL
, false,
4940 /* Some wild matching tests, exercising "(anonymous namespace)",
4941 which should not be confused with a parameter list. */
4943 static const char *syms
[] = {
4947 "A :: B :: C ( int )",
4952 for (const char *s
: syms
)
4954 CHECK_MATCH (s
, symbol_name_match_type::WILD
, false,
4955 EXPECT ("(anonymous namespace)::A::B::C"));
4960 static const char expected
[] = "ns2::tmpl<int>::foo2";
4961 CHECK_MATCH ("tmp", symbol_name_match_type::WILD
, true,
4963 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD
, true,
4967 SELF_CHECK (!any_mismatch
);
4976 test_mapped_index_find_name_component_bounds ();
4977 test_dw2_expand_symtabs_matching_symbol ();
4980 }} // namespace selftests::dw2_expand_symtabs_matching
4982 #endif /* GDB_SELF_TEST */
4984 /* If FILE_MATCHER is NULL or if PER_CU has
4985 dwarf2_per_cu_quick_data::MARK set (see
4986 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4987 EXPANSION_NOTIFY on it. */
4990 dw2_expand_symtabs_matching_one
4991 (struct dwarf2_per_cu_data
*per_cu
,
4992 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
4993 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
)
4995 if (file_matcher
== NULL
|| per_cu
->v
.quick
->mark
)
4997 bool symtab_was_null
4998 = (per_cu
->v
.quick
->compunit_symtab
== NULL
);
5000 dw2_instantiate_symtab (per_cu
, false);
5002 if (expansion_notify
!= NULL
5004 && per_cu
->v
.quick
->compunit_symtab
!= NULL
)
5005 expansion_notify (per_cu
->v
.quick
->compunit_symtab
);
5009 /* Helper for dw2_expand_matching symtabs. Called on each symbol
5010 matched, to expand corresponding CUs that were marked. IDX is the
5011 index of the symbol name that matched. */
5014 dw2_expand_marked_cus
5015 (struct dwarf2_per_objfile
*dwarf2_per_objfile
, offset_type idx
,
5016 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5017 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5020 offset_type
*vec
, vec_len
, vec_idx
;
5021 bool global_seen
= false;
5022 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
5024 vec
= (offset_type
*) (index
.constant_pool
5025 + MAYBE_SWAP (index
.symbol_table
[idx
].vec
));
5026 vec_len
= MAYBE_SWAP (vec
[0]);
5027 for (vec_idx
= 0; vec_idx
< vec_len
; ++vec_idx
)
5029 offset_type cu_index_and_attrs
= MAYBE_SWAP (vec
[vec_idx
+ 1]);
5030 /* This value is only valid for index versions >= 7. */
5031 int is_static
= GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs
);
5032 gdb_index_symbol_kind symbol_kind
=
5033 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs
);
5034 int cu_index
= GDB_INDEX_CU_VALUE (cu_index_and_attrs
);
5035 /* Only check the symbol attributes if they're present.
5036 Indices prior to version 7 don't record them,
5037 and indices >= 7 may elide them for certain symbols
5038 (gold does this). */
5041 && symbol_kind
!= GDB_INDEX_SYMBOL_KIND_NONE
);
5043 /* Work around gold/15646. */
5046 if (!is_static
&& global_seen
)
5052 /* Only check the symbol's kind if it has one. */
5057 case VARIABLES_DOMAIN
:
5058 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_VARIABLE
)
5061 case FUNCTIONS_DOMAIN
:
5062 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_FUNCTION
)
5066 if (symbol_kind
!= GDB_INDEX_SYMBOL_KIND_TYPE
)
5074 /* Don't crash on bad data. */
5075 if (cu_index
>= (dwarf2_per_objfile
->all_comp_units
.size ()
5076 + dwarf2_per_objfile
->all_type_units
.size ()))
5078 complaint (_(".gdb_index entry has bad CU index"
5080 objfile_name (dwarf2_per_objfile
->objfile
));
5084 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (cu_index
);
5085 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
5090 /* If FILE_MATCHER is non-NULL, set all the
5091 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5092 that match FILE_MATCHER. */
5095 dw_expand_symtabs_matching_file_matcher
5096 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5097 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
)
5099 if (file_matcher
== NULL
)
5102 objfile
*const objfile
= dwarf2_per_objfile
->objfile
;
5104 htab_up
visited_found (htab_create_alloc (10, htab_hash_pointer
,
5106 NULL
, xcalloc
, xfree
));
5107 htab_up
visited_not_found (htab_create_alloc (10, htab_hash_pointer
,
5109 NULL
, xcalloc
, xfree
));
5111 /* The rule is CUs specify all the files, including those used by
5112 any TU, so there's no need to scan TUs here. */
5114 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5118 per_cu
->v
.quick
->mark
= 0;
5120 /* We only need to look at symtabs not already expanded. */
5121 if (per_cu
->v
.quick
->compunit_symtab
)
5124 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
5125 if (file_data
== NULL
)
5128 if (htab_find (visited_not_found
.get (), file_data
) != NULL
)
5130 else if (htab_find (visited_found
.get (), file_data
) != NULL
)
5132 per_cu
->v
.quick
->mark
= 1;
5136 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5138 const char *this_real_name
;
5140 if (file_matcher (file_data
->file_names
[j
], false))
5142 per_cu
->v
.quick
->mark
= 1;
5146 /* Before we invoke realpath, which can get expensive when many
5147 files are involved, do a quick comparison of the basenames. */
5148 if (!basenames_may_differ
5149 && !file_matcher (lbasename (file_data
->file_names
[j
]),
5153 this_real_name
= dw2_get_real_path (objfile
, file_data
, j
);
5154 if (file_matcher (this_real_name
, false))
5156 per_cu
->v
.quick
->mark
= 1;
5161 void **slot
= htab_find_slot (per_cu
->v
.quick
->mark
5162 ? visited_found
.get ()
5163 : visited_not_found
.get (),
5170 dw2_expand_symtabs_matching
5171 (struct objfile
*objfile
,
5172 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
5173 const lookup_name_info
&lookup_name
,
5174 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
5175 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
5176 enum search_domain kind
)
5178 struct dwarf2_per_objfile
*dwarf2_per_objfile
5179 = get_dwarf2_per_objfile (objfile
);
5181 /* index_table is NULL if OBJF_READNOW. */
5182 if (!dwarf2_per_objfile
->index_table
)
5185 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
5187 mapped_index
&index
= *dwarf2_per_objfile
->index_table
;
5189 dw2_expand_symtabs_matching_symbol (index
, lookup_name
,
5191 kind
, [&] (offset_type idx
)
5193 dw2_expand_marked_cus (dwarf2_per_objfile
, idx
, file_matcher
,
5194 expansion_notify
, kind
);
5198 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5201 static struct compunit_symtab
*
5202 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab
*cust
,
5207 if (COMPUNIT_BLOCKVECTOR (cust
) != NULL
5208 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust
), pc
))
5211 if (cust
->includes
== NULL
)
5214 for (i
= 0; cust
->includes
[i
]; ++i
)
5216 struct compunit_symtab
*s
= cust
->includes
[i
];
5218 s
= recursively_find_pc_sect_compunit_symtab (s
, pc
);
5226 static struct compunit_symtab
*
5227 dw2_find_pc_sect_compunit_symtab (struct objfile
*objfile
,
5228 struct bound_minimal_symbol msymbol
,
5230 struct obj_section
*section
,
5233 struct dwarf2_per_cu_data
*data
;
5234 struct compunit_symtab
*result
;
5236 if (!objfile
->partial_symtabs
->psymtabs_addrmap
)
5239 CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
5240 SECT_OFF_TEXT (objfile
));
5241 data
= (struct dwarf2_per_cu_data
*) addrmap_find
5242 (objfile
->partial_symtabs
->psymtabs_addrmap
, pc
- baseaddr
);
5246 if (warn_if_readin
&& data
->v
.quick
->compunit_symtab
)
5247 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5248 paddress (get_objfile_arch (objfile
), pc
));
5251 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data
,
5254 gdb_assert (result
!= NULL
);
5259 dw2_map_symbol_filenames (struct objfile
*objfile
, symbol_filename_ftype
*fun
,
5260 void *data
, int need_fullname
)
5262 struct dwarf2_per_objfile
*dwarf2_per_objfile
5263 = get_dwarf2_per_objfile (objfile
);
5265 if (!dwarf2_per_objfile
->filenames_cache
)
5267 dwarf2_per_objfile
->filenames_cache
.emplace ();
5269 htab_up
visited (htab_create_alloc (10,
5270 htab_hash_pointer
, htab_eq_pointer
,
5271 NULL
, xcalloc
, xfree
));
5273 /* The rule is CUs specify all the files, including those used
5274 by any TU, so there's no need to scan TUs here. We can
5275 ignore file names coming from already-expanded CUs. */
5277 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5279 if (per_cu
->v
.quick
->compunit_symtab
)
5281 void **slot
= htab_find_slot (visited
.get (),
5282 per_cu
->v
.quick
->file_names
,
5285 *slot
= per_cu
->v
.quick
->file_names
;
5289 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
5291 /* We only need to look at symtabs not already expanded. */
5292 if (per_cu
->v
.quick
->compunit_symtab
)
5295 quick_file_names
*file_data
= dw2_get_file_names (per_cu
);
5296 if (file_data
== NULL
)
5299 void **slot
= htab_find_slot (visited
.get (), file_data
, INSERT
);
5302 /* Already visited. */
5307 for (int j
= 0; j
< file_data
->num_file_names
; ++j
)
5309 const char *filename
= file_data
->file_names
[j
];
5310 dwarf2_per_objfile
->filenames_cache
->seen (filename
);
5315 dwarf2_per_objfile
->filenames_cache
->traverse ([&] (const char *filename
)
5317 gdb::unique_xmalloc_ptr
<char> this_real_name
;
5320 this_real_name
= gdb_realpath (filename
);
5321 (*fun
) (filename
, this_real_name
.get (), data
);
5326 dw2_has_symbols (struct objfile
*objfile
)
5331 const struct quick_symbol_functions dwarf2_gdb_index_functions
=
5334 dw2_find_last_source_symtab
,
5335 dw2_forget_cached_source_info
,
5336 dw2_map_symtabs_matching_filename
,
5340 dw2_expand_symtabs_for_function
,
5341 dw2_expand_all_symtabs
,
5342 dw2_expand_symtabs_with_fullname
,
5343 dw2_map_matching_symbols
,
5344 dw2_expand_symtabs_matching
,
5345 dw2_find_pc_sect_compunit_symtab
,
5347 dw2_map_symbol_filenames
5350 /* DWARF-5 debug_names reader. */
5352 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5353 static const gdb_byte dwarf5_augmentation
[] = { 'G', 'D', 'B', 0 };
5355 /* A helper function that reads the .debug_names section in SECTION
5356 and fills in MAP. FILENAME is the name of the file containing the
5357 section; it is used for error reporting.
5359 Returns true if all went well, false otherwise. */
5362 read_debug_names_from_section (struct objfile
*objfile
,
5363 const char *filename
,
5364 struct dwarf2_section_info
*section
,
5365 mapped_debug_names
&map
)
5367 if (dwarf2_section_empty_p (section
))
5370 /* Older elfutils strip versions could keep the section in the main
5371 executable while splitting it for the separate debug info file. */
5372 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
5375 dwarf2_read_section (objfile
, section
);
5377 map
.dwarf5_byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
5379 const gdb_byte
*addr
= section
->buffer
;
5381 bfd
*const abfd
= get_section_bfd_owner (section
);
5383 unsigned int bytes_read
;
5384 LONGEST length
= read_initial_length (abfd
, addr
, &bytes_read
);
5387 map
.dwarf5_is_dwarf64
= bytes_read
!= 4;
5388 map
.offset_size
= map
.dwarf5_is_dwarf64
? 8 : 4;
5389 if (bytes_read
+ length
!= section
->size
)
5391 /* There may be multiple per-CU indices. */
5392 warning (_("Section .debug_names in %s length %s does not match "
5393 "section length %s, ignoring .debug_names."),
5394 filename
, plongest (bytes_read
+ length
),
5395 pulongest (section
->size
));
5399 /* The version number. */
5400 uint16_t version
= read_2_bytes (abfd
, addr
);
5404 warning (_("Section .debug_names in %s has unsupported version %d, "
5405 "ignoring .debug_names."),
5411 uint16_t padding
= read_2_bytes (abfd
, addr
);
5415 warning (_("Section .debug_names in %s has unsupported padding %d, "
5416 "ignoring .debug_names."),
5421 /* comp_unit_count - The number of CUs in the CU list. */
5422 map
.cu_count
= read_4_bytes (abfd
, addr
);
5425 /* local_type_unit_count - The number of TUs in the local TU
5427 map
.tu_count
= read_4_bytes (abfd
, addr
);
5430 /* foreign_type_unit_count - The number of TUs in the foreign TU
5432 uint32_t foreign_tu_count
= read_4_bytes (abfd
, addr
);
5434 if (foreign_tu_count
!= 0)
5436 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5437 "ignoring .debug_names."),
5438 filename
, static_cast<unsigned long> (foreign_tu_count
));
5442 /* bucket_count - The number of hash buckets in the hash lookup
5444 map
.bucket_count
= read_4_bytes (abfd
, addr
);
5447 /* name_count - The number of unique names in the index. */
5448 map
.name_count
= read_4_bytes (abfd
, addr
);
5451 /* abbrev_table_size - The size in bytes of the abbreviations
5453 uint32_t abbrev_table_size
= read_4_bytes (abfd
, addr
);
5456 /* augmentation_string_size - The size in bytes of the augmentation
5457 string. This value is rounded up to a multiple of 4. */
5458 uint32_t augmentation_string_size
= read_4_bytes (abfd
, addr
);
5460 map
.augmentation_is_gdb
= ((augmentation_string_size
5461 == sizeof (dwarf5_augmentation
))
5462 && memcmp (addr
, dwarf5_augmentation
,
5463 sizeof (dwarf5_augmentation
)) == 0);
5464 augmentation_string_size
+= (-augmentation_string_size
) & 3;
5465 addr
+= augmentation_string_size
;
5468 map
.cu_table_reordered
= addr
;
5469 addr
+= map
.cu_count
* map
.offset_size
;
5471 /* List of Local TUs */
5472 map
.tu_table_reordered
= addr
;
5473 addr
+= map
.tu_count
* map
.offset_size
;
5475 /* Hash Lookup Table */
5476 map
.bucket_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5477 addr
+= map
.bucket_count
* 4;
5478 map
.hash_table_reordered
= reinterpret_cast<const uint32_t *> (addr
);
5479 addr
+= map
.name_count
* 4;
5482 map
.name_table_string_offs_reordered
= addr
;
5483 addr
+= map
.name_count
* map
.offset_size
;
5484 map
.name_table_entry_offs_reordered
= addr
;
5485 addr
+= map
.name_count
* map
.offset_size
;
5487 const gdb_byte
*abbrev_table_start
= addr
;
5490 const ULONGEST index_num
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5495 const auto insertpair
5496 = map
.abbrev_map
.emplace (index_num
, mapped_debug_names::index_val ());
5497 if (!insertpair
.second
)
5499 warning (_("Section .debug_names in %s has duplicate index %s, "
5500 "ignoring .debug_names."),
5501 filename
, pulongest (index_num
));
5504 mapped_debug_names::index_val
&indexval
= insertpair
.first
->second
;
5505 indexval
.dwarf_tag
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5510 mapped_debug_names::index_val::attr attr
;
5511 attr
.dw_idx
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5513 attr
.form
= read_unsigned_leb128 (abfd
, addr
, &bytes_read
);
5515 if (attr
.form
== DW_FORM_implicit_const
)
5517 attr
.implicit_const
= read_signed_leb128 (abfd
, addr
,
5521 if (attr
.dw_idx
== 0 && attr
.form
== 0)
5523 indexval
.attr_vec
.push_back (std::move (attr
));
5526 if (addr
!= abbrev_table_start
+ abbrev_table_size
)
5528 warning (_("Section .debug_names in %s has abbreviation_table "
5529 "of size %s vs. written as %u, ignoring .debug_names."),
5530 filename
, plongest (addr
- abbrev_table_start
),
5534 map
.entry_pool
= addr
;
5539 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5543 create_cus_from_debug_names_list (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5544 const mapped_debug_names
&map
,
5545 dwarf2_section_info
§ion
,
5548 sect_offset sect_off_prev
;
5549 for (uint32_t i
= 0; i
<= map
.cu_count
; ++i
)
5551 sect_offset sect_off_next
;
5552 if (i
< map
.cu_count
)
5555 = (sect_offset
) (extract_unsigned_integer
5556 (map
.cu_table_reordered
+ i
* map
.offset_size
,
5558 map
.dwarf5_byte_order
));
5561 sect_off_next
= (sect_offset
) section
.size
;
5564 const ULONGEST length
= sect_off_next
- sect_off_prev
;
5565 dwarf2_per_cu_data
*per_cu
5566 = create_cu_from_index_list (dwarf2_per_objfile
, §ion
, is_dwz
,
5567 sect_off_prev
, length
);
5568 dwarf2_per_objfile
->all_comp_units
.push_back (per_cu
);
5570 sect_off_prev
= sect_off_next
;
5574 /* Read the CU list from the mapped index, and use it to create all
5575 the CU objects for this dwarf2_per_objfile. */
5578 create_cus_from_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
5579 const mapped_debug_names
&map
,
5580 const mapped_debug_names
&dwz_map
)
5582 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
5583 dwarf2_per_objfile
->all_comp_units
.reserve (map
.cu_count
+ dwz_map
.cu_count
);
5585 create_cus_from_debug_names_list (dwarf2_per_objfile
, map
,
5586 dwarf2_per_objfile
->info
,
5587 false /* is_dwz */);
5589 if (dwz_map
.cu_count
== 0)
5592 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5593 create_cus_from_debug_names_list (dwarf2_per_objfile
, dwz_map
, dwz
->info
,
5597 /* Read .debug_names. If everything went ok, initialize the "quick"
5598 elements of all the CUs and return true. Otherwise, return false. */
5601 dwarf2_read_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
5603 std::unique_ptr
<mapped_debug_names
> map
5604 (new mapped_debug_names (dwarf2_per_objfile
));
5605 mapped_debug_names
dwz_map (dwarf2_per_objfile
);
5606 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5608 if (!read_debug_names_from_section (objfile
, objfile_name (objfile
),
5609 &dwarf2_per_objfile
->debug_names
,
5613 /* Don't use the index if it's empty. */
5614 if (map
->name_count
== 0)
5617 /* If there is a .dwz file, read it so we can get its CU list as
5619 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
5622 if (!read_debug_names_from_section (objfile
,
5623 bfd_get_filename (dwz
->dwz_bfd
),
5624 &dwz
->debug_names
, dwz_map
))
5626 warning (_("could not read '.debug_names' section from %s; skipping"),
5627 bfd_get_filename (dwz
->dwz_bfd
));
5632 create_cus_from_debug_names (dwarf2_per_objfile
, *map
, dwz_map
);
5634 if (map
->tu_count
!= 0)
5636 /* We can only handle a single .debug_types when we have an
5638 if (dwarf2_per_objfile
->types
.size () != 1)
5641 dwarf2_section_info
*section
= &dwarf2_per_objfile
->types
[0];
5643 create_signatured_type_table_from_debug_names
5644 (dwarf2_per_objfile
, *map
, section
, &dwarf2_per_objfile
->abbrev
);
5647 create_addrmap_from_aranges (dwarf2_per_objfile
,
5648 &dwarf2_per_objfile
->debug_aranges
);
5650 dwarf2_per_objfile
->debug_names_table
= std::move (map
);
5651 dwarf2_per_objfile
->using_index
= 1;
5652 dwarf2_per_objfile
->quick_file_names_table
=
5653 create_quick_file_names_table (dwarf2_per_objfile
->all_comp_units
.size ());
5658 /* Type used to manage iterating over all CUs looking for a symbol for
5661 class dw2_debug_names_iterator
5664 /* If WANT_SPECIFIC_BLOCK is true, only look for symbols in block
5665 BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
5666 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5667 bool want_specific_block
,
5668 block_enum block_index
, domain_enum domain
,
5670 : m_map (map
), m_want_specific_block (want_specific_block
),
5671 m_block_index (block_index
), m_domain (domain
),
5672 m_addr (find_vec_in_debug_names (map
, name
))
5675 dw2_debug_names_iterator (const mapped_debug_names
&map
,
5676 search_domain search
, uint32_t namei
)
5679 m_addr (find_vec_in_debug_names (map
, namei
))
5682 /* Return the next matching CU or NULL if there are no more. */
5683 dwarf2_per_cu_data
*next ();
5686 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5688 static const gdb_byte
*find_vec_in_debug_names (const mapped_debug_names
&map
,
5691 /* The internalized form of .debug_names. */
5692 const mapped_debug_names
&m_map
;
5694 /* If true, only look for symbols that match BLOCK_INDEX. */
5695 const bool m_want_specific_block
= false;
5697 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
5698 Unused if !WANT_SPECIFIC_BLOCK - FIRST_LOCAL_BLOCK is an invalid
5700 const block_enum m_block_index
= FIRST_LOCAL_BLOCK
;
5702 /* The kind of symbol we're looking for. */
5703 const domain_enum m_domain
= UNDEF_DOMAIN
;
5704 const search_domain m_search
= ALL_DOMAIN
;
5706 /* The list of CUs from the index entry of the symbol, or NULL if
5708 const gdb_byte
*m_addr
;
5712 mapped_debug_names::namei_to_name (uint32_t namei
) const
5714 const ULONGEST namei_string_offs
5715 = extract_unsigned_integer ((name_table_string_offs_reordered
5716 + namei
* offset_size
),
5719 return read_indirect_string_at_offset
5720 (dwarf2_per_objfile
, dwarf2_per_objfile
->objfile
->obfd
, namei_string_offs
);
5723 /* Find a slot in .debug_names for the object named NAME. If NAME is
5724 found, return pointer to its pool data. If NAME cannot be found,
5728 dw2_debug_names_iterator::find_vec_in_debug_names
5729 (const mapped_debug_names
&map
, const char *name
)
5731 int (*cmp
) (const char *, const char *);
5733 gdb::unique_xmalloc_ptr
<char> without_params
;
5734 if (current_language
->la_language
== language_cplus
5735 || current_language
->la_language
== language_fortran
5736 || current_language
->la_language
== language_d
)
5738 /* NAME is already canonical. Drop any qualifiers as
5739 .debug_names does not contain any. */
5741 if (strchr (name
, '(') != NULL
)
5743 without_params
= cp_remove_params (name
);
5744 if (without_params
!= NULL
)
5745 name
= without_params
.get ();
5749 cmp
= (case_sensitivity
== case_sensitive_on
? strcmp
: strcasecmp
);
5751 const uint32_t full_hash
= dwarf5_djb_hash (name
);
5753 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5754 (map
.bucket_table_reordered
5755 + (full_hash
% map
.bucket_count
)), 4,
5756 map
.dwarf5_byte_order
);
5760 if (namei
>= map
.name_count
)
5762 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5764 namei
, map
.name_count
,
5765 objfile_name (map
.dwarf2_per_objfile
->objfile
));
5771 const uint32_t namei_full_hash
5772 = extract_unsigned_integer (reinterpret_cast<const gdb_byte
*>
5773 (map
.hash_table_reordered
+ namei
), 4,
5774 map
.dwarf5_byte_order
);
5775 if (full_hash
% map
.bucket_count
!= namei_full_hash
% map
.bucket_count
)
5778 if (full_hash
== namei_full_hash
)
5780 const char *const namei_string
= map
.namei_to_name (namei
);
5782 #if 0 /* An expensive sanity check. */
5783 if (namei_full_hash
!= dwarf5_djb_hash (namei_string
))
5785 complaint (_("Wrong .debug_names hash for string at index %u "
5787 namei
, objfile_name (dwarf2_per_objfile
->objfile
));
5792 if (cmp (namei_string
, name
) == 0)
5794 const ULONGEST namei_entry_offs
5795 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5796 + namei
* map
.offset_size
),
5797 map
.offset_size
, map
.dwarf5_byte_order
);
5798 return map
.entry_pool
+ namei_entry_offs
;
5803 if (namei
>= map
.name_count
)
5809 dw2_debug_names_iterator::find_vec_in_debug_names
5810 (const mapped_debug_names
&map
, uint32_t namei
)
5812 if (namei
>= map
.name_count
)
5814 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5816 namei
, map
.name_count
,
5817 objfile_name (map
.dwarf2_per_objfile
->objfile
));
5821 const ULONGEST namei_entry_offs
5822 = extract_unsigned_integer ((map
.name_table_entry_offs_reordered
5823 + namei
* map
.offset_size
),
5824 map
.offset_size
, map
.dwarf5_byte_order
);
5825 return map
.entry_pool
+ namei_entry_offs
;
5828 /* See dw2_debug_names_iterator. */
5830 dwarf2_per_cu_data
*
5831 dw2_debug_names_iterator::next ()
5836 struct dwarf2_per_objfile
*dwarf2_per_objfile
= m_map
.dwarf2_per_objfile
;
5837 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
5838 bfd
*const abfd
= objfile
->obfd
;
5842 unsigned int bytes_read
;
5843 const ULONGEST abbrev
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5844 m_addr
+= bytes_read
;
5848 const auto indexval_it
= m_map
.abbrev_map
.find (abbrev
);
5849 if (indexval_it
== m_map
.abbrev_map
.cend ())
5851 complaint (_("Wrong .debug_names undefined abbrev code %s "
5853 pulongest (abbrev
), objfile_name (objfile
));
5856 const mapped_debug_names::index_val
&indexval
= indexval_it
->second
;
5857 bool have_is_static
= false;
5859 dwarf2_per_cu_data
*per_cu
= NULL
;
5860 for (const mapped_debug_names::index_val::attr
&attr
: indexval
.attr_vec
)
5865 case DW_FORM_implicit_const
:
5866 ull
= attr
.implicit_const
;
5868 case DW_FORM_flag_present
:
5872 ull
= read_unsigned_leb128 (abfd
, m_addr
, &bytes_read
);
5873 m_addr
+= bytes_read
;
5876 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5877 dwarf_form_name (attr
.form
),
5878 objfile_name (objfile
));
5881 switch (attr
.dw_idx
)
5883 case DW_IDX_compile_unit
:
5884 /* Don't crash on bad data. */
5885 if (ull
>= dwarf2_per_objfile
->all_comp_units
.size ())
5887 complaint (_(".debug_names entry has bad CU index %s"
5890 objfile_name (dwarf2_per_objfile
->objfile
));
5893 per_cu
= dwarf2_per_objfile
->get_cutu (ull
);
5895 case DW_IDX_type_unit
:
5896 /* Don't crash on bad data. */
5897 if (ull
>= dwarf2_per_objfile
->all_type_units
.size ())
5899 complaint (_(".debug_names entry has bad TU index %s"
5902 objfile_name (dwarf2_per_objfile
->objfile
));
5905 per_cu
= &dwarf2_per_objfile
->get_tu (ull
)->per_cu
;
5907 case DW_IDX_GNU_internal
:
5908 if (!m_map
.augmentation_is_gdb
)
5910 have_is_static
= true;
5913 case DW_IDX_GNU_external
:
5914 if (!m_map
.augmentation_is_gdb
)
5916 have_is_static
= true;
5922 /* Skip if already read in. */
5923 if (per_cu
->v
.quick
->compunit_symtab
)
5926 /* Check static vs global. */
5929 const bool want_static
= m_block_index
!= GLOBAL_BLOCK
;
5930 if (m_want_specific_block
&& want_static
!= is_static
)
5934 /* Match dw2_symtab_iter_next, symbol_kind
5935 and debug_names::psymbol_tag. */
5939 switch (indexval
.dwarf_tag
)
5941 case DW_TAG_variable
:
5942 case DW_TAG_subprogram
:
5943 /* Some types are also in VAR_DOMAIN. */
5944 case DW_TAG_typedef
:
5945 case DW_TAG_structure_type
:
5952 switch (indexval
.dwarf_tag
)
5954 case DW_TAG_typedef
:
5955 case DW_TAG_structure_type
:
5962 switch (indexval
.dwarf_tag
)
5965 case DW_TAG_variable
:
5975 /* Match dw2_expand_symtabs_matching, symbol_kind and
5976 debug_names::psymbol_tag. */
5979 case VARIABLES_DOMAIN
:
5980 switch (indexval
.dwarf_tag
)
5982 case DW_TAG_variable
:
5988 case FUNCTIONS_DOMAIN
:
5989 switch (indexval
.dwarf_tag
)
5991 case DW_TAG_subprogram
:
5998 switch (indexval
.dwarf_tag
)
6000 case DW_TAG_typedef
:
6001 case DW_TAG_structure_type
:
6014 static struct compunit_symtab
*
6015 dw2_debug_names_lookup_symbol (struct objfile
*objfile
, int block_index_int
,
6016 const char *name
, domain_enum domain
)
6018 const block_enum block_index
= static_cast<block_enum
> (block_index_int
);
6019 struct dwarf2_per_objfile
*dwarf2_per_objfile
6020 = get_dwarf2_per_objfile (objfile
);
6022 const auto &mapp
= dwarf2_per_objfile
->debug_names_table
;
6025 /* index is NULL if OBJF_READNOW. */
6028 const auto &map
= *mapp
;
6030 dw2_debug_names_iterator
iter (map
, true /* want_specific_block */,
6031 block_index
, domain
, name
);
6033 struct compunit_symtab
*stab_best
= NULL
;
6034 struct dwarf2_per_cu_data
*per_cu
;
6035 while ((per_cu
= iter
.next ()) != NULL
)
6037 struct symbol
*sym
, *with_opaque
= NULL
;
6038 struct compunit_symtab
*stab
= dw2_instantiate_symtab (per_cu
, false);
6039 const struct blockvector
*bv
= COMPUNIT_BLOCKVECTOR (stab
);
6040 const struct block
*block
= BLOCKVECTOR_BLOCK (bv
, block_index
);
6042 sym
= block_find_symbol (block
, name
, domain
,
6043 block_find_non_opaque_type_preferred
,
6046 /* Some caution must be observed with overloaded functions and
6047 methods, since the index will not contain any overload
6048 information (but NAME might contain it). */
6051 && strcmp_iw (SYMBOL_SEARCH_NAME (sym
), name
) == 0)
6053 if (with_opaque
!= NULL
6054 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque
), name
) == 0)
6057 /* Keep looking through other CUs. */
6063 /* This dumps minimal information about .debug_names. It is called
6064 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
6065 uses this to verify that .debug_names has been loaded. */
6068 dw2_debug_names_dump (struct objfile
*objfile
)
6070 struct dwarf2_per_objfile
*dwarf2_per_objfile
6071 = get_dwarf2_per_objfile (objfile
);
6073 gdb_assert (dwarf2_per_objfile
->using_index
);
6074 printf_filtered (".debug_names:");
6075 if (dwarf2_per_objfile
->debug_names_table
)
6076 printf_filtered (" exists\n");
6078 printf_filtered (" faked for \"readnow\"\n");
6079 printf_filtered ("\n");
6083 dw2_debug_names_expand_symtabs_for_function (struct objfile
*objfile
,
6084 const char *func_name
)
6086 struct dwarf2_per_objfile
*dwarf2_per_objfile
6087 = get_dwarf2_per_objfile (objfile
);
6089 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
6090 if (dwarf2_per_objfile
->debug_names_table
)
6092 const mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6094 /* Note: It doesn't matter what we pass for block_index here. */
6095 dw2_debug_names_iterator
iter (map
, false /* want_specific_block */,
6096 GLOBAL_BLOCK
, VAR_DOMAIN
, func_name
);
6098 struct dwarf2_per_cu_data
*per_cu
;
6099 while ((per_cu
= iter
.next ()) != NULL
)
6100 dw2_instantiate_symtab (per_cu
, false);
6105 dw2_debug_names_expand_symtabs_matching
6106 (struct objfile
*objfile
,
6107 gdb::function_view
<expand_symtabs_file_matcher_ftype
> file_matcher
,
6108 const lookup_name_info
&lookup_name
,
6109 gdb::function_view
<expand_symtabs_symbol_matcher_ftype
> symbol_matcher
,
6110 gdb::function_view
<expand_symtabs_exp_notify_ftype
> expansion_notify
,
6111 enum search_domain kind
)
6113 struct dwarf2_per_objfile
*dwarf2_per_objfile
6114 = get_dwarf2_per_objfile (objfile
);
6116 /* debug_names_table is NULL if OBJF_READNOW. */
6117 if (!dwarf2_per_objfile
->debug_names_table
)
6120 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile
, file_matcher
);
6122 mapped_debug_names
&map
= *dwarf2_per_objfile
->debug_names_table
;
6124 dw2_expand_symtabs_matching_symbol (map
, lookup_name
,
6126 kind
, [&] (offset_type namei
)
6128 /* The name was matched, now expand corresponding CUs that were
6130 dw2_debug_names_iterator
iter (map
, kind
, namei
);
6132 struct dwarf2_per_cu_data
*per_cu
;
6133 while ((per_cu
= iter
.next ()) != NULL
)
6134 dw2_expand_symtabs_matching_one (per_cu
, file_matcher
,
6139 const struct quick_symbol_functions dwarf2_debug_names_functions
=
6142 dw2_find_last_source_symtab
,
6143 dw2_forget_cached_source_info
,
6144 dw2_map_symtabs_matching_filename
,
6145 dw2_debug_names_lookup_symbol
,
6147 dw2_debug_names_dump
,
6148 dw2_debug_names_expand_symtabs_for_function
,
6149 dw2_expand_all_symtabs
,
6150 dw2_expand_symtabs_with_fullname
,
6151 dw2_map_matching_symbols
,
6152 dw2_debug_names_expand_symtabs_matching
,
6153 dw2_find_pc_sect_compunit_symtab
,
6155 dw2_map_symbol_filenames
6158 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
6159 to either a dwarf2_per_objfile or dwz_file object. */
6161 template <typename T
>
6162 static gdb::array_view
<const gdb_byte
>
6163 get_gdb_index_contents_from_section (objfile
*obj
, T
*section_owner
)
6165 dwarf2_section_info
*section
= §ion_owner
->gdb_index
;
6167 if (dwarf2_section_empty_p (section
))
6170 /* Older elfutils strip versions could keep the section in the main
6171 executable while splitting it for the separate debug info file. */
6172 if ((get_section_flags (section
) & SEC_HAS_CONTENTS
) == 0)
6175 dwarf2_read_section (obj
, section
);
6177 /* dwarf2_section_info::size is a bfd_size_type, while
6178 gdb::array_view works with size_t. On 32-bit hosts, with
6179 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6180 is 32-bit. So we need an explicit narrowing conversion here.
6181 This is fine, because it's impossible to allocate or mmap an
6182 array/buffer larger than what size_t can represent. */
6183 return gdb::make_array_view (section
->buffer
, section
->size
);
6186 /* Lookup the index cache for the contents of the index associated to
6189 static gdb::array_view
<const gdb_byte
>
6190 get_gdb_index_contents_from_cache (objfile
*obj
, dwarf2_per_objfile
*dwarf2_obj
)
6192 const bfd_build_id
*build_id
= build_id_bfd_get (obj
->obfd
);
6193 if (build_id
== nullptr)
6196 return global_index_cache
.lookup_gdb_index (build_id
,
6197 &dwarf2_obj
->index_cache_res
);
6200 /* Same as the above, but for DWZ. */
6202 static gdb::array_view
<const gdb_byte
>
6203 get_gdb_index_contents_from_cache_dwz (objfile
*obj
, dwz_file
*dwz
)
6205 const bfd_build_id
*build_id
= build_id_bfd_get (dwz
->dwz_bfd
.get ());
6206 if (build_id
== nullptr)
6209 return global_index_cache
.lookup_gdb_index (build_id
, &dwz
->index_cache_res
);
6212 /* See symfile.h. */
6215 dwarf2_initialize_objfile (struct objfile
*objfile
, dw_index_kind
*index_kind
)
6217 struct dwarf2_per_objfile
*dwarf2_per_objfile
6218 = get_dwarf2_per_objfile (objfile
);
6220 /* If we're about to read full symbols, don't bother with the
6221 indices. In this case we also don't care if some other debug
6222 format is making psymtabs, because they are all about to be
6224 if ((objfile
->flags
& OBJF_READNOW
))
6226 dwarf2_per_objfile
->using_index
= 1;
6227 create_all_comp_units (dwarf2_per_objfile
);
6228 create_all_type_units (dwarf2_per_objfile
);
6229 dwarf2_per_objfile
->quick_file_names_table
6230 = create_quick_file_names_table
6231 (dwarf2_per_objfile
->all_comp_units
.size ());
6233 for (int i
= 0; i
< (dwarf2_per_objfile
->all_comp_units
.size ()
6234 + dwarf2_per_objfile
->all_type_units
.size ()); ++i
)
6236 dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->get_cutu (i
);
6238 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6239 struct dwarf2_per_cu_quick_data
);
6242 /* Return 1 so that gdb sees the "quick" functions. However,
6243 these functions will be no-ops because we will have expanded
6245 *index_kind
= dw_index_kind::GDB_INDEX
;
6249 if (dwarf2_read_debug_names (dwarf2_per_objfile
))
6251 *index_kind
= dw_index_kind::DEBUG_NAMES
;
6255 if (dwarf2_read_gdb_index (dwarf2_per_objfile
,
6256 get_gdb_index_contents_from_section
<struct dwarf2_per_objfile
>,
6257 get_gdb_index_contents_from_section
<dwz_file
>))
6259 *index_kind
= dw_index_kind::GDB_INDEX
;
6263 /* ... otherwise, try to find the index in the index cache. */
6264 if (dwarf2_read_gdb_index (dwarf2_per_objfile
,
6265 get_gdb_index_contents_from_cache
,
6266 get_gdb_index_contents_from_cache_dwz
))
6268 global_index_cache
.hit ();
6269 *index_kind
= dw_index_kind::GDB_INDEX
;
6273 global_index_cache
.miss ();
6279 /* Build a partial symbol table. */
6282 dwarf2_build_psymtabs (struct objfile
*objfile
)
6284 struct dwarf2_per_objfile
*dwarf2_per_objfile
6285 = get_dwarf2_per_objfile (objfile
);
6287 init_psymbol_list (objfile
, 1024);
6291 /* This isn't really ideal: all the data we allocate on the
6292 objfile's obstack is still uselessly kept around. However,
6293 freeing it seems unsafe. */
6294 psymtab_discarder
psymtabs (objfile
);
6295 dwarf2_build_psymtabs_hard (dwarf2_per_objfile
);
6298 /* (maybe) store an index in the cache. */
6299 global_index_cache
.store (dwarf2_per_objfile
);
6301 catch (const gdb_exception_error
&except
)
6303 exception_print (gdb_stderr
, except
);
6307 /* Return the total length of the CU described by HEADER. */
6310 get_cu_length (const struct comp_unit_head
*header
)
6312 return header
->initial_length_size
+ header
->length
;
6315 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6318 offset_in_cu_p (const comp_unit_head
*cu_header
, sect_offset sect_off
)
6320 sect_offset bottom
= cu_header
->sect_off
;
6321 sect_offset top
= cu_header
->sect_off
+ get_cu_length (cu_header
);
6323 return sect_off
>= bottom
&& sect_off
< top
;
6326 /* Find the base address of the compilation unit for range lists and
6327 location lists. It will normally be specified by DW_AT_low_pc.
6328 In DWARF-3 draft 4, the base address could be overridden by
6329 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6330 compilation units with discontinuous ranges. */
6333 dwarf2_find_base_address (struct die_info
*die
, struct dwarf2_cu
*cu
)
6335 struct attribute
*attr
;
6338 cu
->base_address
= 0;
6340 attr
= dwarf2_attr (die
, DW_AT_entry_pc
, cu
);
6343 cu
->base_address
= attr_value_as_address (attr
);
6348 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
6351 cu
->base_address
= attr_value_as_address (attr
);
6357 /* Read in the comp unit header information from the debug_info at info_ptr.
6358 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6359 NOTE: This leaves members offset, first_die_offset to be filled in
6362 static const gdb_byte
*
6363 read_comp_unit_head (struct comp_unit_head
*cu_header
,
6364 const gdb_byte
*info_ptr
,
6365 struct dwarf2_section_info
*section
,
6366 rcuh_kind section_kind
)
6369 unsigned int bytes_read
;
6370 const char *filename
= get_section_file_name (section
);
6371 bfd
*abfd
= get_section_bfd_owner (section
);
6373 cu_header
->length
= read_initial_length (abfd
, info_ptr
, &bytes_read
);
6374 cu_header
->initial_length_size
= bytes_read
;
6375 cu_header
->offset_size
= (bytes_read
== 4) ? 4 : 8;
6376 info_ptr
+= bytes_read
;
6377 cu_header
->version
= read_2_bytes (abfd
, info_ptr
);
6378 if (cu_header
->version
< 2 || cu_header
->version
> 5)
6379 error (_("Dwarf Error: wrong version in compilation unit header "
6380 "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6381 cu_header
->version
, filename
);
6383 if (cu_header
->version
< 5)
6384 switch (section_kind
)
6386 case rcuh_kind::COMPILE
:
6387 cu_header
->unit_type
= DW_UT_compile
;
6389 case rcuh_kind::TYPE
:
6390 cu_header
->unit_type
= DW_UT_type
;
6393 internal_error (__FILE__
, __LINE__
,
6394 _("read_comp_unit_head: invalid section_kind"));
6398 cu_header
->unit_type
= static_cast<enum dwarf_unit_type
>
6399 (read_1_byte (abfd
, info_ptr
));
6401 switch (cu_header
->unit_type
)
6404 if (section_kind
!= rcuh_kind::COMPILE
)
6405 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6406 "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6410 section_kind
= rcuh_kind::TYPE
;
6413 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6414 "(is %d, should be %d or %d) [in module %s]"),
6415 cu_header
->unit_type
, DW_UT_compile
, DW_UT_type
, filename
);
6418 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
6421 cu_header
->abbrev_sect_off
= (sect_offset
) read_offset (abfd
, info_ptr
,
6424 info_ptr
+= bytes_read
;
6425 if (cu_header
->version
< 5)
6427 cu_header
->addr_size
= read_1_byte (abfd
, info_ptr
);
6430 signed_addr
= bfd_get_sign_extend_vma (abfd
);
6431 if (signed_addr
< 0)
6432 internal_error (__FILE__
, __LINE__
,
6433 _("read_comp_unit_head: dwarf from non elf file"));
6434 cu_header
->signed_addr_p
= signed_addr
;
6436 if (section_kind
== rcuh_kind::TYPE
)
6438 LONGEST type_offset
;
6440 cu_header
->signature
= read_8_bytes (abfd
, info_ptr
);
6443 type_offset
= read_offset (abfd
, info_ptr
, cu_header
, &bytes_read
);
6444 info_ptr
+= bytes_read
;
6445 cu_header
->type_cu_offset_in_tu
= (cu_offset
) type_offset
;
6446 if (to_underlying (cu_header
->type_cu_offset_in_tu
) != type_offset
)
6447 error (_("Dwarf Error: Too big type_offset in compilation unit "
6448 "header (is %s) [in module %s]"), plongest (type_offset
),
6455 /* Helper function that returns the proper abbrev section for
6458 static struct dwarf2_section_info
*
6459 get_abbrev_section_for_cu (struct dwarf2_per_cu_data
*this_cu
)
6461 struct dwarf2_section_info
*abbrev
;
6462 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
6464 if (this_cu
->is_dwz
)
6465 abbrev
= &dwarf2_get_dwz_file (dwarf2_per_objfile
)->abbrev
;
6467 abbrev
= &dwarf2_per_objfile
->abbrev
;
6472 /* Subroutine of read_and_check_comp_unit_head and
6473 read_and_check_type_unit_head to simplify them.
6474 Perform various error checking on the header. */
6477 error_check_comp_unit_head (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6478 struct comp_unit_head
*header
,
6479 struct dwarf2_section_info
*section
,
6480 struct dwarf2_section_info
*abbrev_section
)
6482 const char *filename
= get_section_file_name (section
);
6484 if (to_underlying (header
->abbrev_sect_off
)
6485 >= dwarf2_section_size (dwarf2_per_objfile
->objfile
, abbrev_section
))
6486 error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6487 "(offset %s + 6) [in module %s]"),
6488 sect_offset_str (header
->abbrev_sect_off
),
6489 sect_offset_str (header
->sect_off
),
6492 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6493 avoid potential 32-bit overflow. */
6494 if (((ULONGEST
) header
->sect_off
+ get_cu_length (header
))
6496 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6497 "(offset %s + 0) [in module %s]"),
6498 header
->length
, sect_offset_str (header
->sect_off
),
6502 /* Read in a CU/TU header and perform some basic error checking.
6503 The contents of the header are stored in HEADER.
6504 The result is a pointer to the start of the first DIE. */
6506 static const gdb_byte
*
6507 read_and_check_comp_unit_head (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6508 struct comp_unit_head
*header
,
6509 struct dwarf2_section_info
*section
,
6510 struct dwarf2_section_info
*abbrev_section
,
6511 const gdb_byte
*info_ptr
,
6512 rcuh_kind section_kind
)
6514 const gdb_byte
*beg_of_comp_unit
= info_ptr
;
6516 header
->sect_off
= (sect_offset
) (beg_of_comp_unit
- section
->buffer
);
6518 info_ptr
= read_comp_unit_head (header
, info_ptr
, section
, section_kind
);
6520 header
->first_die_cu_offset
= (cu_offset
) (info_ptr
- beg_of_comp_unit
);
6522 error_check_comp_unit_head (dwarf2_per_objfile
, header
, section
,
6528 /* Fetch the abbreviation table offset from a comp or type unit header. */
6531 read_abbrev_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6532 struct dwarf2_section_info
*section
,
6533 sect_offset sect_off
)
6535 bfd
*abfd
= get_section_bfd_owner (section
);
6536 const gdb_byte
*info_ptr
;
6537 unsigned int initial_length_size
, offset_size
;
6540 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
6541 info_ptr
= section
->buffer
+ to_underlying (sect_off
);
6542 read_initial_length (abfd
, info_ptr
, &initial_length_size
);
6543 offset_size
= initial_length_size
== 4 ? 4 : 8;
6544 info_ptr
+= initial_length_size
;
6546 version
= read_2_bytes (abfd
, info_ptr
);
6550 /* Skip unit type and address size. */
6554 return (sect_offset
) read_offset_1 (abfd
, info_ptr
, offset_size
);
6557 /* Allocate a new partial symtab for file named NAME and mark this new
6558 partial symtab as being an include of PST. */
6561 dwarf2_create_include_psymtab (const char *name
, struct partial_symtab
*pst
,
6562 struct objfile
*objfile
)
6564 struct partial_symtab
*subpst
= allocate_psymtab (name
, objfile
);
6566 if (!IS_ABSOLUTE_PATH (subpst
->filename
))
6568 /* It shares objfile->objfile_obstack. */
6569 subpst
->dirname
= pst
->dirname
;
6572 subpst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (1);
6573 subpst
->dependencies
[0] = pst
;
6574 subpst
->number_of_dependencies
= 1;
6576 subpst
->read_symtab
= pst
->read_symtab
;
6578 /* No private part is necessary for include psymtabs. This property
6579 can be used to differentiate between such include psymtabs and
6580 the regular ones. */
6581 subpst
->read_symtab_private
= NULL
;
6584 /* Read the Line Number Program data and extract the list of files
6585 included by the source file represented by PST. Build an include
6586 partial symtab for each of these included files. */
6589 dwarf2_build_include_psymtabs (struct dwarf2_cu
*cu
,
6590 struct die_info
*die
,
6591 struct partial_symtab
*pst
)
6594 struct attribute
*attr
;
6596 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
6598 lh
= dwarf_decode_line_header ((sect_offset
) DW_UNSND (attr
), cu
);
6600 return; /* No linetable, so no includes. */
6602 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6603 that we pass in the raw text_low here; that is ok because we're
6604 only decoding the line table to make include partial symtabs, and
6605 so the addresses aren't really used. */
6606 dwarf_decode_lines (lh
.get (), pst
->dirname
, cu
, pst
,
6607 pst
->raw_text_low (), 1);
6611 hash_signatured_type (const void *item
)
6613 const struct signatured_type
*sig_type
6614 = (const struct signatured_type
*) item
;
6616 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6617 return sig_type
->signature
;
6621 eq_signatured_type (const void *item_lhs
, const void *item_rhs
)
6623 const struct signatured_type
*lhs
= (const struct signatured_type
*) item_lhs
;
6624 const struct signatured_type
*rhs
= (const struct signatured_type
*) item_rhs
;
6626 return lhs
->signature
== rhs
->signature
;
6629 /* Allocate a hash table for signatured types. */
6632 allocate_signatured_type_table (struct objfile
*objfile
)
6634 return htab_create_alloc_ex (41,
6635 hash_signatured_type
,
6638 &objfile
->objfile_obstack
,
6639 hashtab_obstack_allocate
,
6640 dummy_obstack_deallocate
);
6643 /* A helper function to add a signatured type CU to a table. */
6646 add_signatured_type_cu_to_table (void **slot
, void *datum
)
6648 struct signatured_type
*sigt
= (struct signatured_type
*) *slot
;
6649 std::vector
<signatured_type
*> *all_type_units
6650 = (std::vector
<signatured_type
*> *) datum
;
6652 all_type_units
->push_back (sigt
);
6657 /* A helper for create_debug_types_hash_table. Read types from SECTION
6658 and fill them into TYPES_HTAB. It will process only type units,
6659 therefore DW_UT_type. */
6662 create_debug_type_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6663 struct dwo_file
*dwo_file
,
6664 dwarf2_section_info
*section
, htab_t
&types_htab
,
6665 rcuh_kind section_kind
)
6667 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6668 struct dwarf2_section_info
*abbrev_section
;
6670 const gdb_byte
*info_ptr
, *end_ptr
;
6672 abbrev_section
= (dwo_file
!= NULL
6673 ? &dwo_file
->sections
.abbrev
6674 : &dwarf2_per_objfile
->abbrev
);
6676 if (dwarf_read_debug
)
6677 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
6678 get_section_name (section
),
6679 get_section_file_name (abbrev_section
));
6681 dwarf2_read_section (objfile
, section
);
6682 info_ptr
= section
->buffer
;
6684 if (info_ptr
== NULL
)
6687 /* We can't set abfd until now because the section may be empty or
6688 not present, in which case the bfd is unknown. */
6689 abfd
= get_section_bfd_owner (section
);
6691 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6692 because we don't need to read any dies: the signature is in the
6695 end_ptr
= info_ptr
+ section
->size
;
6696 while (info_ptr
< end_ptr
)
6698 struct signatured_type
*sig_type
;
6699 struct dwo_unit
*dwo_tu
;
6701 const gdb_byte
*ptr
= info_ptr
;
6702 struct comp_unit_head header
;
6703 unsigned int length
;
6705 sect_offset sect_off
= (sect_offset
) (ptr
- section
->buffer
);
6707 /* Initialize it due to a false compiler warning. */
6708 header
.signature
= -1;
6709 header
.type_cu_offset_in_tu
= (cu_offset
) -1;
6711 /* We need to read the type's signature in order to build the hash
6712 table, but we don't need anything else just yet. */
6714 ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
, &header
, section
,
6715 abbrev_section
, ptr
, section_kind
);
6717 length
= get_cu_length (&header
);
6719 /* Skip dummy type units. */
6720 if (ptr
>= info_ptr
+ length
6721 || peek_abbrev_code (abfd
, ptr
) == 0
6722 || header
.unit_type
!= DW_UT_type
)
6728 if (types_htab
== NULL
)
6731 types_htab
= allocate_dwo_unit_table (objfile
);
6733 types_htab
= allocate_signatured_type_table (objfile
);
6739 dwo_tu
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6741 dwo_tu
->dwo_file
= dwo_file
;
6742 dwo_tu
->signature
= header
.signature
;
6743 dwo_tu
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6744 dwo_tu
->section
= section
;
6745 dwo_tu
->sect_off
= sect_off
;
6746 dwo_tu
->length
= length
;
6750 /* N.B.: type_offset is not usable if this type uses a DWO file.
6751 The real type_offset is in the DWO file. */
6753 sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6754 struct signatured_type
);
6755 sig_type
->signature
= header
.signature
;
6756 sig_type
->type_offset_in_tu
= header
.type_cu_offset_in_tu
;
6757 sig_type
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
6758 sig_type
->per_cu
.is_debug_types
= 1;
6759 sig_type
->per_cu
.section
= section
;
6760 sig_type
->per_cu
.sect_off
= sect_off
;
6761 sig_type
->per_cu
.length
= length
;
6764 slot
= htab_find_slot (types_htab
,
6765 dwo_file
? (void*) dwo_tu
: (void *) sig_type
,
6767 gdb_assert (slot
!= NULL
);
6770 sect_offset dup_sect_off
;
6774 const struct dwo_unit
*dup_tu
6775 = (const struct dwo_unit
*) *slot
;
6777 dup_sect_off
= dup_tu
->sect_off
;
6781 const struct signatured_type
*dup_tu
6782 = (const struct signatured_type
*) *slot
;
6784 dup_sect_off
= dup_tu
->per_cu
.sect_off
;
6787 complaint (_("debug type entry at offset %s is duplicate to"
6788 " the entry at offset %s, signature %s"),
6789 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
6790 hex_string (header
.signature
));
6792 *slot
= dwo_file
? (void *) dwo_tu
: (void *) sig_type
;
6794 if (dwarf_read_debug
> 1)
6795 fprintf_unfiltered (gdb_stdlog
, " offset %s, signature %s\n",
6796 sect_offset_str (sect_off
),
6797 hex_string (header
.signature
));
6803 /* Create the hash table of all entries in the .debug_types
6804 (or .debug_types.dwo) section(s).
6805 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6806 otherwise it is NULL.
6808 The result is a pointer to the hash table or NULL if there are no types.
6810 Note: This function processes DWO files only, not DWP files. */
6813 create_debug_types_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6814 struct dwo_file
*dwo_file
,
6815 gdb::array_view
<dwarf2_section_info
> type_sections
,
6818 for (dwarf2_section_info
§ion
: type_sections
)
6819 create_debug_type_hash_table (dwarf2_per_objfile
, dwo_file
, §ion
,
6820 types_htab
, rcuh_kind::TYPE
);
6823 /* Create the hash table of all entries in the .debug_types section,
6824 and initialize all_type_units.
6825 The result is zero if there is an error (e.g. missing .debug_types section),
6826 otherwise non-zero. */
6829 create_all_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
6831 htab_t types_htab
= NULL
;
6833 create_debug_type_hash_table (dwarf2_per_objfile
, NULL
,
6834 &dwarf2_per_objfile
->info
, types_htab
,
6835 rcuh_kind::COMPILE
);
6836 create_debug_types_hash_table (dwarf2_per_objfile
, NULL
,
6837 dwarf2_per_objfile
->types
, types_htab
);
6838 if (types_htab
== NULL
)
6840 dwarf2_per_objfile
->signatured_types
= NULL
;
6844 dwarf2_per_objfile
->signatured_types
= types_htab
;
6846 gdb_assert (dwarf2_per_objfile
->all_type_units
.empty ());
6847 dwarf2_per_objfile
->all_type_units
.reserve (htab_elements (types_htab
));
6849 htab_traverse_noresize (types_htab
, add_signatured_type_cu_to_table
,
6850 &dwarf2_per_objfile
->all_type_units
);
6855 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6856 If SLOT is non-NULL, it is the entry to use in the hash table.
6857 Otherwise we find one. */
6859 static struct signatured_type
*
6860 add_type_unit (struct dwarf2_per_objfile
*dwarf2_per_objfile
, ULONGEST sig
,
6863 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6865 if (dwarf2_per_objfile
->all_type_units
.size ()
6866 == dwarf2_per_objfile
->all_type_units
.capacity ())
6867 ++dwarf2_per_objfile
->tu_stats
.nr_all_type_units_reallocs
;
6869 signatured_type
*sig_type
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6870 struct signatured_type
);
6872 dwarf2_per_objfile
->all_type_units
.push_back (sig_type
);
6873 sig_type
->signature
= sig
;
6874 sig_type
->per_cu
.is_debug_types
= 1;
6875 if (dwarf2_per_objfile
->using_index
)
6877 sig_type
->per_cu
.v
.quick
=
6878 OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
6879 struct dwarf2_per_cu_quick_data
);
6884 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
6887 gdb_assert (*slot
== NULL
);
6889 /* The rest of sig_type must be filled in by the caller. */
6893 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6894 Fill in SIG_ENTRY with DWO_ENTRY. */
6897 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
6898 struct signatured_type
*sig_entry
,
6899 struct dwo_unit
*dwo_entry
)
6901 /* Make sure we're not clobbering something we don't expect to. */
6902 gdb_assert (! sig_entry
->per_cu
.queued
);
6903 gdb_assert (sig_entry
->per_cu
.cu
== NULL
);
6904 if (dwarf2_per_objfile
->using_index
)
6906 gdb_assert (sig_entry
->per_cu
.v
.quick
!= NULL
);
6907 gdb_assert (sig_entry
->per_cu
.v
.quick
->compunit_symtab
== NULL
);
6910 gdb_assert (sig_entry
->per_cu
.v
.psymtab
== NULL
);
6911 gdb_assert (sig_entry
->signature
== dwo_entry
->signature
);
6912 gdb_assert (to_underlying (sig_entry
->type_offset_in_section
) == 0);
6913 gdb_assert (sig_entry
->type_unit_group
== NULL
);
6914 gdb_assert (sig_entry
->dwo_unit
== NULL
);
6916 sig_entry
->per_cu
.section
= dwo_entry
->section
;
6917 sig_entry
->per_cu
.sect_off
= dwo_entry
->sect_off
;
6918 sig_entry
->per_cu
.length
= dwo_entry
->length
;
6919 sig_entry
->per_cu
.reading_dwo_directly
= 1;
6920 sig_entry
->per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
6921 sig_entry
->type_offset_in_tu
= dwo_entry
->type_offset_in_tu
;
6922 sig_entry
->dwo_unit
= dwo_entry
;
6925 /* Subroutine of lookup_signatured_type.
6926 If we haven't read the TU yet, create the signatured_type data structure
6927 for a TU to be read in directly from a DWO file, bypassing the stub.
6928 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6929 using .gdb_index, then when reading a CU we want to stay in the DWO file
6930 containing that CU. Otherwise we could end up reading several other DWO
6931 files (due to comdat folding) to process the transitive closure of all the
6932 mentioned TUs, and that can be slow. The current DWO file will have every
6933 type signature that it needs.
6934 We only do this for .gdb_index because in the psymtab case we already have
6935 to read all the DWOs to build the type unit groups. */
6937 static struct signatured_type
*
6938 lookup_dwo_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
6940 struct dwarf2_per_objfile
*dwarf2_per_objfile
6941 = cu
->per_cu
->dwarf2_per_objfile
;
6942 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
6943 struct dwo_file
*dwo_file
;
6944 struct dwo_unit find_dwo_entry
, *dwo_entry
;
6945 struct signatured_type find_sig_entry
, *sig_entry
;
6948 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
6950 /* If TU skeletons have been removed then we may not have read in any
6952 if (dwarf2_per_objfile
->signatured_types
== NULL
)
6954 dwarf2_per_objfile
->signatured_types
6955 = allocate_signatured_type_table (objfile
);
6958 /* We only ever need to read in one copy of a signatured type.
6959 Use the global signatured_types array to do our own comdat-folding
6960 of types. If this is the first time we're reading this TU, and
6961 the TU has an entry in .gdb_index, replace the recorded data from
6962 .gdb_index with this TU. */
6964 find_sig_entry
.signature
= sig
;
6965 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
6966 &find_sig_entry
, INSERT
);
6967 sig_entry
= (struct signatured_type
*) *slot
;
6969 /* We can get here with the TU already read, *or* in the process of being
6970 read. Don't reassign the global entry to point to this DWO if that's
6971 the case. Also note that if the TU is already being read, it may not
6972 have come from a DWO, the program may be a mix of Fission-compiled
6973 code and non-Fission-compiled code. */
6975 /* Have we already tried to read this TU?
6976 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6977 needn't exist in the global table yet). */
6978 if (sig_entry
!= NULL
&& sig_entry
->per_cu
.tu_read
)
6981 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6982 dwo_unit of the TU itself. */
6983 dwo_file
= cu
->dwo_unit
->dwo_file
;
6985 /* Ok, this is the first time we're reading this TU. */
6986 if (dwo_file
->tus
== NULL
)
6988 find_dwo_entry
.signature
= sig
;
6989 dwo_entry
= (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_entry
);
6990 if (dwo_entry
== NULL
)
6993 /* If the global table doesn't have an entry for this TU, add one. */
6994 if (sig_entry
== NULL
)
6995 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
6997 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
6998 sig_entry
->per_cu
.tu_read
= 1;
7002 /* Subroutine of lookup_signatured_type.
7003 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7004 then try the DWP file. If the TU stub (skeleton) has been removed then
7005 it won't be in .gdb_index. */
7007 static struct signatured_type
*
7008 lookup_dwp_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7010 struct dwarf2_per_objfile
*dwarf2_per_objfile
7011 = cu
->per_cu
->dwarf2_per_objfile
;
7012 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7013 struct dwp_file
*dwp_file
= get_dwp_file (dwarf2_per_objfile
);
7014 struct dwo_unit
*dwo_entry
;
7015 struct signatured_type find_sig_entry
, *sig_entry
;
7018 gdb_assert (cu
->dwo_unit
&& dwarf2_per_objfile
->using_index
);
7019 gdb_assert (dwp_file
!= NULL
);
7021 /* If TU skeletons have been removed then we may not have read in any
7023 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7025 dwarf2_per_objfile
->signatured_types
7026 = allocate_signatured_type_table (objfile
);
7029 find_sig_entry
.signature
= sig
;
7030 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
,
7031 &find_sig_entry
, INSERT
);
7032 sig_entry
= (struct signatured_type
*) *slot
;
7034 /* Have we already tried to read this TU?
7035 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7036 needn't exist in the global table yet). */
7037 if (sig_entry
!= NULL
)
7040 if (dwp_file
->tus
== NULL
)
7042 dwo_entry
= lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, NULL
,
7043 sig
, 1 /* is_debug_types */);
7044 if (dwo_entry
== NULL
)
7047 sig_entry
= add_type_unit (dwarf2_per_objfile
, sig
, slot
);
7048 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, sig_entry
, dwo_entry
);
7053 /* Lookup a signature based type for DW_FORM_ref_sig8.
7054 Returns NULL if signature SIG is not present in the table.
7055 It is up to the caller to complain about this. */
7057 static struct signatured_type
*
7058 lookup_signatured_type (struct dwarf2_cu
*cu
, ULONGEST sig
)
7060 struct dwarf2_per_objfile
*dwarf2_per_objfile
7061 = cu
->per_cu
->dwarf2_per_objfile
;
7064 && dwarf2_per_objfile
->using_index
)
7066 /* We're in a DWO/DWP file, and we're using .gdb_index.
7067 These cases require special processing. */
7068 if (get_dwp_file (dwarf2_per_objfile
) == NULL
)
7069 return lookup_dwo_signatured_type (cu
, sig
);
7071 return lookup_dwp_signatured_type (cu
, sig
);
7075 struct signatured_type find_entry
, *entry
;
7077 if (dwarf2_per_objfile
->signatured_types
== NULL
)
7079 find_entry
.signature
= sig
;
7080 entry
= ((struct signatured_type
*)
7081 htab_find (dwarf2_per_objfile
->signatured_types
, &find_entry
));
7086 /* Low level DIE reading support. */
7088 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7091 init_cu_die_reader (struct die_reader_specs
*reader
,
7092 struct dwarf2_cu
*cu
,
7093 struct dwarf2_section_info
*section
,
7094 struct dwo_file
*dwo_file
,
7095 struct abbrev_table
*abbrev_table
)
7097 gdb_assert (section
->readin
&& section
->buffer
!= NULL
);
7098 reader
->abfd
= get_section_bfd_owner (section
);
7100 reader
->dwo_file
= dwo_file
;
7101 reader
->die_section
= section
;
7102 reader
->buffer
= section
->buffer
;
7103 reader
->buffer_end
= section
->buffer
+ section
->size
;
7104 reader
->comp_dir
= NULL
;
7105 reader
->abbrev_table
= abbrev_table
;
7108 /* Subroutine of init_cutu_and_read_dies to simplify it.
7109 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7110 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7113 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7114 from it to the DIE in the DWO. If NULL we are skipping the stub.
7115 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7116 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7117 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7118 STUB_COMP_DIR may be non-NULL.
7119 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7120 are filled in with the info of the DIE from the DWO file.
7121 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7122 from the dwo. Since *RESULT_READER references this abbrev table, it must be
7123 kept around for at least as long as *RESULT_READER.
7125 The result is non-zero if a valid (non-dummy) DIE was found. */
7128 read_cutu_die_from_dwo (struct dwarf2_per_cu_data
*this_cu
,
7129 struct dwo_unit
*dwo_unit
,
7130 struct die_info
*stub_comp_unit_die
,
7131 const char *stub_comp_dir
,
7132 struct die_reader_specs
*result_reader
,
7133 const gdb_byte
**result_info_ptr
,
7134 struct die_info
**result_comp_unit_die
,
7135 int *result_has_children
,
7136 abbrev_table_up
*result_dwo_abbrev_table
)
7138 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7139 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7140 struct dwarf2_cu
*cu
= this_cu
->cu
;
7142 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7143 struct attribute
*comp_dir
, *stmt_list
, *low_pc
, *high_pc
, *ranges
;
7144 int i
,num_extra_attrs
;
7145 struct dwarf2_section_info
*dwo_abbrev_section
;
7146 struct attribute
*attr
;
7147 struct die_info
*comp_unit_die
;
7149 /* At most one of these may be provided. */
7150 gdb_assert ((stub_comp_unit_die
!= NULL
) + (stub_comp_dir
!= NULL
) <= 1);
7152 /* These attributes aren't processed until later:
7153 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7154 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7155 referenced later. However, these attributes are found in the stub
7156 which we won't have later. In order to not impose this complication
7157 on the rest of the code, we read them here and copy them to the
7166 if (stub_comp_unit_die
!= NULL
)
7168 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7170 if (! this_cu
->is_debug_types
)
7171 stmt_list
= dwarf2_attr (stub_comp_unit_die
, DW_AT_stmt_list
, cu
);
7172 low_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_low_pc
, cu
);
7173 high_pc
= dwarf2_attr (stub_comp_unit_die
, DW_AT_high_pc
, cu
);
7174 ranges
= dwarf2_attr (stub_comp_unit_die
, DW_AT_ranges
, cu
);
7175 comp_dir
= dwarf2_attr (stub_comp_unit_die
, DW_AT_comp_dir
, cu
);
7177 /* There should be a DW_AT_addr_base attribute here (if needed).
7178 We need the value before we can process DW_FORM_GNU_addr_index
7179 or DW_FORM_addrx. */
7181 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_addr_base
, cu
);
7183 cu
->addr_base
= DW_UNSND (attr
);
7185 /* There should be a DW_AT_ranges_base attribute here (if needed).
7186 We need the value before we can process DW_AT_ranges. */
7187 cu
->ranges_base
= 0;
7188 attr
= dwarf2_attr (stub_comp_unit_die
, DW_AT_GNU_ranges_base
, cu
);
7190 cu
->ranges_base
= DW_UNSND (attr
);
7192 else if (stub_comp_dir
!= NULL
)
7194 /* Reconstruct the comp_dir attribute to simplify the code below. */
7195 comp_dir
= XOBNEW (&cu
->comp_unit_obstack
, struct attribute
);
7196 comp_dir
->name
= DW_AT_comp_dir
;
7197 comp_dir
->form
= DW_FORM_string
;
7198 DW_STRING_IS_CANONICAL (comp_dir
) = 0;
7199 DW_STRING (comp_dir
) = stub_comp_dir
;
7202 /* Set up for reading the DWO CU/TU. */
7203 cu
->dwo_unit
= dwo_unit
;
7204 dwarf2_section_info
*section
= dwo_unit
->section
;
7205 dwarf2_read_section (objfile
, section
);
7206 abfd
= get_section_bfd_owner (section
);
7207 begin_info_ptr
= info_ptr
= (section
->buffer
7208 + to_underlying (dwo_unit
->sect_off
));
7209 dwo_abbrev_section
= &dwo_unit
->dwo_file
->sections
.abbrev
;
7211 if (this_cu
->is_debug_types
)
7213 struct signatured_type
*sig_type
= (struct signatured_type
*) this_cu
;
7215 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7216 &cu
->header
, section
,
7218 info_ptr
, rcuh_kind::TYPE
);
7219 /* This is not an assert because it can be caused by bad debug info. */
7220 if (sig_type
->signature
!= cu
->header
.signature
)
7222 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7223 " TU at offset %s [in module %s]"),
7224 hex_string (sig_type
->signature
),
7225 hex_string (cu
->header
.signature
),
7226 sect_offset_str (dwo_unit
->sect_off
),
7227 bfd_get_filename (abfd
));
7229 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7230 /* For DWOs coming from DWP files, we don't know the CU length
7231 nor the type's offset in the TU until now. */
7232 dwo_unit
->length
= get_cu_length (&cu
->header
);
7233 dwo_unit
->type_offset_in_tu
= cu
->header
.type_cu_offset_in_tu
;
7235 /* Establish the type offset that can be used to lookup the type.
7236 For DWO files, we don't know it until now. */
7237 sig_type
->type_offset_in_section
7238 = dwo_unit
->sect_off
+ to_underlying (dwo_unit
->type_offset_in_tu
);
7242 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7243 &cu
->header
, section
,
7245 info_ptr
, rcuh_kind::COMPILE
);
7246 gdb_assert (dwo_unit
->sect_off
== cu
->header
.sect_off
);
7247 /* For DWOs coming from DWP files, we don't know the CU length
7249 dwo_unit
->length
= get_cu_length (&cu
->header
);
7252 *result_dwo_abbrev_table
7253 = abbrev_table_read_table (dwarf2_per_objfile
, dwo_abbrev_section
,
7254 cu
->header
.abbrev_sect_off
);
7255 init_cu_die_reader (result_reader
, cu
, section
, dwo_unit
->dwo_file
,
7256 result_dwo_abbrev_table
->get ());
7258 /* Read in the die, but leave space to copy over the attributes
7259 from the stub. This has the benefit of simplifying the rest of
7260 the code - all the work to maintain the illusion of a single
7261 DW_TAG_{compile,type}_unit DIE is done here. */
7262 num_extra_attrs
= ((stmt_list
!= NULL
)
7266 + (comp_dir
!= NULL
));
7267 info_ptr
= read_full_die_1 (result_reader
, result_comp_unit_die
, info_ptr
,
7268 result_has_children
, num_extra_attrs
);
7270 /* Copy over the attributes from the stub to the DIE we just read in. */
7271 comp_unit_die
= *result_comp_unit_die
;
7272 i
= comp_unit_die
->num_attrs
;
7273 if (stmt_list
!= NULL
)
7274 comp_unit_die
->attrs
[i
++] = *stmt_list
;
7276 comp_unit_die
->attrs
[i
++] = *low_pc
;
7277 if (high_pc
!= NULL
)
7278 comp_unit_die
->attrs
[i
++] = *high_pc
;
7280 comp_unit_die
->attrs
[i
++] = *ranges
;
7281 if (comp_dir
!= NULL
)
7282 comp_unit_die
->attrs
[i
++] = *comp_dir
;
7283 comp_unit_die
->num_attrs
+= num_extra_attrs
;
7285 if (dwarf_die_debug
)
7287 fprintf_unfiltered (gdb_stdlog
,
7288 "Read die from %s@0x%x of %s:\n",
7289 get_section_name (section
),
7290 (unsigned) (begin_info_ptr
- section
->buffer
),
7291 bfd_get_filename (abfd
));
7292 dump_die (comp_unit_die
, dwarf_die_debug
);
7295 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7296 TUs by skipping the stub and going directly to the entry in the DWO file.
7297 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7298 to get it via circuitous means. Blech. */
7299 if (comp_dir
!= NULL
)
7300 result_reader
->comp_dir
= DW_STRING (comp_dir
);
7302 /* Skip dummy compilation units. */
7303 if (info_ptr
>= begin_info_ptr
+ dwo_unit
->length
7304 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7307 *result_info_ptr
= info_ptr
;
7311 /* Subroutine of init_cutu_and_read_dies to simplify it.
7312 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7313 Returns NULL if the specified DWO unit cannot be found. */
7315 static struct dwo_unit
*
7316 lookup_dwo_unit (struct dwarf2_per_cu_data
*this_cu
,
7317 struct die_info
*comp_unit_die
)
7319 struct dwarf2_cu
*cu
= this_cu
->cu
;
7321 struct dwo_unit
*dwo_unit
;
7322 const char *comp_dir
, *dwo_name
;
7324 gdb_assert (cu
!= NULL
);
7326 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7327 dwo_name
= dwarf2_string_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
7328 comp_dir
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7330 if (this_cu
->is_debug_types
)
7332 struct signatured_type
*sig_type
;
7334 /* Since this_cu is the first member of struct signatured_type,
7335 we can go from a pointer to one to a pointer to the other. */
7336 sig_type
= (struct signatured_type
*) this_cu
;
7337 signature
= sig_type
->signature
;
7338 dwo_unit
= lookup_dwo_type_unit (sig_type
, dwo_name
, comp_dir
);
7342 struct attribute
*attr
;
7344 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
7346 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7348 dwo_name
, objfile_name (this_cu
->dwarf2_per_objfile
->objfile
));
7349 signature
= DW_UNSND (attr
);
7350 dwo_unit
= lookup_dwo_comp_unit (this_cu
, dwo_name
, comp_dir
,
7357 /* Subroutine of init_cutu_and_read_dies to simplify it.
7358 See it for a description of the parameters.
7359 Read a TU directly from a DWO file, bypassing the stub. */
7362 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data
*this_cu
,
7363 int use_existing_cu
, int keep
,
7364 die_reader_func_ftype
*die_reader_func
,
7367 std::unique_ptr
<dwarf2_cu
> new_cu
;
7368 struct signatured_type
*sig_type
;
7369 struct die_reader_specs reader
;
7370 const gdb_byte
*info_ptr
;
7371 struct die_info
*comp_unit_die
;
7373 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7375 /* Verify we can do the following downcast, and that we have the
7377 gdb_assert (this_cu
->is_debug_types
&& this_cu
->reading_dwo_directly
);
7378 sig_type
= (struct signatured_type
*) this_cu
;
7379 gdb_assert (sig_type
->dwo_unit
!= NULL
);
7381 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
7383 gdb_assert (this_cu
->cu
->dwo_unit
== sig_type
->dwo_unit
);
7384 /* There's no need to do the rereading_dwo_cu handling that
7385 init_cutu_and_read_dies does since we don't read the stub. */
7389 /* If !use_existing_cu, this_cu->cu must be NULL. */
7390 gdb_assert (this_cu
->cu
== NULL
);
7391 new_cu
.reset (new dwarf2_cu (this_cu
));
7394 /* A future optimization, if needed, would be to use an existing
7395 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7396 could share abbrev tables. */
7398 /* The abbreviation table used by READER, this must live at least as long as
7400 abbrev_table_up dwo_abbrev_table
;
7402 if (read_cutu_die_from_dwo (this_cu
, sig_type
->dwo_unit
,
7403 NULL
/* stub_comp_unit_die */,
7404 sig_type
->dwo_unit
->dwo_file
->comp_dir
,
7406 &comp_unit_die
, &has_children
,
7407 &dwo_abbrev_table
) == 0)
7413 /* All the "real" work is done here. */
7414 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7416 /* This duplicates the code in init_cutu_and_read_dies,
7417 but the alternative is making the latter more complex.
7418 This function is only for the special case of using DWO files directly:
7419 no point in overly complicating the general case just to handle this. */
7420 if (new_cu
!= NULL
&& keep
)
7422 /* Link this CU into read_in_chain. */
7423 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
7424 dwarf2_per_objfile
->read_in_chain
= this_cu
;
7425 /* The chain owns it now. */
7430 /* Initialize a CU (or TU) and read its DIEs.
7431 If the CU defers to a DWO file, read the DWO file as well.
7433 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7434 Otherwise the table specified in the comp unit header is read in and used.
7435 This is an optimization for when we already have the abbrev table.
7437 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7438 Otherwise, a new CU is allocated with xmalloc.
7440 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7441 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7443 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7444 linker) then DIE_READER_FUNC will not get called. */
7447 init_cutu_and_read_dies (struct dwarf2_per_cu_data
*this_cu
,
7448 struct abbrev_table
*abbrev_table
,
7449 int use_existing_cu
, int keep
,
7451 die_reader_func_ftype
*die_reader_func
,
7454 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7455 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7456 struct dwarf2_section_info
*section
= this_cu
->section
;
7457 bfd
*abfd
= get_section_bfd_owner (section
);
7458 struct dwarf2_cu
*cu
;
7459 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7460 struct die_reader_specs reader
;
7461 struct die_info
*comp_unit_die
;
7463 struct attribute
*attr
;
7464 struct signatured_type
*sig_type
= NULL
;
7465 struct dwarf2_section_info
*abbrev_section
;
7466 /* Non-zero if CU currently points to a DWO file and we need to
7467 reread it. When this happens we need to reread the skeleton die
7468 before we can reread the DWO file (this only applies to CUs, not TUs). */
7469 int rereading_dwo_cu
= 0;
7471 if (dwarf_die_debug
)
7472 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7473 this_cu
->is_debug_types
? "type" : "comp",
7474 sect_offset_str (this_cu
->sect_off
));
7476 if (use_existing_cu
)
7479 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7480 file (instead of going through the stub), short-circuit all of this. */
7481 if (this_cu
->reading_dwo_directly
)
7483 /* Narrow down the scope of possibilities to have to understand. */
7484 gdb_assert (this_cu
->is_debug_types
);
7485 gdb_assert (abbrev_table
== NULL
);
7486 init_tu_and_read_dwo_dies (this_cu
, use_existing_cu
, keep
,
7487 die_reader_func
, data
);
7491 /* This is cheap if the section is already read in. */
7492 dwarf2_read_section (objfile
, section
);
7494 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7496 abbrev_section
= get_abbrev_section_for_cu (this_cu
);
7498 std::unique_ptr
<dwarf2_cu
> new_cu
;
7499 if (use_existing_cu
&& this_cu
->cu
!= NULL
)
7502 /* If this CU is from a DWO file we need to start over, we need to
7503 refetch the attributes from the skeleton CU.
7504 This could be optimized by retrieving those attributes from when we
7505 were here the first time: the previous comp_unit_die was stored in
7506 comp_unit_obstack. But there's no data yet that we need this
7508 if (cu
->dwo_unit
!= NULL
)
7509 rereading_dwo_cu
= 1;
7513 /* If !use_existing_cu, this_cu->cu must be NULL. */
7514 gdb_assert (this_cu
->cu
== NULL
);
7515 new_cu
.reset (new dwarf2_cu (this_cu
));
7519 /* Get the header. */
7520 if (to_underlying (cu
->header
.first_die_cu_offset
) != 0 && !rereading_dwo_cu
)
7522 /* We already have the header, there's no need to read it in again. */
7523 info_ptr
+= to_underlying (cu
->header
.first_die_cu_offset
);
7527 if (this_cu
->is_debug_types
)
7529 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7530 &cu
->header
, section
,
7531 abbrev_section
, info_ptr
,
7534 /* Since per_cu is the first member of struct signatured_type,
7535 we can go from a pointer to one to a pointer to the other. */
7536 sig_type
= (struct signatured_type
*) this_cu
;
7537 gdb_assert (sig_type
->signature
== cu
->header
.signature
);
7538 gdb_assert (sig_type
->type_offset_in_tu
7539 == cu
->header
.type_cu_offset_in_tu
);
7540 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7542 /* LENGTH has not been set yet for type units if we're
7543 using .gdb_index. */
7544 this_cu
->length
= get_cu_length (&cu
->header
);
7546 /* Establish the type offset that can be used to lookup the type. */
7547 sig_type
->type_offset_in_section
=
7548 this_cu
->sect_off
+ to_underlying (sig_type
->type_offset_in_tu
);
7550 this_cu
->dwarf_version
= cu
->header
.version
;
7554 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7555 &cu
->header
, section
,
7558 rcuh_kind::COMPILE
);
7560 gdb_assert (this_cu
->sect_off
== cu
->header
.sect_off
);
7561 gdb_assert (this_cu
->length
== get_cu_length (&cu
->header
));
7562 this_cu
->dwarf_version
= cu
->header
.version
;
7566 /* Skip dummy compilation units. */
7567 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7568 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7571 /* If we don't have them yet, read the abbrevs for this compilation unit.
7572 And if we need to read them now, make sure they're freed when we're
7573 done (own the table through ABBREV_TABLE_HOLDER). */
7574 abbrev_table_up abbrev_table_holder
;
7575 if (abbrev_table
!= NULL
)
7576 gdb_assert (cu
->header
.abbrev_sect_off
== abbrev_table
->sect_off
);
7580 = abbrev_table_read_table (dwarf2_per_objfile
, abbrev_section
,
7581 cu
->header
.abbrev_sect_off
);
7582 abbrev_table
= abbrev_table_holder
.get ();
7585 /* Read the top level CU/TU die. */
7586 init_cu_die_reader (&reader
, cu
, section
, NULL
, abbrev_table
);
7587 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
7589 if (skip_partial
&& comp_unit_die
->tag
== DW_TAG_partial_unit
)
7592 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7593 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7594 table from the DWO file and pass the ownership over to us. It will be
7595 referenced from READER, so we must make sure to free it after we're done
7598 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7599 DWO CU, that this test will fail (the attribute will not be present). */
7600 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_name
, cu
);
7601 abbrev_table_up dwo_abbrev_table
;
7604 struct dwo_unit
*dwo_unit
;
7605 struct die_info
*dwo_comp_unit_die
;
7609 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7610 " has children (offset %s) [in module %s]"),
7611 sect_offset_str (this_cu
->sect_off
),
7612 bfd_get_filename (abfd
));
7614 dwo_unit
= lookup_dwo_unit (this_cu
, comp_unit_die
);
7615 if (dwo_unit
!= NULL
)
7617 if (read_cutu_die_from_dwo (this_cu
, dwo_unit
,
7618 comp_unit_die
, NULL
,
7620 &dwo_comp_unit_die
, &has_children
,
7621 &dwo_abbrev_table
) == 0)
7626 comp_unit_die
= dwo_comp_unit_die
;
7630 /* Yikes, we couldn't find the rest of the DIE, we only have
7631 the stub. A complaint has already been logged. There's
7632 not much more we can do except pass on the stub DIE to
7633 die_reader_func. We don't want to throw an error on bad
7638 /* All of the above is setup for this call. Yikes. */
7639 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7641 /* Done, clean up. */
7642 if (new_cu
!= NULL
&& keep
)
7644 /* Link this CU into read_in_chain. */
7645 this_cu
->cu
->read_in_chain
= dwarf2_per_objfile
->read_in_chain
;
7646 dwarf2_per_objfile
->read_in_chain
= this_cu
;
7647 /* The chain owns it now. */
7652 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7653 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7654 to have already done the lookup to find the DWO file).
7656 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7657 THIS_CU->is_debug_types, but nothing else.
7659 We fill in THIS_CU->length.
7661 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7662 linker) then DIE_READER_FUNC will not get called.
7664 THIS_CU->cu is always freed when done.
7665 This is done in order to not leave THIS_CU->cu in a state where we have
7666 to care whether it refers to the "main" CU or the DWO CU. */
7669 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data
*this_cu
,
7670 struct dwo_file
*dwo_file
,
7671 die_reader_func_ftype
*die_reader_func
,
7674 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_cu
->dwarf2_per_objfile
;
7675 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7676 struct dwarf2_section_info
*section
= this_cu
->section
;
7677 bfd
*abfd
= get_section_bfd_owner (section
);
7678 struct dwarf2_section_info
*abbrev_section
;
7679 const gdb_byte
*begin_info_ptr
, *info_ptr
;
7680 struct die_reader_specs reader
;
7681 struct die_info
*comp_unit_die
;
7684 if (dwarf_die_debug
)
7685 fprintf_unfiltered (gdb_stdlog
, "Reading %s unit at offset %s\n",
7686 this_cu
->is_debug_types
? "type" : "comp",
7687 sect_offset_str (this_cu
->sect_off
));
7689 gdb_assert (this_cu
->cu
== NULL
);
7691 abbrev_section
= (dwo_file
!= NULL
7692 ? &dwo_file
->sections
.abbrev
7693 : get_abbrev_section_for_cu (this_cu
));
7695 /* This is cheap if the section is already read in. */
7696 dwarf2_read_section (objfile
, section
);
7698 struct dwarf2_cu
cu (this_cu
);
7700 begin_info_ptr
= info_ptr
= section
->buffer
+ to_underlying (this_cu
->sect_off
);
7701 info_ptr
= read_and_check_comp_unit_head (dwarf2_per_objfile
,
7702 &cu
.header
, section
,
7703 abbrev_section
, info_ptr
,
7704 (this_cu
->is_debug_types
7706 : rcuh_kind::COMPILE
));
7708 this_cu
->length
= get_cu_length (&cu
.header
);
7710 /* Skip dummy compilation units. */
7711 if (info_ptr
>= begin_info_ptr
+ this_cu
->length
7712 || peek_abbrev_code (abfd
, info_ptr
) == 0)
7715 abbrev_table_up abbrev_table
7716 = abbrev_table_read_table (dwarf2_per_objfile
, abbrev_section
,
7717 cu
.header
.abbrev_sect_off
);
7719 init_cu_die_reader (&reader
, &cu
, section
, dwo_file
, abbrev_table
.get ());
7720 info_ptr
= read_full_die (&reader
, &comp_unit_die
, info_ptr
, &has_children
);
7722 die_reader_func (&reader
, info_ptr
, comp_unit_die
, has_children
, data
);
7725 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7726 does not lookup the specified DWO file.
7727 This cannot be used to read DWO files.
7729 THIS_CU->cu is always freed when done.
7730 This is done in order to not leave THIS_CU->cu in a state where we have
7731 to care whether it refers to the "main" CU or the DWO CU.
7732 We can revisit this if the data shows there's a performance issue. */
7735 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data
*this_cu
,
7736 die_reader_func_ftype
*die_reader_func
,
7739 init_cutu_and_read_dies_no_follow (this_cu
, NULL
, die_reader_func
, data
);
7742 /* Type Unit Groups.
7744 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7745 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7746 so that all types coming from the same compilation (.o file) are grouped
7747 together. A future step could be to put the types in the same symtab as
7748 the CU the types ultimately came from. */
7751 hash_type_unit_group (const void *item
)
7753 const struct type_unit_group
*tu_group
7754 = (const struct type_unit_group
*) item
;
7756 return hash_stmt_list_entry (&tu_group
->hash
);
7760 eq_type_unit_group (const void *item_lhs
, const void *item_rhs
)
7762 const struct type_unit_group
*lhs
= (const struct type_unit_group
*) item_lhs
;
7763 const struct type_unit_group
*rhs
= (const struct type_unit_group
*) item_rhs
;
7765 return eq_stmt_list_entry (&lhs
->hash
, &rhs
->hash
);
7768 /* Allocate a hash table for type unit groups. */
7771 allocate_type_unit_groups_table (struct objfile
*objfile
)
7773 return htab_create_alloc_ex (3,
7774 hash_type_unit_group
,
7777 &objfile
->objfile_obstack
,
7778 hashtab_obstack_allocate
,
7779 dummy_obstack_deallocate
);
7782 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7783 partial symtabs. We combine several TUs per psymtab to not let the size
7784 of any one psymtab grow too big. */
7785 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7786 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7788 /* Helper routine for get_type_unit_group.
7789 Create the type_unit_group object used to hold one or more TUs. */
7791 static struct type_unit_group
*
7792 create_type_unit_group (struct dwarf2_cu
*cu
, sect_offset line_offset_struct
)
7794 struct dwarf2_per_objfile
*dwarf2_per_objfile
7795 = cu
->per_cu
->dwarf2_per_objfile
;
7796 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
7797 struct dwarf2_per_cu_data
*per_cu
;
7798 struct type_unit_group
*tu_group
;
7800 tu_group
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7801 struct type_unit_group
);
7802 per_cu
= &tu_group
->per_cu
;
7803 per_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
7805 if (dwarf2_per_objfile
->using_index
)
7807 per_cu
->v
.quick
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
7808 struct dwarf2_per_cu_quick_data
);
7812 unsigned int line_offset
= to_underlying (line_offset_struct
);
7813 struct partial_symtab
*pst
;
7816 /* Give the symtab a useful name for debug purposes. */
7817 if ((line_offset
& NO_STMT_LIST_TYPE_UNIT_PSYMTAB
) != 0)
7818 name
= string_printf ("<type_units_%d>",
7819 (line_offset
& ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB
));
7821 name
= string_printf ("<type_units_at_0x%x>", line_offset
);
7823 pst
= create_partial_symtab (per_cu
, name
.c_str ());
7827 tu_group
->hash
.dwo_unit
= cu
->dwo_unit
;
7828 tu_group
->hash
.line_sect_off
= line_offset_struct
;
7833 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7834 STMT_LIST is a DW_AT_stmt_list attribute. */
7836 static struct type_unit_group
*
7837 get_type_unit_group (struct dwarf2_cu
*cu
, const struct attribute
*stmt_list
)
7839 struct dwarf2_per_objfile
*dwarf2_per_objfile
7840 = cu
->per_cu
->dwarf2_per_objfile
;
7841 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
7842 struct type_unit_group
*tu_group
;
7844 unsigned int line_offset
;
7845 struct type_unit_group type_unit_group_for_lookup
;
7847 if (dwarf2_per_objfile
->type_unit_groups
== NULL
)
7849 dwarf2_per_objfile
->type_unit_groups
=
7850 allocate_type_unit_groups_table (dwarf2_per_objfile
->objfile
);
7853 /* Do we need to create a new group, or can we use an existing one? */
7857 line_offset
= DW_UNSND (stmt_list
);
7858 ++tu_stats
->nr_symtab_sharers
;
7862 /* Ugh, no stmt_list. Rare, but we have to handle it.
7863 We can do various things here like create one group per TU or
7864 spread them over multiple groups to split up the expansion work.
7865 To avoid worst case scenarios (too many groups or too large groups)
7866 we, umm, group them in bunches. */
7867 line_offset
= (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7868 | (tu_stats
->nr_stmt_less_type_units
7869 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
));
7870 ++tu_stats
->nr_stmt_less_type_units
;
7873 type_unit_group_for_lookup
.hash
.dwo_unit
= cu
->dwo_unit
;
7874 type_unit_group_for_lookup
.hash
.line_sect_off
= (sect_offset
) line_offset
;
7875 slot
= htab_find_slot (dwarf2_per_objfile
->type_unit_groups
,
7876 &type_unit_group_for_lookup
, INSERT
);
7879 tu_group
= (struct type_unit_group
*) *slot
;
7880 gdb_assert (tu_group
!= NULL
);
7884 sect_offset line_offset_struct
= (sect_offset
) line_offset
;
7885 tu_group
= create_type_unit_group (cu
, line_offset_struct
);
7887 ++tu_stats
->nr_symtabs
;
7893 /* Partial symbol tables. */
7895 /* Create a psymtab named NAME and assign it to PER_CU.
7897 The caller must fill in the following details:
7898 dirname, textlow, texthigh. */
7900 static struct partial_symtab
*
7901 create_partial_symtab (struct dwarf2_per_cu_data
*per_cu
, const char *name
)
7903 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
7904 struct partial_symtab
*pst
;
7906 pst
= start_psymtab_common (objfile
, name
, 0);
7908 pst
->psymtabs_addrmap_supported
= 1;
7910 /* This is the glue that links PST into GDB's symbol API. */
7911 pst
->read_symtab_private
= per_cu
;
7912 pst
->read_symtab
= dwarf2_read_symtab
;
7913 per_cu
->v
.psymtab
= pst
;
7918 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7921 struct process_psymtab_comp_unit_data
7923 /* True if we are reading a DW_TAG_partial_unit. */
7925 int want_partial_unit
;
7927 /* The "pretend" language that is used if the CU doesn't declare a
7930 enum language pretend_language
;
7933 /* die_reader_func for process_psymtab_comp_unit. */
7936 process_psymtab_comp_unit_reader (const struct die_reader_specs
*reader
,
7937 const gdb_byte
*info_ptr
,
7938 struct die_info
*comp_unit_die
,
7942 struct dwarf2_cu
*cu
= reader
->cu
;
7943 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
7944 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
7945 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
7947 CORE_ADDR best_lowpc
= 0, best_highpc
= 0;
7948 struct partial_symtab
*pst
;
7949 enum pc_bounds_kind cu_bounds_kind
;
7950 const char *filename
;
7951 struct process_psymtab_comp_unit_data
*info
7952 = (struct process_psymtab_comp_unit_data
*) data
;
7954 if (comp_unit_die
->tag
== DW_TAG_partial_unit
&& !info
->want_partial_unit
)
7957 gdb_assert (! per_cu
->is_debug_types
);
7959 prepare_one_comp_unit (cu
, comp_unit_die
, info
->pretend_language
);
7961 /* Allocate a new partial symbol table structure. */
7962 filename
= dwarf2_string_attr (comp_unit_die
, DW_AT_name
, cu
);
7963 if (filename
== NULL
)
7966 pst
= create_partial_symtab (per_cu
, filename
);
7968 /* This must be done before calling dwarf2_build_include_psymtabs. */
7969 pst
->dirname
= dwarf2_string_attr (comp_unit_die
, DW_AT_comp_dir
, cu
);
7971 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
7973 dwarf2_find_base_address (comp_unit_die
, cu
);
7975 /* Possibly set the default values of LOWPC and HIGHPC from
7977 cu_bounds_kind
= dwarf2_get_pc_bounds (comp_unit_die
, &best_lowpc
,
7978 &best_highpc
, cu
, pst
);
7979 if (cu_bounds_kind
== PC_BOUNDS_HIGH_LOW
&& best_lowpc
< best_highpc
)
7982 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_lowpc
+ baseaddr
)
7985 = (gdbarch_adjust_dwarf2_addr (gdbarch
, best_highpc
+ baseaddr
)
7987 /* Store the contiguous range if it is not empty; it can be
7988 empty for CUs with no code. */
7989 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
7993 /* Check if comp unit has_children.
7994 If so, read the rest of the partial symbols from this comp unit.
7995 If not, there's no more debug_info for this comp unit. */
7998 struct partial_die_info
*first_die
;
7999 CORE_ADDR lowpc
, highpc
;
8001 lowpc
= ((CORE_ADDR
) -1);
8002 highpc
= ((CORE_ADDR
) 0);
8004 first_die
= load_partial_dies (reader
, info_ptr
, 1);
8006 scan_partial_symbols (first_die
, &lowpc
, &highpc
,
8007 cu_bounds_kind
<= PC_BOUNDS_INVALID
, cu
);
8009 /* If we didn't find a lowpc, set it to highpc to avoid
8010 complaints from `maint check'. */
8011 if (lowpc
== ((CORE_ADDR
) -1))
8014 /* If the compilation unit didn't have an explicit address range,
8015 then use the information extracted from its child dies. */
8016 if (cu_bounds_kind
<= PC_BOUNDS_INVALID
)
8019 best_highpc
= highpc
;
8022 pst
->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch
,
8023 best_lowpc
+ baseaddr
)
8025 pst
->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch
,
8026 best_highpc
+ baseaddr
)
8029 end_psymtab_common (objfile
, pst
);
8031 if (!VEC_empty (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
))
8034 int len
= VEC_length (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
8035 struct dwarf2_per_cu_data
*iter
;
8037 /* Fill in 'dependencies' here; we fill in 'users' in a
8039 pst
->number_of_dependencies
= len
;
8041 = objfile
->partial_symtabs
->allocate_dependencies (len
);
8043 VEC_iterate (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
8046 pst
->dependencies
[i
] = iter
->v
.psymtab
;
8048 VEC_free (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
);
8051 /* Get the list of files included in the current compilation unit,
8052 and build a psymtab for each of them. */
8053 dwarf2_build_include_psymtabs (cu
, comp_unit_die
, pst
);
8055 if (dwarf_read_debug
)
8056 fprintf_unfiltered (gdb_stdlog
,
8057 "Psymtab for %s unit @%s: %s - %s"
8058 ", %d global, %d static syms\n",
8059 per_cu
->is_debug_types
? "type" : "comp",
8060 sect_offset_str (per_cu
->sect_off
),
8061 paddress (gdbarch
, pst
->text_low (objfile
)),
8062 paddress (gdbarch
, pst
->text_high (objfile
)),
8063 pst
->n_global_syms
, pst
->n_static_syms
);
8066 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8067 Process compilation unit THIS_CU for a psymtab. */
8070 process_psymtab_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
8071 int want_partial_unit
,
8072 enum language pretend_language
)
8074 /* If this compilation unit was already read in, free the
8075 cached copy in order to read it in again. This is
8076 necessary because we skipped some symbols when we first
8077 read in the compilation unit (see load_partial_dies).
8078 This problem could be avoided, but the benefit is unclear. */
8079 if (this_cu
->cu
!= NULL
)
8080 free_one_cached_comp_unit (this_cu
);
8082 if (this_cu
->is_debug_types
)
8083 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0, false,
8084 build_type_psymtabs_reader
, NULL
);
8087 process_psymtab_comp_unit_data info
;
8088 info
.want_partial_unit
= want_partial_unit
;
8089 info
.pretend_language
= pretend_language
;
8090 init_cutu_and_read_dies (this_cu
, NULL
, 0, 0, false,
8091 process_psymtab_comp_unit_reader
, &info
);
8094 /* Age out any secondary CUs. */
8095 age_cached_comp_units (this_cu
->dwarf2_per_objfile
);
8098 /* Reader function for build_type_psymtabs. */
8101 build_type_psymtabs_reader (const struct die_reader_specs
*reader
,
8102 const gdb_byte
*info_ptr
,
8103 struct die_info
*type_unit_die
,
8107 struct dwarf2_per_objfile
*dwarf2_per_objfile
8108 = reader
->cu
->per_cu
->dwarf2_per_objfile
;
8109 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8110 struct dwarf2_cu
*cu
= reader
->cu
;
8111 struct dwarf2_per_cu_data
*per_cu
= cu
->per_cu
;
8112 struct signatured_type
*sig_type
;
8113 struct type_unit_group
*tu_group
;
8114 struct attribute
*attr
;
8115 struct partial_die_info
*first_die
;
8116 CORE_ADDR lowpc
, highpc
;
8117 struct partial_symtab
*pst
;
8119 gdb_assert (data
== NULL
);
8120 gdb_assert (per_cu
->is_debug_types
);
8121 sig_type
= (struct signatured_type
*) per_cu
;
8126 attr
= dwarf2_attr_no_follow (type_unit_die
, DW_AT_stmt_list
);
8127 tu_group
= get_type_unit_group (cu
, attr
);
8129 VEC_safe_push (sig_type_ptr
, tu_group
->tus
, sig_type
);
8131 prepare_one_comp_unit (cu
, type_unit_die
, language_minimal
);
8132 pst
= create_partial_symtab (per_cu
, "");
8135 first_die
= load_partial_dies (reader
, info_ptr
, 1);
8137 lowpc
= (CORE_ADDR
) -1;
8138 highpc
= (CORE_ADDR
) 0;
8139 scan_partial_symbols (first_die
, &lowpc
, &highpc
, 0, cu
);
8141 end_psymtab_common (objfile
, pst
);
8144 /* Struct used to sort TUs by their abbreviation table offset. */
8146 struct tu_abbrev_offset
8148 tu_abbrev_offset (signatured_type
*sig_type_
, sect_offset abbrev_offset_
)
8149 : sig_type (sig_type_
), abbrev_offset (abbrev_offset_
)
8152 signatured_type
*sig_type
;
8153 sect_offset abbrev_offset
;
8156 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
8159 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset
&a
,
8160 const struct tu_abbrev_offset
&b
)
8162 return a
.abbrev_offset
< b
.abbrev_offset
;
8165 /* Efficiently read all the type units.
8166 This does the bulk of the work for build_type_psymtabs.
8168 The efficiency is because we sort TUs by the abbrev table they use and
8169 only read each abbrev table once. In one program there are 200K TUs
8170 sharing 8K abbrev tables.
8172 The main purpose of this function is to support building the
8173 dwarf2_per_objfile->type_unit_groups table.
8174 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8175 can collapse the search space by grouping them by stmt_list.
8176 The savings can be significant, in the same program from above the 200K TUs
8177 share 8K stmt_list tables.
8179 FUNC is expected to call get_type_unit_group, which will create the
8180 struct type_unit_group if necessary and add it to
8181 dwarf2_per_objfile->type_unit_groups. */
8184 build_type_psymtabs_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8186 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
8187 abbrev_table_up abbrev_table
;
8188 sect_offset abbrev_offset
;
8190 /* It's up to the caller to not call us multiple times. */
8191 gdb_assert (dwarf2_per_objfile
->type_unit_groups
== NULL
);
8193 if (dwarf2_per_objfile
->all_type_units
.empty ())
8196 /* TUs typically share abbrev tables, and there can be way more TUs than
8197 abbrev tables. Sort by abbrev table to reduce the number of times we
8198 read each abbrev table in.
8199 Alternatives are to punt or to maintain a cache of abbrev tables.
8200 This is simpler and efficient enough for now.
8202 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8203 symtab to use). Typically TUs with the same abbrev offset have the same
8204 stmt_list value too so in practice this should work well.
8206 The basic algorithm here is:
8208 sort TUs by abbrev table
8209 for each TU with same abbrev table:
8210 read abbrev table if first user
8211 read TU top level DIE
8212 [IWBN if DWO skeletons had DW_AT_stmt_list]
8215 if (dwarf_read_debug
)
8216 fprintf_unfiltered (gdb_stdlog
, "Building type unit groups ...\n");
8218 /* Sort in a separate table to maintain the order of all_type_units
8219 for .gdb_index: TU indices directly index all_type_units. */
8220 std::vector
<tu_abbrev_offset
> sorted_by_abbrev
;
8221 sorted_by_abbrev
.reserve (dwarf2_per_objfile
->all_type_units
.size ());
8223 for (signatured_type
*sig_type
: dwarf2_per_objfile
->all_type_units
)
8224 sorted_by_abbrev
.emplace_back
8225 (sig_type
, read_abbrev_offset (dwarf2_per_objfile
,
8226 sig_type
->per_cu
.section
,
8227 sig_type
->per_cu
.sect_off
));
8229 std::sort (sorted_by_abbrev
.begin (), sorted_by_abbrev
.end (),
8230 sort_tu_by_abbrev_offset
);
8232 abbrev_offset
= (sect_offset
) ~(unsigned) 0;
8234 for (const tu_abbrev_offset
&tu
: sorted_by_abbrev
)
8236 /* Switch to the next abbrev table if necessary. */
8237 if (abbrev_table
== NULL
8238 || tu
.abbrev_offset
!= abbrev_offset
)
8240 abbrev_offset
= tu
.abbrev_offset
;
8242 abbrev_table_read_table (dwarf2_per_objfile
,
8243 &dwarf2_per_objfile
->abbrev
,
8245 ++tu_stats
->nr_uniq_abbrev_tables
;
8248 init_cutu_and_read_dies (&tu
.sig_type
->per_cu
, abbrev_table
.get (),
8249 0, 0, false, build_type_psymtabs_reader
, NULL
);
8253 /* Print collected type unit statistics. */
8256 print_tu_stats (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8258 struct tu_stats
*tu_stats
= &dwarf2_per_objfile
->tu_stats
;
8260 fprintf_unfiltered (gdb_stdlog
, "Type unit statistics:\n");
8261 fprintf_unfiltered (gdb_stdlog
, " %zu TUs\n",
8262 dwarf2_per_objfile
->all_type_units
.size ());
8263 fprintf_unfiltered (gdb_stdlog
, " %d uniq abbrev tables\n",
8264 tu_stats
->nr_uniq_abbrev_tables
);
8265 fprintf_unfiltered (gdb_stdlog
, " %d symtabs from stmt_list entries\n",
8266 tu_stats
->nr_symtabs
);
8267 fprintf_unfiltered (gdb_stdlog
, " %d symtab sharers\n",
8268 tu_stats
->nr_symtab_sharers
);
8269 fprintf_unfiltered (gdb_stdlog
, " %d type units without a stmt_list\n",
8270 tu_stats
->nr_stmt_less_type_units
);
8271 fprintf_unfiltered (gdb_stdlog
, " %d all_type_units reallocs\n",
8272 tu_stats
->nr_all_type_units_reallocs
);
8275 /* Traversal function for build_type_psymtabs. */
8278 build_type_psymtab_dependencies (void **slot
, void *info
)
8280 struct dwarf2_per_objfile
*dwarf2_per_objfile
8281 = (struct dwarf2_per_objfile
*) info
;
8282 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8283 struct type_unit_group
*tu_group
= (struct type_unit_group
*) *slot
;
8284 struct dwarf2_per_cu_data
*per_cu
= &tu_group
->per_cu
;
8285 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8286 int len
= VEC_length (sig_type_ptr
, tu_group
->tus
);
8287 struct signatured_type
*iter
;
8290 gdb_assert (len
> 0);
8291 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu
));
8293 pst
->number_of_dependencies
= len
;
8294 pst
->dependencies
= objfile
->partial_symtabs
->allocate_dependencies (len
);
8296 VEC_iterate (sig_type_ptr
, tu_group
->tus
, i
, iter
);
8299 gdb_assert (iter
->per_cu
.is_debug_types
);
8300 pst
->dependencies
[i
] = iter
->per_cu
.v
.psymtab
;
8301 iter
->type_unit_group
= tu_group
;
8304 VEC_free (sig_type_ptr
, tu_group
->tus
);
8309 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8310 Build partial symbol tables for the .debug_types comp-units. */
8313 build_type_psymtabs (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8315 if (! create_all_type_units (dwarf2_per_objfile
))
8318 build_type_psymtabs_1 (dwarf2_per_objfile
);
8321 /* Traversal function for process_skeletonless_type_unit.
8322 Read a TU in a DWO file and build partial symbols for it. */
8325 process_skeletonless_type_unit (void **slot
, void *info
)
8327 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
8328 struct dwarf2_per_objfile
*dwarf2_per_objfile
8329 = (struct dwarf2_per_objfile
*) info
;
8330 struct signatured_type find_entry
, *entry
;
8332 /* If this TU doesn't exist in the global table, add it and read it in. */
8334 if (dwarf2_per_objfile
->signatured_types
== NULL
)
8336 dwarf2_per_objfile
->signatured_types
8337 = allocate_signatured_type_table (dwarf2_per_objfile
->objfile
);
8340 find_entry
.signature
= dwo_unit
->signature
;
8341 slot
= htab_find_slot (dwarf2_per_objfile
->signatured_types
, &find_entry
,
8343 /* If we've already seen this type there's nothing to do. What's happening
8344 is we're doing our own version of comdat-folding here. */
8348 /* This does the job that create_all_type_units would have done for
8350 entry
= add_type_unit (dwarf2_per_objfile
, dwo_unit
->signature
, slot
);
8351 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile
, entry
, dwo_unit
);
8354 /* This does the job that build_type_psymtabs_1 would have done. */
8355 init_cutu_and_read_dies (&entry
->per_cu
, NULL
, 0, 0, false,
8356 build_type_psymtabs_reader
, NULL
);
8361 /* Traversal function for process_skeletonless_type_units. */
8364 process_dwo_file_for_skeletonless_type_units (void **slot
, void *info
)
8366 struct dwo_file
*dwo_file
= (struct dwo_file
*) *slot
;
8368 if (dwo_file
->tus
!= NULL
)
8370 htab_traverse_noresize (dwo_file
->tus
,
8371 process_skeletonless_type_unit
, info
);
8377 /* Scan all TUs of DWO files, verifying we've processed them.
8378 This is needed in case a TU was emitted without its skeleton.
8379 Note: This can't be done until we know what all the DWO files are. */
8382 process_skeletonless_type_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8384 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8385 if (get_dwp_file (dwarf2_per_objfile
) == NULL
8386 && dwarf2_per_objfile
->dwo_files
!= NULL
)
8388 htab_traverse_noresize (dwarf2_per_objfile
->dwo_files
.get (),
8389 process_dwo_file_for_skeletonless_type_units
,
8390 dwarf2_per_objfile
);
8394 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8397 set_partial_user (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8399 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
8401 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
8406 for (int j
= 0; j
< pst
->number_of_dependencies
; ++j
)
8408 /* Set the 'user' field only if it is not already set. */
8409 if (pst
->dependencies
[j
]->user
== NULL
)
8410 pst
->dependencies
[j
]->user
= pst
;
8415 /* Build the partial symbol table by doing a quick pass through the
8416 .debug_info and .debug_abbrev sections. */
8419 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8421 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8423 if (dwarf_read_debug
)
8425 fprintf_unfiltered (gdb_stdlog
, "Building psymtabs of objfile %s ...\n",
8426 objfile_name (objfile
));
8429 dwarf2_per_objfile
->reading_partial_symbols
= 1;
8431 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->info
);
8433 /* Any cached compilation units will be linked by the per-objfile
8434 read_in_chain. Make sure to free them when we're done. */
8435 free_cached_comp_units
freer (dwarf2_per_objfile
);
8437 build_type_psymtabs (dwarf2_per_objfile
);
8439 create_all_comp_units (dwarf2_per_objfile
);
8441 /* Create a temporary address map on a temporary obstack. We later
8442 copy this to the final obstack. */
8443 auto_obstack temp_obstack
;
8445 scoped_restore save_psymtabs_addrmap
8446 = make_scoped_restore (&objfile
->partial_symtabs
->psymtabs_addrmap
,
8447 addrmap_create_mutable (&temp_obstack
));
8449 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->all_comp_units
)
8450 process_psymtab_comp_unit (per_cu
, 0, language_minimal
);
8452 /* This has to wait until we read the CUs, we need the list of DWOs. */
8453 process_skeletonless_type_units (dwarf2_per_objfile
);
8455 /* Now that all TUs have been processed we can fill in the dependencies. */
8456 if (dwarf2_per_objfile
->type_unit_groups
!= NULL
)
8458 htab_traverse_noresize (dwarf2_per_objfile
->type_unit_groups
,
8459 build_type_psymtab_dependencies
, dwarf2_per_objfile
);
8462 if (dwarf_read_debug
)
8463 print_tu_stats (dwarf2_per_objfile
);
8465 set_partial_user (dwarf2_per_objfile
);
8467 objfile
->partial_symtabs
->psymtabs_addrmap
8468 = addrmap_create_fixed (objfile
->partial_symtabs
->psymtabs_addrmap
,
8469 objfile
->partial_symtabs
->obstack ());
8470 /* At this point we want to keep the address map. */
8471 save_psymtabs_addrmap
.release ();
8473 if (dwarf_read_debug
)
8474 fprintf_unfiltered (gdb_stdlog
, "Done building psymtabs of %s\n",
8475 objfile_name (objfile
));
8478 /* die_reader_func for load_partial_comp_unit. */
8481 load_partial_comp_unit_reader (const struct die_reader_specs
*reader
,
8482 const gdb_byte
*info_ptr
,
8483 struct die_info
*comp_unit_die
,
8487 struct dwarf2_cu
*cu
= reader
->cu
;
8489 prepare_one_comp_unit (cu
, comp_unit_die
, language_minimal
);
8491 /* Check if comp unit has_children.
8492 If so, read the rest of the partial symbols from this comp unit.
8493 If not, there's no more debug_info for this comp unit. */
8495 load_partial_dies (reader
, info_ptr
, 0);
8498 /* Load the partial DIEs for a secondary CU into memory.
8499 This is also used when rereading a primary CU with load_all_dies. */
8502 load_partial_comp_unit (struct dwarf2_per_cu_data
*this_cu
)
8504 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1, false,
8505 load_partial_comp_unit_reader
, NULL
);
8509 read_comp_units_from_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
8510 struct dwarf2_section_info
*section
,
8511 struct dwarf2_section_info
*abbrev_section
,
8512 unsigned int is_dwz
)
8514 const gdb_byte
*info_ptr
;
8515 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8517 if (dwarf_read_debug
)
8518 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s\n",
8519 get_section_name (section
),
8520 get_section_file_name (section
));
8522 dwarf2_read_section (objfile
, section
);
8524 info_ptr
= section
->buffer
;
8526 while (info_ptr
< section
->buffer
+ section
->size
)
8528 struct dwarf2_per_cu_data
*this_cu
;
8530 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
->buffer
);
8532 comp_unit_head cu_header
;
8533 read_and_check_comp_unit_head (dwarf2_per_objfile
, &cu_header
, section
,
8534 abbrev_section
, info_ptr
,
8535 rcuh_kind::COMPILE
);
8537 /* Save the compilation unit for later lookup. */
8538 if (cu_header
.unit_type
!= DW_UT_type
)
8540 this_cu
= XOBNEW (&objfile
->objfile_obstack
,
8541 struct dwarf2_per_cu_data
);
8542 memset (this_cu
, 0, sizeof (*this_cu
));
8546 auto sig_type
= XOBNEW (&objfile
->objfile_obstack
,
8547 struct signatured_type
);
8548 memset (sig_type
, 0, sizeof (*sig_type
));
8549 sig_type
->signature
= cu_header
.signature
;
8550 sig_type
->type_offset_in_tu
= cu_header
.type_cu_offset_in_tu
;
8551 this_cu
= &sig_type
->per_cu
;
8553 this_cu
->is_debug_types
= (cu_header
.unit_type
== DW_UT_type
);
8554 this_cu
->sect_off
= sect_off
;
8555 this_cu
->length
= cu_header
.length
+ cu_header
.initial_length_size
;
8556 this_cu
->is_dwz
= is_dwz
;
8557 this_cu
->dwarf2_per_objfile
= dwarf2_per_objfile
;
8558 this_cu
->section
= section
;
8560 dwarf2_per_objfile
->all_comp_units
.push_back (this_cu
);
8562 info_ptr
= info_ptr
+ this_cu
->length
;
8566 /* Create a list of all compilation units in OBJFILE.
8567 This is only done for -readnow and building partial symtabs. */
8570 create_all_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
8572 gdb_assert (dwarf2_per_objfile
->all_comp_units
.empty ());
8573 read_comp_units_from_section (dwarf2_per_objfile
, &dwarf2_per_objfile
->info
,
8574 &dwarf2_per_objfile
->abbrev
, 0);
8576 dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
8578 read_comp_units_from_section (dwarf2_per_objfile
, &dwz
->info
, &dwz
->abbrev
,
8582 /* Process all loaded DIEs for compilation unit CU, starting at
8583 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8584 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8585 DW_AT_ranges). See the comments of add_partial_subprogram on how
8586 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8589 scan_partial_symbols (struct partial_die_info
*first_die
, CORE_ADDR
*lowpc
,
8590 CORE_ADDR
*highpc
, int set_addrmap
,
8591 struct dwarf2_cu
*cu
)
8593 struct partial_die_info
*pdi
;
8595 /* Now, march along the PDI's, descending into ones which have
8596 interesting children but skipping the children of the other ones,
8597 until we reach the end of the compilation unit. */
8605 /* Anonymous namespaces or modules have no name but have interesting
8606 children, so we need to look at them. Ditto for anonymous
8609 if (pdi
->name
!= NULL
|| pdi
->tag
== DW_TAG_namespace
8610 || pdi
->tag
== DW_TAG_module
|| pdi
->tag
== DW_TAG_enumeration_type
8611 || pdi
->tag
== DW_TAG_imported_unit
8612 || pdi
->tag
== DW_TAG_inlined_subroutine
)
8616 case DW_TAG_subprogram
:
8617 case DW_TAG_inlined_subroutine
:
8618 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8620 case DW_TAG_constant
:
8621 case DW_TAG_variable
:
8622 case DW_TAG_typedef
:
8623 case DW_TAG_union_type
:
8624 if (!pdi
->is_declaration
)
8626 add_partial_symbol (pdi
, cu
);
8629 case DW_TAG_class_type
:
8630 case DW_TAG_interface_type
:
8631 case DW_TAG_structure_type
:
8632 if (!pdi
->is_declaration
)
8634 add_partial_symbol (pdi
, cu
);
8636 if ((cu
->language
== language_rust
8637 || cu
->language
== language_cplus
) && pdi
->has_children
)
8638 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
,
8641 case DW_TAG_enumeration_type
:
8642 if (!pdi
->is_declaration
)
8643 add_partial_enumeration (pdi
, cu
);
8645 case DW_TAG_base_type
:
8646 case DW_TAG_subrange_type
:
8647 /* File scope base type definitions are added to the partial
8649 add_partial_symbol (pdi
, cu
);
8651 case DW_TAG_namespace
:
8652 add_partial_namespace (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8655 add_partial_module (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
8657 case DW_TAG_imported_unit
:
8659 struct dwarf2_per_cu_data
*per_cu
;
8661 /* For now we don't handle imported units in type units. */
8662 if (cu
->per_cu
->is_debug_types
)
8664 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8665 " supported in type units [in module %s]"),
8666 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
8669 per_cu
= dwarf2_find_containing_comp_unit
8670 (pdi
->d
.sect_off
, pdi
->is_dwz
,
8671 cu
->per_cu
->dwarf2_per_objfile
);
8673 /* Go read the partial unit, if needed. */
8674 if (per_cu
->v
.psymtab
== NULL
)
8675 process_psymtab_comp_unit (per_cu
, 1, cu
->language
);
8677 VEC_safe_push (dwarf2_per_cu_ptr
,
8678 cu
->per_cu
->imported_symtabs
, per_cu
);
8681 case DW_TAG_imported_declaration
:
8682 add_partial_symbol (pdi
, cu
);
8689 /* If the die has a sibling, skip to the sibling. */
8691 pdi
= pdi
->die_sibling
;
8695 /* Functions used to compute the fully scoped name of a partial DIE.
8697 Normally, this is simple. For C++, the parent DIE's fully scoped
8698 name is concatenated with "::" and the partial DIE's name.
8699 Enumerators are an exception; they use the scope of their parent
8700 enumeration type, i.e. the name of the enumeration type is not
8701 prepended to the enumerator.
8703 There are two complexities. One is DW_AT_specification; in this
8704 case "parent" means the parent of the target of the specification,
8705 instead of the direct parent of the DIE. The other is compilers
8706 which do not emit DW_TAG_namespace; in this case we try to guess
8707 the fully qualified name of structure types from their members'
8708 linkage names. This must be done using the DIE's children rather
8709 than the children of any DW_AT_specification target. We only need
8710 to do this for structures at the top level, i.e. if the target of
8711 any DW_AT_specification (if any; otherwise the DIE itself) does not
8714 /* Compute the scope prefix associated with PDI's parent, in
8715 compilation unit CU. The result will be allocated on CU's
8716 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8717 field. NULL is returned if no prefix is necessary. */
8719 partial_die_parent_scope (struct partial_die_info
*pdi
,
8720 struct dwarf2_cu
*cu
)
8722 const char *grandparent_scope
;
8723 struct partial_die_info
*parent
, *real_pdi
;
8725 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8726 then this means the parent of the specification DIE. */
8729 while (real_pdi
->has_specification
)
8731 auto res
= find_partial_die (real_pdi
->spec_offset
,
8732 real_pdi
->spec_is_dwz
, cu
);
8737 parent
= real_pdi
->die_parent
;
8741 if (parent
->scope_set
)
8742 return parent
->scope
;
8746 grandparent_scope
= partial_die_parent_scope (parent
, cu
);
8748 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8749 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8750 Work around this problem here. */
8751 if (cu
->language
== language_cplus
8752 && parent
->tag
== DW_TAG_namespace
8753 && strcmp (parent
->name
, "::") == 0
8754 && grandparent_scope
== NULL
)
8756 parent
->scope
= NULL
;
8757 parent
->scope_set
= 1;
8761 if (pdi
->tag
== DW_TAG_enumerator
)
8762 /* Enumerators should not get the name of the enumeration as a prefix. */
8763 parent
->scope
= grandparent_scope
;
8764 else if (parent
->tag
== DW_TAG_namespace
8765 || parent
->tag
== DW_TAG_module
8766 || parent
->tag
== DW_TAG_structure_type
8767 || parent
->tag
== DW_TAG_class_type
8768 || parent
->tag
== DW_TAG_interface_type
8769 || parent
->tag
== DW_TAG_union_type
8770 || parent
->tag
== DW_TAG_enumeration_type
)
8772 if (grandparent_scope
== NULL
)
8773 parent
->scope
= parent
->name
;
8775 parent
->scope
= typename_concat (&cu
->comp_unit_obstack
,
8777 parent
->name
, 0, cu
);
8781 /* FIXME drow/2004-04-01: What should we be doing with
8782 function-local names? For partial symbols, we should probably be
8784 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8785 dwarf_tag_name (parent
->tag
),
8786 sect_offset_str (pdi
->sect_off
));
8787 parent
->scope
= grandparent_scope
;
8790 parent
->scope_set
= 1;
8791 return parent
->scope
;
8794 /* Return the fully scoped name associated with PDI, from compilation unit
8795 CU. The result will be allocated with malloc. */
8798 partial_die_full_name (struct partial_die_info
*pdi
,
8799 struct dwarf2_cu
*cu
)
8801 const char *parent_scope
;
8803 /* If this is a template instantiation, we can not work out the
8804 template arguments from partial DIEs. So, unfortunately, we have
8805 to go through the full DIEs. At least any work we do building
8806 types here will be reused if full symbols are loaded later. */
8807 if (pdi
->has_template_arguments
)
8811 if (pdi
->name
!= NULL
&& strchr (pdi
->name
, '<') == NULL
)
8813 struct die_info
*die
;
8814 struct attribute attr
;
8815 struct dwarf2_cu
*ref_cu
= cu
;
8817 /* DW_FORM_ref_addr is using section offset. */
8818 attr
.name
= (enum dwarf_attribute
) 0;
8819 attr
.form
= DW_FORM_ref_addr
;
8820 attr
.u
.unsnd
= to_underlying (pdi
->sect_off
);
8821 die
= follow_die_ref (NULL
, &attr
, &ref_cu
);
8823 return xstrdup (dwarf2_full_name (NULL
, die
, ref_cu
));
8827 parent_scope
= partial_die_parent_scope (pdi
, cu
);
8828 if (parent_scope
== NULL
)
8831 return typename_concat (NULL
, parent_scope
, pdi
->name
, 0, cu
);
8835 add_partial_symbol (struct partial_die_info
*pdi
, struct dwarf2_cu
*cu
)
8837 struct dwarf2_per_objfile
*dwarf2_per_objfile
8838 = cu
->per_cu
->dwarf2_per_objfile
;
8839 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
8840 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
8842 const char *actual_name
= NULL
;
8844 char *built_actual_name
;
8846 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
8848 built_actual_name
= partial_die_full_name (pdi
, cu
);
8849 if (built_actual_name
!= NULL
)
8850 actual_name
= built_actual_name
;
8852 if (actual_name
== NULL
)
8853 actual_name
= pdi
->name
;
8857 case DW_TAG_inlined_subroutine
:
8858 case DW_TAG_subprogram
:
8859 addr
= (gdbarch_adjust_dwarf2_addr (gdbarch
, pdi
->lowpc
+ baseaddr
)
8861 if (pdi
->is_external
|| cu
->language
== language_ada
)
8863 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8864 of the global scope. But in Ada, we want to be able to access
8865 nested procedures globally. So all Ada subprograms are stored
8866 in the global scope. */
8867 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8868 built_actual_name
!= NULL
,
8869 VAR_DOMAIN
, LOC_BLOCK
,
8870 SECT_OFF_TEXT (objfile
),
8871 psymbol_placement::GLOBAL
,
8873 cu
->language
, objfile
);
8877 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8878 built_actual_name
!= NULL
,
8879 VAR_DOMAIN
, LOC_BLOCK
,
8880 SECT_OFF_TEXT (objfile
),
8881 psymbol_placement::STATIC
,
8882 addr
, cu
->language
, objfile
);
8885 if (pdi
->main_subprogram
&& actual_name
!= NULL
)
8886 set_objfile_main_name (objfile
, actual_name
, cu
->language
);
8888 case DW_TAG_constant
:
8889 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8890 built_actual_name
!= NULL
, VAR_DOMAIN
, LOC_STATIC
,
8891 -1, (pdi
->is_external
8892 ? psymbol_placement::GLOBAL
8893 : psymbol_placement::STATIC
),
8894 0, cu
->language
, objfile
);
8896 case DW_TAG_variable
:
8898 addr
= decode_locdesc (pdi
->d
.locdesc
, cu
);
8902 && !dwarf2_per_objfile
->has_section_at_zero
)
8904 /* A global or static variable may also have been stripped
8905 out by the linker if unused, in which case its address
8906 will be nullified; do not add such variables into partial
8907 symbol table then. */
8909 else if (pdi
->is_external
)
8912 Don't enter into the minimal symbol tables as there is
8913 a minimal symbol table entry from the ELF symbols already.
8914 Enter into partial symbol table if it has a location
8915 descriptor or a type.
8916 If the location descriptor is missing, new_symbol will create
8917 a LOC_UNRESOLVED symbol, the address of the variable will then
8918 be determined from the minimal symbol table whenever the variable
8920 The address for the partial symbol table entry is not
8921 used by GDB, but it comes in handy for debugging partial symbol
8924 if (pdi
->d
.locdesc
|| pdi
->has_type
)
8925 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8926 built_actual_name
!= NULL
,
8927 VAR_DOMAIN
, LOC_STATIC
,
8928 SECT_OFF_TEXT (objfile
),
8929 psymbol_placement::GLOBAL
,
8930 addr
, cu
->language
, objfile
);
8934 int has_loc
= pdi
->d
.locdesc
!= NULL
;
8936 /* Static Variable. Skip symbols whose value we cannot know (those
8937 without location descriptors or constant values). */
8938 if (!has_loc
&& !pdi
->has_const_value
)
8940 xfree (built_actual_name
);
8944 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8945 built_actual_name
!= NULL
,
8946 VAR_DOMAIN
, LOC_STATIC
,
8947 SECT_OFF_TEXT (objfile
),
8948 psymbol_placement::STATIC
,
8950 cu
->language
, objfile
);
8953 case DW_TAG_typedef
:
8954 case DW_TAG_base_type
:
8955 case DW_TAG_subrange_type
:
8956 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8957 built_actual_name
!= NULL
,
8958 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
8959 psymbol_placement::STATIC
,
8960 0, cu
->language
, objfile
);
8962 case DW_TAG_imported_declaration
:
8963 case DW_TAG_namespace
:
8964 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8965 built_actual_name
!= NULL
,
8966 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
8967 psymbol_placement::GLOBAL
,
8968 0, cu
->language
, objfile
);
8971 /* With Fortran 77 there might be a "BLOCK DATA" module
8972 available without any name. If so, we skip the module as it
8973 doesn't bring any value. */
8974 if (actual_name
!= nullptr)
8975 add_psymbol_to_list (actual_name
, strlen (actual_name
),
8976 built_actual_name
!= NULL
,
8977 MODULE_DOMAIN
, LOC_TYPEDEF
, -1,
8978 psymbol_placement::GLOBAL
,
8979 0, cu
->language
, objfile
);
8981 case DW_TAG_class_type
:
8982 case DW_TAG_interface_type
:
8983 case DW_TAG_structure_type
:
8984 case DW_TAG_union_type
:
8985 case DW_TAG_enumeration_type
:
8986 /* Skip external references. The DWARF standard says in the section
8987 about "Structure, Union, and Class Type Entries": "An incomplete
8988 structure, union or class type is represented by a structure,
8989 union or class entry that does not have a byte size attribute
8990 and that has a DW_AT_declaration attribute." */
8991 if (!pdi
->has_byte_size
&& pdi
->is_declaration
)
8993 xfree (built_actual_name
);
8997 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8998 static vs. global. */
8999 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9000 built_actual_name
!= NULL
,
9001 STRUCT_DOMAIN
, LOC_TYPEDEF
, -1,
9002 cu
->language
== language_cplus
9003 ? psymbol_placement::GLOBAL
9004 : psymbol_placement::STATIC
,
9005 0, cu
->language
, objfile
);
9008 case DW_TAG_enumerator
:
9009 add_psymbol_to_list (actual_name
, strlen (actual_name
),
9010 built_actual_name
!= NULL
,
9011 VAR_DOMAIN
, LOC_CONST
, -1,
9012 cu
->language
== language_cplus
9013 ? psymbol_placement::GLOBAL
9014 : psymbol_placement::STATIC
,
9015 0, cu
->language
, objfile
);
9021 xfree (built_actual_name
);
9024 /* Read a partial die corresponding to a namespace; also, add a symbol
9025 corresponding to that namespace to the symbol table. NAMESPACE is
9026 the name of the enclosing namespace. */
9029 add_partial_namespace (struct partial_die_info
*pdi
,
9030 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9031 int set_addrmap
, struct dwarf2_cu
*cu
)
9033 /* Add a symbol for the namespace. */
9035 add_partial_symbol (pdi
, cu
);
9037 /* Now scan partial symbols in that namespace. */
9039 if (pdi
->has_children
)
9040 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
9043 /* Read a partial die corresponding to a Fortran module. */
9046 add_partial_module (struct partial_die_info
*pdi
, CORE_ADDR
*lowpc
,
9047 CORE_ADDR
*highpc
, int set_addrmap
, struct dwarf2_cu
*cu
)
9049 /* Add a symbol for the namespace. */
9051 add_partial_symbol (pdi
, cu
);
9053 /* Now scan partial symbols in that module. */
9055 if (pdi
->has_children
)
9056 scan_partial_symbols (pdi
->die_child
, lowpc
, highpc
, set_addrmap
, cu
);
9059 /* Read a partial die corresponding to a subprogram or an inlined
9060 subprogram and create a partial symbol for that subprogram.
9061 When the CU language allows it, this routine also defines a partial
9062 symbol for each nested subprogram that this subprogram contains.
9063 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9064 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9066 PDI may also be a lexical block, in which case we simply search
9067 recursively for subprograms defined inside that lexical block.
9068 Again, this is only performed when the CU language allows this
9069 type of definitions. */
9072 add_partial_subprogram (struct partial_die_info
*pdi
,
9073 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
9074 int set_addrmap
, struct dwarf2_cu
*cu
)
9076 if (pdi
->tag
== DW_TAG_subprogram
|| pdi
->tag
== DW_TAG_inlined_subroutine
)
9078 if (pdi
->has_pc_info
)
9080 if (pdi
->lowpc
< *lowpc
)
9081 *lowpc
= pdi
->lowpc
;
9082 if (pdi
->highpc
> *highpc
)
9083 *highpc
= pdi
->highpc
;
9086 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9087 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
9089 CORE_ADDR this_highpc
;
9090 CORE_ADDR this_lowpc
;
9092 baseaddr
= ANOFFSET (objfile
->section_offsets
,
9093 SECT_OFF_TEXT (objfile
));
9095 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
9096 pdi
->lowpc
+ baseaddr
)
9099 = (gdbarch_adjust_dwarf2_addr (gdbarch
,
9100 pdi
->highpc
+ baseaddr
)
9102 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
9103 this_lowpc
, this_highpc
- 1,
9104 cu
->per_cu
->v
.psymtab
);
9108 if (pdi
->has_pc_info
|| (!pdi
->is_external
&& pdi
->may_be_inlined
))
9110 if (!pdi
->is_declaration
)
9111 /* Ignore subprogram DIEs that do not have a name, they are
9112 illegal. Do not emit a complaint at this point, we will
9113 do so when we convert this psymtab into a symtab. */
9115 add_partial_symbol (pdi
, cu
);
9119 if (! pdi
->has_children
)
9122 if (cu
->language
== language_ada
)
9124 pdi
= pdi
->die_child
;
9128 if (pdi
->tag
== DW_TAG_subprogram
9129 || pdi
->tag
== DW_TAG_inlined_subroutine
9130 || pdi
->tag
== DW_TAG_lexical_block
)
9131 add_partial_subprogram (pdi
, lowpc
, highpc
, set_addrmap
, cu
);
9132 pdi
= pdi
->die_sibling
;
9137 /* Read a partial die corresponding to an enumeration type. */
9140 add_partial_enumeration (struct partial_die_info
*enum_pdi
,
9141 struct dwarf2_cu
*cu
)
9143 struct partial_die_info
*pdi
;
9145 if (enum_pdi
->name
!= NULL
)
9146 add_partial_symbol (enum_pdi
, cu
);
9148 pdi
= enum_pdi
->die_child
;
9151 if (pdi
->tag
!= DW_TAG_enumerator
|| pdi
->name
== NULL
)
9152 complaint (_("malformed enumerator DIE ignored"));
9154 add_partial_symbol (pdi
, cu
);
9155 pdi
= pdi
->die_sibling
;
9159 /* Return the initial uleb128 in the die at INFO_PTR. */
9162 peek_abbrev_code (bfd
*abfd
, const gdb_byte
*info_ptr
)
9164 unsigned int bytes_read
;
9166 return read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9169 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9170 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
9172 Return the corresponding abbrev, or NULL if the number is zero (indicating
9173 an empty DIE). In either case *BYTES_READ will be set to the length of
9174 the initial number. */
9176 static struct abbrev_info
*
9177 peek_die_abbrev (const die_reader_specs
&reader
,
9178 const gdb_byte
*info_ptr
, unsigned int *bytes_read
)
9180 dwarf2_cu
*cu
= reader
.cu
;
9181 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
9182 unsigned int abbrev_number
9183 = read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
9185 if (abbrev_number
== 0)
9188 abbrev_info
*abbrev
= reader
.abbrev_table
->lookup_abbrev (abbrev_number
);
9191 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9192 " at offset %s [in module %s]"),
9193 abbrev_number
, cu
->per_cu
->is_debug_types
? "TU" : "CU",
9194 sect_offset_str (cu
->header
.sect_off
), bfd_get_filename (abfd
));
9200 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9201 Returns a pointer to the end of a series of DIEs, terminated by an empty
9202 DIE. Any children of the skipped DIEs will also be skipped. */
9204 static const gdb_byte
*
9205 skip_children (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
)
9209 unsigned int bytes_read
;
9210 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
9213 return info_ptr
+ bytes_read
;
9215 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
9219 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9220 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9221 abbrev corresponding to that skipped uleb128 should be passed in
9222 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9225 static const gdb_byte
*
9226 skip_one_die (const struct die_reader_specs
*reader
, const gdb_byte
*info_ptr
,
9227 struct abbrev_info
*abbrev
)
9229 unsigned int bytes_read
;
9230 struct attribute attr
;
9231 bfd
*abfd
= reader
->abfd
;
9232 struct dwarf2_cu
*cu
= reader
->cu
;
9233 const gdb_byte
*buffer
= reader
->buffer
;
9234 const gdb_byte
*buffer_end
= reader
->buffer_end
;
9235 unsigned int form
, i
;
9237 for (i
= 0; i
< abbrev
->num_attrs
; i
++)
9239 /* The only abbrev we care about is DW_AT_sibling. */
9240 if (abbrev
->attrs
[i
].name
== DW_AT_sibling
)
9242 read_attribute (reader
, &attr
, &abbrev
->attrs
[i
], info_ptr
);
9243 if (attr
.form
== DW_FORM_ref_addr
)
9244 complaint (_("ignoring absolute DW_AT_sibling"));
9247 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
9248 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
9250 if (sibling_ptr
< info_ptr
)
9251 complaint (_("DW_AT_sibling points backwards"));
9252 else if (sibling_ptr
> reader
->buffer_end
)
9253 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
9259 /* If it isn't DW_AT_sibling, skip this attribute. */
9260 form
= abbrev
->attrs
[i
].form
;
9264 case DW_FORM_ref_addr
:
9265 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9266 and later it is offset sized. */
9267 if (cu
->header
.version
== 2)
9268 info_ptr
+= cu
->header
.addr_size
;
9270 info_ptr
+= cu
->header
.offset_size
;
9272 case DW_FORM_GNU_ref_alt
:
9273 info_ptr
+= cu
->header
.offset_size
;
9276 info_ptr
+= cu
->header
.addr_size
;
9283 case DW_FORM_flag_present
:
9284 case DW_FORM_implicit_const
:
9296 case DW_FORM_ref_sig8
:
9299 case DW_FORM_data16
:
9302 case DW_FORM_string
:
9303 read_direct_string (abfd
, info_ptr
, &bytes_read
);
9304 info_ptr
+= bytes_read
;
9306 case DW_FORM_sec_offset
:
9308 case DW_FORM_GNU_strp_alt
:
9309 info_ptr
+= cu
->header
.offset_size
;
9311 case DW_FORM_exprloc
:
9313 info_ptr
+= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9314 info_ptr
+= bytes_read
;
9316 case DW_FORM_block1
:
9317 info_ptr
+= 1 + read_1_byte (abfd
, info_ptr
);
9319 case DW_FORM_block2
:
9320 info_ptr
+= 2 + read_2_bytes (abfd
, info_ptr
);
9322 case DW_FORM_block4
:
9323 info_ptr
+= 4 + read_4_bytes (abfd
, info_ptr
);
9329 case DW_FORM_ref_udata
:
9330 case DW_FORM_GNU_addr_index
:
9331 case DW_FORM_GNU_str_index
:
9332 info_ptr
= safe_skip_leb128 (info_ptr
, buffer_end
);
9334 case DW_FORM_indirect
:
9335 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
9336 info_ptr
+= bytes_read
;
9337 /* We need to continue parsing from here, so just go back to
9339 goto skip_attribute
;
9342 error (_("Dwarf Error: Cannot handle %s "
9343 "in DWARF reader [in module %s]"),
9344 dwarf_form_name (form
),
9345 bfd_get_filename (abfd
));
9349 if (abbrev
->has_children
)
9350 return skip_children (reader
, info_ptr
);
9355 /* Locate ORIG_PDI's sibling.
9356 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9358 static const gdb_byte
*
9359 locate_pdi_sibling (const struct die_reader_specs
*reader
,
9360 struct partial_die_info
*orig_pdi
,
9361 const gdb_byte
*info_ptr
)
9363 /* Do we know the sibling already? */
9365 if (orig_pdi
->sibling
)
9366 return orig_pdi
->sibling
;
9368 /* Are there any children to deal with? */
9370 if (!orig_pdi
->has_children
)
9373 /* Skip the children the long way. */
9375 return skip_children (reader
, info_ptr
);
9378 /* Expand this partial symbol table into a full symbol table. SELF is
9382 dwarf2_read_symtab (struct partial_symtab
*self
,
9383 struct objfile
*objfile
)
9385 struct dwarf2_per_objfile
*dwarf2_per_objfile
9386 = get_dwarf2_per_objfile (objfile
);
9390 warning (_("bug: psymtab for %s is already read in."),
9397 printf_filtered (_("Reading in symbols for %s..."),
9399 gdb_flush (gdb_stdout
);
9402 /* If this psymtab is constructed from a debug-only objfile, the
9403 has_section_at_zero flag will not necessarily be correct. We
9404 can get the correct value for this flag by looking at the data
9405 associated with the (presumably stripped) associated objfile. */
9406 if (objfile
->separate_debug_objfile_backlink
)
9408 struct dwarf2_per_objfile
*dpo_backlink
9409 = get_dwarf2_per_objfile (objfile
->separate_debug_objfile_backlink
);
9411 dwarf2_per_objfile
->has_section_at_zero
9412 = dpo_backlink
->has_section_at_zero
;
9415 dwarf2_per_objfile
->reading_partial_symbols
= 0;
9417 psymtab_to_symtab_1 (self
);
9419 /* Finish up the debug error message. */
9421 printf_filtered (_("done.\n"));
9424 process_cu_includes (dwarf2_per_objfile
);
9427 /* Reading in full CUs. */
9429 /* Add PER_CU to the queue. */
9432 queue_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
9433 enum language pretend_language
)
9435 struct dwarf2_queue_item
*item
;
9438 item
= XNEW (struct dwarf2_queue_item
);
9439 item
->per_cu
= per_cu
;
9440 item
->pretend_language
= pretend_language
;
9443 if (dwarf2_queue
== NULL
)
9444 dwarf2_queue
= item
;
9446 dwarf2_queue_tail
->next
= item
;
9448 dwarf2_queue_tail
= item
;
9451 /* If PER_CU is not yet queued, add it to the queue.
9452 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9454 The result is non-zero if PER_CU was queued, otherwise the result is zero
9455 meaning either PER_CU is already queued or it is already loaded.
9457 N.B. There is an invariant here that if a CU is queued then it is loaded.
9458 The caller is required to load PER_CU if we return non-zero. */
9461 maybe_queue_comp_unit (struct dwarf2_cu
*dependent_cu
,
9462 struct dwarf2_per_cu_data
*per_cu
,
9463 enum language pretend_language
)
9465 /* We may arrive here during partial symbol reading, if we need full
9466 DIEs to process an unusual case (e.g. template arguments). Do
9467 not queue PER_CU, just tell our caller to load its DIEs. */
9468 if (per_cu
->dwarf2_per_objfile
->reading_partial_symbols
)
9470 if (per_cu
->cu
== NULL
|| per_cu
->cu
->dies
== NULL
)
9475 /* Mark the dependence relation so that we don't flush PER_CU
9477 if (dependent_cu
!= NULL
)
9478 dwarf2_add_dependence (dependent_cu
, per_cu
);
9480 /* If it's already on the queue, we have nothing to do. */
9484 /* If the compilation unit is already loaded, just mark it as
9486 if (per_cu
->cu
!= NULL
)
9488 per_cu
->cu
->last_used
= 0;
9492 /* Add it to the queue. */
9493 queue_comp_unit (per_cu
, pretend_language
);
9498 /* Process the queue. */
9501 process_queue (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
9503 struct dwarf2_queue_item
*item
, *next_item
;
9505 if (dwarf_read_debug
)
9507 fprintf_unfiltered (gdb_stdlog
,
9508 "Expanding one or more symtabs of objfile %s ...\n",
9509 objfile_name (dwarf2_per_objfile
->objfile
));
9512 /* The queue starts out with one item, but following a DIE reference
9513 may load a new CU, adding it to the end of the queue. */
9514 for (item
= dwarf2_queue
; item
!= NULL
; dwarf2_queue
= item
= next_item
)
9516 if ((dwarf2_per_objfile
->using_index
9517 ? !item
->per_cu
->v
.quick
->compunit_symtab
9518 : (item
->per_cu
->v
.psymtab
&& !item
->per_cu
->v
.psymtab
->readin
))
9519 /* Skip dummy CUs. */
9520 && item
->per_cu
->cu
!= NULL
)
9522 struct dwarf2_per_cu_data
*per_cu
= item
->per_cu
;
9523 unsigned int debug_print_threshold
;
9526 if (per_cu
->is_debug_types
)
9528 struct signatured_type
*sig_type
=
9529 (struct signatured_type
*) per_cu
;
9531 sprintf (buf
, "TU %s at offset %s",
9532 hex_string (sig_type
->signature
),
9533 sect_offset_str (per_cu
->sect_off
));
9534 /* There can be 100s of TUs.
9535 Only print them in verbose mode. */
9536 debug_print_threshold
= 2;
9540 sprintf (buf
, "CU at offset %s",
9541 sect_offset_str (per_cu
->sect_off
));
9542 debug_print_threshold
= 1;
9545 if (dwarf_read_debug
>= debug_print_threshold
)
9546 fprintf_unfiltered (gdb_stdlog
, "Expanding symtab of %s\n", buf
);
9548 if (per_cu
->is_debug_types
)
9549 process_full_type_unit (per_cu
, item
->pretend_language
);
9551 process_full_comp_unit (per_cu
, item
->pretend_language
);
9553 if (dwarf_read_debug
>= debug_print_threshold
)
9554 fprintf_unfiltered (gdb_stdlog
, "Done expanding %s\n", buf
);
9557 item
->per_cu
->queued
= 0;
9558 next_item
= item
->next
;
9562 dwarf2_queue_tail
= NULL
;
9564 if (dwarf_read_debug
)
9566 fprintf_unfiltered (gdb_stdlog
, "Done expanding symtabs of %s.\n",
9567 objfile_name (dwarf2_per_objfile
->objfile
));
9571 /* Read in full symbols for PST, and anything it depends on. */
9574 psymtab_to_symtab_1 (struct partial_symtab
*pst
)
9576 struct dwarf2_per_cu_data
*per_cu
;
9582 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
9583 if (!pst
->dependencies
[i
]->readin
9584 && pst
->dependencies
[i
]->user
== NULL
)
9586 /* Inform about additional files that need to be read in. */
9589 /* FIXME: i18n: Need to make this a single string. */
9590 fputs_filtered (" ", gdb_stdout
);
9592 fputs_filtered ("and ", gdb_stdout
);
9594 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
9595 wrap_here (""); /* Flush output. */
9596 gdb_flush (gdb_stdout
);
9598 psymtab_to_symtab_1 (pst
->dependencies
[i
]);
9601 per_cu
= (struct dwarf2_per_cu_data
*) pst
->read_symtab_private
;
9605 /* It's an include file, no symbols to read for it.
9606 Everything is in the parent symtab. */
9611 dw2_do_instantiate_symtab (per_cu
, false);
9614 /* Trivial hash function for die_info: the hash value of a DIE
9615 is its offset in .debug_info for this objfile. */
9618 die_hash (const void *item
)
9620 const struct die_info
*die
= (const struct die_info
*) item
;
9622 return to_underlying (die
->sect_off
);
9625 /* Trivial comparison function for die_info structures: two DIEs
9626 are equal if they have the same offset. */
9629 die_eq (const void *item_lhs
, const void *item_rhs
)
9631 const struct die_info
*die_lhs
= (const struct die_info
*) item_lhs
;
9632 const struct die_info
*die_rhs
= (const struct die_info
*) item_rhs
;
9634 return die_lhs
->sect_off
== die_rhs
->sect_off
;
9637 /* die_reader_func for load_full_comp_unit.
9638 This is identical to read_signatured_type_reader,
9639 but is kept separate for now. */
9642 load_full_comp_unit_reader (const struct die_reader_specs
*reader
,
9643 const gdb_byte
*info_ptr
,
9644 struct die_info
*comp_unit_die
,
9648 struct dwarf2_cu
*cu
= reader
->cu
;
9649 enum language
*language_ptr
= (enum language
*) data
;
9651 gdb_assert (cu
->die_hash
== NULL
);
9653 htab_create_alloc_ex (cu
->header
.length
/ 12,
9657 &cu
->comp_unit_obstack
,
9658 hashtab_obstack_allocate
,
9659 dummy_obstack_deallocate
);
9662 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
9663 &info_ptr
, comp_unit_die
);
9664 cu
->dies
= comp_unit_die
;
9665 /* comp_unit_die is not stored in die_hash, no need. */
9667 /* We try not to read any attributes in this function, because not
9668 all CUs needed for references have been loaded yet, and symbol
9669 table processing isn't initialized. But we have to set the CU language,
9670 or we won't be able to build types correctly.
9671 Similarly, if we do not read the producer, we can not apply
9672 producer-specific interpretation. */
9673 prepare_one_comp_unit (cu
, cu
->dies
, *language_ptr
);
9676 /* Load the DIEs associated with PER_CU into memory. */
9679 load_full_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
9681 enum language pretend_language
)
9683 gdb_assert (! this_cu
->is_debug_types
);
9685 init_cutu_and_read_dies (this_cu
, NULL
, 1, 1, skip_partial
,
9686 load_full_comp_unit_reader
, &pretend_language
);
9689 /* Add a DIE to the delayed physname list. */
9692 add_to_method_list (struct type
*type
, int fnfield_index
, int index
,
9693 const char *name
, struct die_info
*die
,
9694 struct dwarf2_cu
*cu
)
9696 struct delayed_method_info mi
;
9698 mi
.fnfield_index
= fnfield_index
;
9702 cu
->method_list
.push_back (mi
);
9705 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9706 "const" / "volatile". If so, decrements LEN by the length of the
9707 modifier and return true. Otherwise return false. */
9711 check_modifier (const char *physname
, size_t &len
, const char (&mod
)[N
])
9713 size_t mod_len
= sizeof (mod
) - 1;
9714 if (len
> mod_len
&& startswith (physname
+ (len
- mod_len
), mod
))
9722 /* Compute the physnames of any methods on the CU's method list.
9724 The computation of method physnames is delayed in order to avoid the
9725 (bad) condition that one of the method's formal parameters is of an as yet
9729 compute_delayed_physnames (struct dwarf2_cu
*cu
)
9731 /* Only C++ delays computing physnames. */
9732 if (cu
->method_list
.empty ())
9734 gdb_assert (cu
->language
== language_cplus
);
9736 for (const delayed_method_info
&mi
: cu
->method_list
)
9738 const char *physname
;
9739 struct fn_fieldlist
*fn_flp
9740 = &TYPE_FN_FIELDLIST (mi
.type
, mi
.fnfield_index
);
9741 physname
= dwarf2_physname (mi
.name
, mi
.die
, cu
);
9742 TYPE_FN_FIELD_PHYSNAME (fn_flp
->fn_fields
, mi
.index
)
9743 = physname
? physname
: "";
9745 /* Since there's no tag to indicate whether a method is a
9746 const/volatile overload, extract that information out of the
9748 if (physname
!= NULL
)
9750 size_t len
= strlen (physname
);
9754 if (physname
[len
] == ')') /* shortcut */
9756 else if (check_modifier (physname
, len
, " const"))
9757 TYPE_FN_FIELD_CONST (fn_flp
->fn_fields
, mi
.index
) = 1;
9758 else if (check_modifier (physname
, len
, " volatile"))
9759 TYPE_FN_FIELD_VOLATILE (fn_flp
->fn_fields
, mi
.index
) = 1;
9766 /* The list is no longer needed. */
9767 cu
->method_list
.clear ();
9770 /* Go objects should be embedded in a DW_TAG_module DIE,
9771 and it's not clear if/how imported objects will appear.
9772 To keep Go support simple until that's worked out,
9773 go back through what we've read and create something usable.
9774 We could do this while processing each DIE, and feels kinda cleaner,
9775 but that way is more invasive.
9776 This is to, for example, allow the user to type "p var" or "b main"
9777 without having to specify the package name, and allow lookups
9778 of module.object to work in contexts that use the expression
9782 fixup_go_packaging (struct dwarf2_cu
*cu
)
9784 char *package_name
= NULL
;
9785 struct pending
*list
;
9788 for (list
= *cu
->get_builder ()->get_global_symbols ();
9792 for (i
= 0; i
< list
->nsyms
; ++i
)
9794 struct symbol
*sym
= list
->symbol
[i
];
9796 if (SYMBOL_LANGUAGE (sym
) == language_go
9797 && SYMBOL_CLASS (sym
) == LOC_BLOCK
)
9799 char *this_package_name
= go_symbol_package_name (sym
);
9801 if (this_package_name
== NULL
)
9803 if (package_name
== NULL
)
9804 package_name
= this_package_name
;
9807 struct objfile
*objfile
9808 = cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9809 if (strcmp (package_name
, this_package_name
) != 0)
9810 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9811 (symbol_symtab (sym
) != NULL
9812 ? symtab_to_filename_for_display
9813 (symbol_symtab (sym
))
9814 : objfile_name (objfile
)),
9815 this_package_name
, package_name
);
9816 xfree (this_package_name
);
9822 if (package_name
!= NULL
)
9824 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
9825 const char *saved_package_name
9826 = (const char *) obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
9828 strlen (package_name
));
9829 struct type
*type
= init_type (objfile
, TYPE_CODE_MODULE
, 0,
9830 saved_package_name
);
9833 sym
= allocate_symbol (objfile
);
9834 SYMBOL_SET_LANGUAGE (sym
, language_go
, &objfile
->objfile_obstack
);
9835 SYMBOL_SET_NAMES (sym
, saved_package_name
,
9836 strlen (saved_package_name
), 0, objfile
);
9837 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9838 e.g., "main" finds the "main" module and not C's main(). */
9839 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
9840 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
9841 SYMBOL_TYPE (sym
) = type
;
9843 add_symbol_to_list (sym
, cu
->get_builder ()->get_global_symbols ());
9845 xfree (package_name
);
9849 /* Allocate a fully-qualified name consisting of the two parts on the
9853 rust_fully_qualify (struct obstack
*obstack
, const char *p1
, const char *p2
)
9855 return obconcat (obstack
, p1
, "::", p2
, (char *) NULL
);
9858 /* A helper that allocates a struct discriminant_info to attach to a
9861 static struct discriminant_info
*
9862 alloc_discriminant_info (struct type
*type
, int discriminant_index
,
9865 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
9866 gdb_assert (discriminant_index
== -1
9867 || (discriminant_index
>= 0
9868 && discriminant_index
< TYPE_NFIELDS (type
)));
9869 gdb_assert (default_index
== -1
9870 || (default_index
>= 0 && default_index
< TYPE_NFIELDS (type
)));
9872 TYPE_FLAG_DISCRIMINATED_UNION (type
) = 1;
9874 struct discriminant_info
*disc
9875 = ((struct discriminant_info
*)
9877 offsetof (struct discriminant_info
, discriminants
)
9878 + TYPE_NFIELDS (type
) * sizeof (disc
->discriminants
[0])));
9879 disc
->default_index
= default_index
;
9880 disc
->discriminant_index
= discriminant_index
;
9882 struct dynamic_prop prop
;
9883 prop
.kind
= PROP_UNDEFINED
;
9884 prop
.data
.baton
= disc
;
9886 add_dyn_prop (DYN_PROP_DISCRIMINATED
, prop
, type
);
9891 /* Some versions of rustc emitted enums in an unusual way.
9893 Ordinary enums were emitted as unions. The first element of each
9894 structure in the union was named "RUST$ENUM$DISR". This element
9895 held the discriminant.
9897 These versions of Rust also implemented the "non-zero"
9898 optimization. When the enum had two values, and one is empty and
9899 the other holds a pointer that cannot be zero, the pointer is used
9900 as the discriminant, with a zero value meaning the empty variant.
9901 Here, the union's first member is of the form
9902 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9903 where the fieldnos are the indices of the fields that should be
9904 traversed in order to find the field (which may be several fields deep)
9905 and the variantname is the name of the variant of the case when the
9908 This function recognizes whether TYPE is of one of these forms,
9909 and, if so, smashes it to be a variant type. */
9912 quirk_rust_enum (struct type
*type
, struct objfile
*objfile
)
9914 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_UNION
);
9916 /* We don't need to deal with empty enums. */
9917 if (TYPE_NFIELDS (type
) == 0)
9920 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9921 if (TYPE_NFIELDS (type
) == 1
9922 && startswith (TYPE_FIELD_NAME (type
, 0), RUST_ENUM_PREFIX
))
9924 const char *name
= TYPE_FIELD_NAME (type
, 0) + strlen (RUST_ENUM_PREFIX
);
9926 /* Decode the field name to find the offset of the
9928 ULONGEST bit_offset
= 0;
9929 struct type
*field_type
= TYPE_FIELD_TYPE (type
, 0);
9930 while (name
[0] >= '0' && name
[0] <= '9')
9933 unsigned long index
= strtoul (name
, &tail
, 10);
9936 || index
>= TYPE_NFIELDS (field_type
)
9937 || (TYPE_FIELD_LOC_KIND (field_type
, index
)
9938 != FIELD_LOC_KIND_BITPOS
))
9940 complaint (_("Could not parse Rust enum encoding string \"%s\""
9942 TYPE_FIELD_NAME (type
, 0),
9943 objfile_name (objfile
));
9948 bit_offset
+= TYPE_FIELD_BITPOS (field_type
, index
);
9949 field_type
= TYPE_FIELD_TYPE (field_type
, index
);
9952 /* Make a union to hold the variants. */
9953 struct type
*union_type
= alloc_type (objfile
);
9954 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
9955 TYPE_NFIELDS (union_type
) = 3;
9956 TYPE_FIELDS (union_type
)
9957 = (struct field
*) TYPE_ZALLOC (type
, 3 * sizeof (struct field
));
9958 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
9959 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
9961 /* Put the discriminant must at index 0. */
9962 TYPE_FIELD_TYPE (union_type
, 0) = field_type
;
9963 TYPE_FIELD_ARTIFICIAL (union_type
, 0) = 1;
9964 TYPE_FIELD_NAME (union_type
, 0) = "<<discriminant>>";
9965 SET_FIELD_BITPOS (TYPE_FIELD (union_type
, 0), bit_offset
);
9967 /* The order of fields doesn't really matter, so put the real
9968 field at index 1 and the data-less field at index 2. */
9969 struct discriminant_info
*disc
9970 = alloc_discriminant_info (union_type
, 0, 1);
9971 TYPE_FIELD (union_type
, 1) = TYPE_FIELD (type
, 0);
9972 TYPE_FIELD_NAME (union_type
, 1)
9973 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type
, 1)));
9974 TYPE_NAME (TYPE_FIELD_TYPE (union_type
, 1))
9975 = rust_fully_qualify (&objfile
->objfile_obstack
, TYPE_NAME (type
),
9976 TYPE_FIELD_NAME (union_type
, 1));
9978 const char *dataless_name
9979 = rust_fully_qualify (&objfile
->objfile_obstack
, TYPE_NAME (type
),
9981 struct type
*dataless_type
= init_type (objfile
, TYPE_CODE_VOID
, 0,
9983 TYPE_FIELD_TYPE (union_type
, 2) = dataless_type
;
9984 /* NAME points into the original discriminant name, which
9985 already has the correct lifetime. */
9986 TYPE_FIELD_NAME (union_type
, 2) = name
;
9987 SET_FIELD_BITPOS (TYPE_FIELD (union_type
, 2), 0);
9988 disc
->discriminants
[2] = 0;
9990 /* Smash this type to be a structure type. We have to do this
9991 because the type has already been recorded. */
9992 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
9993 TYPE_NFIELDS (type
) = 1;
9995 = (struct field
*) TYPE_ZALLOC (type
, sizeof (struct field
));
9997 /* Install the variant part. */
9998 TYPE_FIELD_TYPE (type
, 0) = union_type
;
9999 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10000 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10002 else if (TYPE_NFIELDS (type
) == 1)
10004 /* We assume that a union with a single field is a univariant
10006 /* Smash this type to be a structure type. We have to do this
10007 because the type has already been recorded. */
10008 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10010 /* Make a union to hold the variants. */
10011 struct type
*union_type
= alloc_type (objfile
);
10012 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
10013 TYPE_NFIELDS (union_type
) = TYPE_NFIELDS (type
);
10014 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
10015 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
10016 TYPE_FIELDS (union_type
) = TYPE_FIELDS (type
);
10018 struct type
*field_type
= TYPE_FIELD_TYPE (union_type
, 0);
10019 const char *variant_name
10020 = rust_last_path_segment (TYPE_NAME (field_type
));
10021 TYPE_FIELD_NAME (union_type
, 0) = variant_name
;
10022 TYPE_NAME (field_type
)
10023 = rust_fully_qualify (&objfile
->objfile_obstack
,
10024 TYPE_NAME (type
), variant_name
);
10026 /* Install the union in the outer struct type. */
10027 TYPE_NFIELDS (type
) = 1;
10029 = (struct field
*) TYPE_ZALLOC (union_type
, sizeof (struct field
));
10030 TYPE_FIELD_TYPE (type
, 0) = union_type
;
10031 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10032 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10034 alloc_discriminant_info (union_type
, -1, 0);
10038 struct type
*disr_type
= nullptr;
10039 for (int i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
10041 disr_type
= TYPE_FIELD_TYPE (type
, i
);
10043 if (TYPE_CODE (disr_type
) != TYPE_CODE_STRUCT
)
10045 /* All fields of a true enum will be structs. */
10048 else if (TYPE_NFIELDS (disr_type
) == 0)
10050 /* Could be data-less variant, so keep going. */
10051 disr_type
= nullptr;
10053 else if (strcmp (TYPE_FIELD_NAME (disr_type
, 0),
10054 "RUST$ENUM$DISR") != 0)
10056 /* Not a Rust enum. */
10066 /* If we got here without a discriminant, then it's probably
10068 if (disr_type
== nullptr)
10071 /* Smash this type to be a structure type. We have to do this
10072 because the type has already been recorded. */
10073 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
10075 /* Make a union to hold the variants. */
10076 struct field
*disr_field
= &TYPE_FIELD (disr_type
, 0);
10077 struct type
*union_type
= alloc_type (objfile
);
10078 TYPE_CODE (union_type
) = TYPE_CODE_UNION
;
10079 TYPE_NFIELDS (union_type
) = 1 + TYPE_NFIELDS (type
);
10080 TYPE_LENGTH (union_type
) = TYPE_LENGTH (type
);
10081 set_type_align (union_type
, TYPE_RAW_ALIGN (type
));
10082 TYPE_FIELDS (union_type
)
10083 = (struct field
*) TYPE_ZALLOC (union_type
,
10084 (TYPE_NFIELDS (union_type
)
10085 * sizeof (struct field
)));
10087 memcpy (TYPE_FIELDS (union_type
) + 1, TYPE_FIELDS (type
),
10088 TYPE_NFIELDS (type
) * sizeof (struct field
));
10090 /* Install the discriminant at index 0 in the union. */
10091 TYPE_FIELD (union_type
, 0) = *disr_field
;
10092 TYPE_FIELD_ARTIFICIAL (union_type
, 0) = 1;
10093 TYPE_FIELD_NAME (union_type
, 0) = "<<discriminant>>";
10095 /* Install the union in the outer struct type. */
10096 TYPE_FIELD_TYPE (type
, 0) = union_type
;
10097 TYPE_FIELD_NAME (type
, 0) = "<<variants>>";
10098 TYPE_NFIELDS (type
) = 1;
10100 /* Set the size and offset of the union type. */
10101 SET_FIELD_BITPOS (TYPE_FIELD (type
, 0), 0);
10103 /* We need a way to find the correct discriminant given a
10104 variant name. For convenience we build a map here. */
10105 struct type
*enum_type
= FIELD_TYPE (*disr_field
);
10106 std::unordered_map
<std::string
, ULONGEST
> discriminant_map
;
10107 for (int i
= 0; i
< TYPE_NFIELDS (enum_type
); ++i
)
10109 if (TYPE_FIELD_LOC_KIND (enum_type
, i
) == FIELD_LOC_KIND_ENUMVAL
)
10112 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type
, i
));
10113 discriminant_map
[name
] = TYPE_FIELD_ENUMVAL (enum_type
, i
);
10117 int n_fields
= TYPE_NFIELDS (union_type
);
10118 struct discriminant_info
*disc
10119 = alloc_discriminant_info (union_type
, 0, -1);
10120 /* Skip the discriminant here. */
10121 for (int i
= 1; i
< n_fields
; ++i
)
10123 /* Find the final word in the name of this variant's type.
10124 That name can be used to look up the correct
10126 const char *variant_name
10127 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type
,
10130 auto iter
= discriminant_map
.find (variant_name
);
10131 if (iter
!= discriminant_map
.end ())
10132 disc
->discriminants
[i
] = iter
->second
;
10134 /* Remove the discriminant field, if it exists. */
10135 struct type
*sub_type
= TYPE_FIELD_TYPE (union_type
, i
);
10136 if (TYPE_NFIELDS (sub_type
) > 0)
10138 --TYPE_NFIELDS (sub_type
);
10139 ++TYPE_FIELDS (sub_type
);
10141 TYPE_FIELD_NAME (union_type
, i
) = variant_name
;
10142 TYPE_NAME (sub_type
)
10143 = rust_fully_qualify (&objfile
->objfile_obstack
,
10144 TYPE_NAME (type
), variant_name
);
10149 /* Rewrite some Rust unions to be structures with variants parts. */
10152 rust_union_quirks (struct dwarf2_cu
*cu
)
10154 gdb_assert (cu
->language
== language_rust
);
10155 for (type
*type_
: cu
->rust_unions
)
10156 quirk_rust_enum (type_
, cu
->per_cu
->dwarf2_per_objfile
->objfile
);
10157 /* We don't need this any more. */
10158 cu
->rust_unions
.clear ();
10161 /* Return the symtab for PER_CU. This works properly regardless of
10162 whether we're using the index or psymtabs. */
10164 static struct compunit_symtab
*
10165 get_compunit_symtab (struct dwarf2_per_cu_data
*per_cu
)
10167 return (per_cu
->dwarf2_per_objfile
->using_index
10168 ? per_cu
->v
.quick
->compunit_symtab
10169 : per_cu
->v
.psymtab
->compunit_symtab
);
10172 /* A helper function for computing the list of all symbol tables
10173 included by PER_CU. */
10176 recursively_compute_inclusions (std::vector
<compunit_symtab
*> *result
,
10177 htab_t all_children
, htab_t all_type_symtabs
,
10178 struct dwarf2_per_cu_data
*per_cu
,
10179 struct compunit_symtab
*immediate_parent
)
10183 struct compunit_symtab
*cust
;
10184 struct dwarf2_per_cu_data
*iter
;
10186 slot
= htab_find_slot (all_children
, per_cu
, INSERT
);
10189 /* This inclusion and its children have been processed. */
10194 /* Only add a CU if it has a symbol table. */
10195 cust
= get_compunit_symtab (per_cu
);
10198 /* If this is a type unit only add its symbol table if we haven't
10199 seen it yet (type unit per_cu's can share symtabs). */
10200 if (per_cu
->is_debug_types
)
10202 slot
= htab_find_slot (all_type_symtabs
, cust
, INSERT
);
10206 result
->push_back (cust
);
10207 if (cust
->user
== NULL
)
10208 cust
->user
= immediate_parent
;
10213 result
->push_back (cust
);
10214 if (cust
->user
== NULL
)
10215 cust
->user
= immediate_parent
;
10220 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, ix
, iter
);
10223 recursively_compute_inclusions (result
, all_children
,
10224 all_type_symtabs
, iter
, cust
);
10228 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10232 compute_compunit_symtab_includes (struct dwarf2_per_cu_data
*per_cu
)
10234 gdb_assert (! per_cu
->is_debug_types
);
10236 if (!VEC_empty (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
))
10239 struct dwarf2_per_cu_data
*per_cu_iter
;
10240 std::vector
<compunit_symtab
*> result_symtabs
;
10241 htab_t all_children
, all_type_symtabs
;
10242 struct compunit_symtab
*cust
= get_compunit_symtab (per_cu
);
10244 /* If we don't have a symtab, we can just skip this case. */
10248 all_children
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
10249 NULL
, xcalloc
, xfree
);
10250 all_type_symtabs
= htab_create_alloc (1, htab_hash_pointer
, htab_eq_pointer
,
10251 NULL
, xcalloc
, xfree
);
10254 VEC_iterate (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
,
10258 recursively_compute_inclusions (&result_symtabs
, all_children
,
10259 all_type_symtabs
, per_cu_iter
,
10263 /* Now we have a transitive closure of all the included symtabs. */
10264 len
= result_symtabs
.size ();
10266 = XOBNEWVEC (&per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
,
10267 struct compunit_symtab
*, len
+ 1);
10268 memcpy (cust
->includes
, result_symtabs
.data (),
10269 len
* sizeof (compunit_symtab
*));
10270 cust
->includes
[len
] = NULL
;
10272 htab_delete (all_children
);
10273 htab_delete (all_type_symtabs
);
10277 /* Compute the 'includes' field for the symtabs of all the CUs we just
10281 process_cu_includes (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
10283 for (dwarf2_per_cu_data
*iter
: dwarf2_per_objfile
->just_read_cus
)
10285 if (! iter
->is_debug_types
)
10286 compute_compunit_symtab_includes (iter
);
10289 dwarf2_per_objfile
->just_read_cus
.clear ();
10292 /* Generate full symbol information for PER_CU, whose DIEs have
10293 already been loaded into memory. */
10296 process_full_comp_unit (struct dwarf2_per_cu_data
*per_cu
,
10297 enum language pretend_language
)
10299 struct dwarf2_cu
*cu
= per_cu
->cu
;
10300 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
10301 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10302 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
10303 CORE_ADDR lowpc
, highpc
;
10304 struct compunit_symtab
*cust
;
10305 CORE_ADDR baseaddr
;
10306 struct block
*static_block
;
10309 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
10311 /* Clear the list here in case something was left over. */
10312 cu
->method_list
.clear ();
10314 cu
->language
= pretend_language
;
10315 cu
->language_defn
= language_def (cu
->language
);
10317 /* Do line number decoding in read_file_scope () */
10318 process_die (cu
->dies
, cu
);
10320 /* For now fudge the Go package. */
10321 if (cu
->language
== language_go
)
10322 fixup_go_packaging (cu
);
10324 /* Now that we have processed all the DIEs in the CU, all the types
10325 should be complete, and it should now be safe to compute all of the
10327 compute_delayed_physnames (cu
);
10329 if (cu
->language
== language_rust
)
10330 rust_union_quirks (cu
);
10332 /* Some compilers don't define a DW_AT_high_pc attribute for the
10333 compilation unit. If the DW_AT_high_pc is missing, synthesize
10334 it, by scanning the DIE's below the compilation unit. */
10335 get_scope_pc_bounds (cu
->dies
, &lowpc
, &highpc
, cu
);
10337 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
10338 static_block
= cu
->get_builder ()->end_symtab_get_static_block (addr
, 0, 1);
10340 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10341 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10342 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10343 addrmap to help ensure it has an accurate map of pc values belonging to
10345 dwarf2_record_block_ranges (cu
->dies
, static_block
, baseaddr
, cu
);
10347 cust
= cu
->get_builder ()->end_symtab_from_static_block (static_block
,
10348 SECT_OFF_TEXT (objfile
),
10353 int gcc_4_minor
= producer_is_gcc_ge_4 (cu
->producer
);
10355 /* Set symtab language to language from DW_AT_language. If the
10356 compilation is from a C file generated by language preprocessors, do
10357 not set the language if it was already deduced by start_subfile. */
10358 if (!(cu
->language
== language_c
10359 && COMPUNIT_FILETABS (cust
)->language
!= language_unknown
))
10360 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10362 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10363 produce DW_AT_location with location lists but it can be possibly
10364 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10365 there were bugs in prologue debug info, fixed later in GCC-4.5
10366 by "unwind info for epilogues" patch (which is not directly related).
10368 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10369 needed, it would be wrong due to missing DW_AT_producer there.
10371 Still one can confuse GDB by using non-standard GCC compilation
10372 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10374 if (cu
->has_loclist
&& gcc_4_minor
>= 5)
10375 cust
->locations_valid
= 1;
10377 if (gcc_4_minor
>= 5)
10378 cust
->epilogue_unwind_valid
= 1;
10380 cust
->call_site_htab
= cu
->call_site_htab
;
10383 if (dwarf2_per_objfile
->using_index
)
10384 per_cu
->v
.quick
->compunit_symtab
= cust
;
10387 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
10388 pst
->compunit_symtab
= cust
;
10392 /* Push it for inclusion processing later. */
10393 dwarf2_per_objfile
->just_read_cus
.push_back (per_cu
);
10395 /* Not needed any more. */
10396 cu
->reset_builder ();
10399 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10400 already been loaded into memory. */
10403 process_full_type_unit (struct dwarf2_per_cu_data
*per_cu
,
10404 enum language pretend_language
)
10406 struct dwarf2_cu
*cu
= per_cu
->cu
;
10407 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
10408 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
10409 struct compunit_symtab
*cust
;
10410 struct signatured_type
*sig_type
;
10412 gdb_assert (per_cu
->is_debug_types
);
10413 sig_type
= (struct signatured_type
*) per_cu
;
10415 /* Clear the list here in case something was left over. */
10416 cu
->method_list
.clear ();
10418 cu
->language
= pretend_language
;
10419 cu
->language_defn
= language_def (cu
->language
);
10421 /* The symbol tables are set up in read_type_unit_scope. */
10422 process_die (cu
->dies
, cu
);
10424 /* For now fudge the Go package. */
10425 if (cu
->language
== language_go
)
10426 fixup_go_packaging (cu
);
10428 /* Now that we have processed all the DIEs in the CU, all the types
10429 should be complete, and it should now be safe to compute all of the
10431 compute_delayed_physnames (cu
);
10433 if (cu
->language
== language_rust
)
10434 rust_union_quirks (cu
);
10436 /* TUs share symbol tables.
10437 If this is the first TU to use this symtab, complete the construction
10438 of it with end_expandable_symtab. Otherwise, complete the addition of
10439 this TU's symbols to the existing symtab. */
10440 if (sig_type
->type_unit_group
->compunit_symtab
== NULL
)
10442 buildsym_compunit
*builder
= cu
->get_builder ();
10443 cust
= builder
->end_expandable_symtab (0, SECT_OFF_TEXT (objfile
));
10444 sig_type
->type_unit_group
->compunit_symtab
= cust
;
10448 /* Set symtab language to language from DW_AT_language. If the
10449 compilation is from a C file generated by language preprocessors,
10450 do not set the language if it was already deduced by
10452 if (!(cu
->language
== language_c
10453 && COMPUNIT_FILETABS (cust
)->language
!= language_c
))
10454 COMPUNIT_FILETABS (cust
)->language
= cu
->language
;
10459 cu
->get_builder ()->augment_type_symtab ();
10460 cust
= sig_type
->type_unit_group
->compunit_symtab
;
10463 if (dwarf2_per_objfile
->using_index
)
10464 per_cu
->v
.quick
->compunit_symtab
= cust
;
10467 struct partial_symtab
*pst
= per_cu
->v
.psymtab
;
10468 pst
->compunit_symtab
= cust
;
10472 /* Not needed any more. */
10473 cu
->reset_builder ();
10476 /* Process an imported unit DIE. */
10479 process_imported_unit_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10481 struct attribute
*attr
;
10483 /* For now we don't handle imported units in type units. */
10484 if (cu
->per_cu
->is_debug_types
)
10486 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10487 " supported in type units [in module %s]"),
10488 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
10491 attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
10494 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
10495 bool is_dwz
= (attr
->form
== DW_FORM_GNU_ref_alt
|| cu
->per_cu
->is_dwz
);
10496 dwarf2_per_cu_data
*per_cu
10497 = dwarf2_find_containing_comp_unit (sect_off
, is_dwz
,
10498 cu
->per_cu
->dwarf2_per_objfile
);
10500 /* If necessary, add it to the queue and load its DIEs. */
10501 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
10502 load_full_comp_unit (per_cu
, false, cu
->language
);
10504 VEC_safe_push (dwarf2_per_cu_ptr
, cu
->per_cu
->imported_symtabs
,
10509 /* RAII object that represents a process_die scope: i.e.,
10510 starts/finishes processing a DIE. */
10511 class process_die_scope
10514 process_die_scope (die_info
*die
, dwarf2_cu
*cu
)
10515 : m_die (die
), m_cu (cu
)
10517 /* We should only be processing DIEs not already in process. */
10518 gdb_assert (!m_die
->in_process
);
10519 m_die
->in_process
= true;
10522 ~process_die_scope ()
10524 m_die
->in_process
= false;
10526 /* If we're done processing the DIE for the CU that owns the line
10527 header, we don't need the line header anymore. */
10528 if (m_cu
->line_header_die_owner
== m_die
)
10530 delete m_cu
->line_header
;
10531 m_cu
->line_header
= NULL
;
10532 m_cu
->line_header_die_owner
= NULL
;
10541 /* Process a die and its children. */
10544 process_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
10546 process_die_scope
scope (die
, cu
);
10550 case DW_TAG_padding
:
10552 case DW_TAG_compile_unit
:
10553 case DW_TAG_partial_unit
:
10554 read_file_scope (die
, cu
);
10556 case DW_TAG_type_unit
:
10557 read_type_unit_scope (die
, cu
);
10559 case DW_TAG_subprogram
:
10560 case DW_TAG_inlined_subroutine
:
10561 read_func_scope (die
, cu
);
10563 case DW_TAG_lexical_block
:
10564 case DW_TAG_try_block
:
10565 case DW_TAG_catch_block
:
10566 read_lexical_block_scope (die
, cu
);
10568 case DW_TAG_call_site
:
10569 case DW_TAG_GNU_call_site
:
10570 read_call_site_scope (die
, cu
);
10572 case DW_TAG_class_type
:
10573 case DW_TAG_interface_type
:
10574 case DW_TAG_structure_type
:
10575 case DW_TAG_union_type
:
10576 process_structure_scope (die
, cu
);
10578 case DW_TAG_enumeration_type
:
10579 process_enumeration_scope (die
, cu
);
10582 /* These dies have a type, but processing them does not create
10583 a symbol or recurse to process the children. Therefore we can
10584 read them on-demand through read_type_die. */
10585 case DW_TAG_subroutine_type
:
10586 case DW_TAG_set_type
:
10587 case DW_TAG_array_type
:
10588 case DW_TAG_pointer_type
:
10589 case DW_TAG_ptr_to_member_type
:
10590 case DW_TAG_reference_type
:
10591 case DW_TAG_rvalue_reference_type
:
10592 case DW_TAG_string_type
:
10595 case DW_TAG_base_type
:
10596 case DW_TAG_subrange_type
:
10597 case DW_TAG_typedef
:
10598 /* Add a typedef symbol for the type definition, if it has a
10600 new_symbol (die
, read_type_die (die
, cu
), cu
);
10602 case DW_TAG_common_block
:
10603 read_common_block (die
, cu
);
10605 case DW_TAG_common_inclusion
:
10607 case DW_TAG_namespace
:
10608 cu
->processing_has_namespace_info
= true;
10609 read_namespace (die
, cu
);
10611 case DW_TAG_module
:
10612 cu
->processing_has_namespace_info
= true;
10613 read_module (die
, cu
);
10615 case DW_TAG_imported_declaration
:
10616 cu
->processing_has_namespace_info
= true;
10617 if (read_namespace_alias (die
, cu
))
10619 /* The declaration is not a global namespace alias. */
10620 /* Fall through. */
10621 case DW_TAG_imported_module
:
10622 cu
->processing_has_namespace_info
= true;
10623 if (die
->child
!= NULL
&& (die
->tag
== DW_TAG_imported_declaration
10624 || cu
->language
!= language_fortran
))
10625 complaint (_("Tag '%s' has unexpected children"),
10626 dwarf_tag_name (die
->tag
));
10627 read_import_statement (die
, cu
);
10630 case DW_TAG_imported_unit
:
10631 process_imported_unit_die (die
, cu
);
10634 case DW_TAG_variable
:
10635 read_variable (die
, cu
);
10639 new_symbol (die
, NULL
, cu
);
10644 /* DWARF name computation. */
10646 /* A helper function for dwarf2_compute_name which determines whether DIE
10647 needs to have the name of the scope prepended to the name listed in the
10651 die_needs_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
10653 struct attribute
*attr
;
10657 case DW_TAG_namespace
:
10658 case DW_TAG_typedef
:
10659 case DW_TAG_class_type
:
10660 case DW_TAG_interface_type
:
10661 case DW_TAG_structure_type
:
10662 case DW_TAG_union_type
:
10663 case DW_TAG_enumeration_type
:
10664 case DW_TAG_enumerator
:
10665 case DW_TAG_subprogram
:
10666 case DW_TAG_inlined_subroutine
:
10667 case DW_TAG_member
:
10668 case DW_TAG_imported_declaration
:
10671 case DW_TAG_variable
:
10672 case DW_TAG_constant
:
10673 /* We only need to prefix "globally" visible variables. These include
10674 any variable marked with DW_AT_external or any variable that
10675 lives in a namespace. [Variables in anonymous namespaces
10676 require prefixing, but they are not DW_AT_external.] */
10678 if (dwarf2_attr (die
, DW_AT_specification
, cu
))
10680 struct dwarf2_cu
*spec_cu
= cu
;
10682 return die_needs_namespace (die_specification (die
, &spec_cu
),
10686 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
10687 if (attr
== NULL
&& die
->parent
->tag
!= DW_TAG_namespace
10688 && die
->parent
->tag
!= DW_TAG_module
)
10690 /* A variable in a lexical block of some kind does not need a
10691 namespace, even though in C++ such variables may be external
10692 and have a mangled name. */
10693 if (die
->parent
->tag
== DW_TAG_lexical_block
10694 || die
->parent
->tag
== DW_TAG_try_block
10695 || die
->parent
->tag
== DW_TAG_catch_block
10696 || die
->parent
->tag
== DW_TAG_subprogram
)
10705 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10706 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10707 defined for the given DIE. */
10709 static struct attribute
*
10710 dw2_linkage_name_attr (struct die_info
*die
, struct dwarf2_cu
*cu
)
10712 struct attribute
*attr
;
10714 attr
= dwarf2_attr (die
, DW_AT_linkage_name
, cu
);
10716 attr
= dwarf2_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10721 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10722 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10723 defined for the given DIE. */
10725 static const char *
10726 dw2_linkage_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
10728 const char *linkage_name
;
10730 linkage_name
= dwarf2_string_attr (die
, DW_AT_linkage_name
, cu
);
10731 if (linkage_name
== NULL
)
10732 linkage_name
= dwarf2_string_attr (die
, DW_AT_MIPS_linkage_name
, cu
);
10734 return linkage_name
;
10737 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10738 compute the physname for the object, which include a method's:
10739 - formal parameters (C++),
10740 - receiver type (Go),
10742 The term "physname" is a bit confusing.
10743 For C++, for example, it is the demangled name.
10744 For Go, for example, it's the mangled name.
10746 For Ada, return the DIE's linkage name rather than the fully qualified
10747 name. PHYSNAME is ignored..
10749 The result is allocated on the objfile_obstack and canonicalized. */
10751 static const char *
10752 dwarf2_compute_name (const char *name
,
10753 struct die_info
*die
, struct dwarf2_cu
*cu
,
10756 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
10759 name
= dwarf2_name (die
, cu
);
10761 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10762 but otherwise compute it by typename_concat inside GDB.
10763 FIXME: Actually this is not really true, or at least not always true.
10764 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
10765 Fortran names because there is no mangling standard. So new_symbol
10766 will set the demangled name to the result of dwarf2_full_name, and it is
10767 the demangled name that GDB uses if it exists. */
10768 if (cu
->language
== language_ada
10769 || (cu
->language
== language_fortran
&& physname
))
10771 /* For Ada unit, we prefer the linkage name over the name, as
10772 the former contains the exported name, which the user expects
10773 to be able to reference. Ideally, we want the user to be able
10774 to reference this entity using either natural or linkage name,
10775 but we haven't started looking at this enhancement yet. */
10776 const char *linkage_name
= dw2_linkage_name (die
, cu
);
10778 if (linkage_name
!= NULL
)
10779 return linkage_name
;
10782 /* These are the only languages we know how to qualify names in. */
10784 && (cu
->language
== language_cplus
10785 || cu
->language
== language_fortran
|| cu
->language
== language_d
10786 || cu
->language
== language_rust
))
10788 if (die_needs_namespace (die
, cu
))
10790 const char *prefix
;
10791 const char *canonical_name
= NULL
;
10795 prefix
= determine_prefix (die
, cu
);
10796 if (*prefix
!= '\0')
10798 char *prefixed_name
= typename_concat (NULL
, prefix
, name
,
10801 buf
.puts (prefixed_name
);
10802 xfree (prefixed_name
);
10807 /* Template parameters may be specified in the DIE's DW_AT_name, or
10808 as children with DW_TAG_template_type_param or
10809 DW_TAG_value_type_param. If the latter, add them to the name
10810 here. If the name already has template parameters, then
10811 skip this step; some versions of GCC emit both, and
10812 it is more efficient to use the pre-computed name.
10814 Something to keep in mind about this process: it is very
10815 unlikely, or in some cases downright impossible, to produce
10816 something that will match the mangled name of a function.
10817 If the definition of the function has the same debug info,
10818 we should be able to match up with it anyway. But fallbacks
10819 using the minimal symbol, for instance to find a method
10820 implemented in a stripped copy of libstdc++, will not work.
10821 If we do not have debug info for the definition, we will have to
10822 match them up some other way.
10824 When we do name matching there is a related problem with function
10825 templates; two instantiated function templates are allowed to
10826 differ only by their return types, which we do not add here. */
10828 if (cu
->language
== language_cplus
&& strchr (name
, '<') == NULL
)
10830 struct attribute
*attr
;
10831 struct die_info
*child
;
10834 die
->building_fullname
= 1;
10836 for (child
= die
->child
; child
!= NULL
; child
= child
->sibling
)
10840 const gdb_byte
*bytes
;
10841 struct dwarf2_locexpr_baton
*baton
;
10844 if (child
->tag
!= DW_TAG_template_type_param
10845 && child
->tag
!= DW_TAG_template_value_param
)
10856 attr
= dwarf2_attr (child
, DW_AT_type
, cu
);
10859 complaint (_("template parameter missing DW_AT_type"));
10860 buf
.puts ("UNKNOWN_TYPE");
10863 type
= die_type (child
, cu
);
10865 if (child
->tag
== DW_TAG_template_type_param
)
10867 c_print_type (type
, "", &buf
, -1, 0, cu
->language
,
10868 &type_print_raw_options
);
10872 attr
= dwarf2_attr (child
, DW_AT_const_value
, cu
);
10875 complaint (_("template parameter missing "
10876 "DW_AT_const_value"));
10877 buf
.puts ("UNKNOWN_VALUE");
10881 dwarf2_const_value_attr (attr
, type
, name
,
10882 &cu
->comp_unit_obstack
, cu
,
10883 &value
, &bytes
, &baton
);
10885 if (TYPE_NOSIGN (type
))
10886 /* GDB prints characters as NUMBER 'CHAR'. If that's
10887 changed, this can use value_print instead. */
10888 c_printchar (value
, type
, &buf
);
10891 struct value_print_options opts
;
10894 v
= dwarf2_evaluate_loc_desc (type
, NULL
,
10898 else if (bytes
!= NULL
)
10900 v
= allocate_value (type
);
10901 memcpy (value_contents_writeable (v
), bytes
,
10902 TYPE_LENGTH (type
));
10905 v
= value_from_longest (type
, value
);
10907 /* Specify decimal so that we do not depend on
10909 get_formatted_print_options (&opts
, 'd');
10911 value_print (v
, &buf
, &opts
);
10916 die
->building_fullname
= 0;
10920 /* Close the argument list, with a space if necessary
10921 (nested templates). */
10922 if (!buf
.empty () && buf
.string ().back () == '>')
10929 /* For C++ methods, append formal parameter type
10930 information, if PHYSNAME. */
10932 if (physname
&& die
->tag
== DW_TAG_subprogram
10933 && cu
->language
== language_cplus
)
10935 struct type
*type
= read_type_die (die
, cu
);
10937 c_type_print_args (type
, &buf
, 1, cu
->language
,
10938 &type_print_raw_options
);
10940 if (cu
->language
== language_cplus
)
10942 /* Assume that an artificial first parameter is
10943 "this", but do not crash if it is not. RealView
10944 marks unnamed (and thus unused) parameters as
10945 artificial; there is no way to differentiate
10947 if (TYPE_NFIELDS (type
) > 0
10948 && TYPE_FIELD_ARTIFICIAL (type
, 0)
10949 && TYPE_CODE (TYPE_FIELD_TYPE (type
, 0)) == TYPE_CODE_PTR
10950 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type
,
10952 buf
.puts (" const");
10956 const std::string
&intermediate_name
= buf
.string ();
10958 if (cu
->language
== language_cplus
)
10960 = dwarf2_canonicalize_name (intermediate_name
.c_str (), cu
,
10961 &objfile
->per_bfd
->storage_obstack
);
10963 /* If we only computed INTERMEDIATE_NAME, or if
10964 INTERMEDIATE_NAME is already canonical, then we need to
10965 copy it to the appropriate obstack. */
10966 if (canonical_name
== NULL
|| canonical_name
== intermediate_name
.c_str ())
10967 name
= ((const char *)
10968 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
10969 intermediate_name
.c_str (),
10970 intermediate_name
.length ()));
10972 name
= canonical_name
;
10979 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10980 If scope qualifiers are appropriate they will be added. The result
10981 will be allocated on the storage_obstack, or NULL if the DIE does
10982 not have a name. NAME may either be from a previous call to
10983 dwarf2_name or NULL.
10985 The output string will be canonicalized (if C++). */
10987 static const char *
10988 dwarf2_full_name (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
10990 return dwarf2_compute_name (name
, die
, cu
, 0);
10993 /* Construct a physname for the given DIE in CU. NAME may either be
10994 from a previous call to dwarf2_name or NULL. The result will be
10995 allocated on the objfile_objstack or NULL if the DIE does not have a
10998 The output string will be canonicalized (if C++). */
11000 static const char *
11001 dwarf2_physname (const char *name
, struct die_info
*die
, struct dwarf2_cu
*cu
)
11003 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
11004 const char *retval
, *mangled
= NULL
, *canon
= NULL
;
11007 /* In this case dwarf2_compute_name is just a shortcut not building anything
11009 if (!die_needs_namespace (die
, cu
))
11010 return dwarf2_compute_name (name
, die
, cu
, 1);
11012 mangled
= dw2_linkage_name (die
, cu
);
11014 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
11015 See https://github.com/rust-lang/rust/issues/32925. */
11016 if (cu
->language
== language_rust
&& mangled
!= NULL
11017 && strchr (mangled
, '{') != NULL
)
11020 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11022 gdb::unique_xmalloc_ptr
<char> demangled
;
11023 if (mangled
!= NULL
)
11026 if (language_def (cu
->language
)->la_store_sym_names_in_linkage_form_p
)
11028 /* Do nothing (do not demangle the symbol name). */
11030 else if (cu
->language
== language_go
)
11032 /* This is a lie, but we already lie to the caller new_symbol.
11033 new_symbol assumes we return the mangled name.
11034 This just undoes that lie until things are cleaned up. */
11038 /* Use DMGL_RET_DROP for C++ template functions to suppress
11039 their return type. It is easier for GDB users to search
11040 for such functions as `name(params)' than `long name(params)'.
11041 In such case the minimal symbol names do not match the full
11042 symbol names but for template functions there is never a need
11043 to look up their definition from their declaration so
11044 the only disadvantage remains the minimal symbol variant
11045 `long name(params)' does not have the proper inferior type. */
11046 demangled
.reset (gdb_demangle (mangled
,
11047 (DMGL_PARAMS
| DMGL_ANSI
11048 | DMGL_RET_DROP
)));
11051 canon
= demangled
.get ();
11059 if (canon
== NULL
|| check_physname
)
11061 const char *physname
= dwarf2_compute_name (name
, die
, cu
, 1);
11063 if (canon
!= NULL
&& strcmp (physname
, canon
) != 0)
11065 /* It may not mean a bug in GDB. The compiler could also
11066 compute DW_AT_linkage_name incorrectly. But in such case
11067 GDB would need to be bug-to-bug compatible. */
11069 complaint (_("Computed physname <%s> does not match demangled <%s> "
11070 "(from linkage <%s>) - DIE at %s [in module %s]"),
11071 physname
, canon
, mangled
, sect_offset_str (die
->sect_off
),
11072 objfile_name (objfile
));
11074 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11075 is available here - over computed PHYSNAME. It is safer
11076 against both buggy GDB and buggy compilers. */
11090 retval
= ((const char *)
11091 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
11092 retval
, strlen (retval
)));
11097 /* Inspect DIE in CU for a namespace alias. If one exists, record
11098 a new symbol for it.
11100 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11103 read_namespace_alias (struct die_info
*die
, struct dwarf2_cu
*cu
)
11105 struct attribute
*attr
;
11107 /* If the die does not have a name, this is not a namespace
11109 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
11113 struct die_info
*d
= die
;
11114 struct dwarf2_cu
*imported_cu
= cu
;
11116 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11117 keep inspecting DIEs until we hit the underlying import. */
11118 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11119 for (num
= 0; num
< MAX_NESTED_IMPORTED_DECLARATIONS
; ++num
)
11121 attr
= dwarf2_attr (d
, DW_AT_import
, cu
);
11125 d
= follow_die_ref (d
, attr
, &imported_cu
);
11126 if (d
->tag
!= DW_TAG_imported_declaration
)
11130 if (num
== MAX_NESTED_IMPORTED_DECLARATIONS
)
11132 complaint (_("DIE at %s has too many recursively imported "
11133 "declarations"), sect_offset_str (d
->sect_off
));
11140 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
11142 type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
11143 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
11145 /* This declaration is a global namespace alias. Add
11146 a symbol for it whose type is the aliased namespace. */
11147 new_symbol (die
, type
, cu
);
11156 /* Return the using directives repository (global or local?) to use in the
11157 current context for CU.
11159 For Ada, imported declarations can materialize renamings, which *may* be
11160 global. However it is impossible (for now?) in DWARF to distinguish
11161 "external" imported declarations and "static" ones. As all imported
11162 declarations seem to be static in all other languages, make them all CU-wide
11163 global only in Ada. */
11165 static struct using_direct
**
11166 using_directives (struct dwarf2_cu
*cu
)
11168 if (cu
->language
== language_ada
11169 && cu
->get_builder ()->outermost_context_p ())
11170 return cu
->get_builder ()->get_global_using_directives ();
11172 return cu
->get_builder ()->get_local_using_directives ();
11175 /* Read the import statement specified by the given die and record it. */
11178 read_import_statement (struct die_info
*die
, struct dwarf2_cu
*cu
)
11180 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
11181 struct attribute
*import_attr
;
11182 struct die_info
*imported_die
, *child_die
;
11183 struct dwarf2_cu
*imported_cu
;
11184 const char *imported_name
;
11185 const char *imported_name_prefix
;
11186 const char *canonical_name
;
11187 const char *import_alias
;
11188 const char *imported_declaration
= NULL
;
11189 const char *import_prefix
;
11190 std::vector
<const char *> excludes
;
11192 import_attr
= dwarf2_attr (die
, DW_AT_import
, cu
);
11193 if (import_attr
== NULL
)
11195 complaint (_("Tag '%s' has no DW_AT_import"),
11196 dwarf_tag_name (die
->tag
));
11201 imported_die
= follow_die_ref_or_sig (die
, import_attr
, &imported_cu
);
11202 imported_name
= dwarf2_name (imported_die
, imported_cu
);
11203 if (imported_name
== NULL
)
11205 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11207 The import in the following code:
11221 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11222 <52> DW_AT_decl_file : 1
11223 <53> DW_AT_decl_line : 6
11224 <54> DW_AT_import : <0x75>
11225 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11226 <59> DW_AT_name : B
11227 <5b> DW_AT_decl_file : 1
11228 <5c> DW_AT_decl_line : 2
11229 <5d> DW_AT_type : <0x6e>
11231 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11232 <76> DW_AT_byte_size : 4
11233 <77> DW_AT_encoding : 5 (signed)
11235 imports the wrong die ( 0x75 instead of 0x58 ).
11236 This case will be ignored until the gcc bug is fixed. */
11240 /* Figure out the local name after import. */
11241 import_alias
= dwarf2_name (die
, cu
);
11243 /* Figure out where the statement is being imported to. */
11244 import_prefix
= determine_prefix (die
, cu
);
11246 /* Figure out what the scope of the imported die is and prepend it
11247 to the name of the imported die. */
11248 imported_name_prefix
= determine_prefix (imported_die
, imported_cu
);
11250 if (imported_die
->tag
!= DW_TAG_namespace
11251 && imported_die
->tag
!= DW_TAG_module
)
11253 imported_declaration
= imported_name
;
11254 canonical_name
= imported_name_prefix
;
11256 else if (strlen (imported_name_prefix
) > 0)
11257 canonical_name
= obconcat (&objfile
->objfile_obstack
,
11258 imported_name_prefix
,
11259 (cu
->language
== language_d
? "." : "::"),
11260 imported_name
, (char *) NULL
);
11262 canonical_name
= imported_name
;
11264 if (die
->tag
== DW_TAG_imported_module
&& cu
->language
== language_fortran
)
11265 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
11266 child_die
= sibling_die (child_die
))
11268 /* DWARF-4: A Fortran use statement with a “rename list” may be
11269 represented by an imported module entry with an import attribute
11270 referring to the module and owned entries corresponding to those
11271 entities that are renamed as part of being imported. */
11273 if (child_die
->tag
!= DW_TAG_imported_declaration
)
11275 complaint (_("child DW_TAG_imported_declaration expected "
11276 "- DIE at %s [in module %s]"),
11277 sect_offset_str (child_die
->sect_off
),
11278 objfile_name (objfile
));
11282 import_attr
= dwarf2_attr (child_die
, DW_AT_import
, cu
);
11283 if (import_attr
== NULL
)
11285 complaint (_("Tag '%s' has no DW_AT_import"),
11286 dwarf_tag_name (child_die
->tag
));
11291 imported_die
= follow_die_ref_or_sig (child_die
, import_attr
,
11293 imported_name
= dwarf2_name (imported_die
, imported_cu
);
11294 if (imported_name
== NULL
)
11296 complaint (_("child DW_TAG_imported_declaration has unknown "
11297 "imported name - DIE at %s [in module %s]"),
11298 sect_offset_str (child_die
->sect_off
),
11299 objfile_name (objfile
));
11303 excludes
.push_back (imported_name
);
11305 process_die (child_die
, cu
);
11308 add_using_directive (using_directives (cu
),
11312 imported_declaration
,
11315 &objfile
->objfile_obstack
);
11318 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11319 types, but gives them a size of zero. Starting with version 14,
11320 ICC is compatible with GCC. */
11323 producer_is_icc_lt_14 (struct dwarf2_cu
*cu
)
11325 if (!cu
->checked_producer
)
11326 check_producer (cu
);
11328 return cu
->producer_is_icc_lt_14
;
11331 /* ICC generates a DW_AT_type for C void functions. This was observed on
11332 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11333 which says that void functions should not have a DW_AT_type. */
11336 producer_is_icc (struct dwarf2_cu
*cu
)
11338 if (!cu
->checked_producer
)
11339 check_producer (cu
);
11341 return cu
->producer_is_icc
;
11344 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11345 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11346 this, it was first present in GCC release 4.3.0. */
11349 producer_is_gcc_lt_4_3 (struct dwarf2_cu
*cu
)
11351 if (!cu
->checked_producer
)
11352 check_producer (cu
);
11354 return cu
->producer_is_gcc_lt_4_3
;
11357 static file_and_directory
11358 find_file_and_directory (struct die_info
*die
, struct dwarf2_cu
*cu
)
11360 file_and_directory res
;
11362 /* Find the filename. Do not use dwarf2_name here, since the filename
11363 is not a source language identifier. */
11364 res
.name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
11365 res
.comp_dir
= dwarf2_string_attr (die
, DW_AT_comp_dir
, cu
);
11367 if (res
.comp_dir
== NULL
11368 && producer_is_gcc_lt_4_3 (cu
) && res
.name
!= NULL
11369 && IS_ABSOLUTE_PATH (res
.name
))
11371 res
.comp_dir_storage
= ldirname (res
.name
);
11372 if (!res
.comp_dir_storage
.empty ())
11373 res
.comp_dir
= res
.comp_dir_storage
.c_str ();
11375 if (res
.comp_dir
!= NULL
)
11377 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11378 directory, get rid of it. */
11379 const char *cp
= strchr (res
.comp_dir
, ':');
11381 if (cp
&& cp
!= res
.comp_dir
&& cp
[-1] == '.' && cp
[1] == '/')
11382 res
.comp_dir
= cp
+ 1;
11385 if (res
.name
== NULL
)
11386 res
.name
= "<unknown>";
11391 /* Handle DW_AT_stmt_list for a compilation unit.
11392 DIE is the DW_TAG_compile_unit die for CU.
11393 COMP_DIR is the compilation directory. LOWPC is passed to
11394 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11397 handle_DW_AT_stmt_list (struct die_info
*die
, struct dwarf2_cu
*cu
,
11398 const char *comp_dir
, CORE_ADDR lowpc
) /* ARI: editCase function */
11400 struct dwarf2_per_objfile
*dwarf2_per_objfile
11401 = cu
->per_cu
->dwarf2_per_objfile
;
11402 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11403 struct attribute
*attr
;
11404 struct line_header line_header_local
;
11405 hashval_t line_header_local_hash
;
11407 int decode_mapping
;
11409 gdb_assert (! cu
->per_cu
->is_debug_types
);
11411 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, cu
);
11415 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
11417 /* The line header hash table is only created if needed (it exists to
11418 prevent redundant reading of the line table for partial_units).
11419 If we're given a partial_unit, we'll need it. If we're given a
11420 compile_unit, then use the line header hash table if it's already
11421 created, but don't create one just yet. */
11423 if (dwarf2_per_objfile
->line_header_hash
== NULL
11424 && die
->tag
== DW_TAG_partial_unit
)
11426 dwarf2_per_objfile
->line_header_hash
11427 = htab_create_alloc_ex (127, line_header_hash_voidp
,
11428 line_header_eq_voidp
,
11429 free_line_header_voidp
,
11430 &objfile
->objfile_obstack
,
11431 hashtab_obstack_allocate
,
11432 dummy_obstack_deallocate
);
11435 line_header_local
.sect_off
= line_offset
;
11436 line_header_local
.offset_in_dwz
= cu
->per_cu
->is_dwz
;
11437 line_header_local_hash
= line_header_hash (&line_header_local
);
11438 if (dwarf2_per_objfile
->line_header_hash
!= NULL
)
11440 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
11441 &line_header_local
,
11442 line_header_local_hash
, NO_INSERT
);
11444 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11445 is not present in *SLOT (since if there is something in *SLOT then
11446 it will be for a partial_unit). */
11447 if (die
->tag
== DW_TAG_partial_unit
&& slot
!= NULL
)
11449 gdb_assert (*slot
!= NULL
);
11450 cu
->line_header
= (struct line_header
*) *slot
;
11455 /* dwarf_decode_line_header does not yet provide sufficient information.
11456 We always have to call also dwarf_decode_lines for it. */
11457 line_header_up lh
= dwarf_decode_line_header (line_offset
, cu
);
11461 cu
->line_header
= lh
.release ();
11462 cu
->line_header_die_owner
= die
;
11464 if (dwarf2_per_objfile
->line_header_hash
== NULL
)
11468 slot
= htab_find_slot_with_hash (dwarf2_per_objfile
->line_header_hash
,
11469 &line_header_local
,
11470 line_header_local_hash
, INSERT
);
11471 gdb_assert (slot
!= NULL
);
11473 if (slot
!= NULL
&& *slot
== NULL
)
11475 /* This newly decoded line number information unit will be owned
11476 by line_header_hash hash table. */
11477 *slot
= cu
->line_header
;
11478 cu
->line_header_die_owner
= NULL
;
11482 /* We cannot free any current entry in (*slot) as that struct line_header
11483 may be already used by multiple CUs. Create only temporary decoded
11484 line_header for this CU - it may happen at most once for each line
11485 number information unit. And if we're not using line_header_hash
11486 then this is what we want as well. */
11487 gdb_assert (die
->tag
!= DW_TAG_partial_unit
);
11489 decode_mapping
= (die
->tag
!= DW_TAG_partial_unit
);
11490 dwarf_decode_lines (cu
->line_header
, comp_dir
, cu
, NULL
, lowpc
,
11495 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11498 read_file_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11500 struct dwarf2_per_objfile
*dwarf2_per_objfile
11501 = cu
->per_cu
->dwarf2_per_objfile
;
11502 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11503 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
11504 CORE_ADDR lowpc
= ((CORE_ADDR
) -1);
11505 CORE_ADDR highpc
= ((CORE_ADDR
) 0);
11506 struct attribute
*attr
;
11507 struct die_info
*child_die
;
11508 CORE_ADDR baseaddr
;
11510 prepare_one_comp_unit (cu
, die
, cu
->language
);
11511 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
11513 get_scope_pc_bounds (die
, &lowpc
, &highpc
, cu
);
11515 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11516 from finish_block. */
11517 if (lowpc
== ((CORE_ADDR
) -1))
11519 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
11521 file_and_directory fnd
= find_file_and_directory (die
, cu
);
11523 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11524 standardised yet. As a workaround for the language detection we fall
11525 back to the DW_AT_producer string. */
11526 if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL") != NULL
)
11527 cu
->language
= language_opencl
;
11529 /* Similar hack for Go. */
11530 if (cu
->producer
&& strstr (cu
->producer
, "GNU Go ") != NULL
)
11531 set_cu_language (DW_LANG_Go
, cu
);
11533 cu
->start_symtab (fnd
.name
, fnd
.comp_dir
, lowpc
);
11535 /* Decode line number information if present. We do this before
11536 processing child DIEs, so that the line header table is available
11537 for DW_AT_decl_file. */
11538 handle_DW_AT_stmt_list (die
, cu
, fnd
.comp_dir
, lowpc
);
11540 /* Process all dies in compilation unit. */
11541 if (die
->child
!= NULL
)
11543 child_die
= die
->child
;
11544 while (child_die
&& child_die
->tag
)
11546 process_die (child_die
, cu
);
11547 child_die
= sibling_die (child_die
);
11551 /* Decode macro information, if present. Dwarf 2 macro information
11552 refers to information in the line number info statement program
11553 header, so we can only read it if we've read the header
11555 attr
= dwarf2_attr (die
, DW_AT_macros
, cu
);
11557 attr
= dwarf2_attr (die
, DW_AT_GNU_macros
, cu
);
11558 if (attr
&& cu
->line_header
)
11560 if (dwarf2_attr (die
, DW_AT_macro_info
, cu
))
11561 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11563 dwarf_decode_macros (cu
, DW_UNSND (attr
), 1);
11567 attr
= dwarf2_attr (die
, DW_AT_macro_info
, cu
);
11568 if (attr
&& cu
->line_header
)
11570 unsigned int macro_offset
= DW_UNSND (attr
);
11572 dwarf_decode_macros (cu
, macro_offset
, 0);
11578 dwarf2_cu::setup_type_unit_groups (struct die_info
*die
)
11580 struct type_unit_group
*tu_group
;
11582 struct attribute
*attr
;
11584 struct signatured_type
*sig_type
;
11586 gdb_assert (per_cu
->is_debug_types
);
11587 sig_type
= (struct signatured_type
*) per_cu
;
11589 attr
= dwarf2_attr (die
, DW_AT_stmt_list
, this);
11591 /* If we're using .gdb_index (includes -readnow) then
11592 per_cu->type_unit_group may not have been set up yet. */
11593 if (sig_type
->type_unit_group
== NULL
)
11594 sig_type
->type_unit_group
= get_type_unit_group (this, attr
);
11595 tu_group
= sig_type
->type_unit_group
;
11597 /* If we've already processed this stmt_list there's no real need to
11598 do it again, we could fake it and just recreate the part we need
11599 (file name,index -> symtab mapping). If data shows this optimization
11600 is useful we can do it then. */
11601 first_time
= tu_group
->compunit_symtab
== NULL
;
11603 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11608 sect_offset line_offset
= (sect_offset
) DW_UNSND (attr
);
11609 lh
= dwarf_decode_line_header (line_offset
, this);
11614 start_symtab ("", NULL
, 0);
11617 gdb_assert (tu_group
->symtabs
== NULL
);
11618 gdb_assert (m_builder
== nullptr);
11619 struct compunit_symtab
*cust
= tu_group
->compunit_symtab
;
11620 m_builder
.reset (new struct buildsym_compunit
11621 (COMPUNIT_OBJFILE (cust
), "",
11622 COMPUNIT_DIRNAME (cust
),
11623 compunit_language (cust
),
11629 line_header
= lh
.release ();
11630 line_header_die_owner
= die
;
11634 struct compunit_symtab
*cust
= start_symtab ("", NULL
, 0);
11636 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11637 still initializing it, and our caller (a few levels up)
11638 process_full_type_unit still needs to know if this is the first
11641 tu_group
->num_symtabs
= line_header
->file_names
.size ();
11642 tu_group
->symtabs
= XNEWVEC (struct symtab
*,
11643 line_header
->file_names
.size ());
11645 for (i
= 0; i
< line_header
->file_names
.size (); ++i
)
11647 file_entry
&fe
= line_header
->file_names
[i
];
11649 dwarf2_start_subfile (this, fe
.name
,
11650 fe
.include_dir (line_header
));
11651 buildsym_compunit
*b
= get_builder ();
11652 if (b
->get_current_subfile ()->symtab
== NULL
)
11654 /* NOTE: start_subfile will recognize when it's been
11655 passed a file it has already seen. So we can't
11656 assume there's a simple mapping from
11657 cu->line_header->file_names to subfiles, plus
11658 cu->line_header->file_names may contain dups. */
11659 b
->get_current_subfile ()->symtab
11660 = allocate_symtab (cust
, b
->get_current_subfile ()->name
);
11663 fe
.symtab
= b
->get_current_subfile ()->symtab
;
11664 tu_group
->symtabs
[i
] = fe
.symtab
;
11669 gdb_assert (m_builder
== nullptr);
11670 struct compunit_symtab
*cust
= tu_group
->compunit_symtab
;
11671 m_builder
.reset (new struct buildsym_compunit
11672 (COMPUNIT_OBJFILE (cust
), "",
11673 COMPUNIT_DIRNAME (cust
),
11674 compunit_language (cust
),
11677 for (i
= 0; i
< line_header
->file_names
.size (); ++i
)
11679 file_entry
&fe
= line_header
->file_names
[i
];
11681 fe
.symtab
= tu_group
->symtabs
[i
];
11685 /* The main symtab is allocated last. Type units don't have DW_AT_name
11686 so they don't have a "real" (so to speak) symtab anyway.
11687 There is later code that will assign the main symtab to all symbols
11688 that don't have one. We need to handle the case of a symbol with a
11689 missing symtab (DW_AT_decl_file) anyway. */
11692 /* Process DW_TAG_type_unit.
11693 For TUs we want to skip the first top level sibling if it's not the
11694 actual type being defined by this TU. In this case the first top
11695 level sibling is there to provide context only. */
11698 read_type_unit_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
11700 struct die_info
*child_die
;
11702 prepare_one_comp_unit (cu
, die
, language_minimal
);
11704 /* Initialize (or reinitialize) the machinery for building symtabs.
11705 We do this before processing child DIEs, so that the line header table
11706 is available for DW_AT_decl_file. */
11707 cu
->setup_type_unit_groups (die
);
11709 if (die
->child
!= NULL
)
11711 child_die
= die
->child
;
11712 while (child_die
&& child_die
->tag
)
11714 process_die (child_die
, cu
);
11715 child_die
= sibling_die (child_die
);
11722 http://gcc.gnu.org/wiki/DebugFission
11723 http://gcc.gnu.org/wiki/DebugFissionDWP
11725 To simplify handling of both DWO files ("object" files with the DWARF info)
11726 and DWP files (a file with the DWOs packaged up into one file), we treat
11727 DWP files as having a collection of virtual DWO files. */
11730 hash_dwo_file (const void *item
)
11732 const struct dwo_file
*dwo_file
= (const struct dwo_file
*) item
;
11735 hash
= htab_hash_string (dwo_file
->dwo_name
);
11736 if (dwo_file
->comp_dir
!= NULL
)
11737 hash
+= htab_hash_string (dwo_file
->comp_dir
);
11742 eq_dwo_file (const void *item_lhs
, const void *item_rhs
)
11744 const struct dwo_file
*lhs
= (const struct dwo_file
*) item_lhs
;
11745 const struct dwo_file
*rhs
= (const struct dwo_file
*) item_rhs
;
11747 if (strcmp (lhs
->dwo_name
, rhs
->dwo_name
) != 0)
11749 if (lhs
->comp_dir
== NULL
|| rhs
->comp_dir
== NULL
)
11750 return lhs
->comp_dir
== rhs
->comp_dir
;
11751 return strcmp (lhs
->comp_dir
, rhs
->comp_dir
) == 0;
11754 /* Allocate a hash table for DWO files. */
11757 allocate_dwo_file_hash_table (struct objfile
*objfile
)
11759 auto delete_dwo_file
= [] (void *item
)
11761 struct dwo_file
*dwo_file
= (struct dwo_file
*) item
;
11766 return htab_up (htab_create_alloc_ex (41,
11770 &objfile
->objfile_obstack
,
11771 hashtab_obstack_allocate
,
11772 dummy_obstack_deallocate
));
11775 /* Lookup DWO file DWO_NAME. */
11778 lookup_dwo_file_slot (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11779 const char *dwo_name
,
11780 const char *comp_dir
)
11782 struct dwo_file find_entry
;
11785 if (dwarf2_per_objfile
->dwo_files
== NULL
)
11786 dwarf2_per_objfile
->dwo_files
11787 = allocate_dwo_file_hash_table (dwarf2_per_objfile
->objfile
);
11789 find_entry
.dwo_name
= dwo_name
;
11790 find_entry
.comp_dir
= comp_dir
;
11791 slot
= htab_find_slot (dwarf2_per_objfile
->dwo_files
.get (), &find_entry
,
11798 hash_dwo_unit (const void *item
)
11800 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
11802 /* This drops the top 32 bits of the id, but is ok for a hash. */
11803 return dwo_unit
->signature
;
11807 eq_dwo_unit (const void *item_lhs
, const void *item_rhs
)
11809 const struct dwo_unit
*lhs
= (const struct dwo_unit
*) item_lhs
;
11810 const struct dwo_unit
*rhs
= (const struct dwo_unit
*) item_rhs
;
11812 /* The signature is assumed to be unique within the DWO file.
11813 So while object file CU dwo_id's always have the value zero,
11814 that's OK, assuming each object file DWO file has only one CU,
11815 and that's the rule for now. */
11816 return lhs
->signature
== rhs
->signature
;
11819 /* Allocate a hash table for DWO CUs,TUs.
11820 There is one of these tables for each of CUs,TUs for each DWO file. */
11823 allocate_dwo_unit_table (struct objfile
*objfile
)
11825 /* Start out with a pretty small number.
11826 Generally DWO files contain only one CU and maybe some TUs. */
11827 return htab_create_alloc_ex (3,
11831 &objfile
->objfile_obstack
,
11832 hashtab_obstack_allocate
,
11833 dummy_obstack_deallocate
);
11836 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11838 struct create_dwo_cu_data
11840 struct dwo_file
*dwo_file
;
11841 struct dwo_unit dwo_unit
;
11844 /* die_reader_func for create_dwo_cu. */
11847 create_dwo_cu_reader (const struct die_reader_specs
*reader
,
11848 const gdb_byte
*info_ptr
,
11849 struct die_info
*comp_unit_die
,
11853 struct dwarf2_cu
*cu
= reader
->cu
;
11854 sect_offset sect_off
= cu
->per_cu
->sect_off
;
11855 struct dwarf2_section_info
*section
= cu
->per_cu
->section
;
11856 struct create_dwo_cu_data
*data
= (struct create_dwo_cu_data
*) datap
;
11857 struct dwo_file
*dwo_file
= data
->dwo_file
;
11858 struct dwo_unit
*dwo_unit
= &data
->dwo_unit
;
11859 struct attribute
*attr
;
11861 attr
= dwarf2_attr (comp_unit_die
, DW_AT_GNU_dwo_id
, cu
);
11864 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11865 " its dwo_id [in module %s]"),
11866 sect_offset_str (sect_off
), dwo_file
->dwo_name
);
11870 dwo_unit
->dwo_file
= dwo_file
;
11871 dwo_unit
->signature
= DW_UNSND (attr
);
11872 dwo_unit
->section
= section
;
11873 dwo_unit
->sect_off
= sect_off
;
11874 dwo_unit
->length
= cu
->per_cu
->length
;
11876 if (dwarf_read_debug
)
11877 fprintf_unfiltered (gdb_stdlog
, " offset %s, dwo_id %s\n",
11878 sect_offset_str (sect_off
),
11879 hex_string (dwo_unit
->signature
));
11882 /* Create the dwo_units for the CUs in a DWO_FILE.
11883 Note: This function processes DWO files only, not DWP files. */
11886 create_cus_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
11887 struct dwo_file
&dwo_file
, dwarf2_section_info
§ion
,
11890 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
11891 const gdb_byte
*info_ptr
, *end_ptr
;
11893 dwarf2_read_section (objfile
, §ion
);
11894 info_ptr
= section
.buffer
;
11896 if (info_ptr
== NULL
)
11899 if (dwarf_read_debug
)
11901 fprintf_unfiltered (gdb_stdlog
, "Reading %s for %s:\n",
11902 get_section_name (§ion
),
11903 get_section_file_name (§ion
));
11906 end_ptr
= info_ptr
+ section
.size
;
11907 while (info_ptr
< end_ptr
)
11909 struct dwarf2_per_cu_data per_cu
;
11910 struct create_dwo_cu_data create_dwo_cu_data
;
11911 struct dwo_unit
*dwo_unit
;
11913 sect_offset sect_off
= (sect_offset
) (info_ptr
- section
.buffer
);
11915 memset (&create_dwo_cu_data
.dwo_unit
, 0,
11916 sizeof (create_dwo_cu_data
.dwo_unit
));
11917 memset (&per_cu
, 0, sizeof (per_cu
));
11918 per_cu
.dwarf2_per_objfile
= dwarf2_per_objfile
;
11919 per_cu
.is_debug_types
= 0;
11920 per_cu
.sect_off
= sect_offset (info_ptr
- section
.buffer
);
11921 per_cu
.section
= §ion
;
11922 create_dwo_cu_data
.dwo_file
= &dwo_file
;
11924 init_cutu_and_read_dies_no_follow (
11925 &per_cu
, &dwo_file
, create_dwo_cu_reader
, &create_dwo_cu_data
);
11926 info_ptr
+= per_cu
.length
;
11928 // If the unit could not be parsed, skip it.
11929 if (create_dwo_cu_data
.dwo_unit
.dwo_file
== NULL
)
11932 if (cus_htab
== NULL
)
11933 cus_htab
= allocate_dwo_unit_table (objfile
);
11935 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
11936 *dwo_unit
= create_dwo_cu_data
.dwo_unit
;
11937 slot
= htab_find_slot (cus_htab
, dwo_unit
, INSERT
);
11938 gdb_assert (slot
!= NULL
);
11941 const struct dwo_unit
*dup_cu
= (const struct dwo_unit
*)*slot
;
11942 sect_offset dup_sect_off
= dup_cu
->sect_off
;
11944 complaint (_("debug cu entry at offset %s is duplicate to"
11945 " the entry at offset %s, signature %s"),
11946 sect_offset_str (sect_off
), sect_offset_str (dup_sect_off
),
11947 hex_string (dwo_unit
->signature
));
11949 *slot
= (void *)dwo_unit
;
11953 /* DWP file .debug_{cu,tu}_index section format:
11954 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11958 Both index sections have the same format, and serve to map a 64-bit
11959 signature to a set of section numbers. Each section begins with a header,
11960 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11961 indexes, and a pool of 32-bit section numbers. The index sections will be
11962 aligned at 8-byte boundaries in the file.
11964 The index section header consists of:
11966 V, 32 bit version number
11968 N, 32 bit number of compilation units or type units in the index
11969 M, 32 bit number of slots in the hash table
11971 Numbers are recorded using the byte order of the application binary.
11973 The hash table begins at offset 16 in the section, and consists of an array
11974 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11975 order of the application binary). Unused slots in the hash table are 0.
11976 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11978 The parallel table begins immediately after the hash table
11979 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11980 array of 32-bit indexes (using the byte order of the application binary),
11981 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11982 table contains a 32-bit index into the pool of section numbers. For unused
11983 hash table slots, the corresponding entry in the parallel table will be 0.
11985 The pool of section numbers begins immediately following the hash table
11986 (at offset 16 + 12 * M from the beginning of the section). The pool of
11987 section numbers consists of an array of 32-bit words (using the byte order
11988 of the application binary). Each item in the array is indexed starting
11989 from 0. The hash table entry provides the index of the first section
11990 number in the set. Additional section numbers in the set follow, and the
11991 set is terminated by a 0 entry (section number 0 is not used in ELF).
11993 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
11994 section must be the first entry in the set, and the .debug_abbrev.dwo must
11995 be the second entry. Other members of the set may follow in any order.
12001 DWP Version 2 combines all the .debug_info, etc. sections into one,
12002 and the entries in the index tables are now offsets into these sections.
12003 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
12006 Index Section Contents:
12008 Hash Table of Signatures dwp_hash_table.hash_table
12009 Parallel Table of Indices dwp_hash_table.unit_table
12010 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
12011 Table of Section Sizes dwp_hash_table.v2.sizes
12013 The index section header consists of:
12015 V, 32 bit version number
12016 L, 32 bit number of columns in the table of section offsets
12017 N, 32 bit number of compilation units or type units in the index
12018 M, 32 bit number of slots in the hash table
12020 Numbers are recorded using the byte order of the application binary.
12022 The hash table has the same format as version 1.
12023 The parallel table of indices has the same format as version 1,
12024 except that the entries are origin-1 indices into the table of sections
12025 offsets and the table of section sizes.
12027 The table of offsets begins immediately following the parallel table
12028 (at offset 16 + 12 * M from the beginning of the section). The table is
12029 a two-dimensional array of 32-bit words (using the byte order of the
12030 application binary), with L columns and N+1 rows, in row-major order.
12031 Each row in the array is indexed starting from 0. The first row provides
12032 a key to the remaining rows: each column in this row provides an identifier
12033 for a debug section, and the offsets in the same column of subsequent rows
12034 refer to that section. The section identifiers are:
12036 DW_SECT_INFO 1 .debug_info.dwo
12037 DW_SECT_TYPES 2 .debug_types.dwo
12038 DW_SECT_ABBREV 3 .debug_abbrev.dwo
12039 DW_SECT_LINE 4 .debug_line.dwo
12040 DW_SECT_LOC 5 .debug_loc.dwo
12041 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
12042 DW_SECT_MACINFO 7 .debug_macinfo.dwo
12043 DW_SECT_MACRO 8 .debug_macro.dwo
12045 The offsets provided by the CU and TU index sections are the base offsets
12046 for the contributions made by each CU or TU to the corresponding section
12047 in the package file. Each CU and TU header contains an abbrev_offset
12048 field, used to find the abbreviations table for that CU or TU within the
12049 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12050 be interpreted as relative to the base offset given in the index section.
12051 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12052 should be interpreted as relative to the base offset for .debug_line.dwo,
12053 and offsets into other debug sections obtained from DWARF attributes should
12054 also be interpreted as relative to the corresponding base offset.
12056 The table of sizes begins immediately following the table of offsets.
12057 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12058 with L columns and N rows, in row-major order. Each row in the array is
12059 indexed starting from 1 (row 0 is shared by the two tables).
12063 Hash table lookup is handled the same in version 1 and 2:
12065 We assume that N and M will not exceed 2^32 - 1.
12066 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12068 Given a 64-bit compilation unit signature or a type signature S, an entry
12069 in the hash table is located as follows:
12071 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12072 the low-order k bits all set to 1.
12074 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12076 3) If the hash table entry at index H matches the signature, use that
12077 entry. If the hash table entry at index H is unused (all zeroes),
12078 terminate the search: the signature is not present in the table.
12080 4) Let H = (H + H') modulo M. Repeat at Step 3.
12082 Because M > N and H' and M are relatively prime, the search is guaranteed
12083 to stop at an unused slot or find the match. */
12085 /* Create a hash table to map DWO IDs to their CU/TU entry in
12086 .debug_{info,types}.dwo in DWP_FILE.
12087 Returns NULL if there isn't one.
12088 Note: This function processes DWP files only, not DWO files. */
12090 static struct dwp_hash_table
*
12091 create_dwp_hash_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12092 struct dwp_file
*dwp_file
, int is_debug_types
)
12094 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12095 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12096 const gdb_byte
*index_ptr
, *index_end
;
12097 struct dwarf2_section_info
*index
;
12098 uint32_t version
, nr_columns
, nr_units
, nr_slots
;
12099 struct dwp_hash_table
*htab
;
12101 if (is_debug_types
)
12102 index
= &dwp_file
->sections
.tu_index
;
12104 index
= &dwp_file
->sections
.cu_index
;
12106 if (dwarf2_section_empty_p (index
))
12108 dwarf2_read_section (objfile
, index
);
12110 index_ptr
= index
->buffer
;
12111 index_end
= index_ptr
+ index
->size
;
12113 version
= read_4_bytes (dbfd
, index_ptr
);
12116 nr_columns
= read_4_bytes (dbfd
, index_ptr
);
12120 nr_units
= read_4_bytes (dbfd
, index_ptr
);
12122 nr_slots
= read_4_bytes (dbfd
, index_ptr
);
12125 if (version
!= 1 && version
!= 2)
12127 error (_("Dwarf Error: unsupported DWP file version (%s)"
12128 " [in module %s]"),
12129 pulongest (version
), dwp_file
->name
);
12131 if (nr_slots
!= (nr_slots
& -nr_slots
))
12133 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12134 " is not power of 2 [in module %s]"),
12135 pulongest (nr_slots
), dwp_file
->name
);
12138 htab
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwp_hash_table
);
12139 htab
->version
= version
;
12140 htab
->nr_columns
= nr_columns
;
12141 htab
->nr_units
= nr_units
;
12142 htab
->nr_slots
= nr_slots
;
12143 htab
->hash_table
= index_ptr
;
12144 htab
->unit_table
= htab
->hash_table
+ sizeof (uint64_t) * nr_slots
;
12146 /* Exit early if the table is empty. */
12147 if (nr_slots
== 0 || nr_units
== 0
12148 || (version
== 2 && nr_columns
== 0))
12150 /* All must be zero. */
12151 if (nr_slots
!= 0 || nr_units
!= 0
12152 || (version
== 2 && nr_columns
!= 0))
12154 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12155 " all zero [in modules %s]"),
12163 htab
->section_pool
.v1
.indices
=
12164 htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
12165 /* It's harder to decide whether the section is too small in v1.
12166 V1 is deprecated anyway so we punt. */
12170 const gdb_byte
*ids_ptr
= htab
->unit_table
+ sizeof (uint32_t) * nr_slots
;
12171 int *ids
= htab
->section_pool
.v2
.section_ids
;
12172 size_t sizeof_ids
= sizeof (htab
->section_pool
.v2
.section_ids
);
12173 /* Reverse map for error checking. */
12174 int ids_seen
[DW_SECT_MAX
+ 1];
12177 if (nr_columns
< 2)
12179 error (_("Dwarf Error: bad DWP hash table, too few columns"
12180 " in section table [in module %s]"),
12183 if (nr_columns
> MAX_NR_V2_DWO_SECTIONS
)
12185 error (_("Dwarf Error: bad DWP hash table, too many columns"
12186 " in section table [in module %s]"),
12189 memset (ids
, 255, sizeof_ids
);
12190 memset (ids_seen
, 255, sizeof (ids_seen
));
12191 for (i
= 0; i
< nr_columns
; ++i
)
12193 int id
= read_4_bytes (dbfd
, ids_ptr
+ i
* sizeof (uint32_t));
12195 if (id
< DW_SECT_MIN
|| id
> DW_SECT_MAX
)
12197 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12198 " in section table [in module %s]"),
12199 id
, dwp_file
->name
);
12201 if (ids_seen
[id
] != -1)
12203 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12204 " id %d in section table [in module %s]"),
12205 id
, dwp_file
->name
);
12210 /* Must have exactly one info or types section. */
12211 if (((ids_seen
[DW_SECT_INFO
] != -1)
12212 + (ids_seen
[DW_SECT_TYPES
] != -1))
12215 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12216 " DWO info/types section [in module %s]"),
12219 /* Must have an abbrev section. */
12220 if (ids_seen
[DW_SECT_ABBREV
] == -1)
12222 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12223 " section [in module %s]"),
12226 htab
->section_pool
.v2
.offsets
= ids_ptr
+ sizeof (uint32_t) * nr_columns
;
12227 htab
->section_pool
.v2
.sizes
=
12228 htab
->section_pool
.v2
.offsets
+ (sizeof (uint32_t)
12229 * nr_units
* nr_columns
);
12230 if ((htab
->section_pool
.v2
.sizes
+ (sizeof (uint32_t)
12231 * nr_units
* nr_columns
))
12234 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12235 " [in module %s]"),
12243 /* Update SECTIONS with the data from SECTP.
12245 This function is like the other "locate" section routines that are
12246 passed to bfd_map_over_sections, but in this context the sections to
12247 read comes from the DWP V1 hash table, not the full ELF section table.
12249 The result is non-zero for success, or zero if an error was found. */
12252 locate_v1_virtual_dwo_sections (asection
*sectp
,
12253 struct virtual_v1_dwo_sections
*sections
)
12255 const struct dwop_section_names
*names
= &dwop_section_names
;
12257 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12259 /* There can be only one. */
12260 if (sections
->abbrev
.s
.section
!= NULL
)
12262 sections
->abbrev
.s
.section
= sectp
;
12263 sections
->abbrev
.size
= bfd_get_section_size (sectp
);
12265 else if (section_is_p (sectp
->name
, &names
->info_dwo
)
12266 || section_is_p (sectp
->name
, &names
->types_dwo
))
12268 /* There can be only one. */
12269 if (sections
->info_or_types
.s
.section
!= NULL
)
12271 sections
->info_or_types
.s
.section
= sectp
;
12272 sections
->info_or_types
.size
= bfd_get_section_size (sectp
);
12274 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12276 /* There can be only one. */
12277 if (sections
->line
.s
.section
!= NULL
)
12279 sections
->line
.s
.section
= sectp
;
12280 sections
->line
.size
= bfd_get_section_size (sectp
);
12282 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12284 /* There can be only one. */
12285 if (sections
->loc
.s
.section
!= NULL
)
12287 sections
->loc
.s
.section
= sectp
;
12288 sections
->loc
.size
= bfd_get_section_size (sectp
);
12290 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12292 /* There can be only one. */
12293 if (sections
->macinfo
.s
.section
!= NULL
)
12295 sections
->macinfo
.s
.section
= sectp
;
12296 sections
->macinfo
.size
= bfd_get_section_size (sectp
);
12298 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12300 /* There can be only one. */
12301 if (sections
->macro
.s
.section
!= NULL
)
12303 sections
->macro
.s
.section
= sectp
;
12304 sections
->macro
.size
= bfd_get_section_size (sectp
);
12306 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12308 /* There can be only one. */
12309 if (sections
->str_offsets
.s
.section
!= NULL
)
12311 sections
->str_offsets
.s
.section
= sectp
;
12312 sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
12316 /* No other kind of section is valid. */
12323 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12324 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12325 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12326 This is for DWP version 1 files. */
12328 static struct dwo_unit
*
12329 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12330 struct dwp_file
*dwp_file
,
12331 uint32_t unit_index
,
12332 const char *comp_dir
,
12333 ULONGEST signature
, int is_debug_types
)
12335 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12336 const struct dwp_hash_table
*dwp_htab
=
12337 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12338 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12339 const char *kind
= is_debug_types
? "TU" : "CU";
12340 struct dwo_file
*dwo_file
;
12341 struct dwo_unit
*dwo_unit
;
12342 struct virtual_v1_dwo_sections sections
;
12343 void **dwo_file_slot
;
12346 gdb_assert (dwp_file
->version
== 1);
12348 if (dwarf_read_debug
)
12350 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V1 file: %s\n",
12352 pulongest (unit_index
), hex_string (signature
),
12356 /* Fetch the sections of this DWO unit.
12357 Put a limit on the number of sections we look for so that bad data
12358 doesn't cause us to loop forever. */
12360 #define MAX_NR_V1_DWO_SECTIONS \
12361 (1 /* .debug_info or .debug_types */ \
12362 + 1 /* .debug_abbrev */ \
12363 + 1 /* .debug_line */ \
12364 + 1 /* .debug_loc */ \
12365 + 1 /* .debug_str_offsets */ \
12366 + 1 /* .debug_macro or .debug_macinfo */ \
12367 + 1 /* trailing zero */)
12369 memset (§ions
, 0, sizeof (sections
));
12371 for (i
= 0; i
< MAX_NR_V1_DWO_SECTIONS
; ++i
)
12374 uint32_t section_nr
=
12375 read_4_bytes (dbfd
,
12376 dwp_htab
->section_pool
.v1
.indices
12377 + (unit_index
+ i
) * sizeof (uint32_t));
12379 if (section_nr
== 0)
12381 if (section_nr
>= dwp_file
->num_sections
)
12383 error (_("Dwarf Error: bad DWP hash table, section number too large"
12384 " [in module %s]"),
12388 sectp
= dwp_file
->elf_sections
[section_nr
];
12389 if (! locate_v1_virtual_dwo_sections (sectp
, §ions
))
12391 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12392 " [in module %s]"),
12398 || dwarf2_section_empty_p (§ions
.info_or_types
)
12399 || dwarf2_section_empty_p (§ions
.abbrev
))
12401 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12402 " [in module %s]"),
12405 if (i
== MAX_NR_V1_DWO_SECTIONS
)
12407 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12408 " [in module %s]"),
12412 /* It's easier for the rest of the code if we fake a struct dwo_file and
12413 have dwo_unit "live" in that. At least for now.
12415 The DWP file can be made up of a random collection of CUs and TUs.
12416 However, for each CU + set of TUs that came from the same original DWO
12417 file, we can combine them back into a virtual DWO file to save space
12418 (fewer struct dwo_file objects to allocate). Remember that for really
12419 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12421 std::string virtual_dwo_name
=
12422 string_printf ("virtual-dwo/%d-%d-%d-%d",
12423 get_section_id (§ions
.abbrev
),
12424 get_section_id (§ions
.line
),
12425 get_section_id (§ions
.loc
),
12426 get_section_id (§ions
.str_offsets
));
12427 /* Can we use an existing virtual DWO file? */
12428 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
12429 virtual_dwo_name
.c_str (),
12431 /* Create one if necessary. */
12432 if (*dwo_file_slot
== NULL
)
12434 if (dwarf_read_debug
)
12436 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12437 virtual_dwo_name
.c_str ());
12439 dwo_file
= new struct dwo_file
;
12441 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
12442 virtual_dwo_name
.c_str (),
12443 virtual_dwo_name
.size ());
12444 dwo_file
->comp_dir
= comp_dir
;
12445 dwo_file
->sections
.abbrev
= sections
.abbrev
;
12446 dwo_file
->sections
.line
= sections
.line
;
12447 dwo_file
->sections
.loc
= sections
.loc
;
12448 dwo_file
->sections
.macinfo
= sections
.macinfo
;
12449 dwo_file
->sections
.macro
= sections
.macro
;
12450 dwo_file
->sections
.str_offsets
= sections
.str_offsets
;
12451 /* The "str" section is global to the entire DWP file. */
12452 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12453 /* The info or types section is assigned below to dwo_unit,
12454 there's no need to record it in dwo_file.
12455 Also, we can't simply record type sections in dwo_file because
12456 we record a pointer into the vector in dwo_unit. As we collect more
12457 types we'll grow the vector and eventually have to reallocate space
12458 for it, invalidating all copies of pointers into the previous
12460 *dwo_file_slot
= dwo_file
;
12464 if (dwarf_read_debug
)
12466 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12467 virtual_dwo_name
.c_str ());
12469 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12472 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12473 dwo_unit
->dwo_file
= dwo_file
;
12474 dwo_unit
->signature
= signature
;
12475 dwo_unit
->section
=
12476 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
12477 *dwo_unit
->section
= sections
.info_or_types
;
12478 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12483 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12484 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12485 piece within that section used by a TU/CU, return a virtual section
12486 of just that piece. */
12488 static struct dwarf2_section_info
12489 create_dwp_v2_section (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12490 struct dwarf2_section_info
*section
,
12491 bfd_size_type offset
, bfd_size_type size
)
12493 struct dwarf2_section_info result
;
12496 gdb_assert (section
!= NULL
);
12497 gdb_assert (!section
->is_virtual
);
12499 memset (&result
, 0, sizeof (result
));
12500 result
.s
.containing_section
= section
;
12501 result
.is_virtual
= true;
12506 sectp
= get_section_bfd_section (section
);
12508 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12509 bounds of the real section. This is a pretty-rare event, so just
12510 flag an error (easier) instead of a warning and trying to cope. */
12512 || offset
+ size
> bfd_get_section_size (sectp
))
12514 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12515 " in section %s [in module %s]"),
12516 sectp
? bfd_section_name (abfd
, sectp
) : "<unknown>",
12517 objfile_name (dwarf2_per_objfile
->objfile
));
12520 result
.virtual_offset
= offset
;
12521 result
.size
= size
;
12525 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12526 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12527 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12528 This is for DWP version 2 files. */
12530 static struct dwo_unit
*
12531 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12532 struct dwp_file
*dwp_file
,
12533 uint32_t unit_index
,
12534 const char *comp_dir
,
12535 ULONGEST signature
, int is_debug_types
)
12537 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
12538 const struct dwp_hash_table
*dwp_htab
=
12539 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12540 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12541 const char *kind
= is_debug_types
? "TU" : "CU";
12542 struct dwo_file
*dwo_file
;
12543 struct dwo_unit
*dwo_unit
;
12544 struct virtual_v2_dwo_sections sections
;
12545 void **dwo_file_slot
;
12548 gdb_assert (dwp_file
->version
== 2);
12550 if (dwarf_read_debug
)
12552 fprintf_unfiltered (gdb_stdlog
, "Reading %s %s/%s in DWP V2 file: %s\n",
12554 pulongest (unit_index
), hex_string (signature
),
12558 /* Fetch the section offsets of this DWO unit. */
12560 memset (§ions
, 0, sizeof (sections
));
12562 for (i
= 0; i
< dwp_htab
->nr_columns
; ++i
)
12564 uint32_t offset
= read_4_bytes (dbfd
,
12565 dwp_htab
->section_pool
.v2
.offsets
12566 + (((unit_index
- 1) * dwp_htab
->nr_columns
12568 * sizeof (uint32_t)));
12569 uint32_t size
= read_4_bytes (dbfd
,
12570 dwp_htab
->section_pool
.v2
.sizes
12571 + (((unit_index
- 1) * dwp_htab
->nr_columns
12573 * sizeof (uint32_t)));
12575 switch (dwp_htab
->section_pool
.v2
.section_ids
[i
])
12578 case DW_SECT_TYPES
:
12579 sections
.info_or_types_offset
= offset
;
12580 sections
.info_or_types_size
= size
;
12582 case DW_SECT_ABBREV
:
12583 sections
.abbrev_offset
= offset
;
12584 sections
.abbrev_size
= size
;
12587 sections
.line_offset
= offset
;
12588 sections
.line_size
= size
;
12591 sections
.loc_offset
= offset
;
12592 sections
.loc_size
= size
;
12594 case DW_SECT_STR_OFFSETS
:
12595 sections
.str_offsets_offset
= offset
;
12596 sections
.str_offsets_size
= size
;
12598 case DW_SECT_MACINFO
:
12599 sections
.macinfo_offset
= offset
;
12600 sections
.macinfo_size
= size
;
12602 case DW_SECT_MACRO
:
12603 sections
.macro_offset
= offset
;
12604 sections
.macro_size
= size
;
12609 /* It's easier for the rest of the code if we fake a struct dwo_file and
12610 have dwo_unit "live" in that. At least for now.
12612 The DWP file can be made up of a random collection of CUs and TUs.
12613 However, for each CU + set of TUs that came from the same original DWO
12614 file, we can combine them back into a virtual DWO file to save space
12615 (fewer struct dwo_file objects to allocate). Remember that for really
12616 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12618 std::string virtual_dwo_name
=
12619 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12620 (long) (sections
.abbrev_size
? sections
.abbrev_offset
: 0),
12621 (long) (sections
.line_size
? sections
.line_offset
: 0),
12622 (long) (sections
.loc_size
? sections
.loc_offset
: 0),
12623 (long) (sections
.str_offsets_size
12624 ? sections
.str_offsets_offset
: 0));
12625 /* Can we use an existing virtual DWO file? */
12626 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
12627 virtual_dwo_name
.c_str (),
12629 /* Create one if necessary. */
12630 if (*dwo_file_slot
== NULL
)
12632 if (dwarf_read_debug
)
12634 fprintf_unfiltered (gdb_stdlog
, "Creating virtual DWO: %s\n",
12635 virtual_dwo_name
.c_str ());
12637 dwo_file
= new struct dwo_file
;
12639 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
12640 virtual_dwo_name
.c_str (),
12641 virtual_dwo_name
.size ());
12642 dwo_file
->comp_dir
= comp_dir
;
12643 dwo_file
->sections
.abbrev
=
12644 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.abbrev
,
12645 sections
.abbrev_offset
, sections
.abbrev_size
);
12646 dwo_file
->sections
.line
=
12647 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.line
,
12648 sections
.line_offset
, sections
.line_size
);
12649 dwo_file
->sections
.loc
=
12650 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.loc
,
12651 sections
.loc_offset
, sections
.loc_size
);
12652 dwo_file
->sections
.macinfo
=
12653 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macinfo
,
12654 sections
.macinfo_offset
, sections
.macinfo_size
);
12655 dwo_file
->sections
.macro
=
12656 create_dwp_v2_section (dwarf2_per_objfile
, &dwp_file
->sections
.macro
,
12657 sections
.macro_offset
, sections
.macro_size
);
12658 dwo_file
->sections
.str_offsets
=
12659 create_dwp_v2_section (dwarf2_per_objfile
,
12660 &dwp_file
->sections
.str_offsets
,
12661 sections
.str_offsets_offset
,
12662 sections
.str_offsets_size
);
12663 /* The "str" section is global to the entire DWP file. */
12664 dwo_file
->sections
.str
= dwp_file
->sections
.str
;
12665 /* The info or types section is assigned below to dwo_unit,
12666 there's no need to record it in dwo_file.
12667 Also, we can't simply record type sections in dwo_file because
12668 we record a pointer into the vector in dwo_unit. As we collect more
12669 types we'll grow the vector and eventually have to reallocate space
12670 for it, invalidating all copies of pointers into the previous
12672 *dwo_file_slot
= dwo_file
;
12676 if (dwarf_read_debug
)
12678 fprintf_unfiltered (gdb_stdlog
, "Using existing virtual DWO: %s\n",
12679 virtual_dwo_name
.c_str ());
12681 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
12684 dwo_unit
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
, struct dwo_unit
);
12685 dwo_unit
->dwo_file
= dwo_file
;
12686 dwo_unit
->signature
= signature
;
12687 dwo_unit
->section
=
12688 XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_section_info
);
12689 *dwo_unit
->section
= create_dwp_v2_section (dwarf2_per_objfile
,
12691 ? &dwp_file
->sections
.types
12692 : &dwp_file
->sections
.info
,
12693 sections
.info_or_types_offset
,
12694 sections
.info_or_types_size
);
12695 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12700 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12701 Returns NULL if the signature isn't found. */
12703 static struct dwo_unit
*
12704 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12705 struct dwp_file
*dwp_file
, const char *comp_dir
,
12706 ULONGEST signature
, int is_debug_types
)
12708 const struct dwp_hash_table
*dwp_htab
=
12709 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
12710 bfd
*dbfd
= dwp_file
->dbfd
.get ();
12711 uint32_t mask
= dwp_htab
->nr_slots
- 1;
12712 uint32_t hash
= signature
& mask
;
12713 uint32_t hash2
= ((signature
>> 32) & mask
) | 1;
12716 struct dwo_unit find_dwo_cu
;
12718 memset (&find_dwo_cu
, 0, sizeof (find_dwo_cu
));
12719 find_dwo_cu
.signature
= signature
;
12720 slot
= htab_find_slot (is_debug_types
12721 ? dwp_file
->loaded_tus
12722 : dwp_file
->loaded_cus
,
12723 &find_dwo_cu
, INSERT
);
12726 return (struct dwo_unit
*) *slot
;
12728 /* Use a for loop so that we don't loop forever on bad debug info. */
12729 for (i
= 0; i
< dwp_htab
->nr_slots
; ++i
)
12731 ULONGEST signature_in_table
;
12733 signature_in_table
=
12734 read_8_bytes (dbfd
, dwp_htab
->hash_table
+ hash
* sizeof (uint64_t));
12735 if (signature_in_table
== signature
)
12737 uint32_t unit_index
=
12738 read_4_bytes (dbfd
,
12739 dwp_htab
->unit_table
+ hash
* sizeof (uint32_t));
12741 if (dwp_file
->version
== 1)
12743 *slot
= create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile
,
12744 dwp_file
, unit_index
,
12745 comp_dir
, signature
,
12750 *slot
= create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile
,
12751 dwp_file
, unit_index
,
12752 comp_dir
, signature
,
12755 return (struct dwo_unit
*) *slot
;
12757 if (signature_in_table
== 0)
12759 hash
= (hash
+ hash2
) & mask
;
12762 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12763 " [in module %s]"),
12767 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12768 Open the file specified by FILE_NAME and hand it off to BFD for
12769 preliminary analysis. Return a newly initialized bfd *, which
12770 includes a canonicalized copy of FILE_NAME.
12771 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12772 SEARCH_CWD is true if the current directory is to be searched.
12773 It will be searched before debug-file-directory.
12774 If successful, the file is added to the bfd include table of the
12775 objfile's bfd (see gdb_bfd_record_inclusion).
12776 If unable to find/open the file, return NULL.
12777 NOTE: This function is derived from symfile_bfd_open. */
12779 static gdb_bfd_ref_ptr
12780 try_open_dwop_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12781 const char *file_name
, int is_dwp
, int search_cwd
)
12784 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12785 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12786 to debug_file_directory. */
12787 const char *search_path
;
12788 static const char dirname_separator_string
[] = { DIRNAME_SEPARATOR
, '\0' };
12790 gdb::unique_xmalloc_ptr
<char> search_path_holder
;
12793 if (*debug_file_directory
!= '\0')
12795 search_path_holder
.reset (concat (".", dirname_separator_string
,
12796 debug_file_directory
,
12798 search_path
= search_path_holder
.get ();
12804 search_path
= debug_file_directory
;
12806 openp_flags flags
= OPF_RETURN_REALPATH
;
12808 flags
|= OPF_SEARCH_IN_PATH
;
12810 gdb::unique_xmalloc_ptr
<char> absolute_name
;
12811 desc
= openp (search_path
, flags
, file_name
,
12812 O_RDONLY
| O_BINARY
, &absolute_name
);
12816 gdb_bfd_ref_ptr
sym_bfd (gdb_bfd_open (absolute_name
.get (),
12818 if (sym_bfd
== NULL
)
12820 bfd_set_cacheable (sym_bfd
.get (), 1);
12822 if (!bfd_check_format (sym_bfd
.get (), bfd_object
))
12825 /* Success. Record the bfd as having been included by the objfile's bfd.
12826 This is important because things like demangled_names_hash lives in the
12827 objfile's per_bfd space and may have references to things like symbol
12828 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12829 gdb_bfd_record_inclusion (dwarf2_per_objfile
->objfile
->obfd
, sym_bfd
.get ());
12834 /* Try to open DWO file FILE_NAME.
12835 COMP_DIR is the DW_AT_comp_dir attribute.
12836 The result is the bfd handle of the file.
12837 If there is a problem finding or opening the file, return NULL.
12838 Upon success, the canonicalized path of the file is stored in the bfd,
12839 same as symfile_bfd_open. */
12841 static gdb_bfd_ref_ptr
12842 open_dwo_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
12843 const char *file_name
, const char *comp_dir
)
12845 if (IS_ABSOLUTE_PATH (file_name
))
12846 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12847 0 /*is_dwp*/, 0 /*search_cwd*/);
12849 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12851 if (comp_dir
!= NULL
)
12853 char *path_to_try
= concat (comp_dir
, SLASH_STRING
,
12854 file_name
, (char *) NULL
);
12856 /* NOTE: If comp_dir is a relative path, this will also try the
12857 search path, which seems useful. */
12858 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
,
12861 1 /*search_cwd*/));
12862 xfree (path_to_try
);
12867 /* That didn't work, try debug-file-directory, which, despite its name,
12868 is a list of paths. */
12870 if (*debug_file_directory
== '\0')
12873 return try_open_dwop_file (dwarf2_per_objfile
, file_name
,
12874 0 /*is_dwp*/, 1 /*search_cwd*/);
12877 /* This function is mapped across the sections and remembers the offset and
12878 size of each of the DWO debugging sections we are interested in. */
12881 dwarf2_locate_dwo_sections (bfd
*abfd
, asection
*sectp
, void *dwo_sections_ptr
)
12883 struct dwo_sections
*dwo_sections
= (struct dwo_sections
*) dwo_sections_ptr
;
12884 const struct dwop_section_names
*names
= &dwop_section_names
;
12886 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
12888 dwo_sections
->abbrev
.s
.section
= sectp
;
12889 dwo_sections
->abbrev
.size
= bfd_get_section_size (sectp
);
12891 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
12893 dwo_sections
->info
.s
.section
= sectp
;
12894 dwo_sections
->info
.size
= bfd_get_section_size (sectp
);
12896 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
12898 dwo_sections
->line
.s
.section
= sectp
;
12899 dwo_sections
->line
.size
= bfd_get_section_size (sectp
);
12901 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
12903 dwo_sections
->loc
.s
.section
= sectp
;
12904 dwo_sections
->loc
.size
= bfd_get_section_size (sectp
);
12906 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
12908 dwo_sections
->macinfo
.s
.section
= sectp
;
12909 dwo_sections
->macinfo
.size
= bfd_get_section_size (sectp
);
12911 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
12913 dwo_sections
->macro
.s
.section
= sectp
;
12914 dwo_sections
->macro
.size
= bfd_get_section_size (sectp
);
12916 else if (section_is_p (sectp
->name
, &names
->str_dwo
))
12918 dwo_sections
->str
.s
.section
= sectp
;
12919 dwo_sections
->str
.size
= bfd_get_section_size (sectp
);
12921 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
12923 dwo_sections
->str_offsets
.s
.section
= sectp
;
12924 dwo_sections
->str_offsets
.size
= bfd_get_section_size (sectp
);
12926 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
12928 struct dwarf2_section_info type_section
;
12930 memset (&type_section
, 0, sizeof (type_section
));
12931 type_section
.s
.section
= sectp
;
12932 type_section
.size
= bfd_get_section_size (sectp
);
12933 dwo_sections
->types
.push_back (type_section
);
12937 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12938 by PER_CU. This is for the non-DWP case.
12939 The result is NULL if DWO_NAME can't be found. */
12941 static struct dwo_file
*
12942 open_and_init_dwo_file (struct dwarf2_per_cu_data
*per_cu
,
12943 const char *dwo_name
, const char *comp_dir
)
12945 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
12947 gdb_bfd_ref_ptr dbfd
= open_dwo_file (dwarf2_per_objfile
, dwo_name
, comp_dir
);
12950 if (dwarf_read_debug
)
12951 fprintf_unfiltered (gdb_stdlog
, "DWO file not found: %s\n", dwo_name
);
12955 dwo_file_up
dwo_file (new struct dwo_file
);
12956 dwo_file
->dwo_name
= dwo_name
;
12957 dwo_file
->comp_dir
= comp_dir
;
12958 dwo_file
->dbfd
= std::move (dbfd
);
12960 bfd_map_over_sections (dwo_file
->dbfd
.get (), dwarf2_locate_dwo_sections
,
12961 &dwo_file
->sections
);
12963 create_cus_hash_table (dwarf2_per_objfile
, *dwo_file
, dwo_file
->sections
.info
,
12966 create_debug_types_hash_table (dwarf2_per_objfile
, dwo_file
.get (),
12967 dwo_file
->sections
.types
, dwo_file
->tus
);
12969 if (dwarf_read_debug
)
12970 fprintf_unfiltered (gdb_stdlog
, "DWO file found: %s\n", dwo_name
);
12972 return dwo_file
.release ();
12975 /* This function is mapped across the sections and remembers the offset and
12976 size of each of the DWP debugging sections common to version 1 and 2 that
12977 we are interested in. */
12980 dwarf2_locate_common_dwp_sections (bfd
*abfd
, asection
*sectp
,
12981 void *dwp_file_ptr
)
12983 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
12984 const struct dwop_section_names
*names
= &dwop_section_names
;
12985 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
12987 /* Record the ELF section number for later lookup: this is what the
12988 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12989 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
12990 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
12992 /* Look for specific sections that we need. */
12993 if (section_is_p (sectp
->name
, &names
->str_dwo
))
12995 dwp_file
->sections
.str
.s
.section
= sectp
;
12996 dwp_file
->sections
.str
.size
= bfd_get_section_size (sectp
);
12998 else if (section_is_p (sectp
->name
, &names
->cu_index
))
13000 dwp_file
->sections
.cu_index
.s
.section
= sectp
;
13001 dwp_file
->sections
.cu_index
.size
= bfd_get_section_size (sectp
);
13003 else if (section_is_p (sectp
->name
, &names
->tu_index
))
13005 dwp_file
->sections
.tu_index
.s
.section
= sectp
;
13006 dwp_file
->sections
.tu_index
.size
= bfd_get_section_size (sectp
);
13010 /* This function is mapped across the sections and remembers the offset and
13011 size of each of the DWP version 2 debugging sections that we are interested
13012 in. This is split into a separate function because we don't know if we
13013 have version 1 or 2 until we parse the cu_index/tu_index sections. */
13016 dwarf2_locate_v2_dwp_sections (bfd
*abfd
, asection
*sectp
, void *dwp_file_ptr
)
13018 struct dwp_file
*dwp_file
= (struct dwp_file
*) dwp_file_ptr
;
13019 const struct dwop_section_names
*names
= &dwop_section_names
;
13020 unsigned int elf_section_nr
= elf_section_data (sectp
)->this_idx
;
13022 /* Record the ELF section number for later lookup: this is what the
13023 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13024 gdb_assert (elf_section_nr
< dwp_file
->num_sections
);
13025 dwp_file
->elf_sections
[elf_section_nr
] = sectp
;
13027 /* Look for specific sections that we need. */
13028 if (section_is_p (sectp
->name
, &names
->abbrev_dwo
))
13030 dwp_file
->sections
.abbrev
.s
.section
= sectp
;
13031 dwp_file
->sections
.abbrev
.size
= bfd_get_section_size (sectp
);
13033 else if (section_is_p (sectp
->name
, &names
->info_dwo
))
13035 dwp_file
->sections
.info
.s
.section
= sectp
;
13036 dwp_file
->sections
.info
.size
= bfd_get_section_size (sectp
);
13038 else if (section_is_p (sectp
->name
, &names
->line_dwo
))
13040 dwp_file
->sections
.line
.s
.section
= sectp
;
13041 dwp_file
->sections
.line
.size
= bfd_get_section_size (sectp
);
13043 else if (section_is_p (sectp
->name
, &names
->loc_dwo
))
13045 dwp_file
->sections
.loc
.s
.section
= sectp
;
13046 dwp_file
->sections
.loc
.size
= bfd_get_section_size (sectp
);
13048 else if (section_is_p (sectp
->name
, &names
->macinfo_dwo
))
13050 dwp_file
->sections
.macinfo
.s
.section
= sectp
;
13051 dwp_file
->sections
.macinfo
.size
= bfd_get_section_size (sectp
);
13053 else if (section_is_p (sectp
->name
, &names
->macro_dwo
))
13055 dwp_file
->sections
.macro
.s
.section
= sectp
;
13056 dwp_file
->sections
.macro
.size
= bfd_get_section_size (sectp
);
13058 else if (section_is_p (sectp
->name
, &names
->str_offsets_dwo
))
13060 dwp_file
->sections
.str_offsets
.s
.section
= sectp
;
13061 dwp_file
->sections
.str_offsets
.size
= bfd_get_section_size (sectp
);
13063 else if (section_is_p (sectp
->name
, &names
->types_dwo
))
13065 dwp_file
->sections
.types
.s
.section
= sectp
;
13066 dwp_file
->sections
.types
.size
= bfd_get_section_size (sectp
);
13070 /* Hash function for dwp_file loaded CUs/TUs. */
13073 hash_dwp_loaded_cutus (const void *item
)
13075 const struct dwo_unit
*dwo_unit
= (const struct dwo_unit
*) item
;
13077 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13078 return dwo_unit
->signature
;
13081 /* Equality function for dwp_file loaded CUs/TUs. */
13084 eq_dwp_loaded_cutus (const void *a
, const void *b
)
13086 const struct dwo_unit
*dua
= (const struct dwo_unit
*) a
;
13087 const struct dwo_unit
*dub
= (const struct dwo_unit
*) b
;
13089 return dua
->signature
== dub
->signature
;
13092 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13095 allocate_dwp_loaded_cutus_table (struct objfile
*objfile
)
13097 return htab_create_alloc_ex (3,
13098 hash_dwp_loaded_cutus
,
13099 eq_dwp_loaded_cutus
,
13101 &objfile
->objfile_obstack
,
13102 hashtab_obstack_allocate
,
13103 dummy_obstack_deallocate
);
13106 /* Try to open DWP file FILE_NAME.
13107 The result is the bfd handle of the file.
13108 If there is a problem finding or opening the file, return NULL.
13109 Upon success, the canonicalized path of the file is stored in the bfd,
13110 same as symfile_bfd_open. */
13112 static gdb_bfd_ref_ptr
13113 open_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
13114 const char *file_name
)
13116 gdb_bfd_ref_ptr
abfd (try_open_dwop_file (dwarf2_per_objfile
, file_name
,
13118 1 /*search_cwd*/));
13122 /* Work around upstream bug 15652.
13123 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13124 [Whether that's a "bug" is debatable, but it is getting in our way.]
13125 We have no real idea where the dwp file is, because gdb's realpath-ing
13126 of the executable's path may have discarded the needed info.
13127 [IWBN if the dwp file name was recorded in the executable, akin to
13128 .gnu_debuglink, but that doesn't exist yet.]
13129 Strip the directory from FILE_NAME and search again. */
13130 if (*debug_file_directory
!= '\0')
13132 /* Don't implicitly search the current directory here.
13133 If the user wants to search "." to handle this case,
13134 it must be added to debug-file-directory. */
13135 return try_open_dwop_file (dwarf2_per_objfile
,
13136 lbasename (file_name
), 1 /*is_dwp*/,
13143 /* Initialize the use of the DWP file for the current objfile.
13144 By convention the name of the DWP file is ${objfile}.dwp.
13145 The result is NULL if it can't be found. */
13147 static std::unique_ptr
<struct dwp_file
>
13148 open_and_init_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
13150 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13152 /* Try to find first .dwp for the binary file before any symbolic links
13155 /* If the objfile is a debug file, find the name of the real binary
13156 file and get the name of dwp file from there. */
13157 std::string dwp_name
;
13158 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
13160 struct objfile
*backlink
= objfile
->separate_debug_objfile_backlink
;
13161 const char *backlink_basename
= lbasename (backlink
->original_name
);
13163 dwp_name
= ldirname (objfile
->original_name
) + SLASH_STRING
+ backlink_basename
;
13166 dwp_name
= objfile
->original_name
;
13168 dwp_name
+= ".dwp";
13170 gdb_bfd_ref_ptr
dbfd (open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ()));
13172 && strcmp (objfile
->original_name
, objfile_name (objfile
)) != 0)
13174 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13175 dwp_name
= objfile_name (objfile
);
13176 dwp_name
+= ".dwp";
13177 dbfd
= open_dwp_file (dwarf2_per_objfile
, dwp_name
.c_str ());
13182 if (dwarf_read_debug
)
13183 fprintf_unfiltered (gdb_stdlog
, "DWP file not found: %s\n", dwp_name
.c_str ());
13184 return std::unique_ptr
<dwp_file
> ();
13187 const char *name
= bfd_get_filename (dbfd
.get ());
13188 std::unique_ptr
<struct dwp_file
> dwp_file
13189 (new struct dwp_file (name
, std::move (dbfd
)));
13191 dwp_file
->num_sections
= elf_numsections (dwp_file
->dbfd
);
13192 dwp_file
->elf_sections
=
13193 OBSTACK_CALLOC (&objfile
->objfile_obstack
,
13194 dwp_file
->num_sections
, asection
*);
13196 bfd_map_over_sections (dwp_file
->dbfd
.get (),
13197 dwarf2_locate_common_dwp_sections
,
13200 dwp_file
->cus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
.get (),
13203 dwp_file
->tus
= create_dwp_hash_table (dwarf2_per_objfile
, dwp_file
.get (),
13206 /* The DWP file version is stored in the hash table. Oh well. */
13207 if (dwp_file
->cus
&& dwp_file
->tus
13208 && dwp_file
->cus
->version
!= dwp_file
->tus
->version
)
13210 /* Technically speaking, we should try to limp along, but this is
13211 pretty bizarre. We use pulongest here because that's the established
13212 portability solution (e.g, we cannot use %u for uint32_t). */
13213 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13214 " TU version %s [in DWP file %s]"),
13215 pulongest (dwp_file
->cus
->version
),
13216 pulongest (dwp_file
->tus
->version
), dwp_name
.c_str ());
13220 dwp_file
->version
= dwp_file
->cus
->version
;
13221 else if (dwp_file
->tus
)
13222 dwp_file
->version
= dwp_file
->tus
->version
;
13224 dwp_file
->version
= 2;
13226 if (dwp_file
->version
== 2)
13227 bfd_map_over_sections (dwp_file
->dbfd
.get (),
13228 dwarf2_locate_v2_dwp_sections
,
13231 dwp_file
->loaded_cus
= allocate_dwp_loaded_cutus_table (objfile
);
13232 dwp_file
->loaded_tus
= allocate_dwp_loaded_cutus_table (objfile
);
13234 if (dwarf_read_debug
)
13236 fprintf_unfiltered (gdb_stdlog
, "DWP file found: %s\n", dwp_file
->name
);
13237 fprintf_unfiltered (gdb_stdlog
,
13238 " %s CUs, %s TUs\n",
13239 pulongest (dwp_file
->cus
? dwp_file
->cus
->nr_units
: 0),
13240 pulongest (dwp_file
->tus
? dwp_file
->tus
->nr_units
: 0));
13246 /* Wrapper around open_and_init_dwp_file, only open it once. */
13248 static struct dwp_file
*
13249 get_dwp_file (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
13251 if (! dwarf2_per_objfile
->dwp_checked
)
13253 dwarf2_per_objfile
->dwp_file
13254 = open_and_init_dwp_file (dwarf2_per_objfile
);
13255 dwarf2_per_objfile
->dwp_checked
= 1;
13257 return dwarf2_per_objfile
->dwp_file
.get ();
13260 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13261 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13262 or in the DWP file for the objfile, referenced by THIS_UNIT.
13263 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13264 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13266 This is called, for example, when wanting to read a variable with a
13267 complex location. Therefore we don't want to do file i/o for every call.
13268 Therefore we don't want to look for a DWO file on every call.
13269 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13270 then we check if we've already seen DWO_NAME, and only THEN do we check
13273 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13274 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13276 static struct dwo_unit
*
13277 lookup_dwo_cutu (struct dwarf2_per_cu_data
*this_unit
,
13278 const char *dwo_name
, const char *comp_dir
,
13279 ULONGEST signature
, int is_debug_types
)
13281 struct dwarf2_per_objfile
*dwarf2_per_objfile
= this_unit
->dwarf2_per_objfile
;
13282 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
13283 const char *kind
= is_debug_types
? "TU" : "CU";
13284 void **dwo_file_slot
;
13285 struct dwo_file
*dwo_file
;
13286 struct dwp_file
*dwp_file
;
13288 /* First see if there's a DWP file.
13289 If we have a DWP file but didn't find the DWO inside it, don't
13290 look for the original DWO file. It makes gdb behave differently
13291 depending on whether one is debugging in the build tree. */
13293 dwp_file
= get_dwp_file (dwarf2_per_objfile
);
13294 if (dwp_file
!= NULL
)
13296 const struct dwp_hash_table
*dwp_htab
=
13297 is_debug_types
? dwp_file
->tus
: dwp_file
->cus
;
13299 if (dwp_htab
!= NULL
)
13301 struct dwo_unit
*dwo_cutu
=
13302 lookup_dwo_unit_in_dwp (dwarf2_per_objfile
, dwp_file
, comp_dir
,
13303 signature
, is_debug_types
);
13305 if (dwo_cutu
!= NULL
)
13307 if (dwarf_read_debug
)
13309 fprintf_unfiltered (gdb_stdlog
,
13310 "Virtual DWO %s %s found: @%s\n",
13311 kind
, hex_string (signature
),
13312 host_address_to_string (dwo_cutu
));
13320 /* No DWP file, look for the DWO file. */
13322 dwo_file_slot
= lookup_dwo_file_slot (dwarf2_per_objfile
,
13323 dwo_name
, comp_dir
);
13324 if (*dwo_file_slot
== NULL
)
13326 /* Read in the file and build a table of the CUs/TUs it contains. */
13327 *dwo_file_slot
= open_and_init_dwo_file (this_unit
, dwo_name
, comp_dir
);
13329 /* NOTE: This will be NULL if unable to open the file. */
13330 dwo_file
= (struct dwo_file
*) *dwo_file_slot
;
13332 if (dwo_file
!= NULL
)
13334 struct dwo_unit
*dwo_cutu
= NULL
;
13336 if (is_debug_types
&& dwo_file
->tus
)
13338 struct dwo_unit find_dwo_cutu
;
13340 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13341 find_dwo_cutu
.signature
= signature
;
13343 = (struct dwo_unit
*) htab_find (dwo_file
->tus
, &find_dwo_cutu
);
13345 else if (!is_debug_types
&& dwo_file
->cus
)
13347 struct dwo_unit find_dwo_cutu
;
13349 memset (&find_dwo_cutu
, 0, sizeof (find_dwo_cutu
));
13350 find_dwo_cutu
.signature
= signature
;
13351 dwo_cutu
= (struct dwo_unit
*)htab_find (dwo_file
->cus
,
13355 if (dwo_cutu
!= NULL
)
13357 if (dwarf_read_debug
)
13359 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) found: @%s\n",
13360 kind
, dwo_name
, hex_string (signature
),
13361 host_address_to_string (dwo_cutu
));
13368 /* We didn't find it. This could mean a dwo_id mismatch, or
13369 someone deleted the DWO/DWP file, or the search path isn't set up
13370 correctly to find the file. */
13372 if (dwarf_read_debug
)
13374 fprintf_unfiltered (gdb_stdlog
, "DWO %s %s(%s) not found\n",
13375 kind
, dwo_name
, hex_string (signature
));
13378 /* This is a warning and not a complaint because it can be caused by
13379 pilot error (e.g., user accidentally deleting the DWO). */
13381 /* Print the name of the DWP file if we looked there, helps the user
13382 better diagnose the problem. */
13383 std::string dwp_text
;
13385 if (dwp_file
!= NULL
)
13386 dwp_text
= string_printf (" [in DWP file %s]",
13387 lbasename (dwp_file
->name
));
13389 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13390 " [in module %s]"),
13391 kind
, dwo_name
, hex_string (signature
),
13393 this_unit
->is_debug_types
? "TU" : "CU",
13394 sect_offset_str (this_unit
->sect_off
), objfile_name (objfile
));
13399 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13400 See lookup_dwo_cutu_unit for details. */
13402 static struct dwo_unit
*
13403 lookup_dwo_comp_unit (struct dwarf2_per_cu_data
*this_cu
,
13404 const char *dwo_name
, const char *comp_dir
,
13405 ULONGEST signature
)
13407 return lookup_dwo_cutu (this_cu
, dwo_name
, comp_dir
, signature
, 0);
13410 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13411 See lookup_dwo_cutu_unit for details. */
13413 static struct dwo_unit
*
13414 lookup_dwo_type_unit (struct signatured_type
*this_tu
,
13415 const char *dwo_name
, const char *comp_dir
)
13417 return lookup_dwo_cutu (&this_tu
->per_cu
, dwo_name
, comp_dir
, this_tu
->signature
, 1);
13420 /* Traversal function for queue_and_load_all_dwo_tus. */
13423 queue_and_load_dwo_tu (void **slot
, void *info
)
13425 struct dwo_unit
*dwo_unit
= (struct dwo_unit
*) *slot
;
13426 struct dwarf2_per_cu_data
*per_cu
= (struct dwarf2_per_cu_data
*) info
;
13427 ULONGEST signature
= dwo_unit
->signature
;
13428 struct signatured_type
*sig_type
=
13429 lookup_dwo_signatured_type (per_cu
->cu
, signature
);
13431 if (sig_type
!= NULL
)
13433 struct dwarf2_per_cu_data
*sig_cu
= &sig_type
->per_cu
;
13435 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13436 a real dependency of PER_CU on SIG_TYPE. That is detected later
13437 while processing PER_CU. */
13438 if (maybe_queue_comp_unit (NULL
, sig_cu
, per_cu
->cu
->language
))
13439 load_full_type_unit (sig_cu
);
13440 VEC_safe_push (dwarf2_per_cu_ptr
, per_cu
->imported_symtabs
, sig_cu
);
13446 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13447 The DWO may have the only definition of the type, though it may not be
13448 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13449 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13452 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data
*per_cu
)
13454 struct dwo_unit
*dwo_unit
;
13455 struct dwo_file
*dwo_file
;
13457 gdb_assert (!per_cu
->is_debug_types
);
13458 gdb_assert (get_dwp_file (per_cu
->dwarf2_per_objfile
) == NULL
);
13459 gdb_assert (per_cu
->cu
!= NULL
);
13461 dwo_unit
= per_cu
->cu
->dwo_unit
;
13462 gdb_assert (dwo_unit
!= NULL
);
13464 dwo_file
= dwo_unit
->dwo_file
;
13465 if (dwo_file
->tus
!= NULL
)
13466 htab_traverse_noresize (dwo_file
->tus
, queue_and_load_dwo_tu
, per_cu
);
13469 /* Read in various DIEs. */
13471 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13472 Inherit only the children of the DW_AT_abstract_origin DIE not being
13473 already referenced by DW_AT_abstract_origin from the children of the
13477 inherit_abstract_dies (struct die_info
*die
, struct dwarf2_cu
*cu
)
13479 struct die_info
*child_die
;
13480 sect_offset
*offsetp
;
13481 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13482 struct die_info
*origin_die
;
13483 /* Iterator of the ORIGIN_DIE children. */
13484 struct die_info
*origin_child_die
;
13485 struct attribute
*attr
;
13486 struct dwarf2_cu
*origin_cu
;
13487 struct pending
**origin_previous_list_in_scope
;
13489 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
13493 /* Note that following die references may follow to a die in a
13497 origin_die
= follow_die_ref (die
, attr
, &origin_cu
);
13499 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13501 origin_previous_list_in_scope
= origin_cu
->list_in_scope
;
13502 origin_cu
->list_in_scope
= cu
->list_in_scope
;
13504 if (die
->tag
!= origin_die
->tag
13505 && !(die
->tag
== DW_TAG_inlined_subroutine
13506 && origin_die
->tag
== DW_TAG_subprogram
))
13507 complaint (_("DIE %s and its abstract origin %s have different tags"),
13508 sect_offset_str (die
->sect_off
),
13509 sect_offset_str (origin_die
->sect_off
));
13511 std::vector
<sect_offset
> offsets
;
13513 for (child_die
= die
->child
;
13514 child_die
&& child_die
->tag
;
13515 child_die
= sibling_die (child_die
))
13517 struct die_info
*child_origin_die
;
13518 struct dwarf2_cu
*child_origin_cu
;
13520 /* We are trying to process concrete instance entries:
13521 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13522 it's not relevant to our analysis here. i.e. detecting DIEs that are
13523 present in the abstract instance but not referenced in the concrete
13525 if (child_die
->tag
== DW_TAG_call_site
13526 || child_die
->tag
== DW_TAG_GNU_call_site
)
13529 /* For each CHILD_DIE, find the corresponding child of
13530 ORIGIN_DIE. If there is more than one layer of
13531 DW_AT_abstract_origin, follow them all; there shouldn't be,
13532 but GCC versions at least through 4.4 generate this (GCC PR
13534 child_origin_die
= child_die
;
13535 child_origin_cu
= cu
;
13538 attr
= dwarf2_attr (child_origin_die
, DW_AT_abstract_origin
,
13542 child_origin_die
= follow_die_ref (child_origin_die
, attr
,
13546 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13547 counterpart may exist. */
13548 if (child_origin_die
!= child_die
)
13550 if (child_die
->tag
!= child_origin_die
->tag
13551 && !(child_die
->tag
== DW_TAG_inlined_subroutine
13552 && child_origin_die
->tag
== DW_TAG_subprogram
))
13553 complaint (_("Child DIE %s and its abstract origin %s have "
13555 sect_offset_str (child_die
->sect_off
),
13556 sect_offset_str (child_origin_die
->sect_off
));
13557 if (child_origin_die
->parent
!= origin_die
)
13558 complaint (_("Child DIE %s and its abstract origin %s have "
13559 "different parents"),
13560 sect_offset_str (child_die
->sect_off
),
13561 sect_offset_str (child_origin_die
->sect_off
));
13563 offsets
.push_back (child_origin_die
->sect_off
);
13566 std::sort (offsets
.begin (), offsets
.end ());
13567 sect_offset
*offsets_end
= offsets
.data () + offsets
.size ();
13568 for (offsetp
= offsets
.data () + 1; offsetp
< offsets_end
; offsetp
++)
13569 if (offsetp
[-1] == *offsetp
)
13570 complaint (_("Multiple children of DIE %s refer "
13571 "to DIE %s as their abstract origin"),
13572 sect_offset_str (die
->sect_off
), sect_offset_str (*offsetp
));
13574 offsetp
= offsets
.data ();
13575 origin_child_die
= origin_die
->child
;
13576 while (origin_child_die
&& origin_child_die
->tag
)
13578 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13579 while (offsetp
< offsets_end
13580 && *offsetp
< origin_child_die
->sect_off
)
13582 if (offsetp
>= offsets_end
13583 || *offsetp
> origin_child_die
->sect_off
)
13585 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13586 Check whether we're already processing ORIGIN_CHILD_DIE.
13587 This can happen with mutually referenced abstract_origins.
13589 if (!origin_child_die
->in_process
)
13590 process_die (origin_child_die
, origin_cu
);
13592 origin_child_die
= sibling_die (origin_child_die
);
13594 origin_cu
->list_in_scope
= origin_previous_list_in_scope
;
13598 read_func_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13600 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13601 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13602 struct context_stack
*newobj
;
13605 struct die_info
*child_die
;
13606 struct attribute
*attr
, *call_line
, *call_file
;
13608 CORE_ADDR baseaddr
;
13609 struct block
*block
;
13610 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
13611 std::vector
<struct symbol
*> template_args
;
13612 struct template_symbol
*templ_func
= NULL
;
13616 /* If we do not have call site information, we can't show the
13617 caller of this inlined function. That's too confusing, so
13618 only use the scope for local variables. */
13619 call_line
= dwarf2_attr (die
, DW_AT_call_line
, cu
);
13620 call_file
= dwarf2_attr (die
, DW_AT_call_file
, cu
);
13621 if (call_line
== NULL
|| call_file
== NULL
)
13623 read_lexical_block_scope (die
, cu
);
13628 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13630 name
= dwarf2_name (die
, cu
);
13632 /* Ignore functions with missing or empty names. These are actually
13633 illegal according to the DWARF standard. */
13636 complaint (_("missing name for subprogram DIE at %s"),
13637 sect_offset_str (die
->sect_off
));
13641 /* Ignore functions with missing or invalid low and high pc attributes. */
13642 if (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
)
13643 <= PC_BOUNDS_INVALID
)
13645 attr
= dwarf2_attr (die
, DW_AT_external
, cu
);
13646 if (!attr
|| !DW_UNSND (attr
))
13647 complaint (_("cannot get low and high bounds "
13648 "for subprogram DIE at %s"),
13649 sect_offset_str (die
->sect_off
));
13653 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13654 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13656 /* If we have any template arguments, then we must allocate a
13657 different sort of symbol. */
13658 for (child_die
= die
->child
; child_die
; child_die
= sibling_die (child_die
))
13660 if (child_die
->tag
== DW_TAG_template_type_param
13661 || child_die
->tag
== DW_TAG_template_value_param
)
13663 templ_func
= allocate_template_symbol (objfile
);
13664 templ_func
->subclass
= SYMBOL_TEMPLATE
;
13669 newobj
= cu
->get_builder ()->push_context (0, lowpc
);
13670 newobj
->name
= new_symbol (die
, read_type_die (die
, cu
), cu
,
13671 (struct symbol
*) templ_func
);
13673 if (dwarf2_flag_true_p (die
, DW_AT_main_subprogram
, cu
))
13674 set_objfile_main_name (objfile
, SYMBOL_LINKAGE_NAME (newobj
->name
),
13677 /* If there is a location expression for DW_AT_frame_base, record
13679 attr
= dwarf2_attr (die
, DW_AT_frame_base
, cu
);
13681 dwarf2_symbol_mark_computed (attr
, newobj
->name
, cu
, 1);
13683 /* If there is a location for the static link, record it. */
13684 newobj
->static_link
= NULL
;
13685 attr
= dwarf2_attr (die
, DW_AT_static_link
, cu
);
13688 newobj
->static_link
13689 = XOBNEW (&objfile
->objfile_obstack
, struct dynamic_prop
);
13690 attr_to_dynamic_prop (attr
, die
, cu
, newobj
->static_link
,
13691 dwarf2_per_cu_addr_type (cu
->per_cu
));
13694 cu
->list_in_scope
= cu
->get_builder ()->get_local_symbols ();
13696 if (die
->child
!= NULL
)
13698 child_die
= die
->child
;
13699 while (child_die
&& child_die
->tag
)
13701 if (child_die
->tag
== DW_TAG_template_type_param
13702 || child_die
->tag
== DW_TAG_template_value_param
)
13704 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
13707 template_args
.push_back (arg
);
13710 process_die (child_die
, cu
);
13711 child_die
= sibling_die (child_die
);
13715 inherit_abstract_dies (die
, cu
);
13717 /* If we have a DW_AT_specification, we might need to import using
13718 directives from the context of the specification DIE. See the
13719 comment in determine_prefix. */
13720 if (cu
->language
== language_cplus
13721 && dwarf2_attr (die
, DW_AT_specification
, cu
))
13723 struct dwarf2_cu
*spec_cu
= cu
;
13724 struct die_info
*spec_die
= die_specification (die
, &spec_cu
);
13728 child_die
= spec_die
->child
;
13729 while (child_die
&& child_die
->tag
)
13731 if (child_die
->tag
== DW_TAG_imported_module
)
13732 process_die (child_die
, spec_cu
);
13733 child_die
= sibling_die (child_die
);
13736 /* In some cases, GCC generates specification DIEs that
13737 themselves contain DW_AT_specification attributes. */
13738 spec_die
= die_specification (spec_die
, &spec_cu
);
13742 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13743 /* Make a block for the local symbols within. */
13744 block
= cu
->get_builder ()->finish_block (cstk
.name
, cstk
.old_blocks
,
13745 cstk
.static_link
, lowpc
, highpc
);
13747 /* For C++, set the block's scope. */
13748 if ((cu
->language
== language_cplus
13749 || cu
->language
== language_fortran
13750 || cu
->language
== language_d
13751 || cu
->language
== language_rust
)
13752 && cu
->processing_has_namespace_info
)
13753 block_set_scope (block
, determine_prefix (die
, cu
),
13754 &objfile
->objfile_obstack
);
13756 /* If we have address ranges, record them. */
13757 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13759 gdbarch_make_symbol_special (gdbarch
, cstk
.name
, objfile
);
13761 /* Attach template arguments to function. */
13762 if (!template_args
.empty ())
13764 gdb_assert (templ_func
!= NULL
);
13766 templ_func
->n_template_arguments
= template_args
.size ();
13767 templ_func
->template_arguments
13768 = XOBNEWVEC (&objfile
->objfile_obstack
, struct symbol
*,
13769 templ_func
->n_template_arguments
);
13770 memcpy (templ_func
->template_arguments
,
13771 template_args
.data (),
13772 (templ_func
->n_template_arguments
* sizeof (struct symbol
*)));
13774 /* Make sure that the symtab is set on the new symbols. Even
13775 though they don't appear in this symtab directly, other parts
13776 of gdb assume that symbols do, and this is reasonably
13778 for (symbol
*sym
: template_args
)
13779 symbol_set_symtab (sym
, symbol_symtab (templ_func
));
13782 /* In C++, we can have functions nested inside functions (e.g., when
13783 a function declares a class that has methods). This means that
13784 when we finish processing a function scope, we may need to go
13785 back to building a containing block's symbol lists. */
13786 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13787 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13789 /* If we've finished processing a top-level function, subsequent
13790 symbols go in the file symbol list. */
13791 if (cu
->get_builder ()->outermost_context_p ())
13792 cu
->list_in_scope
= cu
->get_builder ()->get_file_symbols ();
13795 /* Process all the DIES contained within a lexical block scope. Start
13796 a new scope, process the dies, and then close the scope. */
13799 read_lexical_block_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13801 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13802 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13803 CORE_ADDR lowpc
, highpc
;
13804 struct die_info
*child_die
;
13805 CORE_ADDR baseaddr
;
13807 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13809 /* Ignore blocks with missing or invalid low and high pc attributes. */
13810 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13811 as multiple lexical blocks? Handling children in a sane way would
13812 be nasty. Might be easier to properly extend generic blocks to
13813 describe ranges. */
13814 switch (dwarf2_get_pc_bounds (die
, &lowpc
, &highpc
, cu
, NULL
))
13816 case PC_BOUNDS_NOT_PRESENT
:
13817 /* DW_TAG_lexical_block has no attributes, process its children as if
13818 there was no wrapping by that DW_TAG_lexical_block.
13819 GCC does no longer produces such DWARF since GCC r224161. */
13820 for (child_die
= die
->child
;
13821 child_die
!= NULL
&& child_die
->tag
;
13822 child_die
= sibling_die (child_die
))
13823 process_die (child_die
, cu
);
13825 case PC_BOUNDS_INVALID
:
13828 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
13829 highpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, highpc
+ baseaddr
);
13831 cu
->get_builder ()->push_context (0, lowpc
);
13832 if (die
->child
!= NULL
)
13834 child_die
= die
->child
;
13835 while (child_die
&& child_die
->tag
)
13837 process_die (child_die
, cu
);
13838 child_die
= sibling_die (child_die
);
13841 inherit_abstract_dies (die
, cu
);
13842 struct context_stack cstk
= cu
->get_builder ()->pop_context ();
13844 if (*cu
->get_builder ()->get_local_symbols () != NULL
13845 || (*cu
->get_builder ()->get_local_using_directives ()) != NULL
)
13847 struct block
*block
13848 = cu
->get_builder ()->finish_block (0, cstk
.old_blocks
, NULL
,
13849 cstk
.start_addr
, highpc
);
13851 /* Note that recording ranges after traversing children, as we
13852 do here, means that recording a parent's ranges entails
13853 walking across all its children's ranges as they appear in
13854 the address map, which is quadratic behavior.
13856 It would be nicer to record the parent's ranges before
13857 traversing its children, simply overriding whatever you find
13858 there. But since we don't even decide whether to create a
13859 block until after we've traversed its children, that's hard
13861 dwarf2_record_block_ranges (die
, block
, baseaddr
, cu
);
13863 *cu
->get_builder ()->get_local_symbols () = cstk
.locals
;
13864 cu
->get_builder ()->set_local_using_directives (cstk
.local_using_directives
);
13867 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13870 read_call_site_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
13872 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
13873 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
13874 CORE_ADDR pc
, baseaddr
;
13875 struct attribute
*attr
;
13876 struct call_site
*call_site
, call_site_local
;
13879 struct die_info
*child_die
;
13881 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
13883 attr
= dwarf2_attr (die
, DW_AT_call_return_pc
, cu
);
13886 /* This was a pre-DWARF-5 GNU extension alias
13887 for DW_AT_call_return_pc. */
13888 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
13892 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13893 "DIE %s [in module %s]"),
13894 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13897 pc
= attr_value_as_address (attr
) + baseaddr
;
13898 pc
= gdbarch_adjust_dwarf2_addr (gdbarch
, pc
);
13900 if (cu
->call_site_htab
== NULL
)
13901 cu
->call_site_htab
= htab_create_alloc_ex (16, core_addr_hash
, core_addr_eq
,
13902 NULL
, &objfile
->objfile_obstack
,
13903 hashtab_obstack_allocate
, NULL
);
13904 call_site_local
.pc
= pc
;
13905 slot
= htab_find_slot (cu
->call_site_htab
, &call_site_local
, INSERT
);
13908 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13909 "DIE %s [in module %s]"),
13910 paddress (gdbarch
, pc
), sect_offset_str (die
->sect_off
),
13911 objfile_name (objfile
));
13915 /* Count parameters at the caller. */
13918 for (child_die
= die
->child
; child_die
&& child_die
->tag
;
13919 child_die
= sibling_die (child_die
))
13921 if (child_die
->tag
!= DW_TAG_call_site_parameter
13922 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
13924 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13925 "DW_TAG_call_site child DIE %s [in module %s]"),
13926 child_die
->tag
, sect_offset_str (child_die
->sect_off
),
13927 objfile_name (objfile
));
13935 = ((struct call_site
*)
13936 obstack_alloc (&objfile
->objfile_obstack
,
13937 sizeof (*call_site
)
13938 + (sizeof (*call_site
->parameter
) * (nparams
- 1))));
13940 memset (call_site
, 0, sizeof (*call_site
) - sizeof (*call_site
->parameter
));
13941 call_site
->pc
= pc
;
13943 if (dwarf2_flag_true_p (die
, DW_AT_call_tail_call
, cu
)
13944 || dwarf2_flag_true_p (die
, DW_AT_GNU_tail_call
, cu
))
13946 struct die_info
*func_die
;
13948 /* Skip also over DW_TAG_inlined_subroutine. */
13949 for (func_die
= die
->parent
;
13950 func_die
&& func_die
->tag
!= DW_TAG_subprogram
13951 && func_die
->tag
!= DW_TAG_subroutine_type
;
13952 func_die
= func_die
->parent
);
13954 /* DW_AT_call_all_calls is a superset
13955 of DW_AT_call_all_tail_calls. */
13957 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_calls
, cu
)
13958 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_call_sites
, cu
)
13959 && !dwarf2_flag_true_p (func_die
, DW_AT_call_all_tail_calls
, cu
)
13960 && !dwarf2_flag_true_p (func_die
, DW_AT_GNU_all_tail_call_sites
, cu
))
13962 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13963 not complete. But keep CALL_SITE for look ups via call_site_htab,
13964 both the initial caller containing the real return address PC and
13965 the final callee containing the current PC of a chain of tail
13966 calls do not need to have the tail call list complete. But any
13967 function candidate for a virtual tail call frame searched via
13968 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13969 determined unambiguously. */
13973 struct type
*func_type
= NULL
;
13976 func_type
= get_die_type (func_die
, cu
);
13977 if (func_type
!= NULL
)
13979 gdb_assert (TYPE_CODE (func_type
) == TYPE_CODE_FUNC
);
13981 /* Enlist this call site to the function. */
13982 call_site
->tail_call_next
= TYPE_TAIL_CALL_LIST (func_type
);
13983 TYPE_TAIL_CALL_LIST (func_type
) = call_site
;
13986 complaint (_("Cannot find function owning DW_TAG_call_site "
13987 "DIE %s [in module %s]"),
13988 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
13992 attr
= dwarf2_attr (die
, DW_AT_call_target
, cu
);
13994 attr
= dwarf2_attr (die
, DW_AT_GNU_call_site_target
, cu
);
13996 attr
= dwarf2_attr (die
, DW_AT_call_origin
, cu
);
13999 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
14000 attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14002 SET_FIELD_DWARF_BLOCK (call_site
->target
, NULL
);
14003 if (!attr
|| (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0))
14004 /* Keep NULL DWARF_BLOCK. */;
14005 else if (attr_form_is_block (attr
))
14007 struct dwarf2_locexpr_baton
*dlbaton
;
14009 dlbaton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
14010 dlbaton
->data
= DW_BLOCK (attr
)->data
;
14011 dlbaton
->size
= DW_BLOCK (attr
)->size
;
14012 dlbaton
->per_cu
= cu
->per_cu
;
14014 SET_FIELD_DWARF_BLOCK (call_site
->target
, dlbaton
);
14016 else if (attr_form_is_ref (attr
))
14018 struct dwarf2_cu
*target_cu
= cu
;
14019 struct die_info
*target_die
;
14021 target_die
= follow_die_ref (die
, attr
, &target_cu
);
14022 gdb_assert (target_cu
->per_cu
->dwarf2_per_objfile
->objfile
== objfile
);
14023 if (die_is_declaration (target_die
, target_cu
))
14025 const char *target_physname
;
14027 /* Prefer the mangled name; otherwise compute the demangled one. */
14028 target_physname
= dw2_linkage_name (target_die
, target_cu
);
14029 if (target_physname
== NULL
)
14030 target_physname
= dwarf2_physname (NULL
, target_die
, target_cu
);
14031 if (target_physname
== NULL
)
14032 complaint (_("DW_AT_call_target target DIE has invalid "
14033 "physname, for referencing DIE %s [in module %s]"),
14034 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14036 SET_FIELD_PHYSNAME (call_site
->target
, target_physname
);
14042 /* DW_AT_entry_pc should be preferred. */
14043 if (dwarf2_get_pc_bounds (target_die
, &lowpc
, NULL
, target_cu
, NULL
)
14044 <= PC_BOUNDS_INVALID
)
14045 complaint (_("DW_AT_call_target target DIE has invalid "
14046 "low pc, for referencing DIE %s [in module %s]"),
14047 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14050 lowpc
= gdbarch_adjust_dwarf2_addr (gdbarch
, lowpc
+ baseaddr
);
14051 SET_FIELD_PHYSADDR (call_site
->target
, lowpc
);
14056 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14057 "block nor reference, for DIE %s [in module %s]"),
14058 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
14060 call_site
->per_cu
= cu
->per_cu
;
14062 for (child_die
= die
->child
;
14063 child_die
&& child_die
->tag
;
14064 child_die
= sibling_die (child_die
))
14066 struct call_site_parameter
*parameter
;
14067 struct attribute
*loc
, *origin
;
14069 if (child_die
->tag
!= DW_TAG_call_site_parameter
14070 && child_die
->tag
!= DW_TAG_GNU_call_site_parameter
)
14072 /* Already printed the complaint above. */
14076 gdb_assert (call_site
->parameter_count
< nparams
);
14077 parameter
= &call_site
->parameter
[call_site
->parameter_count
];
14079 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14080 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14081 register is contained in DW_AT_call_value. */
14083 loc
= dwarf2_attr (child_die
, DW_AT_location
, cu
);
14084 origin
= dwarf2_attr (child_die
, DW_AT_call_parameter
, cu
);
14085 if (origin
== NULL
)
14087 /* This was a pre-DWARF-5 GNU extension alias
14088 for DW_AT_call_parameter. */
14089 origin
= dwarf2_attr (child_die
, DW_AT_abstract_origin
, cu
);
14091 if (loc
== NULL
&& origin
!= NULL
&& attr_form_is_ref (origin
))
14093 parameter
->kind
= CALL_SITE_PARAMETER_PARAM_OFFSET
;
14095 sect_offset sect_off
14096 = (sect_offset
) dwarf2_get_ref_die_offset (origin
);
14097 if (!offset_in_cu_p (&cu
->header
, sect_off
))
14099 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14100 binding can be done only inside one CU. Such referenced DIE
14101 therefore cannot be even moved to DW_TAG_partial_unit. */
14102 complaint (_("DW_AT_call_parameter offset is not in CU for "
14103 "DW_TAG_call_site child DIE %s [in module %s]"),
14104 sect_offset_str (child_die
->sect_off
),
14105 objfile_name (objfile
));
14108 parameter
->u
.param_cu_off
14109 = (cu_offset
) (sect_off
- cu
->header
.sect_off
);
14111 else if (loc
== NULL
|| origin
!= NULL
|| !attr_form_is_block (loc
))
14113 complaint (_("No DW_FORM_block* DW_AT_location for "
14114 "DW_TAG_call_site child DIE %s [in module %s]"),
14115 sect_offset_str (child_die
->sect_off
), objfile_name (objfile
));
14120 parameter
->u
.dwarf_reg
= dwarf_block_to_dwarf_reg
14121 (DW_BLOCK (loc
)->data
, &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
]);
14122 if (parameter
->u
.dwarf_reg
!= -1)
14123 parameter
->kind
= CALL_SITE_PARAMETER_DWARF_REG
;
14124 else if (dwarf_block_to_sp_offset (gdbarch
, DW_BLOCK (loc
)->data
,
14125 &DW_BLOCK (loc
)->data
[DW_BLOCK (loc
)->size
],
14126 ¶meter
->u
.fb_offset
))
14127 parameter
->kind
= CALL_SITE_PARAMETER_FB_OFFSET
;
14130 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14131 "for DW_FORM_block* DW_AT_location is supported for "
14132 "DW_TAG_call_site child DIE %s "
14134 sect_offset_str (child_die
->sect_off
),
14135 objfile_name (objfile
));
14140 attr
= dwarf2_attr (child_die
, DW_AT_call_value
, cu
);
14142 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_value
, cu
);
14143 if (!attr_form_is_block (attr
))
14145 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14146 "DW_TAG_call_site child DIE %s [in module %s]"),
14147 sect_offset_str (child_die
->sect_off
),
14148 objfile_name (objfile
));
14151 parameter
->value
= DW_BLOCK (attr
)->data
;
14152 parameter
->value_size
= DW_BLOCK (attr
)->size
;
14154 /* Parameters are not pre-cleared by memset above. */
14155 parameter
->data_value
= NULL
;
14156 parameter
->data_value_size
= 0;
14157 call_site
->parameter_count
++;
14159 attr
= dwarf2_attr (child_die
, DW_AT_call_data_value
, cu
);
14161 attr
= dwarf2_attr (child_die
, DW_AT_GNU_call_site_data_value
, cu
);
14164 if (!attr_form_is_block (attr
))
14165 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14166 "DW_TAG_call_site child DIE %s [in module %s]"),
14167 sect_offset_str (child_die
->sect_off
),
14168 objfile_name (objfile
));
14171 parameter
->data_value
= DW_BLOCK (attr
)->data
;
14172 parameter
->data_value_size
= DW_BLOCK (attr
)->size
;
14178 /* Helper function for read_variable. If DIE represents a virtual
14179 table, then return the type of the concrete object that is
14180 associated with the virtual table. Otherwise, return NULL. */
14182 static struct type
*
14183 rust_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
14185 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
14189 /* Find the type DIE. */
14190 struct die_info
*type_die
= NULL
;
14191 struct dwarf2_cu
*type_cu
= cu
;
14193 if (attr_form_is_ref (attr
))
14194 type_die
= follow_die_ref (die
, attr
, &type_cu
);
14195 if (type_die
== NULL
)
14198 if (dwarf2_attr (type_die
, DW_AT_containing_type
, type_cu
) == NULL
)
14200 return die_containing_type (type_die
, type_cu
);
14203 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14206 read_variable (struct die_info
*die
, struct dwarf2_cu
*cu
)
14208 struct rust_vtable_symbol
*storage
= NULL
;
14210 if (cu
->language
== language_rust
)
14212 struct type
*containing_type
= rust_containing_type (die
, cu
);
14214 if (containing_type
!= NULL
)
14216 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14218 storage
= OBSTACK_ZALLOC (&objfile
->objfile_obstack
,
14219 struct rust_vtable_symbol
);
14220 initialize_objfile_symbol (storage
);
14221 storage
->concrete_type
= containing_type
;
14222 storage
->subclass
= SYMBOL_RUST_VTABLE
;
14226 struct symbol
*res
= new_symbol (die
, NULL
, cu
, storage
);
14227 struct attribute
*abstract_origin
14228 = dwarf2_attr (die
, DW_AT_abstract_origin
, cu
);
14229 struct attribute
*loc
= dwarf2_attr (die
, DW_AT_location
, cu
);
14230 if (res
== NULL
&& loc
&& abstract_origin
)
14232 /* We have a variable without a name, but with a location and an abstract
14233 origin. This may be a concrete instance of an abstract variable
14234 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14236 struct dwarf2_cu
*origin_cu
= cu
;
14237 struct die_info
*origin_die
14238 = follow_die_ref (die
, abstract_origin
, &origin_cu
);
14239 dwarf2_per_objfile
*dpo
= cu
->per_cu
->dwarf2_per_objfile
;
14240 dpo
->abstract_to_concrete
[origin_die
->sect_off
].push_back (die
->sect_off
);
14244 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14245 reading .debug_rnglists.
14246 Callback's type should be:
14247 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14248 Return true if the attributes are present and valid, otherwise,
14251 template <typename Callback
>
14253 dwarf2_rnglists_process (unsigned offset
, struct dwarf2_cu
*cu
,
14254 Callback
&&callback
)
14256 struct dwarf2_per_objfile
*dwarf2_per_objfile
14257 = cu
->per_cu
->dwarf2_per_objfile
;
14258 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14259 bfd
*obfd
= objfile
->obfd
;
14260 /* Base address selection entry. */
14263 const gdb_byte
*buffer
;
14264 CORE_ADDR baseaddr
;
14265 bool overflow
= false;
14267 found_base
= cu
->base_known
;
14268 base
= cu
->base_address
;
14270 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->rnglists
);
14271 if (offset
>= dwarf2_per_objfile
->rnglists
.size
)
14273 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14277 buffer
= dwarf2_per_objfile
->rnglists
.buffer
+ offset
;
14279 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14283 /* Initialize it due to a false compiler warning. */
14284 CORE_ADDR range_beginning
= 0, range_end
= 0;
14285 const gdb_byte
*buf_end
= (dwarf2_per_objfile
->rnglists
.buffer
14286 + dwarf2_per_objfile
->rnglists
.size
);
14287 unsigned int bytes_read
;
14289 if (buffer
== buf_end
)
14294 const auto rlet
= static_cast<enum dwarf_range_list_entry
>(*buffer
++);
14297 case DW_RLE_end_of_list
:
14299 case DW_RLE_base_address
:
14300 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14305 base
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14307 buffer
+= bytes_read
;
14309 case DW_RLE_start_length
:
14310 if (buffer
+ cu
->header
.addr_size
> buf_end
)
14315 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14316 buffer
+= bytes_read
;
14317 range_end
= (range_beginning
14318 + read_unsigned_leb128 (obfd
, buffer
, &bytes_read
));
14319 buffer
+= bytes_read
;
14320 if (buffer
> buf_end
)
14326 case DW_RLE_offset_pair
:
14327 range_beginning
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14328 buffer
+= bytes_read
;
14329 if (buffer
> buf_end
)
14334 range_end
= read_unsigned_leb128 (obfd
, buffer
, &bytes_read
);
14335 buffer
+= bytes_read
;
14336 if (buffer
> buf_end
)
14342 case DW_RLE_start_end
:
14343 if (buffer
+ 2 * cu
->header
.addr_size
> buf_end
)
14348 range_beginning
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14349 buffer
+= bytes_read
;
14350 range_end
= read_address (obfd
, buffer
, cu
, &bytes_read
);
14351 buffer
+= bytes_read
;
14354 complaint (_("Invalid .debug_rnglists data (no base address)"));
14357 if (rlet
== DW_RLE_end_of_list
|| overflow
)
14359 if (rlet
== DW_RLE_base_address
)
14364 /* We have no valid base address for the ranges
14366 complaint (_("Invalid .debug_rnglists data (no base address)"));
14370 if (range_beginning
> range_end
)
14372 /* Inverted range entries are invalid. */
14373 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14377 /* Empty range entries have no effect. */
14378 if (range_beginning
== range_end
)
14381 range_beginning
+= base
;
14384 /* A not-uncommon case of bad debug info.
14385 Don't pollute the addrmap with bad data. */
14386 if (range_beginning
+ baseaddr
== 0
14387 && !dwarf2_per_objfile
->has_section_at_zero
)
14389 complaint (_(".debug_rnglists entry has start address of zero"
14390 " [in module %s]"), objfile_name (objfile
));
14394 callback (range_beginning
, range_end
);
14399 complaint (_("Offset %d is not terminated "
14400 "for DW_AT_ranges attribute"),
14408 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14409 Callback's type should be:
14410 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14411 Return 1 if the attributes are present and valid, otherwise, return 0. */
14413 template <typename Callback
>
14415 dwarf2_ranges_process (unsigned offset
, struct dwarf2_cu
*cu
,
14416 Callback
&&callback
)
14418 struct dwarf2_per_objfile
*dwarf2_per_objfile
14419 = cu
->per_cu
->dwarf2_per_objfile
;
14420 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
14421 struct comp_unit_head
*cu_header
= &cu
->header
;
14422 bfd
*obfd
= objfile
->obfd
;
14423 unsigned int addr_size
= cu_header
->addr_size
;
14424 CORE_ADDR mask
= ~(~(CORE_ADDR
)1 << (addr_size
* 8 - 1));
14425 /* Base address selection entry. */
14428 unsigned int dummy
;
14429 const gdb_byte
*buffer
;
14430 CORE_ADDR baseaddr
;
14432 if (cu_header
->version
>= 5)
14433 return dwarf2_rnglists_process (offset
, cu
, callback
);
14435 found_base
= cu
->base_known
;
14436 base
= cu
->base_address
;
14438 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->ranges
);
14439 if (offset
>= dwarf2_per_objfile
->ranges
.size
)
14441 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14445 buffer
= dwarf2_per_objfile
->ranges
.buffer
+ offset
;
14447 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
14451 CORE_ADDR range_beginning
, range_end
;
14453 range_beginning
= read_address (obfd
, buffer
, cu
, &dummy
);
14454 buffer
+= addr_size
;
14455 range_end
= read_address (obfd
, buffer
, cu
, &dummy
);
14456 buffer
+= addr_size
;
14457 offset
+= 2 * addr_size
;
14459 /* An end of list marker is a pair of zero addresses. */
14460 if (range_beginning
== 0 && range_end
== 0)
14461 /* Found the end of list entry. */
14464 /* Each base address selection entry is a pair of 2 values.
14465 The first is the largest possible address, the second is
14466 the base address. Check for a base address here. */
14467 if ((range_beginning
& mask
) == mask
)
14469 /* If we found the largest possible address, then we already
14470 have the base address in range_end. */
14478 /* We have no valid base address for the ranges
14480 complaint (_("Invalid .debug_ranges data (no base address)"));
14484 if (range_beginning
> range_end
)
14486 /* Inverted range entries are invalid. */
14487 complaint (_("Invalid .debug_ranges data (inverted range)"));
14491 /* Empty range entries have no effect. */
14492 if (range_beginning
== range_end
)
14495 range_beginning
+= base
;
14498 /* A not-uncommon case of bad debug info.
14499 Don't pollute the addrmap with bad data. */
14500 if (range_beginning
+ baseaddr
== 0
14501 && !dwarf2_per_objfile
->has_section_at_zero
)
14503 complaint (_(".debug_ranges entry has start address of zero"
14504 " [in module %s]"), objfile_name (objfile
));
14508 callback (range_beginning
, range_end
);
14514 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14515 Return 1 if the attributes are present and valid, otherwise, return 0.
14516 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14519 dwarf2_ranges_read (unsigned offset
, CORE_ADDR
*low_return
,
14520 CORE_ADDR
*high_return
, struct dwarf2_cu
*cu
,
14521 struct partial_symtab
*ranges_pst
)
14523 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14524 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14525 const CORE_ADDR baseaddr
= ANOFFSET (objfile
->section_offsets
,
14526 SECT_OFF_TEXT (objfile
));
14529 CORE_ADDR high
= 0;
14532 retval
= dwarf2_ranges_process (offset
, cu
,
14533 [&] (CORE_ADDR range_beginning
, CORE_ADDR range_end
)
14535 if (ranges_pst
!= NULL
)
14540 lowpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14541 range_beginning
+ baseaddr
)
14543 highpc
= (gdbarch_adjust_dwarf2_addr (gdbarch
,
14544 range_end
+ baseaddr
)
14546 addrmap_set_empty (objfile
->partial_symtabs
->psymtabs_addrmap
,
14547 lowpc
, highpc
- 1, ranges_pst
);
14550 /* FIXME: This is recording everything as a low-high
14551 segment of consecutive addresses. We should have a
14552 data structure for discontiguous block ranges
14556 low
= range_beginning
;
14562 if (range_beginning
< low
)
14563 low
= range_beginning
;
14564 if (range_end
> high
)
14572 /* If the first entry is an end-of-list marker, the range
14573 describes an empty scope, i.e. no instructions. */
14579 *high_return
= high
;
14583 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14584 definition for the return value. *LOWPC and *HIGHPC are set iff
14585 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14587 static enum pc_bounds_kind
14588 dwarf2_get_pc_bounds (struct die_info
*die
, CORE_ADDR
*lowpc
,
14589 CORE_ADDR
*highpc
, struct dwarf2_cu
*cu
,
14590 struct partial_symtab
*pst
)
14592 struct dwarf2_per_objfile
*dwarf2_per_objfile
14593 = cu
->per_cu
->dwarf2_per_objfile
;
14594 struct attribute
*attr
;
14595 struct attribute
*attr_high
;
14597 CORE_ADDR high
= 0;
14598 enum pc_bounds_kind ret
;
14600 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14603 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14606 low
= attr_value_as_address (attr
);
14607 high
= attr_value_as_address (attr_high
);
14608 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
14612 /* Found high w/o low attribute. */
14613 return PC_BOUNDS_INVALID
;
14615 /* Found consecutive range of addresses. */
14616 ret
= PC_BOUNDS_HIGH_LOW
;
14620 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14623 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14624 We take advantage of the fact that DW_AT_ranges does not appear
14625 in DW_TAG_compile_unit of DWO files. */
14626 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
14627 unsigned int ranges_offset
= (DW_UNSND (attr
)
14628 + (need_ranges_base
14632 /* Value of the DW_AT_ranges attribute is the offset in the
14633 .debug_ranges section. */
14634 if (!dwarf2_ranges_read (ranges_offset
, &low
, &high
, cu
, pst
))
14635 return PC_BOUNDS_INVALID
;
14636 /* Found discontinuous range of addresses. */
14637 ret
= PC_BOUNDS_RANGES
;
14640 return PC_BOUNDS_NOT_PRESENT
;
14643 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14645 return PC_BOUNDS_INVALID
;
14647 /* When using the GNU linker, .gnu.linkonce. sections are used to
14648 eliminate duplicate copies of functions and vtables and such.
14649 The linker will arbitrarily choose one and discard the others.
14650 The AT_*_pc values for such functions refer to local labels in
14651 these sections. If the section from that file was discarded, the
14652 labels are not in the output, so the relocs get a value of 0.
14653 If this is a discarded function, mark the pc bounds as invalid,
14654 so that GDB will ignore it. */
14655 if (low
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
14656 return PC_BOUNDS_INVALID
;
14664 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14665 its low and high PC addresses. Do nothing if these addresses could not
14666 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14667 and HIGHPC to the high address if greater than HIGHPC. */
14670 dwarf2_get_subprogram_pc_bounds (struct die_info
*die
,
14671 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14672 struct dwarf2_cu
*cu
)
14674 CORE_ADDR low
, high
;
14675 struct die_info
*child
= die
->child
;
14677 if (dwarf2_get_pc_bounds (die
, &low
, &high
, cu
, NULL
) >= PC_BOUNDS_RANGES
)
14679 *lowpc
= std::min (*lowpc
, low
);
14680 *highpc
= std::max (*highpc
, high
);
14683 /* If the language does not allow nested subprograms (either inside
14684 subprograms or lexical blocks), we're done. */
14685 if (cu
->language
!= language_ada
)
14688 /* Check all the children of the given DIE. If it contains nested
14689 subprograms, then check their pc bounds. Likewise, we need to
14690 check lexical blocks as well, as they may also contain subprogram
14692 while (child
&& child
->tag
)
14694 if (child
->tag
== DW_TAG_subprogram
14695 || child
->tag
== DW_TAG_lexical_block
)
14696 dwarf2_get_subprogram_pc_bounds (child
, lowpc
, highpc
, cu
);
14697 child
= sibling_die (child
);
14701 /* Get the low and high pc's represented by the scope DIE, and store
14702 them in *LOWPC and *HIGHPC. If the correct values can't be
14703 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14706 get_scope_pc_bounds (struct die_info
*die
,
14707 CORE_ADDR
*lowpc
, CORE_ADDR
*highpc
,
14708 struct dwarf2_cu
*cu
)
14710 CORE_ADDR best_low
= (CORE_ADDR
) -1;
14711 CORE_ADDR best_high
= (CORE_ADDR
) 0;
14712 CORE_ADDR current_low
, current_high
;
14714 if (dwarf2_get_pc_bounds (die
, ¤t_low
, ¤t_high
, cu
, NULL
)
14715 >= PC_BOUNDS_RANGES
)
14717 best_low
= current_low
;
14718 best_high
= current_high
;
14722 struct die_info
*child
= die
->child
;
14724 while (child
&& child
->tag
)
14726 switch (child
->tag
) {
14727 case DW_TAG_subprogram
:
14728 dwarf2_get_subprogram_pc_bounds (child
, &best_low
, &best_high
, cu
);
14730 case DW_TAG_namespace
:
14731 case DW_TAG_module
:
14732 /* FIXME: carlton/2004-01-16: Should we do this for
14733 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14734 that current GCC's always emit the DIEs corresponding
14735 to definitions of methods of classes as children of a
14736 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14737 the DIEs giving the declarations, which could be
14738 anywhere). But I don't see any reason why the
14739 standards says that they have to be there. */
14740 get_scope_pc_bounds (child
, ¤t_low
, ¤t_high
, cu
);
14742 if (current_low
!= ((CORE_ADDR
) -1))
14744 best_low
= std::min (best_low
, current_low
);
14745 best_high
= std::max (best_high
, current_high
);
14753 child
= sibling_die (child
);
14758 *highpc
= best_high
;
14761 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14765 dwarf2_record_block_ranges (struct die_info
*die
, struct block
*block
,
14766 CORE_ADDR baseaddr
, struct dwarf2_cu
*cu
)
14768 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14769 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14770 struct attribute
*attr
;
14771 struct attribute
*attr_high
;
14773 attr_high
= dwarf2_attr (die
, DW_AT_high_pc
, cu
);
14776 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
14779 CORE_ADDR low
= attr_value_as_address (attr
);
14780 CORE_ADDR high
= attr_value_as_address (attr_high
);
14782 if (cu
->header
.version
>= 4 && attr_form_is_constant (attr_high
))
14785 low
= gdbarch_adjust_dwarf2_addr (gdbarch
, low
+ baseaddr
);
14786 high
= gdbarch_adjust_dwarf2_addr (gdbarch
, high
+ baseaddr
);
14787 cu
->get_builder ()->record_block_range (block
, low
, high
- 1);
14791 attr
= dwarf2_attr (die
, DW_AT_ranges
, cu
);
14794 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14795 We take advantage of the fact that DW_AT_ranges does not appear
14796 in DW_TAG_compile_unit of DWO files. */
14797 int need_ranges_base
= die
->tag
!= DW_TAG_compile_unit
;
14799 /* The value of the DW_AT_ranges attribute is the offset of the
14800 address range list in the .debug_ranges section. */
14801 unsigned long offset
= (DW_UNSND (attr
)
14802 + (need_ranges_base
? cu
->ranges_base
: 0));
14804 std::vector
<blockrange
> blockvec
;
14805 dwarf2_ranges_process (offset
, cu
,
14806 [&] (CORE_ADDR start
, CORE_ADDR end
)
14810 start
= gdbarch_adjust_dwarf2_addr (gdbarch
, start
);
14811 end
= gdbarch_adjust_dwarf2_addr (gdbarch
, end
);
14812 cu
->get_builder ()->record_block_range (block
, start
, end
- 1);
14813 blockvec
.emplace_back (start
, end
);
14816 BLOCK_RANGES(block
) = make_blockranges (objfile
, blockvec
);
14820 /* Check whether the producer field indicates either of GCC < 4.6, or the
14821 Intel C/C++ compiler, and cache the result in CU. */
14824 check_producer (struct dwarf2_cu
*cu
)
14828 if (cu
->producer
== NULL
)
14830 /* For unknown compilers expect their behavior is DWARF version
14833 GCC started to support .debug_types sections by -gdwarf-4 since
14834 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14835 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14836 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14837 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14839 else if (producer_is_gcc (cu
->producer
, &major
, &minor
))
14841 cu
->producer_is_gxx_lt_4_6
= major
< 4 || (major
== 4 && minor
< 6);
14842 cu
->producer_is_gcc_lt_4_3
= major
< 4 || (major
== 4 && minor
< 3);
14844 else if (producer_is_icc (cu
->producer
, &major
, &minor
))
14846 cu
->producer_is_icc
= true;
14847 cu
->producer_is_icc_lt_14
= major
< 14;
14849 else if (startswith (cu
->producer
, "CodeWarrior S12/L-ISA"))
14850 cu
->producer_is_codewarrior
= true;
14853 /* For other non-GCC compilers, expect their behavior is DWARF version
14857 cu
->checked_producer
= true;
14860 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14861 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14862 during 4.6.0 experimental. */
14865 producer_is_gxx_lt_4_6 (struct dwarf2_cu
*cu
)
14867 if (!cu
->checked_producer
)
14868 check_producer (cu
);
14870 return cu
->producer_is_gxx_lt_4_6
;
14874 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14875 with incorrect is_stmt attributes. */
14878 producer_is_codewarrior (struct dwarf2_cu
*cu
)
14880 if (!cu
->checked_producer
)
14881 check_producer (cu
);
14883 return cu
->producer_is_codewarrior
;
14886 /* Return the default accessibility type if it is not overriden by
14887 DW_AT_accessibility. */
14889 static enum dwarf_access_attribute
14890 dwarf2_default_access_attribute (struct die_info
*die
, struct dwarf2_cu
*cu
)
14892 if (cu
->header
.version
< 3 || producer_is_gxx_lt_4_6 (cu
))
14894 /* The default DWARF 2 accessibility for members is public, the default
14895 accessibility for inheritance is private. */
14897 if (die
->tag
!= DW_TAG_inheritance
)
14898 return DW_ACCESS_public
;
14900 return DW_ACCESS_private
;
14904 /* DWARF 3+ defines the default accessibility a different way. The same
14905 rules apply now for DW_TAG_inheritance as for the members and it only
14906 depends on the container kind. */
14908 if (die
->parent
->tag
== DW_TAG_class_type
)
14909 return DW_ACCESS_private
;
14911 return DW_ACCESS_public
;
14915 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14916 offset. If the attribute was not found return 0, otherwise return
14917 1. If it was found but could not properly be handled, set *OFFSET
14921 handle_data_member_location (struct die_info
*die
, struct dwarf2_cu
*cu
,
14924 struct attribute
*attr
;
14926 attr
= dwarf2_attr (die
, DW_AT_data_member_location
, cu
);
14931 /* Note that we do not check for a section offset first here.
14932 This is because DW_AT_data_member_location is new in DWARF 4,
14933 so if we see it, we can assume that a constant form is really
14934 a constant and not a section offset. */
14935 if (attr_form_is_constant (attr
))
14936 *offset
= dwarf2_get_attr_constant_value (attr
, 0);
14937 else if (attr_form_is_section_offset (attr
))
14938 dwarf2_complex_location_expr_complaint ();
14939 else if (attr_form_is_block (attr
))
14940 *offset
= decode_locdesc (DW_BLOCK (attr
), cu
);
14942 dwarf2_complex_location_expr_complaint ();
14950 /* Add an aggregate field to the field list. */
14953 dwarf2_add_field (struct field_info
*fip
, struct die_info
*die
,
14954 struct dwarf2_cu
*cu
)
14956 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
14957 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
14958 struct nextfield
*new_field
;
14959 struct attribute
*attr
;
14961 const char *fieldname
= "";
14963 if (die
->tag
== DW_TAG_inheritance
)
14965 fip
->baseclasses
.emplace_back ();
14966 new_field
= &fip
->baseclasses
.back ();
14970 fip
->fields
.emplace_back ();
14971 new_field
= &fip
->fields
.back ();
14976 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
14978 new_field
->accessibility
= DW_UNSND (attr
);
14980 new_field
->accessibility
= dwarf2_default_access_attribute (die
, cu
);
14981 if (new_field
->accessibility
!= DW_ACCESS_public
)
14982 fip
->non_public_fields
= 1;
14984 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
14986 new_field
->virtuality
= DW_UNSND (attr
);
14988 new_field
->virtuality
= DW_VIRTUALITY_none
;
14990 fp
= &new_field
->field
;
14992 if (die
->tag
== DW_TAG_member
&& ! die_is_declaration (die
, cu
))
14996 /* Data member other than a C++ static data member. */
14998 /* Get type of field. */
14999 fp
->type
= die_type (die
, cu
);
15001 SET_FIELD_BITPOS (*fp
, 0);
15003 /* Get bit size of field (zero if none). */
15004 attr
= dwarf2_attr (die
, DW_AT_bit_size
, cu
);
15007 FIELD_BITSIZE (*fp
) = DW_UNSND (attr
);
15011 FIELD_BITSIZE (*fp
) = 0;
15014 /* Get bit offset of field. */
15015 if (handle_data_member_location (die
, cu
, &offset
))
15016 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
15017 attr
= dwarf2_attr (die
, DW_AT_bit_offset
, cu
);
15020 if (gdbarch_bits_big_endian (gdbarch
))
15022 /* For big endian bits, the DW_AT_bit_offset gives the
15023 additional bit offset from the MSB of the containing
15024 anonymous object to the MSB of the field. We don't
15025 have to do anything special since we don't need to
15026 know the size of the anonymous object. */
15027 SET_FIELD_BITPOS (*fp
, FIELD_BITPOS (*fp
) + DW_UNSND (attr
));
15031 /* For little endian bits, compute the bit offset to the
15032 MSB of the anonymous object, subtract off the number of
15033 bits from the MSB of the field to the MSB of the
15034 object, and then subtract off the number of bits of
15035 the field itself. The result is the bit offset of
15036 the LSB of the field. */
15037 int anonymous_size
;
15038 int bit_offset
= DW_UNSND (attr
);
15040 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15043 /* The size of the anonymous object containing
15044 the bit field is explicit, so use the
15045 indicated size (in bytes). */
15046 anonymous_size
= DW_UNSND (attr
);
15050 /* The size of the anonymous object containing
15051 the bit field must be inferred from the type
15052 attribute of the data member containing the
15054 anonymous_size
= TYPE_LENGTH (fp
->type
);
15056 SET_FIELD_BITPOS (*fp
,
15057 (FIELD_BITPOS (*fp
)
15058 + anonymous_size
* bits_per_byte
15059 - bit_offset
- FIELD_BITSIZE (*fp
)));
15062 attr
= dwarf2_attr (die
, DW_AT_data_bit_offset
, cu
);
15064 SET_FIELD_BITPOS (*fp
, (FIELD_BITPOS (*fp
)
15065 + dwarf2_get_attr_constant_value (attr
, 0)));
15067 /* Get name of field. */
15068 fieldname
= dwarf2_name (die
, cu
);
15069 if (fieldname
== NULL
)
15072 /* The name is already allocated along with this objfile, so we don't
15073 need to duplicate it for the type. */
15074 fp
->name
= fieldname
;
15076 /* Change accessibility for artificial fields (e.g. virtual table
15077 pointer or virtual base class pointer) to private. */
15078 if (dwarf2_attr (die
, DW_AT_artificial
, cu
))
15080 FIELD_ARTIFICIAL (*fp
) = 1;
15081 new_field
->accessibility
= DW_ACCESS_private
;
15082 fip
->non_public_fields
= 1;
15085 else if (die
->tag
== DW_TAG_member
|| die
->tag
== DW_TAG_variable
)
15087 /* C++ static member. */
15089 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15090 is a declaration, but all versions of G++ as of this writing
15091 (so through at least 3.2.1) incorrectly generate
15092 DW_TAG_variable tags. */
15094 const char *physname
;
15096 /* Get name of field. */
15097 fieldname
= dwarf2_name (die
, cu
);
15098 if (fieldname
== NULL
)
15101 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
15103 /* Only create a symbol if this is an external value.
15104 new_symbol checks this and puts the value in the global symbol
15105 table, which we want. If it is not external, new_symbol
15106 will try to put the value in cu->list_in_scope which is wrong. */
15107 && dwarf2_flag_true_p (die
, DW_AT_external
, cu
))
15109 /* A static const member, not much different than an enum as far as
15110 we're concerned, except that we can support more types. */
15111 new_symbol (die
, NULL
, cu
);
15114 /* Get physical name. */
15115 physname
= dwarf2_physname (fieldname
, die
, cu
);
15117 /* The name is already allocated along with this objfile, so we don't
15118 need to duplicate it for the type. */
15119 SET_FIELD_PHYSNAME (*fp
, physname
? physname
: "");
15120 FIELD_TYPE (*fp
) = die_type (die
, cu
);
15121 FIELD_NAME (*fp
) = fieldname
;
15123 else if (die
->tag
== DW_TAG_inheritance
)
15127 /* C++ base class field. */
15128 if (handle_data_member_location (die
, cu
, &offset
))
15129 SET_FIELD_BITPOS (*fp
, offset
* bits_per_byte
);
15130 FIELD_BITSIZE (*fp
) = 0;
15131 FIELD_TYPE (*fp
) = die_type (die
, cu
);
15132 FIELD_NAME (*fp
) = TYPE_NAME (fp
->type
);
15134 else if (die
->tag
== DW_TAG_variant_part
)
15136 /* process_structure_scope will treat this DIE as a union. */
15137 process_structure_scope (die
, cu
);
15139 /* The variant part is relative to the start of the enclosing
15141 SET_FIELD_BITPOS (*fp
, 0);
15142 fp
->type
= get_die_type (die
, cu
);
15143 fp
->artificial
= 1;
15144 fp
->name
= "<<variant>>";
15146 /* Normally a DW_TAG_variant_part won't have a size, but our
15147 representation requires one, so set it to the maximum of the
15149 if (TYPE_LENGTH (fp
->type
) == 0)
15152 for (int i
= 0; i
< TYPE_NFIELDS (fp
->type
); ++i
)
15153 if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp
->type
, i
)) > max
)
15154 max
= TYPE_LENGTH (TYPE_FIELD_TYPE (fp
->type
, i
));
15155 TYPE_LENGTH (fp
->type
) = max
;
15159 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15162 /* Can the type given by DIE define another type? */
15165 type_can_define_types (const struct die_info
*die
)
15169 case DW_TAG_typedef
:
15170 case DW_TAG_class_type
:
15171 case DW_TAG_structure_type
:
15172 case DW_TAG_union_type
:
15173 case DW_TAG_enumeration_type
:
15181 /* Add a type definition defined in the scope of the FIP's class. */
15184 dwarf2_add_type_defn (struct field_info
*fip
, struct die_info
*die
,
15185 struct dwarf2_cu
*cu
)
15187 struct decl_field fp
;
15188 memset (&fp
, 0, sizeof (fp
));
15190 gdb_assert (type_can_define_types (die
));
15192 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15193 fp
.name
= dwarf2_name (die
, cu
);
15194 fp
.type
= read_type_die (die
, cu
);
15196 /* Save accessibility. */
15197 enum dwarf_access_attribute accessibility
;
15198 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15200 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
15202 accessibility
= dwarf2_default_access_attribute (die
, cu
);
15203 switch (accessibility
)
15205 case DW_ACCESS_public
:
15206 /* The assumed value if neither private nor protected. */
15208 case DW_ACCESS_private
:
15211 case DW_ACCESS_protected
:
15212 fp
.is_protected
= 1;
15215 complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility
);
15218 if (die
->tag
== DW_TAG_typedef
)
15219 fip
->typedef_field_list
.push_back (fp
);
15221 fip
->nested_types_list
.push_back (fp
);
15224 /* Create the vector of fields, and attach it to the type. */
15227 dwarf2_attach_fields_to_type (struct field_info
*fip
, struct type
*type
,
15228 struct dwarf2_cu
*cu
)
15230 int nfields
= fip
->nfields
;
15232 /* Record the field count, allocate space for the array of fields,
15233 and create blank accessibility bitfields if necessary. */
15234 TYPE_NFIELDS (type
) = nfields
;
15235 TYPE_FIELDS (type
) = (struct field
*)
15236 TYPE_ZALLOC (type
, sizeof (struct field
) * nfields
);
15238 if (fip
->non_public_fields
&& cu
->language
!= language_ada
)
15240 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15242 TYPE_FIELD_PRIVATE_BITS (type
) =
15243 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15244 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
15246 TYPE_FIELD_PROTECTED_BITS (type
) =
15247 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15248 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
15250 TYPE_FIELD_IGNORE_BITS (type
) =
15251 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
15252 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
15255 /* If the type has baseclasses, allocate and clear a bit vector for
15256 TYPE_FIELD_VIRTUAL_BITS. */
15257 if (!fip
->baseclasses
.empty () && cu
->language
!= language_ada
)
15259 int num_bytes
= B_BYTES (fip
->baseclasses
.size ());
15260 unsigned char *pointer
;
15262 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15263 pointer
= (unsigned char *) TYPE_ALLOC (type
, num_bytes
);
15264 TYPE_FIELD_VIRTUAL_BITS (type
) = pointer
;
15265 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), fip
->baseclasses
.size ());
15266 TYPE_N_BASECLASSES (type
) = fip
->baseclasses
.size ();
15269 if (TYPE_FLAG_DISCRIMINATED_UNION (type
))
15271 struct discriminant_info
*di
= alloc_discriminant_info (type
, -1, -1);
15273 for (int index
= 0; index
< nfields
; ++index
)
15275 struct nextfield
&field
= fip
->fields
[index
];
15277 if (field
.variant
.is_discriminant
)
15278 di
->discriminant_index
= index
;
15279 else if (field
.variant
.default_branch
)
15280 di
->default_index
= index
;
15282 di
->discriminants
[index
] = field
.variant
.discriminant_value
;
15286 /* Copy the saved-up fields into the field vector. */
15287 for (int i
= 0; i
< nfields
; ++i
)
15289 struct nextfield
&field
15290 = ((i
< fip
->baseclasses
.size ()) ? fip
->baseclasses
[i
]
15291 : fip
->fields
[i
- fip
->baseclasses
.size ()]);
15293 TYPE_FIELD (type
, i
) = field
.field
;
15294 switch (field
.accessibility
)
15296 case DW_ACCESS_private
:
15297 if (cu
->language
!= language_ada
)
15298 SET_TYPE_FIELD_PRIVATE (type
, i
);
15301 case DW_ACCESS_protected
:
15302 if (cu
->language
!= language_ada
)
15303 SET_TYPE_FIELD_PROTECTED (type
, i
);
15306 case DW_ACCESS_public
:
15310 /* Unknown accessibility. Complain and treat it as public. */
15312 complaint (_("unsupported accessibility %d"),
15313 field
.accessibility
);
15317 if (i
< fip
->baseclasses
.size ())
15319 switch (field
.virtuality
)
15321 case DW_VIRTUALITY_virtual
:
15322 case DW_VIRTUALITY_pure_virtual
:
15323 if (cu
->language
== language_ada
)
15324 error (_("unexpected virtuality in component of Ada type"));
15325 SET_TYPE_FIELD_VIRTUAL (type
, i
);
15332 /* Return true if this member function is a constructor, false
15336 dwarf2_is_constructor (struct die_info
*die
, struct dwarf2_cu
*cu
)
15338 const char *fieldname
;
15339 const char *type_name
;
15342 if (die
->parent
== NULL
)
15345 if (die
->parent
->tag
!= DW_TAG_structure_type
15346 && die
->parent
->tag
!= DW_TAG_union_type
15347 && die
->parent
->tag
!= DW_TAG_class_type
)
15350 fieldname
= dwarf2_name (die
, cu
);
15351 type_name
= dwarf2_name (die
->parent
, cu
);
15352 if (fieldname
== NULL
|| type_name
== NULL
)
15355 len
= strlen (fieldname
);
15356 return (strncmp (fieldname
, type_name
, len
) == 0
15357 && (type_name
[len
] == '\0' || type_name
[len
] == '<'));
15360 /* Add a member function to the proper fieldlist. */
15363 dwarf2_add_member_fn (struct field_info
*fip
, struct die_info
*die
,
15364 struct type
*type
, struct dwarf2_cu
*cu
)
15366 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15367 struct attribute
*attr
;
15369 struct fnfieldlist
*flp
= nullptr;
15370 struct fn_field
*fnp
;
15371 const char *fieldname
;
15372 struct type
*this_type
;
15373 enum dwarf_access_attribute accessibility
;
15375 if (cu
->language
== language_ada
)
15376 error (_("unexpected member function in Ada type"));
15378 /* Get name of member function. */
15379 fieldname
= dwarf2_name (die
, cu
);
15380 if (fieldname
== NULL
)
15383 /* Look up member function name in fieldlist. */
15384 for (i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15386 if (strcmp (fip
->fnfieldlists
[i
].name
, fieldname
) == 0)
15388 flp
= &fip
->fnfieldlists
[i
];
15393 /* Create a new fnfieldlist if necessary. */
15394 if (flp
== nullptr)
15396 fip
->fnfieldlists
.emplace_back ();
15397 flp
= &fip
->fnfieldlists
.back ();
15398 flp
->name
= fieldname
;
15399 i
= fip
->fnfieldlists
.size () - 1;
15402 /* Create a new member function field and add it to the vector of
15404 flp
->fnfields
.emplace_back ();
15405 fnp
= &flp
->fnfields
.back ();
15407 /* Delay processing of the physname until later. */
15408 if (cu
->language
== language_cplus
)
15409 add_to_method_list (type
, i
, flp
->fnfields
.size () - 1, fieldname
,
15413 const char *physname
= dwarf2_physname (fieldname
, die
, cu
);
15414 fnp
->physname
= physname
? physname
: "";
15417 fnp
->type
= alloc_type (objfile
);
15418 this_type
= read_type_die (die
, cu
);
15419 if (this_type
&& TYPE_CODE (this_type
) == TYPE_CODE_FUNC
)
15421 int nparams
= TYPE_NFIELDS (this_type
);
15423 /* TYPE is the domain of this method, and THIS_TYPE is the type
15424 of the method itself (TYPE_CODE_METHOD). */
15425 smash_to_method_type (fnp
->type
, type
,
15426 TYPE_TARGET_TYPE (this_type
),
15427 TYPE_FIELDS (this_type
),
15428 TYPE_NFIELDS (this_type
),
15429 TYPE_VARARGS (this_type
));
15431 /* Handle static member functions.
15432 Dwarf2 has no clean way to discern C++ static and non-static
15433 member functions. G++ helps GDB by marking the first
15434 parameter for non-static member functions (which is the this
15435 pointer) as artificial. We obtain this information from
15436 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15437 if (nparams
== 0 || TYPE_FIELD_ARTIFICIAL (this_type
, 0) == 0)
15438 fnp
->voffset
= VOFFSET_STATIC
;
15441 complaint (_("member function type missing for '%s'"),
15442 dwarf2_full_name (fieldname
, die
, cu
));
15444 /* Get fcontext from DW_AT_containing_type if present. */
15445 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
15446 fnp
->fcontext
= die_containing_type (die
, cu
);
15448 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15449 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15451 /* Get accessibility. */
15452 attr
= dwarf2_attr (die
, DW_AT_accessibility
, cu
);
15454 accessibility
= (enum dwarf_access_attribute
) DW_UNSND (attr
);
15456 accessibility
= dwarf2_default_access_attribute (die
, cu
);
15457 switch (accessibility
)
15459 case DW_ACCESS_private
:
15460 fnp
->is_private
= 1;
15462 case DW_ACCESS_protected
:
15463 fnp
->is_protected
= 1;
15467 /* Check for artificial methods. */
15468 attr
= dwarf2_attr (die
, DW_AT_artificial
, cu
);
15469 if (attr
&& DW_UNSND (attr
) != 0)
15470 fnp
->is_artificial
= 1;
15472 fnp
->is_constructor
= dwarf2_is_constructor (die
, cu
);
15474 /* Get index in virtual function table if it is a virtual member
15475 function. For older versions of GCC, this is an offset in the
15476 appropriate virtual table, as specified by DW_AT_containing_type.
15477 For everyone else, it is an expression to be evaluated relative
15478 to the object address. */
15480 attr
= dwarf2_attr (die
, DW_AT_vtable_elem_location
, cu
);
15483 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
> 0)
15485 if (DW_BLOCK (attr
)->data
[0] == DW_OP_constu
)
15487 /* Old-style GCC. */
15488 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
) + 2;
15490 else if (DW_BLOCK (attr
)->data
[0] == DW_OP_deref
15491 || (DW_BLOCK (attr
)->size
> 1
15492 && DW_BLOCK (attr
)->data
[0] == DW_OP_deref_size
15493 && DW_BLOCK (attr
)->data
[1] == cu
->header
.addr_size
))
15495 fnp
->voffset
= decode_locdesc (DW_BLOCK (attr
), cu
);
15496 if ((fnp
->voffset
% cu
->header
.addr_size
) != 0)
15497 dwarf2_complex_location_expr_complaint ();
15499 fnp
->voffset
/= cu
->header
.addr_size
;
15503 dwarf2_complex_location_expr_complaint ();
15505 if (!fnp
->fcontext
)
15507 /* If there is no `this' field and no DW_AT_containing_type,
15508 we cannot actually find a base class context for the
15510 if (TYPE_NFIELDS (this_type
) == 0
15511 || !TYPE_FIELD_ARTIFICIAL (this_type
, 0))
15513 complaint (_("cannot determine context for virtual member "
15514 "function \"%s\" (offset %s)"),
15515 fieldname
, sect_offset_str (die
->sect_off
));
15520 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type
, 0));
15524 else if (attr_form_is_section_offset (attr
))
15526 dwarf2_complex_location_expr_complaint ();
15530 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15536 attr
= dwarf2_attr (die
, DW_AT_virtuality
, cu
);
15537 if (attr
&& DW_UNSND (attr
))
15539 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15540 complaint (_("Member function \"%s\" (offset %s) is virtual "
15541 "but the vtable offset is not specified"),
15542 fieldname
, sect_offset_str (die
->sect_off
));
15543 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15544 TYPE_CPLUS_DYNAMIC (type
) = 1;
15549 /* Create the vector of member function fields, and attach it to the type. */
15552 dwarf2_attach_fn_fields_to_type (struct field_info
*fip
, struct type
*type
,
15553 struct dwarf2_cu
*cu
)
15555 if (cu
->language
== language_ada
)
15556 error (_("unexpected member functions in Ada type"));
15558 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15559 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
15561 sizeof (struct fn_fieldlist
) * fip
->fnfieldlists
.size ());
15563 for (int i
= 0; i
< fip
->fnfieldlists
.size (); i
++)
15565 struct fnfieldlist
&nf
= fip
->fnfieldlists
[i
];
15566 struct fn_fieldlist
*fn_flp
= &TYPE_FN_FIELDLIST (type
, i
);
15568 TYPE_FN_FIELDLIST_NAME (type
, i
) = nf
.name
;
15569 TYPE_FN_FIELDLIST_LENGTH (type
, i
) = nf
.fnfields
.size ();
15570 fn_flp
->fn_fields
= (struct fn_field
*)
15571 TYPE_ALLOC (type
, sizeof (struct fn_field
) * nf
.fnfields
.size ());
15573 for (int k
= 0; k
< nf
.fnfields
.size (); ++k
)
15574 fn_flp
->fn_fields
[k
] = nf
.fnfields
[k
];
15577 TYPE_NFN_FIELDS (type
) = fip
->fnfieldlists
.size ();
15580 /* Returns non-zero if NAME is the name of a vtable member in CU's
15581 language, zero otherwise. */
15583 is_vtable_name (const char *name
, struct dwarf2_cu
*cu
)
15585 static const char vptr
[] = "_vptr";
15587 /* Look for the C++ form of the vtable. */
15588 if (startswith (name
, vptr
) && is_cplus_marker (name
[sizeof (vptr
) - 1]))
15594 /* GCC outputs unnamed structures that are really pointers to member
15595 functions, with the ABI-specified layout. If TYPE describes
15596 such a structure, smash it into a member function type.
15598 GCC shouldn't do this; it should just output pointer to member DIEs.
15599 This is GCC PR debug/28767. */
15602 quirk_gcc_member_function_pointer (struct type
*type
, struct objfile
*objfile
)
15604 struct type
*pfn_type
, *self_type
, *new_type
;
15606 /* Check for a structure with no name and two children. */
15607 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
|| TYPE_NFIELDS (type
) != 2)
15610 /* Check for __pfn and __delta members. */
15611 if (TYPE_FIELD_NAME (type
, 0) == NULL
15612 || strcmp (TYPE_FIELD_NAME (type
, 0), "__pfn") != 0
15613 || TYPE_FIELD_NAME (type
, 1) == NULL
15614 || strcmp (TYPE_FIELD_NAME (type
, 1), "__delta") != 0)
15617 /* Find the type of the method. */
15618 pfn_type
= TYPE_FIELD_TYPE (type
, 0);
15619 if (pfn_type
== NULL
15620 || TYPE_CODE (pfn_type
) != TYPE_CODE_PTR
15621 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type
)) != TYPE_CODE_FUNC
)
15624 /* Look for the "this" argument. */
15625 pfn_type
= TYPE_TARGET_TYPE (pfn_type
);
15626 if (TYPE_NFIELDS (pfn_type
) == 0
15627 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15628 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type
, 0)) != TYPE_CODE_PTR
)
15631 self_type
= TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type
, 0));
15632 new_type
= alloc_type (objfile
);
15633 smash_to_method_type (new_type
, self_type
, TYPE_TARGET_TYPE (pfn_type
),
15634 TYPE_FIELDS (pfn_type
), TYPE_NFIELDS (pfn_type
),
15635 TYPE_VARARGS (pfn_type
));
15636 smash_to_methodptr_type (type
, new_type
);
15639 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15640 appropriate error checking and issuing complaints if there is a
15644 get_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
)
15646 struct attribute
*attr
= dwarf2_attr (die
, DW_AT_alignment
, cu
);
15648 if (attr
== nullptr)
15651 if (!attr_form_is_constant (attr
))
15653 complaint (_("DW_AT_alignment must have constant form"
15654 " - DIE at %s [in module %s]"),
15655 sect_offset_str (die
->sect_off
),
15656 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15661 if (attr
->form
== DW_FORM_sdata
)
15663 LONGEST val
= DW_SND (attr
);
15666 complaint (_("DW_AT_alignment value must not be negative"
15667 " - DIE at %s [in module %s]"),
15668 sect_offset_str (die
->sect_off
),
15669 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15675 align
= DW_UNSND (attr
);
15679 complaint (_("DW_AT_alignment value must not be zero"
15680 " - DIE at %s [in module %s]"),
15681 sect_offset_str (die
->sect_off
),
15682 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15685 if ((align
& (align
- 1)) != 0)
15687 complaint (_("DW_AT_alignment value must be a power of 2"
15688 " - DIE at %s [in module %s]"),
15689 sect_offset_str (die
->sect_off
),
15690 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15697 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15698 the alignment for TYPE. */
15701 maybe_set_alignment (struct dwarf2_cu
*cu
, struct die_info
*die
,
15704 if (!set_type_align (type
, get_alignment (cu
, die
)))
15705 complaint (_("DW_AT_alignment value too large"
15706 " - DIE at %s [in module %s]"),
15707 sect_offset_str (die
->sect_off
),
15708 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15711 /* Called when we find the DIE that starts a structure or union scope
15712 (definition) to create a type for the structure or union. Fill in
15713 the type's name and general properties; the members will not be
15714 processed until process_structure_scope. A symbol table entry for
15715 the type will also not be done until process_structure_scope (assuming
15716 the type has a name).
15718 NOTE: we need to call these functions regardless of whether or not the
15719 DIE has a DW_AT_name attribute, since it might be an anonymous
15720 structure or union. This gets the type entered into our set of
15721 user defined types. */
15723 static struct type
*
15724 read_structure_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
15726 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15728 struct attribute
*attr
;
15731 /* If the definition of this type lives in .debug_types, read that type.
15732 Don't follow DW_AT_specification though, that will take us back up
15733 the chain and we want to go down. */
15734 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
15737 type
= get_DW_AT_signature_type (die
, attr
, cu
);
15739 /* The type's CU may not be the same as CU.
15740 Ensure TYPE is recorded with CU in die_type_hash. */
15741 return set_die_type (die
, type
, cu
);
15744 type
= alloc_type (objfile
);
15745 INIT_CPLUS_SPECIFIC (type
);
15747 name
= dwarf2_name (die
, cu
);
15750 if (cu
->language
== language_cplus
15751 || cu
->language
== language_d
15752 || cu
->language
== language_rust
)
15754 const char *full_name
= dwarf2_full_name (name
, die
, cu
);
15756 /* dwarf2_full_name might have already finished building the DIE's
15757 type. If so, there is no need to continue. */
15758 if (get_die_type (die
, cu
) != NULL
)
15759 return get_die_type (die
, cu
);
15761 TYPE_NAME (type
) = full_name
;
15765 /* The name is already allocated along with this objfile, so
15766 we don't need to duplicate it for the type. */
15767 TYPE_NAME (type
) = name
;
15771 if (die
->tag
== DW_TAG_structure_type
)
15773 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15775 else if (die
->tag
== DW_TAG_union_type
)
15777 TYPE_CODE (type
) = TYPE_CODE_UNION
;
15779 else if (die
->tag
== DW_TAG_variant_part
)
15781 TYPE_CODE (type
) = TYPE_CODE_UNION
;
15782 TYPE_FLAG_DISCRIMINATED_UNION (type
) = 1;
15786 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
15789 if (cu
->language
== language_cplus
&& die
->tag
== DW_TAG_class_type
)
15790 TYPE_DECLARED_CLASS (type
) = 1;
15792 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
15795 if (attr_form_is_constant (attr
))
15796 TYPE_LENGTH (type
) = DW_UNSND (attr
);
15799 /* For the moment, dynamic type sizes are not supported
15800 by GDB's struct type. The actual size is determined
15801 on-demand when resolving the type of a given object,
15802 so set the type's length to zero for now. Otherwise,
15803 we record an expression as the length, and that expression
15804 could lead to a very large value, which could eventually
15805 lead to us trying to allocate that much memory when creating
15806 a value of that type. */
15807 TYPE_LENGTH (type
) = 0;
15812 TYPE_LENGTH (type
) = 0;
15815 maybe_set_alignment (cu
, die
, type
);
15817 if (producer_is_icc_lt_14 (cu
) && (TYPE_LENGTH (type
) == 0))
15819 /* ICC<14 does not output the required DW_AT_declaration on
15820 incomplete types, but gives them a size of zero. */
15821 TYPE_STUB (type
) = 1;
15824 TYPE_STUB_SUPPORTED (type
) = 1;
15826 if (die_is_declaration (die
, cu
))
15827 TYPE_STUB (type
) = 1;
15828 else if (attr
== NULL
&& die
->child
== NULL
15829 && producer_is_realview (cu
->producer
))
15830 /* RealView does not output the required DW_AT_declaration
15831 on incomplete types. */
15832 TYPE_STUB (type
) = 1;
15834 /* We need to add the type field to the die immediately so we don't
15835 infinitely recurse when dealing with pointers to the structure
15836 type within the structure itself. */
15837 set_die_type (die
, type
, cu
);
15839 /* set_die_type should be already done. */
15840 set_descriptive_type (type
, die
, cu
);
15845 /* A helper for process_structure_scope that handles a single member
15849 handle_struct_member_die (struct die_info
*child_die
, struct type
*type
,
15850 struct field_info
*fi
,
15851 std::vector
<struct symbol
*> *template_args
,
15852 struct dwarf2_cu
*cu
)
15854 if (child_die
->tag
== DW_TAG_member
15855 || child_die
->tag
== DW_TAG_variable
15856 || child_die
->tag
== DW_TAG_variant_part
)
15858 /* NOTE: carlton/2002-11-05: A C++ static data member
15859 should be a DW_TAG_member that is a declaration, but
15860 all versions of G++ as of this writing (so through at
15861 least 3.2.1) incorrectly generate DW_TAG_variable
15862 tags for them instead. */
15863 dwarf2_add_field (fi
, child_die
, cu
);
15865 else if (child_die
->tag
== DW_TAG_subprogram
)
15867 /* Rust doesn't have member functions in the C++ sense.
15868 However, it does emit ordinary functions as children
15869 of a struct DIE. */
15870 if (cu
->language
== language_rust
)
15871 read_func_scope (child_die
, cu
);
15874 /* C++ member function. */
15875 dwarf2_add_member_fn (fi
, child_die
, type
, cu
);
15878 else if (child_die
->tag
== DW_TAG_inheritance
)
15880 /* C++ base class field. */
15881 dwarf2_add_field (fi
, child_die
, cu
);
15883 else if (type_can_define_types (child_die
))
15884 dwarf2_add_type_defn (fi
, child_die
, cu
);
15885 else if (child_die
->tag
== DW_TAG_template_type_param
15886 || child_die
->tag
== DW_TAG_template_value_param
)
15888 struct symbol
*arg
= new_symbol (child_die
, NULL
, cu
);
15891 template_args
->push_back (arg
);
15893 else if (child_die
->tag
== DW_TAG_variant
)
15895 /* In a variant we want to get the discriminant and also add a
15896 field for our sole member child. */
15897 struct attribute
*discr
= dwarf2_attr (child_die
, DW_AT_discr_value
, cu
);
15899 for (die_info
*variant_child
= child_die
->child
;
15900 variant_child
!= NULL
;
15901 variant_child
= sibling_die (variant_child
))
15903 if (variant_child
->tag
== DW_TAG_member
)
15905 handle_struct_member_die (variant_child
, type
, fi
,
15906 template_args
, cu
);
15907 /* Only handle the one. */
15912 /* We don't handle this but we might as well report it if we see
15914 if (dwarf2_attr (child_die
, DW_AT_discr_list
, cu
) != nullptr)
15915 complaint (_("DW_AT_discr_list is not supported yet"
15916 " - DIE at %s [in module %s]"),
15917 sect_offset_str (child_die
->sect_off
),
15918 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15920 /* The first field was just added, so we can stash the
15921 discriminant there. */
15922 gdb_assert (!fi
->fields
.empty ());
15924 fi
->fields
.back ().variant
.default_branch
= true;
15926 fi
->fields
.back ().variant
.discriminant_value
= DW_UNSND (discr
);
15930 /* Finish creating a structure or union type, including filling in
15931 its members and creating a symbol for it. */
15934 process_structure_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
15936 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
15937 struct die_info
*child_die
;
15940 type
= get_die_type (die
, cu
);
15942 type
= read_structure_type (die
, cu
);
15944 /* When reading a DW_TAG_variant_part, we need to notice when we
15945 read the discriminant member, so we can record it later in the
15946 discriminant_info. */
15947 bool is_variant_part
= TYPE_FLAG_DISCRIMINATED_UNION (type
);
15948 sect_offset discr_offset
;
15949 bool has_template_parameters
= false;
15951 if (is_variant_part
)
15953 struct attribute
*discr
= dwarf2_attr (die
, DW_AT_discr
, cu
);
15956 /* Maybe it's a univariant form, an extension we support.
15957 In this case arrange not to check the offset. */
15958 is_variant_part
= false;
15960 else if (attr_form_is_ref (discr
))
15962 struct dwarf2_cu
*target_cu
= cu
;
15963 struct die_info
*target_die
= follow_die_ref (die
, discr
, &target_cu
);
15965 discr_offset
= target_die
->sect_off
;
15969 complaint (_("DW_AT_discr does not have DIE reference form"
15970 " - DIE at %s [in module %s]"),
15971 sect_offset_str (die
->sect_off
),
15972 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
15973 is_variant_part
= false;
15977 if (die
->child
!= NULL
&& ! die_is_declaration (die
, cu
))
15979 struct field_info fi
;
15980 std::vector
<struct symbol
*> template_args
;
15982 child_die
= die
->child
;
15984 while (child_die
&& child_die
->tag
)
15986 handle_struct_member_die (child_die
, type
, &fi
, &template_args
, cu
);
15988 if (is_variant_part
&& discr_offset
== child_die
->sect_off
)
15989 fi
.fields
.back ().variant
.is_discriminant
= true;
15991 child_die
= sibling_die (child_die
);
15994 /* Attach template arguments to type. */
15995 if (!template_args
.empty ())
15997 has_template_parameters
= true;
15998 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
15999 TYPE_N_TEMPLATE_ARGUMENTS (type
) = template_args
.size ();
16000 TYPE_TEMPLATE_ARGUMENTS (type
)
16001 = XOBNEWVEC (&objfile
->objfile_obstack
,
16003 TYPE_N_TEMPLATE_ARGUMENTS (type
));
16004 memcpy (TYPE_TEMPLATE_ARGUMENTS (type
),
16005 template_args
.data (),
16006 (TYPE_N_TEMPLATE_ARGUMENTS (type
)
16007 * sizeof (struct symbol
*)));
16010 /* Attach fields and member functions to the type. */
16012 dwarf2_attach_fields_to_type (&fi
, type
, cu
);
16013 if (!fi
.fnfieldlists
.empty ())
16015 dwarf2_attach_fn_fields_to_type (&fi
, type
, cu
);
16017 /* Get the type which refers to the base class (possibly this
16018 class itself) which contains the vtable pointer for the current
16019 class from the DW_AT_containing_type attribute. This use of
16020 DW_AT_containing_type is a GNU extension. */
16022 if (dwarf2_attr (die
, DW_AT_containing_type
, cu
) != NULL
)
16024 struct type
*t
= die_containing_type (die
, cu
);
16026 set_type_vptr_basetype (type
, t
);
16031 /* Our own class provides vtbl ptr. */
16032 for (i
= TYPE_NFIELDS (t
) - 1;
16033 i
>= TYPE_N_BASECLASSES (t
);
16036 const char *fieldname
= TYPE_FIELD_NAME (t
, i
);
16038 if (is_vtable_name (fieldname
, cu
))
16040 set_type_vptr_fieldno (type
, i
);
16045 /* Complain if virtual function table field not found. */
16046 if (i
< TYPE_N_BASECLASSES (t
))
16047 complaint (_("virtual function table pointer "
16048 "not found when defining class '%s'"),
16049 TYPE_NAME (type
) ? TYPE_NAME (type
) : "");
16053 set_type_vptr_fieldno (type
, TYPE_VPTR_FIELDNO (t
));
16056 else if (cu
->producer
16057 && startswith (cu
->producer
, "IBM(R) XL C/C++ Advanced Edition"))
16059 /* The IBM XLC compiler does not provide direct indication
16060 of the containing type, but the vtable pointer is
16061 always named __vfp. */
16065 for (i
= TYPE_NFIELDS (type
) - 1;
16066 i
>= TYPE_N_BASECLASSES (type
);
16069 if (strcmp (TYPE_FIELD_NAME (type
, i
), "__vfp") == 0)
16071 set_type_vptr_fieldno (type
, i
);
16072 set_type_vptr_basetype (type
, type
);
16079 /* Copy fi.typedef_field_list linked list elements content into the
16080 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16081 if (!fi
.typedef_field_list
.empty ())
16083 int count
= fi
.typedef_field_list
.size ();
16085 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16086 TYPE_TYPEDEF_FIELD_ARRAY (type
)
16087 = ((struct decl_field
*)
16089 sizeof (TYPE_TYPEDEF_FIELD (type
, 0)) * count
));
16090 TYPE_TYPEDEF_FIELD_COUNT (type
) = count
;
16092 for (int i
= 0; i
< fi
.typedef_field_list
.size (); ++i
)
16093 TYPE_TYPEDEF_FIELD (type
, i
) = fi
.typedef_field_list
[i
];
16096 /* Copy fi.nested_types_list linked list elements content into the
16097 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16098 if (!fi
.nested_types_list
.empty () && cu
->language
!= language_ada
)
16100 int count
= fi
.nested_types_list
.size ();
16102 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
16103 TYPE_NESTED_TYPES_ARRAY (type
)
16104 = ((struct decl_field
*)
16105 TYPE_ALLOC (type
, sizeof (struct decl_field
) * count
));
16106 TYPE_NESTED_TYPES_COUNT (type
) = count
;
16108 for (int i
= 0; i
< fi
.nested_types_list
.size (); ++i
)
16109 TYPE_NESTED_TYPES_FIELD (type
, i
) = fi
.nested_types_list
[i
];
16113 quirk_gcc_member_function_pointer (type
, objfile
);
16114 if (cu
->language
== language_rust
&& die
->tag
== DW_TAG_union_type
)
16115 cu
->rust_unions
.push_back (type
);
16117 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16118 snapshots) has been known to create a die giving a declaration
16119 for a class that has, as a child, a die giving a definition for a
16120 nested class. So we have to process our children even if the
16121 current die is a declaration. Normally, of course, a declaration
16122 won't have any children at all. */
16124 child_die
= die
->child
;
16126 while (child_die
!= NULL
&& child_die
->tag
)
16128 if (child_die
->tag
== DW_TAG_member
16129 || child_die
->tag
== DW_TAG_variable
16130 || child_die
->tag
== DW_TAG_inheritance
16131 || child_die
->tag
== DW_TAG_template_value_param
16132 || child_die
->tag
== DW_TAG_template_type_param
)
16137 process_die (child_die
, cu
);
16139 child_die
= sibling_die (child_die
);
16142 /* Do not consider external references. According to the DWARF standard,
16143 these DIEs are identified by the fact that they have no byte_size
16144 attribute, and a declaration attribute. */
16145 if (dwarf2_attr (die
, DW_AT_byte_size
, cu
) != NULL
16146 || !die_is_declaration (die
, cu
))
16148 struct symbol
*sym
= new_symbol (die
, type
, cu
);
16150 if (has_template_parameters
)
16152 struct symtab
*symtab
;
16153 if (sym
!= nullptr)
16154 symtab
= symbol_symtab (sym
);
16155 else if (cu
->line_header
!= nullptr)
16157 /* Any related symtab will do. */
16159 = cu
->line_header
->file_name_at (file_name_index (1))->symtab
;
16164 complaint (_("could not find suitable "
16165 "symtab for template parameter"
16166 " - DIE at %s [in module %s]"),
16167 sect_offset_str (die
->sect_off
),
16168 objfile_name (objfile
));
16171 if (symtab
!= nullptr)
16173 /* Make sure that the symtab is set on the new symbols.
16174 Even though they don't appear in this symtab directly,
16175 other parts of gdb assume that symbols do, and this is
16176 reasonably true. */
16177 for (int i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
16178 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type
, i
), symtab
);
16184 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16185 update TYPE using some information only available in DIE's children. */
16188 update_enumeration_type_from_children (struct die_info
*die
,
16190 struct dwarf2_cu
*cu
)
16192 struct die_info
*child_die
;
16193 int unsigned_enum
= 1;
16197 auto_obstack obstack
;
16199 for (child_die
= die
->child
;
16200 child_die
!= NULL
&& child_die
->tag
;
16201 child_die
= sibling_die (child_die
))
16203 struct attribute
*attr
;
16205 const gdb_byte
*bytes
;
16206 struct dwarf2_locexpr_baton
*baton
;
16209 if (child_die
->tag
!= DW_TAG_enumerator
)
16212 attr
= dwarf2_attr (child_die
, DW_AT_const_value
, cu
);
16216 name
= dwarf2_name (child_die
, cu
);
16218 name
= "<anonymous enumerator>";
16220 dwarf2_const_value_attr (attr
, type
, name
, &obstack
, cu
,
16221 &value
, &bytes
, &baton
);
16227 else if ((mask
& value
) != 0)
16232 /* If we already know that the enum type is neither unsigned, nor
16233 a flag type, no need to look at the rest of the enumerates. */
16234 if (!unsigned_enum
&& !flag_enum
)
16239 TYPE_UNSIGNED (type
) = 1;
16241 TYPE_FLAG_ENUM (type
) = 1;
16244 /* Given a DW_AT_enumeration_type die, set its type. We do not
16245 complete the type's fields yet, or create any symbols. */
16247 static struct type
*
16248 read_enumeration_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16250 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16252 struct attribute
*attr
;
16255 /* If the definition of this type lives in .debug_types, read that type.
16256 Don't follow DW_AT_specification though, that will take us back up
16257 the chain and we want to go down. */
16258 attr
= dwarf2_attr_no_follow (die
, DW_AT_signature
);
16261 type
= get_DW_AT_signature_type (die
, attr
, cu
);
16263 /* The type's CU may not be the same as CU.
16264 Ensure TYPE is recorded with CU in die_type_hash. */
16265 return set_die_type (die
, type
, cu
);
16268 type
= alloc_type (objfile
);
16270 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
16271 name
= dwarf2_full_name (NULL
, die
, cu
);
16273 TYPE_NAME (type
) = name
;
16275 attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
16278 struct type
*underlying_type
= die_type (die
, cu
);
16280 TYPE_TARGET_TYPE (type
) = underlying_type
;
16283 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16286 TYPE_LENGTH (type
) = DW_UNSND (attr
);
16290 TYPE_LENGTH (type
) = 0;
16293 maybe_set_alignment (cu
, die
, type
);
16295 /* The enumeration DIE can be incomplete. In Ada, any type can be
16296 declared as private in the package spec, and then defined only
16297 inside the package body. Such types are known as Taft Amendment
16298 Types. When another package uses such a type, an incomplete DIE
16299 may be generated by the compiler. */
16300 if (die_is_declaration (die
, cu
))
16301 TYPE_STUB (type
) = 1;
16303 /* Finish the creation of this type by using the enum's children.
16304 We must call this even when the underlying type has been provided
16305 so that we can determine if we're looking at a "flag" enum. */
16306 update_enumeration_type_from_children (die
, type
, cu
);
16308 /* If this type has an underlying type that is not a stub, then we
16309 may use its attributes. We always use the "unsigned" attribute
16310 in this situation, because ordinarily we guess whether the type
16311 is unsigned -- but the guess can be wrong and the underlying type
16312 can tell us the reality. However, we defer to a local size
16313 attribute if one exists, because this lets the compiler override
16314 the underlying type if needed. */
16315 if (TYPE_TARGET_TYPE (type
) != NULL
&& !TYPE_STUB (TYPE_TARGET_TYPE (type
)))
16317 TYPE_UNSIGNED (type
) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
));
16318 if (TYPE_LENGTH (type
) == 0)
16319 TYPE_LENGTH (type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
16320 if (TYPE_RAW_ALIGN (type
) == 0
16321 && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type
)) != 0)
16322 set_type_align (type
, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type
)));
16325 TYPE_DECLARED_CLASS (type
) = dwarf2_flag_true_p (die
, DW_AT_enum_class
, cu
);
16327 return set_die_type (die
, type
, cu
);
16330 /* Given a pointer to a die which begins an enumeration, process all
16331 the dies that define the members of the enumeration, and create the
16332 symbol for the enumeration type.
16334 NOTE: We reverse the order of the element list. */
16337 process_enumeration_scope (struct die_info
*die
, struct dwarf2_cu
*cu
)
16339 struct type
*this_type
;
16341 this_type
= get_die_type (die
, cu
);
16342 if (this_type
== NULL
)
16343 this_type
= read_enumeration_type (die
, cu
);
16345 if (die
->child
!= NULL
)
16347 struct die_info
*child_die
;
16348 struct symbol
*sym
;
16349 struct field
*fields
= NULL
;
16350 int num_fields
= 0;
16353 child_die
= die
->child
;
16354 while (child_die
&& child_die
->tag
)
16356 if (child_die
->tag
!= DW_TAG_enumerator
)
16358 process_die (child_die
, cu
);
16362 name
= dwarf2_name (child_die
, cu
);
16365 sym
= new_symbol (child_die
, this_type
, cu
);
16367 if ((num_fields
% DW_FIELD_ALLOC_CHUNK
) == 0)
16369 fields
= (struct field
*)
16371 (num_fields
+ DW_FIELD_ALLOC_CHUNK
)
16372 * sizeof (struct field
));
16375 FIELD_NAME (fields
[num_fields
]) = SYMBOL_LINKAGE_NAME (sym
);
16376 FIELD_TYPE (fields
[num_fields
]) = NULL
;
16377 SET_FIELD_ENUMVAL (fields
[num_fields
], SYMBOL_VALUE (sym
));
16378 FIELD_BITSIZE (fields
[num_fields
]) = 0;
16384 child_die
= sibling_die (child_die
);
16389 TYPE_NFIELDS (this_type
) = num_fields
;
16390 TYPE_FIELDS (this_type
) = (struct field
*)
16391 TYPE_ALLOC (this_type
, sizeof (struct field
) * num_fields
);
16392 memcpy (TYPE_FIELDS (this_type
), fields
,
16393 sizeof (struct field
) * num_fields
);
16398 /* If we are reading an enum from a .debug_types unit, and the enum
16399 is a declaration, and the enum is not the signatured type in the
16400 unit, then we do not want to add a symbol for it. Adding a
16401 symbol would in some cases obscure the true definition of the
16402 enum, giving users an incomplete type when the definition is
16403 actually available. Note that we do not want to do this for all
16404 enums which are just declarations, because C++0x allows forward
16405 enum declarations. */
16406 if (cu
->per_cu
->is_debug_types
16407 && die_is_declaration (die
, cu
))
16409 struct signatured_type
*sig_type
;
16411 sig_type
= (struct signatured_type
*) cu
->per_cu
;
16412 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
16413 if (sig_type
->type_offset_in_section
!= die
->sect_off
)
16417 new_symbol (die
, this_type
, cu
);
16420 /* Extract all information from a DW_TAG_array_type DIE and put it in
16421 the DIE's type field. For now, this only handles one dimensional
16424 static struct type
*
16425 read_array_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16427 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16428 struct die_info
*child_die
;
16430 struct type
*element_type
, *range_type
, *index_type
;
16431 struct attribute
*attr
;
16433 struct dynamic_prop
*byte_stride_prop
= NULL
;
16434 unsigned int bit_stride
= 0;
16436 element_type
= die_type (die
, cu
);
16438 /* The die_type call above may have already set the type for this DIE. */
16439 type
= get_die_type (die
, cu
);
16443 attr
= dwarf2_attr (die
, DW_AT_byte_stride
, cu
);
16447 struct type
*prop_type
16448 = dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
16451 = (struct dynamic_prop
*) alloca (sizeof (struct dynamic_prop
));
16452 stride_ok
= attr_to_dynamic_prop (attr
, die
, cu
, byte_stride_prop
,
16456 complaint (_("unable to read array DW_AT_byte_stride "
16457 " - DIE at %s [in module %s]"),
16458 sect_offset_str (die
->sect_off
),
16459 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
16460 /* Ignore this attribute. We will likely not be able to print
16461 arrays of this type correctly, but there is little we can do
16462 to help if we cannot read the attribute's value. */
16463 byte_stride_prop
= NULL
;
16467 attr
= dwarf2_attr (die
, DW_AT_bit_stride
, cu
);
16469 bit_stride
= DW_UNSND (attr
);
16471 /* Irix 6.2 native cc creates array types without children for
16472 arrays with unspecified length. */
16473 if (die
->child
== NULL
)
16475 index_type
= objfile_type (objfile
)->builtin_int
;
16476 range_type
= create_static_range_type (NULL
, index_type
, 0, -1);
16477 type
= create_array_type_with_stride (NULL
, element_type
, range_type
,
16478 byte_stride_prop
, bit_stride
);
16479 return set_die_type (die
, type
, cu
);
16482 std::vector
<struct type
*> range_types
;
16483 child_die
= die
->child
;
16484 while (child_die
&& child_die
->tag
)
16486 if (child_die
->tag
== DW_TAG_subrange_type
)
16488 struct type
*child_type
= read_type_die (child_die
, cu
);
16490 if (child_type
!= NULL
)
16492 /* The range type was succesfully read. Save it for the
16493 array type creation. */
16494 range_types
.push_back (child_type
);
16497 child_die
= sibling_die (child_die
);
16500 /* Dwarf2 dimensions are output from left to right, create the
16501 necessary array types in backwards order. */
16503 type
= element_type
;
16505 if (read_array_order (die
, cu
) == DW_ORD_col_major
)
16509 while (i
< range_types
.size ())
16510 type
= create_array_type_with_stride (NULL
, type
, range_types
[i
++],
16511 byte_stride_prop
, bit_stride
);
16515 size_t ndim
= range_types
.size ();
16517 type
= create_array_type_with_stride (NULL
, type
, range_types
[ndim
],
16518 byte_stride_prop
, bit_stride
);
16521 /* Understand Dwarf2 support for vector types (like they occur on
16522 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16523 array type. This is not part of the Dwarf2/3 standard yet, but a
16524 custom vendor extension. The main difference between a regular
16525 array and the vector variant is that vectors are passed by value
16527 attr
= dwarf2_attr (die
, DW_AT_GNU_vector
, cu
);
16529 make_vector_type (type
);
16531 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16532 implementation may choose to implement triple vectors using this
16534 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16537 if (DW_UNSND (attr
) >= TYPE_LENGTH (type
))
16538 TYPE_LENGTH (type
) = DW_UNSND (attr
);
16540 complaint (_("DW_AT_byte_size for array type smaller "
16541 "than the total size of elements"));
16544 name
= dwarf2_name (die
, cu
);
16546 TYPE_NAME (type
) = name
;
16548 maybe_set_alignment (cu
, die
, type
);
16550 /* Install the type in the die. */
16551 set_die_type (die
, type
, cu
);
16553 /* set_die_type should be already done. */
16554 set_descriptive_type (type
, die
, cu
);
16559 static enum dwarf_array_dim_ordering
16560 read_array_order (struct die_info
*die
, struct dwarf2_cu
*cu
)
16562 struct attribute
*attr
;
16564 attr
= dwarf2_attr (die
, DW_AT_ordering
, cu
);
16567 return (enum dwarf_array_dim_ordering
) DW_SND (attr
);
16569 /* GNU F77 is a special case, as at 08/2004 array type info is the
16570 opposite order to the dwarf2 specification, but data is still
16571 laid out as per normal fortran.
16573 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16574 version checking. */
16576 if (cu
->language
== language_fortran
16577 && cu
->producer
&& strstr (cu
->producer
, "GNU F77"))
16579 return DW_ORD_row_major
;
16582 switch (cu
->language_defn
->la_array_ordering
)
16584 case array_column_major
:
16585 return DW_ORD_col_major
;
16586 case array_row_major
:
16588 return DW_ORD_row_major
;
16592 /* Extract all information from a DW_TAG_set_type DIE and put it in
16593 the DIE's type field. */
16595 static struct type
*
16596 read_set_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16598 struct type
*domain_type
, *set_type
;
16599 struct attribute
*attr
;
16601 domain_type
= die_type (die
, cu
);
16603 /* The die_type call above may have already set the type for this DIE. */
16604 set_type
= get_die_type (die
, cu
);
16608 set_type
= create_set_type (NULL
, domain_type
);
16610 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16612 TYPE_LENGTH (set_type
) = DW_UNSND (attr
);
16614 maybe_set_alignment (cu
, die
, set_type
);
16616 return set_die_type (die
, set_type
, cu
);
16619 /* A helper for read_common_block that creates a locexpr baton.
16620 SYM is the symbol which we are marking as computed.
16621 COMMON_DIE is the DIE for the common block.
16622 COMMON_LOC is the location expression attribute for the common
16624 MEMBER_LOC is the location expression attribute for the particular
16625 member of the common block that we are processing.
16626 CU is the CU from which the above come. */
16629 mark_common_block_symbol_computed (struct symbol
*sym
,
16630 struct die_info
*common_die
,
16631 struct attribute
*common_loc
,
16632 struct attribute
*member_loc
,
16633 struct dwarf2_cu
*cu
)
16635 struct dwarf2_per_objfile
*dwarf2_per_objfile
16636 = cu
->per_cu
->dwarf2_per_objfile
;
16637 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
16638 struct dwarf2_locexpr_baton
*baton
;
16640 unsigned int cu_off
;
16641 enum bfd_endian byte_order
= gdbarch_byte_order (get_objfile_arch (objfile
));
16642 LONGEST offset
= 0;
16644 gdb_assert (common_loc
&& member_loc
);
16645 gdb_assert (attr_form_is_block (common_loc
));
16646 gdb_assert (attr_form_is_block (member_loc
)
16647 || attr_form_is_constant (member_loc
));
16649 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
16650 baton
->per_cu
= cu
->per_cu
;
16651 gdb_assert (baton
->per_cu
);
16653 baton
->size
= 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16655 if (attr_form_is_constant (member_loc
))
16657 offset
= dwarf2_get_attr_constant_value (member_loc
, 0);
16658 baton
->size
+= 1 /* DW_OP_addr */ + cu
->header
.addr_size
;
16661 baton
->size
+= DW_BLOCK (member_loc
)->size
;
16663 ptr
= (gdb_byte
*) obstack_alloc (&objfile
->objfile_obstack
, baton
->size
);
16666 *ptr
++ = DW_OP_call4
;
16667 cu_off
= common_die
->sect_off
- cu
->per_cu
->sect_off
;
16668 store_unsigned_integer (ptr
, 4, byte_order
, cu_off
);
16671 if (attr_form_is_constant (member_loc
))
16673 *ptr
++ = DW_OP_addr
;
16674 store_unsigned_integer (ptr
, cu
->header
.addr_size
, byte_order
, offset
);
16675 ptr
+= cu
->header
.addr_size
;
16679 /* We have to copy the data here, because DW_OP_call4 will only
16680 use a DW_AT_location attribute. */
16681 memcpy (ptr
, DW_BLOCK (member_loc
)->data
, DW_BLOCK (member_loc
)->size
);
16682 ptr
+= DW_BLOCK (member_loc
)->size
;
16685 *ptr
++ = DW_OP_plus
;
16686 gdb_assert (ptr
- baton
->data
== baton
->size
);
16688 SYMBOL_LOCATION_BATON (sym
) = baton
;
16689 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
16692 /* Create appropriate locally-scoped variables for all the
16693 DW_TAG_common_block entries. Also create a struct common_block
16694 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16695 is used to sepate the common blocks name namespace from regular
16699 read_common_block (struct die_info
*die
, struct dwarf2_cu
*cu
)
16701 struct attribute
*attr
;
16703 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
16706 /* Support the .debug_loc offsets. */
16707 if (attr_form_is_block (attr
))
16711 else if (attr_form_is_section_offset (attr
))
16713 dwarf2_complex_location_expr_complaint ();
16718 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16719 "common block member");
16724 if (die
->child
!= NULL
)
16726 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16727 struct die_info
*child_die
;
16728 size_t n_entries
= 0, size
;
16729 struct common_block
*common_block
;
16730 struct symbol
*sym
;
16732 for (child_die
= die
->child
;
16733 child_die
&& child_die
->tag
;
16734 child_die
= sibling_die (child_die
))
16737 size
= (sizeof (struct common_block
)
16738 + (n_entries
- 1) * sizeof (struct symbol
*));
16740 = (struct common_block
*) obstack_alloc (&objfile
->objfile_obstack
,
16742 memset (common_block
->contents
, 0, n_entries
* sizeof (struct symbol
*));
16743 common_block
->n_entries
= 0;
16745 for (child_die
= die
->child
;
16746 child_die
&& child_die
->tag
;
16747 child_die
= sibling_die (child_die
))
16749 /* Create the symbol in the DW_TAG_common_block block in the current
16751 sym
= new_symbol (child_die
, NULL
, cu
);
16754 struct attribute
*member_loc
;
16756 common_block
->contents
[common_block
->n_entries
++] = sym
;
16758 member_loc
= dwarf2_attr (child_die
, DW_AT_data_member_location
,
16762 /* GDB has handled this for a long time, but it is
16763 not specified by DWARF. It seems to have been
16764 emitted by gfortran at least as recently as:
16765 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16766 complaint (_("Variable in common block has "
16767 "DW_AT_data_member_location "
16768 "- DIE at %s [in module %s]"),
16769 sect_offset_str (child_die
->sect_off
),
16770 objfile_name (objfile
));
16772 if (attr_form_is_section_offset (member_loc
))
16773 dwarf2_complex_location_expr_complaint ();
16774 else if (attr_form_is_constant (member_loc
)
16775 || attr_form_is_block (member_loc
))
16778 mark_common_block_symbol_computed (sym
, die
, attr
,
16782 dwarf2_complex_location_expr_complaint ();
16787 sym
= new_symbol (die
, objfile_type (objfile
)->builtin_void
, cu
);
16788 SYMBOL_VALUE_COMMON_BLOCK (sym
) = common_block
;
16792 /* Create a type for a C++ namespace. */
16794 static struct type
*
16795 read_namespace_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16797 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16798 const char *previous_prefix
, *name
;
16802 /* For extensions, reuse the type of the original namespace. */
16803 if (dwarf2_attr (die
, DW_AT_extension
, cu
) != NULL
)
16805 struct die_info
*ext_die
;
16806 struct dwarf2_cu
*ext_cu
= cu
;
16808 ext_die
= dwarf2_extension (die
, &ext_cu
);
16809 type
= read_type_die (ext_die
, ext_cu
);
16811 /* EXT_CU may not be the same as CU.
16812 Ensure TYPE is recorded with CU in die_type_hash. */
16813 return set_die_type (die
, type
, cu
);
16816 name
= namespace_name (die
, &is_anonymous
, cu
);
16818 /* Now build the name of the current namespace. */
16820 previous_prefix
= determine_prefix (die
, cu
);
16821 if (previous_prefix
[0] != '\0')
16822 name
= typename_concat (&objfile
->objfile_obstack
,
16823 previous_prefix
, name
, 0, cu
);
16825 /* Create the type. */
16826 type
= init_type (objfile
, TYPE_CODE_NAMESPACE
, 0, name
);
16828 return set_die_type (die
, type
, cu
);
16831 /* Read a namespace scope. */
16834 read_namespace (struct die_info
*die
, struct dwarf2_cu
*cu
)
16836 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16839 /* Add a symbol associated to this if we haven't seen the namespace
16840 before. Also, add a using directive if it's an anonymous
16843 if (dwarf2_attr (die
, DW_AT_extension
, cu
) == NULL
)
16847 type
= read_type_die (die
, cu
);
16848 new_symbol (die
, type
, cu
);
16850 namespace_name (die
, &is_anonymous
, cu
);
16853 const char *previous_prefix
= determine_prefix (die
, cu
);
16855 std::vector
<const char *> excludes
;
16856 add_using_directive (using_directives (cu
),
16857 previous_prefix
, TYPE_NAME (type
), NULL
,
16858 NULL
, excludes
, 0, &objfile
->objfile_obstack
);
16862 if (die
->child
!= NULL
)
16864 struct die_info
*child_die
= die
->child
;
16866 while (child_die
&& child_die
->tag
)
16868 process_die (child_die
, cu
);
16869 child_die
= sibling_die (child_die
);
16874 /* Read a Fortran module as type. This DIE can be only a declaration used for
16875 imported module. Still we need that type as local Fortran "use ... only"
16876 declaration imports depend on the created type in determine_prefix. */
16878 static struct type
*
16879 read_module_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16881 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
16882 const char *module_name
;
16885 module_name
= dwarf2_name (die
, cu
);
16886 type
= init_type (objfile
, TYPE_CODE_MODULE
, 0, module_name
);
16888 return set_die_type (die
, type
, cu
);
16891 /* Read a Fortran module. */
16894 read_module (struct die_info
*die
, struct dwarf2_cu
*cu
)
16896 struct die_info
*child_die
= die
->child
;
16899 type
= read_type_die (die
, cu
);
16900 new_symbol (die
, type
, cu
);
16902 while (child_die
&& child_die
->tag
)
16904 process_die (child_die
, cu
);
16905 child_die
= sibling_die (child_die
);
16909 /* Return the name of the namespace represented by DIE. Set
16910 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16913 static const char *
16914 namespace_name (struct die_info
*die
, int *is_anonymous
, struct dwarf2_cu
*cu
)
16916 struct die_info
*current_die
;
16917 const char *name
= NULL
;
16919 /* Loop through the extensions until we find a name. */
16921 for (current_die
= die
;
16922 current_die
!= NULL
;
16923 current_die
= dwarf2_extension (die
, &cu
))
16925 /* We don't use dwarf2_name here so that we can detect the absence
16926 of a name -> anonymous namespace. */
16927 name
= dwarf2_string_attr (die
, DW_AT_name
, cu
);
16933 /* Is it an anonymous namespace? */
16935 *is_anonymous
= (name
== NULL
);
16937 name
= CP_ANONYMOUS_NAMESPACE_STR
;
16942 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16943 the user defined type vector. */
16945 static struct type
*
16946 read_tag_pointer_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
16948 struct gdbarch
*gdbarch
16949 = get_objfile_arch (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
16950 struct comp_unit_head
*cu_header
= &cu
->header
;
16952 struct attribute
*attr_byte_size
;
16953 struct attribute
*attr_address_class
;
16954 int byte_size
, addr_class
;
16955 struct type
*target_type
;
16957 target_type
= die_type (die
, cu
);
16959 /* The die_type call above may have already set the type for this DIE. */
16960 type
= get_die_type (die
, cu
);
16964 type
= lookup_pointer_type (target_type
);
16966 attr_byte_size
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
16967 if (attr_byte_size
)
16968 byte_size
= DW_UNSND (attr_byte_size
);
16970 byte_size
= cu_header
->addr_size
;
16972 attr_address_class
= dwarf2_attr (die
, DW_AT_address_class
, cu
);
16973 if (attr_address_class
)
16974 addr_class
= DW_UNSND (attr_address_class
);
16976 addr_class
= DW_ADDR_none
;
16978 ULONGEST alignment
= get_alignment (cu
, die
);
16980 /* If the pointer size, alignment, or address class is different
16981 than the default, create a type variant marked as such and set
16982 the length accordingly. */
16983 if (TYPE_LENGTH (type
) != byte_size
16984 || (alignment
!= 0 && TYPE_RAW_ALIGN (type
) != 0
16985 && alignment
!= TYPE_RAW_ALIGN (type
))
16986 || addr_class
!= DW_ADDR_none
)
16988 if (gdbarch_address_class_type_flags_p (gdbarch
))
16992 type_flags
= gdbarch_address_class_type_flags
16993 (gdbarch
, byte_size
, addr_class
);
16994 gdb_assert ((type_flags
& ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
)
16996 type
= make_type_with_address_space (type
, type_flags
);
16998 else if (TYPE_LENGTH (type
) != byte_size
)
17000 complaint (_("invalid pointer size %d"), byte_size
);
17002 else if (TYPE_RAW_ALIGN (type
) != alignment
)
17004 complaint (_("Invalid DW_AT_alignment"
17005 " - DIE at %s [in module %s]"),
17006 sect_offset_str (die
->sect_off
),
17007 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17011 /* Should we also complain about unhandled address classes? */
17015 TYPE_LENGTH (type
) = byte_size
;
17016 set_type_align (type
, alignment
);
17017 return set_die_type (die
, type
, cu
);
17020 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17021 the user defined type vector. */
17023 static struct type
*
17024 read_tag_ptr_to_member_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17027 struct type
*to_type
;
17028 struct type
*domain
;
17030 to_type
= die_type (die
, cu
);
17031 domain
= die_containing_type (die
, cu
);
17033 /* The calls above may have already set the type for this DIE. */
17034 type
= get_die_type (die
, cu
);
17038 if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_METHOD
)
17039 type
= lookup_methodptr_type (to_type
);
17040 else if (TYPE_CODE (check_typedef (to_type
)) == TYPE_CODE_FUNC
)
17042 struct type
*new_type
17043 = alloc_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
);
17045 smash_to_method_type (new_type
, domain
, TYPE_TARGET_TYPE (to_type
),
17046 TYPE_FIELDS (to_type
), TYPE_NFIELDS (to_type
),
17047 TYPE_VARARGS (to_type
));
17048 type
= lookup_methodptr_type (new_type
);
17051 type
= lookup_memberptr_type (to_type
, domain
);
17053 return set_die_type (die
, type
, cu
);
17056 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17057 the user defined type vector. */
17059 static struct type
*
17060 read_tag_reference_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17061 enum type_code refcode
)
17063 struct comp_unit_head
*cu_header
= &cu
->header
;
17064 struct type
*type
, *target_type
;
17065 struct attribute
*attr
;
17067 gdb_assert (refcode
== TYPE_CODE_REF
|| refcode
== TYPE_CODE_RVALUE_REF
);
17069 target_type
= die_type (die
, cu
);
17071 /* The die_type call above may have already set the type for this DIE. */
17072 type
= get_die_type (die
, cu
);
17076 type
= lookup_reference_type (target_type
, refcode
);
17077 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17080 TYPE_LENGTH (type
) = DW_UNSND (attr
);
17084 TYPE_LENGTH (type
) = cu_header
->addr_size
;
17086 maybe_set_alignment (cu
, die
, type
);
17087 return set_die_type (die
, type
, cu
);
17090 /* Add the given cv-qualifiers to the element type of the array. GCC
17091 outputs DWARF type qualifiers that apply to an array, not the
17092 element type. But GDB relies on the array element type to carry
17093 the cv-qualifiers. This mimics section 6.7.3 of the C99
17096 static struct type
*
17097 add_array_cv_type (struct die_info
*die
, struct dwarf2_cu
*cu
,
17098 struct type
*base_type
, int cnst
, int voltl
)
17100 struct type
*el_type
, *inner_array
;
17102 base_type
= copy_type (base_type
);
17103 inner_array
= base_type
;
17105 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array
)) == TYPE_CODE_ARRAY
)
17107 TYPE_TARGET_TYPE (inner_array
) =
17108 copy_type (TYPE_TARGET_TYPE (inner_array
));
17109 inner_array
= TYPE_TARGET_TYPE (inner_array
);
17112 el_type
= TYPE_TARGET_TYPE (inner_array
);
17113 cnst
|= TYPE_CONST (el_type
);
17114 voltl
|= TYPE_VOLATILE (el_type
);
17115 TYPE_TARGET_TYPE (inner_array
) = make_cv_type (cnst
, voltl
, el_type
, NULL
);
17117 return set_die_type (die
, base_type
, cu
);
17120 static struct type
*
17121 read_tag_const_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17123 struct type
*base_type
, *cv_type
;
17125 base_type
= die_type (die
, cu
);
17127 /* The die_type call above may have already set the type for this DIE. */
17128 cv_type
= get_die_type (die
, cu
);
17132 /* In case the const qualifier is applied to an array type, the element type
17133 is so qualified, not the array type (section 6.7.3 of C99). */
17134 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
17135 return add_array_cv_type (die
, cu
, base_type
, 1, 0);
17137 cv_type
= make_cv_type (1, TYPE_VOLATILE (base_type
), base_type
, 0);
17138 return set_die_type (die
, cv_type
, cu
);
17141 static struct type
*
17142 read_tag_volatile_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17144 struct type
*base_type
, *cv_type
;
17146 base_type
= die_type (die
, cu
);
17148 /* The die_type call above may have already set the type for this DIE. */
17149 cv_type
= get_die_type (die
, cu
);
17153 /* In case the volatile qualifier is applied to an array type, the
17154 element type is so qualified, not the array type (section 6.7.3
17156 if (TYPE_CODE (base_type
) == TYPE_CODE_ARRAY
)
17157 return add_array_cv_type (die
, cu
, base_type
, 0, 1);
17159 cv_type
= make_cv_type (TYPE_CONST (base_type
), 1, base_type
, 0);
17160 return set_die_type (die
, cv_type
, cu
);
17163 /* Handle DW_TAG_restrict_type. */
17165 static struct type
*
17166 read_tag_restrict_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17168 struct type
*base_type
, *cv_type
;
17170 base_type
= die_type (die
, cu
);
17172 /* The die_type call above may have already set the type for this DIE. */
17173 cv_type
= get_die_type (die
, cu
);
17177 cv_type
= make_restrict_type (base_type
);
17178 return set_die_type (die
, cv_type
, cu
);
17181 /* Handle DW_TAG_atomic_type. */
17183 static struct type
*
17184 read_tag_atomic_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17186 struct type
*base_type
, *cv_type
;
17188 base_type
= die_type (die
, cu
);
17190 /* The die_type call above may have already set the type for this DIE. */
17191 cv_type
= get_die_type (die
, cu
);
17195 cv_type
= make_atomic_type (base_type
);
17196 return set_die_type (die
, cv_type
, cu
);
17199 /* Extract all information from a DW_TAG_string_type DIE and add to
17200 the user defined type vector. It isn't really a user defined type,
17201 but it behaves like one, with other DIE's using an AT_user_def_type
17202 attribute to reference it. */
17204 static struct type
*
17205 read_tag_string_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17207 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17208 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17209 struct type
*type
, *range_type
, *index_type
, *char_type
;
17210 struct attribute
*attr
;
17211 unsigned int length
;
17213 attr
= dwarf2_attr (die
, DW_AT_string_length
, cu
);
17216 length
= DW_UNSND (attr
);
17220 /* Check for the DW_AT_byte_size attribute. */
17221 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17224 length
= DW_UNSND (attr
);
17232 index_type
= objfile_type (objfile
)->builtin_int
;
17233 range_type
= create_static_range_type (NULL
, index_type
, 1, length
);
17234 char_type
= language_string_char_type (cu
->language_defn
, gdbarch
);
17235 type
= create_string_type (NULL
, char_type
, range_type
);
17237 return set_die_type (die
, type
, cu
);
17240 /* Assuming that DIE corresponds to a function, returns nonzero
17241 if the function is prototyped. */
17244 prototyped_function_p (struct die_info
*die
, struct dwarf2_cu
*cu
)
17246 struct attribute
*attr
;
17248 attr
= dwarf2_attr (die
, DW_AT_prototyped
, cu
);
17249 if (attr
&& (DW_UNSND (attr
) != 0))
17252 /* The DWARF standard implies that the DW_AT_prototyped attribute
17253 is only meaninful for C, but the concept also extends to other
17254 languages that allow unprototyped functions (Eg: Objective C).
17255 For all other languages, assume that functions are always
17257 if (cu
->language
!= language_c
17258 && cu
->language
!= language_objc
17259 && cu
->language
!= language_opencl
)
17262 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17263 prototyped and unprototyped functions; default to prototyped,
17264 since that is more common in modern code (and RealView warns
17265 about unprototyped functions). */
17266 if (producer_is_realview (cu
->producer
))
17272 /* Handle DIES due to C code like:
17276 int (*funcp)(int a, long l);
17280 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17282 static struct type
*
17283 read_subroutine_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17285 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17286 struct type
*type
; /* Type that this function returns. */
17287 struct type
*ftype
; /* Function that returns above type. */
17288 struct attribute
*attr
;
17290 type
= die_type (die
, cu
);
17292 /* The die_type call above may have already set the type for this DIE. */
17293 ftype
= get_die_type (die
, cu
);
17297 ftype
= lookup_function_type (type
);
17299 if (prototyped_function_p (die
, cu
))
17300 TYPE_PROTOTYPED (ftype
) = 1;
17302 /* Store the calling convention in the type if it's available in
17303 the subroutine die. Otherwise set the calling convention to
17304 the default value DW_CC_normal. */
17305 attr
= dwarf2_attr (die
, DW_AT_calling_convention
, cu
);
17307 TYPE_CALLING_CONVENTION (ftype
) = DW_UNSND (attr
);
17308 else if (cu
->producer
&& strstr (cu
->producer
, "IBM XL C for OpenCL"))
17309 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_GDB_IBM_OpenCL
;
17311 TYPE_CALLING_CONVENTION (ftype
) = DW_CC_normal
;
17313 /* Record whether the function returns normally to its caller or not
17314 if the DWARF producer set that information. */
17315 attr
= dwarf2_attr (die
, DW_AT_noreturn
, cu
);
17316 if (attr
&& (DW_UNSND (attr
) != 0))
17317 TYPE_NO_RETURN (ftype
) = 1;
17319 /* We need to add the subroutine type to the die immediately so
17320 we don't infinitely recurse when dealing with parameters
17321 declared as the same subroutine type. */
17322 set_die_type (die
, ftype
, cu
);
17324 if (die
->child
!= NULL
)
17326 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
17327 struct die_info
*child_die
;
17328 int nparams
, iparams
;
17330 /* Count the number of parameters.
17331 FIXME: GDB currently ignores vararg functions, but knows about
17332 vararg member functions. */
17334 child_die
= die
->child
;
17335 while (child_die
&& child_die
->tag
)
17337 if (child_die
->tag
== DW_TAG_formal_parameter
)
17339 else if (child_die
->tag
== DW_TAG_unspecified_parameters
)
17340 TYPE_VARARGS (ftype
) = 1;
17341 child_die
= sibling_die (child_die
);
17344 /* Allocate storage for parameters and fill them in. */
17345 TYPE_NFIELDS (ftype
) = nparams
;
17346 TYPE_FIELDS (ftype
) = (struct field
*)
17347 TYPE_ZALLOC (ftype
, nparams
* sizeof (struct field
));
17349 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17350 even if we error out during the parameters reading below. */
17351 for (iparams
= 0; iparams
< nparams
; iparams
++)
17352 TYPE_FIELD_TYPE (ftype
, iparams
) = void_type
;
17355 child_die
= die
->child
;
17356 while (child_die
&& child_die
->tag
)
17358 if (child_die
->tag
== DW_TAG_formal_parameter
)
17360 struct type
*arg_type
;
17362 /* DWARF version 2 has no clean way to discern C++
17363 static and non-static member functions. G++ helps
17364 GDB by marking the first parameter for non-static
17365 member functions (which is the this pointer) as
17366 artificial. We pass this information to
17367 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17369 DWARF version 3 added DW_AT_object_pointer, which GCC
17370 4.5 does not yet generate. */
17371 attr
= dwarf2_attr (child_die
, DW_AT_artificial
, cu
);
17373 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = DW_UNSND (attr
);
17375 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
17376 arg_type
= die_type (child_die
, cu
);
17378 /* RealView does not mark THIS as const, which the testsuite
17379 expects. GCC marks THIS as const in method definitions,
17380 but not in the class specifications (GCC PR 43053). */
17381 if (cu
->language
== language_cplus
&& !TYPE_CONST (arg_type
)
17382 && TYPE_FIELD_ARTIFICIAL (ftype
, iparams
))
17385 struct dwarf2_cu
*arg_cu
= cu
;
17386 const char *name
= dwarf2_name (child_die
, cu
);
17388 attr
= dwarf2_attr (die
, DW_AT_object_pointer
, cu
);
17391 /* If the compiler emits this, use it. */
17392 if (follow_die_ref (die
, attr
, &arg_cu
) == child_die
)
17395 else if (name
&& strcmp (name
, "this") == 0)
17396 /* Function definitions will have the argument names. */
17398 else if (name
== NULL
&& iparams
== 0)
17399 /* Declarations may not have the names, so like
17400 elsewhere in GDB, assume an artificial first
17401 argument is "this". */
17405 arg_type
= make_cv_type (1, TYPE_VOLATILE (arg_type
),
17409 TYPE_FIELD_TYPE (ftype
, iparams
) = arg_type
;
17412 child_die
= sibling_die (child_die
);
17419 static struct type
*
17420 read_typedef (struct die_info
*die
, struct dwarf2_cu
*cu
)
17422 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17423 const char *name
= NULL
;
17424 struct type
*this_type
, *target_type
;
17426 name
= dwarf2_full_name (NULL
, die
, cu
);
17427 this_type
= init_type (objfile
, TYPE_CODE_TYPEDEF
, 0, name
);
17428 TYPE_TARGET_STUB (this_type
) = 1;
17429 set_die_type (die
, this_type
, cu
);
17430 target_type
= die_type (die
, cu
);
17431 if (target_type
!= this_type
)
17432 TYPE_TARGET_TYPE (this_type
) = target_type
;
17435 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17436 spec and cause infinite loops in GDB. */
17437 complaint (_("Self-referential DW_TAG_typedef "
17438 "- DIE at %s [in module %s]"),
17439 sect_offset_str (die
->sect_off
), objfile_name (objfile
));
17440 TYPE_TARGET_TYPE (this_type
) = NULL
;
17445 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17446 (which may be different from NAME) to the architecture back-end to allow
17447 it to guess the correct format if necessary. */
17449 static struct type
*
17450 dwarf2_init_float_type (struct objfile
*objfile
, int bits
, const char *name
,
17451 const char *name_hint
)
17453 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17454 const struct floatformat
**format
;
17457 format
= gdbarch_floatformat_for_type (gdbarch
, name_hint
, bits
);
17459 type
= init_float_type (objfile
, bits
, name
, format
);
17461 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17466 /* Allocate an integer type of size BITS and name NAME. */
17468 static struct type
*
17469 dwarf2_init_integer_type (struct dwarf2_cu
*cu
, struct objfile
*objfile
,
17470 int bits
, int unsigned_p
, const char *name
)
17474 /* Versions of Intel's C Compiler generate an integer type called "void"
17475 instead of using DW_TAG_unspecified_type. This has been seen on
17476 at least versions 14, 17, and 18. */
17477 if (bits
== 0 && producer_is_icc (cu
) && name
!= nullptr
17478 && strcmp (name
, "void") == 0)
17479 type
= objfile_type (objfile
)->builtin_void
;
17481 type
= init_integer_type (objfile
, bits
, unsigned_p
, name
);
17486 /* Initialise and return a floating point type of size BITS suitable for
17487 use as a component of a complex number. The NAME_HINT is passed through
17488 when initialising the floating point type and is the name of the complex
17491 As DWARF doesn't currently provide an explicit name for the components
17492 of a complex number, but it can be helpful to have these components
17493 named, we try to select a suitable name based on the size of the
17495 static struct type
*
17496 dwarf2_init_complex_target_type (struct dwarf2_cu
*cu
,
17497 struct objfile
*objfile
,
17498 int bits
, const char *name_hint
)
17500 gdbarch
*gdbarch
= get_objfile_arch (objfile
);
17501 struct type
*tt
= nullptr;
17503 /* Try to find a suitable floating point builtin type of size BITS.
17504 We're going to use the name of this type as the name for the complex
17505 target type that we are about to create. */
17506 switch (cu
->language
)
17508 case language_fortran
:
17512 tt
= builtin_f_type (gdbarch
)->builtin_real
;
17515 tt
= builtin_f_type (gdbarch
)->builtin_real_s8
;
17517 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17519 tt
= builtin_f_type (gdbarch
)->builtin_real_s16
;
17527 tt
= builtin_type (gdbarch
)->builtin_float
;
17530 tt
= builtin_type (gdbarch
)->builtin_double
;
17532 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17534 tt
= builtin_type (gdbarch
)->builtin_long_double
;
17540 /* If the type we found doesn't match the size we were looking for, then
17541 pretend we didn't find a type at all, the complex target type we
17542 create will then be nameless. */
17543 if (tt
!= nullptr && TYPE_LENGTH (tt
) * TARGET_CHAR_BIT
!= bits
)
17546 const char *name
= (tt
== nullptr) ? nullptr : TYPE_NAME (tt
);
17547 return dwarf2_init_float_type (objfile
, bits
, name
, name_hint
);
17550 /* Find a representation of a given base type and install
17551 it in the TYPE field of the die. */
17553 static struct type
*
17554 read_base_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17556 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
17558 struct attribute
*attr
;
17559 int encoding
= 0, bits
= 0;
17562 attr
= dwarf2_attr (die
, DW_AT_encoding
, cu
);
17565 encoding
= DW_UNSND (attr
);
17567 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17570 bits
= DW_UNSND (attr
) * TARGET_CHAR_BIT
;
17572 name
= dwarf2_name (die
, cu
);
17575 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17580 case DW_ATE_address
:
17581 /* Turn DW_ATE_address into a void * pointer. */
17582 type
= init_type (objfile
, TYPE_CODE_VOID
, TARGET_CHAR_BIT
, NULL
);
17583 type
= init_pointer_type (objfile
, bits
, name
, type
);
17585 case DW_ATE_boolean
:
17586 type
= init_boolean_type (objfile
, bits
, 1, name
);
17588 case DW_ATE_complex_float
:
17589 type
= dwarf2_init_complex_target_type (cu
, objfile
, bits
/ 2, name
);
17590 type
= init_complex_type (objfile
, name
, type
);
17592 case DW_ATE_decimal_float
:
17593 type
= init_decfloat_type (objfile
, bits
, name
);
17596 type
= dwarf2_init_float_type (objfile
, bits
, name
, name
);
17598 case DW_ATE_signed
:
17599 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
17601 case DW_ATE_unsigned
:
17602 if (cu
->language
== language_fortran
17604 && startswith (name
, "character("))
17605 type
= init_character_type (objfile
, bits
, 1, name
);
17607 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17609 case DW_ATE_signed_char
:
17610 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17611 || cu
->language
== language_pascal
17612 || cu
->language
== language_fortran
)
17613 type
= init_character_type (objfile
, bits
, 0, name
);
17615 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 0, name
);
17617 case DW_ATE_unsigned_char
:
17618 if (cu
->language
== language_ada
|| cu
->language
== language_m2
17619 || cu
->language
== language_pascal
17620 || cu
->language
== language_fortran
17621 || cu
->language
== language_rust
)
17622 type
= init_character_type (objfile
, bits
, 1, name
);
17624 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17628 gdbarch
*arch
= get_objfile_arch (objfile
);
17631 type
= builtin_type (arch
)->builtin_char16
;
17632 else if (bits
== 32)
17633 type
= builtin_type (arch
)->builtin_char32
;
17636 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17638 type
= dwarf2_init_integer_type (cu
, objfile
, bits
, 1, name
);
17640 return set_die_type (die
, type
, cu
);
17645 complaint (_("unsupported DW_AT_encoding: '%s'"),
17646 dwarf_type_encoding_name (encoding
));
17647 type
= init_type (objfile
, TYPE_CODE_ERROR
, bits
, name
);
17651 if (name
&& strcmp (name
, "char") == 0)
17652 TYPE_NOSIGN (type
) = 1;
17654 maybe_set_alignment (cu
, die
, type
);
17656 return set_die_type (die
, type
, cu
);
17659 /* Parse dwarf attribute if it's a block, reference or constant and put the
17660 resulting value of the attribute into struct bound_prop.
17661 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17664 attr_to_dynamic_prop (const struct attribute
*attr
, struct die_info
*die
,
17665 struct dwarf2_cu
*cu
, struct dynamic_prop
*prop
,
17666 struct type
*default_type
)
17668 struct dwarf2_property_baton
*baton
;
17669 struct obstack
*obstack
17670 = &cu
->per_cu
->dwarf2_per_objfile
->objfile
->objfile_obstack
;
17672 gdb_assert (default_type
!= NULL
);
17674 if (attr
== NULL
|| prop
== NULL
)
17677 if (attr_form_is_block (attr
))
17679 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17680 baton
->property_type
= default_type
;
17681 baton
->locexpr
.per_cu
= cu
->per_cu
;
17682 baton
->locexpr
.size
= DW_BLOCK (attr
)->size
;
17683 baton
->locexpr
.data
= DW_BLOCK (attr
)->data
;
17684 baton
->locexpr
.is_reference
= false;
17685 prop
->data
.baton
= baton
;
17686 prop
->kind
= PROP_LOCEXPR
;
17687 gdb_assert (prop
->data
.baton
!= NULL
);
17689 else if (attr_form_is_ref (attr
))
17691 struct dwarf2_cu
*target_cu
= cu
;
17692 struct die_info
*target_die
;
17693 struct attribute
*target_attr
;
17695 target_die
= follow_die_ref (die
, attr
, &target_cu
);
17696 target_attr
= dwarf2_attr (target_die
, DW_AT_location
, target_cu
);
17697 if (target_attr
== NULL
)
17698 target_attr
= dwarf2_attr (target_die
, DW_AT_data_member_location
,
17700 if (target_attr
== NULL
)
17703 switch (target_attr
->name
)
17705 case DW_AT_location
:
17706 if (attr_form_is_section_offset (target_attr
))
17708 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17709 baton
->property_type
= die_type (target_die
, target_cu
);
17710 fill_in_loclist_baton (cu
, &baton
->loclist
, target_attr
);
17711 prop
->data
.baton
= baton
;
17712 prop
->kind
= PROP_LOCLIST
;
17713 gdb_assert (prop
->data
.baton
!= NULL
);
17715 else if (attr_form_is_block (target_attr
))
17717 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17718 baton
->property_type
= die_type (target_die
, target_cu
);
17719 baton
->locexpr
.per_cu
= cu
->per_cu
;
17720 baton
->locexpr
.size
= DW_BLOCK (target_attr
)->size
;
17721 baton
->locexpr
.data
= DW_BLOCK (target_attr
)->data
;
17722 baton
->locexpr
.is_reference
= true;
17723 prop
->data
.baton
= baton
;
17724 prop
->kind
= PROP_LOCEXPR
;
17725 gdb_assert (prop
->data
.baton
!= NULL
);
17729 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17730 "dynamic property");
17734 case DW_AT_data_member_location
:
17738 if (!handle_data_member_location (target_die
, target_cu
,
17742 baton
= XOBNEW (obstack
, struct dwarf2_property_baton
);
17743 baton
->property_type
= read_type_die (target_die
->parent
,
17745 baton
->offset_info
.offset
= offset
;
17746 baton
->offset_info
.type
= die_type (target_die
, target_cu
);
17747 prop
->data
.baton
= baton
;
17748 prop
->kind
= PROP_ADDR_OFFSET
;
17753 else if (attr_form_is_constant (attr
))
17755 prop
->data
.const_val
= dwarf2_get_attr_constant_value (attr
, 0);
17756 prop
->kind
= PROP_CONST
;
17760 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr
->form
),
17761 dwarf2_name (die
, cu
));
17768 /* Find an integer type the same size as the address size given in the
17769 compilation unit header for PER_CU. UNSIGNED_P controls if the integer
17770 is unsigned or not. */
17772 static struct type
*
17773 dwarf2_per_cu_addr_sized_int_type (struct dwarf2_per_cu_data
*per_cu
,
17776 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
17777 int addr_size
= dwarf2_per_cu_addr_size (per_cu
);
17778 struct type
*int_type
;
17780 /* Helper macro to examine the various builtin types. */
17781 #define TRY_TYPE(F) \
17782 int_type = (unsigned_p \
17783 ? objfile_type (objfile)->builtin_unsigned_ ## F \
17784 : objfile_type (objfile)->builtin_ ## F); \
17785 if (int_type != NULL && TYPE_LENGTH (int_type) == addr_size) \
17792 TRY_TYPE (long_long
);
17796 gdb_assert_not_reached ("unable to find suitable integer type");
17799 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
17800 present (which is valid) then compute the default type based on the
17801 compilation units address size. */
17803 static struct type
*
17804 read_subrange_index_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17806 struct type
*index_type
= die_type (die
, cu
);
17808 /* Dwarf-2 specifications explicitly allows to create subrange types
17809 without specifying a base type.
17810 In that case, the base type must be set to the type of
17811 the lower bound, upper bound or count, in that order, if any of these
17812 three attributes references an object that has a type.
17813 If no base type is found, the Dwarf-2 specifications say that
17814 a signed integer type of size equal to the size of an address should
17816 For the following C code: `extern char gdb_int [];'
17817 GCC produces an empty range DIE.
17818 FIXME: muller/2010-05-28: Possible references to object for low bound,
17819 high bound or count are not yet handled by this code. */
17820 if (TYPE_CODE (index_type
) == TYPE_CODE_VOID
)
17821 index_type
= dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
17826 /* Read the given DW_AT_subrange DIE. */
17828 static struct type
*
17829 read_subrange_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17831 struct type
*base_type
, *orig_base_type
;
17832 struct type
*range_type
;
17833 struct attribute
*attr
;
17834 struct dynamic_prop low
, high
;
17835 int low_default_is_valid
;
17836 int high_bound_is_count
= 0;
17838 ULONGEST negative_mask
;
17840 orig_base_type
= read_subrange_index_type (die
, cu
);
17842 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17843 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17844 creating the range type, but we use the result of check_typedef
17845 when examining properties of the type. */
17846 base_type
= check_typedef (orig_base_type
);
17848 /* The die_type call above may have already set the type for this DIE. */
17849 range_type
= get_die_type (die
, cu
);
17853 low
.kind
= PROP_CONST
;
17854 high
.kind
= PROP_CONST
;
17855 high
.data
.const_val
= 0;
17857 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17858 omitting DW_AT_lower_bound. */
17859 switch (cu
->language
)
17862 case language_cplus
:
17863 low
.data
.const_val
= 0;
17864 low_default_is_valid
= 1;
17866 case language_fortran
:
17867 low
.data
.const_val
= 1;
17868 low_default_is_valid
= 1;
17871 case language_objc
:
17872 case language_rust
:
17873 low
.data
.const_val
= 0;
17874 low_default_is_valid
= (cu
->header
.version
>= 4);
17878 case language_pascal
:
17879 low
.data
.const_val
= 1;
17880 low_default_is_valid
= (cu
->header
.version
>= 4);
17883 low
.data
.const_val
= 0;
17884 low_default_is_valid
= 0;
17888 attr
= dwarf2_attr (die
, DW_AT_lower_bound
, cu
);
17890 attr_to_dynamic_prop (attr
, die
, cu
, &low
, base_type
);
17891 else if (!low_default_is_valid
)
17892 complaint (_("Missing DW_AT_lower_bound "
17893 "- DIE at %s [in module %s]"),
17894 sect_offset_str (die
->sect_off
),
17895 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17897 struct attribute
*attr_ub
, *attr_count
;
17898 attr
= attr_ub
= dwarf2_attr (die
, DW_AT_upper_bound
, cu
);
17899 if (!attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
17901 attr
= attr_count
= dwarf2_attr (die
, DW_AT_count
, cu
);
17902 if (attr_to_dynamic_prop (attr
, die
, cu
, &high
, base_type
))
17904 /* If bounds are constant do the final calculation here. */
17905 if (low
.kind
== PROP_CONST
&& high
.kind
== PROP_CONST
)
17906 high
.data
.const_val
= low
.data
.const_val
+ high
.data
.const_val
- 1;
17908 high_bound_is_count
= 1;
17912 if (attr_ub
!= NULL
)
17913 complaint (_("Unresolved DW_AT_upper_bound "
17914 "- DIE at %s [in module %s]"),
17915 sect_offset_str (die
->sect_off
),
17916 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17917 if (attr_count
!= NULL
)
17918 complaint (_("Unresolved DW_AT_count "
17919 "- DIE at %s [in module %s]"),
17920 sect_offset_str (die
->sect_off
),
17921 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
17925 /* Normally, the DWARF producers are expected to use a signed
17926 constant form (Eg. DW_FORM_sdata) to express negative bounds.
17927 But this is unfortunately not always the case, as witnessed
17928 with GCC, for instance, where the ambiguous DW_FORM_dataN form
17929 is used instead. To work around that ambiguity, we treat
17930 the bounds as signed, and thus sign-extend their values, when
17931 the base type is signed. */
17933 -((ULONGEST
) 1 << (TYPE_LENGTH (base_type
) * TARGET_CHAR_BIT
- 1));
17934 if (low
.kind
== PROP_CONST
17935 && !TYPE_UNSIGNED (base_type
) && (low
.data
.const_val
& negative_mask
))
17936 low
.data
.const_val
|= negative_mask
;
17937 if (high
.kind
== PROP_CONST
17938 && !TYPE_UNSIGNED (base_type
) && (high
.data
.const_val
& negative_mask
))
17939 high
.data
.const_val
|= negative_mask
;
17941 range_type
= create_range_type (NULL
, orig_base_type
, &low
, &high
);
17943 if (high_bound_is_count
)
17944 TYPE_RANGE_DATA (range_type
)->flag_upper_bound_is_count
= 1;
17946 /* Ada expects an empty array on no boundary attributes. */
17947 if (attr
== NULL
&& cu
->language
!= language_ada
)
17948 TYPE_HIGH_BOUND_KIND (range_type
) = PROP_UNDEFINED
;
17950 name
= dwarf2_name (die
, cu
);
17952 TYPE_NAME (range_type
) = name
;
17954 attr
= dwarf2_attr (die
, DW_AT_byte_size
, cu
);
17956 TYPE_LENGTH (range_type
) = DW_UNSND (attr
);
17958 maybe_set_alignment (cu
, die
, range_type
);
17960 set_die_type (die
, range_type
, cu
);
17962 /* set_die_type should be already done. */
17963 set_descriptive_type (range_type
, die
, cu
);
17968 static struct type
*
17969 read_unspecified_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
17973 type
= init_type (cu
->per_cu
->dwarf2_per_objfile
->objfile
, TYPE_CODE_VOID
,0,
17975 TYPE_NAME (type
) = dwarf2_name (die
, cu
);
17977 /* In Ada, an unspecified type is typically used when the description
17978 of the type is defered to a different unit. When encountering
17979 such a type, we treat it as a stub, and try to resolve it later on,
17981 if (cu
->language
== language_ada
)
17982 TYPE_STUB (type
) = 1;
17984 return set_die_type (die
, type
, cu
);
17987 /* Read a single die and all its descendents. Set the die's sibling
17988 field to NULL; set other fields in the die correctly, and set all
17989 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
17990 location of the info_ptr after reading all of those dies. PARENT
17991 is the parent of the die in question. */
17993 static struct die_info
*
17994 read_die_and_children (const struct die_reader_specs
*reader
,
17995 const gdb_byte
*info_ptr
,
17996 const gdb_byte
**new_info_ptr
,
17997 struct die_info
*parent
)
17999 struct die_info
*die
;
18000 const gdb_byte
*cur_ptr
;
18003 cur_ptr
= read_full_die_1 (reader
, &die
, info_ptr
, &has_children
, 0);
18006 *new_info_ptr
= cur_ptr
;
18009 store_in_ref_table (die
, reader
->cu
);
18012 die
->child
= read_die_and_siblings_1 (reader
, cur_ptr
, new_info_ptr
, die
);
18016 *new_info_ptr
= cur_ptr
;
18019 die
->sibling
= NULL
;
18020 die
->parent
= parent
;
18024 /* Read a die, all of its descendents, and all of its siblings; set
18025 all of the fields of all of the dies correctly. Arguments are as
18026 in read_die_and_children. */
18028 static struct die_info
*
18029 read_die_and_siblings_1 (const struct die_reader_specs
*reader
,
18030 const gdb_byte
*info_ptr
,
18031 const gdb_byte
**new_info_ptr
,
18032 struct die_info
*parent
)
18034 struct die_info
*first_die
, *last_sibling
;
18035 const gdb_byte
*cur_ptr
;
18037 cur_ptr
= info_ptr
;
18038 first_die
= last_sibling
= NULL
;
18042 struct die_info
*die
18043 = read_die_and_children (reader
, cur_ptr
, &cur_ptr
, parent
);
18047 *new_info_ptr
= cur_ptr
;
18054 last_sibling
->sibling
= die
;
18056 last_sibling
= die
;
18060 /* Read a die, all of its descendents, and all of its siblings; set
18061 all of the fields of all of the dies correctly. Arguments are as
18062 in read_die_and_children.
18063 This the main entry point for reading a DIE and all its children. */
18065 static struct die_info
*
18066 read_die_and_siblings (const struct die_reader_specs
*reader
,
18067 const gdb_byte
*info_ptr
,
18068 const gdb_byte
**new_info_ptr
,
18069 struct die_info
*parent
)
18071 struct die_info
*die
= read_die_and_siblings_1 (reader
, info_ptr
,
18072 new_info_ptr
, parent
);
18074 if (dwarf_die_debug
)
18076 fprintf_unfiltered (gdb_stdlog
,
18077 "Read die from %s@0x%x of %s:\n",
18078 get_section_name (reader
->die_section
),
18079 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18080 bfd_get_filename (reader
->abfd
));
18081 dump_die (die
, dwarf_die_debug
);
18087 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18089 The caller is responsible for filling in the extra attributes
18090 and updating (*DIEP)->num_attrs.
18091 Set DIEP to point to a newly allocated die with its information,
18092 except for its child, sibling, and parent fields.
18093 Set HAS_CHILDREN to tell whether the die has children or not. */
18095 static const gdb_byte
*
18096 read_full_die_1 (const struct die_reader_specs
*reader
,
18097 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18098 int *has_children
, int num_extra_attrs
)
18100 unsigned int abbrev_number
, bytes_read
, i
;
18101 struct abbrev_info
*abbrev
;
18102 struct die_info
*die
;
18103 struct dwarf2_cu
*cu
= reader
->cu
;
18104 bfd
*abfd
= reader
->abfd
;
18106 sect_offset sect_off
= (sect_offset
) (info_ptr
- reader
->buffer
);
18107 abbrev_number
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
18108 info_ptr
+= bytes_read
;
18109 if (!abbrev_number
)
18116 abbrev
= reader
->abbrev_table
->lookup_abbrev (abbrev_number
);
18118 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18120 bfd_get_filename (abfd
));
18122 die
= dwarf_alloc_die (cu
, abbrev
->num_attrs
+ num_extra_attrs
);
18123 die
->sect_off
= sect_off
;
18124 die
->tag
= abbrev
->tag
;
18125 die
->abbrev
= abbrev_number
;
18127 /* Make the result usable.
18128 The caller needs to update num_attrs after adding the extra
18130 die
->num_attrs
= abbrev
->num_attrs
;
18132 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
18133 info_ptr
= read_attribute (reader
, &die
->attrs
[i
], &abbrev
->attrs
[i
],
18137 *has_children
= abbrev
->has_children
;
18141 /* Read a die and all its attributes.
18142 Set DIEP to point to a newly allocated die with its information,
18143 except for its child, sibling, and parent fields.
18144 Set HAS_CHILDREN to tell whether the die has children or not. */
18146 static const gdb_byte
*
18147 read_full_die (const struct die_reader_specs
*reader
,
18148 struct die_info
**diep
, const gdb_byte
*info_ptr
,
18151 const gdb_byte
*result
;
18153 result
= read_full_die_1 (reader
, diep
, info_ptr
, has_children
, 0);
18155 if (dwarf_die_debug
)
18157 fprintf_unfiltered (gdb_stdlog
,
18158 "Read die from %s@0x%x of %s:\n",
18159 get_section_name (reader
->die_section
),
18160 (unsigned) (info_ptr
- reader
->die_section
->buffer
),
18161 bfd_get_filename (reader
->abfd
));
18162 dump_die (*diep
, dwarf_die_debug
);
18168 /* Abbreviation tables.
18170 In DWARF version 2, the description of the debugging information is
18171 stored in a separate .debug_abbrev section. Before we read any
18172 dies from a section we read in all abbreviations and install them
18173 in a hash table. */
18175 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18177 struct abbrev_info
*
18178 abbrev_table::alloc_abbrev ()
18180 struct abbrev_info
*abbrev
;
18182 abbrev
= XOBNEW (&abbrev_obstack
, struct abbrev_info
);
18183 memset (abbrev
, 0, sizeof (struct abbrev_info
));
18188 /* Add an abbreviation to the table. */
18191 abbrev_table::add_abbrev (unsigned int abbrev_number
,
18192 struct abbrev_info
*abbrev
)
18194 unsigned int hash_number
;
18196 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
18197 abbrev
->next
= m_abbrevs
[hash_number
];
18198 m_abbrevs
[hash_number
] = abbrev
;
18201 /* Look up an abbrev in the table.
18202 Returns NULL if the abbrev is not found. */
18204 struct abbrev_info
*
18205 abbrev_table::lookup_abbrev (unsigned int abbrev_number
)
18207 unsigned int hash_number
;
18208 struct abbrev_info
*abbrev
;
18210 hash_number
= abbrev_number
% ABBREV_HASH_SIZE
;
18211 abbrev
= m_abbrevs
[hash_number
];
18215 if (abbrev
->number
== abbrev_number
)
18217 abbrev
= abbrev
->next
;
18222 /* Read in an abbrev table. */
18224 static abbrev_table_up
18225 abbrev_table_read_table (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
18226 struct dwarf2_section_info
*section
,
18227 sect_offset sect_off
)
18229 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18230 bfd
*abfd
= get_section_bfd_owner (section
);
18231 const gdb_byte
*abbrev_ptr
;
18232 struct abbrev_info
*cur_abbrev
;
18233 unsigned int abbrev_number
, bytes_read
, abbrev_name
;
18234 unsigned int abbrev_form
;
18235 struct attr_abbrev
*cur_attrs
;
18236 unsigned int allocated_attrs
;
18238 abbrev_table_up
abbrev_table (new struct abbrev_table (sect_off
));
18240 dwarf2_read_section (objfile
, section
);
18241 abbrev_ptr
= section
->buffer
+ to_underlying (sect_off
);
18242 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18243 abbrev_ptr
+= bytes_read
;
18245 allocated_attrs
= ATTR_ALLOC_CHUNK
;
18246 cur_attrs
= XNEWVEC (struct attr_abbrev
, allocated_attrs
);
18248 /* Loop until we reach an abbrev number of 0. */
18249 while (abbrev_number
)
18251 cur_abbrev
= abbrev_table
->alloc_abbrev ();
18253 /* read in abbrev header */
18254 cur_abbrev
->number
= abbrev_number
;
18256 = (enum dwarf_tag
) read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18257 abbrev_ptr
+= bytes_read
;
18258 cur_abbrev
->has_children
= read_1_byte (abfd
, abbrev_ptr
);
18261 /* now read in declarations */
18264 LONGEST implicit_const
;
18266 abbrev_name
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18267 abbrev_ptr
+= bytes_read
;
18268 abbrev_form
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18269 abbrev_ptr
+= bytes_read
;
18270 if (abbrev_form
== DW_FORM_implicit_const
)
18272 implicit_const
= read_signed_leb128 (abfd
, abbrev_ptr
,
18274 abbrev_ptr
+= bytes_read
;
18278 /* Initialize it due to a false compiler warning. */
18279 implicit_const
= -1;
18282 if (abbrev_name
== 0)
18285 if (cur_abbrev
->num_attrs
== allocated_attrs
)
18287 allocated_attrs
+= ATTR_ALLOC_CHUNK
;
18289 = XRESIZEVEC (struct attr_abbrev
, cur_attrs
, allocated_attrs
);
18292 cur_attrs
[cur_abbrev
->num_attrs
].name
18293 = (enum dwarf_attribute
) abbrev_name
;
18294 cur_attrs
[cur_abbrev
->num_attrs
].form
18295 = (enum dwarf_form
) abbrev_form
;
18296 cur_attrs
[cur_abbrev
->num_attrs
].implicit_const
= implicit_const
;
18297 ++cur_abbrev
->num_attrs
;
18300 cur_abbrev
->attrs
=
18301 XOBNEWVEC (&abbrev_table
->abbrev_obstack
, struct attr_abbrev
,
18302 cur_abbrev
->num_attrs
);
18303 memcpy (cur_abbrev
->attrs
, cur_attrs
,
18304 cur_abbrev
->num_attrs
* sizeof (struct attr_abbrev
));
18306 abbrev_table
->add_abbrev (abbrev_number
, cur_abbrev
);
18308 /* Get next abbreviation.
18309 Under Irix6 the abbreviations for a compilation unit are not
18310 always properly terminated with an abbrev number of 0.
18311 Exit loop if we encounter an abbreviation which we have
18312 already read (which means we are about to read the abbreviations
18313 for the next compile unit) or if the end of the abbreviation
18314 table is reached. */
18315 if ((unsigned int) (abbrev_ptr
- section
->buffer
) >= section
->size
)
18317 abbrev_number
= read_unsigned_leb128 (abfd
, abbrev_ptr
, &bytes_read
);
18318 abbrev_ptr
+= bytes_read
;
18319 if (abbrev_table
->lookup_abbrev (abbrev_number
) != NULL
)
18324 return abbrev_table
;
18327 /* Returns nonzero if TAG represents a type that we might generate a partial
18331 is_type_tag_for_partial (int tag
)
18336 /* Some types that would be reasonable to generate partial symbols for,
18337 that we don't at present. */
18338 case DW_TAG_array_type
:
18339 case DW_TAG_file_type
:
18340 case DW_TAG_ptr_to_member_type
:
18341 case DW_TAG_set_type
:
18342 case DW_TAG_string_type
:
18343 case DW_TAG_subroutine_type
:
18345 case DW_TAG_base_type
:
18346 case DW_TAG_class_type
:
18347 case DW_TAG_interface_type
:
18348 case DW_TAG_enumeration_type
:
18349 case DW_TAG_structure_type
:
18350 case DW_TAG_subrange_type
:
18351 case DW_TAG_typedef
:
18352 case DW_TAG_union_type
:
18359 /* Load all DIEs that are interesting for partial symbols into memory. */
18361 static struct partial_die_info
*
18362 load_partial_dies (const struct die_reader_specs
*reader
,
18363 const gdb_byte
*info_ptr
, int building_psymtab
)
18365 struct dwarf2_cu
*cu
= reader
->cu
;
18366 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
18367 struct partial_die_info
*parent_die
, *last_die
, *first_die
= NULL
;
18368 unsigned int bytes_read
;
18369 unsigned int load_all
= 0;
18370 int nesting_level
= 1;
18375 gdb_assert (cu
->per_cu
!= NULL
);
18376 if (cu
->per_cu
->load_all_dies
)
18380 = htab_create_alloc_ex (cu
->header
.length
/ 12,
18384 &cu
->comp_unit_obstack
,
18385 hashtab_obstack_allocate
,
18386 dummy_obstack_deallocate
);
18390 abbrev_info
*abbrev
= peek_die_abbrev (*reader
, info_ptr
, &bytes_read
);
18392 /* A NULL abbrev means the end of a series of children. */
18393 if (abbrev
== NULL
)
18395 if (--nesting_level
== 0)
18398 info_ptr
+= bytes_read
;
18399 last_die
= parent_die
;
18400 parent_die
= parent_die
->die_parent
;
18404 /* Check for template arguments. We never save these; if
18405 they're seen, we just mark the parent, and go on our way. */
18406 if (parent_die
!= NULL
18407 && cu
->language
== language_cplus
18408 && (abbrev
->tag
== DW_TAG_template_type_param
18409 || abbrev
->tag
== DW_TAG_template_value_param
))
18411 parent_die
->has_template_arguments
= 1;
18415 /* We don't need a partial DIE for the template argument. */
18416 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18421 /* We only recurse into c++ subprograms looking for template arguments.
18422 Skip their other children. */
18424 && cu
->language
== language_cplus
18425 && parent_die
!= NULL
18426 && parent_die
->tag
== DW_TAG_subprogram
)
18428 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18432 /* Check whether this DIE is interesting enough to save. Normally
18433 we would not be interested in members here, but there may be
18434 later variables referencing them via DW_AT_specification (for
18435 static members). */
18437 && !is_type_tag_for_partial (abbrev
->tag
)
18438 && abbrev
->tag
!= DW_TAG_constant
18439 && abbrev
->tag
!= DW_TAG_enumerator
18440 && abbrev
->tag
!= DW_TAG_subprogram
18441 && abbrev
->tag
!= DW_TAG_inlined_subroutine
18442 && abbrev
->tag
!= DW_TAG_lexical_block
18443 && abbrev
->tag
!= DW_TAG_variable
18444 && abbrev
->tag
!= DW_TAG_namespace
18445 && abbrev
->tag
!= DW_TAG_module
18446 && abbrev
->tag
!= DW_TAG_member
18447 && abbrev
->tag
!= DW_TAG_imported_unit
18448 && abbrev
->tag
!= DW_TAG_imported_declaration
)
18450 /* Otherwise we skip to the next sibling, if any. */
18451 info_ptr
= skip_one_die (reader
, info_ptr
+ bytes_read
, abbrev
);
18455 struct partial_die_info
pdi ((sect_offset
) (info_ptr
- reader
->buffer
),
18458 info_ptr
= pdi
.read (reader
, *abbrev
, info_ptr
+ bytes_read
);
18460 /* This two-pass algorithm for processing partial symbols has a
18461 high cost in cache pressure. Thus, handle some simple cases
18462 here which cover the majority of C partial symbols. DIEs
18463 which neither have specification tags in them, nor could have
18464 specification tags elsewhere pointing at them, can simply be
18465 processed and discarded.
18467 This segment is also optional; scan_partial_symbols and
18468 add_partial_symbol will handle these DIEs if we chain
18469 them in normally. When compilers which do not emit large
18470 quantities of duplicate debug information are more common,
18471 this code can probably be removed. */
18473 /* Any complete simple types at the top level (pretty much all
18474 of them, for a language without namespaces), can be processed
18476 if (parent_die
== NULL
18477 && pdi
.has_specification
== 0
18478 && pdi
.is_declaration
== 0
18479 && ((pdi
.tag
== DW_TAG_typedef
&& !pdi
.has_children
)
18480 || pdi
.tag
== DW_TAG_base_type
18481 || pdi
.tag
== DW_TAG_subrange_type
))
18483 if (building_psymtab
&& pdi
.name
!= NULL
)
18484 add_psymbol_to_list (pdi
.name
, strlen (pdi
.name
), 0,
18485 VAR_DOMAIN
, LOC_TYPEDEF
, -1,
18486 psymbol_placement::STATIC
,
18487 0, cu
->language
, objfile
);
18488 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18492 /* The exception for DW_TAG_typedef with has_children above is
18493 a workaround of GCC PR debug/47510. In the case of this complaint
18494 type_name_or_error will error on such types later.
18496 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18497 it could not find the child DIEs referenced later, this is checked
18498 above. In correct DWARF DW_TAG_typedef should have no children. */
18500 if (pdi
.tag
== DW_TAG_typedef
&& pdi
.has_children
)
18501 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18502 "- DIE at %s [in module %s]"),
18503 sect_offset_str (pdi
.sect_off
), objfile_name (objfile
));
18505 /* If we're at the second level, and we're an enumerator, and
18506 our parent has no specification (meaning possibly lives in a
18507 namespace elsewhere), then we can add the partial symbol now
18508 instead of queueing it. */
18509 if (pdi
.tag
== DW_TAG_enumerator
18510 && parent_die
!= NULL
18511 && parent_die
->die_parent
== NULL
18512 && parent_die
->tag
== DW_TAG_enumeration_type
18513 && parent_die
->has_specification
== 0)
18515 if (pdi
.name
== NULL
)
18516 complaint (_("malformed enumerator DIE ignored"));
18517 else if (building_psymtab
)
18518 add_psymbol_to_list (pdi
.name
, strlen (pdi
.name
), 0,
18519 VAR_DOMAIN
, LOC_CONST
, -1,
18520 cu
->language
== language_cplus
18521 ? psymbol_placement::GLOBAL
18522 : psymbol_placement::STATIC
,
18523 0, cu
->language
, objfile
);
18525 info_ptr
= locate_pdi_sibling (reader
, &pdi
, info_ptr
);
18529 struct partial_die_info
*part_die
18530 = new (&cu
->comp_unit_obstack
) partial_die_info (pdi
);
18532 /* We'll save this DIE so link it in. */
18533 part_die
->die_parent
= parent_die
;
18534 part_die
->die_sibling
= NULL
;
18535 part_die
->die_child
= NULL
;
18537 if (last_die
&& last_die
== parent_die
)
18538 last_die
->die_child
= part_die
;
18540 last_die
->die_sibling
= part_die
;
18542 last_die
= part_die
;
18544 if (first_die
== NULL
)
18545 first_die
= part_die
;
18547 /* Maybe add the DIE to the hash table. Not all DIEs that we
18548 find interesting need to be in the hash table, because we
18549 also have the parent/sibling/child chains; only those that we
18550 might refer to by offset later during partial symbol reading.
18552 For now this means things that might have be the target of a
18553 DW_AT_specification, DW_AT_abstract_origin, or
18554 DW_AT_extension. DW_AT_extension will refer only to
18555 namespaces; DW_AT_abstract_origin refers to functions (and
18556 many things under the function DIE, but we do not recurse
18557 into function DIEs during partial symbol reading) and
18558 possibly variables as well; DW_AT_specification refers to
18559 declarations. Declarations ought to have the DW_AT_declaration
18560 flag. It happens that GCC forgets to put it in sometimes, but
18561 only for functions, not for types.
18563 Adding more things than necessary to the hash table is harmless
18564 except for the performance cost. Adding too few will result in
18565 wasted time in find_partial_die, when we reread the compilation
18566 unit with load_all_dies set. */
18569 || abbrev
->tag
== DW_TAG_constant
18570 || abbrev
->tag
== DW_TAG_subprogram
18571 || abbrev
->tag
== DW_TAG_variable
18572 || abbrev
->tag
== DW_TAG_namespace
18573 || part_die
->is_declaration
)
18577 slot
= htab_find_slot_with_hash (cu
->partial_dies
, part_die
,
18578 to_underlying (part_die
->sect_off
),
18583 /* For some DIEs we want to follow their children (if any). For C
18584 we have no reason to follow the children of structures; for other
18585 languages we have to, so that we can get at method physnames
18586 to infer fully qualified class names, for DW_AT_specification,
18587 and for C++ template arguments. For C++, we also look one level
18588 inside functions to find template arguments (if the name of the
18589 function does not already contain the template arguments).
18591 For Ada, we need to scan the children of subprograms and lexical
18592 blocks as well because Ada allows the definition of nested
18593 entities that could be interesting for the debugger, such as
18594 nested subprograms for instance. */
18595 if (last_die
->has_children
18597 || last_die
->tag
== DW_TAG_namespace
18598 || last_die
->tag
== DW_TAG_module
18599 || last_die
->tag
== DW_TAG_enumeration_type
18600 || (cu
->language
== language_cplus
18601 && last_die
->tag
== DW_TAG_subprogram
18602 && (last_die
->name
== NULL
18603 || strchr (last_die
->name
, '<') == NULL
))
18604 || (cu
->language
!= language_c
18605 && (last_die
->tag
== DW_TAG_class_type
18606 || last_die
->tag
== DW_TAG_interface_type
18607 || last_die
->tag
== DW_TAG_structure_type
18608 || last_die
->tag
== DW_TAG_union_type
))
18609 || (cu
->language
== language_ada
18610 && (last_die
->tag
== DW_TAG_subprogram
18611 || last_die
->tag
== DW_TAG_lexical_block
))))
18614 parent_die
= last_die
;
18618 /* Otherwise we skip to the next sibling, if any. */
18619 info_ptr
= locate_pdi_sibling (reader
, last_die
, info_ptr
);
18621 /* Back to the top, do it again. */
18625 partial_die_info::partial_die_info (sect_offset sect_off_
,
18626 struct abbrev_info
*abbrev
)
18627 : partial_die_info (sect_off_
, abbrev
->tag
, abbrev
->has_children
)
18631 /* Read a minimal amount of information into the minimal die structure.
18632 INFO_PTR should point just after the initial uleb128 of a DIE. */
18635 partial_die_info::read (const struct die_reader_specs
*reader
,
18636 const struct abbrev_info
&abbrev
, const gdb_byte
*info_ptr
)
18638 struct dwarf2_cu
*cu
= reader
->cu
;
18639 struct dwarf2_per_objfile
*dwarf2_per_objfile
18640 = cu
->per_cu
->dwarf2_per_objfile
;
18642 int has_low_pc_attr
= 0;
18643 int has_high_pc_attr
= 0;
18644 int high_pc_relative
= 0;
18646 for (i
= 0; i
< abbrev
.num_attrs
; ++i
)
18648 struct attribute attr
;
18650 info_ptr
= read_attribute (reader
, &attr
, &abbrev
.attrs
[i
], info_ptr
);
18652 /* Store the data if it is of an attribute we want to keep in a
18653 partial symbol table. */
18659 case DW_TAG_compile_unit
:
18660 case DW_TAG_partial_unit
:
18661 case DW_TAG_type_unit
:
18662 /* Compilation units have a DW_AT_name that is a filename, not
18663 a source language identifier. */
18664 case DW_TAG_enumeration_type
:
18665 case DW_TAG_enumerator
:
18666 /* These tags always have simple identifiers already; no need
18667 to canonicalize them. */
18668 name
= DW_STRING (&attr
);
18672 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18675 = dwarf2_canonicalize_name (DW_STRING (&attr
), cu
,
18676 &objfile
->per_bfd
->storage_obstack
);
18681 case DW_AT_linkage_name
:
18682 case DW_AT_MIPS_linkage_name
:
18683 /* Note that both forms of linkage name might appear. We
18684 assume they will be the same, and we only store the last
18686 linkage_name
= DW_STRING (&attr
);
18689 has_low_pc_attr
= 1;
18690 lowpc
= attr_value_as_address (&attr
);
18692 case DW_AT_high_pc
:
18693 has_high_pc_attr
= 1;
18694 highpc
= attr_value_as_address (&attr
);
18695 if (cu
->header
.version
>= 4 && attr_form_is_constant (&attr
))
18696 high_pc_relative
= 1;
18698 case DW_AT_location
:
18699 /* Support the .debug_loc offsets. */
18700 if (attr_form_is_block (&attr
))
18702 d
.locdesc
= DW_BLOCK (&attr
);
18704 else if (attr_form_is_section_offset (&attr
))
18706 dwarf2_complex_location_expr_complaint ();
18710 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18711 "partial symbol information");
18714 case DW_AT_external
:
18715 is_external
= DW_UNSND (&attr
);
18717 case DW_AT_declaration
:
18718 is_declaration
= DW_UNSND (&attr
);
18723 case DW_AT_abstract_origin
:
18724 case DW_AT_specification
:
18725 case DW_AT_extension
:
18726 has_specification
= 1;
18727 spec_offset
= dwarf2_get_ref_die_offset (&attr
);
18728 spec_is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
18729 || cu
->per_cu
->is_dwz
);
18731 case DW_AT_sibling
:
18732 /* Ignore absolute siblings, they might point outside of
18733 the current compile unit. */
18734 if (attr
.form
== DW_FORM_ref_addr
)
18735 complaint (_("ignoring absolute DW_AT_sibling"));
18738 const gdb_byte
*buffer
= reader
->buffer
;
18739 sect_offset off
= dwarf2_get_ref_die_offset (&attr
);
18740 const gdb_byte
*sibling_ptr
= buffer
+ to_underlying (off
);
18742 if (sibling_ptr
< info_ptr
)
18743 complaint (_("DW_AT_sibling points backwards"));
18744 else if (sibling_ptr
> reader
->buffer_end
)
18745 dwarf2_section_buffer_overflow_complaint (reader
->die_section
);
18747 sibling
= sibling_ptr
;
18750 case DW_AT_byte_size
:
18753 case DW_AT_const_value
:
18754 has_const_value
= 1;
18756 case DW_AT_calling_convention
:
18757 /* DWARF doesn't provide a way to identify a program's source-level
18758 entry point. DW_AT_calling_convention attributes are only meant
18759 to describe functions' calling conventions.
18761 However, because it's a necessary piece of information in
18762 Fortran, and before DWARF 4 DW_CC_program was the only
18763 piece of debugging information whose definition refers to
18764 a 'main program' at all, several compilers marked Fortran
18765 main programs with DW_CC_program --- even when those
18766 functions use the standard calling conventions.
18768 Although DWARF now specifies a way to provide this
18769 information, we support this practice for backward
18771 if (DW_UNSND (&attr
) == DW_CC_program
18772 && cu
->language
== language_fortran
)
18773 main_subprogram
= 1;
18776 if (DW_UNSND (&attr
) == DW_INL_inlined
18777 || DW_UNSND (&attr
) == DW_INL_declared_inlined
)
18778 may_be_inlined
= 1;
18782 if (tag
== DW_TAG_imported_unit
)
18784 d
.sect_off
= dwarf2_get_ref_die_offset (&attr
);
18785 is_dwz
= (attr
.form
== DW_FORM_GNU_ref_alt
18786 || cu
->per_cu
->is_dwz
);
18790 case DW_AT_main_subprogram
:
18791 main_subprogram
= DW_UNSND (&attr
);
18796 /* It would be nice to reuse dwarf2_get_pc_bounds here,
18797 but that requires a full DIE, so instead we just
18799 int need_ranges_base
= tag
!= DW_TAG_compile_unit
;
18800 unsigned int ranges_offset
= (DW_UNSND (&attr
)
18801 + (need_ranges_base
18805 /* Value of the DW_AT_ranges attribute is the offset in the
18806 .debug_ranges section. */
18807 if (dwarf2_ranges_read (ranges_offset
, &lowpc
, &highpc
, cu
,
18818 /* For Ada, if both the name and the linkage name appear, we prefer
18819 the latter. This lets "catch exception" work better, regardless
18820 of the order in which the name and linkage name were emitted.
18821 Really, though, this is just a workaround for the fact that gdb
18822 doesn't store both the name and the linkage name. */
18823 if (cu
->language
== language_ada
&& linkage_name
!= nullptr)
18824 name
= linkage_name
;
18826 if (high_pc_relative
)
18829 if (has_low_pc_attr
&& has_high_pc_attr
)
18831 /* When using the GNU linker, .gnu.linkonce. sections are used to
18832 eliminate duplicate copies of functions and vtables and such.
18833 The linker will arbitrarily choose one and discard the others.
18834 The AT_*_pc values for such functions refer to local labels in
18835 these sections. If the section from that file was discarded, the
18836 labels are not in the output, so the relocs get a value of 0.
18837 If this is a discarded function, mark the pc bounds as invalid,
18838 so that GDB will ignore it. */
18839 if (lowpc
== 0 && !dwarf2_per_objfile
->has_section_at_zero
)
18841 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18842 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18844 complaint (_("DW_AT_low_pc %s is zero "
18845 "for DIE at %s [in module %s]"),
18846 paddress (gdbarch
, lowpc
),
18847 sect_offset_str (sect_off
),
18848 objfile_name (objfile
));
18850 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18851 else if (lowpc
>= highpc
)
18853 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18854 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
18856 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18857 "for DIE at %s [in module %s]"),
18858 paddress (gdbarch
, lowpc
),
18859 paddress (gdbarch
, highpc
),
18860 sect_offset_str (sect_off
),
18861 objfile_name (objfile
));
18870 /* Find a cached partial DIE at OFFSET in CU. */
18872 struct partial_die_info
*
18873 dwarf2_cu::find_partial_die (sect_offset sect_off
)
18875 struct partial_die_info
*lookup_die
= NULL
;
18876 struct partial_die_info
part_die (sect_off
);
18878 lookup_die
= ((struct partial_die_info
*)
18879 htab_find_with_hash (partial_dies
, &part_die
,
18880 to_underlying (sect_off
)));
18885 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18886 except in the case of .debug_types DIEs which do not reference
18887 outside their CU (they do however referencing other types via
18888 DW_FORM_ref_sig8). */
18890 static const struct cu_partial_die_info
18891 find_partial_die (sect_offset sect_off
, int offset_in_dwz
, struct dwarf2_cu
*cu
)
18893 struct dwarf2_per_objfile
*dwarf2_per_objfile
18894 = cu
->per_cu
->dwarf2_per_objfile
;
18895 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
18896 struct dwarf2_per_cu_data
*per_cu
= NULL
;
18897 struct partial_die_info
*pd
= NULL
;
18899 if (offset_in_dwz
== cu
->per_cu
->is_dwz
18900 && offset_in_cu_p (&cu
->header
, sect_off
))
18902 pd
= cu
->find_partial_die (sect_off
);
18905 /* We missed recording what we needed.
18906 Load all dies and try again. */
18907 per_cu
= cu
->per_cu
;
18911 /* TUs don't reference other CUs/TUs (except via type signatures). */
18912 if (cu
->per_cu
->is_debug_types
)
18914 error (_("Dwarf Error: Type Unit at offset %s contains"
18915 " external reference to offset %s [in module %s].\n"),
18916 sect_offset_str (cu
->header
.sect_off
), sect_offset_str (sect_off
),
18917 bfd_get_filename (objfile
->obfd
));
18919 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
18920 dwarf2_per_objfile
);
18922 if (per_cu
->cu
== NULL
|| per_cu
->cu
->partial_dies
== NULL
)
18923 load_partial_comp_unit (per_cu
);
18925 per_cu
->cu
->last_used
= 0;
18926 pd
= per_cu
->cu
->find_partial_die (sect_off
);
18929 /* If we didn't find it, and not all dies have been loaded,
18930 load them all and try again. */
18932 if (pd
== NULL
&& per_cu
->load_all_dies
== 0)
18934 per_cu
->load_all_dies
= 1;
18936 /* This is nasty. When we reread the DIEs, somewhere up the call chain
18937 THIS_CU->cu may already be in use. So we can't just free it and
18938 replace its DIEs with the ones we read in. Instead, we leave those
18939 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18940 and clobber THIS_CU->cu->partial_dies with the hash table for the new
18942 load_partial_comp_unit (per_cu
);
18944 pd
= per_cu
->cu
->find_partial_die (sect_off
);
18948 internal_error (__FILE__
, __LINE__
,
18949 _("could not find partial DIE %s "
18950 "in cache [from module %s]\n"),
18951 sect_offset_str (sect_off
), bfd_get_filename (objfile
->obfd
));
18952 return { per_cu
->cu
, pd
};
18955 /* See if we can figure out if the class lives in a namespace. We do
18956 this by looking for a member function; its demangled name will
18957 contain namespace info, if there is any. */
18960 guess_partial_die_structure_name (struct partial_die_info
*struct_pdi
,
18961 struct dwarf2_cu
*cu
)
18963 /* NOTE: carlton/2003-10-07: Getting the info this way changes
18964 what template types look like, because the demangler
18965 frequently doesn't give the same name as the debug info. We
18966 could fix this by only using the demangled name to get the
18967 prefix (but see comment in read_structure_type). */
18969 struct partial_die_info
*real_pdi
;
18970 struct partial_die_info
*child_pdi
;
18972 /* If this DIE (this DIE's specification, if any) has a parent, then
18973 we should not do this. We'll prepend the parent's fully qualified
18974 name when we create the partial symbol. */
18976 real_pdi
= struct_pdi
;
18977 while (real_pdi
->has_specification
)
18979 auto res
= find_partial_die (real_pdi
->spec_offset
,
18980 real_pdi
->spec_is_dwz
, cu
);
18981 real_pdi
= res
.pdi
;
18985 if (real_pdi
->die_parent
!= NULL
)
18988 for (child_pdi
= struct_pdi
->die_child
;
18990 child_pdi
= child_pdi
->die_sibling
)
18992 if (child_pdi
->tag
== DW_TAG_subprogram
18993 && child_pdi
->linkage_name
!= NULL
)
18995 char *actual_class_name
18996 = language_class_name_from_physname (cu
->language_defn
,
18997 child_pdi
->linkage_name
);
18998 if (actual_class_name
!= NULL
)
19000 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
19003 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
19005 strlen (actual_class_name
)));
19006 xfree (actual_class_name
);
19014 partial_die_info::fixup (struct dwarf2_cu
*cu
)
19016 /* Once we've fixed up a die, there's no point in doing so again.
19017 This also avoids a memory leak if we were to call
19018 guess_partial_die_structure_name multiple times. */
19022 /* If we found a reference attribute and the DIE has no name, try
19023 to find a name in the referred to DIE. */
19025 if (name
== NULL
&& has_specification
)
19027 struct partial_die_info
*spec_die
;
19029 auto res
= find_partial_die (spec_offset
, spec_is_dwz
, cu
);
19030 spec_die
= res
.pdi
;
19033 spec_die
->fixup (cu
);
19035 if (spec_die
->name
)
19037 name
= spec_die
->name
;
19039 /* Copy DW_AT_external attribute if it is set. */
19040 if (spec_die
->is_external
)
19041 is_external
= spec_die
->is_external
;
19045 /* Set default names for some unnamed DIEs. */
19047 if (name
== NULL
&& tag
== DW_TAG_namespace
)
19048 name
= CP_ANONYMOUS_NAMESPACE_STR
;
19050 /* If there is no parent die to provide a namespace, and there are
19051 children, see if we can determine the namespace from their linkage
19053 if (cu
->language
== language_cplus
19054 && !cu
->per_cu
->dwarf2_per_objfile
->types
.empty ()
19055 && die_parent
== NULL
19057 && (tag
== DW_TAG_class_type
19058 || tag
== DW_TAG_structure_type
19059 || tag
== DW_TAG_union_type
))
19060 guess_partial_die_structure_name (this, cu
);
19062 /* GCC might emit a nameless struct or union that has a linkage
19063 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19065 && (tag
== DW_TAG_class_type
19066 || tag
== DW_TAG_interface_type
19067 || tag
== DW_TAG_structure_type
19068 || tag
== DW_TAG_union_type
)
19069 && linkage_name
!= NULL
)
19073 demangled
= gdb_demangle (linkage_name
, DMGL_TYPES
);
19078 /* Strip any leading namespaces/classes, keep only the base name.
19079 DW_AT_name for named DIEs does not contain the prefixes. */
19080 base
= strrchr (demangled
, ':');
19081 if (base
&& base
> demangled
&& base
[-1] == ':')
19086 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
19089 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
19090 base
, strlen (base
)));
19098 /* Read an attribute value described by an attribute form. */
19100 static const gdb_byte
*
19101 read_attribute_value (const struct die_reader_specs
*reader
,
19102 struct attribute
*attr
, unsigned form
,
19103 LONGEST implicit_const
, const gdb_byte
*info_ptr
)
19105 struct dwarf2_cu
*cu
= reader
->cu
;
19106 struct dwarf2_per_objfile
*dwarf2_per_objfile
19107 = cu
->per_cu
->dwarf2_per_objfile
;
19108 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19109 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
19110 bfd
*abfd
= reader
->abfd
;
19111 struct comp_unit_head
*cu_header
= &cu
->header
;
19112 unsigned int bytes_read
;
19113 struct dwarf_block
*blk
;
19115 attr
->form
= (enum dwarf_form
) form
;
19118 case DW_FORM_ref_addr
:
19119 if (cu
->header
.version
== 2)
19120 DW_UNSND (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
19122 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
,
19123 &cu
->header
, &bytes_read
);
19124 info_ptr
+= bytes_read
;
19126 case DW_FORM_GNU_ref_alt
:
19127 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
19128 info_ptr
+= bytes_read
;
19131 DW_ADDR (attr
) = read_address (abfd
, info_ptr
, cu
, &bytes_read
);
19132 DW_ADDR (attr
) = gdbarch_adjust_dwarf2_addr (gdbarch
, DW_ADDR (attr
));
19133 info_ptr
+= bytes_read
;
19135 case DW_FORM_block2
:
19136 blk
= dwarf_alloc_block (cu
);
19137 blk
->size
= read_2_bytes (abfd
, info_ptr
);
19139 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19140 info_ptr
+= blk
->size
;
19141 DW_BLOCK (attr
) = blk
;
19143 case DW_FORM_block4
:
19144 blk
= dwarf_alloc_block (cu
);
19145 blk
->size
= read_4_bytes (abfd
, info_ptr
);
19147 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19148 info_ptr
+= blk
->size
;
19149 DW_BLOCK (attr
) = blk
;
19151 case DW_FORM_data2
:
19152 DW_UNSND (attr
) = read_2_bytes (abfd
, info_ptr
);
19155 case DW_FORM_data4
:
19156 DW_UNSND (attr
) = read_4_bytes (abfd
, info_ptr
);
19159 case DW_FORM_data8
:
19160 DW_UNSND (attr
) = read_8_bytes (abfd
, info_ptr
);
19163 case DW_FORM_data16
:
19164 blk
= dwarf_alloc_block (cu
);
19166 blk
->data
= read_n_bytes (abfd
, info_ptr
, 16);
19168 DW_BLOCK (attr
) = blk
;
19170 case DW_FORM_sec_offset
:
19171 DW_UNSND (attr
) = read_offset (abfd
, info_ptr
, &cu
->header
, &bytes_read
);
19172 info_ptr
+= bytes_read
;
19174 case DW_FORM_string
:
19175 DW_STRING (attr
) = read_direct_string (abfd
, info_ptr
, &bytes_read
);
19176 DW_STRING_IS_CANONICAL (attr
) = 0;
19177 info_ptr
+= bytes_read
;
19180 if (!cu
->per_cu
->is_dwz
)
19182 DW_STRING (attr
) = read_indirect_string (dwarf2_per_objfile
,
19183 abfd
, info_ptr
, cu_header
,
19185 DW_STRING_IS_CANONICAL (attr
) = 0;
19186 info_ptr
+= bytes_read
;
19190 case DW_FORM_line_strp
:
19191 if (!cu
->per_cu
->is_dwz
)
19193 DW_STRING (attr
) = read_indirect_line_string (dwarf2_per_objfile
,
19195 cu_header
, &bytes_read
);
19196 DW_STRING_IS_CANONICAL (attr
) = 0;
19197 info_ptr
+= bytes_read
;
19201 case DW_FORM_GNU_strp_alt
:
19203 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
19204 LONGEST str_offset
= read_offset (abfd
, info_ptr
, cu_header
,
19207 DW_STRING (attr
) = read_indirect_string_from_dwz (objfile
,
19209 DW_STRING_IS_CANONICAL (attr
) = 0;
19210 info_ptr
+= bytes_read
;
19213 case DW_FORM_exprloc
:
19214 case DW_FORM_block
:
19215 blk
= dwarf_alloc_block (cu
);
19216 blk
->size
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19217 info_ptr
+= bytes_read
;
19218 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19219 info_ptr
+= blk
->size
;
19220 DW_BLOCK (attr
) = blk
;
19222 case DW_FORM_block1
:
19223 blk
= dwarf_alloc_block (cu
);
19224 blk
->size
= read_1_byte (abfd
, info_ptr
);
19226 blk
->data
= read_n_bytes (abfd
, info_ptr
, blk
->size
);
19227 info_ptr
+= blk
->size
;
19228 DW_BLOCK (attr
) = blk
;
19230 case DW_FORM_data1
:
19231 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
19235 DW_UNSND (attr
) = read_1_byte (abfd
, info_ptr
);
19238 case DW_FORM_flag_present
:
19239 DW_UNSND (attr
) = 1;
19241 case DW_FORM_sdata
:
19242 DW_SND (attr
) = read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19243 info_ptr
+= bytes_read
;
19245 case DW_FORM_udata
:
19246 DW_UNSND (attr
) = read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19247 info_ptr
+= bytes_read
;
19250 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19251 + read_1_byte (abfd
, info_ptr
));
19255 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19256 + read_2_bytes (abfd
, info_ptr
));
19260 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19261 + read_4_bytes (abfd
, info_ptr
));
19265 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19266 + read_8_bytes (abfd
, info_ptr
));
19269 case DW_FORM_ref_sig8
:
19270 DW_SIGNATURE (attr
) = read_8_bytes (abfd
, info_ptr
);
19273 case DW_FORM_ref_udata
:
19274 DW_UNSND (attr
) = (to_underlying (cu
->header
.sect_off
)
19275 + read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
));
19276 info_ptr
+= bytes_read
;
19278 case DW_FORM_indirect
:
19279 form
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19280 info_ptr
+= bytes_read
;
19281 if (form
== DW_FORM_implicit_const
)
19283 implicit_const
= read_signed_leb128 (abfd
, info_ptr
, &bytes_read
);
19284 info_ptr
+= bytes_read
;
19286 info_ptr
= read_attribute_value (reader
, attr
, form
, implicit_const
,
19289 case DW_FORM_implicit_const
:
19290 DW_SND (attr
) = implicit_const
;
19292 case DW_FORM_addrx
:
19293 case DW_FORM_GNU_addr_index
:
19294 if (reader
->dwo_file
== NULL
)
19296 /* For now flag a hard error.
19297 Later we can turn this into a complaint. */
19298 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19299 dwarf_form_name (form
),
19300 bfd_get_filename (abfd
));
19302 DW_ADDR (attr
) = read_addr_index_from_leb128 (cu
, info_ptr
, &bytes_read
);
19303 info_ptr
+= bytes_read
;
19306 case DW_FORM_strx1
:
19307 case DW_FORM_strx2
:
19308 case DW_FORM_strx3
:
19309 case DW_FORM_strx4
:
19310 case DW_FORM_GNU_str_index
:
19311 if (reader
->dwo_file
== NULL
)
19313 /* For now flag a hard error.
19314 Later we can turn this into a complaint if warranted. */
19315 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19316 dwarf_form_name (form
),
19317 bfd_get_filename (abfd
));
19320 ULONGEST str_index
;
19321 if (form
== DW_FORM_strx1
)
19323 str_index
= read_1_byte (abfd
, info_ptr
);
19326 else if (form
== DW_FORM_strx2
)
19328 str_index
= read_2_bytes (abfd
, info_ptr
);
19331 else if (form
== DW_FORM_strx3
)
19333 str_index
= read_3_bytes (abfd
, info_ptr
);
19336 else if (form
== DW_FORM_strx4
)
19338 str_index
= read_4_bytes (abfd
, info_ptr
);
19343 str_index
= read_unsigned_leb128 (abfd
, info_ptr
, &bytes_read
);
19344 info_ptr
+= bytes_read
;
19346 DW_STRING (attr
) = read_str_index (reader
, str_index
);
19347 DW_STRING_IS_CANONICAL (attr
) = 0;
19351 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19352 dwarf_form_name (form
),
19353 bfd_get_filename (abfd
));
19357 if (cu
->per_cu
->is_dwz
&& attr_form_is_ref (attr
))
19358 attr
->form
= DW_FORM_GNU_ref_alt
;
19360 /* We have seen instances where the compiler tried to emit a byte
19361 size attribute of -1 which ended up being encoded as an unsigned
19362 0xffffffff. Although 0xffffffff is technically a valid size value,
19363 an object of this size seems pretty unlikely so we can relatively
19364 safely treat these cases as if the size attribute was invalid and
19365 treat them as zero by default. */
19366 if (attr
->name
== DW_AT_byte_size
19367 && form
== DW_FORM_data4
19368 && DW_UNSND (attr
) >= 0xffffffff)
19371 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19372 hex_string (DW_UNSND (attr
)));
19373 DW_UNSND (attr
) = 0;
19379 /* Read an attribute described by an abbreviated attribute. */
19381 static const gdb_byte
*
19382 read_attribute (const struct die_reader_specs
*reader
,
19383 struct attribute
*attr
, struct attr_abbrev
*abbrev
,
19384 const gdb_byte
*info_ptr
)
19386 attr
->name
= abbrev
->name
;
19387 return read_attribute_value (reader
, attr
, abbrev
->form
,
19388 abbrev
->implicit_const
, info_ptr
);
19391 /* Read dwarf information from a buffer. */
19393 static unsigned int
19394 read_1_byte (bfd
*abfd
, const gdb_byte
*buf
)
19396 return bfd_get_8 (abfd
, buf
);
19400 read_1_signed_byte (bfd
*abfd
, const gdb_byte
*buf
)
19402 return bfd_get_signed_8 (abfd
, buf
);
19405 static unsigned int
19406 read_2_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19408 return bfd_get_16 (abfd
, buf
);
19412 read_2_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19414 return bfd_get_signed_16 (abfd
, buf
);
19417 static unsigned int
19418 read_3_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19420 unsigned int result
= 0;
19421 for (int i
= 0; i
< 3; ++i
)
19423 unsigned char byte
= bfd_get_8 (abfd
, buf
);
19425 result
|= ((unsigned int) byte
<< (i
* 8));
19430 static unsigned int
19431 read_4_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19433 return bfd_get_32 (abfd
, buf
);
19437 read_4_signed_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19439 return bfd_get_signed_32 (abfd
, buf
);
19443 read_8_bytes (bfd
*abfd
, const gdb_byte
*buf
)
19445 return bfd_get_64 (abfd
, buf
);
19449 read_address (bfd
*abfd
, const gdb_byte
*buf
, struct dwarf2_cu
*cu
,
19450 unsigned int *bytes_read
)
19452 struct comp_unit_head
*cu_header
= &cu
->header
;
19453 CORE_ADDR retval
= 0;
19455 if (cu_header
->signed_addr_p
)
19457 switch (cu_header
->addr_size
)
19460 retval
= bfd_get_signed_16 (abfd
, buf
);
19463 retval
= bfd_get_signed_32 (abfd
, buf
);
19466 retval
= bfd_get_signed_64 (abfd
, buf
);
19469 internal_error (__FILE__
, __LINE__
,
19470 _("read_address: bad switch, signed [in module %s]"),
19471 bfd_get_filename (abfd
));
19476 switch (cu_header
->addr_size
)
19479 retval
= bfd_get_16 (abfd
, buf
);
19482 retval
= bfd_get_32 (abfd
, buf
);
19485 retval
= bfd_get_64 (abfd
, buf
);
19488 internal_error (__FILE__
, __LINE__
,
19489 _("read_address: bad switch, "
19490 "unsigned [in module %s]"),
19491 bfd_get_filename (abfd
));
19495 *bytes_read
= cu_header
->addr_size
;
19499 /* Read the initial length from a section. The (draft) DWARF 3
19500 specification allows the initial length to take up either 4 bytes
19501 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19502 bytes describe the length and all offsets will be 8 bytes in length
19505 An older, non-standard 64-bit format is also handled by this
19506 function. The older format in question stores the initial length
19507 as an 8-byte quantity without an escape value. Lengths greater
19508 than 2^32 aren't very common which means that the initial 4 bytes
19509 is almost always zero. Since a length value of zero doesn't make
19510 sense for the 32-bit format, this initial zero can be considered to
19511 be an escape value which indicates the presence of the older 64-bit
19512 format. As written, the code can't detect (old format) lengths
19513 greater than 4GB. If it becomes necessary to handle lengths
19514 somewhat larger than 4GB, we could allow other small values (such
19515 as the non-sensical values of 1, 2, and 3) to also be used as
19516 escape values indicating the presence of the old format.
19518 The value returned via bytes_read should be used to increment the
19519 relevant pointer after calling read_initial_length().
19521 [ Note: read_initial_length() and read_offset() are based on the
19522 document entitled "DWARF Debugging Information Format", revision
19523 3, draft 8, dated November 19, 2001. This document was obtained
19526 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19528 This document is only a draft and is subject to change. (So beware.)
19530 Details regarding the older, non-standard 64-bit format were
19531 determined empirically by examining 64-bit ELF files produced by
19532 the SGI toolchain on an IRIX 6.5 machine.
19534 - Kevin, July 16, 2002
19538 read_initial_length (bfd
*abfd
, const gdb_byte
*buf
, unsigned int *bytes_read
)
19540 LONGEST length
= bfd_get_32 (abfd
, buf
);
19542 if (length
== 0xffffffff)
19544 length
= bfd_get_64 (abfd
, buf
+ 4);
19547 else if (length
== 0)
19549 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19550 length
= bfd_get_64 (abfd
, buf
);
19561 /* Cover function for read_initial_length.
19562 Returns the length of the object at BUF, and stores the size of the
19563 initial length in *BYTES_READ and stores the size that offsets will be in
19565 If the initial length size is not equivalent to that specified in
19566 CU_HEADER then issue a complaint.
19567 This is useful when reading non-comp-unit headers. */
19570 read_checked_initial_length_and_offset (bfd
*abfd
, const gdb_byte
*buf
,
19571 const struct comp_unit_head
*cu_header
,
19572 unsigned int *bytes_read
,
19573 unsigned int *offset_size
)
19575 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
19577 gdb_assert (cu_header
->initial_length_size
== 4
19578 || cu_header
->initial_length_size
== 8
19579 || cu_header
->initial_length_size
== 12);
19581 if (cu_header
->initial_length_size
!= *bytes_read
)
19582 complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19584 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
19588 /* Read an offset from the data stream. The size of the offset is
19589 given by cu_header->offset_size. */
19592 read_offset (bfd
*abfd
, const gdb_byte
*buf
,
19593 const struct comp_unit_head
*cu_header
,
19594 unsigned int *bytes_read
)
19596 LONGEST offset
= read_offset_1 (abfd
, buf
, cu_header
->offset_size
);
19598 *bytes_read
= cu_header
->offset_size
;
19602 /* Read an offset from the data stream. */
19605 read_offset_1 (bfd
*abfd
, const gdb_byte
*buf
, unsigned int offset_size
)
19607 LONGEST retval
= 0;
19609 switch (offset_size
)
19612 retval
= bfd_get_32 (abfd
, buf
);
19615 retval
= bfd_get_64 (abfd
, buf
);
19618 internal_error (__FILE__
, __LINE__
,
19619 _("read_offset_1: bad switch [in module %s]"),
19620 bfd_get_filename (abfd
));
19626 static const gdb_byte
*
19627 read_n_bytes (bfd
*abfd
, const gdb_byte
*buf
, unsigned int size
)
19629 /* If the size of a host char is 8 bits, we can return a pointer
19630 to the buffer, otherwise we have to copy the data to a buffer
19631 allocated on the temporary obstack. */
19632 gdb_assert (HOST_CHAR_BIT
== 8);
19636 static const char *
19637 read_direct_string (bfd
*abfd
, const gdb_byte
*buf
,
19638 unsigned int *bytes_read_ptr
)
19640 /* If the size of a host char is 8 bits, we can return a pointer
19641 to the string, otherwise we have to copy the string to a buffer
19642 allocated on the temporary obstack. */
19643 gdb_assert (HOST_CHAR_BIT
== 8);
19646 *bytes_read_ptr
= 1;
19649 *bytes_read_ptr
= strlen ((const char *) buf
) + 1;
19650 return (const char *) buf
;
19653 /* Return pointer to string at section SECT offset STR_OFFSET with error
19654 reporting strings FORM_NAME and SECT_NAME. */
19656 static const char *
19657 read_indirect_string_at_offset_from (struct objfile
*objfile
,
19658 bfd
*abfd
, LONGEST str_offset
,
19659 struct dwarf2_section_info
*sect
,
19660 const char *form_name
,
19661 const char *sect_name
)
19663 dwarf2_read_section (objfile
, sect
);
19664 if (sect
->buffer
== NULL
)
19665 error (_("%s used without %s section [in module %s]"),
19666 form_name
, sect_name
, bfd_get_filename (abfd
));
19667 if (str_offset
>= sect
->size
)
19668 error (_("%s pointing outside of %s section [in module %s]"),
19669 form_name
, sect_name
, bfd_get_filename (abfd
));
19670 gdb_assert (HOST_CHAR_BIT
== 8);
19671 if (sect
->buffer
[str_offset
] == '\0')
19673 return (const char *) (sect
->buffer
+ str_offset
);
19676 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19678 static const char *
19679 read_indirect_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19680 bfd
*abfd
, LONGEST str_offset
)
19682 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
19684 &dwarf2_per_objfile
->str
,
19685 "DW_FORM_strp", ".debug_str");
19688 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
19690 static const char *
19691 read_indirect_line_string_at_offset (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19692 bfd
*abfd
, LONGEST str_offset
)
19694 return read_indirect_string_at_offset_from (dwarf2_per_objfile
->objfile
,
19696 &dwarf2_per_objfile
->line_str
,
19697 "DW_FORM_line_strp",
19698 ".debug_line_str");
19701 /* Read a string at offset STR_OFFSET in the .debug_str section from
19702 the .dwz file DWZ. Throw an error if the offset is too large. If
19703 the string consists of a single NUL byte, return NULL; otherwise
19704 return a pointer to the string. */
19706 static const char *
19707 read_indirect_string_from_dwz (struct objfile
*objfile
, struct dwz_file
*dwz
,
19708 LONGEST str_offset
)
19710 dwarf2_read_section (objfile
, &dwz
->str
);
19712 if (dwz
->str
.buffer
== NULL
)
19713 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19714 "section [in module %s]"),
19715 bfd_get_filename (dwz
->dwz_bfd
));
19716 if (str_offset
>= dwz
->str
.size
)
19717 error (_("DW_FORM_GNU_strp_alt pointing outside of "
19718 ".debug_str section [in module %s]"),
19719 bfd_get_filename (dwz
->dwz_bfd
));
19720 gdb_assert (HOST_CHAR_BIT
== 8);
19721 if (dwz
->str
.buffer
[str_offset
] == '\0')
19723 return (const char *) (dwz
->str
.buffer
+ str_offset
);
19726 /* Return pointer to string at .debug_str offset as read from BUF.
19727 BUF is assumed to be in a compilation unit described by CU_HEADER.
19728 Return *BYTES_READ_PTR count of bytes read from BUF. */
19730 static const char *
19731 read_indirect_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bfd
*abfd
,
19732 const gdb_byte
*buf
,
19733 const struct comp_unit_head
*cu_header
,
19734 unsigned int *bytes_read_ptr
)
19736 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
19738 return read_indirect_string_at_offset (dwarf2_per_objfile
, abfd
, str_offset
);
19741 /* Return pointer to string at .debug_line_str offset as read from BUF.
19742 BUF is assumed to be in a compilation unit described by CU_HEADER.
19743 Return *BYTES_READ_PTR count of bytes read from BUF. */
19745 static const char *
19746 read_indirect_line_string (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19747 bfd
*abfd
, const gdb_byte
*buf
,
19748 const struct comp_unit_head
*cu_header
,
19749 unsigned int *bytes_read_ptr
)
19751 LONGEST str_offset
= read_offset (abfd
, buf
, cu_header
, bytes_read_ptr
);
19753 return read_indirect_line_string_at_offset (dwarf2_per_objfile
, abfd
,
19758 read_unsigned_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
19759 unsigned int *bytes_read_ptr
)
19762 unsigned int num_read
;
19764 unsigned char byte
;
19771 byte
= bfd_get_8 (abfd
, buf
);
19774 result
|= ((ULONGEST
) (byte
& 127) << shift
);
19775 if ((byte
& 128) == 0)
19781 *bytes_read_ptr
= num_read
;
19786 read_signed_leb128 (bfd
*abfd
, const gdb_byte
*buf
,
19787 unsigned int *bytes_read_ptr
)
19790 int shift
, num_read
;
19791 unsigned char byte
;
19798 byte
= bfd_get_8 (abfd
, buf
);
19801 result
|= ((ULONGEST
) (byte
& 127) << shift
);
19803 if ((byte
& 128) == 0)
19808 if ((shift
< 8 * sizeof (result
)) && (byte
& 0x40))
19809 result
|= -(((ULONGEST
) 1) << shift
);
19810 *bytes_read_ptr
= num_read
;
19814 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19815 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19816 ADDR_SIZE is the size of addresses from the CU header. */
19819 read_addr_index_1 (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
19820 unsigned int addr_index
, ULONGEST addr_base
, int addr_size
)
19822 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19823 bfd
*abfd
= objfile
->obfd
;
19824 const gdb_byte
*info_ptr
;
19826 dwarf2_read_section (objfile
, &dwarf2_per_objfile
->addr
);
19827 if (dwarf2_per_objfile
->addr
.buffer
== NULL
)
19828 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19829 objfile_name (objfile
));
19830 if (addr_base
+ addr_index
* addr_size
>= dwarf2_per_objfile
->addr
.size
)
19831 error (_("DW_FORM_addr_index pointing outside of "
19832 ".debug_addr section [in module %s]"),
19833 objfile_name (objfile
));
19834 info_ptr
= (dwarf2_per_objfile
->addr
.buffer
19835 + addr_base
+ addr_index
* addr_size
);
19836 if (addr_size
== 4)
19837 return bfd_get_32 (abfd
, info_ptr
);
19839 return bfd_get_64 (abfd
, info_ptr
);
19842 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
19845 read_addr_index (struct dwarf2_cu
*cu
, unsigned int addr_index
)
19847 return read_addr_index_1 (cu
->per_cu
->dwarf2_per_objfile
, addr_index
,
19848 cu
->addr_base
, cu
->header
.addr_size
);
19851 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
19854 read_addr_index_from_leb128 (struct dwarf2_cu
*cu
, const gdb_byte
*info_ptr
,
19855 unsigned int *bytes_read
)
19857 bfd
*abfd
= cu
->per_cu
->dwarf2_per_objfile
->objfile
->obfd
;
19858 unsigned int addr_index
= read_unsigned_leb128 (abfd
, info_ptr
, bytes_read
);
19860 return read_addr_index (cu
, addr_index
);
19863 /* Data structure to pass results from dwarf2_read_addr_index_reader
19864 back to dwarf2_read_addr_index. */
19866 struct dwarf2_read_addr_index_data
19868 ULONGEST addr_base
;
19872 /* die_reader_func for dwarf2_read_addr_index. */
19875 dwarf2_read_addr_index_reader (const struct die_reader_specs
*reader
,
19876 const gdb_byte
*info_ptr
,
19877 struct die_info
*comp_unit_die
,
19881 struct dwarf2_cu
*cu
= reader
->cu
;
19882 struct dwarf2_read_addr_index_data
*aidata
=
19883 (struct dwarf2_read_addr_index_data
*) data
;
19885 aidata
->addr_base
= cu
->addr_base
;
19886 aidata
->addr_size
= cu
->header
.addr_size
;
19889 /* Given an index in .debug_addr, fetch the value.
19890 NOTE: This can be called during dwarf expression evaluation,
19891 long after the debug information has been read, and thus per_cu->cu
19892 may no longer exist. */
19895 dwarf2_read_addr_index (struct dwarf2_per_cu_data
*per_cu
,
19896 unsigned int addr_index
)
19898 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
19899 struct dwarf2_cu
*cu
= per_cu
->cu
;
19900 ULONGEST addr_base
;
19903 /* We need addr_base and addr_size.
19904 If we don't have PER_CU->cu, we have to get it.
19905 Nasty, but the alternative is storing the needed info in PER_CU,
19906 which at this point doesn't seem justified: it's not clear how frequently
19907 it would get used and it would increase the size of every PER_CU.
19908 Entry points like dwarf2_per_cu_addr_size do a similar thing
19909 so we're not in uncharted territory here.
19910 Alas we need to be a bit more complicated as addr_base is contained
19913 We don't need to read the entire CU(/TU).
19914 We just need the header and top level die.
19916 IWBN to use the aging mechanism to let us lazily later discard the CU.
19917 For now we skip this optimization. */
19921 addr_base
= cu
->addr_base
;
19922 addr_size
= cu
->header
.addr_size
;
19926 struct dwarf2_read_addr_index_data aidata
;
19928 /* Note: We can't use init_cutu_and_read_dies_simple here,
19929 we need addr_base. */
19930 init_cutu_and_read_dies (per_cu
, NULL
, 0, 0, false,
19931 dwarf2_read_addr_index_reader
, &aidata
);
19932 addr_base
= aidata
.addr_base
;
19933 addr_size
= aidata
.addr_size
;
19936 return read_addr_index_1 (dwarf2_per_objfile
, addr_index
, addr_base
,
19940 /* Given a DW_FORM_GNU_str_index or DW_FORM_strx, fetch the string.
19941 This is only used by the Fission support. */
19943 static const char *
19944 read_str_index (const struct die_reader_specs
*reader
, ULONGEST str_index
)
19946 struct dwarf2_cu
*cu
= reader
->cu
;
19947 struct dwarf2_per_objfile
*dwarf2_per_objfile
19948 = cu
->per_cu
->dwarf2_per_objfile
;
19949 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
19950 const char *objf_name
= objfile_name (objfile
);
19951 bfd
*abfd
= objfile
->obfd
;
19952 struct dwarf2_section_info
*str_section
= &reader
->dwo_file
->sections
.str
;
19953 struct dwarf2_section_info
*str_offsets_section
=
19954 &reader
->dwo_file
->sections
.str_offsets
;
19955 const gdb_byte
*info_ptr
;
19956 ULONGEST str_offset
;
19957 static const char form_name
[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
19959 dwarf2_read_section (objfile
, str_section
);
19960 dwarf2_read_section (objfile
, str_offsets_section
);
19961 if (str_section
->buffer
== NULL
)
19962 error (_("%s used without .debug_str.dwo section"
19963 " in CU at offset %s [in module %s]"),
19964 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
19965 if (str_offsets_section
->buffer
== NULL
)
19966 error (_("%s used without .debug_str_offsets.dwo section"
19967 " in CU at offset %s [in module %s]"),
19968 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
19969 if (str_index
* cu
->header
.offset_size
>= str_offsets_section
->size
)
19970 error (_("%s pointing outside of .debug_str_offsets.dwo"
19971 " section in CU at offset %s [in module %s]"),
19972 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
19973 info_ptr
= (str_offsets_section
->buffer
19974 + str_index
* cu
->header
.offset_size
);
19975 if (cu
->header
.offset_size
== 4)
19976 str_offset
= bfd_get_32 (abfd
, info_ptr
);
19978 str_offset
= bfd_get_64 (abfd
, info_ptr
);
19979 if (str_offset
>= str_section
->size
)
19980 error (_("Offset from %s pointing outside of"
19981 " .debug_str.dwo section in CU at offset %s [in module %s]"),
19982 form_name
, sect_offset_str (cu
->header
.sect_off
), objf_name
);
19983 return (const char *) (str_section
->buffer
+ str_offset
);
19986 /* Return the length of an LEB128 number in BUF. */
19989 leb128_size (const gdb_byte
*buf
)
19991 const gdb_byte
*begin
= buf
;
19997 if ((byte
& 128) == 0)
19998 return buf
- begin
;
20003 set_cu_language (unsigned int lang
, struct dwarf2_cu
*cu
)
20012 cu
->language
= language_c
;
20015 case DW_LANG_C_plus_plus
:
20016 case DW_LANG_C_plus_plus_11
:
20017 case DW_LANG_C_plus_plus_14
:
20018 cu
->language
= language_cplus
;
20021 cu
->language
= language_d
;
20023 case DW_LANG_Fortran77
:
20024 case DW_LANG_Fortran90
:
20025 case DW_LANG_Fortran95
:
20026 case DW_LANG_Fortran03
:
20027 case DW_LANG_Fortran08
:
20028 cu
->language
= language_fortran
;
20031 cu
->language
= language_go
;
20033 case DW_LANG_Mips_Assembler
:
20034 cu
->language
= language_asm
;
20036 case DW_LANG_Ada83
:
20037 case DW_LANG_Ada95
:
20038 cu
->language
= language_ada
;
20040 case DW_LANG_Modula2
:
20041 cu
->language
= language_m2
;
20043 case DW_LANG_Pascal83
:
20044 cu
->language
= language_pascal
;
20047 cu
->language
= language_objc
;
20050 case DW_LANG_Rust_old
:
20051 cu
->language
= language_rust
;
20053 case DW_LANG_Cobol74
:
20054 case DW_LANG_Cobol85
:
20056 cu
->language
= language_minimal
;
20059 cu
->language_defn
= language_def (cu
->language
);
20062 /* Return the named attribute or NULL if not there. */
20064 static struct attribute
*
20065 dwarf2_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20070 struct attribute
*spec
= NULL
;
20072 for (i
= 0; i
< die
->num_attrs
; ++i
)
20074 if (die
->attrs
[i
].name
== name
)
20075 return &die
->attrs
[i
];
20076 if (die
->attrs
[i
].name
== DW_AT_specification
20077 || die
->attrs
[i
].name
== DW_AT_abstract_origin
)
20078 spec
= &die
->attrs
[i
];
20084 die
= follow_die_ref (die
, spec
, &cu
);
20090 /* Return the named attribute or NULL if not there,
20091 but do not follow DW_AT_specification, etc.
20092 This is for use in contexts where we're reading .debug_types dies.
20093 Following DW_AT_specification, DW_AT_abstract_origin will take us
20094 back up the chain, and we want to go down. */
20096 static struct attribute
*
20097 dwarf2_attr_no_follow (struct die_info
*die
, unsigned int name
)
20101 for (i
= 0; i
< die
->num_attrs
; ++i
)
20102 if (die
->attrs
[i
].name
== name
)
20103 return &die
->attrs
[i
];
20108 /* Return the string associated with a string-typed attribute, or NULL if it
20109 is either not found or is of an incorrect type. */
20111 static const char *
20112 dwarf2_string_attr (struct die_info
*die
, unsigned int name
, struct dwarf2_cu
*cu
)
20114 struct attribute
*attr
;
20115 const char *str
= NULL
;
20117 attr
= dwarf2_attr (die
, name
, cu
);
20121 if (attr
->form
== DW_FORM_strp
|| attr
->form
== DW_FORM_line_strp
20122 || attr
->form
== DW_FORM_string
20123 || attr
->form
== DW_FORM_strx
20124 || attr
->form
== DW_FORM_GNU_str_index
20125 || attr
->form
== DW_FORM_GNU_strp_alt
)
20126 str
= DW_STRING (attr
);
20128 complaint (_("string type expected for attribute %s for "
20129 "DIE at %s in module %s"),
20130 dwarf_attr_name (name
), sect_offset_str (die
->sect_off
),
20131 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
20137 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20138 and holds a non-zero value. This function should only be used for
20139 DW_FORM_flag or DW_FORM_flag_present attributes. */
20142 dwarf2_flag_true_p (struct die_info
*die
, unsigned name
, struct dwarf2_cu
*cu
)
20144 struct attribute
*attr
= dwarf2_attr (die
, name
, cu
);
20146 return (attr
&& DW_UNSND (attr
));
20150 die_is_declaration (struct die_info
*die
, struct dwarf2_cu
*cu
)
20152 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20153 which value is non-zero. However, we have to be careful with
20154 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20155 (via dwarf2_flag_true_p) follows this attribute. So we may
20156 end up accidently finding a declaration attribute that belongs
20157 to a different DIE referenced by the specification attribute,
20158 even though the given DIE does not have a declaration attribute. */
20159 return (dwarf2_flag_true_p (die
, DW_AT_declaration
, cu
)
20160 && dwarf2_attr (die
, DW_AT_specification
, cu
) == NULL
);
20163 /* Return the die giving the specification for DIE, if there is
20164 one. *SPEC_CU is the CU containing DIE on input, and the CU
20165 containing the return value on output. If there is no
20166 specification, but there is an abstract origin, that is
20169 static struct die_info
*
20170 die_specification (struct die_info
*die
, struct dwarf2_cu
**spec_cu
)
20172 struct attribute
*spec_attr
= dwarf2_attr (die
, DW_AT_specification
,
20175 if (spec_attr
== NULL
)
20176 spec_attr
= dwarf2_attr (die
, DW_AT_abstract_origin
, *spec_cu
);
20178 if (spec_attr
== NULL
)
20181 return follow_die_ref (die
, spec_attr
, spec_cu
);
20184 /* Stub for free_line_header to match void * callback types. */
20187 free_line_header_voidp (void *arg
)
20189 struct line_header
*lh
= (struct line_header
*) arg
;
20195 line_header::add_include_dir (const char *include_dir
)
20197 if (dwarf_line_debug
>= 2)
20198 fprintf_unfiltered (gdb_stdlog
, "Adding dir %zu: %s\n",
20199 include_dirs
.size () + 1, include_dir
);
20201 include_dirs
.push_back (include_dir
);
20205 line_header::add_file_name (const char *name
,
20207 unsigned int mod_time
,
20208 unsigned int length
)
20210 if (dwarf_line_debug
>= 2)
20211 fprintf_unfiltered (gdb_stdlog
, "Adding file %u: %s\n",
20212 (unsigned) file_names
.size () + 1, name
);
20214 file_names
.emplace_back (name
, d_index
, mod_time
, length
);
20217 /* A convenience function to find the proper .debug_line section for a CU. */
20219 static struct dwarf2_section_info
*
20220 get_debug_line_section (struct dwarf2_cu
*cu
)
20222 struct dwarf2_section_info
*section
;
20223 struct dwarf2_per_objfile
*dwarf2_per_objfile
20224 = cu
->per_cu
->dwarf2_per_objfile
;
20226 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20228 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20229 section
= &cu
->dwo_unit
->dwo_file
->sections
.line
;
20230 else if (cu
->per_cu
->is_dwz
)
20232 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
20234 section
= &dwz
->line
;
20237 section
= &dwarf2_per_objfile
->line
;
20242 /* Read directory or file name entry format, starting with byte of
20243 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20244 entries count and the entries themselves in the described entry
20248 read_formatted_entries (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
20249 bfd
*abfd
, const gdb_byte
**bufp
,
20250 struct line_header
*lh
,
20251 const struct comp_unit_head
*cu_header
,
20252 void (*callback
) (struct line_header
*lh
,
20255 unsigned int mod_time
,
20256 unsigned int length
))
20258 gdb_byte format_count
, formati
;
20259 ULONGEST data_count
, datai
;
20260 const gdb_byte
*buf
= *bufp
;
20261 const gdb_byte
*format_header_data
;
20262 unsigned int bytes_read
;
20264 format_count
= read_1_byte (abfd
, buf
);
20266 format_header_data
= buf
;
20267 for (formati
= 0; formati
< format_count
; formati
++)
20269 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20271 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20275 data_count
= read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
20277 for (datai
= 0; datai
< data_count
; datai
++)
20279 const gdb_byte
*format
= format_header_data
;
20280 struct file_entry fe
;
20282 for (formati
= 0; formati
< format_count
; formati
++)
20284 ULONGEST content_type
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
20285 format
+= bytes_read
;
20287 ULONGEST form
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
20288 format
+= bytes_read
;
20290 gdb::optional
<const char *> string
;
20291 gdb::optional
<unsigned int> uint
;
20295 case DW_FORM_string
:
20296 string
.emplace (read_direct_string (abfd
, buf
, &bytes_read
));
20300 case DW_FORM_line_strp
:
20301 string
.emplace (read_indirect_line_string (dwarf2_per_objfile
,
20308 case DW_FORM_data1
:
20309 uint
.emplace (read_1_byte (abfd
, buf
));
20313 case DW_FORM_data2
:
20314 uint
.emplace (read_2_bytes (abfd
, buf
));
20318 case DW_FORM_data4
:
20319 uint
.emplace (read_4_bytes (abfd
, buf
));
20323 case DW_FORM_data8
:
20324 uint
.emplace (read_8_bytes (abfd
, buf
));
20328 case DW_FORM_udata
:
20329 uint
.emplace (read_unsigned_leb128 (abfd
, buf
, &bytes_read
));
20333 case DW_FORM_block
:
20334 /* It is valid only for DW_LNCT_timestamp which is ignored by
20339 switch (content_type
)
20342 if (string
.has_value ())
20345 case DW_LNCT_directory_index
:
20346 if (uint
.has_value ())
20347 fe
.d_index
= (dir_index
) *uint
;
20349 case DW_LNCT_timestamp
:
20350 if (uint
.has_value ())
20351 fe
.mod_time
= *uint
;
20354 if (uint
.has_value ())
20360 complaint (_("Unknown format content type %s"),
20361 pulongest (content_type
));
20365 callback (lh
, fe
.name
, fe
.d_index
, fe
.mod_time
, fe
.length
);
20371 /* Read the statement program header starting at OFFSET in
20372 .debug_line, or .debug_line.dwo. Return a pointer
20373 to a struct line_header, allocated using xmalloc.
20374 Returns NULL if there is a problem reading the header, e.g., if it
20375 has a version we don't understand.
20377 NOTE: the strings in the include directory and file name tables of
20378 the returned object point into the dwarf line section buffer,
20379 and must not be freed. */
20381 static line_header_up
20382 dwarf_decode_line_header (sect_offset sect_off
, struct dwarf2_cu
*cu
)
20384 const gdb_byte
*line_ptr
;
20385 unsigned int bytes_read
, offset_size
;
20387 const char *cur_dir
, *cur_file
;
20388 struct dwarf2_section_info
*section
;
20390 struct dwarf2_per_objfile
*dwarf2_per_objfile
20391 = cu
->per_cu
->dwarf2_per_objfile
;
20393 section
= get_debug_line_section (cu
);
20394 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
20395 if (section
->buffer
== NULL
)
20397 if (cu
->dwo_unit
&& cu
->per_cu
->is_debug_types
)
20398 complaint (_("missing .debug_line.dwo section"));
20400 complaint (_("missing .debug_line section"));
20404 /* We can't do this until we know the section is non-empty.
20405 Only then do we know we have such a section. */
20406 abfd
= get_section_bfd_owner (section
);
20408 /* Make sure that at least there's room for the total_length field.
20409 That could be 12 bytes long, but we're just going to fudge that. */
20410 if (to_underlying (sect_off
) + 4 >= section
->size
)
20412 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20416 line_header_up
lh (new line_header ());
20418 lh
->sect_off
= sect_off
;
20419 lh
->offset_in_dwz
= cu
->per_cu
->is_dwz
;
20421 line_ptr
= section
->buffer
+ to_underlying (sect_off
);
20423 /* Read in the header. */
20425 read_checked_initial_length_and_offset (abfd
, line_ptr
, &cu
->header
,
20426 &bytes_read
, &offset_size
);
20427 line_ptr
+= bytes_read
;
20428 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
20430 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20433 lh
->statement_program_end
= line_ptr
+ lh
->total_length
;
20434 lh
->version
= read_2_bytes (abfd
, line_ptr
);
20436 if (lh
->version
> 5)
20438 /* This is a version we don't understand. The format could have
20439 changed in ways we don't handle properly so just punt. */
20440 complaint (_("unsupported version in .debug_line section"));
20443 if (lh
->version
>= 5)
20445 gdb_byte segment_selector_size
;
20447 /* Skip address size. */
20448 read_1_byte (abfd
, line_ptr
);
20451 segment_selector_size
= read_1_byte (abfd
, line_ptr
);
20453 if (segment_selector_size
!= 0)
20455 complaint (_("unsupported segment selector size %u "
20456 "in .debug_line section"),
20457 segment_selector_size
);
20461 lh
->header_length
= read_offset_1 (abfd
, line_ptr
, offset_size
);
20462 line_ptr
+= offset_size
;
20463 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
20465 if (lh
->version
>= 4)
20467 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
20471 lh
->maximum_ops_per_instruction
= 1;
20473 if (lh
->maximum_ops_per_instruction
== 0)
20475 lh
->maximum_ops_per_instruction
= 1;
20476 complaint (_("invalid maximum_ops_per_instruction "
20477 "in `.debug_line' section"));
20480 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
20482 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
20484 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
20486 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
20488 lh
->standard_opcode_lengths
.reset (new unsigned char[lh
->opcode_base
]);
20490 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
20491 for (i
= 1; i
< lh
->opcode_base
; ++i
)
20493 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
20497 if (lh
->version
>= 5)
20499 /* Read directory table. */
20500 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
20502 [] (struct line_header
*header
, const char *name
,
20503 dir_index d_index
, unsigned int mod_time
,
20504 unsigned int length
)
20506 header
->add_include_dir (name
);
20509 /* Read file name table. */
20510 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
20512 [] (struct line_header
*header
, const char *name
,
20513 dir_index d_index
, unsigned int mod_time
,
20514 unsigned int length
)
20516 header
->add_file_name (name
, d_index
, mod_time
, length
);
20521 /* Read directory table. */
20522 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
20524 line_ptr
+= bytes_read
;
20525 lh
->add_include_dir (cur_dir
);
20527 line_ptr
+= bytes_read
;
20529 /* Read file name table. */
20530 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
20532 unsigned int mod_time
, length
;
20535 line_ptr
+= bytes_read
;
20536 d_index
= (dir_index
) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20537 line_ptr
+= bytes_read
;
20538 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20539 line_ptr
+= bytes_read
;
20540 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
20541 line_ptr
+= bytes_read
;
20543 lh
->add_file_name (cur_file
, d_index
, mod_time
, length
);
20545 line_ptr
+= bytes_read
;
20547 lh
->statement_program_start
= line_ptr
;
20549 if (line_ptr
> (section
->buffer
+ section
->size
))
20550 complaint (_("line number info header doesn't "
20551 "fit in `.debug_line' section"));
20556 /* Subroutine of dwarf_decode_lines to simplify it.
20557 Return the file name of the psymtab for included file FILE_INDEX
20558 in line header LH of PST.
20559 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20560 If space for the result is malloc'd, *NAME_HOLDER will be set.
20561 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20563 static const char *
20564 psymtab_include_file_name (const struct line_header
*lh
, int file_index
,
20565 const struct partial_symtab
*pst
,
20566 const char *comp_dir
,
20567 gdb::unique_xmalloc_ptr
<char> *name_holder
)
20569 const file_entry
&fe
= lh
->file_names
[file_index
];
20570 const char *include_name
= fe
.name
;
20571 const char *include_name_to_compare
= include_name
;
20572 const char *pst_filename
;
20575 const char *dir_name
= fe
.include_dir (lh
);
20577 gdb::unique_xmalloc_ptr
<char> hold_compare
;
20578 if (!IS_ABSOLUTE_PATH (include_name
)
20579 && (dir_name
!= NULL
|| comp_dir
!= NULL
))
20581 /* Avoid creating a duplicate psymtab for PST.
20582 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20583 Before we do the comparison, however, we need to account
20584 for DIR_NAME and COMP_DIR.
20585 First prepend dir_name (if non-NULL). If we still don't
20586 have an absolute path prepend comp_dir (if non-NULL).
20587 However, the directory we record in the include-file's
20588 psymtab does not contain COMP_DIR (to match the
20589 corresponding symtab(s)).
20594 bash$ gcc -g ./hello.c
20595 include_name = "hello.c"
20597 DW_AT_comp_dir = comp_dir = "/tmp"
20598 DW_AT_name = "./hello.c"
20602 if (dir_name
!= NULL
)
20604 name_holder
->reset (concat (dir_name
, SLASH_STRING
,
20605 include_name
, (char *) NULL
));
20606 include_name
= name_holder
->get ();
20607 include_name_to_compare
= include_name
;
20609 if (!IS_ABSOLUTE_PATH (include_name
) && comp_dir
!= NULL
)
20611 hold_compare
.reset (concat (comp_dir
, SLASH_STRING
,
20612 include_name
, (char *) NULL
));
20613 include_name_to_compare
= hold_compare
.get ();
20617 pst_filename
= pst
->filename
;
20618 gdb::unique_xmalloc_ptr
<char> copied_name
;
20619 if (!IS_ABSOLUTE_PATH (pst_filename
) && pst
->dirname
!= NULL
)
20621 copied_name
.reset (concat (pst
->dirname
, SLASH_STRING
,
20622 pst_filename
, (char *) NULL
));
20623 pst_filename
= copied_name
.get ();
20626 file_is_pst
= FILENAME_CMP (include_name_to_compare
, pst_filename
) == 0;
20630 return include_name
;
20633 /* State machine to track the state of the line number program. */
20635 class lnp_state_machine
20638 /* Initialize a machine state for the start of a line number
20640 lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
, line_header
*lh
,
20641 bool record_lines_p
);
20643 file_entry
*current_file ()
20645 /* lh->file_names is 0-based, but the file name numbers in the
20646 statement program are 1-based. */
20647 return m_line_header
->file_name_at (m_file
);
20650 /* Record the line in the state machine. END_SEQUENCE is true if
20651 we're processing the end of a sequence. */
20652 void record_line (bool end_sequence
);
20654 /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20655 nop-out rest of the lines in this sequence. */
20656 void check_line_address (struct dwarf2_cu
*cu
,
20657 const gdb_byte
*line_ptr
,
20658 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
);
20660 void handle_set_discriminator (unsigned int discriminator
)
20662 m_discriminator
= discriminator
;
20663 m_line_has_non_zero_discriminator
|= discriminator
!= 0;
20666 /* Handle DW_LNE_set_address. */
20667 void handle_set_address (CORE_ADDR baseaddr
, CORE_ADDR address
)
20670 address
+= baseaddr
;
20671 m_address
= gdbarch_adjust_dwarf2_line (m_gdbarch
, address
, false);
20674 /* Handle DW_LNS_advance_pc. */
20675 void handle_advance_pc (CORE_ADDR adjust
);
20677 /* Handle a special opcode. */
20678 void handle_special_opcode (unsigned char op_code
);
20680 /* Handle DW_LNS_advance_line. */
20681 void handle_advance_line (int line_delta
)
20683 advance_line (line_delta
);
20686 /* Handle DW_LNS_set_file. */
20687 void handle_set_file (file_name_index file
);
20689 /* Handle DW_LNS_negate_stmt. */
20690 void handle_negate_stmt ()
20692 m_is_stmt
= !m_is_stmt
;
20695 /* Handle DW_LNS_const_add_pc. */
20696 void handle_const_add_pc ();
20698 /* Handle DW_LNS_fixed_advance_pc. */
20699 void handle_fixed_advance_pc (CORE_ADDR addr_adj
)
20701 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20705 /* Handle DW_LNS_copy. */
20706 void handle_copy ()
20708 record_line (false);
20709 m_discriminator
= 0;
20712 /* Handle DW_LNE_end_sequence. */
20713 void handle_end_sequence ()
20715 m_currently_recording_lines
= true;
20719 /* Advance the line by LINE_DELTA. */
20720 void advance_line (int line_delta
)
20722 m_line
+= line_delta
;
20724 if (line_delta
!= 0)
20725 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20728 struct dwarf2_cu
*m_cu
;
20730 gdbarch
*m_gdbarch
;
20732 /* True if we're recording lines.
20733 Otherwise we're building partial symtabs and are just interested in
20734 finding include files mentioned by the line number program. */
20735 bool m_record_lines_p
;
20737 /* The line number header. */
20738 line_header
*m_line_header
;
20740 /* These are part of the standard DWARF line number state machine,
20741 and initialized according to the DWARF spec. */
20743 unsigned char m_op_index
= 0;
20744 /* The line table index (1-based) of the current file. */
20745 file_name_index m_file
= (file_name_index
) 1;
20746 unsigned int m_line
= 1;
20748 /* These are initialized in the constructor. */
20750 CORE_ADDR m_address
;
20752 unsigned int m_discriminator
;
20754 /* Additional bits of state we need to track. */
20756 /* The last file that we called dwarf2_start_subfile for.
20757 This is only used for TLLs. */
20758 unsigned int m_last_file
= 0;
20759 /* The last file a line number was recorded for. */
20760 struct subfile
*m_last_subfile
= NULL
;
20762 /* When true, record the lines we decode. */
20763 bool m_currently_recording_lines
= false;
20765 /* The last line number that was recorded, used to coalesce
20766 consecutive entries for the same line. This can happen, for
20767 example, when discriminators are present. PR 17276. */
20768 unsigned int m_last_line
= 0;
20769 bool m_line_has_non_zero_discriminator
= false;
20773 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust
)
20775 CORE_ADDR addr_adj
= (((m_op_index
+ adjust
)
20776 / m_line_header
->maximum_ops_per_instruction
)
20777 * m_line_header
->minimum_instruction_length
);
20778 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20779 m_op_index
= ((m_op_index
+ adjust
)
20780 % m_line_header
->maximum_ops_per_instruction
);
20784 lnp_state_machine::handle_special_opcode (unsigned char op_code
)
20786 unsigned char adj_opcode
= op_code
- m_line_header
->opcode_base
;
20787 CORE_ADDR addr_adj
= (((m_op_index
20788 + (adj_opcode
/ m_line_header
->line_range
))
20789 / m_line_header
->maximum_ops_per_instruction
)
20790 * m_line_header
->minimum_instruction_length
);
20791 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20792 m_op_index
= ((m_op_index
+ (adj_opcode
/ m_line_header
->line_range
))
20793 % m_line_header
->maximum_ops_per_instruction
);
20795 int line_delta
= (m_line_header
->line_base
20796 + (adj_opcode
% m_line_header
->line_range
));
20797 advance_line (line_delta
);
20798 record_line (false);
20799 m_discriminator
= 0;
20803 lnp_state_machine::handle_set_file (file_name_index file
)
20807 const file_entry
*fe
= current_file ();
20809 dwarf2_debug_line_missing_file_complaint ();
20810 else if (m_record_lines_p
)
20812 const char *dir
= fe
->include_dir (m_line_header
);
20814 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20815 m_line_has_non_zero_discriminator
= m_discriminator
!= 0;
20816 dwarf2_start_subfile (m_cu
, fe
->name
, dir
);
20821 lnp_state_machine::handle_const_add_pc ()
20824 = (255 - m_line_header
->opcode_base
) / m_line_header
->line_range
;
20827 = (((m_op_index
+ adjust
)
20828 / m_line_header
->maximum_ops_per_instruction
)
20829 * m_line_header
->minimum_instruction_length
);
20831 m_address
+= gdbarch_adjust_dwarf2_line (m_gdbarch
, addr_adj
, true);
20832 m_op_index
= ((m_op_index
+ adjust
)
20833 % m_line_header
->maximum_ops_per_instruction
);
20836 /* Return non-zero if we should add LINE to the line number table.
20837 LINE is the line to add, LAST_LINE is the last line that was added,
20838 LAST_SUBFILE is the subfile for LAST_LINE.
20839 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20840 had a non-zero discriminator.
20842 We have to be careful in the presence of discriminators.
20843 E.g., for this line:
20845 for (i = 0; i < 100000; i++);
20847 clang can emit four line number entries for that one line,
20848 each with a different discriminator.
20849 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20851 However, we want gdb to coalesce all four entries into one.
20852 Otherwise the user could stepi into the middle of the line and
20853 gdb would get confused about whether the pc really was in the
20854 middle of the line.
20856 Things are further complicated by the fact that two consecutive
20857 line number entries for the same line is a heuristic used by gcc
20858 to denote the end of the prologue. So we can't just discard duplicate
20859 entries, we have to be selective about it. The heuristic we use is
20860 that we only collapse consecutive entries for the same line if at least
20861 one of those entries has a non-zero discriminator. PR 17276.
20863 Note: Addresses in the line number state machine can never go backwards
20864 within one sequence, thus this coalescing is ok. */
20867 dwarf_record_line_p (struct dwarf2_cu
*cu
,
20868 unsigned int line
, unsigned int last_line
,
20869 int line_has_non_zero_discriminator
,
20870 struct subfile
*last_subfile
)
20872 if (cu
->get_builder ()->get_current_subfile () != last_subfile
)
20874 if (line
!= last_line
)
20876 /* Same line for the same file that we've seen already.
20877 As a last check, for pr 17276, only record the line if the line
20878 has never had a non-zero discriminator. */
20879 if (!line_has_non_zero_discriminator
)
20884 /* Use the CU's builder to record line number LINE beginning at
20885 address ADDRESS in the line table of subfile SUBFILE. */
20888 dwarf_record_line_1 (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20889 unsigned int line
, CORE_ADDR address
,
20890 struct dwarf2_cu
*cu
)
20892 CORE_ADDR addr
= gdbarch_addr_bits_remove (gdbarch
, address
);
20894 if (dwarf_line_debug
)
20896 fprintf_unfiltered (gdb_stdlog
,
20897 "Recording line %u, file %s, address %s\n",
20898 line
, lbasename (subfile
->name
),
20899 paddress (gdbarch
, address
));
20903 cu
->get_builder ()->record_line (subfile
, line
, addr
);
20906 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20907 Mark the end of a set of line number records.
20908 The arguments are the same as for dwarf_record_line_1.
20909 If SUBFILE is NULL the request is ignored. */
20912 dwarf_finish_line (struct gdbarch
*gdbarch
, struct subfile
*subfile
,
20913 CORE_ADDR address
, struct dwarf2_cu
*cu
)
20915 if (subfile
== NULL
)
20918 if (dwarf_line_debug
)
20920 fprintf_unfiltered (gdb_stdlog
,
20921 "Finishing current line, file %s, address %s\n",
20922 lbasename (subfile
->name
),
20923 paddress (gdbarch
, address
));
20926 dwarf_record_line_1 (gdbarch
, subfile
, 0, address
, cu
);
20930 lnp_state_machine::record_line (bool end_sequence
)
20932 if (dwarf_line_debug
)
20934 fprintf_unfiltered (gdb_stdlog
,
20935 "Processing actual line %u: file %u,"
20936 " address %s, is_stmt %u, discrim %u\n",
20937 m_line
, to_underlying (m_file
),
20938 paddress (m_gdbarch
, m_address
),
20939 m_is_stmt
, m_discriminator
);
20942 file_entry
*fe
= current_file ();
20945 dwarf2_debug_line_missing_file_complaint ();
20946 /* For now we ignore lines not starting on an instruction boundary.
20947 But not when processing end_sequence for compatibility with the
20948 previous version of the code. */
20949 else if (m_op_index
== 0 || end_sequence
)
20951 fe
->included_p
= 1;
20952 if (m_record_lines_p
&& (producer_is_codewarrior (m_cu
) || m_is_stmt
))
20954 if (m_last_subfile
!= m_cu
->get_builder ()->get_current_subfile ()
20957 dwarf_finish_line (m_gdbarch
, m_last_subfile
, m_address
,
20958 m_currently_recording_lines
? m_cu
: nullptr);
20963 if (dwarf_record_line_p (m_cu
, m_line
, m_last_line
,
20964 m_line_has_non_zero_discriminator
,
20967 buildsym_compunit
*builder
= m_cu
->get_builder ();
20968 dwarf_record_line_1 (m_gdbarch
,
20969 builder
->get_current_subfile (),
20971 m_currently_recording_lines
? m_cu
: nullptr);
20973 m_last_subfile
= m_cu
->get_builder ()->get_current_subfile ();
20974 m_last_line
= m_line
;
20980 lnp_state_machine::lnp_state_machine (struct dwarf2_cu
*cu
, gdbarch
*arch
,
20981 line_header
*lh
, bool record_lines_p
)
20985 m_record_lines_p
= record_lines_p
;
20986 m_line_header
= lh
;
20988 m_currently_recording_lines
= true;
20990 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20991 was a line entry for it so that the backend has a chance to adjust it
20992 and also record it in case it needs it. This is currently used by MIPS
20993 code, cf. `mips_adjust_dwarf2_line'. */
20994 m_address
= gdbarch_adjust_dwarf2_line (arch
, 0, 0);
20995 m_is_stmt
= lh
->default_is_stmt
;
20996 m_discriminator
= 0;
21000 lnp_state_machine::check_line_address (struct dwarf2_cu
*cu
,
21001 const gdb_byte
*line_ptr
,
21002 CORE_ADDR unrelocated_lowpc
, CORE_ADDR address
)
21004 /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
21005 the pc range of the CU. However, we restrict the test to only ADDRESS
21006 values of zero to preserve GDB's previous behaviour which is to handle
21007 the specific case of a function being GC'd by the linker. */
21009 if (address
== 0 && address
< unrelocated_lowpc
)
21011 /* This line table is for a function which has been
21012 GCd by the linker. Ignore it. PR gdb/12528 */
21014 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21015 long line_offset
= line_ptr
- get_debug_line_section (cu
)->buffer
;
21017 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21018 line_offset
, objfile_name (objfile
));
21019 m_currently_recording_lines
= false;
21020 /* Note: m_currently_recording_lines is left as false until we see
21021 DW_LNE_end_sequence. */
21025 /* Subroutine of dwarf_decode_lines to simplify it.
21026 Process the line number information in LH.
21027 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21028 program in order to set included_p for every referenced header. */
21031 dwarf_decode_lines_1 (struct line_header
*lh
, struct dwarf2_cu
*cu
,
21032 const int decode_for_pst_p
, CORE_ADDR lowpc
)
21034 const gdb_byte
*line_ptr
, *extended_end
;
21035 const gdb_byte
*line_end
;
21036 unsigned int bytes_read
, extended_len
;
21037 unsigned char op_code
, extended_op
;
21038 CORE_ADDR baseaddr
;
21039 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21040 bfd
*abfd
= objfile
->obfd
;
21041 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
21042 /* True if we're recording line info (as opposed to building partial
21043 symtabs and just interested in finding include files mentioned by
21044 the line number program). */
21045 bool record_lines_p
= !decode_for_pst_p
;
21047 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21049 line_ptr
= lh
->statement_program_start
;
21050 line_end
= lh
->statement_program_end
;
21052 /* Read the statement sequences until there's nothing left. */
21053 while (line_ptr
< line_end
)
21055 /* The DWARF line number program state machine. Reset the state
21056 machine at the start of each sequence. */
21057 lnp_state_machine
state_machine (cu
, gdbarch
, lh
, record_lines_p
);
21058 bool end_sequence
= false;
21060 if (record_lines_p
)
21062 /* Start a subfile for the current file of the state
21064 const file_entry
*fe
= state_machine
.current_file ();
21067 dwarf2_start_subfile (cu
, fe
->name
, fe
->include_dir (lh
));
21070 /* Decode the table. */
21071 while (line_ptr
< line_end
&& !end_sequence
)
21073 op_code
= read_1_byte (abfd
, line_ptr
);
21076 if (op_code
>= lh
->opcode_base
)
21078 /* Special opcode. */
21079 state_machine
.handle_special_opcode (op_code
);
21081 else switch (op_code
)
21083 case DW_LNS_extended_op
:
21084 extended_len
= read_unsigned_leb128 (abfd
, line_ptr
,
21086 line_ptr
+= bytes_read
;
21087 extended_end
= line_ptr
+ extended_len
;
21088 extended_op
= read_1_byte (abfd
, line_ptr
);
21090 switch (extended_op
)
21092 case DW_LNE_end_sequence
:
21093 state_machine
.handle_end_sequence ();
21094 end_sequence
= true;
21096 case DW_LNE_set_address
:
21099 = read_address (abfd
, line_ptr
, cu
, &bytes_read
);
21100 line_ptr
+= bytes_read
;
21102 state_machine
.check_line_address (cu
, line_ptr
,
21103 lowpc
- baseaddr
, address
);
21104 state_machine
.handle_set_address (baseaddr
, address
);
21107 case DW_LNE_define_file
:
21109 const char *cur_file
;
21110 unsigned int mod_time
, length
;
21113 cur_file
= read_direct_string (abfd
, line_ptr
,
21115 line_ptr
+= bytes_read
;
21116 dindex
= (dir_index
)
21117 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21118 line_ptr
+= bytes_read
;
21120 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21121 line_ptr
+= bytes_read
;
21123 read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21124 line_ptr
+= bytes_read
;
21125 lh
->add_file_name (cur_file
, dindex
, mod_time
, length
);
21128 case DW_LNE_set_discriminator
:
21130 /* The discriminator is not interesting to the
21131 debugger; just ignore it. We still need to
21132 check its value though:
21133 if there are consecutive entries for the same
21134 (non-prologue) line we want to coalesce them.
21137 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21138 line_ptr
+= bytes_read
;
21140 state_machine
.handle_set_discriminator (discr
);
21144 complaint (_("mangled .debug_line section"));
21147 /* Make sure that we parsed the extended op correctly. If e.g.
21148 we expected a different address size than the producer used,
21149 we may have read the wrong number of bytes. */
21150 if (line_ptr
!= extended_end
)
21152 complaint (_("mangled .debug_line section"));
21157 state_machine
.handle_copy ();
21159 case DW_LNS_advance_pc
:
21162 = read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21163 line_ptr
+= bytes_read
;
21165 state_machine
.handle_advance_pc (adjust
);
21168 case DW_LNS_advance_line
:
21171 = read_signed_leb128 (abfd
, line_ptr
, &bytes_read
);
21172 line_ptr
+= bytes_read
;
21174 state_machine
.handle_advance_line (line_delta
);
21177 case DW_LNS_set_file
:
21179 file_name_index file
21180 = (file_name_index
) read_unsigned_leb128 (abfd
, line_ptr
,
21182 line_ptr
+= bytes_read
;
21184 state_machine
.handle_set_file (file
);
21187 case DW_LNS_set_column
:
21188 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21189 line_ptr
+= bytes_read
;
21191 case DW_LNS_negate_stmt
:
21192 state_machine
.handle_negate_stmt ();
21194 case DW_LNS_set_basic_block
:
21196 /* Add to the address register of the state machine the
21197 address increment value corresponding to special opcode
21198 255. I.e., this value is scaled by the minimum
21199 instruction length since special opcode 255 would have
21200 scaled the increment. */
21201 case DW_LNS_const_add_pc
:
21202 state_machine
.handle_const_add_pc ();
21204 case DW_LNS_fixed_advance_pc
:
21206 CORE_ADDR addr_adj
= read_2_bytes (abfd
, line_ptr
);
21209 state_machine
.handle_fixed_advance_pc (addr_adj
);
21214 /* Unknown standard opcode, ignore it. */
21217 for (i
= 0; i
< lh
->standard_opcode_lengths
[op_code
]; i
++)
21219 (void) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
21220 line_ptr
+= bytes_read
;
21227 dwarf2_debug_line_missing_end_sequence_complaint ();
21229 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21230 in which case we still finish recording the last line). */
21231 state_machine
.record_line (true);
21235 /* Decode the Line Number Program (LNP) for the given line_header
21236 structure and CU. The actual information extracted and the type
21237 of structures created from the LNP depends on the value of PST.
21239 1. If PST is NULL, then this procedure uses the data from the program
21240 to create all necessary symbol tables, and their linetables.
21242 2. If PST is not NULL, this procedure reads the program to determine
21243 the list of files included by the unit represented by PST, and
21244 builds all the associated partial symbol tables.
21246 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21247 It is used for relative paths in the line table.
21248 NOTE: When processing partial symtabs (pst != NULL),
21249 comp_dir == pst->dirname.
21251 NOTE: It is important that psymtabs have the same file name (via strcmp)
21252 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21253 symtab we don't use it in the name of the psymtabs we create.
21254 E.g. expand_line_sal requires this when finding psymtabs to expand.
21255 A good testcase for this is mb-inline.exp.
21257 LOWPC is the lowest address in CU (or 0 if not known).
21259 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21260 for its PC<->lines mapping information. Otherwise only the filename
21261 table is read in. */
21264 dwarf_decode_lines (struct line_header
*lh
, const char *comp_dir
,
21265 struct dwarf2_cu
*cu
, struct partial_symtab
*pst
,
21266 CORE_ADDR lowpc
, int decode_mapping
)
21268 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21269 const int decode_for_pst_p
= (pst
!= NULL
);
21271 if (decode_mapping
)
21272 dwarf_decode_lines_1 (lh
, cu
, decode_for_pst_p
, lowpc
);
21274 if (decode_for_pst_p
)
21278 /* Now that we're done scanning the Line Header Program, we can
21279 create the psymtab of each included file. */
21280 for (file_index
= 0; file_index
< lh
->file_names
.size (); file_index
++)
21281 if (lh
->file_names
[file_index
].included_p
== 1)
21283 gdb::unique_xmalloc_ptr
<char> name_holder
;
21284 const char *include_name
=
21285 psymtab_include_file_name (lh
, file_index
, pst
, comp_dir
,
21287 if (include_name
!= NULL
)
21288 dwarf2_create_include_psymtab (include_name
, pst
, objfile
);
21293 /* Make sure a symtab is created for every file, even files
21294 which contain only variables (i.e. no code with associated
21296 buildsym_compunit
*builder
= cu
->get_builder ();
21297 struct compunit_symtab
*cust
= builder
->get_compunit_symtab ();
21300 for (i
= 0; i
< lh
->file_names
.size (); i
++)
21302 file_entry
&fe
= lh
->file_names
[i
];
21304 dwarf2_start_subfile (cu
, fe
.name
, fe
.include_dir (lh
));
21306 if (builder
->get_current_subfile ()->symtab
== NULL
)
21308 builder
->get_current_subfile ()->symtab
21309 = allocate_symtab (cust
,
21310 builder
->get_current_subfile ()->name
);
21312 fe
.symtab
= builder
->get_current_subfile ()->symtab
;
21317 /* Start a subfile for DWARF. FILENAME is the name of the file and
21318 DIRNAME the name of the source directory which contains FILENAME
21319 or NULL if not known.
21320 This routine tries to keep line numbers from identical absolute and
21321 relative file names in a common subfile.
21323 Using the `list' example from the GDB testsuite, which resides in
21324 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21325 of /srcdir/list0.c yields the following debugging information for list0.c:
21327 DW_AT_name: /srcdir/list0.c
21328 DW_AT_comp_dir: /compdir
21329 files.files[0].name: list0.h
21330 files.files[0].dir: /srcdir
21331 files.files[1].name: list0.c
21332 files.files[1].dir: /srcdir
21334 The line number information for list0.c has to end up in a single
21335 subfile, so that `break /srcdir/list0.c:1' works as expected.
21336 start_subfile will ensure that this happens provided that we pass the
21337 concatenation of files.files[1].dir and files.files[1].name as the
21341 dwarf2_start_subfile (struct dwarf2_cu
*cu
, const char *filename
,
21342 const char *dirname
)
21346 /* In order not to lose the line information directory,
21347 we concatenate it to the filename when it makes sense.
21348 Note that the Dwarf3 standard says (speaking of filenames in line
21349 information): ``The directory index is ignored for file names
21350 that represent full path names''. Thus ignoring dirname in the
21351 `else' branch below isn't an issue. */
21353 if (!IS_ABSOLUTE_PATH (filename
) && dirname
!= NULL
)
21355 copy
= concat (dirname
, SLASH_STRING
, filename
, (char *)NULL
);
21359 cu
->get_builder ()->start_subfile (filename
);
21365 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21366 buildsym_compunit constructor. */
21368 struct compunit_symtab
*
21369 dwarf2_cu::start_symtab (const char *name
, const char *comp_dir
,
21372 gdb_assert (m_builder
== nullptr);
21374 m_builder
.reset (new struct buildsym_compunit
21375 (per_cu
->dwarf2_per_objfile
->objfile
,
21376 name
, comp_dir
, language
, low_pc
));
21378 list_in_scope
= get_builder ()->get_file_symbols ();
21380 get_builder ()->record_debugformat ("DWARF 2");
21381 get_builder ()->record_producer (producer
);
21383 processing_has_namespace_info
= false;
21385 return get_builder ()->get_compunit_symtab ();
21389 var_decode_location (struct attribute
*attr
, struct symbol
*sym
,
21390 struct dwarf2_cu
*cu
)
21392 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21393 struct comp_unit_head
*cu_header
= &cu
->header
;
21395 /* NOTE drow/2003-01-30: There used to be a comment and some special
21396 code here to turn a symbol with DW_AT_external and a
21397 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21398 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21399 with some versions of binutils) where shared libraries could have
21400 relocations against symbols in their debug information - the
21401 minimal symbol would have the right address, but the debug info
21402 would not. It's no longer necessary, because we will explicitly
21403 apply relocations when we read in the debug information now. */
21405 /* A DW_AT_location attribute with no contents indicates that a
21406 variable has been optimized away. */
21407 if (attr_form_is_block (attr
) && DW_BLOCK (attr
)->size
== 0)
21409 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21413 /* Handle one degenerate form of location expression specially, to
21414 preserve GDB's previous behavior when section offsets are
21415 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
21416 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
21418 if (attr_form_is_block (attr
)
21419 && ((DW_BLOCK (attr
)->data
[0] == DW_OP_addr
21420 && DW_BLOCK (attr
)->size
== 1 + cu_header
->addr_size
)
21421 || ((DW_BLOCK (attr
)->data
[0] == DW_OP_GNU_addr_index
21422 || DW_BLOCK (attr
)->data
[0] == DW_OP_addrx
)
21423 && (DW_BLOCK (attr
)->size
21424 == 1 + leb128_size (&DW_BLOCK (attr
)->data
[1])))))
21426 unsigned int dummy
;
21428 if (DW_BLOCK (attr
)->data
[0] == DW_OP_addr
)
21429 SYMBOL_VALUE_ADDRESS (sym
) =
21430 read_address (objfile
->obfd
, DW_BLOCK (attr
)->data
+ 1, cu
, &dummy
);
21432 SYMBOL_VALUE_ADDRESS (sym
) =
21433 read_addr_index_from_leb128 (cu
, DW_BLOCK (attr
)->data
+ 1, &dummy
);
21434 SYMBOL_ACLASS_INDEX (sym
) = LOC_STATIC
;
21435 fixup_symbol_section (sym
, objfile
);
21436 SYMBOL_VALUE_ADDRESS (sym
) += ANOFFSET (objfile
->section_offsets
,
21437 SYMBOL_SECTION (sym
));
21441 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21442 expression evaluator, and use LOC_COMPUTED only when necessary
21443 (i.e. when the value of a register or memory location is
21444 referenced, or a thread-local block, etc.). Then again, it might
21445 not be worthwhile. I'm assuming that it isn't unless performance
21446 or memory numbers show me otherwise. */
21448 dwarf2_symbol_mark_computed (attr
, sym
, cu
, 0);
21450 if (SYMBOL_COMPUTED_OPS (sym
)->location_has_loclist
)
21451 cu
->has_loclist
= true;
21454 /* Given a pointer to a DWARF information entry, figure out if we need
21455 to make a symbol table entry for it, and if so, create a new entry
21456 and return a pointer to it.
21457 If TYPE is NULL, determine symbol type from the die, otherwise
21458 used the passed type.
21459 If SPACE is not NULL, use it to hold the new symbol. If it is
21460 NULL, allocate a new symbol on the objfile's obstack. */
21462 static struct symbol
*
21463 new_symbol (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
,
21464 struct symbol
*space
)
21466 struct dwarf2_per_objfile
*dwarf2_per_objfile
21467 = cu
->per_cu
->dwarf2_per_objfile
;
21468 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
21469 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
21470 struct symbol
*sym
= NULL
;
21472 struct attribute
*attr
= NULL
;
21473 struct attribute
*attr2
= NULL
;
21474 CORE_ADDR baseaddr
;
21475 struct pending
**list_to_add
= NULL
;
21477 int inlined_func
= (die
->tag
== DW_TAG_inlined_subroutine
);
21479 baseaddr
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
21481 name
= dwarf2_name (die
, cu
);
21484 const char *linkagename
;
21485 int suppress_add
= 0;
21490 sym
= allocate_symbol (objfile
);
21491 OBJSTAT (objfile
, n_syms
++);
21493 /* Cache this symbol's name and the name's demangled form (if any). */
21494 SYMBOL_SET_LANGUAGE (sym
, cu
->language
, &objfile
->objfile_obstack
);
21495 linkagename
= dwarf2_physname (name
, die
, cu
);
21496 SYMBOL_SET_NAMES (sym
, linkagename
, strlen (linkagename
), 0, objfile
);
21498 /* Fortran does not have mangling standard and the mangling does differ
21499 between gfortran, iFort etc. */
21500 if (cu
->language
== language_fortran
21501 && symbol_get_demangled_name (&(sym
->ginfo
)) == NULL
)
21502 symbol_set_demangled_name (&(sym
->ginfo
),
21503 dwarf2_full_name (name
, die
, cu
),
21506 /* Default assumptions.
21507 Use the passed type or decode it from the die. */
21508 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21509 SYMBOL_ACLASS_INDEX (sym
) = LOC_OPTIMIZED_OUT
;
21511 SYMBOL_TYPE (sym
) = type
;
21513 SYMBOL_TYPE (sym
) = die_type (die
, cu
);
21514 attr
= dwarf2_attr (die
,
21515 inlined_func
? DW_AT_call_line
: DW_AT_decl_line
,
21519 SYMBOL_LINE (sym
) = DW_UNSND (attr
);
21522 attr
= dwarf2_attr (die
,
21523 inlined_func
? DW_AT_call_file
: DW_AT_decl_file
,
21527 file_name_index file_index
= (file_name_index
) DW_UNSND (attr
);
21528 struct file_entry
*fe
;
21530 if (cu
->line_header
!= NULL
)
21531 fe
= cu
->line_header
->file_name_at (file_index
);
21536 complaint (_("file index out of range"));
21538 symbol_set_symtab (sym
, fe
->symtab
);
21544 attr
= dwarf2_attr (die
, DW_AT_low_pc
, cu
);
21549 addr
= attr_value_as_address (attr
);
21550 addr
= gdbarch_adjust_dwarf2_addr (gdbarch
, addr
+ baseaddr
);
21551 SYMBOL_VALUE_ADDRESS (sym
) = addr
;
21553 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_core_addr
;
21554 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
21555 SYMBOL_ACLASS_INDEX (sym
) = LOC_LABEL
;
21556 add_symbol_to_list (sym
, cu
->list_in_scope
);
21558 case DW_TAG_subprogram
:
21559 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21561 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21562 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21563 if ((attr2
&& (DW_UNSND (attr2
) != 0))
21564 || cu
->language
== language_ada
)
21566 /* Subprograms marked external are stored as a global symbol.
21567 Ada subprograms, whether marked external or not, are always
21568 stored as a global symbol, because we want to be able to
21569 access them globally. For instance, we want to be able
21570 to break on a nested subprogram without having to
21571 specify the context. */
21572 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21576 list_to_add
= cu
->list_in_scope
;
21579 case DW_TAG_inlined_subroutine
:
21580 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21582 SYMBOL_ACLASS_INDEX (sym
) = LOC_BLOCK
;
21583 SYMBOL_INLINED (sym
) = 1;
21584 list_to_add
= cu
->list_in_scope
;
21586 case DW_TAG_template_value_param
:
21588 /* Fall through. */
21589 case DW_TAG_constant
:
21590 case DW_TAG_variable
:
21591 case DW_TAG_member
:
21592 /* Compilation with minimal debug info may result in
21593 variables with missing type entries. Change the
21594 misleading `void' type to something sensible. */
21595 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_VOID
)
21596 SYMBOL_TYPE (sym
) = objfile_type (objfile
)->builtin_int
;
21598 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21599 /* In the case of DW_TAG_member, we should only be called for
21600 static const members. */
21601 if (die
->tag
== DW_TAG_member
)
21603 /* dwarf2_add_field uses die_is_declaration,
21604 so we do the same. */
21605 gdb_assert (die_is_declaration (die
, cu
));
21610 dwarf2_const_value (attr
, sym
, cu
);
21611 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21614 if (attr2
&& (DW_UNSND (attr2
) != 0))
21615 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21617 list_to_add
= cu
->list_in_scope
;
21621 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21624 var_decode_location (attr
, sym
, cu
);
21625 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21627 /* Fortran explicitly imports any global symbols to the local
21628 scope by DW_TAG_common_block. */
21629 if (cu
->language
== language_fortran
&& die
->parent
21630 && die
->parent
->tag
== DW_TAG_common_block
)
21633 if (SYMBOL_CLASS (sym
) == LOC_STATIC
21634 && SYMBOL_VALUE_ADDRESS (sym
) == 0
21635 && !dwarf2_per_objfile
->has_section_at_zero
)
21637 /* When a static variable is eliminated by the linker,
21638 the corresponding debug information is not stripped
21639 out, but the variable address is set to null;
21640 do not add such variables into symbol table. */
21642 else if (attr2
&& (DW_UNSND (attr2
) != 0))
21644 /* Workaround gfortran PR debug/40040 - it uses
21645 DW_AT_location for variables in -fPIC libraries which may
21646 get overriden by other libraries/executable and get
21647 a different address. Resolve it by the minimal symbol
21648 which may come from inferior's executable using copy
21649 relocation. Make this workaround only for gfortran as for
21650 other compilers GDB cannot guess the minimal symbol
21651 Fortran mangling kind. */
21652 if (cu
->language
== language_fortran
&& die
->parent
21653 && die
->parent
->tag
== DW_TAG_module
21655 && startswith (cu
->producer
, "GNU Fortran"))
21656 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21658 /* A variable with DW_AT_external is never static,
21659 but it may be block-scoped. */
21661 = ((cu
->list_in_scope
21662 == cu
->get_builder ()->get_file_symbols ())
21663 ? cu
->get_builder ()->get_global_symbols ()
21664 : cu
->list_in_scope
);
21667 list_to_add
= cu
->list_in_scope
;
21671 /* We do not know the address of this symbol.
21672 If it is an external symbol and we have type information
21673 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21674 The address of the variable will then be determined from
21675 the minimal symbol table whenever the variable is
21677 attr2
= dwarf2_attr (die
, DW_AT_external
, cu
);
21679 /* Fortran explicitly imports any global symbols to the local
21680 scope by DW_TAG_common_block. */
21681 if (cu
->language
== language_fortran
&& die
->parent
21682 && die
->parent
->tag
== DW_TAG_common_block
)
21684 /* SYMBOL_CLASS doesn't matter here because
21685 read_common_block is going to reset it. */
21687 list_to_add
= cu
->list_in_scope
;
21689 else if (attr2
&& (DW_UNSND (attr2
) != 0)
21690 && dwarf2_attr (die
, DW_AT_type
, cu
) != NULL
)
21692 /* A variable with DW_AT_external is never static, but it
21693 may be block-scoped. */
21695 = ((cu
->list_in_scope
21696 == cu
->get_builder ()->get_file_symbols ())
21697 ? cu
->get_builder ()->get_global_symbols ()
21698 : cu
->list_in_scope
);
21700 SYMBOL_ACLASS_INDEX (sym
) = LOC_UNRESOLVED
;
21702 else if (!die_is_declaration (die
, cu
))
21704 /* Use the default LOC_OPTIMIZED_OUT class. */
21705 gdb_assert (SYMBOL_CLASS (sym
) == LOC_OPTIMIZED_OUT
);
21707 list_to_add
= cu
->list_in_scope
;
21711 case DW_TAG_formal_parameter
:
21713 /* If we are inside a function, mark this as an argument. If
21714 not, we might be looking at an argument to an inlined function
21715 when we do not have enough information to show inlined frames;
21716 pretend it's a local variable in that case so that the user can
21718 struct context_stack
*curr
21719 = cu
->get_builder ()->get_current_context_stack ();
21720 if (curr
!= nullptr && curr
->name
!= nullptr)
21721 SYMBOL_IS_ARGUMENT (sym
) = 1;
21722 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
21725 var_decode_location (attr
, sym
, cu
);
21727 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21730 dwarf2_const_value (attr
, sym
, cu
);
21733 list_to_add
= cu
->list_in_scope
;
21736 case DW_TAG_unspecified_parameters
:
21737 /* From varargs functions; gdb doesn't seem to have any
21738 interest in this information, so just ignore it for now.
21741 case DW_TAG_template_type_param
:
21743 /* Fall through. */
21744 case DW_TAG_class_type
:
21745 case DW_TAG_interface_type
:
21746 case DW_TAG_structure_type
:
21747 case DW_TAG_union_type
:
21748 case DW_TAG_set_type
:
21749 case DW_TAG_enumeration_type
:
21750 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21751 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
21754 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21755 really ever be static objects: otherwise, if you try
21756 to, say, break of a class's method and you're in a file
21757 which doesn't mention that class, it won't work unless
21758 the check for all static symbols in lookup_symbol_aux
21759 saves you. See the OtherFileClass tests in
21760 gdb.c++/namespace.exp. */
21764 buildsym_compunit
*builder
= cu
->get_builder ();
21766 = (cu
->list_in_scope
== builder
->get_file_symbols ()
21767 && cu
->language
== language_cplus
21768 ? builder
->get_global_symbols ()
21769 : cu
->list_in_scope
);
21771 /* The semantics of C++ state that "struct foo {
21772 ... }" also defines a typedef for "foo". */
21773 if (cu
->language
== language_cplus
21774 || cu
->language
== language_ada
21775 || cu
->language
== language_d
21776 || cu
->language
== language_rust
)
21778 /* The symbol's name is already allocated along
21779 with this objfile, so we don't need to
21780 duplicate it for the type. */
21781 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
21782 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_SEARCH_NAME (sym
);
21787 case DW_TAG_typedef
:
21788 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21789 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21790 list_to_add
= cu
->list_in_scope
;
21792 case DW_TAG_base_type
:
21793 case DW_TAG_subrange_type
:
21794 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21795 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
21796 list_to_add
= cu
->list_in_scope
;
21798 case DW_TAG_enumerator
:
21799 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
21802 dwarf2_const_value (attr
, sym
, cu
);
21805 /* NOTE: carlton/2003-11-10: See comment above in the
21806 DW_TAG_class_type, etc. block. */
21809 = (cu
->list_in_scope
== cu
->get_builder ()->get_file_symbols ()
21810 && cu
->language
== language_cplus
21811 ? cu
->get_builder ()->get_global_symbols ()
21812 : cu
->list_in_scope
);
21815 case DW_TAG_imported_declaration
:
21816 case DW_TAG_namespace
:
21817 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21818 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21820 case DW_TAG_module
:
21821 SYMBOL_ACLASS_INDEX (sym
) = LOC_TYPEDEF
;
21822 SYMBOL_DOMAIN (sym
) = MODULE_DOMAIN
;
21823 list_to_add
= cu
->get_builder ()->get_global_symbols ();
21825 case DW_TAG_common_block
:
21826 SYMBOL_ACLASS_INDEX (sym
) = LOC_COMMON_BLOCK
;
21827 SYMBOL_DOMAIN (sym
) = COMMON_BLOCK_DOMAIN
;
21828 add_symbol_to_list (sym
, cu
->list_in_scope
);
21831 /* Not a tag we recognize. Hopefully we aren't processing
21832 trash data, but since we must specifically ignore things
21833 we don't recognize, there is nothing else we should do at
21835 complaint (_("unsupported tag: '%s'"),
21836 dwarf_tag_name (die
->tag
));
21842 sym
->hash_next
= objfile
->template_symbols
;
21843 objfile
->template_symbols
= sym
;
21844 list_to_add
= NULL
;
21847 if (list_to_add
!= NULL
)
21848 add_symbol_to_list (sym
, list_to_add
);
21850 /* For the benefit of old versions of GCC, check for anonymous
21851 namespaces based on the demangled name. */
21852 if (!cu
->processing_has_namespace_info
21853 && cu
->language
== language_cplus
)
21854 cp_scan_for_anonymous_namespaces (cu
->get_builder (), sym
, objfile
);
21859 /* Given an attr with a DW_FORM_dataN value in host byte order,
21860 zero-extend it as appropriate for the symbol's type. The DWARF
21861 standard (v4) is not entirely clear about the meaning of using
21862 DW_FORM_dataN for a constant with a signed type, where the type is
21863 wider than the data. The conclusion of a discussion on the DWARF
21864 list was that this is unspecified. We choose to always zero-extend
21865 because that is the interpretation long in use by GCC. */
21868 dwarf2_const_value_data (const struct attribute
*attr
, struct obstack
*obstack
,
21869 struct dwarf2_cu
*cu
, LONGEST
*value
, int bits
)
21871 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21872 enum bfd_endian byte_order
= bfd_big_endian (objfile
->obfd
) ?
21873 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
21874 LONGEST l
= DW_UNSND (attr
);
21876 if (bits
< sizeof (*value
) * 8)
21878 l
&= ((LONGEST
) 1 << bits
) - 1;
21881 else if (bits
== sizeof (*value
) * 8)
21885 gdb_byte
*bytes
= (gdb_byte
*) obstack_alloc (obstack
, bits
/ 8);
21886 store_unsigned_integer (bytes
, bits
/ 8, byte_order
, l
);
21893 /* Read a constant value from an attribute. Either set *VALUE, or if
21894 the value does not fit in *VALUE, set *BYTES - either already
21895 allocated on the objfile obstack, or newly allocated on OBSTACK,
21896 or, set *BATON, if we translated the constant to a location
21900 dwarf2_const_value_attr (const struct attribute
*attr
, struct type
*type
,
21901 const char *name
, struct obstack
*obstack
,
21902 struct dwarf2_cu
*cu
,
21903 LONGEST
*value
, const gdb_byte
**bytes
,
21904 struct dwarf2_locexpr_baton
**baton
)
21906 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
21907 struct comp_unit_head
*cu_header
= &cu
->header
;
21908 struct dwarf_block
*blk
;
21909 enum bfd_endian byte_order
= (bfd_big_endian (objfile
->obfd
) ?
21910 BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
21916 switch (attr
->form
)
21919 case DW_FORM_addrx
:
21920 case DW_FORM_GNU_addr_index
:
21924 if (TYPE_LENGTH (type
) != cu_header
->addr_size
)
21925 dwarf2_const_value_length_mismatch_complaint (name
,
21926 cu_header
->addr_size
,
21927 TYPE_LENGTH (type
));
21928 /* Symbols of this form are reasonably rare, so we just
21929 piggyback on the existing location code rather than writing
21930 a new implementation of symbol_computed_ops. */
21931 *baton
= XOBNEW (obstack
, struct dwarf2_locexpr_baton
);
21932 (*baton
)->per_cu
= cu
->per_cu
;
21933 gdb_assert ((*baton
)->per_cu
);
21935 (*baton
)->size
= 2 + cu_header
->addr_size
;
21936 data
= (gdb_byte
*) obstack_alloc (obstack
, (*baton
)->size
);
21937 (*baton
)->data
= data
;
21939 data
[0] = DW_OP_addr
;
21940 store_unsigned_integer (&data
[1], cu_header
->addr_size
,
21941 byte_order
, DW_ADDR (attr
));
21942 data
[cu_header
->addr_size
+ 1] = DW_OP_stack_value
;
21945 case DW_FORM_string
:
21948 case DW_FORM_GNU_str_index
:
21949 case DW_FORM_GNU_strp_alt
:
21950 /* DW_STRING is already allocated on the objfile obstack, point
21952 *bytes
= (const gdb_byte
*) DW_STRING (attr
);
21954 case DW_FORM_block1
:
21955 case DW_FORM_block2
:
21956 case DW_FORM_block4
:
21957 case DW_FORM_block
:
21958 case DW_FORM_exprloc
:
21959 case DW_FORM_data16
:
21960 blk
= DW_BLOCK (attr
);
21961 if (TYPE_LENGTH (type
) != blk
->size
)
21962 dwarf2_const_value_length_mismatch_complaint (name
, blk
->size
,
21963 TYPE_LENGTH (type
));
21964 *bytes
= blk
->data
;
21967 /* The DW_AT_const_value attributes are supposed to carry the
21968 symbol's value "represented as it would be on the target
21969 architecture." By the time we get here, it's already been
21970 converted to host endianness, so we just need to sign- or
21971 zero-extend it as appropriate. */
21972 case DW_FORM_data1
:
21973 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 8);
21975 case DW_FORM_data2
:
21976 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 16);
21978 case DW_FORM_data4
:
21979 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 32);
21981 case DW_FORM_data8
:
21982 *bytes
= dwarf2_const_value_data (attr
, obstack
, cu
, value
, 64);
21985 case DW_FORM_sdata
:
21986 case DW_FORM_implicit_const
:
21987 *value
= DW_SND (attr
);
21990 case DW_FORM_udata
:
21991 *value
= DW_UNSND (attr
);
21995 complaint (_("unsupported const value attribute form: '%s'"),
21996 dwarf_form_name (attr
->form
));
22003 /* Copy constant value from an attribute to a symbol. */
22006 dwarf2_const_value (const struct attribute
*attr
, struct symbol
*sym
,
22007 struct dwarf2_cu
*cu
)
22009 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22011 const gdb_byte
*bytes
;
22012 struct dwarf2_locexpr_baton
*baton
;
22014 dwarf2_const_value_attr (attr
, SYMBOL_TYPE (sym
),
22015 SYMBOL_PRINT_NAME (sym
),
22016 &objfile
->objfile_obstack
, cu
,
22017 &value
, &bytes
, &baton
);
22021 SYMBOL_LOCATION_BATON (sym
) = baton
;
22022 SYMBOL_ACLASS_INDEX (sym
) = dwarf2_locexpr_index
;
22024 else if (bytes
!= NULL
)
22026 SYMBOL_VALUE_BYTES (sym
) = bytes
;
22027 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST_BYTES
;
22031 SYMBOL_VALUE (sym
) = value
;
22032 SYMBOL_ACLASS_INDEX (sym
) = LOC_CONST
;
22036 /* Return the type of the die in question using its DW_AT_type attribute. */
22038 static struct type
*
22039 die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22041 struct attribute
*type_attr
;
22043 type_attr
= dwarf2_attr (die
, DW_AT_type
, cu
);
22046 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22047 /* A missing DW_AT_type represents a void type. */
22048 return objfile_type (objfile
)->builtin_void
;
22051 return lookup_die_type (die
, type_attr
, cu
);
22054 /* True iff CU's producer generates GNAT Ada auxiliary information
22055 that allows to find parallel types through that information instead
22056 of having to do expensive parallel lookups by type name. */
22059 need_gnat_info (struct dwarf2_cu
*cu
)
22061 /* Assume that the Ada compiler was GNAT, which always produces
22062 the auxiliary information. */
22063 return (cu
->language
== language_ada
);
22066 /* Return the auxiliary type of the die in question using its
22067 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
22068 attribute is not present. */
22070 static struct type
*
22071 die_descriptive_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22073 struct attribute
*type_attr
;
22075 type_attr
= dwarf2_attr (die
, DW_AT_GNAT_descriptive_type
, cu
);
22079 return lookup_die_type (die
, type_attr
, cu
);
22082 /* If DIE has a descriptive_type attribute, then set the TYPE's
22083 descriptive type accordingly. */
22086 set_descriptive_type (struct type
*type
, struct die_info
*die
,
22087 struct dwarf2_cu
*cu
)
22089 struct type
*descriptive_type
= die_descriptive_type (die
, cu
);
22091 if (descriptive_type
)
22093 ALLOCATE_GNAT_AUX_TYPE (type
);
22094 TYPE_DESCRIPTIVE_TYPE (type
) = descriptive_type
;
22098 /* Return the containing type of the die in question using its
22099 DW_AT_containing_type attribute. */
22101 static struct type
*
22102 die_containing_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
22104 struct attribute
*type_attr
;
22105 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22107 type_attr
= dwarf2_attr (die
, DW_AT_containing_type
, cu
);
22109 error (_("Dwarf Error: Problem turning containing type into gdb type "
22110 "[in module %s]"), objfile_name (objfile
));
22112 return lookup_die_type (die
, type_attr
, cu
);
22115 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22117 static struct type
*
22118 build_error_marker_type (struct dwarf2_cu
*cu
, struct die_info
*die
)
22120 struct dwarf2_per_objfile
*dwarf2_per_objfile
22121 = cu
->per_cu
->dwarf2_per_objfile
;
22122 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22125 std::string message
22126 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22127 objfile_name (objfile
),
22128 sect_offset_str (cu
->header
.sect_off
),
22129 sect_offset_str (die
->sect_off
));
22130 saved
= (char *) obstack_copy0 (&objfile
->objfile_obstack
,
22131 message
.c_str (), message
.length ());
22133 return init_type (objfile
, TYPE_CODE_ERROR
, 0, saved
);
22136 /* Look up the type of DIE in CU using its type attribute ATTR.
22137 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22138 DW_AT_containing_type.
22139 If there is no type substitute an error marker. */
22141 static struct type
*
22142 lookup_die_type (struct die_info
*die
, const struct attribute
*attr
,
22143 struct dwarf2_cu
*cu
)
22145 struct dwarf2_per_objfile
*dwarf2_per_objfile
22146 = cu
->per_cu
->dwarf2_per_objfile
;
22147 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
22148 struct type
*this_type
;
22150 gdb_assert (attr
->name
== DW_AT_type
22151 || attr
->name
== DW_AT_GNAT_descriptive_type
22152 || attr
->name
== DW_AT_containing_type
);
22154 /* First see if we have it cached. */
22156 if (attr
->form
== DW_FORM_GNU_ref_alt
)
22158 struct dwarf2_per_cu_data
*per_cu
;
22159 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
22161 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, 1,
22162 dwarf2_per_objfile
);
22163 this_type
= get_die_type_at_offset (sect_off
, per_cu
);
22165 else if (attr_form_is_ref (attr
))
22167 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
22169 this_type
= get_die_type_at_offset (sect_off
, cu
->per_cu
);
22171 else if (attr
->form
== DW_FORM_ref_sig8
)
22173 ULONGEST signature
= DW_SIGNATURE (attr
);
22175 return get_signatured_type (die
, signature
, cu
);
22179 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22180 " at %s [in module %s]"),
22181 dwarf_attr_name (attr
->name
), sect_offset_str (die
->sect_off
),
22182 objfile_name (objfile
));
22183 return build_error_marker_type (cu
, die
);
22186 /* If not cached we need to read it in. */
22188 if (this_type
== NULL
)
22190 struct die_info
*type_die
= NULL
;
22191 struct dwarf2_cu
*type_cu
= cu
;
22193 if (attr_form_is_ref (attr
))
22194 type_die
= follow_die_ref (die
, attr
, &type_cu
);
22195 if (type_die
== NULL
)
22196 return build_error_marker_type (cu
, die
);
22197 /* If we find the type now, it's probably because the type came
22198 from an inter-CU reference and the type's CU got expanded before
22200 this_type
= read_type_die (type_die
, type_cu
);
22203 /* If we still don't have a type use an error marker. */
22205 if (this_type
== NULL
)
22206 return build_error_marker_type (cu
, die
);
22211 /* Return the type in DIE, CU.
22212 Returns NULL for invalid types.
22214 This first does a lookup in die_type_hash,
22215 and only reads the die in if necessary.
22217 NOTE: This can be called when reading in partial or full symbols. */
22219 static struct type
*
22220 read_type_die (struct die_info
*die
, struct dwarf2_cu
*cu
)
22222 struct type
*this_type
;
22224 this_type
= get_die_type (die
, cu
);
22228 return read_type_die_1 (die
, cu
);
22231 /* Read the type in DIE, CU.
22232 Returns NULL for invalid types. */
22234 static struct type
*
22235 read_type_die_1 (struct die_info
*die
, struct dwarf2_cu
*cu
)
22237 struct type
*this_type
= NULL
;
22241 case DW_TAG_class_type
:
22242 case DW_TAG_interface_type
:
22243 case DW_TAG_structure_type
:
22244 case DW_TAG_union_type
:
22245 this_type
= read_structure_type (die
, cu
);
22247 case DW_TAG_enumeration_type
:
22248 this_type
= read_enumeration_type (die
, cu
);
22250 case DW_TAG_subprogram
:
22251 case DW_TAG_subroutine_type
:
22252 case DW_TAG_inlined_subroutine
:
22253 this_type
= read_subroutine_type (die
, cu
);
22255 case DW_TAG_array_type
:
22256 this_type
= read_array_type (die
, cu
);
22258 case DW_TAG_set_type
:
22259 this_type
= read_set_type (die
, cu
);
22261 case DW_TAG_pointer_type
:
22262 this_type
= read_tag_pointer_type (die
, cu
);
22264 case DW_TAG_ptr_to_member_type
:
22265 this_type
= read_tag_ptr_to_member_type (die
, cu
);
22267 case DW_TAG_reference_type
:
22268 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_REF
);
22270 case DW_TAG_rvalue_reference_type
:
22271 this_type
= read_tag_reference_type (die
, cu
, TYPE_CODE_RVALUE_REF
);
22273 case DW_TAG_const_type
:
22274 this_type
= read_tag_const_type (die
, cu
);
22276 case DW_TAG_volatile_type
:
22277 this_type
= read_tag_volatile_type (die
, cu
);
22279 case DW_TAG_restrict_type
:
22280 this_type
= read_tag_restrict_type (die
, cu
);
22282 case DW_TAG_string_type
:
22283 this_type
= read_tag_string_type (die
, cu
);
22285 case DW_TAG_typedef
:
22286 this_type
= read_typedef (die
, cu
);
22288 case DW_TAG_subrange_type
:
22289 this_type
= read_subrange_type (die
, cu
);
22291 case DW_TAG_base_type
:
22292 this_type
= read_base_type (die
, cu
);
22294 case DW_TAG_unspecified_type
:
22295 this_type
= read_unspecified_type (die
, cu
);
22297 case DW_TAG_namespace
:
22298 this_type
= read_namespace_type (die
, cu
);
22300 case DW_TAG_module
:
22301 this_type
= read_module_type (die
, cu
);
22303 case DW_TAG_atomic_type
:
22304 this_type
= read_tag_atomic_type (die
, cu
);
22307 complaint (_("unexpected tag in read_type_die: '%s'"),
22308 dwarf_tag_name (die
->tag
));
22315 /* See if we can figure out if the class lives in a namespace. We do
22316 this by looking for a member function; its demangled name will
22317 contain namespace info, if there is any.
22318 Return the computed name or NULL.
22319 Space for the result is allocated on the objfile's obstack.
22320 This is the full-die version of guess_partial_die_structure_name.
22321 In this case we know DIE has no useful parent. */
22324 guess_full_die_structure_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22326 struct die_info
*spec_die
;
22327 struct dwarf2_cu
*spec_cu
;
22328 struct die_info
*child
;
22329 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22332 spec_die
= die_specification (die
, &spec_cu
);
22333 if (spec_die
!= NULL
)
22339 for (child
= die
->child
;
22341 child
= child
->sibling
)
22343 if (child
->tag
== DW_TAG_subprogram
)
22345 const char *linkage_name
= dw2_linkage_name (child
, cu
);
22347 if (linkage_name
!= NULL
)
22350 = language_class_name_from_physname (cu
->language_defn
,
22354 if (actual_name
!= NULL
)
22356 const char *die_name
= dwarf2_name (die
, cu
);
22358 if (die_name
!= NULL
22359 && strcmp (die_name
, actual_name
) != 0)
22361 /* Strip off the class name from the full name.
22362 We want the prefix. */
22363 int die_name_len
= strlen (die_name
);
22364 int actual_name_len
= strlen (actual_name
);
22366 /* Test for '::' as a sanity check. */
22367 if (actual_name_len
> die_name_len
+ 2
22368 && actual_name
[actual_name_len
22369 - die_name_len
- 1] == ':')
22370 name
= (char *) obstack_copy0 (
22371 &objfile
->per_bfd
->storage_obstack
,
22372 actual_name
, actual_name_len
- die_name_len
- 2);
22375 xfree (actual_name
);
22384 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22385 prefix part in such case. See
22386 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22388 static const char *
22389 anonymous_struct_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22391 struct attribute
*attr
;
22394 if (die
->tag
!= DW_TAG_class_type
&& die
->tag
!= DW_TAG_interface_type
22395 && die
->tag
!= DW_TAG_structure_type
&& die
->tag
!= DW_TAG_union_type
)
22398 if (dwarf2_string_attr (die
, DW_AT_name
, cu
) != NULL
)
22401 attr
= dw2_linkage_name_attr (die
, cu
);
22402 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
22405 /* dwarf2_name had to be already called. */
22406 gdb_assert (DW_STRING_IS_CANONICAL (attr
));
22408 /* Strip the base name, keep any leading namespaces/classes. */
22409 base
= strrchr (DW_STRING (attr
), ':');
22410 if (base
== NULL
|| base
== DW_STRING (attr
) || base
[-1] != ':')
22413 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22414 return (char *) obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
22416 &base
[-1] - DW_STRING (attr
));
22419 /* Return the name of the namespace/class that DIE is defined within,
22420 or "" if we can't tell. The caller should not xfree the result.
22422 For example, if we're within the method foo() in the following
22432 then determine_prefix on foo's die will return "N::C". */
22434 static const char *
22435 determine_prefix (struct die_info
*die
, struct dwarf2_cu
*cu
)
22437 struct dwarf2_per_objfile
*dwarf2_per_objfile
22438 = cu
->per_cu
->dwarf2_per_objfile
;
22439 struct die_info
*parent
, *spec_die
;
22440 struct dwarf2_cu
*spec_cu
;
22441 struct type
*parent_type
;
22442 const char *retval
;
22444 if (cu
->language
!= language_cplus
22445 && cu
->language
!= language_fortran
&& cu
->language
!= language_d
22446 && cu
->language
!= language_rust
)
22449 retval
= anonymous_struct_prefix (die
, cu
);
22453 /* We have to be careful in the presence of DW_AT_specification.
22454 For example, with GCC 3.4, given the code
22458 // Definition of N::foo.
22462 then we'll have a tree of DIEs like this:
22464 1: DW_TAG_compile_unit
22465 2: DW_TAG_namespace // N
22466 3: DW_TAG_subprogram // declaration of N::foo
22467 4: DW_TAG_subprogram // definition of N::foo
22468 DW_AT_specification // refers to die #3
22470 Thus, when processing die #4, we have to pretend that we're in
22471 the context of its DW_AT_specification, namely the contex of die
22474 spec_die
= die_specification (die
, &spec_cu
);
22475 if (spec_die
== NULL
)
22476 parent
= die
->parent
;
22479 parent
= spec_die
->parent
;
22483 if (parent
== NULL
)
22485 else if (parent
->building_fullname
)
22488 const char *parent_name
;
22490 /* It has been seen on RealView 2.2 built binaries,
22491 DW_TAG_template_type_param types actually _defined_ as
22492 children of the parent class:
22495 template class <class Enum> Class{};
22496 Class<enum E> class_e;
22498 1: DW_TAG_class_type (Class)
22499 2: DW_TAG_enumeration_type (E)
22500 3: DW_TAG_enumerator (enum1:0)
22501 3: DW_TAG_enumerator (enum2:1)
22503 2: DW_TAG_template_type_param
22504 DW_AT_type DW_FORM_ref_udata (E)
22506 Besides being broken debug info, it can put GDB into an
22507 infinite loop. Consider:
22509 When we're building the full name for Class<E>, we'll start
22510 at Class, and go look over its template type parameters,
22511 finding E. We'll then try to build the full name of E, and
22512 reach here. We're now trying to build the full name of E,
22513 and look over the parent DIE for containing scope. In the
22514 broken case, if we followed the parent DIE of E, we'd again
22515 find Class, and once again go look at its template type
22516 arguments, etc., etc. Simply don't consider such parent die
22517 as source-level parent of this die (it can't be, the language
22518 doesn't allow it), and break the loop here. */
22519 name
= dwarf2_name (die
, cu
);
22520 parent_name
= dwarf2_name (parent
, cu
);
22521 complaint (_("template param type '%s' defined within parent '%s'"),
22522 name
? name
: "<unknown>",
22523 parent_name
? parent_name
: "<unknown>");
22527 switch (parent
->tag
)
22529 case DW_TAG_namespace
:
22530 parent_type
= read_type_die (parent
, cu
);
22531 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22532 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22533 Work around this problem here. */
22534 if (cu
->language
== language_cplus
22535 && strcmp (TYPE_NAME (parent_type
), "::") == 0)
22537 /* We give a name to even anonymous namespaces. */
22538 return TYPE_NAME (parent_type
);
22539 case DW_TAG_class_type
:
22540 case DW_TAG_interface_type
:
22541 case DW_TAG_structure_type
:
22542 case DW_TAG_union_type
:
22543 case DW_TAG_module
:
22544 parent_type
= read_type_die (parent
, cu
);
22545 if (TYPE_NAME (parent_type
) != NULL
)
22546 return TYPE_NAME (parent_type
);
22548 /* An anonymous structure is only allowed non-static data
22549 members; no typedefs, no member functions, et cetera.
22550 So it does not need a prefix. */
22552 case DW_TAG_compile_unit
:
22553 case DW_TAG_partial_unit
:
22554 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22555 if (cu
->language
== language_cplus
22556 && !dwarf2_per_objfile
->types
.empty ()
22557 && die
->child
!= NULL
22558 && (die
->tag
== DW_TAG_class_type
22559 || die
->tag
== DW_TAG_structure_type
22560 || die
->tag
== DW_TAG_union_type
))
22562 char *name
= guess_full_die_structure_name (die
, cu
);
22567 case DW_TAG_enumeration_type
:
22568 parent_type
= read_type_die (parent
, cu
);
22569 if (TYPE_DECLARED_CLASS (parent_type
))
22571 if (TYPE_NAME (parent_type
) != NULL
)
22572 return TYPE_NAME (parent_type
);
22575 /* Fall through. */
22577 return determine_prefix (parent
, cu
);
22581 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22582 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22583 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22584 an obconcat, otherwise allocate storage for the result. The CU argument is
22585 used to determine the language and hence, the appropriate separator. */
22587 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22590 typename_concat (struct obstack
*obs
, const char *prefix
, const char *suffix
,
22591 int physname
, struct dwarf2_cu
*cu
)
22593 const char *lead
= "";
22596 if (suffix
== NULL
|| suffix
[0] == '\0'
22597 || prefix
== NULL
|| prefix
[0] == '\0')
22599 else if (cu
->language
== language_d
)
22601 /* For D, the 'main' function could be defined in any module, but it
22602 should never be prefixed. */
22603 if (strcmp (suffix
, "D main") == 0)
22611 else if (cu
->language
== language_fortran
&& physname
)
22613 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22614 DW_AT_MIPS_linkage_name is preferred and used instead. */
22622 if (prefix
== NULL
)
22624 if (suffix
== NULL
)
22631 xmalloc (strlen (prefix
) + MAX_SEP_LEN
+ strlen (suffix
) + 1));
22633 strcpy (retval
, lead
);
22634 strcat (retval
, prefix
);
22635 strcat (retval
, sep
);
22636 strcat (retval
, suffix
);
22641 /* We have an obstack. */
22642 return obconcat (obs
, lead
, prefix
, sep
, suffix
, (char *) NULL
);
22646 /* Return sibling of die, NULL if no sibling. */
22648 static struct die_info
*
22649 sibling_die (struct die_info
*die
)
22651 return die
->sibling
;
22654 /* Get name of a die, return NULL if not found. */
22656 static const char *
22657 dwarf2_canonicalize_name (const char *name
, struct dwarf2_cu
*cu
,
22658 struct obstack
*obstack
)
22660 if (name
&& cu
->language
== language_cplus
)
22662 std::string canon_name
= cp_canonicalize_string (name
);
22664 if (!canon_name
.empty ())
22666 if (canon_name
!= name
)
22667 name
= (const char *) obstack_copy0 (obstack
,
22668 canon_name
.c_str (),
22669 canon_name
.length ());
22676 /* Get name of a die, return NULL if not found.
22677 Anonymous namespaces are converted to their magic string. */
22679 static const char *
22680 dwarf2_name (struct die_info
*die
, struct dwarf2_cu
*cu
)
22682 struct attribute
*attr
;
22683 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
22685 attr
= dwarf2_attr (die
, DW_AT_name
, cu
);
22686 if ((!attr
|| !DW_STRING (attr
))
22687 && die
->tag
!= DW_TAG_namespace
22688 && die
->tag
!= DW_TAG_class_type
22689 && die
->tag
!= DW_TAG_interface_type
22690 && die
->tag
!= DW_TAG_structure_type
22691 && die
->tag
!= DW_TAG_union_type
)
22696 case DW_TAG_compile_unit
:
22697 case DW_TAG_partial_unit
:
22698 /* Compilation units have a DW_AT_name that is a filename, not
22699 a source language identifier. */
22700 case DW_TAG_enumeration_type
:
22701 case DW_TAG_enumerator
:
22702 /* These tags always have simple identifiers already; no need
22703 to canonicalize them. */
22704 return DW_STRING (attr
);
22706 case DW_TAG_namespace
:
22707 if (attr
!= NULL
&& DW_STRING (attr
) != NULL
)
22708 return DW_STRING (attr
);
22709 return CP_ANONYMOUS_NAMESPACE_STR
;
22711 case DW_TAG_class_type
:
22712 case DW_TAG_interface_type
:
22713 case DW_TAG_structure_type
:
22714 case DW_TAG_union_type
:
22715 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22716 structures or unions. These were of the form "._%d" in GCC 4.1,
22717 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22718 and GCC 4.4. We work around this problem by ignoring these. */
22719 if (attr
&& DW_STRING (attr
)
22720 && (startswith (DW_STRING (attr
), "._")
22721 || startswith (DW_STRING (attr
), "<anonymous")))
22724 /* GCC might emit a nameless typedef that has a linkage name. See
22725 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22726 if (!attr
|| DW_STRING (attr
) == NULL
)
22728 char *demangled
= NULL
;
22730 attr
= dw2_linkage_name_attr (die
, cu
);
22731 if (attr
== NULL
|| DW_STRING (attr
) == NULL
)
22734 /* Avoid demangling DW_STRING (attr) the second time on a second
22735 call for the same DIE. */
22736 if (!DW_STRING_IS_CANONICAL (attr
))
22737 demangled
= gdb_demangle (DW_STRING (attr
), DMGL_TYPES
);
22743 /* FIXME: we already did this for the partial symbol... */
22746 obstack_copy0 (&objfile
->per_bfd
->storage_obstack
,
22747 demangled
, strlen (demangled
)));
22748 DW_STRING_IS_CANONICAL (attr
) = 1;
22751 /* Strip any leading namespaces/classes, keep only the base name.
22752 DW_AT_name for named DIEs does not contain the prefixes. */
22753 base
= strrchr (DW_STRING (attr
), ':');
22754 if (base
&& base
> DW_STRING (attr
) && base
[-1] == ':')
22757 return DW_STRING (attr
);
22766 if (!DW_STRING_IS_CANONICAL (attr
))
22769 = dwarf2_canonicalize_name (DW_STRING (attr
), cu
,
22770 &objfile
->per_bfd
->storage_obstack
);
22771 DW_STRING_IS_CANONICAL (attr
) = 1;
22773 return DW_STRING (attr
);
22776 /* Return the die that this die in an extension of, or NULL if there
22777 is none. *EXT_CU is the CU containing DIE on input, and the CU
22778 containing the return value on output. */
22780 static struct die_info
*
22781 dwarf2_extension (struct die_info
*die
, struct dwarf2_cu
**ext_cu
)
22783 struct attribute
*attr
;
22785 attr
= dwarf2_attr (die
, DW_AT_extension
, *ext_cu
);
22789 return follow_die_ref (die
, attr
, ext_cu
);
22792 /* A convenience function that returns an "unknown" DWARF name,
22793 including the value of V. STR is the name of the entity being
22794 printed, e.g., "TAG". */
22796 static const char *
22797 dwarf_unknown (const char *str
, unsigned v
)
22799 char *cell
= get_print_cell ();
22800 xsnprintf (cell
, PRINT_CELL_SIZE
, "DW_%s_<unknown: %u>", str
, v
);
22804 /* Convert a DIE tag into its string name. */
22806 static const char *
22807 dwarf_tag_name (unsigned tag
)
22809 const char *name
= get_DW_TAG_name (tag
);
22812 return dwarf_unknown ("TAG", tag
);
22817 /* Convert a DWARF attribute code into its string name. */
22819 static const char *
22820 dwarf_attr_name (unsigned attr
)
22824 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22825 if (attr
== DW_AT_MIPS_fde
)
22826 return "DW_AT_MIPS_fde";
22828 if (attr
== DW_AT_HP_block_index
)
22829 return "DW_AT_HP_block_index";
22832 name
= get_DW_AT_name (attr
);
22835 return dwarf_unknown ("AT", attr
);
22840 /* Convert a DWARF value form code into its string name. */
22842 static const char *
22843 dwarf_form_name (unsigned form
)
22845 const char *name
= get_DW_FORM_name (form
);
22848 return dwarf_unknown ("FORM", form
);
22853 static const char *
22854 dwarf_bool_name (unsigned mybool
)
22862 /* Convert a DWARF type code into its string name. */
22864 static const char *
22865 dwarf_type_encoding_name (unsigned enc
)
22867 const char *name
= get_DW_ATE_name (enc
);
22870 return dwarf_unknown ("ATE", enc
);
22876 dump_die_shallow (struct ui_file
*f
, int indent
, struct die_info
*die
)
22880 print_spaces (indent
, f
);
22881 fprintf_unfiltered (f
, "Die: %s (abbrev %d, offset %s)\n",
22882 dwarf_tag_name (die
->tag
), die
->abbrev
,
22883 sect_offset_str (die
->sect_off
));
22885 if (die
->parent
!= NULL
)
22887 print_spaces (indent
, f
);
22888 fprintf_unfiltered (f
, " parent at offset: %s\n",
22889 sect_offset_str (die
->parent
->sect_off
));
22892 print_spaces (indent
, f
);
22893 fprintf_unfiltered (f
, " has children: %s\n",
22894 dwarf_bool_name (die
->child
!= NULL
));
22896 print_spaces (indent
, f
);
22897 fprintf_unfiltered (f
, " attributes:\n");
22899 for (i
= 0; i
< die
->num_attrs
; ++i
)
22901 print_spaces (indent
, f
);
22902 fprintf_unfiltered (f
, " %s (%s) ",
22903 dwarf_attr_name (die
->attrs
[i
].name
),
22904 dwarf_form_name (die
->attrs
[i
].form
));
22906 switch (die
->attrs
[i
].form
)
22909 case DW_FORM_addrx
:
22910 case DW_FORM_GNU_addr_index
:
22911 fprintf_unfiltered (f
, "address: ");
22912 fputs_filtered (hex_string (DW_ADDR (&die
->attrs
[i
])), f
);
22914 case DW_FORM_block2
:
22915 case DW_FORM_block4
:
22916 case DW_FORM_block
:
22917 case DW_FORM_block1
:
22918 fprintf_unfiltered (f
, "block: size %s",
22919 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
22921 case DW_FORM_exprloc
:
22922 fprintf_unfiltered (f
, "expression: size %s",
22923 pulongest (DW_BLOCK (&die
->attrs
[i
])->size
));
22925 case DW_FORM_data16
:
22926 fprintf_unfiltered (f
, "constant of 16 bytes");
22928 case DW_FORM_ref_addr
:
22929 fprintf_unfiltered (f
, "ref address: ");
22930 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
22932 case DW_FORM_GNU_ref_alt
:
22933 fprintf_unfiltered (f
, "alt ref address: ");
22934 fputs_filtered (hex_string (DW_UNSND (&die
->attrs
[i
])), f
);
22940 case DW_FORM_ref_udata
:
22941 fprintf_unfiltered (f
, "constant ref: 0x%lx (adjusted)",
22942 (long) (DW_UNSND (&die
->attrs
[i
])));
22944 case DW_FORM_data1
:
22945 case DW_FORM_data2
:
22946 case DW_FORM_data4
:
22947 case DW_FORM_data8
:
22948 case DW_FORM_udata
:
22949 case DW_FORM_sdata
:
22950 fprintf_unfiltered (f
, "constant: %s",
22951 pulongest (DW_UNSND (&die
->attrs
[i
])));
22953 case DW_FORM_sec_offset
:
22954 fprintf_unfiltered (f
, "section offset: %s",
22955 pulongest (DW_UNSND (&die
->attrs
[i
])));
22957 case DW_FORM_ref_sig8
:
22958 fprintf_unfiltered (f
, "signature: %s",
22959 hex_string (DW_SIGNATURE (&die
->attrs
[i
])));
22961 case DW_FORM_string
:
22963 case DW_FORM_line_strp
:
22965 case DW_FORM_GNU_str_index
:
22966 case DW_FORM_GNU_strp_alt
:
22967 fprintf_unfiltered (f
, "string: \"%s\" (%s canonicalized)",
22968 DW_STRING (&die
->attrs
[i
])
22969 ? DW_STRING (&die
->attrs
[i
]) : "",
22970 DW_STRING_IS_CANONICAL (&die
->attrs
[i
]) ? "is" : "not");
22973 if (DW_UNSND (&die
->attrs
[i
]))
22974 fprintf_unfiltered (f
, "flag: TRUE");
22976 fprintf_unfiltered (f
, "flag: FALSE");
22978 case DW_FORM_flag_present
:
22979 fprintf_unfiltered (f
, "flag: TRUE");
22981 case DW_FORM_indirect
:
22982 /* The reader will have reduced the indirect form to
22983 the "base form" so this form should not occur. */
22984 fprintf_unfiltered (f
,
22985 "unexpected attribute form: DW_FORM_indirect");
22987 case DW_FORM_implicit_const
:
22988 fprintf_unfiltered (f
, "constant: %s",
22989 plongest (DW_SND (&die
->attrs
[i
])));
22992 fprintf_unfiltered (f
, "unsupported attribute form: %d.",
22993 die
->attrs
[i
].form
);
22996 fprintf_unfiltered (f
, "\n");
23001 dump_die_for_error (struct die_info
*die
)
23003 dump_die_shallow (gdb_stderr
, 0, die
);
23007 dump_die_1 (struct ui_file
*f
, int level
, int max_level
, struct die_info
*die
)
23009 int indent
= level
* 4;
23011 gdb_assert (die
!= NULL
);
23013 if (level
>= max_level
)
23016 dump_die_shallow (f
, indent
, die
);
23018 if (die
->child
!= NULL
)
23020 print_spaces (indent
, f
);
23021 fprintf_unfiltered (f
, " Children:");
23022 if (level
+ 1 < max_level
)
23024 fprintf_unfiltered (f
, "\n");
23025 dump_die_1 (f
, level
+ 1, max_level
, die
->child
);
23029 fprintf_unfiltered (f
,
23030 " [not printed, max nesting level reached]\n");
23034 if (die
->sibling
!= NULL
&& level
> 0)
23036 dump_die_1 (f
, level
, max_level
, die
->sibling
);
23040 /* This is called from the pdie macro in gdbinit.in.
23041 It's not static so gcc will keep a copy callable from gdb. */
23044 dump_die (struct die_info
*die
, int max_level
)
23046 dump_die_1 (gdb_stdlog
, 0, max_level
, die
);
23050 store_in_ref_table (struct die_info
*die
, struct dwarf2_cu
*cu
)
23054 slot
= htab_find_slot_with_hash (cu
->die_hash
, die
,
23055 to_underlying (die
->sect_off
),
23061 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
23065 dwarf2_get_ref_die_offset (const struct attribute
*attr
)
23067 if (attr_form_is_ref (attr
))
23068 return (sect_offset
) DW_UNSND (attr
);
23070 complaint (_("unsupported die ref attribute form: '%s'"),
23071 dwarf_form_name (attr
->form
));
23075 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
23076 * the value held by the attribute is not constant. */
23079 dwarf2_get_attr_constant_value (const struct attribute
*attr
, int default_value
)
23081 if (attr
->form
== DW_FORM_sdata
|| attr
->form
== DW_FORM_implicit_const
)
23082 return DW_SND (attr
);
23083 else if (attr
->form
== DW_FORM_udata
23084 || attr
->form
== DW_FORM_data1
23085 || attr
->form
== DW_FORM_data2
23086 || attr
->form
== DW_FORM_data4
23087 || attr
->form
== DW_FORM_data8
)
23088 return DW_UNSND (attr
);
23091 /* For DW_FORM_data16 see attr_form_is_constant. */
23092 complaint (_("Attribute value is not a constant (%s)"),
23093 dwarf_form_name (attr
->form
));
23094 return default_value
;
23098 /* Follow reference or signature attribute ATTR of SRC_DIE.
23099 On entry *REF_CU is the CU of SRC_DIE.
23100 On exit *REF_CU is the CU of the result. */
23102 static struct die_info
*
23103 follow_die_ref_or_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23104 struct dwarf2_cu
**ref_cu
)
23106 struct die_info
*die
;
23108 if (attr_form_is_ref (attr
))
23109 die
= follow_die_ref (src_die
, attr
, ref_cu
);
23110 else if (attr
->form
== DW_FORM_ref_sig8
)
23111 die
= follow_die_sig (src_die
, attr
, ref_cu
);
23114 dump_die_for_error (src_die
);
23115 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23116 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23122 /* Follow reference OFFSET.
23123 On entry *REF_CU is the CU of the source die referencing OFFSET.
23124 On exit *REF_CU is the CU of the result.
23125 Returns NULL if OFFSET is invalid. */
23127 static struct die_info
*
23128 follow_die_offset (sect_offset sect_off
, int offset_in_dwz
,
23129 struct dwarf2_cu
**ref_cu
)
23131 struct die_info temp_die
;
23132 struct dwarf2_cu
*target_cu
, *cu
= *ref_cu
;
23133 struct dwarf2_per_objfile
*dwarf2_per_objfile
23134 = cu
->per_cu
->dwarf2_per_objfile
;
23136 gdb_assert (cu
->per_cu
!= NULL
);
23140 if (cu
->per_cu
->is_debug_types
)
23142 /* .debug_types CUs cannot reference anything outside their CU.
23143 If they need to, they have to reference a signatured type via
23144 DW_FORM_ref_sig8. */
23145 if (!offset_in_cu_p (&cu
->header
, sect_off
))
23148 else if (offset_in_dwz
!= cu
->per_cu
->is_dwz
23149 || !offset_in_cu_p (&cu
->header
, sect_off
))
23151 struct dwarf2_per_cu_data
*per_cu
;
23153 per_cu
= dwarf2_find_containing_comp_unit (sect_off
, offset_in_dwz
,
23154 dwarf2_per_objfile
);
23156 /* If necessary, add it to the queue and load its DIEs. */
23157 if (maybe_queue_comp_unit (cu
, per_cu
, cu
->language
))
23158 load_full_comp_unit (per_cu
, false, cu
->language
);
23160 target_cu
= per_cu
->cu
;
23162 else if (cu
->dies
== NULL
)
23164 /* We're loading full DIEs during partial symbol reading. */
23165 gdb_assert (dwarf2_per_objfile
->reading_partial_symbols
);
23166 load_full_comp_unit (cu
->per_cu
, false, language_minimal
);
23169 *ref_cu
= target_cu
;
23170 temp_die
.sect_off
= sect_off
;
23172 if (target_cu
!= cu
)
23173 target_cu
->ancestor
= cu
;
23175 return (struct die_info
*) htab_find_with_hash (target_cu
->die_hash
,
23177 to_underlying (sect_off
));
23180 /* Follow reference attribute ATTR of SRC_DIE.
23181 On entry *REF_CU is the CU of SRC_DIE.
23182 On exit *REF_CU is the CU of the result. */
23184 static struct die_info
*
23185 follow_die_ref (struct die_info
*src_die
, const struct attribute
*attr
,
23186 struct dwarf2_cu
**ref_cu
)
23188 sect_offset sect_off
= dwarf2_get_ref_die_offset (attr
);
23189 struct dwarf2_cu
*cu
= *ref_cu
;
23190 struct die_info
*die
;
23192 die
= follow_die_offset (sect_off
,
23193 (attr
->form
== DW_FORM_GNU_ref_alt
23194 || cu
->per_cu
->is_dwz
),
23197 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23198 "at %s [in module %s]"),
23199 sect_offset_str (sect_off
), sect_offset_str (src_die
->sect_off
),
23200 objfile_name (cu
->per_cu
->dwarf2_per_objfile
->objfile
));
23205 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23206 Returned value is intended for DW_OP_call*. Returned
23207 dwarf2_locexpr_baton->data has lifetime of
23208 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
23210 struct dwarf2_locexpr_baton
23211 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off
,
23212 struct dwarf2_per_cu_data
*per_cu
,
23213 CORE_ADDR (*get_frame_pc
) (void *baton
),
23214 void *baton
, bool resolve_abstract_p
)
23216 struct dwarf2_cu
*cu
;
23217 struct die_info
*die
;
23218 struct attribute
*attr
;
23219 struct dwarf2_locexpr_baton retval
;
23220 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
23221 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
23223 if (per_cu
->cu
== NULL
)
23224 load_cu (per_cu
, false);
23228 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23229 Instead just throw an error, not much else we can do. */
23230 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23231 sect_offset_str (sect_off
), objfile_name (objfile
));
23234 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23236 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23237 sect_offset_str (sect_off
), objfile_name (objfile
));
23239 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23240 if (!attr
&& resolve_abstract_p
23241 && (dwarf2_per_objfile
->abstract_to_concrete
.find (die
->sect_off
)
23242 != dwarf2_per_objfile
->abstract_to_concrete
.end ()))
23244 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
23246 for (const auto &cand_off
23247 : dwarf2_per_objfile
->abstract_to_concrete
[die
->sect_off
])
23249 struct dwarf2_cu
*cand_cu
= cu
;
23250 struct die_info
*cand
23251 = follow_die_offset (cand_off
, per_cu
->is_dwz
, &cand_cu
);
23254 || cand
->parent
->tag
!= DW_TAG_subprogram
)
23257 CORE_ADDR pc_low
, pc_high
;
23258 get_scope_pc_bounds (cand
->parent
, &pc_low
, &pc_high
, cu
);
23259 if (pc_low
== ((CORE_ADDR
) -1)
23260 || !(pc_low
<= pc
&& pc
< pc_high
))
23264 attr
= dwarf2_attr (die
, DW_AT_location
, cu
);
23271 /* DWARF: "If there is no such attribute, then there is no effect.".
23272 DATA is ignored if SIZE is 0. */
23274 retval
.data
= NULL
;
23277 else if (attr_form_is_section_offset (attr
))
23279 struct dwarf2_loclist_baton loclist_baton
;
23280 CORE_ADDR pc
= (*get_frame_pc
) (baton
);
23283 fill_in_loclist_baton (cu
, &loclist_baton
, attr
);
23285 retval
.data
= dwarf2_find_location_expression (&loclist_baton
,
23287 retval
.size
= size
;
23291 if (!attr_form_is_block (attr
))
23292 error (_("Dwarf Error: DIE at %s referenced in module %s "
23293 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23294 sect_offset_str (sect_off
), objfile_name (objfile
));
23296 retval
.data
= DW_BLOCK (attr
)->data
;
23297 retval
.size
= DW_BLOCK (attr
)->size
;
23299 retval
.per_cu
= cu
->per_cu
;
23301 age_cached_comp_units (dwarf2_per_objfile
);
23306 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23309 struct dwarf2_locexpr_baton
23310 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu
,
23311 struct dwarf2_per_cu_data
*per_cu
,
23312 CORE_ADDR (*get_frame_pc
) (void *baton
),
23315 sect_offset sect_off
= per_cu
->sect_off
+ to_underlying (offset_in_cu
);
23317 return dwarf2_fetch_die_loc_sect_off (sect_off
, per_cu
, get_frame_pc
, baton
);
23320 /* Write a constant of a given type as target-ordered bytes into
23323 static const gdb_byte
*
23324 write_constant_as_bytes (struct obstack
*obstack
,
23325 enum bfd_endian byte_order
,
23332 *len
= TYPE_LENGTH (type
);
23333 result
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23334 store_unsigned_integer (result
, *len
, byte_order
, value
);
23339 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23340 pointer to the constant bytes and set LEN to the length of the
23341 data. If memory is needed, allocate it on OBSTACK. If the DIE
23342 does not have a DW_AT_const_value, return NULL. */
23345 dwarf2_fetch_constant_bytes (sect_offset sect_off
,
23346 struct dwarf2_per_cu_data
*per_cu
,
23347 struct obstack
*obstack
,
23350 struct dwarf2_cu
*cu
;
23351 struct die_info
*die
;
23352 struct attribute
*attr
;
23353 const gdb_byte
*result
= NULL
;
23356 enum bfd_endian byte_order
;
23357 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
23359 if (per_cu
->cu
== NULL
)
23360 load_cu (per_cu
, false);
23364 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23365 Instead just throw an error, not much else we can do. */
23366 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23367 sect_offset_str (sect_off
), objfile_name (objfile
));
23370 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23372 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23373 sect_offset_str (sect_off
), objfile_name (objfile
));
23375 attr
= dwarf2_attr (die
, DW_AT_const_value
, cu
);
23379 byte_order
= (bfd_big_endian (objfile
->obfd
)
23380 ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
);
23382 switch (attr
->form
)
23385 case DW_FORM_addrx
:
23386 case DW_FORM_GNU_addr_index
:
23390 *len
= cu
->header
.addr_size
;
23391 tem
= (gdb_byte
*) obstack_alloc (obstack
, *len
);
23392 store_unsigned_integer (tem
, *len
, byte_order
, DW_ADDR (attr
));
23396 case DW_FORM_string
:
23399 case DW_FORM_GNU_str_index
:
23400 case DW_FORM_GNU_strp_alt
:
23401 /* DW_STRING is already allocated on the objfile obstack, point
23403 result
= (const gdb_byte
*) DW_STRING (attr
);
23404 *len
= strlen (DW_STRING (attr
));
23406 case DW_FORM_block1
:
23407 case DW_FORM_block2
:
23408 case DW_FORM_block4
:
23409 case DW_FORM_block
:
23410 case DW_FORM_exprloc
:
23411 case DW_FORM_data16
:
23412 result
= DW_BLOCK (attr
)->data
;
23413 *len
= DW_BLOCK (attr
)->size
;
23416 /* The DW_AT_const_value attributes are supposed to carry the
23417 symbol's value "represented as it would be on the target
23418 architecture." By the time we get here, it's already been
23419 converted to host endianness, so we just need to sign- or
23420 zero-extend it as appropriate. */
23421 case DW_FORM_data1
:
23422 type
= die_type (die
, cu
);
23423 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 8);
23424 if (result
== NULL
)
23425 result
= write_constant_as_bytes (obstack
, byte_order
,
23428 case DW_FORM_data2
:
23429 type
= die_type (die
, cu
);
23430 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 16);
23431 if (result
== NULL
)
23432 result
= write_constant_as_bytes (obstack
, byte_order
,
23435 case DW_FORM_data4
:
23436 type
= die_type (die
, cu
);
23437 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 32);
23438 if (result
== NULL
)
23439 result
= write_constant_as_bytes (obstack
, byte_order
,
23442 case DW_FORM_data8
:
23443 type
= die_type (die
, cu
);
23444 result
= dwarf2_const_value_data (attr
, obstack
, cu
, &value
, 64);
23445 if (result
== NULL
)
23446 result
= write_constant_as_bytes (obstack
, byte_order
,
23450 case DW_FORM_sdata
:
23451 case DW_FORM_implicit_const
:
23452 type
= die_type (die
, cu
);
23453 result
= write_constant_as_bytes (obstack
, byte_order
,
23454 type
, DW_SND (attr
), len
);
23457 case DW_FORM_udata
:
23458 type
= die_type (die
, cu
);
23459 result
= write_constant_as_bytes (obstack
, byte_order
,
23460 type
, DW_UNSND (attr
), len
);
23464 complaint (_("unsupported const value attribute form: '%s'"),
23465 dwarf_form_name (attr
->form
));
23472 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23473 valid type for this die is found. */
23476 dwarf2_fetch_die_type_sect_off (sect_offset sect_off
,
23477 struct dwarf2_per_cu_data
*per_cu
)
23479 struct dwarf2_cu
*cu
;
23480 struct die_info
*die
;
23482 if (per_cu
->cu
== NULL
)
23483 load_cu (per_cu
, false);
23488 die
= follow_die_offset (sect_off
, per_cu
->is_dwz
, &cu
);
23492 return die_type (die
, cu
);
23495 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23499 dwarf2_get_die_type (cu_offset die_offset
,
23500 struct dwarf2_per_cu_data
*per_cu
)
23502 sect_offset die_offset_sect
= per_cu
->sect_off
+ to_underlying (die_offset
);
23503 return get_die_type_at_offset (die_offset_sect
, per_cu
);
23506 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23507 On entry *REF_CU is the CU of SRC_DIE.
23508 On exit *REF_CU is the CU of the result.
23509 Returns NULL if the referenced DIE isn't found. */
23511 static struct die_info
*
23512 follow_die_sig_1 (struct die_info
*src_die
, struct signatured_type
*sig_type
,
23513 struct dwarf2_cu
**ref_cu
)
23515 struct die_info temp_die
;
23516 struct dwarf2_cu
*sig_cu
, *cu
= *ref_cu
;
23517 struct die_info
*die
;
23519 /* While it might be nice to assert sig_type->type == NULL here,
23520 we can get here for DW_AT_imported_declaration where we need
23521 the DIE not the type. */
23523 /* If necessary, add it to the queue and load its DIEs. */
23525 if (maybe_queue_comp_unit (*ref_cu
, &sig_type
->per_cu
, language_minimal
))
23526 read_signatured_type (sig_type
);
23528 sig_cu
= sig_type
->per_cu
.cu
;
23529 gdb_assert (sig_cu
!= NULL
);
23530 gdb_assert (to_underlying (sig_type
->type_offset_in_section
) != 0);
23531 temp_die
.sect_off
= sig_type
->type_offset_in_section
;
23532 die
= (struct die_info
*) htab_find_with_hash (sig_cu
->die_hash
, &temp_die
,
23533 to_underlying (temp_die
.sect_off
));
23536 struct dwarf2_per_objfile
*dwarf2_per_objfile
23537 = (*ref_cu
)->per_cu
->dwarf2_per_objfile
;
23539 /* For .gdb_index version 7 keep track of included TUs.
23540 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23541 if (dwarf2_per_objfile
->index_table
!= NULL
23542 && dwarf2_per_objfile
->index_table
->version
<= 7)
23544 VEC_safe_push (dwarf2_per_cu_ptr
,
23545 (*ref_cu
)->per_cu
->imported_symtabs
,
23551 sig_cu
->ancestor
= cu
;
23559 /* Follow signatured type referenced by ATTR in SRC_DIE.
23560 On entry *REF_CU is the CU of SRC_DIE.
23561 On exit *REF_CU is the CU of the result.
23562 The result is the DIE of the type.
23563 If the referenced type cannot be found an error is thrown. */
23565 static struct die_info
*
23566 follow_die_sig (struct die_info
*src_die
, const struct attribute
*attr
,
23567 struct dwarf2_cu
**ref_cu
)
23569 ULONGEST signature
= DW_SIGNATURE (attr
);
23570 struct signatured_type
*sig_type
;
23571 struct die_info
*die
;
23573 gdb_assert (attr
->form
== DW_FORM_ref_sig8
);
23575 sig_type
= lookup_signatured_type (*ref_cu
, signature
);
23576 /* sig_type will be NULL if the signatured type is missing from
23578 if (sig_type
== NULL
)
23580 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23581 " from DIE at %s [in module %s]"),
23582 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23583 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23586 die
= follow_die_sig_1 (src_die
, sig_type
, ref_cu
);
23589 dump_die_for_error (src_die
);
23590 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23591 " from DIE at %s [in module %s]"),
23592 hex_string (signature
), sect_offset_str (src_die
->sect_off
),
23593 objfile_name ((*ref_cu
)->per_cu
->dwarf2_per_objfile
->objfile
));
23599 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23600 reading in and processing the type unit if necessary. */
23602 static struct type
*
23603 get_signatured_type (struct die_info
*die
, ULONGEST signature
,
23604 struct dwarf2_cu
*cu
)
23606 struct dwarf2_per_objfile
*dwarf2_per_objfile
23607 = cu
->per_cu
->dwarf2_per_objfile
;
23608 struct signatured_type
*sig_type
;
23609 struct dwarf2_cu
*type_cu
;
23610 struct die_info
*type_die
;
23613 sig_type
= lookup_signatured_type (cu
, signature
);
23614 /* sig_type will be NULL if the signatured type is missing from
23616 if (sig_type
== NULL
)
23618 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23619 " from DIE at %s [in module %s]"),
23620 hex_string (signature
), sect_offset_str (die
->sect_off
),
23621 objfile_name (dwarf2_per_objfile
->objfile
));
23622 return build_error_marker_type (cu
, die
);
23625 /* If we already know the type we're done. */
23626 if (sig_type
->type
!= NULL
)
23627 return sig_type
->type
;
23630 type_die
= follow_die_sig_1 (die
, sig_type
, &type_cu
);
23631 if (type_die
!= NULL
)
23633 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23634 is created. This is important, for example, because for c++ classes
23635 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23636 type
= read_type_die (type_die
, type_cu
);
23639 complaint (_("Dwarf Error: Cannot build signatured type %s"
23640 " referenced from DIE at %s [in module %s]"),
23641 hex_string (signature
), sect_offset_str (die
->sect_off
),
23642 objfile_name (dwarf2_per_objfile
->objfile
));
23643 type
= build_error_marker_type (cu
, die
);
23648 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23649 " from DIE at %s [in module %s]"),
23650 hex_string (signature
), sect_offset_str (die
->sect_off
),
23651 objfile_name (dwarf2_per_objfile
->objfile
));
23652 type
= build_error_marker_type (cu
, die
);
23654 sig_type
->type
= type
;
23659 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23660 reading in and processing the type unit if necessary. */
23662 static struct type
*
23663 get_DW_AT_signature_type (struct die_info
*die
, const struct attribute
*attr
,
23664 struct dwarf2_cu
*cu
) /* ARI: editCase function */
23666 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23667 if (attr_form_is_ref (attr
))
23669 struct dwarf2_cu
*type_cu
= cu
;
23670 struct die_info
*type_die
= follow_die_ref (die
, attr
, &type_cu
);
23672 return read_type_die (type_die
, type_cu
);
23674 else if (attr
->form
== DW_FORM_ref_sig8
)
23676 return get_signatured_type (die
, DW_SIGNATURE (attr
), cu
);
23680 struct dwarf2_per_objfile
*dwarf2_per_objfile
23681 = cu
->per_cu
->dwarf2_per_objfile
;
23683 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23684 " at %s [in module %s]"),
23685 dwarf_form_name (attr
->form
), sect_offset_str (die
->sect_off
),
23686 objfile_name (dwarf2_per_objfile
->objfile
));
23687 return build_error_marker_type (cu
, die
);
23691 /* Load the DIEs associated with type unit PER_CU into memory. */
23694 load_full_type_unit (struct dwarf2_per_cu_data
*per_cu
)
23696 struct signatured_type
*sig_type
;
23698 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23699 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu
));
23701 /* We have the per_cu, but we need the signatured_type.
23702 Fortunately this is an easy translation. */
23703 gdb_assert (per_cu
->is_debug_types
);
23704 sig_type
= (struct signatured_type
*) per_cu
;
23706 gdb_assert (per_cu
->cu
== NULL
);
23708 read_signatured_type (sig_type
);
23710 gdb_assert (per_cu
->cu
!= NULL
);
23713 /* die_reader_func for read_signatured_type.
23714 This is identical to load_full_comp_unit_reader,
23715 but is kept separate for now. */
23718 read_signatured_type_reader (const struct die_reader_specs
*reader
,
23719 const gdb_byte
*info_ptr
,
23720 struct die_info
*comp_unit_die
,
23724 struct dwarf2_cu
*cu
= reader
->cu
;
23726 gdb_assert (cu
->die_hash
== NULL
);
23728 htab_create_alloc_ex (cu
->header
.length
/ 12,
23732 &cu
->comp_unit_obstack
,
23733 hashtab_obstack_allocate
,
23734 dummy_obstack_deallocate
);
23737 comp_unit_die
->child
= read_die_and_siblings (reader
, info_ptr
,
23738 &info_ptr
, comp_unit_die
);
23739 cu
->dies
= comp_unit_die
;
23740 /* comp_unit_die is not stored in die_hash, no need. */
23742 /* We try not to read any attributes in this function, because not
23743 all CUs needed for references have been loaded yet, and symbol
23744 table processing isn't initialized. But we have to set the CU language,
23745 or we won't be able to build types correctly.
23746 Similarly, if we do not read the producer, we can not apply
23747 producer-specific interpretation. */
23748 prepare_one_comp_unit (cu
, cu
->dies
, language_minimal
);
23751 /* Read in a signatured type and build its CU and DIEs.
23752 If the type is a stub for the real type in a DWO file,
23753 read in the real type from the DWO file as well. */
23756 read_signatured_type (struct signatured_type
*sig_type
)
23758 struct dwarf2_per_cu_data
*per_cu
= &sig_type
->per_cu
;
23760 gdb_assert (per_cu
->is_debug_types
);
23761 gdb_assert (per_cu
->cu
== NULL
);
23763 init_cutu_and_read_dies (per_cu
, NULL
, 0, 1, false,
23764 read_signatured_type_reader
, NULL
);
23765 sig_type
->per_cu
.tu_read
= 1;
23768 /* Decode simple location descriptions.
23769 Given a pointer to a dwarf block that defines a location, compute
23770 the location and return the value.
23772 NOTE drow/2003-11-18: This function is called in two situations
23773 now: for the address of static or global variables (partial symbols
23774 only) and for offsets into structures which are expected to be
23775 (more or less) constant. The partial symbol case should go away,
23776 and only the constant case should remain. That will let this
23777 function complain more accurately. A few special modes are allowed
23778 without complaint for global variables (for instance, global
23779 register values and thread-local values).
23781 A location description containing no operations indicates that the
23782 object is optimized out. The return value is 0 for that case.
23783 FIXME drow/2003-11-16: No callers check for this case any more; soon all
23784 callers will only want a very basic result and this can become a
23787 Note that stack[0] is unused except as a default error return. */
23790 decode_locdesc (struct dwarf_block
*blk
, struct dwarf2_cu
*cu
)
23792 struct objfile
*objfile
= cu
->per_cu
->dwarf2_per_objfile
->objfile
;
23794 size_t size
= blk
->size
;
23795 const gdb_byte
*data
= blk
->data
;
23796 CORE_ADDR stack
[64];
23798 unsigned int bytes_read
, unsnd
;
23804 stack
[++stacki
] = 0;
23843 stack
[++stacki
] = op
- DW_OP_lit0
;
23878 stack
[++stacki
] = op
- DW_OP_reg0
;
23880 dwarf2_complex_location_expr_complaint ();
23884 unsnd
= read_unsigned_leb128 (NULL
, (data
+ i
), &bytes_read
);
23886 stack
[++stacki
] = unsnd
;
23888 dwarf2_complex_location_expr_complaint ();
23892 stack
[++stacki
] = read_address (objfile
->obfd
, &data
[i
],
23897 case DW_OP_const1u
:
23898 stack
[++stacki
] = read_1_byte (objfile
->obfd
, &data
[i
]);
23902 case DW_OP_const1s
:
23903 stack
[++stacki
] = read_1_signed_byte (objfile
->obfd
, &data
[i
]);
23907 case DW_OP_const2u
:
23908 stack
[++stacki
] = read_2_bytes (objfile
->obfd
, &data
[i
]);
23912 case DW_OP_const2s
:
23913 stack
[++stacki
] = read_2_signed_bytes (objfile
->obfd
, &data
[i
]);
23917 case DW_OP_const4u
:
23918 stack
[++stacki
] = read_4_bytes (objfile
->obfd
, &data
[i
]);
23922 case DW_OP_const4s
:
23923 stack
[++stacki
] = read_4_signed_bytes (objfile
->obfd
, &data
[i
]);
23927 case DW_OP_const8u
:
23928 stack
[++stacki
] = read_8_bytes (objfile
->obfd
, &data
[i
]);
23933 stack
[++stacki
] = read_unsigned_leb128 (NULL
, (data
+ i
),
23939 stack
[++stacki
] = read_signed_leb128 (NULL
, (data
+ i
), &bytes_read
);
23944 stack
[stacki
+ 1] = stack
[stacki
];
23949 stack
[stacki
- 1] += stack
[stacki
];
23953 case DW_OP_plus_uconst
:
23954 stack
[stacki
] += read_unsigned_leb128 (NULL
, (data
+ i
),
23960 stack
[stacki
- 1] -= stack
[stacki
];
23965 /* If we're not the last op, then we definitely can't encode
23966 this using GDB's address_class enum. This is valid for partial
23967 global symbols, although the variable's address will be bogus
23970 dwarf2_complex_location_expr_complaint ();
23973 case DW_OP_GNU_push_tls_address
:
23974 case DW_OP_form_tls_address
:
23975 /* The top of the stack has the offset from the beginning
23976 of the thread control block at which the variable is located. */
23977 /* Nothing should follow this operator, so the top of stack would
23979 /* This is valid for partial global symbols, but the variable's
23980 address will be bogus in the psymtab. Make it always at least
23981 non-zero to not look as a variable garbage collected by linker
23982 which have DW_OP_addr 0. */
23984 dwarf2_complex_location_expr_complaint ();
23988 case DW_OP_GNU_uninit
:
23992 case DW_OP_GNU_addr_index
:
23993 case DW_OP_GNU_const_index
:
23994 stack
[++stacki
] = read_addr_index_from_leb128 (cu
, &data
[i
],
24001 const char *name
= get_DW_OP_name (op
);
24004 complaint (_("unsupported stack op: '%s'"),
24007 complaint (_("unsupported stack op: '%02x'"),
24011 return (stack
[stacki
]);
24014 /* Enforce maximum stack depth of SIZE-1 to avoid writing
24015 outside of the allocated space. Also enforce minimum>0. */
24016 if (stacki
>= ARRAY_SIZE (stack
) - 1)
24018 complaint (_("location description stack overflow"));
24024 complaint (_("location description stack underflow"));
24028 return (stack
[stacki
]);
24031 /* memory allocation interface */
24033 static struct dwarf_block
*
24034 dwarf_alloc_block (struct dwarf2_cu
*cu
)
24036 return XOBNEW (&cu
->comp_unit_obstack
, struct dwarf_block
);
24039 static struct die_info
*
24040 dwarf_alloc_die (struct dwarf2_cu
*cu
, int num_attrs
)
24042 struct die_info
*die
;
24043 size_t size
= sizeof (struct die_info
);
24046 size
+= (num_attrs
- 1) * sizeof (struct attribute
);
24048 die
= (struct die_info
*) obstack_alloc (&cu
->comp_unit_obstack
, size
);
24049 memset (die
, 0, sizeof (struct die_info
));
24054 /* Macro support. */
24056 /* Return file name relative to the compilation directory of file number I in
24057 *LH's file name table. The result is allocated using xmalloc; the caller is
24058 responsible for freeing it. */
24061 file_file_name (int file
, struct line_header
*lh
)
24063 /* Is the file number a valid index into the line header's file name
24064 table? Remember that file numbers start with one, not zero. */
24065 if (1 <= file
&& file
<= lh
->file_names
.size ())
24067 const file_entry
&fe
= lh
->file_names
[file
- 1];
24069 if (!IS_ABSOLUTE_PATH (fe
.name
))
24071 const char *dir
= fe
.include_dir (lh
);
24073 return concat (dir
, SLASH_STRING
, fe
.name
, (char *) NULL
);
24075 return xstrdup (fe
.name
);
24079 /* The compiler produced a bogus file number. We can at least
24080 record the macro definitions made in the file, even if we
24081 won't be able to find the file by name. */
24082 char fake_name
[80];
24084 xsnprintf (fake_name
, sizeof (fake_name
),
24085 "<bad macro file number %d>", file
);
24087 complaint (_("bad file number in macro information (%d)"),
24090 return xstrdup (fake_name
);
24094 /* Return the full name of file number I in *LH's file name table.
24095 Use COMP_DIR as the name of the current directory of the
24096 compilation. The result is allocated using xmalloc; the caller is
24097 responsible for freeing it. */
24099 file_full_name (int file
, struct line_header
*lh
, const char *comp_dir
)
24101 /* Is the file number a valid index into the line header's file name
24102 table? Remember that file numbers start with one, not zero. */
24103 if (1 <= file
&& file
<= lh
->file_names
.size ())
24105 char *relative
= file_file_name (file
, lh
);
24107 if (IS_ABSOLUTE_PATH (relative
) || comp_dir
== NULL
)
24109 return reconcat (relative
, comp_dir
, SLASH_STRING
,
24110 relative
, (char *) NULL
);
24113 return file_file_name (file
, lh
);
24117 static struct macro_source_file
*
24118 macro_start_file (struct dwarf2_cu
*cu
,
24119 int file
, int line
,
24120 struct macro_source_file
*current_file
,
24121 struct line_header
*lh
)
24123 /* File name relative to the compilation directory of this source file. */
24124 char *file_name
= file_file_name (file
, lh
);
24126 if (! current_file
)
24128 /* Note: We don't create a macro table for this compilation unit
24129 at all until we actually get a filename. */
24130 struct macro_table
*macro_table
= cu
->get_builder ()->get_macro_table ();
24132 /* If we have no current file, then this must be the start_file
24133 directive for the compilation unit's main source file. */
24134 current_file
= macro_set_main (macro_table
, file_name
);
24135 macro_define_special (macro_table
);
24138 current_file
= macro_include (current_file
, line
, file_name
);
24142 return current_file
;
24145 static const char *
24146 consume_improper_spaces (const char *p
, const char *body
)
24150 complaint (_("macro definition contains spaces "
24151 "in formal argument list:\n`%s'"),
24163 parse_macro_definition (struct macro_source_file
*file
, int line
,
24168 /* The body string takes one of two forms. For object-like macro
24169 definitions, it should be:
24171 <macro name> " " <definition>
24173 For function-like macro definitions, it should be:
24175 <macro name> "() " <definition>
24177 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24179 Spaces may appear only where explicitly indicated, and in the
24182 The Dwarf 2 spec says that an object-like macro's name is always
24183 followed by a space, but versions of GCC around March 2002 omit
24184 the space when the macro's definition is the empty string.
24186 The Dwarf 2 spec says that there should be no spaces between the
24187 formal arguments in a function-like macro's formal argument list,
24188 but versions of GCC around March 2002 include spaces after the
24192 /* Find the extent of the macro name. The macro name is terminated
24193 by either a space or null character (for an object-like macro) or
24194 an opening paren (for a function-like macro). */
24195 for (p
= body
; *p
; p
++)
24196 if (*p
== ' ' || *p
== '(')
24199 if (*p
== ' ' || *p
== '\0')
24201 /* It's an object-like macro. */
24202 int name_len
= p
- body
;
24203 char *name
= savestring (body
, name_len
);
24204 const char *replacement
;
24207 replacement
= body
+ name_len
+ 1;
24210 dwarf2_macro_malformed_definition_complaint (body
);
24211 replacement
= body
+ name_len
;
24214 macro_define_object (file
, line
, name
, replacement
);
24218 else if (*p
== '(')
24220 /* It's a function-like macro. */
24221 char *name
= savestring (body
, p
- body
);
24224 char **argv
= XNEWVEC (char *, argv_size
);
24228 p
= consume_improper_spaces (p
, body
);
24230 /* Parse the formal argument list. */
24231 while (*p
&& *p
!= ')')
24233 /* Find the extent of the current argument name. */
24234 const char *arg_start
= p
;
24236 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
24239 if (! *p
|| p
== arg_start
)
24240 dwarf2_macro_malformed_definition_complaint (body
);
24243 /* Make sure argv has room for the new argument. */
24244 if (argc
>= argv_size
)
24247 argv
= XRESIZEVEC (char *, argv
, argv_size
);
24250 argv
[argc
++] = savestring (arg_start
, p
- arg_start
);
24253 p
= consume_improper_spaces (p
, body
);
24255 /* Consume the comma, if present. */
24260 p
= consume_improper_spaces (p
, body
);
24269 /* Perfectly formed definition, no complaints. */
24270 macro_define_function (file
, line
, name
,
24271 argc
, (const char **) argv
,
24273 else if (*p
== '\0')
24275 /* Complain, but do define it. */
24276 dwarf2_macro_malformed_definition_complaint (body
);
24277 macro_define_function (file
, line
, name
,
24278 argc
, (const char **) argv
,
24282 /* Just complain. */
24283 dwarf2_macro_malformed_definition_complaint (body
);
24286 /* Just complain. */
24287 dwarf2_macro_malformed_definition_complaint (body
);
24293 for (i
= 0; i
< argc
; i
++)
24299 dwarf2_macro_malformed_definition_complaint (body
);
24302 /* Skip some bytes from BYTES according to the form given in FORM.
24303 Returns the new pointer. */
24305 static const gdb_byte
*
24306 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
24307 enum dwarf_form form
,
24308 unsigned int offset_size
,
24309 struct dwarf2_section_info
*section
)
24311 unsigned int bytes_read
;
24315 case DW_FORM_data1
:
24320 case DW_FORM_data2
:
24324 case DW_FORM_data4
:
24328 case DW_FORM_data8
:
24332 case DW_FORM_data16
:
24336 case DW_FORM_string
:
24337 read_direct_string (abfd
, bytes
, &bytes_read
);
24338 bytes
+= bytes_read
;
24341 case DW_FORM_sec_offset
:
24343 case DW_FORM_GNU_strp_alt
:
24344 bytes
+= offset_size
;
24347 case DW_FORM_block
:
24348 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
24349 bytes
+= bytes_read
;
24352 case DW_FORM_block1
:
24353 bytes
+= 1 + read_1_byte (abfd
, bytes
);
24355 case DW_FORM_block2
:
24356 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
24358 case DW_FORM_block4
:
24359 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
24362 case DW_FORM_addrx
:
24363 case DW_FORM_sdata
:
24365 case DW_FORM_udata
:
24366 case DW_FORM_GNU_addr_index
:
24367 case DW_FORM_GNU_str_index
:
24368 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
24371 dwarf2_section_buffer_overflow_complaint (section
);
24376 case DW_FORM_implicit_const
:
24381 complaint (_("invalid form 0x%x in `%s'"),
24382 form
, get_section_name (section
));
24390 /* A helper for dwarf_decode_macros that handles skipping an unknown
24391 opcode. Returns an updated pointer to the macro data buffer; or,
24392 on error, issues a complaint and returns NULL. */
24394 static const gdb_byte
*
24395 skip_unknown_opcode (unsigned int opcode
,
24396 const gdb_byte
**opcode_definitions
,
24397 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
24399 unsigned int offset_size
,
24400 struct dwarf2_section_info
*section
)
24402 unsigned int bytes_read
, i
;
24404 const gdb_byte
*defn
;
24406 if (opcode_definitions
[opcode
] == NULL
)
24408 complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24413 defn
= opcode_definitions
[opcode
];
24414 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
24415 defn
+= bytes_read
;
24417 for (i
= 0; i
< arg
; ++i
)
24419 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
,
24420 (enum dwarf_form
) defn
[i
], offset_size
,
24422 if (mac_ptr
== NULL
)
24424 /* skip_form_bytes already issued the complaint. */
24432 /* A helper function which parses the header of a macro section.
24433 If the macro section is the extended (for now called "GNU") type,
24434 then this updates *OFFSET_SIZE. Returns a pointer to just after
24435 the header, or issues a complaint and returns NULL on error. */
24437 static const gdb_byte
*
24438 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
24440 const gdb_byte
*mac_ptr
,
24441 unsigned int *offset_size
,
24442 int section_is_gnu
)
24444 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
24446 if (section_is_gnu
)
24448 unsigned int version
, flags
;
24450 version
= read_2_bytes (abfd
, mac_ptr
);
24451 if (version
!= 4 && version
!= 5)
24453 complaint (_("unrecognized version `%d' in .debug_macro section"),
24459 flags
= read_1_byte (abfd
, mac_ptr
);
24461 *offset_size
= (flags
& 1) ? 8 : 4;
24463 if ((flags
& 2) != 0)
24464 /* We don't need the line table offset. */
24465 mac_ptr
+= *offset_size
;
24467 /* Vendor opcode descriptions. */
24468 if ((flags
& 4) != 0)
24470 unsigned int i
, count
;
24472 count
= read_1_byte (abfd
, mac_ptr
);
24474 for (i
= 0; i
< count
; ++i
)
24476 unsigned int opcode
, bytes_read
;
24479 opcode
= read_1_byte (abfd
, mac_ptr
);
24481 opcode_definitions
[opcode
] = mac_ptr
;
24482 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24483 mac_ptr
+= bytes_read
;
24492 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24493 including DW_MACRO_import. */
24496 dwarf_decode_macro_bytes (struct dwarf2_cu
*cu
,
24498 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
24499 struct macro_source_file
*current_file
,
24500 struct line_header
*lh
,
24501 struct dwarf2_section_info
*section
,
24502 int section_is_gnu
, int section_is_dwz
,
24503 unsigned int offset_size
,
24504 htab_t include_hash
)
24506 struct dwarf2_per_objfile
*dwarf2_per_objfile
24507 = cu
->per_cu
->dwarf2_per_objfile
;
24508 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24509 enum dwarf_macro_record_type macinfo_type
;
24510 int at_commandline
;
24511 const gdb_byte
*opcode_definitions
[256];
24513 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
24514 &offset_size
, section_is_gnu
);
24515 if (mac_ptr
== NULL
)
24517 /* We already issued a complaint. */
24521 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24522 GDB is still reading the definitions from command line. First
24523 DW_MACINFO_start_file will need to be ignored as it was already executed
24524 to create CURRENT_FILE for the main source holding also the command line
24525 definitions. On first met DW_MACINFO_start_file this flag is reset to
24526 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24528 at_commandline
= 1;
24532 /* Do we at least have room for a macinfo type byte? */
24533 if (mac_ptr
>= mac_end
)
24535 dwarf2_section_buffer_overflow_complaint (section
);
24539 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
24542 /* Note that we rely on the fact that the corresponding GNU and
24543 DWARF constants are the same. */
24545 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24546 switch (macinfo_type
)
24548 /* A zero macinfo type indicates the end of the macro
24553 case DW_MACRO_define
:
24554 case DW_MACRO_undef
:
24555 case DW_MACRO_define_strp
:
24556 case DW_MACRO_undef_strp
:
24557 case DW_MACRO_define_sup
:
24558 case DW_MACRO_undef_sup
:
24560 unsigned int bytes_read
;
24565 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24566 mac_ptr
+= bytes_read
;
24568 if (macinfo_type
== DW_MACRO_define
24569 || macinfo_type
== DW_MACRO_undef
)
24571 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24572 mac_ptr
+= bytes_read
;
24576 LONGEST str_offset
;
24578 str_offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
24579 mac_ptr
+= offset_size
;
24581 if (macinfo_type
== DW_MACRO_define_sup
24582 || macinfo_type
== DW_MACRO_undef_sup
24585 struct dwz_file
*dwz
24586 = dwarf2_get_dwz_file (dwarf2_per_objfile
);
24588 body
= read_indirect_string_from_dwz (objfile
,
24592 body
= read_indirect_string_at_offset (dwarf2_per_objfile
,
24596 is_define
= (macinfo_type
== DW_MACRO_define
24597 || macinfo_type
== DW_MACRO_define_strp
24598 || macinfo_type
== DW_MACRO_define_sup
);
24599 if (! current_file
)
24601 /* DWARF violation as no main source is present. */
24602 complaint (_("debug info with no main source gives macro %s "
24604 is_define
? _("definition") : _("undefinition"),
24608 if ((line
== 0 && !at_commandline
)
24609 || (line
!= 0 && at_commandline
))
24610 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24611 at_commandline
? _("command-line") : _("in-file"),
24612 is_define
? _("definition") : _("undefinition"),
24613 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
24617 /* Fedora's rpm-build's "debugedit" binary
24618 corrupted .debug_macro sections.
24621 https://bugzilla.redhat.com/show_bug.cgi?id=1708786 */
24622 complaint (_("debug info gives %s invalid macro %s "
24623 "without body (corrupted?) at line %d "
24625 at_commandline
? _("command-line") : _("in-file"),
24626 is_define
? _("definition") : _("undefinition"),
24627 line
, current_file
->filename
);
24629 else if (is_define
)
24630 parse_macro_definition (current_file
, line
, body
);
24633 gdb_assert (macinfo_type
== DW_MACRO_undef
24634 || macinfo_type
== DW_MACRO_undef_strp
24635 || macinfo_type
== DW_MACRO_undef_sup
);
24636 macro_undef (current_file
, line
, body
);
24641 case DW_MACRO_start_file
:
24643 unsigned int bytes_read
;
24646 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24647 mac_ptr
+= bytes_read
;
24648 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24649 mac_ptr
+= bytes_read
;
24651 if ((line
== 0 && !at_commandline
)
24652 || (line
!= 0 && at_commandline
))
24653 complaint (_("debug info gives source %d included "
24654 "from %s at %s line %d"),
24655 file
, at_commandline
? _("command-line") : _("file"),
24656 line
== 0 ? _("zero") : _("non-zero"), line
);
24658 if (at_commandline
)
24660 /* This DW_MACRO_start_file was executed in the
24662 at_commandline
= 0;
24665 current_file
= macro_start_file (cu
, file
, line
, current_file
,
24670 case DW_MACRO_end_file
:
24671 if (! current_file
)
24672 complaint (_("macro debug info has an unmatched "
24673 "`close_file' directive"));
24676 current_file
= current_file
->included_by
;
24677 if (! current_file
)
24679 enum dwarf_macro_record_type next_type
;
24681 /* GCC circa March 2002 doesn't produce the zero
24682 type byte marking the end of the compilation
24683 unit. Complain if it's not there, but exit no
24686 /* Do we at least have room for a macinfo type byte? */
24687 if (mac_ptr
>= mac_end
)
24689 dwarf2_section_buffer_overflow_complaint (section
);
24693 /* We don't increment mac_ptr here, so this is just
24696 = (enum dwarf_macro_record_type
) read_1_byte (abfd
,
24698 if (next_type
!= 0)
24699 complaint (_("no terminating 0-type entry for "
24700 "macros in `.debug_macinfo' section"));
24707 case DW_MACRO_import
:
24708 case DW_MACRO_import_sup
:
24712 bfd
*include_bfd
= abfd
;
24713 struct dwarf2_section_info
*include_section
= section
;
24714 const gdb_byte
*include_mac_end
= mac_end
;
24715 int is_dwz
= section_is_dwz
;
24716 const gdb_byte
*new_mac_ptr
;
24718 offset
= read_offset_1 (abfd
, mac_ptr
, offset_size
);
24719 mac_ptr
+= offset_size
;
24721 if (macinfo_type
== DW_MACRO_import_sup
)
24723 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
24725 dwarf2_read_section (objfile
, &dwz
->macro
);
24727 include_section
= &dwz
->macro
;
24728 include_bfd
= get_section_bfd_owner (include_section
);
24729 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
24733 new_mac_ptr
= include_section
->buffer
+ offset
;
24734 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
24738 /* This has actually happened; see
24739 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
24740 complaint (_("recursive DW_MACRO_import in "
24741 ".debug_macro section"));
24745 *slot
= (void *) new_mac_ptr
;
24747 dwarf_decode_macro_bytes (cu
, include_bfd
, new_mac_ptr
,
24748 include_mac_end
, current_file
, lh
,
24749 section
, section_is_gnu
, is_dwz
,
24750 offset_size
, include_hash
);
24752 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
24757 case DW_MACINFO_vendor_ext
:
24758 if (!section_is_gnu
)
24760 unsigned int bytes_read
;
24762 /* This reads the constant, but since we don't recognize
24763 any vendor extensions, we ignore it. */
24764 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24765 mac_ptr
+= bytes_read
;
24766 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24767 mac_ptr
+= bytes_read
;
24769 /* We don't recognize any vendor extensions. */
24775 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
24776 mac_ptr
, mac_end
, abfd
, offset_size
,
24778 if (mac_ptr
== NULL
)
24783 } while (macinfo_type
!= 0);
24787 dwarf_decode_macros (struct dwarf2_cu
*cu
, unsigned int offset
,
24788 int section_is_gnu
)
24790 struct dwarf2_per_objfile
*dwarf2_per_objfile
24791 = cu
->per_cu
->dwarf2_per_objfile
;
24792 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
24793 struct line_header
*lh
= cu
->line_header
;
24795 const gdb_byte
*mac_ptr
, *mac_end
;
24796 struct macro_source_file
*current_file
= 0;
24797 enum dwarf_macro_record_type macinfo_type
;
24798 unsigned int offset_size
= cu
->header
.offset_size
;
24799 const gdb_byte
*opcode_definitions
[256];
24801 struct dwarf2_section_info
*section
;
24802 const char *section_name
;
24804 if (cu
->dwo_unit
!= NULL
)
24806 if (section_is_gnu
)
24808 section
= &cu
->dwo_unit
->dwo_file
->sections
.macro
;
24809 section_name
= ".debug_macro.dwo";
24813 section
= &cu
->dwo_unit
->dwo_file
->sections
.macinfo
;
24814 section_name
= ".debug_macinfo.dwo";
24819 if (section_is_gnu
)
24821 section
= &dwarf2_per_objfile
->macro
;
24822 section_name
= ".debug_macro";
24826 section
= &dwarf2_per_objfile
->macinfo
;
24827 section_name
= ".debug_macinfo";
24831 dwarf2_read_section (objfile
, section
);
24832 if (section
->buffer
== NULL
)
24834 complaint (_("missing %s section"), section_name
);
24837 abfd
= get_section_bfd_owner (section
);
24839 /* First pass: Find the name of the base filename.
24840 This filename is needed in order to process all macros whose definition
24841 (or undefinition) comes from the command line. These macros are defined
24842 before the first DW_MACINFO_start_file entry, and yet still need to be
24843 associated to the base file.
24845 To determine the base file name, we scan the macro definitions until we
24846 reach the first DW_MACINFO_start_file entry. We then initialize
24847 CURRENT_FILE accordingly so that any macro definition found before the
24848 first DW_MACINFO_start_file can still be associated to the base file. */
24850 mac_ptr
= section
->buffer
+ offset
;
24851 mac_end
= section
->buffer
+ section
->size
;
24853 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
24854 &offset_size
, section_is_gnu
);
24855 if (mac_ptr
== NULL
)
24857 /* We already issued a complaint. */
24863 /* Do we at least have room for a macinfo type byte? */
24864 if (mac_ptr
>= mac_end
)
24866 /* Complaint is printed during the second pass as GDB will probably
24867 stop the first pass earlier upon finding
24868 DW_MACINFO_start_file. */
24872 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
24875 /* Note that we rely on the fact that the corresponding GNU and
24876 DWARF constants are the same. */
24878 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24879 switch (macinfo_type
)
24881 /* A zero macinfo type indicates the end of the macro
24886 case DW_MACRO_define
:
24887 case DW_MACRO_undef
:
24888 /* Only skip the data by MAC_PTR. */
24890 unsigned int bytes_read
;
24892 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24893 mac_ptr
+= bytes_read
;
24894 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24895 mac_ptr
+= bytes_read
;
24899 case DW_MACRO_start_file
:
24901 unsigned int bytes_read
;
24904 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24905 mac_ptr
+= bytes_read
;
24906 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24907 mac_ptr
+= bytes_read
;
24909 current_file
= macro_start_file (cu
, file
, line
, current_file
, lh
);
24913 case DW_MACRO_end_file
:
24914 /* No data to skip by MAC_PTR. */
24917 case DW_MACRO_define_strp
:
24918 case DW_MACRO_undef_strp
:
24919 case DW_MACRO_define_sup
:
24920 case DW_MACRO_undef_sup
:
24922 unsigned int bytes_read
;
24924 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24925 mac_ptr
+= bytes_read
;
24926 mac_ptr
+= offset_size
;
24930 case DW_MACRO_import
:
24931 case DW_MACRO_import_sup
:
24932 /* Note that, according to the spec, a transparent include
24933 chain cannot call DW_MACRO_start_file. So, we can just
24934 skip this opcode. */
24935 mac_ptr
+= offset_size
;
24938 case DW_MACINFO_vendor_ext
:
24939 /* Only skip the data by MAC_PTR. */
24940 if (!section_is_gnu
)
24942 unsigned int bytes_read
;
24944 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
24945 mac_ptr
+= bytes_read
;
24946 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
24947 mac_ptr
+= bytes_read
;
24952 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
24953 mac_ptr
, mac_end
, abfd
, offset_size
,
24955 if (mac_ptr
== NULL
)
24960 } while (macinfo_type
!= 0 && current_file
== NULL
);
24962 /* Second pass: Process all entries.
24964 Use the AT_COMMAND_LINE flag to determine whether we are still processing
24965 command-line macro definitions/undefinitions. This flag is unset when we
24966 reach the first DW_MACINFO_start_file entry. */
24968 htab_up
include_hash (htab_create_alloc (1, htab_hash_pointer
,
24970 NULL
, xcalloc
, xfree
));
24971 mac_ptr
= section
->buffer
+ offset
;
24972 slot
= htab_find_slot (include_hash
.get (), mac_ptr
, INSERT
);
24973 *slot
= (void *) mac_ptr
;
24974 dwarf_decode_macro_bytes (cu
, abfd
, mac_ptr
, mac_end
,
24975 current_file
, lh
, section
,
24976 section_is_gnu
, 0, offset_size
,
24977 include_hash
.get ());
24980 /* Check if the attribute's form is a DW_FORM_block*
24981 if so return true else false. */
24984 attr_form_is_block (const struct attribute
*attr
)
24986 return (attr
== NULL
? 0 :
24987 attr
->form
== DW_FORM_block1
24988 || attr
->form
== DW_FORM_block2
24989 || attr
->form
== DW_FORM_block4
24990 || attr
->form
== DW_FORM_block
24991 || attr
->form
== DW_FORM_exprloc
);
24994 /* Return non-zero if ATTR's value is a section offset --- classes
24995 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24996 You may use DW_UNSND (attr) to retrieve such offsets.
24998 Section 7.5.4, "Attribute Encodings", explains that no attribute
24999 may have a value that belongs to more than one of these classes; it
25000 would be ambiguous if we did, because we use the same forms for all
25004 attr_form_is_section_offset (const struct attribute
*attr
)
25006 return (attr
->form
== DW_FORM_data4
25007 || attr
->form
== DW_FORM_data8
25008 || attr
->form
== DW_FORM_sec_offset
);
25011 /* Return non-zero if ATTR's value falls in the 'constant' class, or
25012 zero otherwise. When this function returns true, you can apply
25013 dwarf2_get_attr_constant_value to it.
25015 However, note that for some attributes you must check
25016 attr_form_is_section_offset before using this test. DW_FORM_data4
25017 and DW_FORM_data8 are members of both the constant class, and of
25018 the classes that contain offsets into other debug sections
25019 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
25020 that, if an attribute's can be either a constant or one of the
25021 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
25022 taken as section offsets, not constants.
25024 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
25025 cannot handle that. */
25028 attr_form_is_constant (const struct attribute
*attr
)
25030 switch (attr
->form
)
25032 case DW_FORM_sdata
:
25033 case DW_FORM_udata
:
25034 case DW_FORM_data1
:
25035 case DW_FORM_data2
:
25036 case DW_FORM_data4
:
25037 case DW_FORM_data8
:
25038 case DW_FORM_implicit_const
:
25046 /* DW_ADDR is always stored already as sect_offset; despite for the forms
25047 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
25050 attr_form_is_ref (const struct attribute
*attr
)
25052 switch (attr
->form
)
25054 case DW_FORM_ref_addr
:
25059 case DW_FORM_ref_udata
:
25060 case DW_FORM_GNU_ref_alt
:
25067 /* Return the .debug_loc section to use for CU.
25068 For DWO files use .debug_loc.dwo. */
25070 static struct dwarf2_section_info
*
25071 cu_debug_loc_section (struct dwarf2_cu
*cu
)
25073 struct dwarf2_per_objfile
*dwarf2_per_objfile
25074 = cu
->per_cu
->dwarf2_per_objfile
;
25078 struct dwo_sections
*sections
= &cu
->dwo_unit
->dwo_file
->sections
;
25080 return cu
->header
.version
>= 5 ? §ions
->loclists
: §ions
->loc
;
25082 return (cu
->header
.version
>= 5 ? &dwarf2_per_objfile
->loclists
25083 : &dwarf2_per_objfile
->loc
);
25086 /* A helper function that fills in a dwarf2_loclist_baton. */
25089 fill_in_loclist_baton (struct dwarf2_cu
*cu
,
25090 struct dwarf2_loclist_baton
*baton
,
25091 const struct attribute
*attr
)
25093 struct dwarf2_per_objfile
*dwarf2_per_objfile
25094 = cu
->per_cu
->dwarf2_per_objfile
;
25095 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
25097 dwarf2_read_section (dwarf2_per_objfile
->objfile
, section
);
25099 baton
->per_cu
= cu
->per_cu
;
25100 gdb_assert (baton
->per_cu
);
25101 /* We don't know how long the location list is, but make sure we
25102 don't run off the edge of the section. */
25103 baton
->size
= section
->size
- DW_UNSND (attr
);
25104 baton
->data
= section
->buffer
+ DW_UNSND (attr
);
25105 baton
->base_address
= cu
->base_address
;
25106 baton
->from_dwo
= cu
->dwo_unit
!= NULL
;
25110 dwarf2_symbol_mark_computed (const struct attribute
*attr
, struct symbol
*sym
,
25111 struct dwarf2_cu
*cu
, int is_block
)
25113 struct dwarf2_per_objfile
*dwarf2_per_objfile
25114 = cu
->per_cu
->dwarf2_per_objfile
;
25115 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
25116 struct dwarf2_section_info
*section
= cu_debug_loc_section (cu
);
25118 if (attr_form_is_section_offset (attr
)
25119 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
25120 the section. If so, fall through to the complaint in the
25122 && DW_UNSND (attr
) < dwarf2_section_size (objfile
, section
))
25124 struct dwarf2_loclist_baton
*baton
;
25126 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_loclist_baton
);
25128 fill_in_loclist_baton (cu
, baton
, attr
);
25130 if (cu
->base_known
== 0)
25131 complaint (_("Location list used without "
25132 "specifying the CU base address."));
25134 SYMBOL_ACLASS_INDEX (sym
) = (is_block
25135 ? dwarf2_loclist_block_index
25136 : dwarf2_loclist_index
);
25137 SYMBOL_LOCATION_BATON (sym
) = baton
;
25141 struct dwarf2_locexpr_baton
*baton
;
25143 baton
= XOBNEW (&objfile
->objfile_obstack
, struct dwarf2_locexpr_baton
);
25144 baton
->per_cu
= cu
->per_cu
;
25145 gdb_assert (baton
->per_cu
);
25147 if (attr_form_is_block (attr
))
25149 /* Note that we're just copying the block's data pointer
25150 here, not the actual data. We're still pointing into the
25151 info_buffer for SYM's objfile; right now we never release
25152 that buffer, but when we do clean up properly this may
25154 baton
->size
= DW_BLOCK (attr
)->size
;
25155 baton
->data
= DW_BLOCK (attr
)->data
;
25159 dwarf2_invalid_attrib_class_complaint ("location description",
25160 SYMBOL_NATURAL_NAME (sym
));
25164 SYMBOL_ACLASS_INDEX (sym
) = (is_block
25165 ? dwarf2_locexpr_block_index
25166 : dwarf2_locexpr_index
);
25167 SYMBOL_LOCATION_BATON (sym
) = baton
;
25171 /* Return the OBJFILE associated with the compilation unit CU. If CU
25172 came from a separate debuginfo file, then the master objfile is
25176 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data
*per_cu
)
25178 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25180 /* Return the master objfile, so that we can report and look up the
25181 correct file containing this variable. */
25182 if (objfile
->separate_debug_objfile_backlink
)
25183 objfile
= objfile
->separate_debug_objfile_backlink
;
25188 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25189 (CU_HEADERP is unused in such case) or prepare a temporary copy at
25190 CU_HEADERP first. */
25192 static const struct comp_unit_head
*
25193 per_cu_header_read_in (struct comp_unit_head
*cu_headerp
,
25194 struct dwarf2_per_cu_data
*per_cu
)
25196 const gdb_byte
*info_ptr
;
25199 return &per_cu
->cu
->header
;
25201 info_ptr
= per_cu
->section
->buffer
+ to_underlying (per_cu
->sect_off
);
25203 memset (cu_headerp
, 0, sizeof (*cu_headerp
));
25204 read_comp_unit_head (cu_headerp
, info_ptr
, per_cu
->section
,
25205 rcuh_kind::COMPILE
);
25210 /* Return the address size given in the compilation unit header for CU. */
25213 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data
*per_cu
)
25215 struct comp_unit_head cu_header_local
;
25216 const struct comp_unit_head
*cu_headerp
;
25218 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25220 return cu_headerp
->addr_size
;
25223 /* Return the offset size given in the compilation unit header for CU. */
25226 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data
*per_cu
)
25228 struct comp_unit_head cu_header_local
;
25229 const struct comp_unit_head
*cu_headerp
;
25231 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25233 return cu_headerp
->offset_size
;
25236 /* See its dwarf2loc.h declaration. */
25239 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data
*per_cu
)
25241 struct comp_unit_head cu_header_local
;
25242 const struct comp_unit_head
*cu_headerp
;
25244 cu_headerp
= per_cu_header_read_in (&cu_header_local
, per_cu
);
25246 if (cu_headerp
->version
== 2)
25247 return cu_headerp
->addr_size
;
25249 return cu_headerp
->offset_size
;
25252 /* Return the text offset of the CU. The returned offset comes from
25253 this CU's objfile. If this objfile came from a separate debuginfo
25254 file, then the offset may be different from the corresponding
25255 offset in the parent objfile. */
25258 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data
*per_cu
)
25260 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25262 return ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
25265 /* Return a type that is a generic pointer type, the size of which matches
25266 the address size given in the compilation unit header for PER_CU. */
25267 static struct type
*
25268 dwarf2_per_cu_addr_type (struct dwarf2_per_cu_data
*per_cu
)
25270 struct objfile
*objfile
= per_cu
->dwarf2_per_objfile
->objfile
;
25271 struct type
*void_type
= objfile_type (objfile
)->builtin_void
;
25272 struct type
*addr_type
= lookup_pointer_type (void_type
);
25273 int addr_size
= dwarf2_per_cu_addr_size (per_cu
);
25275 if (TYPE_LENGTH (addr_type
) == addr_size
)
25279 = dwarf2_per_cu_addr_sized_int_type (per_cu
, TYPE_UNSIGNED (addr_type
));
25283 /* Return DWARF version number of PER_CU. */
25286 dwarf2_version (struct dwarf2_per_cu_data
*per_cu
)
25288 return per_cu
->dwarf_version
;
25291 /* Locate the .debug_info compilation unit from CU's objfile which contains
25292 the DIE at OFFSET. Raises an error on failure. */
25294 static struct dwarf2_per_cu_data
*
25295 dwarf2_find_containing_comp_unit (sect_offset sect_off
,
25296 unsigned int offset_in_dwz
,
25297 struct dwarf2_per_objfile
*dwarf2_per_objfile
)
25299 struct dwarf2_per_cu_data
*this_cu
;
25303 high
= dwarf2_per_objfile
->all_comp_units
.size () - 1;
25306 struct dwarf2_per_cu_data
*mid_cu
;
25307 int mid
= low
+ (high
- low
) / 2;
25309 mid_cu
= dwarf2_per_objfile
->all_comp_units
[mid
];
25310 if (mid_cu
->is_dwz
> offset_in_dwz
25311 || (mid_cu
->is_dwz
== offset_in_dwz
25312 && mid_cu
->sect_off
+ mid_cu
->length
>= sect_off
))
25317 gdb_assert (low
== high
);
25318 this_cu
= dwarf2_per_objfile
->all_comp_units
[low
];
25319 if (this_cu
->is_dwz
!= offset_in_dwz
|| this_cu
->sect_off
> sect_off
)
25321 if (low
== 0 || this_cu
->is_dwz
!= offset_in_dwz
)
25322 error (_("Dwarf Error: could not find partial DIE containing "
25323 "offset %s [in module %s]"),
25324 sect_offset_str (sect_off
),
25325 bfd_get_filename (dwarf2_per_objfile
->objfile
->obfd
));
25327 gdb_assert (dwarf2_per_objfile
->all_comp_units
[low
-1]->sect_off
25329 return dwarf2_per_objfile
->all_comp_units
[low
-1];
25333 if (low
== dwarf2_per_objfile
->all_comp_units
.size () - 1
25334 && sect_off
>= this_cu
->sect_off
+ this_cu
->length
)
25335 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off
));
25336 gdb_assert (sect_off
< this_cu
->sect_off
+ this_cu
->length
);
25341 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25343 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data
*per_cu_
)
25344 : per_cu (per_cu_
),
25346 has_loclist (false),
25347 checked_producer (false),
25348 producer_is_gxx_lt_4_6 (false),
25349 producer_is_gcc_lt_4_3 (false),
25350 producer_is_icc (false),
25351 producer_is_icc_lt_14 (false),
25352 producer_is_codewarrior (false),
25353 processing_has_namespace_info (false)
25358 /* Destroy a dwarf2_cu. */
25360 dwarf2_cu::~dwarf2_cu ()
25365 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25368 prepare_one_comp_unit (struct dwarf2_cu
*cu
, struct die_info
*comp_unit_die
,
25369 enum language pretend_language
)
25371 struct attribute
*attr
;
25373 /* Set the language we're debugging. */
25374 attr
= dwarf2_attr (comp_unit_die
, DW_AT_language
, cu
);
25376 set_cu_language (DW_UNSND (attr
), cu
);
25379 cu
->language
= pretend_language
;
25380 cu
->language_defn
= language_def (cu
->language
);
25383 cu
->producer
= dwarf2_string_attr (comp_unit_die
, DW_AT_producer
, cu
);
25386 /* Increase the age counter on each cached compilation unit, and free
25387 any that are too old. */
25390 age_cached_comp_units (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
25392 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
25394 dwarf2_clear_marks (dwarf2_per_objfile
->read_in_chain
);
25395 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25396 while (per_cu
!= NULL
)
25398 per_cu
->cu
->last_used
++;
25399 if (per_cu
->cu
->last_used
<= dwarf_max_cache_age
)
25400 dwarf2_mark (per_cu
->cu
);
25401 per_cu
= per_cu
->cu
->read_in_chain
;
25404 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25405 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
25406 while (per_cu
!= NULL
)
25408 struct dwarf2_per_cu_data
*next_cu
;
25410 next_cu
= per_cu
->cu
->read_in_chain
;
25412 if (!per_cu
->cu
->mark
)
25415 *last_chain
= next_cu
;
25418 last_chain
= &per_cu
->cu
->read_in_chain
;
25424 /* Remove a single compilation unit from the cache. */
25427 free_one_cached_comp_unit (struct dwarf2_per_cu_data
*target_per_cu
)
25429 struct dwarf2_per_cu_data
*per_cu
, **last_chain
;
25430 struct dwarf2_per_objfile
*dwarf2_per_objfile
25431 = target_per_cu
->dwarf2_per_objfile
;
25433 per_cu
= dwarf2_per_objfile
->read_in_chain
;
25434 last_chain
= &dwarf2_per_objfile
->read_in_chain
;
25435 while (per_cu
!= NULL
)
25437 struct dwarf2_per_cu_data
*next_cu
;
25439 next_cu
= per_cu
->cu
->read_in_chain
;
25441 if (per_cu
== target_per_cu
)
25445 *last_chain
= next_cu
;
25449 last_chain
= &per_cu
->cu
->read_in_chain
;
25455 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25456 We store these in a hash table separate from the DIEs, and preserve them
25457 when the DIEs are flushed out of cache.
25459 The CU "per_cu" pointer is needed because offset alone is not enough to
25460 uniquely identify the type. A file may have multiple .debug_types sections,
25461 or the type may come from a DWO file. Furthermore, while it's more logical
25462 to use per_cu->section+offset, with Fission the section with the data is in
25463 the DWO file but we don't know that section at the point we need it.
25464 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25465 because we can enter the lookup routine, get_die_type_at_offset, from
25466 outside this file, and thus won't necessarily have PER_CU->cu.
25467 Fortunately, PER_CU is stable for the life of the objfile. */
25469 struct dwarf2_per_cu_offset_and_type
25471 const struct dwarf2_per_cu_data
*per_cu
;
25472 sect_offset sect_off
;
25476 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25479 per_cu_offset_and_type_hash (const void *item
)
25481 const struct dwarf2_per_cu_offset_and_type
*ofs
25482 = (const struct dwarf2_per_cu_offset_and_type
*) item
;
25484 return (uintptr_t) ofs
->per_cu
+ to_underlying (ofs
->sect_off
);
25487 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25490 per_cu_offset_and_type_eq (const void *item_lhs
, const void *item_rhs
)
25492 const struct dwarf2_per_cu_offset_and_type
*ofs_lhs
25493 = (const struct dwarf2_per_cu_offset_and_type
*) item_lhs
;
25494 const struct dwarf2_per_cu_offset_and_type
*ofs_rhs
25495 = (const struct dwarf2_per_cu_offset_and_type
*) item_rhs
;
25497 return (ofs_lhs
->per_cu
== ofs_rhs
->per_cu
25498 && ofs_lhs
->sect_off
== ofs_rhs
->sect_off
);
25501 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25502 table if necessary. For convenience, return TYPE.
25504 The DIEs reading must have careful ordering to:
25505 * Not cause infite loops trying to read in DIEs as a prerequisite for
25506 reading current DIE.
25507 * Not trying to dereference contents of still incompletely read in types
25508 while reading in other DIEs.
25509 * Enable referencing still incompletely read in types just by a pointer to
25510 the type without accessing its fields.
25512 Therefore caller should follow these rules:
25513 * Try to fetch any prerequisite types we may need to build this DIE type
25514 before building the type and calling set_die_type.
25515 * After building type call set_die_type for current DIE as soon as
25516 possible before fetching more types to complete the current type.
25517 * Make the type as complete as possible before fetching more types. */
25519 static struct type
*
25520 set_die_type (struct die_info
*die
, struct type
*type
, struct dwarf2_cu
*cu
)
25522 struct dwarf2_per_objfile
*dwarf2_per_objfile
25523 = cu
->per_cu
->dwarf2_per_objfile
;
25524 struct dwarf2_per_cu_offset_and_type
**slot
, ofs
;
25525 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
25526 struct attribute
*attr
;
25527 struct dynamic_prop prop
;
25529 /* For Ada types, make sure that the gnat-specific data is always
25530 initialized (if not already set). There are a few types where
25531 we should not be doing so, because the type-specific area is
25532 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25533 where the type-specific area is used to store the floatformat).
25534 But this is not a problem, because the gnat-specific information
25535 is actually not needed for these types. */
25536 if (need_gnat_info (cu
)
25537 && TYPE_CODE (type
) != TYPE_CODE_FUNC
25538 && TYPE_CODE (type
) != TYPE_CODE_FLT
25539 && TYPE_CODE (type
) != TYPE_CODE_METHODPTR
25540 && TYPE_CODE (type
) != TYPE_CODE_MEMBERPTR
25541 && TYPE_CODE (type
) != TYPE_CODE_METHOD
25542 && !HAVE_GNAT_AUX_INFO (type
))
25543 INIT_GNAT_SPECIFIC (type
);
25545 /* Read DW_AT_allocated and set in type. */
25546 attr
= dwarf2_attr (die
, DW_AT_allocated
, cu
);
25547 if (attr_form_is_block (attr
))
25549 struct type
*prop_type
25550 = dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
25551 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25552 add_dyn_prop (DYN_PROP_ALLOCATED
, prop
, type
);
25554 else if (attr
!= NULL
)
25556 complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25557 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
25558 sect_offset_str (die
->sect_off
));
25561 /* Read DW_AT_associated and set in type. */
25562 attr
= dwarf2_attr (die
, DW_AT_associated
, cu
);
25563 if (attr_form_is_block (attr
))
25565 struct type
*prop_type
25566 = dwarf2_per_cu_addr_sized_int_type (cu
->per_cu
, false);
25567 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
, prop_type
))
25568 add_dyn_prop (DYN_PROP_ASSOCIATED
, prop
, type
);
25570 else if (attr
!= NULL
)
25572 complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25573 (attr
!= NULL
? dwarf_form_name (attr
->form
) : "n/a"),
25574 sect_offset_str (die
->sect_off
));
25577 /* Read DW_AT_data_location and set in type. */
25578 attr
= dwarf2_attr (die
, DW_AT_data_location
, cu
);
25579 if (attr_to_dynamic_prop (attr
, die
, cu
, &prop
,
25580 dwarf2_per_cu_addr_type (cu
->per_cu
)))
25581 add_dyn_prop (DYN_PROP_DATA_LOCATION
, prop
, type
);
25583 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
25585 dwarf2_per_objfile
->die_type_hash
=
25586 htab_create_alloc_ex (127,
25587 per_cu_offset_and_type_hash
,
25588 per_cu_offset_and_type_eq
,
25590 &objfile
->objfile_obstack
,
25591 hashtab_obstack_allocate
,
25592 dummy_obstack_deallocate
);
25595 ofs
.per_cu
= cu
->per_cu
;
25596 ofs
.sect_off
= die
->sect_off
;
25598 slot
= (struct dwarf2_per_cu_offset_and_type
**)
25599 htab_find_slot (dwarf2_per_objfile
->die_type_hash
, &ofs
, INSERT
);
25601 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25602 sect_offset_str (die
->sect_off
));
25603 *slot
= XOBNEW (&objfile
->objfile_obstack
,
25604 struct dwarf2_per_cu_offset_and_type
);
25609 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25610 or return NULL if the die does not have a saved type. */
25612 static struct type
*
25613 get_die_type_at_offset (sect_offset sect_off
,
25614 struct dwarf2_per_cu_data
*per_cu
)
25616 struct dwarf2_per_cu_offset_and_type
*slot
, ofs
;
25617 struct dwarf2_per_objfile
*dwarf2_per_objfile
= per_cu
->dwarf2_per_objfile
;
25619 if (dwarf2_per_objfile
->die_type_hash
== NULL
)
25622 ofs
.per_cu
= per_cu
;
25623 ofs
.sect_off
= sect_off
;
25624 slot
= ((struct dwarf2_per_cu_offset_and_type
*)
25625 htab_find (dwarf2_per_objfile
->die_type_hash
, &ofs
));
25632 /* Look up the type for DIE in CU in die_type_hash,
25633 or return NULL if DIE does not have a saved type. */
25635 static struct type
*
25636 get_die_type (struct die_info
*die
, struct dwarf2_cu
*cu
)
25638 return get_die_type_at_offset (die
->sect_off
, cu
->per_cu
);
25641 /* Add a dependence relationship from CU to REF_PER_CU. */
25644 dwarf2_add_dependence (struct dwarf2_cu
*cu
,
25645 struct dwarf2_per_cu_data
*ref_per_cu
)
25649 if (cu
->dependencies
== NULL
)
25651 = htab_create_alloc_ex (5, htab_hash_pointer
, htab_eq_pointer
,
25652 NULL
, &cu
->comp_unit_obstack
,
25653 hashtab_obstack_allocate
,
25654 dummy_obstack_deallocate
);
25656 slot
= htab_find_slot (cu
->dependencies
, ref_per_cu
, INSERT
);
25658 *slot
= ref_per_cu
;
25661 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25662 Set the mark field in every compilation unit in the
25663 cache that we must keep because we are keeping CU. */
25666 dwarf2_mark_helper (void **slot
, void *data
)
25668 struct dwarf2_per_cu_data
*per_cu
;
25670 per_cu
= (struct dwarf2_per_cu_data
*) *slot
;
25672 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25673 reading of the chain. As such dependencies remain valid it is not much
25674 useful to track and undo them during QUIT cleanups. */
25675 if (per_cu
->cu
== NULL
)
25678 if (per_cu
->cu
->mark
)
25680 per_cu
->cu
->mark
= true;
25682 if (per_cu
->cu
->dependencies
!= NULL
)
25683 htab_traverse (per_cu
->cu
->dependencies
, dwarf2_mark_helper
, NULL
);
25688 /* Set the mark field in CU and in every other compilation unit in the
25689 cache that we must keep because we are keeping CU. */
25692 dwarf2_mark (struct dwarf2_cu
*cu
)
25697 if (cu
->dependencies
!= NULL
)
25698 htab_traverse (cu
->dependencies
, dwarf2_mark_helper
, NULL
);
25702 dwarf2_clear_marks (struct dwarf2_per_cu_data
*per_cu
)
25706 per_cu
->cu
->mark
= false;
25707 per_cu
= per_cu
->cu
->read_in_chain
;
25711 /* Trivial hash function for partial_die_info: the hash value of a DIE
25712 is its offset in .debug_info for this objfile. */
25715 partial_die_hash (const void *item
)
25717 const struct partial_die_info
*part_die
25718 = (const struct partial_die_info
*) item
;
25720 return to_underlying (part_die
->sect_off
);
25723 /* Trivial comparison function for partial_die_info structures: two DIEs
25724 are equal if they have the same offset. */
25727 partial_die_eq (const void *item_lhs
, const void *item_rhs
)
25729 const struct partial_die_info
*part_die_lhs
25730 = (const struct partial_die_info
*) item_lhs
;
25731 const struct partial_die_info
*part_die_rhs
25732 = (const struct partial_die_info
*) item_rhs
;
25734 return part_die_lhs
->sect_off
== part_die_rhs
->sect_off
;
25737 struct cmd_list_element
*set_dwarf_cmdlist
;
25738 struct cmd_list_element
*show_dwarf_cmdlist
;
25741 set_dwarf_cmd (const char *args
, int from_tty
)
25743 help_list (set_dwarf_cmdlist
, "maintenance set dwarf ", all_commands
,
25748 show_dwarf_cmd (const char *args
, int from_tty
)
25750 cmd_show_list (show_dwarf_cmdlist
, from_tty
, "");
25753 int dwarf_always_disassemble
;
25756 show_dwarf_always_disassemble (struct ui_file
*file
, int from_tty
,
25757 struct cmd_list_element
*c
, const char *value
)
25759 fprintf_filtered (file
,
25760 _("Whether to always disassemble "
25761 "DWARF expressions is %s.\n"),
25766 show_check_physname (struct ui_file
*file
, int from_tty
,
25767 struct cmd_list_element
*c
, const char *value
)
25769 fprintf_filtered (file
,
25770 _("Whether to check \"physname\" is %s.\n"),
25775 _initialize_dwarf2_read (void)
25777 add_prefix_cmd ("dwarf", class_maintenance
, set_dwarf_cmd
, _("\
25778 Set DWARF specific variables.\n\
25779 Configure DWARF variables such as the cache size"),
25780 &set_dwarf_cmdlist
, "maintenance set dwarf ",
25781 0/*allow-unknown*/, &maintenance_set_cmdlist
);
25783 add_prefix_cmd ("dwarf", class_maintenance
, show_dwarf_cmd
, _("\
25784 Show DWARF specific variables\n\
25785 Show DWARF variables such as the cache size"),
25786 &show_dwarf_cmdlist
, "maintenance show dwarf ",
25787 0/*allow-unknown*/, &maintenance_show_cmdlist
);
25789 add_setshow_zinteger_cmd ("max-cache-age", class_obscure
,
25790 &dwarf_max_cache_age
, _("\
25791 Set the upper bound on the age of cached DWARF compilation units."), _("\
25792 Show the upper bound on the age of cached DWARF compilation units."), _("\
25793 A higher limit means that cached compilation units will be stored\n\
25794 in memory longer, and more total memory will be used. Zero disables\n\
25795 caching, which can slow down startup."),
25797 show_dwarf_max_cache_age
,
25798 &set_dwarf_cmdlist
,
25799 &show_dwarf_cmdlist
);
25801 add_setshow_boolean_cmd ("always-disassemble", class_obscure
,
25802 &dwarf_always_disassemble
, _("\
25803 Set whether `info address' always disassembles DWARF expressions."), _("\
25804 Show whether `info address' always disassembles DWARF expressions."), _("\
25805 When enabled, DWARF expressions are always printed in an assembly-like\n\
25806 syntax. When disabled, expressions will be printed in a more\n\
25807 conversational style, when possible."),
25809 show_dwarf_always_disassemble
,
25810 &set_dwarf_cmdlist
,
25811 &show_dwarf_cmdlist
);
25813 add_setshow_zuinteger_cmd ("dwarf-read", no_class
, &dwarf_read_debug
, _("\
25814 Set debugging of the DWARF reader."), _("\
25815 Show debugging of the DWARF reader."), _("\
25816 When enabled (non-zero), debugging messages are printed during DWARF\n\
25817 reading and symtab expansion. A value of 1 (one) provides basic\n\
25818 information. A value greater than 1 provides more verbose information."),
25821 &setdebuglist
, &showdebuglist
);
25823 add_setshow_zuinteger_cmd ("dwarf-die", no_class
, &dwarf_die_debug
, _("\
25824 Set debugging of the DWARF DIE reader."), _("\
25825 Show debugging of the DWARF DIE reader."), _("\
25826 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25827 The value is the maximum depth to print."),
25830 &setdebuglist
, &showdebuglist
);
25832 add_setshow_zuinteger_cmd ("dwarf-line", no_class
, &dwarf_line_debug
, _("\
25833 Set debugging of the dwarf line reader."), _("\
25834 Show debugging of the dwarf line reader."), _("\
25835 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25836 A value of 1 (one) provides basic information.\n\
25837 A value greater than 1 provides more verbose information."),
25840 &setdebuglist
, &showdebuglist
);
25842 add_setshow_boolean_cmd ("check-physname", no_class
, &check_physname
, _("\
25843 Set cross-checking of \"physname\" code against demangler."), _("\
25844 Show cross-checking of \"physname\" code against demangler."), _("\
25845 When enabled, GDB's internal \"physname\" code is checked against\n\
25847 NULL
, show_check_physname
,
25848 &setdebuglist
, &showdebuglist
);
25850 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25851 no_class
, &use_deprecated_index_sections
, _("\
25852 Set whether to use deprecated gdb_index sections."), _("\
25853 Show whether to use deprecated gdb_index sections."), _("\
25854 When enabled, deprecated .gdb_index sections are used anyway.\n\
25855 Normally they are ignored either because of a missing feature or\n\
25856 performance issue.\n\
25857 Warning: This option must be enabled before gdb reads the file."),
25860 &setlist
, &showlist
);
25862 dwarf2_locexpr_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25863 &dwarf2_locexpr_funcs
);
25864 dwarf2_loclist_index
= register_symbol_computed_impl (LOC_COMPUTED
,
25865 &dwarf2_loclist_funcs
);
25867 dwarf2_locexpr_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25868 &dwarf2_block_frame_base_locexpr_funcs
);
25869 dwarf2_loclist_block_index
= register_symbol_block_impl (LOC_BLOCK
,
25870 &dwarf2_block_frame_base_loclist_funcs
);
25873 selftests::register_test ("dw2_expand_symtabs_matching",
25874 selftests::dw2_expand_symtabs_matching::run_test
);