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"
50 #include "dwarf2expr.h"
51 #include "dwarf2loc.h"
52 #include "cp-support.h"
58 #include "typeprint.h"
61 #include "completer.h"
66 #include "gdbcore.h" /* for gnutarget */
67 #include "gdb/gdb-index.h"
72 #include "filestuff.h"
74 #include "namespace.h"
75 #include "common/gdb_unlinker.h"
76 #include "common/function-view.h"
77 #include "common/gdb_optional.h"
78 #include "common/underlying.h"
79 #include "common/byte-vector.h"
80 #include "common/hash_enum.h"
81 #include "filename-seen-cache.h"
84 #include <sys/types.h>
86 #include <unordered_set>
87 #include <unordered_map>
91 #include <forward_list>
92 #include "rust-lang.h"
93 #include "common/pathstuff.h"
95 /* When == 1, print basic high level tracing messages.
96 When > 1, be more verbose.
97 This is in contrast to the low level DIE reading of dwarf_die_debug. */
98 static unsigned int dwarf_read_debug = 0;
100 /* When non-zero, dump DIEs after they are read in. */
101 static unsigned int dwarf_die_debug = 0;
103 /* When non-zero, dump line number entries as they are read in. */
104 static unsigned int dwarf_line_debug = 0;
106 /* When non-zero, cross-check physname against demangler. */
107 static int check_physname = 0;
109 /* When non-zero, do not reject deprecated .gdb_index sections. */
110 static int use_deprecated_index_sections = 0;
112 static const struct objfile_data *dwarf2_objfile_data_key;
114 /* The "aclass" indices for various kinds of computed DWARF symbols. */
116 static int dwarf2_locexpr_index;
117 static int dwarf2_loclist_index;
118 static int dwarf2_locexpr_block_index;
119 static int dwarf2_loclist_block_index;
121 /* An index into a (C++) symbol name component in a symbol name as
122 recorded in the mapped_index's symbol table. For each C++ symbol
123 in the symbol table, we record one entry for the start of each
124 component in the symbol in a table of name components, and then
125 sort the table, in order to be able to binary search symbol names,
126 ignoring leading namespaces, both completion and regular look up.
127 For example, for symbol "A::B::C", we'll have an entry that points
128 to "A::B::C", another that points to "B::C", and another for "C".
129 Note that function symbols in GDB index have no parameter
130 information, just the function/method names. You can convert a
131 name_component to a "const char *" using the
132 'mapped_index::symbol_name_at(offset_type)' method. */
134 struct name_component
136 /* Offset in the symbol name where the component starts. Stored as
137 a (32-bit) offset instead of a pointer to save memory and improve
138 locality on 64-bit architectures. */
139 offset_type name_offset;
141 /* The symbol's index in the symbol and constant pool tables of a
146 /* Base class containing bits shared by both .gdb_index and
147 .debug_name indexes. */
149 struct mapped_index_base
151 mapped_index_base () = default;
152 DISABLE_COPY_AND_ASSIGN (mapped_index_base);
154 /* The name_component table (a sorted vector). See name_component's
155 description above. */
156 std::vector<name_component> name_components;
158 /* How NAME_COMPONENTS is sorted. */
159 enum case_sensitivity name_components_casing;
161 /* Return the number of names in the symbol table. */
162 virtual size_t symbol_name_count () const = 0;
164 /* Get the name of the symbol at IDX in the symbol table. */
165 virtual const char *symbol_name_at (offset_type idx) const = 0;
167 /* Return whether the name at IDX in the symbol table should be
169 virtual bool symbol_name_slot_invalid (offset_type idx) const
174 /* Build the symbol name component sorted vector, if we haven't
176 void build_name_components ();
178 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
179 possible matches for LN_NO_PARAMS in the name component
181 std::pair<std::vector<name_component>::const_iterator,
182 std::vector<name_component>::const_iterator>
183 find_name_components_bounds (const lookup_name_info &ln_no_params) const;
185 /* Prevent deleting/destroying via a base class pointer. */
187 ~mapped_index_base() = default;
190 /* A description of the mapped index. The file format is described in
191 a comment by the code that writes the index. */
192 struct mapped_index final : public mapped_index_base
194 /* A slot/bucket in the symbol table hash. */
195 struct symbol_table_slot
197 const offset_type name;
198 const offset_type vec;
201 /* Index data format version. */
204 /* The address table data. */
205 gdb::array_view<const gdb_byte> address_table;
207 /* The symbol table, implemented as a hash table. */
208 gdb::array_view<symbol_table_slot> symbol_table;
210 /* A pointer to the constant pool. */
211 const char *constant_pool = nullptr;
213 bool symbol_name_slot_invalid (offset_type idx) const override
215 const auto &bucket = this->symbol_table[idx];
216 return bucket.name == 0 && bucket.vec;
219 /* Convenience method to get at the name of the symbol at IDX in the
221 const char *symbol_name_at (offset_type idx) const override
222 { return this->constant_pool + MAYBE_SWAP (this->symbol_table[idx].name); }
224 size_t symbol_name_count () const override
225 { return this->symbol_table.size (); }
228 /* A description of the mapped .debug_names.
229 Uninitialized map has CU_COUNT 0. */
230 struct mapped_debug_names final : public mapped_index_base
232 mapped_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile_)
233 : dwarf2_per_objfile (dwarf2_per_objfile_)
236 struct dwarf2_per_objfile *dwarf2_per_objfile;
237 bfd_endian dwarf5_byte_order;
238 bool dwarf5_is_dwarf64;
239 bool augmentation_is_gdb;
241 uint32_t cu_count = 0;
242 uint32_t tu_count, bucket_count, name_count;
243 const gdb_byte *cu_table_reordered, *tu_table_reordered;
244 const uint32_t *bucket_table_reordered, *hash_table_reordered;
245 const gdb_byte *name_table_string_offs_reordered;
246 const gdb_byte *name_table_entry_offs_reordered;
247 const gdb_byte *entry_pool;
254 /* Attribute name DW_IDX_*. */
257 /* Attribute form DW_FORM_*. */
260 /* Value if FORM is DW_FORM_implicit_const. */
261 LONGEST implicit_const;
263 std::vector<attr> attr_vec;
266 std::unordered_map<ULONGEST, index_val> abbrev_map;
268 const char *namei_to_name (uint32_t namei) const;
270 /* Implementation of the mapped_index_base virtual interface, for
271 the name_components cache. */
273 const char *symbol_name_at (offset_type idx) const override
274 { return namei_to_name (idx); }
276 size_t symbol_name_count () const override
277 { return this->name_count; }
280 /* See dwarf2read.h. */
283 get_dwarf2_per_objfile (struct objfile *objfile)
285 return ((struct dwarf2_per_objfile *)
286 objfile_data (objfile, dwarf2_objfile_data_key));
289 /* Set the dwarf2_per_objfile associated to OBJFILE. */
292 set_dwarf2_per_objfile (struct objfile *objfile,
293 struct dwarf2_per_objfile *dwarf2_per_objfile)
295 gdb_assert (get_dwarf2_per_objfile (objfile) == NULL);
296 set_objfile_data (objfile, dwarf2_objfile_data_key, dwarf2_per_objfile);
299 /* Default names of the debugging sections. */
301 /* Note that if the debugging section has been compressed, it might
302 have a name like .zdebug_info. */
304 static const struct dwarf2_debug_sections dwarf2_elf_names =
306 { ".debug_info", ".zdebug_info" },
307 { ".debug_abbrev", ".zdebug_abbrev" },
308 { ".debug_line", ".zdebug_line" },
309 { ".debug_loc", ".zdebug_loc" },
310 { ".debug_loclists", ".zdebug_loclists" },
311 { ".debug_macinfo", ".zdebug_macinfo" },
312 { ".debug_macro", ".zdebug_macro" },
313 { ".debug_str", ".zdebug_str" },
314 { ".debug_line_str", ".zdebug_line_str" },
315 { ".debug_ranges", ".zdebug_ranges" },
316 { ".debug_rnglists", ".zdebug_rnglists" },
317 { ".debug_types", ".zdebug_types" },
318 { ".debug_addr", ".zdebug_addr" },
319 { ".debug_frame", ".zdebug_frame" },
320 { ".eh_frame", NULL },
321 { ".gdb_index", ".zgdb_index" },
322 { ".debug_names", ".zdebug_names" },
323 { ".debug_aranges", ".zdebug_aranges" },
327 /* List of DWO/DWP sections. */
329 static const struct dwop_section_names
331 struct dwarf2_section_names abbrev_dwo;
332 struct dwarf2_section_names info_dwo;
333 struct dwarf2_section_names line_dwo;
334 struct dwarf2_section_names loc_dwo;
335 struct dwarf2_section_names loclists_dwo;
336 struct dwarf2_section_names macinfo_dwo;
337 struct dwarf2_section_names macro_dwo;
338 struct dwarf2_section_names str_dwo;
339 struct dwarf2_section_names str_offsets_dwo;
340 struct dwarf2_section_names types_dwo;
341 struct dwarf2_section_names cu_index;
342 struct dwarf2_section_names tu_index;
346 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
347 { ".debug_info.dwo", ".zdebug_info.dwo" },
348 { ".debug_line.dwo", ".zdebug_line.dwo" },
349 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
350 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
351 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
352 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
353 { ".debug_str.dwo", ".zdebug_str.dwo" },
354 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
355 { ".debug_types.dwo", ".zdebug_types.dwo" },
356 { ".debug_cu_index", ".zdebug_cu_index" },
357 { ".debug_tu_index", ".zdebug_tu_index" },
360 /* local data types */
362 /* The data in a compilation unit header, after target2host
363 translation, looks like this. */
364 struct comp_unit_head
368 unsigned char addr_size;
369 unsigned char signed_addr_p;
370 sect_offset abbrev_sect_off;
372 /* Size of file offsets; either 4 or 8. */
373 unsigned int offset_size;
375 /* Size of the length field; either 4 or 12. */
376 unsigned int initial_length_size;
378 enum dwarf_unit_type unit_type;
380 /* Offset to the first byte of this compilation unit header in the
381 .debug_info section, for resolving relative reference dies. */
382 sect_offset sect_off;
384 /* Offset to first die in this cu from the start of the cu.
385 This will be the first byte following the compilation unit header. */
386 cu_offset first_die_cu_offset;
388 /* 64-bit signature of this type unit - it is valid only for
389 UNIT_TYPE DW_UT_type. */
392 /* For types, offset in the type's DIE of the type defined by this TU. */
393 cu_offset type_cu_offset_in_tu;
396 /* Type used for delaying computation of method physnames.
397 See comments for compute_delayed_physnames. */
398 struct delayed_method_info
400 /* The type to which the method is attached, i.e., its parent class. */
403 /* The index of the method in the type's function fieldlists. */
406 /* The index of the method in the fieldlist. */
409 /* The name of the DIE. */
412 /* The DIE associated with this method. */
413 struct die_info *die;
416 /* Internal state when decoding a particular compilation unit. */
419 explicit dwarf2_cu (struct dwarf2_per_cu_data *per_cu);
422 DISABLE_COPY_AND_ASSIGN (dwarf2_cu);
424 /* The header of the compilation unit. */
425 struct comp_unit_head header {};
427 /* Base address of this compilation unit. */
428 CORE_ADDR base_address = 0;
430 /* Non-zero if base_address has been set. */
433 /* The language we are debugging. */
434 enum language language = language_unknown;
435 const struct language_defn *language_defn = nullptr;
437 const char *producer = nullptr;
439 /* The symtab builder for this CU. This is only non-NULL when full
440 symbols are being read. */
441 std::unique_ptr<buildsym_compunit> builder;
443 /* The generic symbol table building routines have separate lists for
444 file scope symbols and all all other scopes (local scopes). So
445 we need to select the right one to pass to add_symbol_to_list().
446 We do it by keeping a pointer to the correct list in list_in_scope.
448 FIXME: The original dwarf code just treated the file scope as the
449 first local scope, and all other local scopes as nested local
450 scopes, and worked fine. Check to see if we really need to
451 distinguish these in buildsym.c. */
452 struct pending **list_in_scope = nullptr;
454 /* Hash table holding all the loaded partial DIEs
455 with partial_die->offset.SECT_OFF as hash. */
456 htab_t partial_dies = nullptr;
458 /* Storage for things with the same lifetime as this read-in compilation
459 unit, including partial DIEs. */
460 auto_obstack comp_unit_obstack;
462 /* When multiple dwarf2_cu structures are living in memory, this field
463 chains them all together, so that they can be released efficiently.
464 We will probably also want a generation counter so that most-recently-used
465 compilation units are cached... */
466 struct dwarf2_per_cu_data *read_in_chain = nullptr;
468 /* Backlink to our per_cu entry. */
469 struct dwarf2_per_cu_data *per_cu;
471 /* How many compilation units ago was this CU last referenced? */
474 /* A hash table of DIE cu_offset for following references with
475 die_info->offset.sect_off as hash. */
476 htab_t die_hash = nullptr;
478 /* Full DIEs if read in. */
479 struct die_info *dies = nullptr;
481 /* A set of pointers to dwarf2_per_cu_data objects for compilation
482 units referenced by this one. Only set during full symbol processing;
483 partial symbol tables do not have dependencies. */
484 htab_t dependencies = nullptr;
486 /* Header data from the line table, during full symbol processing. */
487 struct line_header *line_header = nullptr;
488 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
489 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
490 this is the DW_TAG_compile_unit die for this CU. We'll hold on
491 to the line header as long as this DIE is being processed. See
492 process_die_scope. */
493 die_info *line_header_die_owner = nullptr;
495 /* A list of methods which need to have physnames computed
496 after all type information has been read. */
497 std::vector<delayed_method_info> method_list;
499 /* To be copied to symtab->call_site_htab. */
500 htab_t call_site_htab = nullptr;
502 /* Non-NULL if this CU came from a DWO file.
503 There is an invariant here that is important to remember:
504 Except for attributes copied from the top level DIE in the "main"
505 (or "stub") file in preparation for reading the DWO file
506 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
507 Either there isn't a DWO file (in which case this is NULL and the point
508 is moot), or there is and either we're not going to read it (in which
509 case this is NULL) or there is and we are reading it (in which case this
511 struct dwo_unit *dwo_unit = nullptr;
513 /* The DW_AT_addr_base attribute if present, zero otherwise
514 (zero is a valid value though).
515 Note this value comes from the Fission stub CU/TU's DIE. */
516 ULONGEST addr_base = 0;
518 /* The DW_AT_ranges_base attribute if present, zero otherwise
519 (zero is a valid value though).
520 Note this value comes from the Fission stub CU/TU's DIE.
521 Also note that the value is zero in the non-DWO case so this value can
522 be used without needing to know whether DWO files are in use or not.
523 N.B. This does not apply to DW_AT_ranges appearing in
524 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
525 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
526 DW_AT_ranges_base *would* have to be applied, and we'd have to care
527 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
528 ULONGEST ranges_base = 0;
530 /* When reading debug info generated by older versions of rustc, we
531 have to rewrite some union types to be struct types with a
532 variant part. This rewriting must be done after the CU is fully
533 read in, because otherwise at the point of rewriting some struct
534 type might not have been fully processed. So, we keep a list of
535 all such types here and process them after expansion. */
536 std::vector<struct type *> rust_unions;
538 /* Mark used when releasing cached dies. */
541 /* This CU references .debug_loc. See the symtab->locations_valid field.
542 This test is imperfect as there may exist optimized debug code not using
543 any location list and still facing inlining issues if handled as
544 unoptimized code. For a future better test see GCC PR other/32998. */
545 bool has_loclist : 1;
547 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is true
548 if all the producer_is_* fields are valid. This information is cached
549 because profiling CU expansion showed excessive time spent in
550 producer_is_gxx_lt_4_6. */
551 bool checked_producer : 1;
552 bool producer_is_gxx_lt_4_6 : 1;
553 bool producer_is_gcc_lt_4_3 : 1;
554 bool producer_is_icc : 1;
555 bool producer_is_icc_lt_14 : 1;
556 bool producer_is_codewarrior : 1;
558 /* When true, the file that we're processing is known to have
559 debugging info for C++ namespaces. GCC 3.3.x did not produce
560 this information, but later versions do. */
562 bool processing_has_namespace_info : 1;
564 struct partial_die_info *find_partial_die (sect_offset sect_off);
567 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
568 This includes type_unit_group and quick_file_names. */
570 struct stmt_list_hash
572 /* The DWO unit this table is from or NULL if there is none. */
573 struct dwo_unit *dwo_unit;
575 /* Offset in .debug_line or .debug_line.dwo. */
576 sect_offset line_sect_off;
579 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
580 an object of this type. */
582 struct type_unit_group
584 /* dwarf2read.c's main "handle" on a TU symtab.
585 To simplify things we create an artificial CU that "includes" all the
586 type units using this stmt_list so that the rest of the code still has
587 a "per_cu" handle on the symtab.
588 This PER_CU is recognized by having no section. */
589 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
590 struct dwarf2_per_cu_data per_cu;
592 /* The TUs that share this DW_AT_stmt_list entry.
593 This is added to while parsing type units to build partial symtabs,
594 and is deleted afterwards and not used again. */
595 VEC (sig_type_ptr) *tus;
597 /* The compunit symtab.
598 Type units in a group needn't all be defined in the same source file,
599 so we create an essentially anonymous symtab as the compunit symtab. */
600 struct compunit_symtab *compunit_symtab;
602 /* The data used to construct the hash key. */
603 struct stmt_list_hash hash;
605 /* The number of symtabs from the line header.
606 The value here must match line_header.num_file_names. */
607 unsigned int num_symtabs;
609 /* The symbol tables for this TU (obtained from the files listed in
611 WARNING: The order of entries here must match the order of entries
612 in the line header. After the first TU using this type_unit_group, the
613 line header for the subsequent TUs is recreated from this. This is done
614 because we need to use the same symtabs for each TU using the same
615 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
616 there's no guarantee the line header doesn't have duplicate entries. */
617 struct symtab **symtabs;
620 /* These sections are what may appear in a (real or virtual) DWO file. */
624 struct dwarf2_section_info abbrev;
625 struct dwarf2_section_info line;
626 struct dwarf2_section_info loc;
627 struct dwarf2_section_info loclists;
628 struct dwarf2_section_info macinfo;
629 struct dwarf2_section_info macro;
630 struct dwarf2_section_info str;
631 struct dwarf2_section_info str_offsets;
632 /* In the case of a virtual DWO file, these two are unused. */
633 struct dwarf2_section_info info;
634 VEC (dwarf2_section_info_def) *types;
637 /* CUs/TUs in DWP/DWO files. */
641 /* Backlink to the containing struct dwo_file. */
642 struct dwo_file *dwo_file;
644 /* The "id" that distinguishes this CU/TU.
645 .debug_info calls this "dwo_id", .debug_types calls this "signature".
646 Since signatures came first, we stick with it for consistency. */
649 /* The section this CU/TU lives in, in the DWO file. */
650 struct dwarf2_section_info *section;
652 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
653 sect_offset sect_off;
656 /* For types, offset in the type's DIE of the type defined by this TU. */
657 cu_offset type_offset_in_tu;
660 /* include/dwarf2.h defines the DWP section codes.
661 It defines a max value but it doesn't define a min value, which we
662 use for error checking, so provide one. */
664 enum dwp_v2_section_ids
669 /* Data for one DWO file.
671 This includes virtual DWO files (a virtual DWO file is a DWO file as it
672 appears in a DWP file). DWP files don't really have DWO files per se -
673 comdat folding of types "loses" the DWO file they came from, and from
674 a high level view DWP files appear to contain a mass of random types.
675 However, to maintain consistency with the non-DWP case we pretend DWP
676 files contain virtual DWO files, and we assign each TU with one virtual
677 DWO file (generally based on the line and abbrev section offsets -
678 a heuristic that seems to work in practice). */
682 /* The DW_AT_GNU_dwo_name attribute.
683 For virtual DWO files the name is constructed from the section offsets
684 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
685 from related CU+TUs. */
686 const char *dwo_name;
688 /* The DW_AT_comp_dir attribute. */
689 const char *comp_dir;
691 /* The bfd, when the file is open. Otherwise this is NULL.
692 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
695 /* The sections that make up this DWO file.
696 Remember that for virtual DWO files in DWP V2, these are virtual
697 sections (for lack of a better name). */
698 struct dwo_sections sections;
700 /* The CUs in the file.
701 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
702 an extension to handle LLVM's Link Time Optimization output (where
703 multiple source files may be compiled into a single object/dwo pair). */
706 /* Table of TUs in the file.
707 Each element is a struct dwo_unit. */
711 /* These sections are what may appear in a DWP file. */
715 /* These are used by both DWP version 1 and 2. */
716 struct dwarf2_section_info str;
717 struct dwarf2_section_info cu_index;
718 struct dwarf2_section_info tu_index;
720 /* These are only used by DWP version 2 files.
721 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
722 sections are referenced by section number, and are not recorded here.
723 In DWP version 2 there is at most one copy of all these sections, each
724 section being (effectively) comprised of the concatenation of all of the
725 individual sections that exist in the version 1 format.
726 To keep the code simple we treat each of these concatenated pieces as a
727 section itself (a virtual section?). */
728 struct dwarf2_section_info abbrev;
729 struct dwarf2_section_info info;
730 struct dwarf2_section_info line;
731 struct dwarf2_section_info loc;
732 struct dwarf2_section_info macinfo;
733 struct dwarf2_section_info macro;
734 struct dwarf2_section_info str_offsets;
735 struct dwarf2_section_info types;
738 /* These sections are what may appear in a virtual DWO file in DWP version 1.
739 A virtual DWO file is a DWO file as it appears in a DWP file. */
741 struct virtual_v1_dwo_sections
743 struct dwarf2_section_info abbrev;
744 struct dwarf2_section_info line;
745 struct dwarf2_section_info loc;
746 struct dwarf2_section_info macinfo;
747 struct dwarf2_section_info macro;
748 struct dwarf2_section_info str_offsets;
749 /* Each DWP hash table entry records one CU or one TU.
750 That is recorded here, and copied to dwo_unit.section. */
751 struct dwarf2_section_info info_or_types;
754 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
755 In version 2, the sections of the DWO files are concatenated together
756 and stored in one section of that name. Thus each ELF section contains
757 several "virtual" sections. */
759 struct virtual_v2_dwo_sections
761 bfd_size_type abbrev_offset;
762 bfd_size_type abbrev_size;
764 bfd_size_type line_offset;
765 bfd_size_type line_size;
767 bfd_size_type loc_offset;
768 bfd_size_type loc_size;
770 bfd_size_type macinfo_offset;
771 bfd_size_type macinfo_size;
773 bfd_size_type macro_offset;
774 bfd_size_type macro_size;
776 bfd_size_type str_offsets_offset;
777 bfd_size_type str_offsets_size;
779 /* Each DWP hash table entry records one CU or one TU.
780 That is recorded here, and copied to dwo_unit.section. */
781 bfd_size_type info_or_types_offset;
782 bfd_size_type info_or_types_size;
785 /* Contents of DWP hash tables. */
787 struct dwp_hash_table
789 uint32_t version, nr_columns;
790 uint32_t nr_units, nr_slots;
791 const gdb_byte *hash_table, *unit_table;
796 const gdb_byte *indices;
800 /* This is indexed by column number and gives the id of the section
802 #define MAX_NR_V2_DWO_SECTIONS \
803 (1 /* .debug_info or .debug_types */ \
804 + 1 /* .debug_abbrev */ \
805 + 1 /* .debug_line */ \
806 + 1 /* .debug_loc */ \
807 + 1 /* .debug_str_offsets */ \
808 + 1 /* .debug_macro or .debug_macinfo */)
809 int section_ids[MAX_NR_V2_DWO_SECTIONS];
810 const gdb_byte *offsets;
811 const gdb_byte *sizes;
816 /* Data for one DWP file. */
820 dwp_file (const char *name_, gdb_bfd_ref_ptr &&abfd)
822 dbfd (std::move (abfd))
826 /* Name of the file. */
829 /* File format version. */
833 gdb_bfd_ref_ptr dbfd;
835 /* Section info for this file. */
836 struct dwp_sections sections {};
838 /* Table of CUs in the file. */
839 const struct dwp_hash_table *cus = nullptr;
841 /* Table of TUs in the file. */
842 const struct dwp_hash_table *tus = nullptr;
844 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
845 htab_t loaded_cus {};
846 htab_t loaded_tus {};
848 /* Table to map ELF section numbers to their sections.
849 This is only needed for the DWP V1 file format. */
850 unsigned int num_sections = 0;
851 asection **elf_sections = nullptr;
854 /* This represents a '.dwz' file. */
858 dwz_file (gdb_bfd_ref_ptr &&bfd)
859 : dwz_bfd (std::move (bfd))
863 /* A dwz file can only contain a few sections. */
864 struct dwarf2_section_info abbrev {};
865 struct dwarf2_section_info info {};
866 struct dwarf2_section_info str {};
867 struct dwarf2_section_info line {};
868 struct dwarf2_section_info macro {};
869 struct dwarf2_section_info gdb_index {};
870 struct dwarf2_section_info debug_names {};
873 gdb_bfd_ref_ptr dwz_bfd;
875 /* If we loaded the index from an external file, this contains the
876 resources associated to the open file, memory mapping, etc. */
877 std::unique_ptr<index_cache_resource> index_cache_res;
880 /* Struct used to pass misc. parameters to read_die_and_children, et
881 al. which are used for both .debug_info and .debug_types dies.
882 All parameters here are unchanging for the life of the call. This
883 struct exists to abstract away the constant parameters of die reading. */
885 struct die_reader_specs
887 /* The bfd of die_section. */
890 /* The CU of the DIE we are parsing. */
891 struct dwarf2_cu *cu;
893 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
894 struct dwo_file *dwo_file;
896 /* The section the die comes from.
897 This is either .debug_info or .debug_types, or the .dwo variants. */
898 struct dwarf2_section_info *die_section;
900 /* die_section->buffer. */
901 const gdb_byte *buffer;
903 /* The end of the buffer. */
904 const gdb_byte *buffer_end;
906 /* The value of the DW_AT_comp_dir attribute. */
907 const char *comp_dir;
909 /* The abbreviation table to use when reading the DIEs. */
910 struct abbrev_table *abbrev_table;
913 /* Type of function passed to init_cutu_and_read_dies, et.al. */
914 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
915 const gdb_byte *info_ptr,
916 struct die_info *comp_unit_die,
920 /* A 1-based directory index. This is a strong typedef to prevent
921 accidentally using a directory index as a 0-based index into an
923 enum class dir_index : unsigned int {};
925 /* Likewise, a 1-based file name index. */
926 enum class file_name_index : unsigned int {};
930 file_entry () = default;
932 file_entry (const char *name_, dir_index d_index_,
933 unsigned int mod_time_, unsigned int length_)
936 mod_time (mod_time_),
940 /* Return the include directory at D_INDEX stored in LH. Returns
941 NULL if D_INDEX is out of bounds. */
942 const char *include_dir (const line_header *lh) const;
944 /* The file name. Note this is an observing pointer. The memory is
945 owned by debug_line_buffer. */
948 /* The directory index (1-based). */
949 dir_index d_index {};
951 unsigned int mod_time {};
953 unsigned int length {};
955 /* True if referenced by the Line Number Program. */
958 /* The associated symbol table, if any. */
959 struct symtab *symtab {};
962 /* The line number information for a compilation unit (found in the
963 .debug_line section) begins with a "statement program header",
964 which contains the following information. */
971 /* Add an entry to the include directory table. */
972 void add_include_dir (const char *include_dir);
974 /* Add an entry to the file name table. */
975 void add_file_name (const char *name, dir_index d_index,
976 unsigned int mod_time, unsigned int length);
978 /* Return the include dir at INDEX (1-based). Returns NULL if INDEX
980 const char *include_dir_at (dir_index index) const
982 /* Convert directory index number (1-based) to vector index
984 size_t vec_index = to_underlying (index) - 1;
986 if (vec_index >= include_dirs.size ())
988 return include_dirs[vec_index];
991 /* Return the file name at INDEX (1-based). Returns NULL if INDEX
993 file_entry *file_name_at (file_name_index index)
995 /* Convert file name index number (1-based) to vector index
997 size_t vec_index = to_underlying (index) - 1;
999 if (vec_index >= file_names.size ())
1001 return &file_names[vec_index];
1004 /* Const version of the above. */
1005 const file_entry *file_name_at (unsigned int index) const
1007 if (index >= file_names.size ())
1009 return &file_names[index];
1012 /* Offset of line number information in .debug_line section. */
1013 sect_offset sect_off {};
1015 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1016 unsigned offset_in_dwz : 1; /* Can't initialize bitfields in-class. */
1018 unsigned int total_length {};
1019 unsigned short version {};
1020 unsigned int header_length {};
1021 unsigned char minimum_instruction_length {};
1022 unsigned char maximum_ops_per_instruction {};
1023 unsigned char default_is_stmt {};
1025 unsigned char line_range {};
1026 unsigned char opcode_base {};
1028 /* standard_opcode_lengths[i] is the number of operands for the
1029 standard opcode whose value is i. This means that
1030 standard_opcode_lengths[0] is unused, and the last meaningful
1031 element is standard_opcode_lengths[opcode_base - 1]. */
1032 std::unique_ptr<unsigned char[]> standard_opcode_lengths;
1034 /* The include_directories table. Note these are observing
1035 pointers. The memory is owned by debug_line_buffer. */
1036 std::vector<const char *> include_dirs;
1038 /* The file_names table. */
1039 std::vector<file_entry> file_names;
1041 /* The start and end of the statement program following this
1042 header. These point into dwarf2_per_objfile->line_buffer. */
1043 const gdb_byte *statement_program_start {}, *statement_program_end {};
1046 typedef std::unique_ptr<line_header> line_header_up;
1049 file_entry::include_dir (const line_header *lh) const
1051 return lh->include_dir_at (d_index);
1054 /* When we construct a partial symbol table entry we only
1055 need this much information. */
1056 struct partial_die_info : public allocate_on_obstack
1058 partial_die_info (sect_offset sect_off, struct abbrev_info *abbrev);
1060 /* Disable assign but still keep copy ctor, which is needed
1061 load_partial_dies. */
1062 partial_die_info& operator=(const partial_die_info& rhs) = delete;
1064 /* Adjust the partial die before generating a symbol for it. This
1065 function may set the is_external flag or change the DIE's
1067 void fixup (struct dwarf2_cu *cu);
1069 /* Read a minimal amount of information into the minimal die
1071 const gdb_byte *read (const struct die_reader_specs *reader,
1072 const struct abbrev_info &abbrev,
1073 const gdb_byte *info_ptr);
1075 /* Offset of this DIE. */
1076 const sect_offset sect_off;
1078 /* DWARF-2 tag for this DIE. */
1079 const ENUM_BITFIELD(dwarf_tag) tag : 16;
1081 /* Assorted flags describing the data found in this DIE. */
1082 const unsigned int has_children : 1;
1084 unsigned int is_external : 1;
1085 unsigned int is_declaration : 1;
1086 unsigned int has_type : 1;
1087 unsigned int has_specification : 1;
1088 unsigned int has_pc_info : 1;
1089 unsigned int may_be_inlined : 1;
1091 /* This DIE has been marked DW_AT_main_subprogram. */
1092 unsigned int main_subprogram : 1;
1094 /* Flag set if the SCOPE field of this structure has been
1096 unsigned int scope_set : 1;
1098 /* Flag set if the DIE has a byte_size attribute. */
1099 unsigned int has_byte_size : 1;
1101 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1102 unsigned int has_const_value : 1;
1104 /* Flag set if any of the DIE's children are template arguments. */
1105 unsigned int has_template_arguments : 1;
1107 /* Flag set if fixup has been called on this die. */
1108 unsigned int fixup_called : 1;
1110 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1111 unsigned int is_dwz : 1;
1113 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1114 unsigned int spec_is_dwz : 1;
1116 /* The name of this DIE. Normally the value of DW_AT_name, but
1117 sometimes a default name for unnamed DIEs. */
1118 const char *name = nullptr;
1120 /* The linkage name, if present. */
1121 const char *linkage_name = nullptr;
1123 /* The scope to prepend to our children. This is generally
1124 allocated on the comp_unit_obstack, so will disappear
1125 when this compilation unit leaves the cache. */
1126 const char *scope = nullptr;
1128 /* Some data associated with the partial DIE. The tag determines
1129 which field is live. */
1132 /* The location description associated with this DIE, if any. */
1133 struct dwarf_block *locdesc;
1134 /* The offset of an import, for DW_TAG_imported_unit. */
1135 sect_offset sect_off;
1138 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1139 CORE_ADDR lowpc = 0;
1140 CORE_ADDR highpc = 0;
1142 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1143 DW_AT_sibling, if any. */
1144 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1145 could return DW_AT_sibling values to its caller load_partial_dies. */
1146 const gdb_byte *sibling = nullptr;
1148 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1149 DW_AT_specification (or DW_AT_abstract_origin or
1150 DW_AT_extension). */
1151 sect_offset spec_offset {};
1153 /* Pointers to this DIE's parent, first child, and next sibling,
1155 struct partial_die_info *die_parent = nullptr;
1156 struct partial_die_info *die_child = nullptr;
1157 struct partial_die_info *die_sibling = nullptr;
1159 friend struct partial_die_info *
1160 dwarf2_cu::find_partial_die (sect_offset sect_off);
1163 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1164 partial_die_info (sect_offset sect_off)
1165 : partial_die_info (sect_off, DW_TAG_padding, 0)
1169 partial_die_info (sect_offset sect_off_, enum dwarf_tag tag_,
1171 : sect_off (sect_off_), tag (tag_), has_children (has_children_)
1176 has_specification = 0;
1179 main_subprogram = 0;
1182 has_const_value = 0;
1183 has_template_arguments = 0;
1190 /* This data structure holds the information of an abbrev. */
1193 unsigned int number; /* number identifying abbrev */
1194 enum dwarf_tag tag; /* dwarf tag */
1195 unsigned short has_children; /* boolean */
1196 unsigned short num_attrs; /* number of attributes */
1197 struct attr_abbrev *attrs; /* an array of attribute descriptions */
1198 struct abbrev_info *next; /* next in chain */
1203 ENUM_BITFIELD(dwarf_attribute) name : 16;
1204 ENUM_BITFIELD(dwarf_form) form : 16;
1206 /* It is valid only if FORM is DW_FORM_implicit_const. */
1207 LONGEST implicit_const;
1210 /* Size of abbrev_table.abbrev_hash_table. */
1211 #define ABBREV_HASH_SIZE 121
1213 /* Top level data structure to contain an abbreviation table. */
1217 explicit abbrev_table (sect_offset off)
1221 XOBNEWVEC (&abbrev_obstack, struct abbrev_info *, ABBREV_HASH_SIZE);
1222 memset (m_abbrevs, 0, ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
1225 DISABLE_COPY_AND_ASSIGN (abbrev_table);
1227 /* Allocate space for a struct abbrev_info object in
1229 struct abbrev_info *alloc_abbrev ();
1231 /* Add an abbreviation to the table. */
1232 void add_abbrev (unsigned int abbrev_number, struct abbrev_info *abbrev);
1234 /* Look up an abbrev in the table.
1235 Returns NULL if the abbrev is not found. */
1237 struct abbrev_info *lookup_abbrev (unsigned int abbrev_number);
1240 /* Where the abbrev table came from.
1241 This is used as a sanity check when the table is used. */
1242 const sect_offset sect_off;
1244 /* Storage for the abbrev table. */
1245 auto_obstack abbrev_obstack;
1249 /* Hash table of abbrevs.
1250 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1251 It could be statically allocated, but the previous code didn't so we
1253 struct abbrev_info **m_abbrevs;
1256 typedef std::unique_ptr<struct abbrev_table> abbrev_table_up;
1258 /* Attributes have a name and a value. */
1261 ENUM_BITFIELD(dwarf_attribute) name : 16;
1262 ENUM_BITFIELD(dwarf_form) form : 15;
1264 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1265 field should be in u.str (existing only for DW_STRING) but it is kept
1266 here for better struct attribute alignment. */
1267 unsigned int string_is_canonical : 1;
1272 struct dwarf_block *blk;
1281 /* This data structure holds a complete die structure. */
1284 /* DWARF-2 tag for this DIE. */
1285 ENUM_BITFIELD(dwarf_tag) tag : 16;
1287 /* Number of attributes */
1288 unsigned char num_attrs;
1290 /* True if we're presently building the full type name for the
1291 type derived from this DIE. */
1292 unsigned char building_fullname : 1;
1294 /* True if this die is in process. PR 16581. */
1295 unsigned char in_process : 1;
1298 unsigned int abbrev;
1300 /* Offset in .debug_info or .debug_types section. */
1301 sect_offset sect_off;
1303 /* The dies in a compilation unit form an n-ary tree. PARENT
1304 points to this die's parent; CHILD points to the first child of
1305 this node; and all the children of a given node are chained
1306 together via their SIBLING fields. */
1307 struct die_info *child; /* Its first child, if any. */
1308 struct die_info *sibling; /* Its next sibling, if any. */
1309 struct die_info *parent; /* Its parent, if any. */
1311 /* An array of attributes, with NUM_ATTRS elements. There may be
1312 zero, but it's not common and zero-sized arrays are not
1313 sufficiently portable C. */
1314 struct attribute attrs[1];
1317 /* Get at parts of an attribute structure. */
1319 #define DW_STRING(attr) ((attr)->u.str)
1320 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1321 #define DW_UNSND(attr) ((attr)->u.unsnd)
1322 #define DW_BLOCK(attr) ((attr)->u.blk)
1323 #define DW_SND(attr) ((attr)->u.snd)
1324 #define DW_ADDR(attr) ((attr)->u.addr)
1325 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1327 /* Blocks are a bunch of untyped bytes. */
1332 /* Valid only if SIZE is not zero. */
1333 const gdb_byte *data;
1336 #ifndef ATTR_ALLOC_CHUNK
1337 #define ATTR_ALLOC_CHUNK 4
1340 /* Allocate fields for structs, unions and enums in this size. */
1341 #ifndef DW_FIELD_ALLOC_CHUNK
1342 #define DW_FIELD_ALLOC_CHUNK 4
1345 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1346 but this would require a corresponding change in unpack_field_as_long
1348 static int bits_per_byte = 8;
1350 /* When reading a variant or variant part, we track a bit more
1351 information about the field, and store it in an object of this
1354 struct variant_field
1356 /* If we see a DW_TAG_variant, then this will be the discriminant
1358 ULONGEST discriminant_value;
1359 /* If we see a DW_TAG_variant, then this will be set if this is the
1361 bool default_branch;
1362 /* While reading a DW_TAG_variant_part, this will be set if this
1363 field is the discriminant. */
1364 bool is_discriminant;
1369 int accessibility = 0;
1371 /* Extra information to describe a variant or variant part. */
1372 struct variant_field variant {};
1373 struct field field {};
1378 const char *name = nullptr;
1379 std::vector<struct fn_field> fnfields;
1382 /* The routines that read and process dies for a C struct or C++ class
1383 pass lists of data member fields and lists of member function fields
1384 in an instance of a field_info structure, as defined below. */
1387 /* List of data member and baseclasses fields. */
1388 std::vector<struct nextfield> fields;
1389 std::vector<struct nextfield> baseclasses;
1391 /* Number of fields (including baseclasses). */
1394 /* Set if the accesibility of one of the fields is not public. */
1395 int non_public_fields = 0;
1397 /* Member function fieldlist array, contains name of possibly overloaded
1398 member function, number of overloaded member functions and a pointer
1399 to the head of the member function field chain. */
1400 std::vector<struct fnfieldlist> fnfieldlists;
1402 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1403 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1404 std::vector<struct decl_field> typedef_field_list;
1406 /* Nested types defined by this class and the number of elements in this
1408 std::vector<struct decl_field> nested_types_list;
1411 /* One item on the queue of compilation units to read in full symbols
1413 struct dwarf2_queue_item
1415 struct dwarf2_per_cu_data *per_cu;
1416 enum language pretend_language;
1417 struct dwarf2_queue_item *next;
1420 /* The current queue. */
1421 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1423 /* Loaded secondary compilation units are kept in memory until they
1424 have not been referenced for the processing of this many
1425 compilation units. Set this to zero to disable caching. Cache
1426 sizes of up to at least twenty will improve startup time for
1427 typical inter-CU-reference binaries, at an obvious memory cost. */
1428 static int dwarf_max_cache_age = 5;
1430 show_dwarf_max_cache_age (struct ui_file *file, int from_tty,
1431 struct cmd_list_element *c, const char *value)
1433 fprintf_filtered (file, _("The upper bound on the age of cached "
1434 "DWARF compilation units is %s.\n"),
1438 /* local function prototypes */
1440 static const char *get_section_name (const struct dwarf2_section_info *);
1442 static const char *get_section_file_name (const struct dwarf2_section_info *);
1444 static void dwarf2_find_base_address (struct die_info *die,
1445 struct dwarf2_cu *cu);
1447 static struct partial_symtab *create_partial_symtab
1448 (struct dwarf2_per_cu_data *per_cu, const char *name);
1450 static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
1451 const gdb_byte *info_ptr,
1452 struct die_info *type_unit_die,
1453 int has_children, void *data);
1455 static void dwarf2_build_psymtabs_hard
1456 (struct dwarf2_per_objfile *dwarf2_per_objfile);
1458 static void scan_partial_symbols (struct partial_die_info *,
1459 CORE_ADDR *, CORE_ADDR *,
1460 int, struct dwarf2_cu *);
1462 static void add_partial_symbol (struct partial_die_info *,
1463 struct dwarf2_cu *);
1465 static void add_partial_namespace (struct partial_die_info *pdi,
1466 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1467 int set_addrmap, struct dwarf2_cu *cu);
1469 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1470 CORE_ADDR *highpc, int set_addrmap,
1471 struct dwarf2_cu *cu);
1473 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1474 struct dwarf2_cu *cu);
1476 static void add_partial_subprogram (struct partial_die_info *pdi,
1477 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1478 int need_pc, struct dwarf2_cu *cu);
1480 static void dwarf2_read_symtab (struct partial_symtab *,
1483 static void psymtab_to_symtab_1 (struct partial_symtab *);
1485 static abbrev_table_up abbrev_table_read_table
1486 (struct dwarf2_per_objfile *dwarf2_per_objfile, struct dwarf2_section_info *,
1489 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1491 static struct partial_die_info *load_partial_dies
1492 (const struct die_reader_specs *, const gdb_byte *, int);
1494 static struct partial_die_info *find_partial_die (sect_offset, int,
1495 struct dwarf2_cu *);
1497 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1498 struct attribute *, struct attr_abbrev *,
1501 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1503 static int read_1_signed_byte (bfd *, const gdb_byte *);
1505 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1507 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1509 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1511 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1514 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1516 static LONGEST read_checked_initial_length_and_offset
1517 (bfd *, const gdb_byte *, const struct comp_unit_head *,
1518 unsigned int *, unsigned int *);
1520 static LONGEST read_offset (bfd *, const gdb_byte *,
1521 const struct comp_unit_head *,
1524 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1526 static sect_offset read_abbrev_offset
1527 (struct dwarf2_per_objfile *dwarf2_per_objfile,
1528 struct dwarf2_section_info *, sect_offset);
1530 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1532 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1534 static const char *read_indirect_string
1535 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1536 const struct comp_unit_head *, unsigned int *);
1538 static const char *read_indirect_line_string
1539 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1540 const struct comp_unit_head *, unsigned int *);
1542 static const char *read_indirect_string_at_offset
1543 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
1544 LONGEST str_offset);
1546 static const char *read_indirect_string_from_dwz
1547 (struct objfile *objfile, struct dwz_file *, LONGEST);
1549 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1551 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1555 static const char *read_str_index (const struct die_reader_specs *reader,
1556 ULONGEST str_index);
1558 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1560 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1561 struct dwarf2_cu *);
1563 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1566 static const char *dwarf2_string_attr (struct die_info *die, unsigned int name,
1567 struct dwarf2_cu *cu);
1569 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1570 struct dwarf2_cu *cu);
1572 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1574 static struct die_info *die_specification (struct die_info *die,
1575 struct dwarf2_cu **);
1577 static line_header_up dwarf_decode_line_header (sect_offset sect_off,
1578 struct dwarf2_cu *cu);
1580 static void dwarf_decode_lines (struct line_header *, const char *,
1581 struct dwarf2_cu *, struct partial_symtab *,
1582 CORE_ADDR, int decode_mapping);
1584 static void dwarf2_start_subfile (struct dwarf2_cu *, const char *,
1587 static struct compunit_symtab *dwarf2_start_symtab (struct dwarf2_cu *,
1588 const char *, const char *,
1591 static struct symbol *new_symbol (struct die_info *, struct type *,
1592 struct dwarf2_cu *, struct symbol * = NULL);
1594 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1595 struct dwarf2_cu *);
1597 static void dwarf2_const_value_attr (const struct attribute *attr,
1600 struct obstack *obstack,
1601 struct dwarf2_cu *cu, LONGEST *value,
1602 const gdb_byte **bytes,
1603 struct dwarf2_locexpr_baton **baton);
1605 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1607 static int need_gnat_info (struct dwarf2_cu *);
1609 static struct type *die_descriptive_type (struct die_info *,
1610 struct dwarf2_cu *);
1612 static void set_descriptive_type (struct type *, struct die_info *,
1613 struct dwarf2_cu *);
1615 static struct type *die_containing_type (struct die_info *,
1616 struct dwarf2_cu *);
1618 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1619 struct dwarf2_cu *);
1621 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1623 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1625 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1627 static char *typename_concat (struct obstack *obs, const char *prefix,
1628 const char *suffix, int physname,
1629 struct dwarf2_cu *cu);
1631 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1633 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1635 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1637 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1639 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1641 static void read_variable (struct die_info *die, struct dwarf2_cu *cu);
1643 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1644 struct dwarf2_cu *, struct partial_symtab *);
1646 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1647 values. Keep the items ordered with increasing constraints compliance. */
1650 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1651 PC_BOUNDS_NOT_PRESENT,
1653 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1654 were present but they do not form a valid range of PC addresses. */
1657 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1660 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1664 static enum pc_bounds_kind dwarf2_get_pc_bounds (struct die_info *,
1665 CORE_ADDR *, CORE_ADDR *,
1667 struct partial_symtab *);
1669 static void get_scope_pc_bounds (struct die_info *,
1670 CORE_ADDR *, CORE_ADDR *,
1671 struct dwarf2_cu *);
1673 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1674 CORE_ADDR, struct dwarf2_cu *);
1676 static void dwarf2_add_field (struct field_info *, struct die_info *,
1677 struct dwarf2_cu *);
1679 static void dwarf2_attach_fields_to_type (struct field_info *,
1680 struct type *, struct dwarf2_cu *);
1682 static void dwarf2_add_member_fn (struct field_info *,
1683 struct die_info *, struct type *,
1684 struct dwarf2_cu *);
1686 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1688 struct dwarf2_cu *);
1690 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1692 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1694 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1696 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1698 static struct using_direct **using_directives (struct dwarf2_cu *cu);
1700 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1702 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1704 static struct type *read_module_type (struct die_info *die,
1705 struct dwarf2_cu *cu);
1707 static const char *namespace_name (struct die_info *die,
1708 int *is_anonymous, struct dwarf2_cu *);
1710 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1712 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1714 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1715 struct dwarf2_cu *);
1717 static struct die_info *read_die_and_siblings_1
1718 (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1721 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1722 const gdb_byte *info_ptr,
1723 const gdb_byte **new_info_ptr,
1724 struct die_info *parent);
1726 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1727 struct die_info **, const gdb_byte *,
1730 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1731 struct die_info **, const gdb_byte *,
1734 static void process_die (struct die_info *, struct dwarf2_cu *);
1736 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1739 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1741 static const char *dwarf2_full_name (const char *name,
1742 struct die_info *die,
1743 struct dwarf2_cu *cu);
1745 static const char *dwarf2_physname (const char *name, struct die_info *die,
1746 struct dwarf2_cu *cu);
1748 static struct die_info *dwarf2_extension (struct die_info *die,
1749 struct dwarf2_cu **);
1751 static const char *dwarf_tag_name (unsigned int);
1753 static const char *dwarf_attr_name (unsigned int);
1755 static const char *dwarf_form_name (unsigned int);
1757 static const char *dwarf_bool_name (unsigned int);
1759 static const char *dwarf_type_encoding_name (unsigned int);
1761 static struct die_info *sibling_die (struct die_info *);
1763 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1765 static void dump_die_for_error (struct die_info *);
1767 static void dump_die_1 (struct ui_file *, int level, int max_level,
1770 /*static*/ void dump_die (struct die_info *, int max_level);
1772 static void store_in_ref_table (struct die_info *,
1773 struct dwarf2_cu *);
1775 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1777 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1779 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1780 const struct attribute *,
1781 struct dwarf2_cu **);
1783 static struct die_info *follow_die_ref (struct die_info *,
1784 const struct attribute *,
1785 struct dwarf2_cu **);
1787 static struct die_info *follow_die_sig (struct die_info *,
1788 const struct attribute *,
1789 struct dwarf2_cu **);
1791 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1792 struct dwarf2_cu *);
1794 static struct type *get_DW_AT_signature_type (struct die_info *,
1795 const struct attribute *,
1796 struct dwarf2_cu *);
1798 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1800 static void read_signatured_type (struct signatured_type *);
1802 static int attr_to_dynamic_prop (const struct attribute *attr,
1803 struct die_info *die, struct dwarf2_cu *cu,
1804 struct dynamic_prop *prop);
1806 /* memory allocation interface */
1808 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1810 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1812 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int, int);
1814 static int attr_form_is_block (const struct attribute *);
1816 static int attr_form_is_section_offset (const struct attribute *);
1818 static int attr_form_is_constant (const struct attribute *);
1820 static int attr_form_is_ref (const struct attribute *);
1822 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1823 struct dwarf2_loclist_baton *baton,
1824 const struct attribute *attr);
1826 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1828 struct dwarf2_cu *cu,
1831 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1832 const gdb_byte *info_ptr,
1833 struct abbrev_info *abbrev);
1835 static hashval_t partial_die_hash (const void *item);
1837 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1839 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1840 (sect_offset sect_off, unsigned int offset_in_dwz,
1841 struct dwarf2_per_objfile *dwarf2_per_objfile);
1843 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1844 struct die_info *comp_unit_die,
1845 enum language pretend_language);
1847 static void age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1849 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1851 static struct type *set_die_type (struct die_info *, struct type *,
1852 struct dwarf2_cu *);
1854 static void create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1856 static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1858 static void load_full_comp_unit (struct dwarf2_per_cu_data *, bool,
1861 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1864 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1867 static void dwarf2_add_dependence (struct dwarf2_cu *,
1868 struct dwarf2_per_cu_data *);
1870 static void dwarf2_mark (struct dwarf2_cu *);
1872 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1874 static struct type *get_die_type_at_offset (sect_offset,
1875 struct dwarf2_per_cu_data *);
1877 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1879 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1880 enum language pretend_language);
1882 static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile);
1884 /* Class, the destructor of which frees all allocated queue entries. This
1885 will only have work to do if an error was thrown while processing the
1886 dwarf. If no error was thrown then the queue entries should have all
1887 been processed, and freed, as we went along. */
1889 class dwarf2_queue_guard
1892 dwarf2_queue_guard () = default;
1894 /* Free any entries remaining on the queue. There should only be
1895 entries left if we hit an error while processing the dwarf. */
1896 ~dwarf2_queue_guard ()
1898 struct dwarf2_queue_item *item, *last;
1900 item = dwarf2_queue;
1903 /* Anything still marked queued is likely to be in an
1904 inconsistent state, so discard it. */
1905 if (item->per_cu->queued)
1907 if (item->per_cu->cu != NULL)
1908 free_one_cached_comp_unit (item->per_cu);
1909 item->per_cu->queued = 0;
1917 dwarf2_queue = dwarf2_queue_tail = NULL;
1921 /* The return type of find_file_and_directory. Note, the enclosed
1922 string pointers are only valid while this object is valid. */
1924 struct file_and_directory
1926 /* The filename. This is never NULL. */
1929 /* The compilation directory. NULL if not known. If we needed to
1930 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1931 points directly to the DW_AT_comp_dir string attribute owned by
1932 the obstack that owns the DIE. */
1933 const char *comp_dir;
1935 /* If we needed to build a new string for comp_dir, this is what
1936 owns the storage. */
1937 std::string comp_dir_storage;
1940 static file_and_directory find_file_and_directory (struct die_info *die,
1941 struct dwarf2_cu *cu);
1943 static char *file_full_name (int file, struct line_header *lh,
1944 const char *comp_dir);
1946 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
1947 enum class rcuh_kind { COMPILE, TYPE };
1949 static const gdb_byte *read_and_check_comp_unit_head
1950 (struct dwarf2_per_objfile* dwarf2_per_objfile,
1951 struct comp_unit_head *header,
1952 struct dwarf2_section_info *section,
1953 struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1954 rcuh_kind section_kind);
1956 static void init_cutu_and_read_dies
1957 (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1958 int use_existing_cu, int keep, bool skip_partial,
1959 die_reader_func_ftype *die_reader_func, void *data);
1961 static void init_cutu_and_read_dies_simple
1962 (struct dwarf2_per_cu_data *this_cu,
1963 die_reader_func_ftype *die_reader_func, void *data);
1965 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1967 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1969 static struct dwo_unit *lookup_dwo_unit_in_dwp
1970 (struct dwarf2_per_objfile *dwarf2_per_objfile,
1971 struct dwp_file *dwp_file, const char *comp_dir,
1972 ULONGEST signature, int is_debug_types);
1974 static struct dwp_file *get_dwp_file
1975 (struct dwarf2_per_objfile *dwarf2_per_objfile);
1977 static struct dwo_unit *lookup_dwo_comp_unit
1978 (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
1980 static struct dwo_unit *lookup_dwo_type_unit
1981 (struct signatured_type *, const char *, const char *);
1983 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
1985 static void free_dwo_file (struct dwo_file *);
1987 /* A unique_ptr helper to free a dwo_file. */
1989 struct dwo_file_deleter
1991 void operator() (struct dwo_file *df) const
1997 /* A unique pointer to a dwo_file. */
1999 typedef std::unique_ptr<struct dwo_file, dwo_file_deleter> dwo_file_up;
2001 static void process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile);
2003 static void check_producer (struct dwarf2_cu *cu);
2005 static void free_line_header_voidp (void *arg);
2007 /* Various complaints about symbol reading that don't abort the process. */
2010 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2012 complaint (_("statement list doesn't fit in .debug_line section"));
2016 dwarf2_debug_line_missing_file_complaint (void)
2018 complaint (_(".debug_line section has line data without a file"));
2022 dwarf2_debug_line_missing_end_sequence_complaint (void)
2024 complaint (_(".debug_line section has line "
2025 "program sequence without an end"));
2029 dwarf2_complex_location_expr_complaint (void)
2031 complaint (_("location expression too complex"));
2035 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
2038 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
2043 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
2045 complaint (_("debug info runs off end of %s section"
2047 get_section_name (section),
2048 get_section_file_name (section));
2052 dwarf2_macro_malformed_definition_complaint (const char *arg1)
2054 complaint (_("macro debug info contains a "
2055 "malformed macro definition:\n`%s'"),
2060 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
2062 complaint (_("invalid attribute class or form for '%s' in '%s'"),
2066 /* Hash function for line_header_hash. */
2069 line_header_hash (const struct line_header *ofs)
2071 return to_underlying (ofs->sect_off) ^ ofs->offset_in_dwz;
2074 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2077 line_header_hash_voidp (const void *item)
2079 const struct line_header *ofs = (const struct line_header *) item;
2081 return line_header_hash (ofs);
2084 /* Equality function for line_header_hash. */
2087 line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
2089 const struct line_header *ofs_lhs = (const struct line_header *) item_lhs;
2090 const struct line_header *ofs_rhs = (const struct line_header *) item_rhs;
2092 return (ofs_lhs->sect_off == ofs_rhs->sect_off
2093 && ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
2098 /* Read the given attribute value as an address, taking the attribute's
2099 form into account. */
2102 attr_value_as_address (struct attribute *attr)
2106 if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index)
2108 /* Aside from a few clearly defined exceptions, attributes that
2109 contain an address must always be in DW_FORM_addr form.
2110 Unfortunately, some compilers happen to be violating this
2111 requirement by encoding addresses using other forms, such
2112 as DW_FORM_data4 for example. For those broken compilers,
2113 we try to do our best, without any guarantee of success,
2114 to interpret the address correctly. It would also be nice
2115 to generate a complaint, but that would require us to maintain
2116 a list of legitimate cases where a non-address form is allowed,
2117 as well as update callers to pass in at least the CU's DWARF
2118 version. This is more overhead than what we're willing to
2119 expand for a pretty rare case. */
2120 addr = DW_UNSND (attr);
2123 addr = DW_ADDR (attr);
2128 /* See declaration. */
2130 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_,
2131 const dwarf2_debug_sections *names)
2132 : objfile (objfile_)
2135 names = &dwarf2_elf_names;
2137 bfd *obfd = objfile->obfd;
2139 for (asection *sec = obfd->sections; sec != NULL; sec = sec->next)
2140 locate_sections (obfd, sec, *names);
2143 static void free_dwo_files (htab_t dwo_files, struct objfile *objfile);
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 VEC_free (dwarf2_section_info_def, types);
2164 if (dwo_files != NULL)
2165 free_dwo_files (dwo_files, objfile);
2167 /* Everything else should be on the objfile obstack. */
2170 /* See declaration. */
2173 dwarf2_per_objfile::free_cached_comp_units ()
2175 dwarf2_per_cu_data *per_cu = read_in_chain;
2176 dwarf2_per_cu_data **last_chain = &read_in_chain;
2177 while (per_cu != NULL)
2179 dwarf2_per_cu_data *next_cu = per_cu->cu->read_in_chain;
2182 *last_chain = next_cu;
2187 /* A helper class that calls free_cached_comp_units on
2190 class free_cached_comp_units
2194 explicit free_cached_comp_units (dwarf2_per_objfile *per_objfile)
2195 : m_per_objfile (per_objfile)
2199 ~free_cached_comp_units ()
2201 m_per_objfile->free_cached_comp_units ();
2204 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units);
2208 dwarf2_per_objfile *m_per_objfile;
2211 /* Try to locate the sections we need for DWARF 2 debugging
2212 information and return true if we have enough to do something.
2213 NAMES points to the dwarf2 section names, or is NULL if the standard
2214 ELF names are used. */
2217 dwarf2_has_info (struct objfile *objfile,
2218 const struct dwarf2_debug_sections *names)
2220 if (objfile->flags & OBJF_READNEVER)
2223 struct dwarf2_per_objfile *dwarf2_per_objfile
2224 = get_dwarf2_per_objfile (objfile);
2226 if (dwarf2_per_objfile == NULL)
2228 /* Initialize per-objfile state. */
2230 = new (&objfile->objfile_obstack) struct dwarf2_per_objfile (objfile,
2232 set_dwarf2_per_objfile (objfile, dwarf2_per_objfile);
2234 return (!dwarf2_per_objfile->info.is_virtual
2235 && dwarf2_per_objfile->info.s.section != NULL
2236 && !dwarf2_per_objfile->abbrev.is_virtual
2237 && dwarf2_per_objfile->abbrev.s.section != NULL);
2240 /* Return the containing section of virtual section SECTION. */
2242 static struct dwarf2_section_info *
2243 get_containing_section (const struct dwarf2_section_info *section)
2245 gdb_assert (section->is_virtual);
2246 return section->s.containing_section;
2249 /* Return the bfd owner of SECTION. */
2252 get_section_bfd_owner (const struct dwarf2_section_info *section)
2254 if (section->is_virtual)
2256 section = get_containing_section (section);
2257 gdb_assert (!section->is_virtual);
2259 return section->s.section->owner;
2262 /* Return the bfd section of SECTION.
2263 Returns NULL if the section is not present. */
2266 get_section_bfd_section (const struct dwarf2_section_info *section)
2268 if (section->is_virtual)
2270 section = get_containing_section (section);
2271 gdb_assert (!section->is_virtual);
2273 return section->s.section;
2276 /* Return the name of SECTION. */
2279 get_section_name (const struct dwarf2_section_info *section)
2281 asection *sectp = get_section_bfd_section (section);
2283 gdb_assert (sectp != NULL);
2284 return bfd_section_name (get_section_bfd_owner (section), sectp);
2287 /* Return the name of the file SECTION is in. */
2290 get_section_file_name (const struct dwarf2_section_info *section)
2292 bfd *abfd = get_section_bfd_owner (section);
2294 return bfd_get_filename (abfd);
2297 /* Return the id of SECTION.
2298 Returns 0 if SECTION doesn't exist. */
2301 get_section_id (const struct dwarf2_section_info *section)
2303 asection *sectp = get_section_bfd_section (section);
2310 /* Return the flags of SECTION.
2311 SECTION (or containing section if this is a virtual section) must exist. */
2314 get_section_flags (const struct dwarf2_section_info *section)
2316 asection *sectp = get_section_bfd_section (section);
2318 gdb_assert (sectp != NULL);
2319 return bfd_get_section_flags (sectp->owner, sectp);
2322 /* When loading sections, we look either for uncompressed section or for
2323 compressed section names. */
2326 section_is_p (const char *section_name,
2327 const struct dwarf2_section_names *names)
2329 if (names->normal != NULL
2330 && strcmp (section_name, names->normal) == 0)
2332 if (names->compressed != NULL
2333 && strcmp (section_name, names->compressed) == 0)
2338 /* See declaration. */
2341 dwarf2_per_objfile::locate_sections (bfd *abfd, asection *sectp,
2342 const dwarf2_debug_sections &names)
2344 flagword aflag = bfd_get_section_flags (abfd, sectp);
2346 if ((aflag & SEC_HAS_CONTENTS) == 0)
2349 else if (section_is_p (sectp->name, &names.info))
2351 this->info.s.section = sectp;
2352 this->info.size = bfd_get_section_size (sectp);
2354 else if (section_is_p (sectp->name, &names.abbrev))
2356 this->abbrev.s.section = sectp;
2357 this->abbrev.size = bfd_get_section_size (sectp);
2359 else if (section_is_p (sectp->name, &names.line))
2361 this->line.s.section = sectp;
2362 this->line.size = bfd_get_section_size (sectp);
2364 else if (section_is_p (sectp->name, &names.loc))
2366 this->loc.s.section = sectp;
2367 this->loc.size = bfd_get_section_size (sectp);
2369 else if (section_is_p (sectp->name, &names.loclists))
2371 this->loclists.s.section = sectp;
2372 this->loclists.size = bfd_get_section_size (sectp);
2374 else if (section_is_p (sectp->name, &names.macinfo))
2376 this->macinfo.s.section = sectp;
2377 this->macinfo.size = bfd_get_section_size (sectp);
2379 else if (section_is_p (sectp->name, &names.macro))
2381 this->macro.s.section = sectp;
2382 this->macro.size = bfd_get_section_size (sectp);
2384 else if (section_is_p (sectp->name, &names.str))
2386 this->str.s.section = sectp;
2387 this->str.size = bfd_get_section_size (sectp);
2389 else if (section_is_p (sectp->name, &names.line_str))
2391 this->line_str.s.section = sectp;
2392 this->line_str.size = bfd_get_section_size (sectp);
2394 else if (section_is_p (sectp->name, &names.addr))
2396 this->addr.s.section = sectp;
2397 this->addr.size = bfd_get_section_size (sectp);
2399 else if (section_is_p (sectp->name, &names.frame))
2401 this->frame.s.section = sectp;
2402 this->frame.size = bfd_get_section_size (sectp);
2404 else if (section_is_p (sectp->name, &names.eh_frame))
2406 this->eh_frame.s.section = sectp;
2407 this->eh_frame.size = bfd_get_section_size (sectp);
2409 else if (section_is_p (sectp->name, &names.ranges))
2411 this->ranges.s.section = sectp;
2412 this->ranges.size = bfd_get_section_size (sectp);
2414 else if (section_is_p (sectp->name, &names.rnglists))
2416 this->rnglists.s.section = sectp;
2417 this->rnglists.size = bfd_get_section_size (sectp);
2419 else if (section_is_p (sectp->name, &names.types))
2421 struct dwarf2_section_info type_section;
2423 memset (&type_section, 0, sizeof (type_section));
2424 type_section.s.section = sectp;
2425 type_section.size = bfd_get_section_size (sectp);
2427 VEC_safe_push (dwarf2_section_info_def, this->types,
2430 else if (section_is_p (sectp->name, &names.gdb_index))
2432 this->gdb_index.s.section = sectp;
2433 this->gdb_index.size = bfd_get_section_size (sectp);
2435 else if (section_is_p (sectp->name, &names.debug_names))
2437 this->debug_names.s.section = sectp;
2438 this->debug_names.size = bfd_get_section_size (sectp);
2440 else if (section_is_p (sectp->name, &names.debug_aranges))
2442 this->debug_aranges.s.section = sectp;
2443 this->debug_aranges.size = bfd_get_section_size (sectp);
2446 if ((bfd_get_section_flags (abfd, sectp) & (SEC_LOAD | SEC_ALLOC))
2447 && bfd_section_vma (abfd, sectp) == 0)
2448 this->has_section_at_zero = true;
2451 /* A helper function that decides whether a section is empty,
2455 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2457 if (section->is_virtual)
2458 return section->size == 0;
2459 return section->s.section == NULL || section->size == 0;
2462 /* See dwarf2read.h. */
2465 dwarf2_read_section (struct objfile *objfile, dwarf2_section_info *info)
2469 gdb_byte *buf, *retbuf;
2473 info->buffer = NULL;
2476 if (dwarf2_section_empty_p (info))
2479 sectp = get_section_bfd_section (info);
2481 /* If this is a virtual section we need to read in the real one first. */
2482 if (info->is_virtual)
2484 struct dwarf2_section_info *containing_section =
2485 get_containing_section (info);
2487 gdb_assert (sectp != NULL);
2488 if ((sectp->flags & SEC_RELOC) != 0)
2490 error (_("Dwarf Error: DWP format V2 with relocations is not"
2491 " supported in section %s [in module %s]"),
2492 get_section_name (info), get_section_file_name (info));
2494 dwarf2_read_section (objfile, containing_section);
2495 /* Other code should have already caught virtual sections that don't
2497 gdb_assert (info->virtual_offset + info->size
2498 <= containing_section->size);
2499 /* If the real section is empty or there was a problem reading the
2500 section we shouldn't get here. */
2501 gdb_assert (containing_section->buffer != NULL);
2502 info->buffer = containing_section->buffer + info->virtual_offset;
2506 /* If the section has relocations, we must read it ourselves.
2507 Otherwise we attach it to the BFD. */
2508 if ((sectp->flags & SEC_RELOC) == 0)
2510 info->buffer = gdb_bfd_map_section (sectp, &info->size);
2514 buf = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, info->size);
2517 /* When debugging .o files, we may need to apply relocations; see
2518 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2519 We never compress sections in .o files, so we only need to
2520 try this when the section is not compressed. */
2521 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2524 info->buffer = retbuf;
2528 abfd = get_section_bfd_owner (info);
2529 gdb_assert (abfd != NULL);
2531 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2532 || bfd_bread (buf, info->size, abfd) != info->size)
2534 error (_("Dwarf Error: Can't read DWARF data"
2535 " in section %s [in module %s]"),
2536 bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2540 /* A helper function that returns the size of a section in a safe way.
2541 If you are positive that the section has been read before using the
2542 size, then it is safe to refer to the dwarf2_section_info object's
2543 "size" field directly. In other cases, you must call this
2544 function, because for compressed sections the size field is not set
2545 correctly until the section has been read. */
2547 static bfd_size_type
2548 dwarf2_section_size (struct objfile *objfile,
2549 struct dwarf2_section_info *info)
2552 dwarf2_read_section (objfile, info);
2556 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2560 dwarf2_get_section_info (struct objfile *objfile,
2561 enum dwarf2_section_enum sect,
2562 asection **sectp, const gdb_byte **bufp,
2563 bfd_size_type *sizep)
2565 struct dwarf2_per_objfile *data
2566 = (struct dwarf2_per_objfile *) objfile_data (objfile,
2567 dwarf2_objfile_data_key);
2568 struct dwarf2_section_info *info;
2570 /* We may see an objfile without any DWARF, in which case we just
2581 case DWARF2_DEBUG_FRAME:
2582 info = &data->frame;
2584 case DWARF2_EH_FRAME:
2585 info = &data->eh_frame;
2588 gdb_assert_not_reached ("unexpected section");
2591 dwarf2_read_section (objfile, info);
2593 *sectp = get_section_bfd_section (info);
2594 *bufp = info->buffer;
2595 *sizep = info->size;
2598 /* A helper function to find the sections for a .dwz file. */
2601 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2603 struct dwz_file *dwz_file = (struct dwz_file *) arg;
2605 /* Note that we only support the standard ELF names, because .dwz
2606 is ELF-only (at the time of writing). */
2607 if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2609 dwz_file->abbrev.s.section = sectp;
2610 dwz_file->abbrev.size = bfd_get_section_size (sectp);
2612 else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2614 dwz_file->info.s.section = sectp;
2615 dwz_file->info.size = bfd_get_section_size (sectp);
2617 else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2619 dwz_file->str.s.section = sectp;
2620 dwz_file->str.size = bfd_get_section_size (sectp);
2622 else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2624 dwz_file->line.s.section = sectp;
2625 dwz_file->line.size = bfd_get_section_size (sectp);
2627 else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2629 dwz_file->macro.s.section = sectp;
2630 dwz_file->macro.size = bfd_get_section_size (sectp);
2632 else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2634 dwz_file->gdb_index.s.section = sectp;
2635 dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2637 else if (section_is_p (sectp->name, &dwarf2_elf_names.debug_names))
2639 dwz_file->debug_names.s.section = sectp;
2640 dwz_file->debug_names.size = bfd_get_section_size (sectp);
2644 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2645 there is no .gnu_debugaltlink section in the file. Error if there
2646 is such a section but the file cannot be found. */
2648 static struct dwz_file *
2649 dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
2651 const char *filename;
2652 bfd_size_type buildid_len_arg;
2656 if (dwarf2_per_objfile->dwz_file != NULL)
2657 return dwarf2_per_objfile->dwz_file.get ();
2659 bfd_set_error (bfd_error_no_error);
2660 gdb::unique_xmalloc_ptr<char> data
2661 (bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2662 &buildid_len_arg, &buildid));
2665 if (bfd_get_error () == bfd_error_no_error)
2667 error (_("could not read '.gnu_debugaltlink' section: %s"),
2668 bfd_errmsg (bfd_get_error ()));
2671 gdb::unique_xmalloc_ptr<bfd_byte> buildid_holder (buildid);
2673 buildid_len = (size_t) buildid_len_arg;
2675 filename = data.get ();
2677 std::string abs_storage;
2678 if (!IS_ABSOLUTE_PATH (filename))
2680 gdb::unique_xmalloc_ptr<char> abs
2681 = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2683 abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
2684 filename = abs_storage.c_str ();
2687 /* First try the file name given in the section. If that doesn't
2688 work, try to use the build-id instead. */
2689 gdb_bfd_ref_ptr dwz_bfd (gdb_bfd_open (filename, gnutarget, -1));
2690 if (dwz_bfd != NULL)
2692 if (!build_id_verify (dwz_bfd.get (), buildid_len, buildid))
2696 if (dwz_bfd == NULL)
2697 dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2699 if (dwz_bfd == NULL)
2700 error (_("could not find '.gnu_debugaltlink' file for %s"),
2701 objfile_name (dwarf2_per_objfile->objfile));
2703 std::unique_ptr<struct dwz_file> result
2704 (new struct dwz_file (std::move (dwz_bfd)));
2706 bfd_map_over_sections (result->dwz_bfd.get (), locate_dwz_sections,
2709 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd,
2710 result->dwz_bfd.get ());
2711 dwarf2_per_objfile->dwz_file = std::move (result);
2712 return dwarf2_per_objfile->dwz_file.get ();
2715 /* DWARF quick_symbols_functions support. */
2717 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2718 unique line tables, so we maintain a separate table of all .debug_line
2719 derived entries to support the sharing.
2720 All the quick functions need is the list of file names. We discard the
2721 line_header when we're done and don't need to record it here. */
2722 struct quick_file_names
2724 /* The data used to construct the hash key. */
2725 struct stmt_list_hash hash;
2727 /* The number of entries in file_names, real_names. */
2728 unsigned int num_file_names;
2730 /* The file names from the line table, after being run through
2732 const char **file_names;
2734 /* The file names from the line table after being run through
2735 gdb_realpath. These are computed lazily. */
2736 const char **real_names;
2739 /* When using the index (and thus not using psymtabs), each CU has an
2740 object of this type. This is used to hold information needed by
2741 the various "quick" methods. */
2742 struct dwarf2_per_cu_quick_data
2744 /* The file table. This can be NULL if there was no file table
2745 or it's currently not read in.
2746 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2747 struct quick_file_names *file_names;
2749 /* The corresponding symbol table. This is NULL if symbols for this
2750 CU have not yet been read. */
2751 struct compunit_symtab *compunit_symtab;
2753 /* A temporary mark bit used when iterating over all CUs in
2754 expand_symtabs_matching. */
2755 unsigned int mark : 1;
2757 /* True if we've tried to read the file table and found there isn't one.
2758 There will be no point in trying to read it again next time. */
2759 unsigned int no_file_data : 1;
2762 /* Utility hash function for a stmt_list_hash. */
2765 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2769 if (stmt_list_hash->dwo_unit != NULL)
2770 v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2771 v += to_underlying (stmt_list_hash->line_sect_off);
2775 /* Utility equality function for a stmt_list_hash. */
2778 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2779 const struct stmt_list_hash *rhs)
2781 if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2783 if (lhs->dwo_unit != NULL
2784 && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2787 return lhs->line_sect_off == rhs->line_sect_off;
2790 /* Hash function for a quick_file_names. */
2793 hash_file_name_entry (const void *e)
2795 const struct quick_file_names *file_data
2796 = (const struct quick_file_names *) e;
2798 return hash_stmt_list_entry (&file_data->hash);
2801 /* Equality function for a quick_file_names. */
2804 eq_file_name_entry (const void *a, const void *b)
2806 const struct quick_file_names *ea = (const struct quick_file_names *) a;
2807 const struct quick_file_names *eb = (const struct quick_file_names *) b;
2809 return eq_stmt_list_entry (&ea->hash, &eb->hash);
2812 /* Delete function for a quick_file_names. */
2815 delete_file_name_entry (void *e)
2817 struct quick_file_names *file_data = (struct quick_file_names *) e;
2820 for (i = 0; i < file_data->num_file_names; ++i)
2822 xfree ((void*) file_data->file_names[i]);
2823 if (file_data->real_names)
2824 xfree ((void*) file_data->real_names[i]);
2827 /* The space for the struct itself lives on objfile_obstack,
2828 so we don't free it here. */
2831 /* Create a quick_file_names hash table. */
2834 create_quick_file_names_table (unsigned int nr_initial_entries)
2836 return htab_create_alloc (nr_initial_entries,
2837 hash_file_name_entry, eq_file_name_entry,
2838 delete_file_name_entry, xcalloc, xfree);
2841 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2842 have to be created afterwards. You should call age_cached_comp_units after
2843 processing PER_CU->CU. dw2_setup must have been already called. */
2846 load_cu (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2848 if (per_cu->is_debug_types)
2849 load_full_type_unit (per_cu);
2851 load_full_comp_unit (per_cu, skip_partial, language_minimal);
2853 if (per_cu->cu == NULL)
2854 return; /* Dummy CU. */
2856 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2859 /* Read in the symbols for PER_CU. */
2862 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2864 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2866 /* Skip type_unit_groups, reading the type units they contain
2867 is handled elsewhere. */
2868 if (IS_TYPE_UNIT_GROUP (per_cu))
2871 /* The destructor of dwarf2_queue_guard frees any entries left on
2872 the queue. After this point we're guaranteed to leave this function
2873 with the dwarf queue empty. */
2874 dwarf2_queue_guard q_guard;
2876 if (dwarf2_per_objfile->using_index
2877 ? per_cu->v.quick->compunit_symtab == NULL
2878 : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2880 queue_comp_unit (per_cu, language_minimal);
2881 load_cu (per_cu, skip_partial);
2883 /* If we just loaded a CU from a DWO, and we're working with an index
2884 that may badly handle TUs, load all the TUs in that DWO as well.
2885 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2886 if (!per_cu->is_debug_types
2887 && per_cu->cu != NULL
2888 && per_cu->cu->dwo_unit != NULL
2889 && dwarf2_per_objfile->index_table != NULL
2890 && dwarf2_per_objfile->index_table->version <= 7
2891 /* DWP files aren't supported yet. */
2892 && get_dwp_file (dwarf2_per_objfile) == NULL)
2893 queue_and_load_all_dwo_tus (per_cu);
2896 process_queue (dwarf2_per_objfile);
2898 /* Age the cache, releasing compilation units that have not
2899 been used recently. */
2900 age_cached_comp_units (dwarf2_per_objfile);
2903 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2904 the objfile from which this CU came. Returns the resulting symbol
2907 static struct compunit_symtab *
2908 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2910 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2912 gdb_assert (dwarf2_per_objfile->using_index);
2913 if (!per_cu->v.quick->compunit_symtab)
2915 free_cached_comp_units freer (dwarf2_per_objfile);
2916 scoped_restore decrementer = increment_reading_symtab ();
2917 dw2_do_instantiate_symtab (per_cu, skip_partial);
2918 process_cu_includes (dwarf2_per_objfile);
2921 return per_cu->v.quick->compunit_symtab;
2924 /* See declaration. */
2926 dwarf2_per_cu_data *
2927 dwarf2_per_objfile::get_cutu (int index)
2929 if (index >= this->all_comp_units.size ())
2931 index -= this->all_comp_units.size ();
2932 gdb_assert (index < this->all_type_units.size ());
2933 return &this->all_type_units[index]->per_cu;
2936 return this->all_comp_units[index];
2939 /* See declaration. */
2941 dwarf2_per_cu_data *
2942 dwarf2_per_objfile::get_cu (int index)
2944 gdb_assert (index >= 0 && index < this->all_comp_units.size ());
2946 return this->all_comp_units[index];
2949 /* See declaration. */
2952 dwarf2_per_objfile::get_tu (int index)
2954 gdb_assert (index >= 0 && index < this->all_type_units.size ());
2956 return this->all_type_units[index];
2959 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2960 objfile_obstack, and constructed with the specified field
2963 static dwarf2_per_cu_data *
2964 create_cu_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2965 struct dwarf2_section_info *section,
2967 sect_offset sect_off, ULONGEST length)
2969 struct objfile *objfile = dwarf2_per_objfile->objfile;
2970 dwarf2_per_cu_data *the_cu
2971 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2972 struct dwarf2_per_cu_data);
2973 the_cu->sect_off = sect_off;
2974 the_cu->length = length;
2975 the_cu->dwarf2_per_objfile = dwarf2_per_objfile;
2976 the_cu->section = section;
2977 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2978 struct dwarf2_per_cu_quick_data);
2979 the_cu->is_dwz = is_dwz;
2983 /* A helper for create_cus_from_index that handles a given list of
2987 create_cus_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2988 const gdb_byte *cu_list, offset_type n_elements,
2989 struct dwarf2_section_info *section,
2992 for (offset_type i = 0; i < n_elements; i += 2)
2994 gdb_static_assert (sizeof (ULONGEST) >= 8);
2996 sect_offset sect_off
2997 = (sect_offset) extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
2998 ULONGEST length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
3001 dwarf2_per_cu_data *per_cu
3002 = create_cu_from_index_list (dwarf2_per_objfile, section, is_dwz,
3004 dwarf2_per_objfile->all_comp_units.push_back (per_cu);
3008 /* Read the CU list from the mapped index, and use it to create all
3009 the CU objects for this objfile. */
3012 create_cus_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3013 const gdb_byte *cu_list, offset_type cu_list_elements,
3014 const gdb_byte *dwz_list, offset_type dwz_elements)
3016 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
3017 dwarf2_per_objfile->all_comp_units.reserve
3018 ((cu_list_elements + dwz_elements) / 2);
3020 create_cus_from_index_list (dwarf2_per_objfile, cu_list, cu_list_elements,
3021 &dwarf2_per_objfile->info, 0);
3023 if (dwz_elements == 0)
3026 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3027 create_cus_from_index_list (dwarf2_per_objfile, dwz_list, dwz_elements,
3031 /* Create the signatured type hash table from the index. */
3034 create_signatured_type_table_from_index
3035 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3036 struct dwarf2_section_info *section,
3037 const gdb_byte *bytes,
3038 offset_type elements)
3040 struct objfile *objfile = dwarf2_per_objfile->objfile;
3042 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3043 dwarf2_per_objfile->all_type_units.reserve (elements / 3);
3045 htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3047 for (offset_type i = 0; i < elements; i += 3)
3049 struct signatured_type *sig_type;
3052 cu_offset type_offset_in_tu;
3054 gdb_static_assert (sizeof (ULONGEST) >= 8);
3055 sect_offset sect_off
3056 = (sect_offset) extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
3058 = (cu_offset) extract_unsigned_integer (bytes + 8, 8,
3060 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
3063 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3064 struct signatured_type);
3065 sig_type->signature = signature;
3066 sig_type->type_offset_in_tu = type_offset_in_tu;
3067 sig_type->per_cu.is_debug_types = 1;
3068 sig_type->per_cu.section = section;
3069 sig_type->per_cu.sect_off = sect_off;
3070 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3071 sig_type->per_cu.v.quick
3072 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3073 struct dwarf2_per_cu_quick_data);
3075 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3078 dwarf2_per_objfile->all_type_units.push_back (sig_type);
3081 dwarf2_per_objfile->signatured_types = sig_types_hash;
3084 /* Create the signatured type hash table from .debug_names. */
3087 create_signatured_type_table_from_debug_names
3088 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3089 const mapped_debug_names &map,
3090 struct dwarf2_section_info *section,
3091 struct dwarf2_section_info *abbrev_section)
3093 struct objfile *objfile = dwarf2_per_objfile->objfile;
3095 dwarf2_read_section (objfile, section);
3096 dwarf2_read_section (objfile, abbrev_section);
3098 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3099 dwarf2_per_objfile->all_type_units.reserve (map.tu_count);
3101 htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3103 for (uint32_t i = 0; i < map.tu_count; ++i)
3105 struct signatured_type *sig_type;
3108 sect_offset sect_off
3109 = (sect_offset) (extract_unsigned_integer
3110 (map.tu_table_reordered + i * map.offset_size,
3112 map.dwarf5_byte_order));
3114 comp_unit_head cu_header;
3115 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
3117 section->buffer + to_underlying (sect_off),
3120 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3121 struct signatured_type);
3122 sig_type->signature = cu_header.signature;
3123 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
3124 sig_type->per_cu.is_debug_types = 1;
3125 sig_type->per_cu.section = section;
3126 sig_type->per_cu.sect_off = sect_off;
3127 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3128 sig_type->per_cu.v.quick
3129 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3130 struct dwarf2_per_cu_quick_data);
3132 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3135 dwarf2_per_objfile->all_type_units.push_back (sig_type);
3138 dwarf2_per_objfile->signatured_types = sig_types_hash;
3141 /* Read the address map data from the mapped index, and use it to
3142 populate the objfile's psymtabs_addrmap. */
3145 create_addrmap_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3146 struct mapped_index *index)
3148 struct objfile *objfile = dwarf2_per_objfile->objfile;
3149 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3150 const gdb_byte *iter, *end;
3151 struct addrmap *mutable_map;
3154 auto_obstack temp_obstack;
3156 mutable_map = addrmap_create_mutable (&temp_obstack);
3158 iter = index->address_table.data ();
3159 end = iter + index->address_table.size ();
3161 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3165 ULONGEST hi, lo, cu_index;
3166 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3168 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3170 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
3175 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
3176 hex_string (lo), hex_string (hi));
3180 if (cu_index >= dwarf2_per_objfile->all_comp_units.size ())
3182 complaint (_(".gdb_index address table has invalid CU number %u"),
3183 (unsigned) cu_index);
3187 lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr) - baseaddr;
3188 hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr) - baseaddr;
3189 addrmap_set_empty (mutable_map, lo, hi - 1,
3190 dwarf2_per_objfile->get_cu (cu_index));
3193 objfile->partial_symtabs->psymtabs_addrmap
3194 = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3197 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3198 populate the objfile's psymtabs_addrmap. */
3201 create_addrmap_from_aranges (struct dwarf2_per_objfile *dwarf2_per_objfile,
3202 struct dwarf2_section_info *section)
3204 struct objfile *objfile = dwarf2_per_objfile->objfile;
3205 bfd *abfd = objfile->obfd;
3206 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3207 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
3208 SECT_OFF_TEXT (objfile));
3210 auto_obstack temp_obstack;
3211 addrmap *mutable_map = addrmap_create_mutable (&temp_obstack);
3213 std::unordered_map<sect_offset,
3214 dwarf2_per_cu_data *,
3215 gdb::hash_enum<sect_offset>>
3216 debug_info_offset_to_per_cu;
3217 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3219 const auto insertpair
3220 = debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);
3221 if (!insertpair.second)
3223 warning (_("Section .debug_aranges in %s has duplicate "
3224 "debug_info_offset %s, ignoring .debug_aranges."),
3225 objfile_name (objfile), sect_offset_str (per_cu->sect_off));
3230 dwarf2_read_section (objfile, section);
3232 const bfd_endian dwarf5_byte_order = gdbarch_byte_order (gdbarch);
3234 const gdb_byte *addr = section->buffer;
3236 while (addr < section->buffer + section->size)
3238 const gdb_byte *const entry_addr = addr;
3239 unsigned int bytes_read;
3241 const LONGEST entry_length = read_initial_length (abfd, addr,
3245 const gdb_byte *const entry_end = addr + entry_length;
3246 const bool dwarf5_is_dwarf64 = bytes_read != 4;
3247 const uint8_t offset_size = dwarf5_is_dwarf64 ? 8 : 4;
3248 if (addr + entry_length > section->buffer + section->size)
3250 warning (_("Section .debug_aranges in %s entry at offset %zu "
3251 "length %s exceeds section length %s, "
3252 "ignoring .debug_aranges."),
3253 objfile_name (objfile), entry_addr - section->buffer,
3254 plongest (bytes_read + entry_length),
3255 pulongest (section->size));
3259 /* The version number. */
3260 const uint16_t version = read_2_bytes (abfd, addr);
3264 warning (_("Section .debug_aranges in %s entry at offset %zu "
3265 "has unsupported version %d, ignoring .debug_aranges."),
3266 objfile_name (objfile), entry_addr - section->buffer,
3271 const uint64_t debug_info_offset
3272 = extract_unsigned_integer (addr, offset_size, dwarf5_byte_order);
3273 addr += offset_size;
3274 const auto per_cu_it
3275 = debug_info_offset_to_per_cu.find (sect_offset (debug_info_offset));
3276 if (per_cu_it == debug_info_offset_to_per_cu.cend ())
3278 warning (_("Section .debug_aranges in %s entry at offset %zu "
3279 "debug_info_offset %s does not exists, "
3280 "ignoring .debug_aranges."),
3281 objfile_name (objfile), entry_addr - section->buffer,
3282 pulongest (debug_info_offset));
3285 dwarf2_per_cu_data *const per_cu = per_cu_it->second;
3287 const uint8_t address_size = *addr++;
3288 if (address_size < 1 || address_size > 8)
3290 warning (_("Section .debug_aranges in %s entry at offset %zu "
3291 "address_size %u is invalid, ignoring .debug_aranges."),
3292 objfile_name (objfile), entry_addr - section->buffer,
3297 const uint8_t segment_selector_size = *addr++;
3298 if (segment_selector_size != 0)
3300 warning (_("Section .debug_aranges in %s entry at offset %zu "
3301 "segment_selector_size %u is not supported, "
3302 "ignoring .debug_aranges."),
3303 objfile_name (objfile), entry_addr - section->buffer,
3304 segment_selector_size);
3308 /* Must pad to an alignment boundary that is twice the address
3309 size. It is undocumented by the DWARF standard but GCC does
3311 for (size_t padding = ((-(addr - section->buffer))
3312 & (2 * address_size - 1));
3313 padding > 0; padding--)
3316 warning (_("Section .debug_aranges in %s entry at offset %zu "
3317 "padding is not zero, ignoring .debug_aranges."),
3318 objfile_name (objfile), entry_addr - section->buffer);
3324 if (addr + 2 * address_size > entry_end)
3326 warning (_("Section .debug_aranges in %s entry at offset %zu "
3327 "address list is not properly terminated, "
3328 "ignoring .debug_aranges."),
3329 objfile_name (objfile), entry_addr - section->buffer);
3332 ULONGEST start = extract_unsigned_integer (addr, address_size,
3334 addr += address_size;
3335 ULONGEST length = extract_unsigned_integer (addr, address_size,
3337 addr += address_size;
3338 if (start == 0 && length == 0)
3340 if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
3342 /* Symbol was eliminated due to a COMDAT group. */
3345 ULONGEST end = start + length;
3346 start = (gdbarch_adjust_dwarf2_addr (gdbarch, start + baseaddr)
3348 end = (gdbarch_adjust_dwarf2_addr (gdbarch, end + baseaddr)
3350 addrmap_set_empty (mutable_map, start, end - 1, per_cu);
3354 objfile->partial_symtabs->psymtabs_addrmap
3355 = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3358 /* Find a slot in the mapped index INDEX for the object named NAME.
3359 If NAME is found, set *VEC_OUT to point to the CU vector in the
3360 constant pool and return true. If NAME cannot be found, return
3364 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
3365 offset_type **vec_out)
3368 offset_type slot, step;
3369 int (*cmp) (const char *, const char *);
3371 gdb::unique_xmalloc_ptr<char> without_params;
3372 if (current_language->la_language == language_cplus
3373 || current_language->la_language == language_fortran
3374 || current_language->la_language == language_d)
3376 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3379 if (strchr (name, '(') != NULL)
3381 without_params = cp_remove_params (name);
3383 if (without_params != NULL)
3384 name = without_params.get ();
3388 /* Index version 4 did not support case insensitive searches. But the
3389 indices for case insensitive languages are built in lowercase, therefore
3390 simulate our NAME being searched is also lowercased. */
3391 hash = mapped_index_string_hash ((index->version == 4
3392 && case_sensitivity == case_sensitive_off
3393 ? 5 : index->version),
3396 slot = hash & (index->symbol_table.size () - 1);
3397 step = ((hash * 17) & (index->symbol_table.size () - 1)) | 1;
3398 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
3404 const auto &bucket = index->symbol_table[slot];
3405 if (bucket.name == 0 && bucket.vec == 0)
3408 str = index->constant_pool + MAYBE_SWAP (bucket.name);
3409 if (!cmp (name, str))
3411 *vec_out = (offset_type *) (index->constant_pool
3412 + MAYBE_SWAP (bucket.vec));
3416 slot = (slot + step) & (index->symbol_table.size () - 1);
3420 /* A helper function that reads the .gdb_index from BUFFER and fills
3421 in MAP. FILENAME is the name of the file containing the data;
3422 it is used for error reporting. DEPRECATED_OK is true if it is
3423 ok to use deprecated sections.
3425 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3426 out parameters that are filled in with information about the CU and
3427 TU lists in the section.
3429 Returns true if all went well, false otherwise. */
3432 read_gdb_index_from_buffer (struct objfile *objfile,
3433 const char *filename,
3435 gdb::array_view<const gdb_byte> buffer,
3436 struct mapped_index *map,
3437 const gdb_byte **cu_list,
3438 offset_type *cu_list_elements,
3439 const gdb_byte **types_list,
3440 offset_type *types_list_elements)
3442 const gdb_byte *addr = &buffer[0];
3444 /* Version check. */
3445 offset_type version = MAYBE_SWAP (*(offset_type *) addr);
3446 /* Versions earlier than 3 emitted every copy of a psymbol. This
3447 causes the index to behave very poorly for certain requests. Version 3
3448 contained incomplete addrmap. So, it seems better to just ignore such
3452 static int warning_printed = 0;
3453 if (!warning_printed)
3455 warning (_("Skipping obsolete .gdb_index section in %s."),
3457 warning_printed = 1;
3461 /* Index version 4 uses a different hash function than index version
3464 Versions earlier than 6 did not emit psymbols for inlined
3465 functions. Using these files will cause GDB not to be able to
3466 set breakpoints on inlined functions by name, so we ignore these
3467 indices unless the user has done
3468 "set use-deprecated-index-sections on". */
3469 if (version < 6 && !deprecated_ok)
3471 static int warning_printed = 0;
3472 if (!warning_printed)
3475 Skipping deprecated .gdb_index section in %s.\n\
3476 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3477 to use the section anyway."),
3479 warning_printed = 1;
3483 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3484 of the TU (for symbols coming from TUs),
3485 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3486 Plus gold-generated indices can have duplicate entries for global symbols,
3487 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3488 These are just performance bugs, and we can't distinguish gdb-generated
3489 indices from gold-generated ones, so issue no warning here. */
3491 /* Indexes with higher version than the one supported by GDB may be no
3492 longer backward compatible. */
3496 map->version = version;
3498 offset_type *metadata = (offset_type *) (addr + sizeof (offset_type));
3501 *cu_list = addr + MAYBE_SWAP (metadata[i]);
3502 *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3506 *types_list = addr + MAYBE_SWAP (metadata[i]);
3507 *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3508 - MAYBE_SWAP (metadata[i]))
3512 const gdb_byte *address_table = addr + MAYBE_SWAP (metadata[i]);
3513 const gdb_byte *address_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3515 = gdb::array_view<const gdb_byte> (address_table, address_table_end);
3518 const gdb_byte *symbol_table = addr + MAYBE_SWAP (metadata[i]);
3519 const gdb_byte *symbol_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3521 = gdb::array_view<mapped_index::symbol_table_slot>
3522 ((mapped_index::symbol_table_slot *) symbol_table,
3523 (mapped_index::symbol_table_slot *) symbol_table_end);
3526 map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3531 /* Callback types for dwarf2_read_gdb_index. */
3533 typedef gdb::function_view
3534 <gdb::array_view<const gdb_byte>(objfile *, dwarf2_per_objfile *)>
3535 get_gdb_index_contents_ftype;
3536 typedef gdb::function_view
3537 <gdb::array_view<const gdb_byte>(objfile *, dwz_file *)>
3538 get_gdb_index_contents_dwz_ftype;
3540 /* Read .gdb_index. If everything went ok, initialize the "quick"
3541 elements of all the CUs and return 1. Otherwise, return 0. */
3544 dwarf2_read_gdb_index
3545 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3546 get_gdb_index_contents_ftype get_gdb_index_contents,
3547 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz)
3549 const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3550 offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3551 struct dwz_file *dwz;
3552 struct objfile *objfile = dwarf2_per_objfile->objfile;
3554 gdb::array_view<const gdb_byte> main_index_contents
3555 = get_gdb_index_contents (objfile, dwarf2_per_objfile);
3557 if (main_index_contents.empty ())
3560 std::unique_ptr<struct mapped_index> map (new struct mapped_index);
3561 if (!read_gdb_index_from_buffer (objfile, objfile_name (objfile),
3562 use_deprecated_index_sections,
3563 main_index_contents, map.get (), &cu_list,
3564 &cu_list_elements, &types_list,
3565 &types_list_elements))
3568 /* Don't use the index if it's empty. */
3569 if (map->symbol_table.empty ())
3572 /* If there is a .dwz file, read it so we can get its CU list as
3574 dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3577 struct mapped_index dwz_map;
3578 const gdb_byte *dwz_types_ignore;
3579 offset_type dwz_types_elements_ignore;
3581 gdb::array_view<const gdb_byte> dwz_index_content
3582 = get_gdb_index_contents_dwz (objfile, dwz);
3584 if (dwz_index_content.empty ())
3587 if (!read_gdb_index_from_buffer (objfile,
3588 bfd_get_filename (dwz->dwz_bfd), 1,
3589 dwz_index_content, &dwz_map,
3590 &dwz_list, &dwz_list_elements,
3592 &dwz_types_elements_ignore))
3594 warning (_("could not read '.gdb_index' section from %s; skipping"),
3595 bfd_get_filename (dwz->dwz_bfd));
3600 create_cus_from_index (dwarf2_per_objfile, cu_list, cu_list_elements,
3601 dwz_list, dwz_list_elements);
3603 if (types_list_elements)
3605 struct dwarf2_section_info *section;
3607 /* We can only handle a single .debug_types when we have an
3609 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3612 section = VEC_index (dwarf2_section_info_def,
3613 dwarf2_per_objfile->types, 0);
3615 create_signatured_type_table_from_index (dwarf2_per_objfile, section,
3616 types_list, types_list_elements);
3619 create_addrmap_from_index (dwarf2_per_objfile, map.get ());
3621 dwarf2_per_objfile->index_table = std::move (map);
3622 dwarf2_per_objfile->using_index = 1;
3623 dwarf2_per_objfile->quick_file_names_table =
3624 create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
3629 /* die_reader_func for dw2_get_file_names. */
3632 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3633 const gdb_byte *info_ptr,
3634 struct die_info *comp_unit_die,
3638 struct dwarf2_cu *cu = reader->cu;
3639 struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3640 struct dwarf2_per_objfile *dwarf2_per_objfile
3641 = cu->per_cu->dwarf2_per_objfile;
3642 struct objfile *objfile = dwarf2_per_objfile->objfile;
3643 struct dwarf2_per_cu_data *lh_cu;
3644 struct attribute *attr;
3647 struct quick_file_names *qfn;
3649 gdb_assert (! this_cu->is_debug_types);
3651 /* Our callers never want to match partial units -- instead they
3652 will match the enclosing full CU. */
3653 if (comp_unit_die->tag == DW_TAG_partial_unit)
3655 this_cu->v.quick->no_file_data = 1;
3663 sect_offset line_offset {};
3665 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3668 struct quick_file_names find_entry;
3670 line_offset = (sect_offset) DW_UNSND (attr);
3672 /* We may have already read in this line header (TU line header sharing).
3673 If we have we're done. */
3674 find_entry.hash.dwo_unit = cu->dwo_unit;
3675 find_entry.hash.line_sect_off = line_offset;
3676 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3677 &find_entry, INSERT);
3680 lh_cu->v.quick->file_names = (struct quick_file_names *) *slot;
3684 lh = dwarf_decode_line_header (line_offset, cu);
3688 lh_cu->v.quick->no_file_data = 1;
3692 qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
3693 qfn->hash.dwo_unit = cu->dwo_unit;
3694 qfn->hash.line_sect_off = line_offset;
3695 gdb_assert (slot != NULL);
3698 file_and_directory fnd = find_file_and_directory (comp_unit_die, cu);
3700 qfn->num_file_names = lh->file_names.size ();
3702 XOBNEWVEC (&objfile->objfile_obstack, const char *, lh->file_names.size ());
3703 for (i = 0; i < lh->file_names.size (); ++i)
3704 qfn->file_names[i] = file_full_name (i + 1, lh.get (), fnd.comp_dir);
3705 qfn->real_names = NULL;
3707 lh_cu->v.quick->file_names = qfn;
3710 /* A helper for the "quick" functions which attempts to read the line
3711 table for THIS_CU. */
3713 static struct quick_file_names *
3714 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3716 /* This should never be called for TUs. */
3717 gdb_assert (! this_cu->is_debug_types);
3718 /* Nor type unit groups. */
3719 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3721 if (this_cu->v.quick->file_names != NULL)
3722 return this_cu->v.quick->file_names;
3723 /* If we know there is no line data, no point in looking again. */
3724 if (this_cu->v.quick->no_file_data)
3727 init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3729 if (this_cu->v.quick->no_file_data)
3731 return this_cu->v.quick->file_names;
3734 /* A helper for the "quick" functions which computes and caches the
3735 real path for a given file name from the line table. */
3738 dw2_get_real_path (struct objfile *objfile,
3739 struct quick_file_names *qfn, int index)
3741 if (qfn->real_names == NULL)
3742 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3743 qfn->num_file_names, const char *);
3745 if (qfn->real_names[index] == NULL)
3746 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]).release ();
3748 return qfn->real_names[index];
3751 static struct symtab *
3752 dw2_find_last_source_symtab (struct objfile *objfile)
3754 struct dwarf2_per_objfile *dwarf2_per_objfile
3755 = get_dwarf2_per_objfile (objfile);
3756 dwarf2_per_cu_data *dwarf_cu = dwarf2_per_objfile->all_comp_units.back ();
3757 compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu, false);
3762 return compunit_primary_filetab (cust);
3765 /* Traversal function for dw2_forget_cached_source_info. */
3768 dw2_free_cached_file_names (void **slot, void *info)
3770 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3772 if (file_data->real_names)
3776 for (i = 0; i < file_data->num_file_names; ++i)
3778 xfree ((void*) file_data->real_names[i]);
3779 file_data->real_names[i] = NULL;
3787 dw2_forget_cached_source_info (struct objfile *objfile)
3789 struct dwarf2_per_objfile *dwarf2_per_objfile
3790 = get_dwarf2_per_objfile (objfile);
3792 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3793 dw2_free_cached_file_names, NULL);
3796 /* Helper function for dw2_map_symtabs_matching_filename that expands
3797 the symtabs and calls the iterator. */
3800 dw2_map_expand_apply (struct objfile *objfile,
3801 struct dwarf2_per_cu_data *per_cu,
3802 const char *name, const char *real_path,
3803 gdb::function_view<bool (symtab *)> callback)
3805 struct compunit_symtab *last_made = objfile->compunit_symtabs;
3807 /* Don't visit already-expanded CUs. */
3808 if (per_cu->v.quick->compunit_symtab)
3811 /* This may expand more than one symtab, and we want to iterate over
3813 dw2_instantiate_symtab (per_cu, false);
3815 return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
3816 last_made, callback);
3819 /* Implementation of the map_symtabs_matching_filename method. */
3822 dw2_map_symtabs_matching_filename
3823 (struct objfile *objfile, const char *name, const char *real_path,
3824 gdb::function_view<bool (symtab *)> callback)
3826 const char *name_basename = lbasename (name);
3827 struct dwarf2_per_objfile *dwarf2_per_objfile
3828 = get_dwarf2_per_objfile (objfile);
3830 /* The rule is CUs specify all the files, including those used by
3831 any TU, so there's no need to scan TUs here. */
3833 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3835 /* We only need to look at symtabs not already expanded. */
3836 if (per_cu->v.quick->compunit_symtab)
3839 quick_file_names *file_data = dw2_get_file_names (per_cu);
3840 if (file_data == NULL)
3843 for (int j = 0; j < file_data->num_file_names; ++j)
3845 const char *this_name = file_data->file_names[j];
3846 const char *this_real_name;
3848 if (compare_filenames_for_search (this_name, name))
3850 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3856 /* Before we invoke realpath, which can get expensive when many
3857 files are involved, do a quick comparison of the basenames. */
3858 if (! basenames_may_differ
3859 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3862 this_real_name = dw2_get_real_path (objfile, file_data, j);
3863 if (compare_filenames_for_search (this_real_name, name))
3865 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3871 if (real_path != NULL)
3873 gdb_assert (IS_ABSOLUTE_PATH (real_path));
3874 gdb_assert (IS_ABSOLUTE_PATH (name));
3875 if (this_real_name != NULL
3876 && FILENAME_CMP (real_path, this_real_name) == 0)
3878 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3890 /* Struct used to manage iterating over all CUs looking for a symbol. */
3892 struct dw2_symtab_iterator
3894 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3895 struct dwarf2_per_objfile *dwarf2_per_objfile;
3896 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3897 int want_specific_block;
3898 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3899 Unused if !WANT_SPECIFIC_BLOCK. */
3901 /* The kind of symbol we're looking for. */
3903 /* The list of CUs from the index entry of the symbol,
3904 or NULL if not found. */
3906 /* The next element in VEC to look at. */
3908 /* The number of elements in VEC, or zero if there is no match. */
3910 /* Have we seen a global version of the symbol?
3911 If so we can ignore all further global instances.
3912 This is to work around gold/15646, inefficient gold-generated
3917 /* Initialize the index symtab iterator ITER.
3918 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3919 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3922 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3923 struct dwarf2_per_objfile *dwarf2_per_objfile,
3924 int want_specific_block,
3929 iter->dwarf2_per_objfile = dwarf2_per_objfile;
3930 iter->want_specific_block = want_specific_block;
3931 iter->block_index = block_index;
3932 iter->domain = domain;
3934 iter->global_seen = 0;
3936 mapped_index *index = dwarf2_per_objfile->index_table.get ();
3938 /* index is NULL if OBJF_READNOW. */
3939 if (index != NULL && find_slot_in_mapped_hash (index, name, &iter->vec))
3940 iter->length = MAYBE_SWAP (*iter->vec);
3948 /* Return the next matching CU or NULL if there are no more. */
3950 static struct dwarf2_per_cu_data *
3951 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
3953 struct dwarf2_per_objfile *dwarf2_per_objfile = iter->dwarf2_per_objfile;
3955 for ( ; iter->next < iter->length; ++iter->next)
3957 offset_type cu_index_and_attrs =
3958 MAYBE_SWAP (iter->vec[iter->next + 1]);
3959 offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3960 int want_static = iter->block_index != GLOBAL_BLOCK;
3961 /* This value is only valid for index versions >= 7. */
3962 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3963 gdb_index_symbol_kind symbol_kind =
3964 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3965 /* Only check the symbol attributes if they're present.
3966 Indices prior to version 7 don't record them,
3967 and indices >= 7 may elide them for certain symbols
3968 (gold does this). */
3970 (dwarf2_per_objfile->index_table->version >= 7
3971 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3973 /* Don't crash on bad data. */
3974 if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
3975 + dwarf2_per_objfile->all_type_units.size ()))
3977 complaint (_(".gdb_index entry has bad CU index"
3979 objfile_name (dwarf2_per_objfile->objfile));
3983 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
3985 /* Skip if already read in. */
3986 if (per_cu->v.quick->compunit_symtab)
3989 /* Check static vs global. */
3992 if (iter->want_specific_block
3993 && want_static != is_static)
3995 /* Work around gold/15646. */
3996 if (!is_static && iter->global_seen)
3999 iter->global_seen = 1;
4002 /* Only check the symbol's kind if it has one. */
4005 switch (iter->domain)
4008 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
4009 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
4010 /* Some types are also in VAR_DOMAIN. */
4011 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4015 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4019 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
4034 static struct compunit_symtab *
4035 dw2_lookup_symbol (struct objfile *objfile, int block_index,
4036 const char *name, domain_enum domain)
4038 struct compunit_symtab *stab_best = NULL;
4039 struct dwarf2_per_objfile *dwarf2_per_objfile
4040 = get_dwarf2_per_objfile (objfile);
4042 lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
4044 struct dw2_symtab_iterator iter;
4045 struct dwarf2_per_cu_data *per_cu;
4047 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 1, block_index, domain, name);
4049 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4051 struct symbol *sym, *with_opaque = NULL;
4052 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
4053 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
4054 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
4056 sym = block_find_symbol (block, name, domain,
4057 block_find_non_opaque_type_preferred,
4060 /* Some caution must be observed with overloaded functions
4061 and methods, since the index will not contain any overload
4062 information (but NAME might contain it). */
4065 && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
4067 if (with_opaque != NULL
4068 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
4071 /* Keep looking through other CUs. */
4078 dw2_print_stats (struct objfile *objfile)
4080 struct dwarf2_per_objfile *dwarf2_per_objfile
4081 = get_dwarf2_per_objfile (objfile);
4082 int total = (dwarf2_per_objfile->all_comp_units.size ()
4083 + dwarf2_per_objfile->all_type_units.size ());
4086 for (int i = 0; i < total; ++i)
4088 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4090 if (!per_cu->v.quick->compunit_symtab)
4093 printf_filtered (_(" Number of read CUs: %d\n"), total - count);
4094 printf_filtered (_(" Number of unread CUs: %d\n"), count);
4097 /* This dumps minimal information about the index.
4098 It is called via "mt print objfiles".
4099 One use is to verify .gdb_index has been loaded by the
4100 gdb.dwarf2/gdb-index.exp testcase. */
4103 dw2_dump (struct objfile *objfile)
4105 struct dwarf2_per_objfile *dwarf2_per_objfile
4106 = get_dwarf2_per_objfile (objfile);
4108 gdb_assert (dwarf2_per_objfile->using_index);
4109 printf_filtered (".gdb_index:");
4110 if (dwarf2_per_objfile->index_table != NULL)
4112 printf_filtered (" version %d\n",
4113 dwarf2_per_objfile->index_table->version);
4116 printf_filtered (" faked for \"readnow\"\n");
4117 printf_filtered ("\n");
4121 dw2_expand_symtabs_for_function (struct objfile *objfile,
4122 const char *func_name)
4124 struct dwarf2_per_objfile *dwarf2_per_objfile
4125 = get_dwarf2_per_objfile (objfile);
4127 struct dw2_symtab_iterator iter;
4128 struct dwarf2_per_cu_data *per_cu;
4130 /* Note: It doesn't matter what we pass for block_index here. */
4131 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 0, GLOBAL_BLOCK, VAR_DOMAIN,
4134 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4135 dw2_instantiate_symtab (per_cu, false);
4140 dw2_expand_all_symtabs (struct objfile *objfile)
4142 struct dwarf2_per_objfile *dwarf2_per_objfile
4143 = get_dwarf2_per_objfile (objfile);
4144 int total_units = (dwarf2_per_objfile->all_comp_units.size ()
4145 + dwarf2_per_objfile->all_type_units.size ());
4147 for (int i = 0; i < total_units; ++i)
4149 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4151 /* We don't want to directly expand a partial CU, because if we
4152 read it with the wrong language, then assertion failures can
4153 be triggered later on. See PR symtab/23010. So, tell
4154 dw2_instantiate_symtab to skip partial CUs -- any important
4155 partial CU will be read via DW_TAG_imported_unit anyway. */
4156 dw2_instantiate_symtab (per_cu, true);
4161 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
4162 const char *fullname)
4164 struct dwarf2_per_objfile *dwarf2_per_objfile
4165 = get_dwarf2_per_objfile (objfile);
4167 /* We don't need to consider type units here.
4168 This is only called for examining code, e.g. expand_line_sal.
4169 There can be an order of magnitude (or more) more type units
4170 than comp units, and we avoid them if we can. */
4172 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
4174 /* We only need to look at symtabs not already expanded. */
4175 if (per_cu->v.quick->compunit_symtab)
4178 quick_file_names *file_data = dw2_get_file_names (per_cu);
4179 if (file_data == NULL)
4182 for (int j = 0; j < file_data->num_file_names; ++j)
4184 const char *this_fullname = file_data->file_names[j];
4186 if (filename_cmp (this_fullname, fullname) == 0)
4188 dw2_instantiate_symtab (per_cu, false);
4196 dw2_map_matching_symbols (struct objfile *objfile,
4197 const char * name, domain_enum domain,
4199 int (*callback) (struct block *,
4200 struct symbol *, void *),
4201 void *data, symbol_name_match_type match,
4202 symbol_compare_ftype *ordered_compare)
4204 /* Currently unimplemented; used for Ada. The function can be called if the
4205 current language is Ada for a non-Ada objfile using GNU index. As Ada
4206 does not look for non-Ada symbols this function should just return. */
4209 /* Symbol name matcher for .gdb_index names.
4211 Symbol names in .gdb_index have a few particularities:
4213 - There's no indication of which is the language of each symbol.
4215 Since each language has its own symbol name matching algorithm,
4216 and we don't know which language is the right one, we must match
4217 each symbol against all languages. This would be a potential
4218 performance problem if it were not mitigated by the
4219 mapped_index::name_components lookup table, which significantly
4220 reduces the number of times we need to call into this matcher,
4221 making it a non-issue.
4223 - Symbol names in the index have no overload (parameter)
4224 information. I.e., in C++, "foo(int)" and "foo(long)" both
4225 appear as "foo" in the index, for example.
4227 This means that the lookup names passed to the symbol name
4228 matcher functions must have no parameter information either
4229 because (e.g.) symbol search name "foo" does not match
4230 lookup-name "foo(int)" [while swapping search name for lookup
4233 class gdb_index_symbol_name_matcher
4236 /* Prepares the vector of comparison functions for LOOKUP_NAME. */
4237 gdb_index_symbol_name_matcher (const lookup_name_info &lookup_name);
4239 /* Walk all the matcher routines and match SYMBOL_NAME against them.
4240 Returns true if any matcher matches. */
4241 bool matches (const char *symbol_name);
4244 /* A reference to the lookup name we're matching against. */
4245 const lookup_name_info &m_lookup_name;
4247 /* A vector holding all the different symbol name matchers, for all
4249 std::vector<symbol_name_matcher_ftype *> m_symbol_name_matcher_funcs;
4252 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4253 (const lookup_name_info &lookup_name)
4254 : m_lookup_name (lookup_name)
4256 /* Prepare the vector of comparison functions upfront, to avoid
4257 doing the same work for each symbol. Care is taken to avoid
4258 matching with the same matcher more than once if/when multiple
4259 languages use the same matcher function. */
4260 auto &matchers = m_symbol_name_matcher_funcs;
4261 matchers.reserve (nr_languages);
4263 matchers.push_back (default_symbol_name_matcher);
4265 for (int i = 0; i < nr_languages; i++)
4267 const language_defn *lang = language_def ((enum language) i);
4268 symbol_name_matcher_ftype *name_matcher
4269 = get_symbol_name_matcher (lang, m_lookup_name);
4271 /* Don't insert the same comparison routine more than once.
4272 Note that we do this linear walk instead of a seemingly
4273 cheaper sorted insert, or use a std::set or something like
4274 that, because relative order of function addresses is not
4275 stable. This is not a problem in practice because the number
4276 of supported languages is low, and the cost here is tiny
4277 compared to the number of searches we'll do afterwards using
4279 if (name_matcher != default_symbol_name_matcher
4280 && (std::find (matchers.begin (), matchers.end (), name_matcher)
4281 == matchers.end ()))
4282 matchers.push_back (name_matcher);
4287 gdb_index_symbol_name_matcher::matches (const char *symbol_name)
4289 for (auto matches_name : m_symbol_name_matcher_funcs)
4290 if (matches_name (symbol_name, m_lookup_name, NULL))
4296 /* Starting from a search name, return the string that finds the upper
4297 bound of all strings that start with SEARCH_NAME in a sorted name
4298 list. Returns the empty string to indicate that the upper bound is
4299 the end of the list. */
4302 make_sort_after_prefix_name (const char *search_name)
4304 /* When looking to complete "func", we find the upper bound of all
4305 symbols that start with "func" by looking for where we'd insert
4306 the closest string that would follow "func" in lexicographical
4307 order. Usually, that's "func"-with-last-character-incremented,
4308 i.e. "fund". Mind non-ASCII characters, though. Usually those
4309 will be UTF-8 multi-byte sequences, but we can't be certain.
4310 Especially mind the 0xff character, which is a valid character in
4311 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4312 rule out compilers allowing it in identifiers. Note that
4313 conveniently, strcmp/strcasecmp are specified to compare
4314 characters interpreted as unsigned char. So what we do is treat
4315 the whole string as a base 256 number composed of a sequence of
4316 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4317 to 0, and carries 1 to the following more-significant position.
4318 If the very first character in SEARCH_NAME ends up incremented
4319 and carries/overflows, then the upper bound is the end of the
4320 list. The string after the empty string is also the empty
4323 Some examples of this operation:
4325 SEARCH_NAME => "+1" RESULT
4329 "\xff" "a" "\xff" => "\xff" "b"
4334 Then, with these symbols for example:
4340 completing "func" looks for symbols between "func" and
4341 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4342 which finds "func" and "func1", but not "fund".
4346 funcÿ (Latin1 'ÿ' [0xff])
4350 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4351 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4355 ÿÿ (Latin1 'ÿ' [0xff])
4358 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4359 the end of the list.
4361 std::string after = search_name;
4362 while (!after.empty () && (unsigned char) after.back () == 0xff)
4364 if (!after.empty ())
4365 after.back () = (unsigned char) after.back () + 1;
4369 /* See declaration. */
4371 std::pair<std::vector<name_component>::const_iterator,
4372 std::vector<name_component>::const_iterator>
4373 mapped_index_base::find_name_components_bounds
4374 (const lookup_name_info &lookup_name_without_params) const
4377 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4380 = lookup_name_without_params.cplus ().lookup_name ().c_str ();
4382 /* Comparison function object for lower_bound that matches against a
4383 given symbol name. */
4384 auto lookup_compare_lower = [&] (const name_component &elem,
4387 const char *elem_qualified = this->symbol_name_at (elem.idx);
4388 const char *elem_name = elem_qualified + elem.name_offset;
4389 return name_cmp (elem_name, name) < 0;
4392 /* Comparison function object for upper_bound that matches against a
4393 given symbol name. */
4394 auto lookup_compare_upper = [&] (const char *name,
4395 const name_component &elem)
4397 const char *elem_qualified = this->symbol_name_at (elem.idx);
4398 const char *elem_name = elem_qualified + elem.name_offset;
4399 return name_cmp (name, elem_name) < 0;
4402 auto begin = this->name_components.begin ();
4403 auto end = this->name_components.end ();
4405 /* Find the lower bound. */
4408 if (lookup_name_without_params.completion_mode () && cplus[0] == '\0')
4411 return std::lower_bound (begin, end, cplus, lookup_compare_lower);
4414 /* Find the upper bound. */
4417 if (lookup_name_without_params.completion_mode ())
4419 /* In completion mode, we want UPPER to point past all
4420 symbols names that have the same prefix. I.e., with
4421 these symbols, and completing "func":
4423 function << lower bound
4425 other_function << upper bound
4427 We find the upper bound by looking for the insertion
4428 point of "func"-with-last-character-incremented,
4430 std::string after = make_sort_after_prefix_name (cplus);
4433 return std::lower_bound (lower, end, after.c_str (),
4434 lookup_compare_lower);
4437 return std::upper_bound (lower, end, cplus, lookup_compare_upper);
4440 return {lower, upper};
4443 /* See declaration. */
4446 mapped_index_base::build_name_components ()
4448 if (!this->name_components.empty ())
4451 this->name_components_casing = case_sensitivity;
4453 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4455 /* The code below only knows how to break apart components of C++
4456 symbol names (and other languages that use '::' as
4457 namespace/module separator). If we add support for wild matching
4458 to some language that uses some other operator (E.g., Ada, Go and
4459 D use '.'), then we'll need to try splitting the symbol name
4460 according to that language too. Note that Ada does support wild
4461 matching, but doesn't currently support .gdb_index. */
4462 auto count = this->symbol_name_count ();
4463 for (offset_type idx = 0; idx < count; idx++)
4465 if (this->symbol_name_slot_invalid (idx))
4468 const char *name = this->symbol_name_at (idx);
4470 /* Add each name component to the name component table. */
4471 unsigned int previous_len = 0;
4472 for (unsigned int current_len = cp_find_first_component (name);
4473 name[current_len] != '\0';
4474 current_len += cp_find_first_component (name + current_len))
4476 gdb_assert (name[current_len] == ':');
4477 this->name_components.push_back ({previous_len, idx});
4478 /* Skip the '::'. */
4480 previous_len = current_len;
4482 this->name_components.push_back ({previous_len, idx});
4485 /* Sort name_components elements by name. */
4486 auto name_comp_compare = [&] (const name_component &left,
4487 const name_component &right)
4489 const char *left_qualified = this->symbol_name_at (left.idx);
4490 const char *right_qualified = this->symbol_name_at (right.idx);
4492 const char *left_name = left_qualified + left.name_offset;
4493 const char *right_name = right_qualified + right.name_offset;
4495 return name_cmp (left_name, right_name) < 0;
4498 std::sort (this->name_components.begin (),
4499 this->name_components.end (),
4503 /* Helper for dw2_expand_symtabs_matching that works with a
4504 mapped_index_base instead of the containing objfile. This is split
4505 to a separate function in order to be able to unit test the
4506 name_components matching using a mock mapped_index_base. For each
4507 symbol name that matches, calls MATCH_CALLBACK, passing it the
4508 symbol's index in the mapped_index_base symbol table. */
4511 dw2_expand_symtabs_matching_symbol
4512 (mapped_index_base &index,
4513 const lookup_name_info &lookup_name_in,
4514 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
4515 enum search_domain kind,
4516 gdb::function_view<void (offset_type)> match_callback)
4518 lookup_name_info lookup_name_without_params
4519 = lookup_name_in.make_ignore_params ();
4520 gdb_index_symbol_name_matcher lookup_name_matcher
4521 (lookup_name_without_params);
4523 /* Build the symbol name component sorted vector, if we haven't
4525 index.build_name_components ();
4527 auto bounds = index.find_name_components_bounds (lookup_name_without_params);
4529 /* Now for each symbol name in range, check to see if we have a name
4530 match, and if so, call the MATCH_CALLBACK callback. */
4532 /* The same symbol may appear more than once in the range though.
4533 E.g., if we're looking for symbols that complete "w", and we have
4534 a symbol named "w1::w2", we'll find the two name components for
4535 that same symbol in the range. To be sure we only call the
4536 callback once per symbol, we first collect the symbol name
4537 indexes that matched in a temporary vector and ignore
4539 std::vector<offset_type> matches;
4540 matches.reserve (std::distance (bounds.first, bounds.second));
4542 for (; bounds.first != bounds.second; ++bounds.first)
4544 const char *qualified = index.symbol_name_at (bounds.first->idx);
4546 if (!lookup_name_matcher.matches (qualified)
4547 || (symbol_matcher != NULL && !symbol_matcher (qualified)))
4550 matches.push_back (bounds.first->idx);
4553 std::sort (matches.begin (), matches.end ());
4555 /* Finally call the callback, once per match. */
4557 for (offset_type idx : matches)
4561 match_callback (idx);
4566 /* Above we use a type wider than idx's for 'prev', since 0 and
4567 (offset_type)-1 are both possible values. */
4568 static_assert (sizeof (prev) > sizeof (offset_type), "");
4573 namespace selftests { namespace dw2_expand_symtabs_matching {
4575 /* A mock .gdb_index/.debug_names-like name index table, enough to
4576 exercise dw2_expand_symtabs_matching_symbol, which works with the
4577 mapped_index_base interface. Builds an index from the symbol list
4578 passed as parameter to the constructor. */
4579 class mock_mapped_index : public mapped_index_base
4582 mock_mapped_index (gdb::array_view<const char *> symbols)
4583 : m_symbol_table (symbols)
4586 DISABLE_COPY_AND_ASSIGN (mock_mapped_index);
4588 /* Return the number of names in the symbol table. */
4589 size_t symbol_name_count () const override
4591 return m_symbol_table.size ();
4594 /* Get the name of the symbol at IDX in the symbol table. */
4595 const char *symbol_name_at (offset_type idx) const override
4597 return m_symbol_table[idx];
4601 gdb::array_view<const char *> m_symbol_table;
4604 /* Convenience function that converts a NULL pointer to a "<null>"
4605 string, to pass to print routines. */
4608 string_or_null (const char *str)
4610 return str != NULL ? str : "<null>";
4613 /* Check if a lookup_name_info built from
4614 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4615 index. EXPECTED_LIST is the list of expected matches, in expected
4616 matching order. If no match expected, then an empty list is
4617 specified. Returns true on success. On failure prints a warning
4618 indicating the file:line that failed, and returns false. */
4621 check_match (const char *file, int line,
4622 mock_mapped_index &mock_index,
4623 const char *name, symbol_name_match_type match_type,
4624 bool completion_mode,
4625 std::initializer_list<const char *> expected_list)
4627 lookup_name_info lookup_name (name, match_type, completion_mode);
4629 bool matched = true;
4631 auto mismatch = [&] (const char *expected_str,
4634 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4635 "expected=\"%s\", got=\"%s\"\n"),
4637 (match_type == symbol_name_match_type::FULL
4639 name, string_or_null (expected_str), string_or_null (got));
4643 auto expected_it = expected_list.begin ();
4644 auto expected_end = expected_list.end ();
4646 dw2_expand_symtabs_matching_symbol (mock_index, lookup_name,
4648 [&] (offset_type idx)
4650 const char *matched_name = mock_index.symbol_name_at (idx);
4651 const char *expected_str
4652 = expected_it == expected_end ? NULL : *expected_it++;
4654 if (expected_str == NULL || strcmp (expected_str, matched_name) != 0)
4655 mismatch (expected_str, matched_name);
4658 const char *expected_str
4659 = expected_it == expected_end ? NULL : *expected_it++;
4660 if (expected_str != NULL)
4661 mismatch (expected_str, NULL);
4666 /* The symbols added to the mock mapped_index for testing (in
4668 static const char *test_symbols[] = {
4677 "ns2::tmpl<int>::foo2",
4678 "(anonymous namespace)::A::B::C",
4680 /* These are used to check that the increment-last-char in the
4681 matching algorithm for completion doesn't match "t1_fund" when
4682 completing "t1_func". */
4688 /* A UTF-8 name with multi-byte sequences to make sure that
4689 cp-name-parser understands this as a single identifier ("função"
4690 is "function" in PT). */
4693 /* \377 (0xff) is Latin1 'ÿ'. */
4696 /* \377 (0xff) is Latin1 'ÿ'. */
4700 /* A name with all sorts of complications. Starts with "z" to make
4701 it easier for the completion tests below. */
4702 #define Z_SYM_NAME \
4703 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4704 "::tuple<(anonymous namespace)::ui*, " \
4705 "std::default_delete<(anonymous namespace)::ui>, void>"
4710 /* Returns true if the mapped_index_base::find_name_component_bounds
4711 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4712 in completion mode. */
4715 check_find_bounds_finds (mapped_index_base &index,
4716 const char *search_name,
4717 gdb::array_view<const char *> expected_syms)
4719 lookup_name_info lookup_name (search_name,
4720 symbol_name_match_type::FULL, true);
4722 auto bounds = index.find_name_components_bounds (lookup_name);
4724 size_t distance = std::distance (bounds.first, bounds.second);
4725 if (distance != expected_syms.size ())
4728 for (size_t exp_elem = 0; exp_elem < distance; exp_elem++)
4730 auto nc_elem = bounds.first + exp_elem;
4731 const char *qualified = index.symbol_name_at (nc_elem->idx);
4732 if (strcmp (qualified, expected_syms[exp_elem]) != 0)
4739 /* Test the lower-level mapped_index::find_name_component_bounds
4743 test_mapped_index_find_name_component_bounds ()
4745 mock_mapped_index mock_index (test_symbols);
4747 mock_index.build_name_components ();
4749 /* Test the lower-level mapped_index::find_name_component_bounds
4750 method in completion mode. */
4752 static const char *expected_syms[] = {
4757 SELF_CHECK (check_find_bounds_finds (mock_index,
4758 "t1_func", expected_syms));
4761 /* Check that the increment-last-char in the name matching algorithm
4762 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4764 static const char *expected_syms1[] = {
4768 SELF_CHECK (check_find_bounds_finds (mock_index,
4769 "\377", expected_syms1));
4771 static const char *expected_syms2[] = {
4774 SELF_CHECK (check_find_bounds_finds (mock_index,
4775 "\377\377", expected_syms2));
4779 /* Test dw2_expand_symtabs_matching_symbol. */
4782 test_dw2_expand_symtabs_matching_symbol ()
4784 mock_mapped_index mock_index (test_symbols);
4786 /* We let all tests run until the end even if some fails, for debug
4788 bool any_mismatch = false;
4790 /* Create the expected symbols list (an initializer_list). Needed
4791 because lists have commas, and we need to pass them to CHECK,
4792 which is a macro. */
4793 #define EXPECT(...) { __VA_ARGS__ }
4795 /* Wrapper for check_match that passes down the current
4796 __FILE__/__LINE__. */
4797 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4798 any_mismatch |= !check_match (__FILE__, __LINE__, \
4800 NAME, MATCH_TYPE, COMPLETION_MODE, \
4803 /* Identity checks. */
4804 for (const char *sym : test_symbols)
4806 /* Should be able to match all existing symbols. */
4807 CHECK_MATCH (sym, symbol_name_match_type::FULL, false,
4810 /* Should be able to match all existing symbols with
4812 std::string with_params = std::string (sym) + "(int)";
4813 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4816 /* Should be able to match all existing symbols with
4817 parameters and qualifiers. */
4818 with_params = std::string (sym) + " ( int ) const";
4819 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4822 /* This should really find sym, but cp-name-parser.y doesn't
4823 know about lvalue/rvalue qualifiers yet. */
4824 with_params = std::string (sym) + " ( int ) &&";
4825 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4829 /* Check that the name matching algorithm for completion doesn't get
4830 confused with Latin1 'ÿ' / 0xff. */
4832 static const char str[] = "\377";
4833 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4834 EXPECT ("\377", "\377\377123"));
4837 /* Check that the increment-last-char in the matching algorithm for
4838 completion doesn't match "t1_fund" when completing "t1_func". */
4840 static const char str[] = "t1_func";
4841 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4842 EXPECT ("t1_func", "t1_func1"));
4845 /* Check that completion mode works at each prefix of the expected
4848 static const char str[] = "function(int)";
4849 size_t len = strlen (str);
4852 for (size_t i = 1; i < len; i++)
4854 lookup.assign (str, i);
4855 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4856 EXPECT ("function"));
4860 /* While "w" is a prefix of both components, the match function
4861 should still only be called once. */
4863 CHECK_MATCH ("w", symbol_name_match_type::FULL, true,
4865 CHECK_MATCH ("w", symbol_name_match_type::WILD, true,
4869 /* Same, with a "complicated" symbol. */
4871 static const char str[] = Z_SYM_NAME;
4872 size_t len = strlen (str);
4875 for (size_t i = 1; i < len; i++)
4877 lookup.assign (str, i);
4878 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4879 EXPECT (Z_SYM_NAME));
4883 /* In FULL mode, an incomplete symbol doesn't match. */
4885 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL, false,
4889 /* A complete symbol with parameters matches any overload, since the
4890 index has no overload info. */
4892 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL, true,
4893 EXPECT ("std::zfunction", "std::zfunction2"));
4894 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD, true,
4895 EXPECT ("std::zfunction", "std::zfunction2"));
4896 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD, true,
4897 EXPECT ("std::zfunction", "std::zfunction2"));
4900 /* Check that whitespace is ignored appropriately. A symbol with a
4901 template argument list. */
4903 static const char expected[] = "ns::foo<int>";
4904 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL, false,
4906 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD, false,
4910 /* Check that whitespace is ignored appropriately. A symbol with a
4911 template argument list that includes a pointer. */
4913 static const char expected[] = "ns::foo<char*>";
4914 /* Try both completion and non-completion modes. */
4915 static const bool completion_mode[2] = {false, true};
4916 for (size_t i = 0; i < 2; i++)
4918 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL,
4919 completion_mode[i], EXPECT (expected));
4920 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD,
4921 completion_mode[i], EXPECT (expected));
4923 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL,
4924 completion_mode[i], EXPECT (expected));
4925 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD,
4926 completion_mode[i], EXPECT (expected));
4931 /* Check method qualifiers are ignored. */
4932 static const char expected[] = "ns::foo<char*>";
4933 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4934 symbol_name_match_type::FULL, true, EXPECT (expected));
4935 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4936 symbol_name_match_type::FULL, true, EXPECT (expected));
4937 CHECK_MATCH ("foo < char * > ( int ) const",
4938 symbol_name_match_type::WILD, true, EXPECT (expected));
4939 CHECK_MATCH ("foo < char * > ( int ) &&",
4940 symbol_name_match_type::WILD, true, EXPECT (expected));
4943 /* Test lookup names that don't match anything. */
4945 CHECK_MATCH ("bar2", symbol_name_match_type::WILD, false,
4948 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL, false,
4952 /* Some wild matching tests, exercising "(anonymous namespace)",
4953 which should not be confused with a parameter list. */
4955 static const char *syms[] = {
4959 "A :: B :: C ( int )",
4964 for (const char *s : syms)
4966 CHECK_MATCH (s, symbol_name_match_type::WILD, false,
4967 EXPECT ("(anonymous namespace)::A::B::C"));
4972 static const char expected[] = "ns2::tmpl<int>::foo2";
4973 CHECK_MATCH ("tmp", symbol_name_match_type::WILD, true,
4975 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD, true,
4979 SELF_CHECK (!any_mismatch);
4988 test_mapped_index_find_name_component_bounds ();
4989 test_dw2_expand_symtabs_matching_symbol ();
4992 }} // namespace selftests::dw2_expand_symtabs_matching
4994 #endif /* GDB_SELF_TEST */
4996 /* If FILE_MATCHER is NULL or if PER_CU has
4997 dwarf2_per_cu_quick_data::MARK set (see
4998 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4999 EXPANSION_NOTIFY on it. */
5002 dw2_expand_symtabs_matching_one
5003 (struct dwarf2_per_cu_data *per_cu,
5004 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5005 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify)
5007 if (file_matcher == NULL || per_cu->v.quick->mark)
5009 bool symtab_was_null
5010 = (per_cu->v.quick->compunit_symtab == NULL);
5012 dw2_instantiate_symtab (per_cu, false);
5014 if (expansion_notify != NULL
5016 && per_cu->v.quick->compunit_symtab != NULL)
5017 expansion_notify (per_cu->v.quick->compunit_symtab);
5021 /* Helper for dw2_expand_matching symtabs. Called on each symbol
5022 matched, to expand corresponding CUs that were marked. IDX is the
5023 index of the symbol name that matched. */
5026 dw2_expand_marked_cus
5027 (struct dwarf2_per_objfile *dwarf2_per_objfile, offset_type idx,
5028 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5029 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5032 offset_type *vec, vec_len, vec_idx;
5033 bool global_seen = false;
5034 mapped_index &index = *dwarf2_per_objfile->index_table;
5036 vec = (offset_type *) (index.constant_pool
5037 + MAYBE_SWAP (index.symbol_table[idx].vec));
5038 vec_len = MAYBE_SWAP (vec[0]);
5039 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
5041 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
5042 /* This value is only valid for index versions >= 7. */
5043 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
5044 gdb_index_symbol_kind symbol_kind =
5045 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
5046 int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
5047 /* Only check the symbol attributes if they're present.
5048 Indices prior to version 7 don't record them,
5049 and indices >= 7 may elide them for certain symbols
5050 (gold does this). */
5053 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
5055 /* Work around gold/15646. */
5058 if (!is_static && global_seen)
5064 /* Only check the symbol's kind if it has one. */
5069 case VARIABLES_DOMAIN:
5070 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
5073 case FUNCTIONS_DOMAIN:
5074 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
5078 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
5086 /* Don't crash on bad data. */
5087 if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
5088 + dwarf2_per_objfile->all_type_units.size ()))
5090 complaint (_(".gdb_index entry has bad CU index"
5092 objfile_name (dwarf2_per_objfile->objfile));
5096 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
5097 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
5102 /* If FILE_MATCHER is non-NULL, set all the
5103 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5104 that match FILE_MATCHER. */
5107 dw_expand_symtabs_matching_file_matcher
5108 (struct dwarf2_per_objfile *dwarf2_per_objfile,
5109 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher)
5111 if (file_matcher == NULL)
5114 objfile *const objfile = dwarf2_per_objfile->objfile;
5116 htab_up visited_found (htab_create_alloc (10, htab_hash_pointer,
5118 NULL, xcalloc, xfree));
5119 htab_up visited_not_found (htab_create_alloc (10, htab_hash_pointer,
5121 NULL, xcalloc, xfree));
5123 /* The rule is CUs specify all the files, including those used by
5124 any TU, so there's no need to scan TUs here. */
5126 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5130 per_cu->v.quick->mark = 0;
5132 /* We only need to look at symtabs not already expanded. */
5133 if (per_cu->v.quick->compunit_symtab)
5136 quick_file_names *file_data = dw2_get_file_names (per_cu);
5137 if (file_data == NULL)
5140 if (htab_find (visited_not_found.get (), file_data) != NULL)
5142 else if (htab_find (visited_found.get (), file_data) != NULL)
5144 per_cu->v.quick->mark = 1;
5148 for (int j = 0; j < file_data->num_file_names; ++j)
5150 const char *this_real_name;
5152 if (file_matcher (file_data->file_names[j], false))
5154 per_cu->v.quick->mark = 1;
5158 /* Before we invoke realpath, which can get expensive when many
5159 files are involved, do a quick comparison of the basenames. */
5160 if (!basenames_may_differ
5161 && !file_matcher (lbasename (file_data->file_names[j]),
5165 this_real_name = dw2_get_real_path (objfile, file_data, j);
5166 if (file_matcher (this_real_name, false))
5168 per_cu->v.quick->mark = 1;
5173 void **slot = htab_find_slot (per_cu->v.quick->mark
5174 ? visited_found.get ()
5175 : visited_not_found.get (),
5182 dw2_expand_symtabs_matching
5183 (struct objfile *objfile,
5184 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5185 const lookup_name_info &lookup_name,
5186 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
5187 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5188 enum search_domain kind)
5190 struct dwarf2_per_objfile *dwarf2_per_objfile
5191 = get_dwarf2_per_objfile (objfile);
5193 /* index_table is NULL if OBJF_READNOW. */
5194 if (!dwarf2_per_objfile->index_table)
5197 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
5199 mapped_index &index = *dwarf2_per_objfile->index_table;
5201 dw2_expand_symtabs_matching_symbol (index, lookup_name,
5203 kind, [&] (offset_type idx)
5205 dw2_expand_marked_cus (dwarf2_per_objfile, idx, file_matcher,
5206 expansion_notify, kind);
5210 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5213 static struct compunit_symtab *
5214 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab *cust,
5219 if (COMPUNIT_BLOCKVECTOR (cust) != NULL
5220 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust), pc))
5223 if (cust->includes == NULL)
5226 for (i = 0; cust->includes[i]; ++i)
5228 struct compunit_symtab *s = cust->includes[i];
5230 s = recursively_find_pc_sect_compunit_symtab (s, pc);
5238 static struct compunit_symtab *
5239 dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
5240 struct bound_minimal_symbol msymbol,
5242 struct obj_section *section,
5245 struct dwarf2_per_cu_data *data;
5246 struct compunit_symtab *result;
5248 if (!objfile->partial_symtabs->psymtabs_addrmap)
5251 CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
5252 SECT_OFF_TEXT (objfile));
5253 data = (struct dwarf2_per_cu_data *) addrmap_find
5254 (objfile->partial_symtabs->psymtabs_addrmap, pc - baseaddr);
5258 if (warn_if_readin && data->v.quick->compunit_symtab)
5259 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5260 paddress (get_objfile_arch (objfile), pc));
5263 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data,
5266 gdb_assert (result != NULL);
5271 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
5272 void *data, int need_fullname)
5274 struct dwarf2_per_objfile *dwarf2_per_objfile
5275 = get_dwarf2_per_objfile (objfile);
5277 if (!dwarf2_per_objfile->filenames_cache)
5279 dwarf2_per_objfile->filenames_cache.emplace ();
5281 htab_up visited (htab_create_alloc (10,
5282 htab_hash_pointer, htab_eq_pointer,
5283 NULL, xcalloc, xfree));
5285 /* The rule is CUs specify all the files, including those used
5286 by any TU, so there's no need to scan TUs here. We can
5287 ignore file names coming from already-expanded CUs. */
5289 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5291 if (per_cu->v.quick->compunit_symtab)
5293 void **slot = htab_find_slot (visited.get (),
5294 per_cu->v.quick->file_names,
5297 *slot = per_cu->v.quick->file_names;
5301 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5303 /* We only need to look at symtabs not already expanded. */
5304 if (per_cu->v.quick->compunit_symtab)
5307 quick_file_names *file_data = dw2_get_file_names (per_cu);
5308 if (file_data == NULL)
5311 void **slot = htab_find_slot (visited.get (), file_data, INSERT);
5314 /* Already visited. */
5319 for (int j = 0; j < file_data->num_file_names; ++j)
5321 const char *filename = file_data->file_names[j];
5322 dwarf2_per_objfile->filenames_cache->seen (filename);
5327 dwarf2_per_objfile->filenames_cache->traverse ([&] (const char *filename)
5329 gdb::unique_xmalloc_ptr<char> this_real_name;
5332 this_real_name = gdb_realpath (filename);
5333 (*fun) (filename, this_real_name.get (), data);
5338 dw2_has_symbols (struct objfile *objfile)
5343 const struct quick_symbol_functions dwarf2_gdb_index_functions =
5346 dw2_find_last_source_symtab,
5347 dw2_forget_cached_source_info,
5348 dw2_map_symtabs_matching_filename,
5352 dw2_expand_symtabs_for_function,
5353 dw2_expand_all_symtabs,
5354 dw2_expand_symtabs_with_fullname,
5355 dw2_map_matching_symbols,
5356 dw2_expand_symtabs_matching,
5357 dw2_find_pc_sect_compunit_symtab,
5359 dw2_map_symbol_filenames
5362 /* DWARF-5 debug_names reader. */
5364 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5365 static const gdb_byte dwarf5_augmentation[] = { 'G', 'D', 'B', 0 };
5367 /* A helper function that reads the .debug_names section in SECTION
5368 and fills in MAP. FILENAME is the name of the file containing the
5369 section; it is used for error reporting.
5371 Returns true if all went well, false otherwise. */
5374 read_debug_names_from_section (struct objfile *objfile,
5375 const char *filename,
5376 struct dwarf2_section_info *section,
5377 mapped_debug_names &map)
5379 if (dwarf2_section_empty_p (section))
5382 /* Older elfutils strip versions could keep the section in the main
5383 executable while splitting it for the separate debug info file. */
5384 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
5387 dwarf2_read_section (objfile, section);
5389 map.dwarf5_byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
5391 const gdb_byte *addr = section->buffer;
5393 bfd *const abfd = get_section_bfd_owner (section);
5395 unsigned int bytes_read;
5396 LONGEST length = read_initial_length (abfd, addr, &bytes_read);
5399 map.dwarf5_is_dwarf64 = bytes_read != 4;
5400 map.offset_size = map.dwarf5_is_dwarf64 ? 8 : 4;
5401 if (bytes_read + length != section->size)
5403 /* There may be multiple per-CU indices. */
5404 warning (_("Section .debug_names in %s length %s does not match "
5405 "section length %s, ignoring .debug_names."),
5406 filename, plongest (bytes_read + length),
5407 pulongest (section->size));
5411 /* The version number. */
5412 uint16_t version = read_2_bytes (abfd, addr);
5416 warning (_("Section .debug_names in %s has unsupported version %d, "
5417 "ignoring .debug_names."),
5423 uint16_t padding = read_2_bytes (abfd, addr);
5427 warning (_("Section .debug_names in %s has unsupported padding %d, "
5428 "ignoring .debug_names."),
5433 /* comp_unit_count - The number of CUs in the CU list. */
5434 map.cu_count = read_4_bytes (abfd, addr);
5437 /* local_type_unit_count - The number of TUs in the local TU
5439 map.tu_count = read_4_bytes (abfd, addr);
5442 /* foreign_type_unit_count - The number of TUs in the foreign TU
5444 uint32_t foreign_tu_count = read_4_bytes (abfd, addr);
5446 if (foreign_tu_count != 0)
5448 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5449 "ignoring .debug_names."),
5450 filename, static_cast<unsigned long> (foreign_tu_count));
5454 /* bucket_count - The number of hash buckets in the hash lookup
5456 map.bucket_count = read_4_bytes (abfd, addr);
5459 /* name_count - The number of unique names in the index. */
5460 map.name_count = read_4_bytes (abfd, addr);
5463 /* abbrev_table_size - The size in bytes of the abbreviations
5465 uint32_t abbrev_table_size = read_4_bytes (abfd, addr);
5468 /* augmentation_string_size - The size in bytes of the augmentation
5469 string. This value is rounded up to a multiple of 4. */
5470 uint32_t augmentation_string_size = read_4_bytes (abfd, addr);
5472 map.augmentation_is_gdb = ((augmentation_string_size
5473 == sizeof (dwarf5_augmentation))
5474 && memcmp (addr, dwarf5_augmentation,
5475 sizeof (dwarf5_augmentation)) == 0);
5476 augmentation_string_size += (-augmentation_string_size) & 3;
5477 addr += augmentation_string_size;
5480 map.cu_table_reordered = addr;
5481 addr += map.cu_count * map.offset_size;
5483 /* List of Local TUs */
5484 map.tu_table_reordered = addr;
5485 addr += map.tu_count * map.offset_size;
5487 /* Hash Lookup Table */
5488 map.bucket_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5489 addr += map.bucket_count * 4;
5490 map.hash_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5491 addr += map.name_count * 4;
5494 map.name_table_string_offs_reordered = addr;
5495 addr += map.name_count * map.offset_size;
5496 map.name_table_entry_offs_reordered = addr;
5497 addr += map.name_count * map.offset_size;
5499 const gdb_byte *abbrev_table_start = addr;
5502 const ULONGEST index_num = read_unsigned_leb128 (abfd, addr, &bytes_read);
5507 const auto insertpair
5508 = map.abbrev_map.emplace (index_num, mapped_debug_names::index_val ());
5509 if (!insertpair.second)
5511 warning (_("Section .debug_names in %s has duplicate index %s, "
5512 "ignoring .debug_names."),
5513 filename, pulongest (index_num));
5516 mapped_debug_names::index_val &indexval = insertpair.first->second;
5517 indexval.dwarf_tag = read_unsigned_leb128 (abfd, addr, &bytes_read);
5522 mapped_debug_names::index_val::attr attr;
5523 attr.dw_idx = read_unsigned_leb128 (abfd, addr, &bytes_read);
5525 attr.form = read_unsigned_leb128 (abfd, addr, &bytes_read);
5527 if (attr.form == DW_FORM_implicit_const)
5529 attr.implicit_const = read_signed_leb128 (abfd, addr,
5533 if (attr.dw_idx == 0 && attr.form == 0)
5535 indexval.attr_vec.push_back (std::move (attr));
5538 if (addr != abbrev_table_start + abbrev_table_size)
5540 warning (_("Section .debug_names in %s has abbreviation_table "
5541 "of size %zu vs. written as %u, ignoring .debug_names."),
5542 filename, addr - abbrev_table_start, abbrev_table_size);
5545 map.entry_pool = addr;
5550 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5554 create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
5555 const mapped_debug_names &map,
5556 dwarf2_section_info §ion,
5559 sect_offset sect_off_prev;
5560 for (uint32_t i = 0; i <= map.cu_count; ++i)
5562 sect_offset sect_off_next;
5563 if (i < map.cu_count)
5566 = (sect_offset) (extract_unsigned_integer
5567 (map.cu_table_reordered + i * map.offset_size,
5569 map.dwarf5_byte_order));
5572 sect_off_next = (sect_offset) section.size;
5575 const ULONGEST length = sect_off_next - sect_off_prev;
5576 dwarf2_per_cu_data *per_cu
5577 = create_cu_from_index_list (dwarf2_per_objfile, §ion, is_dwz,
5578 sect_off_prev, length);
5579 dwarf2_per_objfile->all_comp_units.push_back (per_cu);
5581 sect_off_prev = sect_off_next;
5585 /* Read the CU list from the mapped index, and use it to create all
5586 the CU objects for this dwarf2_per_objfile. */
5589 create_cus_from_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
5590 const mapped_debug_names &map,
5591 const mapped_debug_names &dwz_map)
5593 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
5594 dwarf2_per_objfile->all_comp_units.reserve (map.cu_count + dwz_map.cu_count);
5596 create_cus_from_debug_names_list (dwarf2_per_objfile, map,
5597 dwarf2_per_objfile->info,
5598 false /* is_dwz */);
5600 if (dwz_map.cu_count == 0)
5603 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5604 create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
5608 /* Read .debug_names. If everything went ok, initialize the "quick"
5609 elements of all the CUs and return true. Otherwise, return false. */
5612 dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
5614 std::unique_ptr<mapped_debug_names> map
5615 (new mapped_debug_names (dwarf2_per_objfile));
5616 mapped_debug_names dwz_map (dwarf2_per_objfile);
5617 struct objfile *objfile = dwarf2_per_objfile->objfile;
5619 if (!read_debug_names_from_section (objfile, objfile_name (objfile),
5620 &dwarf2_per_objfile->debug_names,
5624 /* Don't use the index if it's empty. */
5625 if (map->name_count == 0)
5628 /* If there is a .dwz file, read it so we can get its CU list as
5630 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5633 if (!read_debug_names_from_section (objfile,
5634 bfd_get_filename (dwz->dwz_bfd),
5635 &dwz->debug_names, dwz_map))
5637 warning (_("could not read '.debug_names' section from %s; skipping"),
5638 bfd_get_filename (dwz->dwz_bfd));
5643 create_cus_from_debug_names (dwarf2_per_objfile, *map, dwz_map);
5645 if (map->tu_count != 0)
5647 /* We can only handle a single .debug_types when we have an
5649 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
5652 dwarf2_section_info *section = VEC_index (dwarf2_section_info_def,
5653 dwarf2_per_objfile->types, 0);
5655 create_signatured_type_table_from_debug_names
5656 (dwarf2_per_objfile, *map, section, &dwarf2_per_objfile->abbrev);
5659 create_addrmap_from_aranges (dwarf2_per_objfile,
5660 &dwarf2_per_objfile->debug_aranges);
5662 dwarf2_per_objfile->debug_names_table = std::move (map);
5663 dwarf2_per_objfile->using_index = 1;
5664 dwarf2_per_objfile->quick_file_names_table =
5665 create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
5670 /* Type used to manage iterating over all CUs looking for a symbol for
5673 class dw2_debug_names_iterator
5676 /* If WANT_SPECIFIC_BLOCK is true, only look for symbols in block
5677 BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
5678 dw2_debug_names_iterator (const mapped_debug_names &map,
5679 bool want_specific_block,
5680 block_enum block_index, domain_enum domain,
5682 : m_map (map), m_want_specific_block (want_specific_block),
5683 m_block_index (block_index), m_domain (domain),
5684 m_addr (find_vec_in_debug_names (map, name))
5687 dw2_debug_names_iterator (const mapped_debug_names &map,
5688 search_domain search, uint32_t namei)
5691 m_addr (find_vec_in_debug_names (map, namei))
5694 /* Return the next matching CU or NULL if there are no more. */
5695 dwarf2_per_cu_data *next ();
5698 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5700 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5703 /* The internalized form of .debug_names. */
5704 const mapped_debug_names &m_map;
5706 /* If true, only look for symbols that match BLOCK_INDEX. */
5707 const bool m_want_specific_block = false;
5709 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
5710 Unused if !WANT_SPECIFIC_BLOCK - FIRST_LOCAL_BLOCK is an invalid
5712 const block_enum m_block_index = FIRST_LOCAL_BLOCK;
5714 /* The kind of symbol we're looking for. */
5715 const domain_enum m_domain = UNDEF_DOMAIN;
5716 const search_domain m_search = ALL_DOMAIN;
5718 /* The list of CUs from the index entry of the symbol, or NULL if
5720 const gdb_byte *m_addr;
5724 mapped_debug_names::namei_to_name (uint32_t namei) const
5726 const ULONGEST namei_string_offs
5727 = extract_unsigned_integer ((name_table_string_offs_reordered
5728 + namei * offset_size),
5731 return read_indirect_string_at_offset
5732 (dwarf2_per_objfile, dwarf2_per_objfile->objfile->obfd, namei_string_offs);
5735 /* Find a slot in .debug_names for the object named NAME. If NAME is
5736 found, return pointer to its pool data. If NAME cannot be found,
5740 dw2_debug_names_iterator::find_vec_in_debug_names
5741 (const mapped_debug_names &map, const char *name)
5743 int (*cmp) (const char *, const char *);
5745 if (current_language->la_language == language_cplus
5746 || current_language->la_language == language_fortran
5747 || current_language->la_language == language_d)
5749 /* NAME is already canonical. Drop any qualifiers as
5750 .debug_names does not contain any. */
5752 if (strchr (name, '(') != NULL)
5754 gdb::unique_xmalloc_ptr<char> without_params
5755 = cp_remove_params (name);
5757 if (without_params != NULL)
5759 name = without_params.get();
5764 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
5766 const uint32_t full_hash = dwarf5_djb_hash (name);
5768 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5769 (map.bucket_table_reordered
5770 + (full_hash % map.bucket_count)), 4,
5771 map.dwarf5_byte_order);
5775 if (namei >= map.name_count)
5777 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5779 namei, map.name_count,
5780 objfile_name (map.dwarf2_per_objfile->objfile));
5786 const uint32_t namei_full_hash
5787 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5788 (map.hash_table_reordered + namei), 4,
5789 map.dwarf5_byte_order);
5790 if (full_hash % map.bucket_count != namei_full_hash % map.bucket_count)
5793 if (full_hash == namei_full_hash)
5795 const char *const namei_string = map.namei_to_name (namei);
5797 #if 0 /* An expensive sanity check. */
5798 if (namei_full_hash != dwarf5_djb_hash (namei_string))
5800 complaint (_("Wrong .debug_names hash for string at index %u "
5802 namei, objfile_name (dwarf2_per_objfile->objfile));
5807 if (cmp (namei_string, name) == 0)
5809 const ULONGEST namei_entry_offs
5810 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5811 + namei * map.offset_size),
5812 map.offset_size, map.dwarf5_byte_order);
5813 return map.entry_pool + namei_entry_offs;
5818 if (namei >= map.name_count)
5824 dw2_debug_names_iterator::find_vec_in_debug_names
5825 (const mapped_debug_names &map, uint32_t namei)
5827 if (namei >= map.name_count)
5829 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5831 namei, map.name_count,
5832 objfile_name (map.dwarf2_per_objfile->objfile));
5836 const ULONGEST namei_entry_offs
5837 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5838 + namei * map.offset_size),
5839 map.offset_size, map.dwarf5_byte_order);
5840 return map.entry_pool + namei_entry_offs;
5843 /* See dw2_debug_names_iterator. */
5845 dwarf2_per_cu_data *
5846 dw2_debug_names_iterator::next ()
5851 struct dwarf2_per_objfile *dwarf2_per_objfile = m_map.dwarf2_per_objfile;
5852 struct objfile *objfile = dwarf2_per_objfile->objfile;
5853 bfd *const abfd = objfile->obfd;
5857 unsigned int bytes_read;
5858 const ULONGEST abbrev = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5859 m_addr += bytes_read;
5863 const auto indexval_it = m_map.abbrev_map.find (abbrev);
5864 if (indexval_it == m_map.abbrev_map.cend ())
5866 complaint (_("Wrong .debug_names undefined abbrev code %s "
5868 pulongest (abbrev), objfile_name (objfile));
5871 const mapped_debug_names::index_val &indexval = indexval_it->second;
5872 bool have_is_static = false;
5874 dwarf2_per_cu_data *per_cu = NULL;
5875 for (const mapped_debug_names::index_val::attr &attr : indexval.attr_vec)
5880 case DW_FORM_implicit_const:
5881 ull = attr.implicit_const;
5883 case DW_FORM_flag_present:
5887 ull = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5888 m_addr += bytes_read;
5891 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5892 dwarf_form_name (attr.form),
5893 objfile_name (objfile));
5896 switch (attr.dw_idx)
5898 case DW_IDX_compile_unit:
5899 /* Don't crash on bad data. */
5900 if (ull >= dwarf2_per_objfile->all_comp_units.size ())
5902 complaint (_(".debug_names entry has bad CU index %s"
5905 objfile_name (dwarf2_per_objfile->objfile));
5908 per_cu = dwarf2_per_objfile->get_cutu (ull);
5910 case DW_IDX_type_unit:
5911 /* Don't crash on bad data. */
5912 if (ull >= dwarf2_per_objfile->all_type_units.size ())
5914 complaint (_(".debug_names entry has bad TU index %s"
5917 objfile_name (dwarf2_per_objfile->objfile));
5920 per_cu = &dwarf2_per_objfile->get_tu (ull)->per_cu;
5922 case DW_IDX_GNU_internal:
5923 if (!m_map.augmentation_is_gdb)
5925 have_is_static = true;
5928 case DW_IDX_GNU_external:
5929 if (!m_map.augmentation_is_gdb)
5931 have_is_static = true;
5937 /* Skip if already read in. */
5938 if (per_cu->v.quick->compunit_symtab)
5941 /* Check static vs global. */
5944 const bool want_static = m_block_index != GLOBAL_BLOCK;
5945 if (m_want_specific_block && want_static != is_static)
5949 /* Match dw2_symtab_iter_next, symbol_kind
5950 and debug_names::psymbol_tag. */
5954 switch (indexval.dwarf_tag)
5956 case DW_TAG_variable:
5957 case DW_TAG_subprogram:
5958 /* Some types are also in VAR_DOMAIN. */
5959 case DW_TAG_typedef:
5960 case DW_TAG_structure_type:
5967 switch (indexval.dwarf_tag)
5969 case DW_TAG_typedef:
5970 case DW_TAG_structure_type:
5977 switch (indexval.dwarf_tag)
5980 case DW_TAG_variable:
5990 /* Match dw2_expand_symtabs_matching, symbol_kind and
5991 debug_names::psymbol_tag. */
5994 case VARIABLES_DOMAIN:
5995 switch (indexval.dwarf_tag)
5997 case DW_TAG_variable:
6003 case FUNCTIONS_DOMAIN:
6004 switch (indexval.dwarf_tag)
6006 case DW_TAG_subprogram:
6013 switch (indexval.dwarf_tag)
6015 case DW_TAG_typedef:
6016 case DW_TAG_structure_type:
6029 static struct compunit_symtab *
6030 dw2_debug_names_lookup_symbol (struct objfile *objfile, int block_index_int,
6031 const char *name, domain_enum domain)
6033 const block_enum block_index = static_cast<block_enum> (block_index_int);
6034 struct dwarf2_per_objfile *dwarf2_per_objfile
6035 = get_dwarf2_per_objfile (objfile);
6037 const auto &mapp = dwarf2_per_objfile->debug_names_table;
6040 /* index is NULL if OBJF_READNOW. */
6043 const auto &map = *mapp;
6045 dw2_debug_names_iterator iter (map, true /* want_specific_block */,
6046 block_index, domain, name);
6048 struct compunit_symtab *stab_best = NULL;
6049 struct dwarf2_per_cu_data *per_cu;
6050 while ((per_cu = iter.next ()) != NULL)
6052 struct symbol *sym, *with_opaque = NULL;
6053 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
6054 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
6055 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
6057 sym = block_find_symbol (block, name, domain,
6058 block_find_non_opaque_type_preferred,
6061 /* Some caution must be observed with overloaded functions and
6062 methods, since the index will not contain any overload
6063 information (but NAME might contain it). */
6066 && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
6068 if (with_opaque != NULL
6069 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
6072 /* Keep looking through other CUs. */
6078 /* This dumps minimal information about .debug_names. It is called
6079 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
6080 uses this to verify that .debug_names has been loaded. */
6083 dw2_debug_names_dump (struct objfile *objfile)
6085 struct dwarf2_per_objfile *dwarf2_per_objfile
6086 = get_dwarf2_per_objfile (objfile);
6088 gdb_assert (dwarf2_per_objfile->using_index);
6089 printf_filtered (".debug_names:");
6090 if (dwarf2_per_objfile->debug_names_table)
6091 printf_filtered (" exists\n");
6093 printf_filtered (" faked for \"readnow\"\n");
6094 printf_filtered ("\n");
6098 dw2_debug_names_expand_symtabs_for_function (struct objfile *objfile,
6099 const char *func_name)
6101 struct dwarf2_per_objfile *dwarf2_per_objfile
6102 = get_dwarf2_per_objfile (objfile);
6104 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
6105 if (dwarf2_per_objfile->debug_names_table)
6107 const mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6109 /* Note: It doesn't matter what we pass for block_index here. */
6110 dw2_debug_names_iterator iter (map, false /* want_specific_block */,
6111 GLOBAL_BLOCK, VAR_DOMAIN, func_name);
6113 struct dwarf2_per_cu_data *per_cu;
6114 while ((per_cu = iter.next ()) != NULL)
6115 dw2_instantiate_symtab (per_cu, false);
6120 dw2_debug_names_expand_symtabs_matching
6121 (struct objfile *objfile,
6122 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
6123 const lookup_name_info &lookup_name,
6124 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
6125 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
6126 enum search_domain kind)
6128 struct dwarf2_per_objfile *dwarf2_per_objfile
6129 = get_dwarf2_per_objfile (objfile);
6131 /* debug_names_table is NULL if OBJF_READNOW. */
6132 if (!dwarf2_per_objfile->debug_names_table)
6135 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
6137 mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6139 dw2_expand_symtabs_matching_symbol (map, lookup_name,
6141 kind, [&] (offset_type namei)
6143 /* The name was matched, now expand corresponding CUs that were
6145 dw2_debug_names_iterator iter (map, kind, namei);
6147 struct dwarf2_per_cu_data *per_cu;
6148 while ((per_cu = iter.next ()) != NULL)
6149 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
6154 const struct quick_symbol_functions dwarf2_debug_names_functions =
6157 dw2_find_last_source_symtab,
6158 dw2_forget_cached_source_info,
6159 dw2_map_symtabs_matching_filename,
6160 dw2_debug_names_lookup_symbol,
6162 dw2_debug_names_dump,
6163 dw2_debug_names_expand_symtabs_for_function,
6164 dw2_expand_all_symtabs,
6165 dw2_expand_symtabs_with_fullname,
6166 dw2_map_matching_symbols,
6167 dw2_debug_names_expand_symtabs_matching,
6168 dw2_find_pc_sect_compunit_symtab,
6170 dw2_map_symbol_filenames
6173 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
6174 to either a dwarf2_per_objfile or dwz_file object. */
6176 template <typename T>
6177 static gdb::array_view<const gdb_byte>
6178 get_gdb_index_contents_from_section (objfile *obj, T *section_owner)
6180 dwarf2_section_info *section = §ion_owner->gdb_index;
6182 if (dwarf2_section_empty_p (section))
6185 /* Older elfutils strip versions could keep the section in the main
6186 executable while splitting it for the separate debug info file. */
6187 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
6190 dwarf2_read_section (obj, section);
6192 /* dwarf2_section_info::size is a bfd_size_type, while
6193 gdb::array_view works with size_t. On 32-bit hosts, with
6194 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6195 is 32-bit. So we need an explicit narrowing conversion here.
6196 This is fine, because it's impossible to allocate or mmap an
6197 array/buffer larger than what size_t can represent. */
6198 return gdb::make_array_view (section->buffer, section->size);
6201 /* Lookup the index cache for the contents of the index associated to
6204 static gdb::array_view<const gdb_byte>
6205 get_gdb_index_contents_from_cache (objfile *obj, dwarf2_per_objfile *dwarf2_obj)
6207 const bfd_build_id *build_id = build_id_bfd_get (obj->obfd);
6208 if (build_id == nullptr)
6211 return global_index_cache.lookup_gdb_index (build_id,
6212 &dwarf2_obj->index_cache_res);
6215 /* Same as the above, but for DWZ. */
6217 static gdb::array_view<const gdb_byte>
6218 get_gdb_index_contents_from_cache_dwz (objfile *obj, dwz_file *dwz)
6220 const bfd_build_id *build_id = build_id_bfd_get (dwz->dwz_bfd.get ());
6221 if (build_id == nullptr)
6224 return global_index_cache.lookup_gdb_index (build_id, &dwz->index_cache_res);
6227 /* See symfile.h. */
6230 dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
6232 struct dwarf2_per_objfile *dwarf2_per_objfile
6233 = get_dwarf2_per_objfile (objfile);
6235 /* If we're about to read full symbols, don't bother with the
6236 indices. In this case we also don't care if some other debug
6237 format is making psymtabs, because they are all about to be
6239 if ((objfile->flags & OBJF_READNOW))
6241 dwarf2_per_objfile->using_index = 1;
6242 create_all_comp_units (dwarf2_per_objfile);
6243 create_all_type_units (dwarf2_per_objfile);
6244 dwarf2_per_objfile->quick_file_names_table
6245 = create_quick_file_names_table
6246 (dwarf2_per_objfile->all_comp_units.size ());
6248 for (int i = 0; i < (dwarf2_per_objfile->all_comp_units.size ()
6249 + dwarf2_per_objfile->all_type_units.size ()); ++i)
6251 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
6253 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6254 struct dwarf2_per_cu_quick_data);
6257 /* Return 1 so that gdb sees the "quick" functions. However,
6258 these functions will be no-ops because we will have expanded
6260 *index_kind = dw_index_kind::GDB_INDEX;
6264 if (dwarf2_read_debug_names (dwarf2_per_objfile))
6266 *index_kind = dw_index_kind::DEBUG_NAMES;
6270 if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6271 get_gdb_index_contents_from_section<struct dwarf2_per_objfile>,
6272 get_gdb_index_contents_from_section<dwz_file>))
6274 *index_kind = dw_index_kind::GDB_INDEX;
6278 /* ... otherwise, try to find the index in the index cache. */
6279 if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6280 get_gdb_index_contents_from_cache,
6281 get_gdb_index_contents_from_cache_dwz))
6283 global_index_cache.hit ();
6284 *index_kind = dw_index_kind::GDB_INDEX;
6288 global_index_cache.miss ();
6294 /* Build a partial symbol table. */
6297 dwarf2_build_psymtabs (struct objfile *objfile)
6299 struct dwarf2_per_objfile *dwarf2_per_objfile
6300 = get_dwarf2_per_objfile (objfile);
6302 init_psymbol_list (objfile, 1024);
6306 /* This isn't really ideal: all the data we allocate on the
6307 objfile's obstack is still uselessly kept around. However,
6308 freeing it seems unsafe. */
6309 psymtab_discarder psymtabs (objfile);
6310 dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
6313 /* (maybe) store an index in the cache. */
6314 global_index_cache.store (dwarf2_per_objfile);
6316 CATCH (except, RETURN_MASK_ERROR)
6318 exception_print (gdb_stderr, except);
6323 /* Return the total length of the CU described by HEADER. */
6326 get_cu_length (const struct comp_unit_head *header)
6328 return header->initial_length_size + header->length;
6331 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6334 offset_in_cu_p (const comp_unit_head *cu_header, sect_offset sect_off)
6336 sect_offset bottom = cu_header->sect_off;
6337 sect_offset top = cu_header->sect_off + get_cu_length (cu_header);
6339 return sect_off >= bottom && sect_off < top;
6342 /* Find the base address of the compilation unit for range lists and
6343 location lists. It will normally be specified by DW_AT_low_pc.
6344 In DWARF-3 draft 4, the base address could be overridden by
6345 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6346 compilation units with discontinuous ranges. */
6349 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
6351 struct attribute *attr;
6354 cu->base_address = 0;
6356 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
6359 cu->base_address = attr_value_as_address (attr);
6364 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6367 cu->base_address = attr_value_as_address (attr);
6373 /* Read in the comp unit header information from the debug_info at info_ptr.
6374 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6375 NOTE: This leaves members offset, first_die_offset to be filled in
6378 static const gdb_byte *
6379 read_comp_unit_head (struct comp_unit_head *cu_header,
6380 const gdb_byte *info_ptr,
6381 struct dwarf2_section_info *section,
6382 rcuh_kind section_kind)
6385 unsigned int bytes_read;
6386 const char *filename = get_section_file_name (section);
6387 bfd *abfd = get_section_bfd_owner (section);
6389 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
6390 cu_header->initial_length_size = bytes_read;
6391 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
6392 info_ptr += bytes_read;
6393 cu_header->version = read_2_bytes (abfd, info_ptr);
6394 if (cu_header->version < 2 || cu_header->version > 5)
6395 error (_("Dwarf Error: wrong version in compilation unit header "
6396 "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6397 cu_header->version, filename);
6399 if (cu_header->version < 5)
6400 switch (section_kind)
6402 case rcuh_kind::COMPILE:
6403 cu_header->unit_type = DW_UT_compile;
6405 case rcuh_kind::TYPE:
6406 cu_header->unit_type = DW_UT_type;
6409 internal_error (__FILE__, __LINE__,
6410 _("read_comp_unit_head: invalid section_kind"));
6414 cu_header->unit_type = static_cast<enum dwarf_unit_type>
6415 (read_1_byte (abfd, info_ptr));
6417 switch (cu_header->unit_type)
6420 if (section_kind != rcuh_kind::COMPILE)
6421 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6422 "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6426 section_kind = rcuh_kind::TYPE;
6429 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6430 "(is %d, should be %d or %d) [in module %s]"),
6431 cu_header->unit_type, DW_UT_compile, DW_UT_type, filename);
6434 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6437 cu_header->abbrev_sect_off = (sect_offset) read_offset (abfd, info_ptr,
6440 info_ptr += bytes_read;
6441 if (cu_header->version < 5)
6443 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6446 signed_addr = bfd_get_sign_extend_vma (abfd);
6447 if (signed_addr < 0)
6448 internal_error (__FILE__, __LINE__,
6449 _("read_comp_unit_head: dwarf from non elf file"));
6450 cu_header->signed_addr_p = signed_addr;
6452 if (section_kind == rcuh_kind::TYPE)
6454 LONGEST type_offset;
6456 cu_header->signature = read_8_bytes (abfd, info_ptr);
6459 type_offset = read_offset (abfd, info_ptr, cu_header, &bytes_read);
6460 info_ptr += bytes_read;
6461 cu_header->type_cu_offset_in_tu = (cu_offset) type_offset;
6462 if (to_underlying (cu_header->type_cu_offset_in_tu) != type_offset)
6463 error (_("Dwarf Error: Too big type_offset in compilation unit "
6464 "header (is %s) [in module %s]"), plongest (type_offset),
6471 /* Helper function that returns the proper abbrev section for
6474 static struct dwarf2_section_info *
6475 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
6477 struct dwarf2_section_info *abbrev;
6478 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
6480 if (this_cu->is_dwz)
6481 abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
6483 abbrev = &dwarf2_per_objfile->abbrev;
6488 /* Subroutine of read_and_check_comp_unit_head and
6489 read_and_check_type_unit_head to simplify them.
6490 Perform various error checking on the header. */
6493 error_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6494 struct comp_unit_head *header,
6495 struct dwarf2_section_info *section,
6496 struct dwarf2_section_info *abbrev_section)
6498 const char *filename = get_section_file_name (section);
6500 if (to_underlying (header->abbrev_sect_off)
6501 >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
6502 error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6503 "(offset %s + 6) [in module %s]"),
6504 sect_offset_str (header->abbrev_sect_off),
6505 sect_offset_str (header->sect_off),
6508 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6509 avoid potential 32-bit overflow. */
6510 if (((ULONGEST) header->sect_off + get_cu_length (header))
6512 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6513 "(offset %s + 0) [in module %s]"),
6514 header->length, sect_offset_str (header->sect_off),
6518 /* Read in a CU/TU header and perform some basic error checking.
6519 The contents of the header are stored in HEADER.
6520 The result is a pointer to the start of the first DIE. */
6522 static const gdb_byte *
6523 read_and_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6524 struct comp_unit_head *header,
6525 struct dwarf2_section_info *section,
6526 struct dwarf2_section_info *abbrev_section,
6527 const gdb_byte *info_ptr,
6528 rcuh_kind section_kind)
6530 const gdb_byte *beg_of_comp_unit = info_ptr;
6532 header->sect_off = (sect_offset) (beg_of_comp_unit - section->buffer);
6534 info_ptr = read_comp_unit_head (header, info_ptr, section, section_kind);
6536 header->first_die_cu_offset = (cu_offset) (info_ptr - beg_of_comp_unit);
6538 error_check_comp_unit_head (dwarf2_per_objfile, header, section,
6544 /* Fetch the abbreviation table offset from a comp or type unit header. */
6547 read_abbrev_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
6548 struct dwarf2_section_info *section,
6549 sect_offset sect_off)
6551 bfd *abfd = get_section_bfd_owner (section);
6552 const gdb_byte *info_ptr;
6553 unsigned int initial_length_size, offset_size;
6556 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
6557 info_ptr = section->buffer + to_underlying (sect_off);
6558 read_initial_length (abfd, info_ptr, &initial_length_size);
6559 offset_size = initial_length_size == 4 ? 4 : 8;
6560 info_ptr += initial_length_size;
6562 version = read_2_bytes (abfd, info_ptr);
6566 /* Skip unit type and address size. */
6570 return (sect_offset) read_offset_1 (abfd, info_ptr, offset_size);
6573 /* Allocate a new partial symtab for file named NAME and mark this new
6574 partial symtab as being an include of PST. */
6577 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
6578 struct objfile *objfile)
6580 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
6582 if (!IS_ABSOLUTE_PATH (subpst->filename))
6584 /* It shares objfile->objfile_obstack. */
6585 subpst->dirname = pst->dirname;
6588 subpst->dependencies = objfile->partial_symtabs->allocate_dependencies (1);
6589 subpst->dependencies[0] = pst;
6590 subpst->number_of_dependencies = 1;
6592 subpst->read_symtab = pst->read_symtab;
6594 /* No private part is necessary for include psymtabs. This property
6595 can be used to differentiate between such include psymtabs and
6596 the regular ones. */
6597 subpst->read_symtab_private = NULL;
6600 /* Read the Line Number Program data and extract the list of files
6601 included by the source file represented by PST. Build an include
6602 partial symtab for each of these included files. */
6605 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
6606 struct die_info *die,
6607 struct partial_symtab *pst)
6610 struct attribute *attr;
6612 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
6614 lh = dwarf_decode_line_header ((sect_offset) DW_UNSND (attr), cu);
6616 return; /* No linetable, so no includes. */
6618 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6619 that we pass in the raw text_low here; that is ok because we're
6620 only decoding the line table to make include partial symtabs, and
6621 so the addresses aren't really used. */
6622 dwarf_decode_lines (lh.get (), pst->dirname, cu, pst,
6623 pst->raw_text_low (), 1);
6627 hash_signatured_type (const void *item)
6629 const struct signatured_type *sig_type
6630 = (const struct signatured_type *) item;
6632 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6633 return sig_type->signature;
6637 eq_signatured_type (const void *item_lhs, const void *item_rhs)
6639 const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
6640 const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
6642 return lhs->signature == rhs->signature;
6645 /* Allocate a hash table for signatured types. */
6648 allocate_signatured_type_table (struct objfile *objfile)
6650 return htab_create_alloc_ex (41,
6651 hash_signatured_type,
6654 &objfile->objfile_obstack,
6655 hashtab_obstack_allocate,
6656 dummy_obstack_deallocate);
6659 /* A helper function to add a signatured type CU to a table. */
6662 add_signatured_type_cu_to_table (void **slot, void *datum)
6664 struct signatured_type *sigt = (struct signatured_type *) *slot;
6665 std::vector<signatured_type *> *all_type_units
6666 = (std::vector<signatured_type *> *) datum;
6668 all_type_units->push_back (sigt);
6673 /* A helper for create_debug_types_hash_table. Read types from SECTION
6674 and fill them into TYPES_HTAB. It will process only type units,
6675 therefore DW_UT_type. */
6678 create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6679 struct dwo_file *dwo_file,
6680 dwarf2_section_info *section, htab_t &types_htab,
6681 rcuh_kind section_kind)
6683 struct objfile *objfile = dwarf2_per_objfile->objfile;
6684 struct dwarf2_section_info *abbrev_section;
6686 const gdb_byte *info_ptr, *end_ptr;
6688 abbrev_section = (dwo_file != NULL
6689 ? &dwo_file->sections.abbrev
6690 : &dwarf2_per_objfile->abbrev);
6692 if (dwarf_read_debug)
6693 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
6694 get_section_name (section),
6695 get_section_file_name (abbrev_section));
6697 dwarf2_read_section (objfile, section);
6698 info_ptr = section->buffer;
6700 if (info_ptr == NULL)
6703 /* We can't set abfd until now because the section may be empty or
6704 not present, in which case the bfd is unknown. */
6705 abfd = get_section_bfd_owner (section);
6707 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6708 because we don't need to read any dies: the signature is in the
6711 end_ptr = info_ptr + section->size;
6712 while (info_ptr < end_ptr)
6714 struct signatured_type *sig_type;
6715 struct dwo_unit *dwo_tu;
6717 const gdb_byte *ptr = info_ptr;
6718 struct comp_unit_head header;
6719 unsigned int length;
6721 sect_offset sect_off = (sect_offset) (ptr - section->buffer);
6723 /* Initialize it due to a false compiler warning. */
6724 header.signature = -1;
6725 header.type_cu_offset_in_tu = (cu_offset) -1;
6727 /* We need to read the type's signature in order to build the hash
6728 table, but we don't need anything else just yet. */
6730 ptr = read_and_check_comp_unit_head (dwarf2_per_objfile, &header, section,
6731 abbrev_section, ptr, section_kind);
6733 length = get_cu_length (&header);
6735 /* Skip dummy type units. */
6736 if (ptr >= info_ptr + length
6737 || peek_abbrev_code (abfd, ptr) == 0
6738 || header.unit_type != DW_UT_type)
6744 if (types_htab == NULL)
6747 types_htab = allocate_dwo_unit_table (objfile);
6749 types_htab = allocate_signatured_type_table (objfile);
6755 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6757 dwo_tu->dwo_file = dwo_file;
6758 dwo_tu->signature = header.signature;
6759 dwo_tu->type_offset_in_tu = header.type_cu_offset_in_tu;
6760 dwo_tu->section = section;
6761 dwo_tu->sect_off = sect_off;
6762 dwo_tu->length = length;
6766 /* N.B.: type_offset is not usable if this type uses a DWO file.
6767 The real type_offset is in the DWO file. */
6769 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6770 struct signatured_type);
6771 sig_type->signature = header.signature;
6772 sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;
6773 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6774 sig_type->per_cu.is_debug_types = 1;
6775 sig_type->per_cu.section = section;
6776 sig_type->per_cu.sect_off = sect_off;
6777 sig_type->per_cu.length = length;
6780 slot = htab_find_slot (types_htab,
6781 dwo_file ? (void*) dwo_tu : (void *) sig_type,
6783 gdb_assert (slot != NULL);
6786 sect_offset dup_sect_off;
6790 const struct dwo_unit *dup_tu
6791 = (const struct dwo_unit *) *slot;
6793 dup_sect_off = dup_tu->sect_off;
6797 const struct signatured_type *dup_tu
6798 = (const struct signatured_type *) *slot;
6800 dup_sect_off = dup_tu->per_cu.sect_off;
6803 complaint (_("debug type entry at offset %s is duplicate to"
6804 " the entry at offset %s, signature %s"),
6805 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
6806 hex_string (header.signature));
6808 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
6810 if (dwarf_read_debug > 1)
6811 fprintf_unfiltered (gdb_stdlog, " offset %s, signature %s\n",
6812 sect_offset_str (sect_off),
6813 hex_string (header.signature));
6819 /* Create the hash table of all entries in the .debug_types
6820 (or .debug_types.dwo) section(s).
6821 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6822 otherwise it is NULL.
6824 The result is a pointer to the hash table or NULL if there are no types.
6826 Note: This function processes DWO files only, not DWP files. */
6829 create_debug_types_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6830 struct dwo_file *dwo_file,
6831 VEC (dwarf2_section_info_def) *types,
6835 struct dwarf2_section_info *section;
6837 if (VEC_empty (dwarf2_section_info_def, types))
6841 VEC_iterate (dwarf2_section_info_def, types, ix, section);
6843 create_debug_type_hash_table (dwarf2_per_objfile, dwo_file, section,
6844 types_htab, rcuh_kind::TYPE);
6847 /* Create the hash table of all entries in the .debug_types section,
6848 and initialize all_type_units.
6849 The result is zero if there is an error (e.g. missing .debug_types section),
6850 otherwise non-zero. */
6853 create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
6855 htab_t types_htab = NULL;
6857 create_debug_type_hash_table (dwarf2_per_objfile, NULL,
6858 &dwarf2_per_objfile->info, types_htab,
6859 rcuh_kind::COMPILE);
6860 create_debug_types_hash_table (dwarf2_per_objfile, NULL,
6861 dwarf2_per_objfile->types, types_htab);
6862 if (types_htab == NULL)
6864 dwarf2_per_objfile->signatured_types = NULL;
6868 dwarf2_per_objfile->signatured_types = types_htab;
6870 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
6871 dwarf2_per_objfile->all_type_units.reserve (htab_elements (types_htab));
6873 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table,
6874 &dwarf2_per_objfile->all_type_units);
6879 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6880 If SLOT is non-NULL, it is the entry to use in the hash table.
6881 Otherwise we find one. */
6883 static struct signatured_type *
6884 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
6887 struct objfile *objfile = dwarf2_per_objfile->objfile;
6889 if (dwarf2_per_objfile->all_type_units.size ()
6890 == dwarf2_per_objfile->all_type_units.capacity ())
6891 ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
6893 signatured_type *sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6894 struct signatured_type);
6896 dwarf2_per_objfile->all_type_units.push_back (sig_type);
6897 sig_type->signature = sig;
6898 sig_type->per_cu.is_debug_types = 1;
6899 if (dwarf2_per_objfile->using_index)
6901 sig_type->per_cu.v.quick =
6902 OBSTACK_ZALLOC (&objfile->objfile_obstack,
6903 struct dwarf2_per_cu_quick_data);
6908 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6911 gdb_assert (*slot == NULL);
6913 /* The rest of sig_type must be filled in by the caller. */
6917 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6918 Fill in SIG_ENTRY with DWO_ENTRY. */
6921 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
6922 struct signatured_type *sig_entry,
6923 struct dwo_unit *dwo_entry)
6925 /* Make sure we're not clobbering something we don't expect to. */
6926 gdb_assert (! sig_entry->per_cu.queued);
6927 gdb_assert (sig_entry->per_cu.cu == NULL);
6928 if (dwarf2_per_objfile->using_index)
6930 gdb_assert (sig_entry->per_cu.v.quick != NULL);
6931 gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
6934 gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
6935 gdb_assert (sig_entry->signature == dwo_entry->signature);
6936 gdb_assert (to_underlying (sig_entry->type_offset_in_section) == 0);
6937 gdb_assert (sig_entry->type_unit_group == NULL);
6938 gdb_assert (sig_entry->dwo_unit == NULL);
6940 sig_entry->per_cu.section = dwo_entry->section;
6941 sig_entry->per_cu.sect_off = dwo_entry->sect_off;
6942 sig_entry->per_cu.length = dwo_entry->length;
6943 sig_entry->per_cu.reading_dwo_directly = 1;
6944 sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6945 sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
6946 sig_entry->dwo_unit = dwo_entry;
6949 /* Subroutine of lookup_signatured_type.
6950 If we haven't read the TU yet, create the signatured_type data structure
6951 for a TU to be read in directly from a DWO file, bypassing the stub.
6952 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6953 using .gdb_index, then when reading a CU we want to stay in the DWO file
6954 containing that CU. Otherwise we could end up reading several other DWO
6955 files (due to comdat folding) to process the transitive closure of all the
6956 mentioned TUs, and that can be slow. The current DWO file will have every
6957 type signature that it needs.
6958 We only do this for .gdb_index because in the psymtab case we already have
6959 to read all the DWOs to build the type unit groups. */
6961 static struct signatured_type *
6962 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
6964 struct dwarf2_per_objfile *dwarf2_per_objfile
6965 = cu->per_cu->dwarf2_per_objfile;
6966 struct objfile *objfile = dwarf2_per_objfile->objfile;
6967 struct dwo_file *dwo_file;
6968 struct dwo_unit find_dwo_entry, *dwo_entry;
6969 struct signatured_type find_sig_entry, *sig_entry;
6972 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
6974 /* If TU skeletons have been removed then we may not have read in any
6976 if (dwarf2_per_objfile->signatured_types == NULL)
6978 dwarf2_per_objfile->signatured_types
6979 = allocate_signatured_type_table (objfile);
6982 /* We only ever need to read in one copy of a signatured type.
6983 Use the global signatured_types array to do our own comdat-folding
6984 of types. If this is the first time we're reading this TU, and
6985 the TU has an entry in .gdb_index, replace the recorded data from
6986 .gdb_index with this TU. */
6988 find_sig_entry.signature = sig;
6989 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6990 &find_sig_entry, INSERT);
6991 sig_entry = (struct signatured_type *) *slot;
6993 /* We can get here with the TU already read, *or* in the process of being
6994 read. Don't reassign the global entry to point to this DWO if that's
6995 the case. Also note that if the TU is already being read, it may not
6996 have come from a DWO, the program may be a mix of Fission-compiled
6997 code and non-Fission-compiled code. */
6999 /* Have we already tried to read this TU?
7000 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7001 needn't exist in the global table yet). */
7002 if (sig_entry != NULL && sig_entry->per_cu.tu_read)
7005 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
7006 dwo_unit of the TU itself. */
7007 dwo_file = cu->dwo_unit->dwo_file;
7009 /* Ok, this is the first time we're reading this TU. */
7010 if (dwo_file->tus == NULL)
7012 find_dwo_entry.signature = sig;
7013 dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
7014 if (dwo_entry == NULL)
7017 /* If the global table doesn't have an entry for this TU, add one. */
7018 if (sig_entry == NULL)
7019 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7021 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7022 sig_entry->per_cu.tu_read = 1;
7026 /* Subroutine of lookup_signatured_type.
7027 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7028 then try the DWP file. If the TU stub (skeleton) has been removed then
7029 it won't be in .gdb_index. */
7031 static struct signatured_type *
7032 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7034 struct dwarf2_per_objfile *dwarf2_per_objfile
7035 = cu->per_cu->dwarf2_per_objfile;
7036 struct objfile *objfile = dwarf2_per_objfile->objfile;
7037 struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
7038 struct dwo_unit *dwo_entry;
7039 struct signatured_type find_sig_entry, *sig_entry;
7042 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7043 gdb_assert (dwp_file != NULL);
7045 /* If TU skeletons have been removed then we may not have read in any
7047 if (dwarf2_per_objfile->signatured_types == NULL)
7049 dwarf2_per_objfile->signatured_types
7050 = allocate_signatured_type_table (objfile);
7053 find_sig_entry.signature = sig;
7054 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7055 &find_sig_entry, INSERT);
7056 sig_entry = (struct signatured_type *) *slot;
7058 /* Have we already tried to read this TU?
7059 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7060 needn't exist in the global table yet). */
7061 if (sig_entry != NULL)
7064 if (dwp_file->tus == NULL)
7066 dwo_entry = lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, NULL,
7067 sig, 1 /* is_debug_types */);
7068 if (dwo_entry == NULL)
7071 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7072 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7077 /* Lookup a signature based type for DW_FORM_ref_sig8.
7078 Returns NULL if signature SIG is not present in the table.
7079 It is up to the caller to complain about this. */
7081 static struct signatured_type *
7082 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7084 struct dwarf2_per_objfile *dwarf2_per_objfile
7085 = cu->per_cu->dwarf2_per_objfile;
7088 && dwarf2_per_objfile->using_index)
7090 /* We're in a DWO/DWP file, and we're using .gdb_index.
7091 These cases require special processing. */
7092 if (get_dwp_file (dwarf2_per_objfile) == NULL)
7093 return lookup_dwo_signatured_type (cu, sig);
7095 return lookup_dwp_signatured_type (cu, sig);
7099 struct signatured_type find_entry, *entry;
7101 if (dwarf2_per_objfile->signatured_types == NULL)
7103 find_entry.signature = sig;
7104 entry = ((struct signatured_type *)
7105 htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
7110 /* Low level DIE reading support. */
7112 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7115 init_cu_die_reader (struct die_reader_specs *reader,
7116 struct dwarf2_cu *cu,
7117 struct dwarf2_section_info *section,
7118 struct dwo_file *dwo_file,
7119 struct abbrev_table *abbrev_table)
7121 gdb_assert (section->readin && section->buffer != NULL);
7122 reader->abfd = get_section_bfd_owner (section);
7124 reader->dwo_file = dwo_file;
7125 reader->die_section = section;
7126 reader->buffer = section->buffer;
7127 reader->buffer_end = section->buffer + section->size;
7128 reader->comp_dir = NULL;
7129 reader->abbrev_table = abbrev_table;
7132 /* Subroutine of init_cutu_and_read_dies to simplify it.
7133 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7134 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7137 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7138 from it to the DIE in the DWO. If NULL we are skipping the stub.
7139 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7140 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7141 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7142 STUB_COMP_DIR may be non-NULL.
7143 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7144 are filled in with the info of the DIE from the DWO file.
7145 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7146 from the dwo. Since *RESULT_READER references this abbrev table, it must be
7147 kept around for at least as long as *RESULT_READER.
7149 The result is non-zero if a valid (non-dummy) DIE was found. */
7152 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
7153 struct dwo_unit *dwo_unit,
7154 struct die_info *stub_comp_unit_die,
7155 const char *stub_comp_dir,
7156 struct die_reader_specs *result_reader,
7157 const gdb_byte **result_info_ptr,
7158 struct die_info **result_comp_unit_die,
7159 int *result_has_children,
7160 abbrev_table_up *result_dwo_abbrev_table)
7162 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7163 struct objfile *objfile = dwarf2_per_objfile->objfile;
7164 struct dwarf2_cu *cu = this_cu->cu;
7166 const gdb_byte *begin_info_ptr, *info_ptr;
7167 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
7168 int i,num_extra_attrs;
7169 struct dwarf2_section_info *dwo_abbrev_section;
7170 struct attribute *attr;
7171 struct die_info *comp_unit_die;
7173 /* At most one of these may be provided. */
7174 gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
7176 /* These attributes aren't processed until later:
7177 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7178 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7179 referenced later. However, these attributes are found in the stub
7180 which we won't have later. In order to not impose this complication
7181 on the rest of the code, we read them here and copy them to the
7190 if (stub_comp_unit_die != NULL)
7192 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7194 if (! this_cu->is_debug_types)
7195 stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
7196 low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
7197 high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
7198 ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
7199 comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
7201 /* There should be a DW_AT_addr_base attribute here (if needed).
7202 We need the value before we can process DW_FORM_GNU_addr_index. */
7204 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
7206 cu->addr_base = DW_UNSND (attr);
7208 /* There should be a DW_AT_ranges_base attribute here (if needed).
7209 We need the value before we can process DW_AT_ranges. */
7210 cu->ranges_base = 0;
7211 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
7213 cu->ranges_base = DW_UNSND (attr);
7215 else if (stub_comp_dir != NULL)
7217 /* Reconstruct the comp_dir attribute to simplify the code below. */
7218 comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
7219 comp_dir->name = DW_AT_comp_dir;
7220 comp_dir->form = DW_FORM_string;
7221 DW_STRING_IS_CANONICAL (comp_dir) = 0;
7222 DW_STRING (comp_dir) = stub_comp_dir;
7225 /* Set up for reading the DWO CU/TU. */
7226 cu->dwo_unit = dwo_unit;
7227 dwarf2_section_info *section = dwo_unit->section;
7228 dwarf2_read_section (objfile, section);
7229 abfd = get_section_bfd_owner (section);
7230 begin_info_ptr = info_ptr = (section->buffer
7231 + to_underlying (dwo_unit->sect_off));
7232 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
7234 if (this_cu->is_debug_types)
7236 struct signatured_type *sig_type = (struct signatured_type *) this_cu;
7238 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7239 &cu->header, section,
7241 info_ptr, rcuh_kind::TYPE);
7242 /* This is not an assert because it can be caused by bad debug info. */
7243 if (sig_type->signature != cu->header.signature)
7245 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7246 " TU at offset %s [in module %s]"),
7247 hex_string (sig_type->signature),
7248 hex_string (cu->header.signature),
7249 sect_offset_str (dwo_unit->sect_off),
7250 bfd_get_filename (abfd));
7252 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7253 /* For DWOs coming from DWP files, we don't know the CU length
7254 nor the type's offset in the TU until now. */
7255 dwo_unit->length = get_cu_length (&cu->header);
7256 dwo_unit->type_offset_in_tu = cu->header.type_cu_offset_in_tu;
7258 /* Establish the type offset that can be used to lookup the type.
7259 For DWO files, we don't know it until now. */
7260 sig_type->type_offset_in_section
7261 = dwo_unit->sect_off + to_underlying (dwo_unit->type_offset_in_tu);
7265 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7266 &cu->header, section,
7268 info_ptr, rcuh_kind::COMPILE);
7269 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7270 /* For DWOs coming from DWP files, we don't know the CU length
7272 dwo_unit->length = get_cu_length (&cu->header);
7275 *result_dwo_abbrev_table
7276 = abbrev_table_read_table (dwarf2_per_objfile, dwo_abbrev_section,
7277 cu->header.abbrev_sect_off);
7278 init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file,
7279 result_dwo_abbrev_table->get ());
7281 /* Read in the die, but leave space to copy over the attributes
7282 from the stub. This has the benefit of simplifying the rest of
7283 the code - all the work to maintain the illusion of a single
7284 DW_TAG_{compile,type}_unit DIE is done here. */
7285 num_extra_attrs = ((stmt_list != NULL)
7289 + (comp_dir != NULL));
7290 info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
7291 result_has_children, num_extra_attrs);
7293 /* Copy over the attributes from the stub to the DIE we just read in. */
7294 comp_unit_die = *result_comp_unit_die;
7295 i = comp_unit_die->num_attrs;
7296 if (stmt_list != NULL)
7297 comp_unit_die->attrs[i++] = *stmt_list;
7299 comp_unit_die->attrs[i++] = *low_pc;
7300 if (high_pc != NULL)
7301 comp_unit_die->attrs[i++] = *high_pc;
7303 comp_unit_die->attrs[i++] = *ranges;
7304 if (comp_dir != NULL)
7305 comp_unit_die->attrs[i++] = *comp_dir;
7306 comp_unit_die->num_attrs += num_extra_attrs;
7308 if (dwarf_die_debug)
7310 fprintf_unfiltered (gdb_stdlog,
7311 "Read die from %s@0x%x of %s:\n",
7312 get_section_name (section),
7313 (unsigned) (begin_info_ptr - section->buffer),
7314 bfd_get_filename (abfd));
7315 dump_die (comp_unit_die, dwarf_die_debug);
7318 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7319 TUs by skipping the stub and going directly to the entry in the DWO file.
7320 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7321 to get it via circuitous means. Blech. */
7322 if (comp_dir != NULL)
7323 result_reader->comp_dir = DW_STRING (comp_dir);
7325 /* Skip dummy compilation units. */
7326 if (info_ptr >= begin_info_ptr + dwo_unit->length
7327 || peek_abbrev_code (abfd, info_ptr) == 0)
7330 *result_info_ptr = info_ptr;
7334 /* Subroutine of init_cutu_and_read_dies to simplify it.
7335 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7336 Returns NULL if the specified DWO unit cannot be found. */
7338 static struct dwo_unit *
7339 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
7340 struct die_info *comp_unit_die)
7342 struct dwarf2_cu *cu = this_cu->cu;
7344 struct dwo_unit *dwo_unit;
7345 const char *comp_dir, *dwo_name;
7347 gdb_assert (cu != NULL);
7349 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7350 dwo_name = dwarf2_string_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7351 comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7353 if (this_cu->is_debug_types)
7355 struct signatured_type *sig_type;
7357 /* Since this_cu is the first member of struct signatured_type,
7358 we can go from a pointer to one to a pointer to the other. */
7359 sig_type = (struct signatured_type *) this_cu;
7360 signature = sig_type->signature;
7361 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
7365 struct attribute *attr;
7367 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
7369 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7371 dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
7372 signature = DW_UNSND (attr);
7373 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
7380 /* Subroutine of init_cutu_and_read_dies to simplify it.
7381 See it for a description of the parameters.
7382 Read a TU directly from a DWO file, bypassing the stub. */
7385 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
7386 int use_existing_cu, int keep,
7387 die_reader_func_ftype *die_reader_func,
7390 std::unique_ptr<dwarf2_cu> new_cu;
7391 struct signatured_type *sig_type;
7392 struct die_reader_specs reader;
7393 const gdb_byte *info_ptr;
7394 struct die_info *comp_unit_die;
7396 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7398 /* Verify we can do the following downcast, and that we have the
7400 gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
7401 sig_type = (struct signatured_type *) this_cu;
7402 gdb_assert (sig_type->dwo_unit != NULL);
7404 if (use_existing_cu && this_cu->cu != NULL)
7406 gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
7407 /* There's no need to do the rereading_dwo_cu handling that
7408 init_cutu_and_read_dies does since we don't read the stub. */
7412 /* If !use_existing_cu, this_cu->cu must be NULL. */
7413 gdb_assert (this_cu->cu == NULL);
7414 new_cu.reset (new dwarf2_cu (this_cu));
7417 /* A future optimization, if needed, would be to use an existing
7418 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7419 could share abbrev tables. */
7421 /* The abbreviation table used by READER, this must live at least as long as
7423 abbrev_table_up dwo_abbrev_table;
7425 if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
7426 NULL /* stub_comp_unit_die */,
7427 sig_type->dwo_unit->dwo_file->comp_dir,
7429 &comp_unit_die, &has_children,
7430 &dwo_abbrev_table) == 0)
7436 /* All the "real" work is done here. */
7437 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7439 /* This duplicates the code in init_cutu_and_read_dies,
7440 but the alternative is making the latter more complex.
7441 This function is only for the special case of using DWO files directly:
7442 no point in overly complicating the general case just to handle this. */
7443 if (new_cu != NULL && keep)
7445 /* Link this CU into read_in_chain. */
7446 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7447 dwarf2_per_objfile->read_in_chain = this_cu;
7448 /* The chain owns it now. */
7453 /* Initialize a CU (or TU) and read its DIEs.
7454 If the CU defers to a DWO file, read the DWO file as well.
7456 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7457 Otherwise the table specified in the comp unit header is read in and used.
7458 This is an optimization for when we already have the abbrev table.
7460 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7461 Otherwise, a new CU is allocated with xmalloc.
7463 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7464 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7466 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7467 linker) then DIE_READER_FUNC will not get called. */
7470 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
7471 struct abbrev_table *abbrev_table,
7472 int use_existing_cu, int keep,
7474 die_reader_func_ftype *die_reader_func,
7477 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7478 struct objfile *objfile = dwarf2_per_objfile->objfile;
7479 struct dwarf2_section_info *section = this_cu->section;
7480 bfd *abfd = get_section_bfd_owner (section);
7481 struct dwarf2_cu *cu;
7482 const gdb_byte *begin_info_ptr, *info_ptr;
7483 struct die_reader_specs reader;
7484 struct die_info *comp_unit_die;
7486 struct attribute *attr;
7487 struct signatured_type *sig_type = NULL;
7488 struct dwarf2_section_info *abbrev_section;
7489 /* Non-zero if CU currently points to a DWO file and we need to
7490 reread it. When this happens we need to reread the skeleton die
7491 before we can reread the DWO file (this only applies to CUs, not TUs). */
7492 int rereading_dwo_cu = 0;
7494 if (dwarf_die_debug)
7495 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7496 this_cu->is_debug_types ? "type" : "comp",
7497 sect_offset_str (this_cu->sect_off));
7499 if (use_existing_cu)
7502 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7503 file (instead of going through the stub), short-circuit all of this. */
7504 if (this_cu->reading_dwo_directly)
7506 /* Narrow down the scope of possibilities to have to understand. */
7507 gdb_assert (this_cu->is_debug_types);
7508 gdb_assert (abbrev_table == NULL);
7509 init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
7510 die_reader_func, data);
7514 /* This is cheap if the section is already read in. */
7515 dwarf2_read_section (objfile, section);
7517 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7519 abbrev_section = get_abbrev_section_for_cu (this_cu);
7521 std::unique_ptr<dwarf2_cu> new_cu;
7522 if (use_existing_cu && this_cu->cu != NULL)
7525 /* If this CU is from a DWO file we need to start over, we need to
7526 refetch the attributes from the skeleton CU.
7527 This could be optimized by retrieving those attributes from when we
7528 were here the first time: the previous comp_unit_die was stored in
7529 comp_unit_obstack. But there's no data yet that we need this
7531 if (cu->dwo_unit != NULL)
7532 rereading_dwo_cu = 1;
7536 /* If !use_existing_cu, this_cu->cu must be NULL. */
7537 gdb_assert (this_cu->cu == NULL);
7538 new_cu.reset (new dwarf2_cu (this_cu));
7542 /* Get the header. */
7543 if (to_underlying (cu->header.first_die_cu_offset) != 0 && !rereading_dwo_cu)
7545 /* We already have the header, there's no need to read it in again. */
7546 info_ptr += to_underlying (cu->header.first_die_cu_offset);
7550 if (this_cu->is_debug_types)
7552 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7553 &cu->header, section,
7554 abbrev_section, info_ptr,
7557 /* Since per_cu is the first member of struct signatured_type,
7558 we can go from a pointer to one to a pointer to the other. */
7559 sig_type = (struct signatured_type *) this_cu;
7560 gdb_assert (sig_type->signature == cu->header.signature);
7561 gdb_assert (sig_type->type_offset_in_tu
7562 == cu->header.type_cu_offset_in_tu);
7563 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7565 /* LENGTH has not been set yet for type units if we're
7566 using .gdb_index. */
7567 this_cu->length = get_cu_length (&cu->header);
7569 /* Establish the type offset that can be used to lookup the type. */
7570 sig_type->type_offset_in_section =
7571 this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu);
7573 this_cu->dwarf_version = cu->header.version;
7577 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7578 &cu->header, section,
7581 rcuh_kind::COMPILE);
7583 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7584 gdb_assert (this_cu->length == get_cu_length (&cu->header));
7585 this_cu->dwarf_version = cu->header.version;
7589 /* Skip dummy compilation units. */
7590 if (info_ptr >= begin_info_ptr + this_cu->length
7591 || peek_abbrev_code (abfd, info_ptr) == 0)
7594 /* If we don't have them yet, read the abbrevs for this compilation unit.
7595 And if we need to read them now, make sure they're freed when we're
7596 done (own the table through ABBREV_TABLE_HOLDER). */
7597 abbrev_table_up abbrev_table_holder;
7598 if (abbrev_table != NULL)
7599 gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off);
7603 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7604 cu->header.abbrev_sect_off);
7605 abbrev_table = abbrev_table_holder.get ();
7608 /* Read the top level CU/TU die. */
7609 init_cu_die_reader (&reader, cu, section, NULL, abbrev_table);
7610 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7612 if (skip_partial && comp_unit_die->tag == DW_TAG_partial_unit)
7615 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7616 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7617 table from the DWO file and pass the ownership over to us. It will be
7618 referenced from READER, so we must make sure to free it after we're done
7621 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7622 DWO CU, that this test will fail (the attribute will not be present). */
7623 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7624 abbrev_table_up dwo_abbrev_table;
7627 struct dwo_unit *dwo_unit;
7628 struct die_info *dwo_comp_unit_die;
7632 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7633 " has children (offset %s) [in module %s]"),
7634 sect_offset_str (this_cu->sect_off),
7635 bfd_get_filename (abfd));
7637 dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
7638 if (dwo_unit != NULL)
7640 if (read_cutu_die_from_dwo (this_cu, dwo_unit,
7641 comp_unit_die, NULL,
7643 &dwo_comp_unit_die, &has_children,
7644 &dwo_abbrev_table) == 0)
7649 comp_unit_die = dwo_comp_unit_die;
7653 /* Yikes, we couldn't find the rest of the DIE, we only have
7654 the stub. A complaint has already been logged. There's
7655 not much more we can do except pass on the stub DIE to
7656 die_reader_func. We don't want to throw an error on bad
7661 /* All of the above is setup for this call. Yikes. */
7662 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7664 /* Done, clean up. */
7665 if (new_cu != NULL && keep)
7667 /* Link this CU into read_in_chain. */
7668 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7669 dwarf2_per_objfile->read_in_chain = this_cu;
7670 /* The chain owns it now. */
7675 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7676 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7677 to have already done the lookup to find the DWO file).
7679 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7680 THIS_CU->is_debug_types, but nothing else.
7682 We fill in THIS_CU->length.
7684 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7685 linker) then DIE_READER_FUNC will not get called.
7687 THIS_CU->cu is always freed when done.
7688 This is done in order to not leave THIS_CU->cu in a state where we have
7689 to care whether it refers to the "main" CU or the DWO CU. */
7692 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
7693 struct dwo_file *dwo_file,
7694 die_reader_func_ftype *die_reader_func,
7697 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7698 struct objfile *objfile = dwarf2_per_objfile->objfile;
7699 struct dwarf2_section_info *section = this_cu->section;
7700 bfd *abfd = get_section_bfd_owner (section);
7701 struct dwarf2_section_info *abbrev_section;
7702 const gdb_byte *begin_info_ptr, *info_ptr;
7703 struct die_reader_specs reader;
7704 struct die_info *comp_unit_die;
7707 if (dwarf_die_debug)
7708 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7709 this_cu->is_debug_types ? "type" : "comp",
7710 sect_offset_str (this_cu->sect_off));
7712 gdb_assert (this_cu->cu == NULL);
7714 abbrev_section = (dwo_file != NULL
7715 ? &dwo_file->sections.abbrev
7716 : get_abbrev_section_for_cu (this_cu));
7718 /* This is cheap if the section is already read in. */
7719 dwarf2_read_section (objfile, section);
7721 struct dwarf2_cu cu (this_cu);
7723 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7724 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7725 &cu.header, section,
7726 abbrev_section, info_ptr,
7727 (this_cu->is_debug_types
7729 : rcuh_kind::COMPILE));
7731 this_cu->length = get_cu_length (&cu.header);
7733 /* Skip dummy compilation units. */
7734 if (info_ptr >= begin_info_ptr + this_cu->length
7735 || peek_abbrev_code (abfd, info_ptr) == 0)
7738 abbrev_table_up abbrev_table
7739 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7740 cu.header.abbrev_sect_off);
7742 init_cu_die_reader (&reader, &cu, section, dwo_file, abbrev_table.get ());
7743 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7745 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7748 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7749 does not lookup the specified DWO file.
7750 This cannot be used to read DWO files.
7752 THIS_CU->cu is always freed when done.
7753 This is done in order to not leave THIS_CU->cu in a state where we have
7754 to care whether it refers to the "main" CU or the DWO CU.
7755 We can revisit this if the data shows there's a performance issue. */
7758 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
7759 die_reader_func_ftype *die_reader_func,
7762 init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
7765 /* Type Unit Groups.
7767 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7768 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7769 so that all types coming from the same compilation (.o file) are grouped
7770 together. A future step could be to put the types in the same symtab as
7771 the CU the types ultimately came from. */
7774 hash_type_unit_group (const void *item)
7776 const struct type_unit_group *tu_group
7777 = (const struct type_unit_group *) item;
7779 return hash_stmt_list_entry (&tu_group->hash);
7783 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
7785 const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
7786 const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
7788 return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
7791 /* Allocate a hash table for type unit groups. */
7794 allocate_type_unit_groups_table (struct objfile *objfile)
7796 return htab_create_alloc_ex (3,
7797 hash_type_unit_group,
7800 &objfile->objfile_obstack,
7801 hashtab_obstack_allocate,
7802 dummy_obstack_deallocate);
7805 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7806 partial symtabs. We combine several TUs per psymtab to not let the size
7807 of any one psymtab grow too big. */
7808 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7809 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7811 /* Helper routine for get_type_unit_group.
7812 Create the type_unit_group object used to hold one or more TUs. */
7814 static struct type_unit_group *
7815 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
7817 struct dwarf2_per_objfile *dwarf2_per_objfile
7818 = cu->per_cu->dwarf2_per_objfile;
7819 struct objfile *objfile = dwarf2_per_objfile->objfile;
7820 struct dwarf2_per_cu_data *per_cu;
7821 struct type_unit_group *tu_group;
7823 tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7824 struct type_unit_group);
7825 per_cu = &tu_group->per_cu;
7826 per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
7828 if (dwarf2_per_objfile->using_index)
7830 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7831 struct dwarf2_per_cu_quick_data);
7835 unsigned int line_offset = to_underlying (line_offset_struct);
7836 struct partial_symtab *pst;
7839 /* Give the symtab a useful name for debug purposes. */
7840 if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
7841 name = string_printf ("<type_units_%d>",
7842 (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
7844 name = string_printf ("<type_units_at_0x%x>", line_offset);
7846 pst = create_partial_symtab (per_cu, name.c_str ());
7850 tu_group->hash.dwo_unit = cu->dwo_unit;
7851 tu_group->hash.line_sect_off = line_offset_struct;
7856 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7857 STMT_LIST is a DW_AT_stmt_list attribute. */
7859 static struct type_unit_group *
7860 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
7862 struct dwarf2_per_objfile *dwarf2_per_objfile
7863 = cu->per_cu->dwarf2_per_objfile;
7864 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
7865 struct type_unit_group *tu_group;
7867 unsigned int line_offset;
7868 struct type_unit_group type_unit_group_for_lookup;
7870 if (dwarf2_per_objfile->type_unit_groups == NULL)
7872 dwarf2_per_objfile->type_unit_groups =
7873 allocate_type_unit_groups_table (dwarf2_per_objfile->objfile);
7876 /* Do we need to create a new group, or can we use an existing one? */
7880 line_offset = DW_UNSND (stmt_list);
7881 ++tu_stats->nr_symtab_sharers;
7885 /* Ugh, no stmt_list. Rare, but we have to handle it.
7886 We can do various things here like create one group per TU or
7887 spread them over multiple groups to split up the expansion work.
7888 To avoid worst case scenarios (too many groups or too large groups)
7889 we, umm, group them in bunches. */
7890 line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7891 | (tu_stats->nr_stmt_less_type_units
7892 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
7893 ++tu_stats->nr_stmt_less_type_units;
7896 type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
7897 type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;
7898 slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
7899 &type_unit_group_for_lookup, INSERT);
7902 tu_group = (struct type_unit_group *) *slot;
7903 gdb_assert (tu_group != NULL);
7907 sect_offset line_offset_struct = (sect_offset) line_offset;
7908 tu_group = create_type_unit_group (cu, line_offset_struct);
7910 ++tu_stats->nr_symtabs;
7916 /* Partial symbol tables. */
7918 /* Create a psymtab named NAME and assign it to PER_CU.
7920 The caller must fill in the following details:
7921 dirname, textlow, texthigh. */
7923 static struct partial_symtab *
7924 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
7926 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
7927 struct partial_symtab *pst;
7929 pst = start_psymtab_common (objfile, name, 0);
7931 pst->psymtabs_addrmap_supported = 1;
7933 /* This is the glue that links PST into GDB's symbol API. */
7934 pst->read_symtab_private = per_cu;
7935 pst->read_symtab = dwarf2_read_symtab;
7936 per_cu->v.psymtab = pst;
7941 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7944 struct process_psymtab_comp_unit_data
7946 /* True if we are reading a DW_TAG_partial_unit. */
7948 int want_partial_unit;
7950 /* The "pretend" language that is used if the CU doesn't declare a
7953 enum language pretend_language;
7956 /* die_reader_func for process_psymtab_comp_unit. */
7959 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
7960 const gdb_byte *info_ptr,
7961 struct die_info *comp_unit_die,
7965 struct dwarf2_cu *cu = reader->cu;
7966 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
7967 struct gdbarch *gdbarch = get_objfile_arch (objfile);
7968 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
7970 CORE_ADDR best_lowpc = 0, best_highpc = 0;
7971 struct partial_symtab *pst;
7972 enum pc_bounds_kind cu_bounds_kind;
7973 const char *filename;
7974 struct process_psymtab_comp_unit_data *info
7975 = (struct process_psymtab_comp_unit_data *) data;
7977 if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
7980 gdb_assert (! per_cu->is_debug_types);
7982 prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
7984 /* Allocate a new partial symbol table structure. */
7985 filename = dwarf2_string_attr (comp_unit_die, DW_AT_name, cu);
7986 if (filename == NULL)
7989 pst = create_partial_symtab (per_cu, filename);
7991 /* This must be done before calling dwarf2_build_include_psymtabs. */
7992 pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7994 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7996 dwarf2_find_base_address (comp_unit_die, cu);
7998 /* Possibly set the default values of LOWPC and HIGHPC from
8000 cu_bounds_kind = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
8001 &best_highpc, cu, pst);
8002 if (cu_bounds_kind == PC_BOUNDS_HIGH_LOW && best_lowpc < best_highpc)
8005 = (gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr)
8008 = (gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr)
8010 /* Store the contiguous range if it is not empty; it can be
8011 empty for CUs with no code. */
8012 addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
8016 /* Check if comp unit has_children.
8017 If so, read the rest of the partial symbols from this comp unit.
8018 If not, there's no more debug_info for this comp unit. */
8021 struct partial_die_info *first_die;
8022 CORE_ADDR lowpc, highpc;
8024 lowpc = ((CORE_ADDR) -1);
8025 highpc = ((CORE_ADDR) 0);
8027 first_die = load_partial_dies (reader, info_ptr, 1);
8029 scan_partial_symbols (first_die, &lowpc, &highpc,
8030 cu_bounds_kind <= PC_BOUNDS_INVALID, cu);
8032 /* If we didn't find a lowpc, set it to highpc to avoid
8033 complaints from `maint check'. */
8034 if (lowpc == ((CORE_ADDR) -1))
8037 /* If the compilation unit didn't have an explicit address range,
8038 then use the information extracted from its child dies. */
8039 if (cu_bounds_kind <= PC_BOUNDS_INVALID)
8042 best_highpc = highpc;
8045 pst->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch,
8046 best_lowpc + baseaddr)
8048 pst->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch,
8049 best_highpc + baseaddr)
8052 end_psymtab_common (objfile, pst);
8054 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
8057 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8058 struct dwarf2_per_cu_data *iter;
8060 /* Fill in 'dependencies' here; we fill in 'users' in a
8062 pst->number_of_dependencies = len;
8064 = objfile->partial_symtabs->allocate_dependencies (len);
8066 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8069 pst->dependencies[i] = iter->v.psymtab;
8071 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8074 /* Get the list of files included in the current compilation unit,
8075 and build a psymtab for each of them. */
8076 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
8078 if (dwarf_read_debug)
8079 fprintf_unfiltered (gdb_stdlog,
8080 "Psymtab for %s unit @%s: %s - %s"
8081 ", %d global, %d static syms\n",
8082 per_cu->is_debug_types ? "type" : "comp",
8083 sect_offset_str (per_cu->sect_off),
8084 paddress (gdbarch, pst->text_low (objfile)),
8085 paddress (gdbarch, pst->text_high (objfile)),
8086 pst->n_global_syms, pst->n_static_syms);
8089 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8090 Process compilation unit THIS_CU for a psymtab. */
8093 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
8094 int want_partial_unit,
8095 enum language pretend_language)
8097 /* If this compilation unit was already read in, free the
8098 cached copy in order to read it in again. This is
8099 necessary because we skipped some symbols when we first
8100 read in the compilation unit (see load_partial_dies).
8101 This problem could be avoided, but the benefit is unclear. */
8102 if (this_cu->cu != NULL)
8103 free_one_cached_comp_unit (this_cu);
8105 if (this_cu->is_debug_types)
8106 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8107 build_type_psymtabs_reader, NULL);
8110 process_psymtab_comp_unit_data info;
8111 info.want_partial_unit = want_partial_unit;
8112 info.pretend_language = pretend_language;
8113 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8114 process_psymtab_comp_unit_reader, &info);
8117 /* Age out any secondary CUs. */
8118 age_cached_comp_units (this_cu->dwarf2_per_objfile);
8121 /* Reader function for build_type_psymtabs. */
8124 build_type_psymtabs_reader (const struct die_reader_specs *reader,
8125 const gdb_byte *info_ptr,
8126 struct die_info *type_unit_die,
8130 struct dwarf2_per_objfile *dwarf2_per_objfile
8131 = reader->cu->per_cu->dwarf2_per_objfile;
8132 struct objfile *objfile = dwarf2_per_objfile->objfile;
8133 struct dwarf2_cu *cu = reader->cu;
8134 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8135 struct signatured_type *sig_type;
8136 struct type_unit_group *tu_group;
8137 struct attribute *attr;
8138 struct partial_die_info *first_die;
8139 CORE_ADDR lowpc, highpc;
8140 struct partial_symtab *pst;
8142 gdb_assert (data == NULL);
8143 gdb_assert (per_cu->is_debug_types);
8144 sig_type = (struct signatured_type *) per_cu;
8149 attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
8150 tu_group = get_type_unit_group (cu, attr);
8152 VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
8154 prepare_one_comp_unit (cu, type_unit_die, language_minimal);
8155 pst = create_partial_symtab (per_cu, "");
8158 first_die = load_partial_dies (reader, info_ptr, 1);
8160 lowpc = (CORE_ADDR) -1;
8161 highpc = (CORE_ADDR) 0;
8162 scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
8164 end_psymtab_common (objfile, pst);
8167 /* Struct used to sort TUs by their abbreviation table offset. */
8169 struct tu_abbrev_offset
8171 tu_abbrev_offset (signatured_type *sig_type_, sect_offset abbrev_offset_)
8172 : sig_type (sig_type_), abbrev_offset (abbrev_offset_)
8175 signatured_type *sig_type;
8176 sect_offset abbrev_offset;
8179 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
8182 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset &a,
8183 const struct tu_abbrev_offset &b)
8185 return a.abbrev_offset < b.abbrev_offset;
8188 /* Efficiently read all the type units.
8189 This does the bulk of the work for build_type_psymtabs.
8191 The efficiency is because we sort TUs by the abbrev table they use and
8192 only read each abbrev table once. In one program there are 200K TUs
8193 sharing 8K abbrev tables.
8195 The main purpose of this function is to support building the
8196 dwarf2_per_objfile->type_unit_groups table.
8197 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8198 can collapse the search space by grouping them by stmt_list.
8199 The savings can be significant, in the same program from above the 200K TUs
8200 share 8K stmt_list tables.
8202 FUNC is expected to call get_type_unit_group, which will create the
8203 struct type_unit_group if necessary and add it to
8204 dwarf2_per_objfile->type_unit_groups. */
8207 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
8209 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8210 abbrev_table_up abbrev_table;
8211 sect_offset abbrev_offset;
8213 /* It's up to the caller to not call us multiple times. */
8214 gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
8216 if (dwarf2_per_objfile->all_type_units.empty ())
8219 /* TUs typically share abbrev tables, and there can be way more TUs than
8220 abbrev tables. Sort by abbrev table to reduce the number of times we
8221 read each abbrev table in.
8222 Alternatives are to punt or to maintain a cache of abbrev tables.
8223 This is simpler and efficient enough for now.
8225 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8226 symtab to use). Typically TUs with the same abbrev offset have the same
8227 stmt_list value too so in practice this should work well.
8229 The basic algorithm here is:
8231 sort TUs by abbrev table
8232 for each TU with same abbrev table:
8233 read abbrev table if first user
8234 read TU top level DIE
8235 [IWBN if DWO skeletons had DW_AT_stmt_list]
8238 if (dwarf_read_debug)
8239 fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
8241 /* Sort in a separate table to maintain the order of all_type_units
8242 for .gdb_index: TU indices directly index all_type_units. */
8243 std::vector<tu_abbrev_offset> sorted_by_abbrev;
8244 sorted_by_abbrev.reserve (dwarf2_per_objfile->all_type_units.size ());
8246 for (signatured_type *sig_type : dwarf2_per_objfile->all_type_units)
8247 sorted_by_abbrev.emplace_back
8248 (sig_type, read_abbrev_offset (dwarf2_per_objfile,
8249 sig_type->per_cu.section,
8250 sig_type->per_cu.sect_off));
8252 std::sort (sorted_by_abbrev.begin (), sorted_by_abbrev.end (),
8253 sort_tu_by_abbrev_offset);
8255 abbrev_offset = (sect_offset) ~(unsigned) 0;
8257 for (const tu_abbrev_offset &tu : sorted_by_abbrev)
8259 /* Switch to the next abbrev table if necessary. */
8260 if (abbrev_table == NULL
8261 || tu.abbrev_offset != abbrev_offset)
8263 abbrev_offset = tu.abbrev_offset;
8265 abbrev_table_read_table (dwarf2_per_objfile,
8266 &dwarf2_per_objfile->abbrev,
8268 ++tu_stats->nr_uniq_abbrev_tables;
8271 init_cutu_and_read_dies (&tu.sig_type->per_cu, abbrev_table.get (),
8272 0, 0, false, build_type_psymtabs_reader, NULL);
8276 /* Print collected type unit statistics. */
8279 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
8281 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8283 fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
8284 fprintf_unfiltered (gdb_stdlog, " %zu TUs\n",
8285 dwarf2_per_objfile->all_type_units.size ());
8286 fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
8287 tu_stats->nr_uniq_abbrev_tables);
8288 fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
8289 tu_stats->nr_symtabs);
8290 fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
8291 tu_stats->nr_symtab_sharers);
8292 fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
8293 tu_stats->nr_stmt_less_type_units);
8294 fprintf_unfiltered (gdb_stdlog, " %d all_type_units reallocs\n",
8295 tu_stats->nr_all_type_units_reallocs);
8298 /* Traversal function for build_type_psymtabs. */
8301 build_type_psymtab_dependencies (void **slot, void *info)
8303 struct dwarf2_per_objfile *dwarf2_per_objfile
8304 = (struct dwarf2_per_objfile *) info;
8305 struct objfile *objfile = dwarf2_per_objfile->objfile;
8306 struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
8307 struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
8308 struct partial_symtab *pst = per_cu->v.psymtab;
8309 int len = VEC_length (sig_type_ptr, tu_group->tus);
8310 struct signatured_type *iter;
8313 gdb_assert (len > 0);
8314 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
8316 pst->number_of_dependencies = len;
8317 pst->dependencies = objfile->partial_symtabs->allocate_dependencies (len);
8319 VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
8322 gdb_assert (iter->per_cu.is_debug_types);
8323 pst->dependencies[i] = iter->per_cu.v.psymtab;
8324 iter->type_unit_group = tu_group;
8327 VEC_free (sig_type_ptr, tu_group->tus);
8332 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8333 Build partial symbol tables for the .debug_types comp-units. */
8336 build_type_psymtabs (struct dwarf2_per_objfile *dwarf2_per_objfile)
8338 if (! create_all_type_units (dwarf2_per_objfile))
8341 build_type_psymtabs_1 (dwarf2_per_objfile);
8344 /* Traversal function for process_skeletonless_type_unit.
8345 Read a TU in a DWO file and build partial symbols for it. */
8348 process_skeletonless_type_unit (void **slot, void *info)
8350 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
8351 struct dwarf2_per_objfile *dwarf2_per_objfile
8352 = (struct dwarf2_per_objfile *) info;
8353 struct signatured_type find_entry, *entry;
8355 /* If this TU doesn't exist in the global table, add it and read it in. */
8357 if (dwarf2_per_objfile->signatured_types == NULL)
8359 dwarf2_per_objfile->signatured_types
8360 = allocate_signatured_type_table (dwarf2_per_objfile->objfile);
8363 find_entry.signature = dwo_unit->signature;
8364 slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
8366 /* If we've already seen this type there's nothing to do. What's happening
8367 is we're doing our own version of comdat-folding here. */
8371 /* This does the job that create_all_type_units would have done for
8373 entry = add_type_unit (dwarf2_per_objfile, dwo_unit->signature, slot);
8374 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, entry, dwo_unit);
8377 /* This does the job that build_type_psymtabs_1 would have done. */
8378 init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0, false,
8379 build_type_psymtabs_reader, NULL);
8384 /* Traversal function for process_skeletonless_type_units. */
8387 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
8389 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
8391 if (dwo_file->tus != NULL)
8393 htab_traverse_noresize (dwo_file->tus,
8394 process_skeletonless_type_unit, info);
8400 /* Scan all TUs of DWO files, verifying we've processed them.
8401 This is needed in case a TU was emitted without its skeleton.
8402 Note: This can't be done until we know what all the DWO files are. */
8405 process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8407 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8408 if (get_dwp_file (dwarf2_per_objfile) == NULL
8409 && dwarf2_per_objfile->dwo_files != NULL)
8411 htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
8412 process_dwo_file_for_skeletonless_type_units,
8413 dwarf2_per_objfile);
8417 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8420 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
8422 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8424 struct partial_symtab *pst = per_cu->v.psymtab;
8429 for (int j = 0; j < pst->number_of_dependencies; ++j)
8431 /* Set the 'user' field only if it is not already set. */
8432 if (pst->dependencies[j]->user == NULL)
8433 pst->dependencies[j]->user = pst;
8438 /* Build the partial symbol table by doing a quick pass through the
8439 .debug_info and .debug_abbrev sections. */
8442 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
8444 struct objfile *objfile = dwarf2_per_objfile->objfile;
8446 if (dwarf_read_debug)
8448 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
8449 objfile_name (objfile));
8452 dwarf2_per_objfile->reading_partial_symbols = 1;
8454 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
8456 /* Any cached compilation units will be linked by the per-objfile
8457 read_in_chain. Make sure to free them when we're done. */
8458 free_cached_comp_units freer (dwarf2_per_objfile);
8460 build_type_psymtabs (dwarf2_per_objfile);
8462 create_all_comp_units (dwarf2_per_objfile);
8464 /* Create a temporary address map on a temporary obstack. We later
8465 copy this to the final obstack. */
8466 auto_obstack temp_obstack;
8468 scoped_restore save_psymtabs_addrmap
8469 = make_scoped_restore (&objfile->partial_symtabs->psymtabs_addrmap,
8470 addrmap_create_mutable (&temp_obstack));
8472 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8473 process_psymtab_comp_unit (per_cu, 0, language_minimal);
8475 /* This has to wait until we read the CUs, we need the list of DWOs. */
8476 process_skeletonless_type_units (dwarf2_per_objfile);
8478 /* Now that all TUs have been processed we can fill in the dependencies. */
8479 if (dwarf2_per_objfile->type_unit_groups != NULL)
8481 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
8482 build_type_psymtab_dependencies, dwarf2_per_objfile);
8485 if (dwarf_read_debug)
8486 print_tu_stats (dwarf2_per_objfile);
8488 set_partial_user (dwarf2_per_objfile);
8490 objfile->partial_symtabs->psymtabs_addrmap
8491 = addrmap_create_fixed (objfile->partial_symtabs->psymtabs_addrmap,
8492 objfile->partial_symtabs->obstack ());
8493 /* At this point we want to keep the address map. */
8494 save_psymtabs_addrmap.release ();
8496 if (dwarf_read_debug)
8497 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
8498 objfile_name (objfile));
8501 /* die_reader_func for load_partial_comp_unit. */
8504 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
8505 const gdb_byte *info_ptr,
8506 struct die_info *comp_unit_die,
8510 struct dwarf2_cu *cu = reader->cu;
8512 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
8514 /* Check if comp unit has_children.
8515 If so, read the rest of the partial symbols from this comp unit.
8516 If not, there's no more debug_info for this comp unit. */
8518 load_partial_dies (reader, info_ptr, 0);
8521 /* Load the partial DIEs for a secondary CU into memory.
8522 This is also used when rereading a primary CU with load_all_dies. */
8525 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
8527 init_cutu_and_read_dies (this_cu, NULL, 1, 1, false,
8528 load_partial_comp_unit_reader, NULL);
8532 read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
8533 struct dwarf2_section_info *section,
8534 struct dwarf2_section_info *abbrev_section,
8535 unsigned int is_dwz)
8537 const gdb_byte *info_ptr;
8538 struct objfile *objfile = dwarf2_per_objfile->objfile;
8540 if (dwarf_read_debug)
8541 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
8542 get_section_name (section),
8543 get_section_file_name (section));
8545 dwarf2_read_section (objfile, section);
8547 info_ptr = section->buffer;
8549 while (info_ptr < section->buffer + section->size)
8551 struct dwarf2_per_cu_data *this_cu;
8553 sect_offset sect_off = (sect_offset) (info_ptr - section->buffer);
8555 comp_unit_head cu_header;
8556 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
8557 abbrev_section, info_ptr,
8558 rcuh_kind::COMPILE);
8560 /* Save the compilation unit for later lookup. */
8561 if (cu_header.unit_type != DW_UT_type)
8563 this_cu = XOBNEW (&objfile->objfile_obstack,
8564 struct dwarf2_per_cu_data);
8565 memset (this_cu, 0, sizeof (*this_cu));
8569 auto sig_type = XOBNEW (&objfile->objfile_obstack,
8570 struct signatured_type);
8571 memset (sig_type, 0, sizeof (*sig_type));
8572 sig_type->signature = cu_header.signature;
8573 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
8574 this_cu = &sig_type->per_cu;
8576 this_cu->is_debug_types = (cu_header.unit_type == DW_UT_type);
8577 this_cu->sect_off = sect_off;
8578 this_cu->length = cu_header.length + cu_header.initial_length_size;
8579 this_cu->is_dwz = is_dwz;
8580 this_cu->dwarf2_per_objfile = dwarf2_per_objfile;
8581 this_cu->section = section;
8583 dwarf2_per_objfile->all_comp_units.push_back (this_cu);
8585 info_ptr = info_ptr + this_cu->length;
8589 /* Create a list of all compilation units in OBJFILE.
8590 This is only done for -readnow and building partial symtabs. */
8593 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8595 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
8596 read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
8597 &dwarf2_per_objfile->abbrev, 0);
8599 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
8601 read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
8605 /* Process all loaded DIEs for compilation unit CU, starting at
8606 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8607 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8608 DW_AT_ranges). See the comments of add_partial_subprogram on how
8609 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8612 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
8613 CORE_ADDR *highpc, int set_addrmap,
8614 struct dwarf2_cu *cu)
8616 struct partial_die_info *pdi;
8618 /* Now, march along the PDI's, descending into ones which have
8619 interesting children but skipping the children of the other ones,
8620 until we reach the end of the compilation unit. */
8628 /* Anonymous namespaces or modules have no name but have interesting
8629 children, so we need to look at them. Ditto for anonymous
8632 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
8633 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
8634 || pdi->tag == DW_TAG_imported_unit
8635 || pdi->tag == DW_TAG_inlined_subroutine)
8639 case DW_TAG_subprogram:
8640 case DW_TAG_inlined_subroutine:
8641 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
8643 case DW_TAG_constant:
8644 case DW_TAG_variable:
8645 case DW_TAG_typedef:
8646 case DW_TAG_union_type:
8647 if (!pdi->is_declaration)
8649 add_partial_symbol (pdi, cu);
8652 case DW_TAG_class_type:
8653 case DW_TAG_interface_type:
8654 case DW_TAG_structure_type:
8655 if (!pdi->is_declaration)
8657 add_partial_symbol (pdi, cu);
8659 if ((cu->language == language_rust
8660 || cu->language == language_cplus) && pdi->has_children)
8661 scan_partial_symbols (pdi->die_child, lowpc, highpc,
8664 case DW_TAG_enumeration_type:
8665 if (!pdi->is_declaration)
8666 add_partial_enumeration (pdi, cu);
8668 case DW_TAG_base_type:
8669 case DW_TAG_subrange_type:
8670 /* File scope base type definitions are added to the partial
8672 add_partial_symbol (pdi, cu);
8674 case DW_TAG_namespace:
8675 add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
8678 add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
8680 case DW_TAG_imported_unit:
8682 struct dwarf2_per_cu_data *per_cu;
8684 /* For now we don't handle imported units in type units. */
8685 if (cu->per_cu->is_debug_types)
8687 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8688 " supported in type units [in module %s]"),
8689 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
8692 per_cu = dwarf2_find_containing_comp_unit
8693 (pdi->d.sect_off, pdi->is_dwz,
8694 cu->per_cu->dwarf2_per_objfile);
8696 /* Go read the partial unit, if needed. */
8697 if (per_cu->v.psymtab == NULL)
8698 process_psymtab_comp_unit (per_cu, 1, cu->language);
8700 VEC_safe_push (dwarf2_per_cu_ptr,
8701 cu->per_cu->imported_symtabs, per_cu);
8704 case DW_TAG_imported_declaration:
8705 add_partial_symbol (pdi, cu);
8712 /* If the die has a sibling, skip to the sibling. */
8714 pdi = pdi->die_sibling;
8718 /* Functions used to compute the fully scoped name of a partial DIE.
8720 Normally, this is simple. For C++, the parent DIE's fully scoped
8721 name is concatenated with "::" and the partial DIE's name.
8722 Enumerators are an exception; they use the scope of their parent
8723 enumeration type, i.e. the name of the enumeration type is not
8724 prepended to the enumerator.
8726 There are two complexities. One is DW_AT_specification; in this
8727 case "parent" means the parent of the target of the specification,
8728 instead of the direct parent of the DIE. The other is compilers
8729 which do not emit DW_TAG_namespace; in this case we try to guess
8730 the fully qualified name of structure types from their members'
8731 linkage names. This must be done using the DIE's children rather
8732 than the children of any DW_AT_specification target. We only need
8733 to do this for structures at the top level, i.e. if the target of
8734 any DW_AT_specification (if any; otherwise the DIE itself) does not
8737 /* Compute the scope prefix associated with PDI's parent, in
8738 compilation unit CU. The result will be allocated on CU's
8739 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8740 field. NULL is returned if no prefix is necessary. */
8742 partial_die_parent_scope (struct partial_die_info *pdi,
8743 struct dwarf2_cu *cu)
8745 const char *grandparent_scope;
8746 struct partial_die_info *parent, *real_pdi;
8748 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8749 then this means the parent of the specification DIE. */
8752 while (real_pdi->has_specification)
8753 real_pdi = find_partial_die (real_pdi->spec_offset,
8754 real_pdi->spec_is_dwz, cu);
8756 parent = real_pdi->die_parent;
8760 if (parent->scope_set)
8761 return parent->scope;
8765 grandparent_scope = partial_die_parent_scope (parent, cu);
8767 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8768 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8769 Work around this problem here. */
8770 if (cu->language == language_cplus
8771 && parent->tag == DW_TAG_namespace
8772 && strcmp (parent->name, "::") == 0
8773 && grandparent_scope == NULL)
8775 parent->scope = NULL;
8776 parent->scope_set = 1;
8780 if (pdi->tag == DW_TAG_enumerator)
8781 /* Enumerators should not get the name of the enumeration as a prefix. */
8782 parent->scope = grandparent_scope;
8783 else if (parent->tag == DW_TAG_namespace
8784 || parent->tag == DW_TAG_module
8785 || parent->tag == DW_TAG_structure_type
8786 || parent->tag == DW_TAG_class_type
8787 || parent->tag == DW_TAG_interface_type
8788 || parent->tag == DW_TAG_union_type
8789 || parent->tag == DW_TAG_enumeration_type)
8791 if (grandparent_scope == NULL)
8792 parent->scope = parent->name;
8794 parent->scope = typename_concat (&cu->comp_unit_obstack,
8796 parent->name, 0, cu);
8800 /* FIXME drow/2004-04-01: What should we be doing with
8801 function-local names? For partial symbols, we should probably be
8803 complaint (_("unhandled containing DIE tag %d for DIE at %s"),
8804 parent->tag, sect_offset_str (pdi->sect_off));
8805 parent->scope = grandparent_scope;
8808 parent->scope_set = 1;
8809 return parent->scope;
8812 /* Return the fully scoped name associated with PDI, from compilation unit
8813 CU. The result will be allocated with malloc. */
8816 partial_die_full_name (struct partial_die_info *pdi,
8817 struct dwarf2_cu *cu)
8819 const char *parent_scope;
8821 /* If this is a template instantiation, we can not work out the
8822 template arguments from partial DIEs. So, unfortunately, we have
8823 to go through the full DIEs. At least any work we do building
8824 types here will be reused if full symbols are loaded later. */
8825 if (pdi->has_template_arguments)
8829 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
8831 struct die_info *die;
8832 struct attribute attr;
8833 struct dwarf2_cu *ref_cu = cu;
8835 /* DW_FORM_ref_addr is using section offset. */
8836 attr.name = (enum dwarf_attribute) 0;
8837 attr.form = DW_FORM_ref_addr;
8838 attr.u.unsnd = to_underlying (pdi->sect_off);
8839 die = follow_die_ref (NULL, &attr, &ref_cu);
8841 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
8845 parent_scope = partial_die_parent_scope (pdi, cu);
8846 if (parent_scope == NULL)
8849 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
8853 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
8855 struct dwarf2_per_objfile *dwarf2_per_objfile
8856 = cu->per_cu->dwarf2_per_objfile;
8857 struct objfile *objfile = dwarf2_per_objfile->objfile;
8858 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8860 const char *actual_name = NULL;
8862 char *built_actual_name;
8864 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8866 built_actual_name = partial_die_full_name (pdi, cu);
8867 if (built_actual_name != NULL)
8868 actual_name = built_actual_name;
8870 if (actual_name == NULL)
8871 actual_name = pdi->name;
8875 case DW_TAG_inlined_subroutine:
8876 case DW_TAG_subprogram:
8877 addr = (gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr)
8879 if (pdi->is_external || cu->language == language_ada)
8881 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8882 of the global scope. But in Ada, we want to be able to access
8883 nested procedures globally. So all Ada subprograms are stored
8884 in the global scope. */
8885 add_psymbol_to_list (actual_name, strlen (actual_name),
8886 built_actual_name != NULL,
8887 VAR_DOMAIN, LOC_BLOCK,
8888 SECT_OFF_TEXT (objfile),
8889 psymbol_placement::GLOBAL,
8891 cu->language, objfile);
8895 add_psymbol_to_list (actual_name, strlen (actual_name),
8896 built_actual_name != NULL,
8897 VAR_DOMAIN, LOC_BLOCK,
8898 SECT_OFF_TEXT (objfile),
8899 psymbol_placement::STATIC,
8900 addr, cu->language, objfile);
8903 if (pdi->main_subprogram && actual_name != NULL)
8904 set_objfile_main_name (objfile, actual_name, cu->language);
8906 case DW_TAG_constant:
8907 add_psymbol_to_list (actual_name, strlen (actual_name),
8908 built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
8909 -1, (pdi->is_external
8910 ? psymbol_placement::GLOBAL
8911 : psymbol_placement::STATIC),
8912 0, cu->language, objfile);
8914 case DW_TAG_variable:
8916 addr = decode_locdesc (pdi->d.locdesc, cu);
8920 && !dwarf2_per_objfile->has_section_at_zero)
8922 /* A global or static variable may also have been stripped
8923 out by the linker if unused, in which case its address
8924 will be nullified; do not add such variables into partial
8925 symbol table then. */
8927 else if (pdi->is_external)
8930 Don't enter into the minimal symbol tables as there is
8931 a minimal symbol table entry from the ELF symbols already.
8932 Enter into partial symbol table if it has a location
8933 descriptor or a type.
8934 If the location descriptor is missing, new_symbol will create
8935 a LOC_UNRESOLVED symbol, the address of the variable will then
8936 be determined from the minimal symbol table whenever the variable
8938 The address for the partial symbol table entry is not
8939 used by GDB, but it comes in handy for debugging partial symbol
8942 if (pdi->d.locdesc || pdi->has_type)
8943 add_psymbol_to_list (actual_name, strlen (actual_name),
8944 built_actual_name != NULL,
8945 VAR_DOMAIN, LOC_STATIC,
8946 SECT_OFF_TEXT (objfile),
8947 psymbol_placement::GLOBAL,
8948 addr, cu->language, objfile);
8952 int has_loc = pdi->d.locdesc != NULL;
8954 /* Static Variable. Skip symbols whose value we cannot know (those
8955 without location descriptors or constant values). */
8956 if (!has_loc && !pdi->has_const_value)
8958 xfree (built_actual_name);
8962 add_psymbol_to_list (actual_name, strlen (actual_name),
8963 built_actual_name != NULL,
8964 VAR_DOMAIN, LOC_STATIC,
8965 SECT_OFF_TEXT (objfile),
8966 psymbol_placement::STATIC,
8968 cu->language, objfile);
8971 case DW_TAG_typedef:
8972 case DW_TAG_base_type:
8973 case DW_TAG_subrange_type:
8974 add_psymbol_to_list (actual_name, strlen (actual_name),
8975 built_actual_name != NULL,
8976 VAR_DOMAIN, LOC_TYPEDEF, -1,
8977 psymbol_placement::STATIC,
8978 0, cu->language, objfile);
8980 case DW_TAG_imported_declaration:
8981 case DW_TAG_namespace:
8982 add_psymbol_to_list (actual_name, strlen (actual_name),
8983 built_actual_name != NULL,
8984 VAR_DOMAIN, LOC_TYPEDEF, -1,
8985 psymbol_placement::GLOBAL,
8986 0, cu->language, objfile);
8989 add_psymbol_to_list (actual_name, strlen (actual_name),
8990 built_actual_name != NULL,
8991 MODULE_DOMAIN, LOC_TYPEDEF, -1,
8992 psymbol_placement::GLOBAL,
8993 0, cu->language, objfile);
8995 case DW_TAG_class_type:
8996 case DW_TAG_interface_type:
8997 case DW_TAG_structure_type:
8998 case DW_TAG_union_type:
8999 case DW_TAG_enumeration_type:
9000 /* Skip external references. The DWARF standard says in the section
9001 about "Structure, Union, and Class Type Entries": "An incomplete
9002 structure, union or class type is represented by a structure,
9003 union or class entry that does not have a byte size attribute
9004 and that has a DW_AT_declaration attribute." */
9005 if (!pdi->has_byte_size && pdi->is_declaration)
9007 xfree (built_actual_name);
9011 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9012 static vs. global. */
9013 add_psymbol_to_list (actual_name, strlen (actual_name),
9014 built_actual_name != NULL,
9015 STRUCT_DOMAIN, LOC_TYPEDEF, -1,
9016 cu->language == language_cplus
9017 ? psymbol_placement::GLOBAL
9018 : psymbol_placement::STATIC,
9019 0, cu->language, objfile);
9022 case DW_TAG_enumerator:
9023 add_psymbol_to_list (actual_name, strlen (actual_name),
9024 built_actual_name != NULL,
9025 VAR_DOMAIN, LOC_CONST, -1,
9026 cu->language == language_cplus
9027 ? psymbol_placement::GLOBAL
9028 : psymbol_placement::STATIC,
9029 0, cu->language, objfile);
9035 xfree (built_actual_name);
9038 /* Read a partial die corresponding to a namespace; also, add a symbol
9039 corresponding to that namespace to the symbol table. NAMESPACE is
9040 the name of the enclosing namespace. */
9043 add_partial_namespace (struct partial_die_info *pdi,
9044 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9045 int set_addrmap, struct dwarf2_cu *cu)
9047 /* Add a symbol for the namespace. */
9049 add_partial_symbol (pdi, cu);
9051 /* Now scan partial symbols in that namespace. */
9053 if (pdi->has_children)
9054 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9057 /* Read a partial die corresponding to a Fortran module. */
9060 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
9061 CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
9063 /* Add a symbol for the namespace. */
9065 add_partial_symbol (pdi, cu);
9067 /* Now scan partial symbols in that module. */
9069 if (pdi->has_children)
9070 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9073 /* Read a partial die corresponding to a subprogram or an inlined
9074 subprogram and create a partial symbol for that subprogram.
9075 When the CU language allows it, this routine also defines a partial
9076 symbol for each nested subprogram that this subprogram contains.
9077 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9078 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9080 PDI may also be a lexical block, in which case we simply search
9081 recursively for subprograms defined inside that lexical block.
9082 Again, this is only performed when the CU language allows this
9083 type of definitions. */
9086 add_partial_subprogram (struct partial_die_info *pdi,
9087 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9088 int set_addrmap, struct dwarf2_cu *cu)
9090 if (pdi->tag == DW_TAG_subprogram || pdi->tag == DW_TAG_inlined_subroutine)
9092 if (pdi->has_pc_info)
9094 if (pdi->lowpc < *lowpc)
9095 *lowpc = pdi->lowpc;
9096 if (pdi->highpc > *highpc)
9097 *highpc = pdi->highpc;
9100 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9101 struct gdbarch *gdbarch = get_objfile_arch (objfile);
9103 CORE_ADDR this_highpc;
9104 CORE_ADDR this_lowpc;
9106 baseaddr = ANOFFSET (objfile->section_offsets,
9107 SECT_OFF_TEXT (objfile));
9109 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9110 pdi->lowpc + baseaddr)
9113 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9114 pdi->highpc + baseaddr)
9116 addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
9117 this_lowpc, this_highpc - 1,
9118 cu->per_cu->v.psymtab);
9122 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
9124 if (!pdi->is_declaration)
9125 /* Ignore subprogram DIEs that do not have a name, they are
9126 illegal. Do not emit a complaint at this point, we will
9127 do so when we convert this psymtab into a symtab. */
9129 add_partial_symbol (pdi, cu);
9133 if (! pdi->has_children)
9136 if (cu->language == language_ada)
9138 pdi = pdi->die_child;
9142 if (pdi->tag == DW_TAG_subprogram
9143 || pdi->tag == DW_TAG_inlined_subroutine
9144 || pdi->tag == DW_TAG_lexical_block)
9145 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
9146 pdi = pdi->die_sibling;
9151 /* Read a partial die corresponding to an enumeration type. */
9154 add_partial_enumeration (struct partial_die_info *enum_pdi,
9155 struct dwarf2_cu *cu)
9157 struct partial_die_info *pdi;
9159 if (enum_pdi->name != NULL)
9160 add_partial_symbol (enum_pdi, cu);
9162 pdi = enum_pdi->die_child;
9165 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
9166 complaint (_("malformed enumerator DIE ignored"));
9168 add_partial_symbol (pdi, cu);
9169 pdi = pdi->die_sibling;
9173 /* Return the initial uleb128 in the die at INFO_PTR. */
9176 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
9178 unsigned int bytes_read;
9180 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9183 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9184 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
9186 Return the corresponding abbrev, or NULL if the number is zero (indicating
9187 an empty DIE). In either case *BYTES_READ will be set to the length of
9188 the initial number. */
9190 static struct abbrev_info *
9191 peek_die_abbrev (const die_reader_specs &reader,
9192 const gdb_byte *info_ptr, unsigned int *bytes_read)
9194 dwarf2_cu *cu = reader.cu;
9195 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
9196 unsigned int abbrev_number
9197 = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
9199 if (abbrev_number == 0)
9202 abbrev_info *abbrev = reader.abbrev_table->lookup_abbrev (abbrev_number);
9205 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9206 " at offset %s [in module %s]"),
9207 abbrev_number, cu->per_cu->is_debug_types ? "TU" : "CU",
9208 sect_offset_str (cu->header.sect_off), bfd_get_filename (abfd));
9214 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9215 Returns a pointer to the end of a series of DIEs, terminated by an empty
9216 DIE. Any children of the skipped DIEs will also be skipped. */
9218 static const gdb_byte *
9219 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
9223 unsigned int bytes_read;
9224 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
9227 return info_ptr + bytes_read;
9229 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
9233 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9234 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9235 abbrev corresponding to that skipped uleb128 should be passed in
9236 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9239 static const gdb_byte *
9240 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
9241 struct abbrev_info *abbrev)
9243 unsigned int bytes_read;
9244 struct attribute attr;
9245 bfd *abfd = reader->abfd;
9246 struct dwarf2_cu *cu = reader->cu;
9247 const gdb_byte *buffer = reader->buffer;
9248 const gdb_byte *buffer_end = reader->buffer_end;
9249 unsigned int form, i;
9251 for (i = 0; i < abbrev->num_attrs; i++)
9253 /* The only abbrev we care about is DW_AT_sibling. */
9254 if (abbrev->attrs[i].name == DW_AT_sibling)
9256 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
9257 if (attr.form == DW_FORM_ref_addr)
9258 complaint (_("ignoring absolute DW_AT_sibling"));
9261 sect_offset off = dwarf2_get_ref_die_offset (&attr);
9262 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
9264 if (sibling_ptr < info_ptr)
9265 complaint (_("DW_AT_sibling points backwards"));
9266 else if (sibling_ptr > reader->buffer_end)
9267 dwarf2_section_buffer_overflow_complaint (reader->die_section);
9273 /* If it isn't DW_AT_sibling, skip this attribute. */
9274 form = abbrev->attrs[i].form;
9278 case DW_FORM_ref_addr:
9279 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9280 and later it is offset sized. */
9281 if (cu->header.version == 2)
9282 info_ptr += cu->header.addr_size;
9284 info_ptr += cu->header.offset_size;
9286 case DW_FORM_GNU_ref_alt:
9287 info_ptr += cu->header.offset_size;
9290 info_ptr += cu->header.addr_size;
9297 case DW_FORM_flag_present:
9298 case DW_FORM_implicit_const:
9310 case DW_FORM_ref_sig8:
9313 case DW_FORM_data16:
9316 case DW_FORM_string:
9317 read_direct_string (abfd, info_ptr, &bytes_read);
9318 info_ptr += bytes_read;
9320 case DW_FORM_sec_offset:
9322 case DW_FORM_GNU_strp_alt:
9323 info_ptr += cu->header.offset_size;
9325 case DW_FORM_exprloc:
9327 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9328 info_ptr += bytes_read;
9330 case DW_FORM_block1:
9331 info_ptr += 1 + read_1_byte (abfd, info_ptr);
9333 case DW_FORM_block2:
9334 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
9336 case DW_FORM_block4:
9337 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
9341 case DW_FORM_ref_udata:
9342 case DW_FORM_GNU_addr_index:
9343 case DW_FORM_GNU_str_index:
9344 info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
9346 case DW_FORM_indirect:
9347 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9348 info_ptr += bytes_read;
9349 /* We need to continue parsing from here, so just go back to
9351 goto skip_attribute;
9354 error (_("Dwarf Error: Cannot handle %s "
9355 "in DWARF reader [in module %s]"),
9356 dwarf_form_name (form),
9357 bfd_get_filename (abfd));
9361 if (abbrev->has_children)
9362 return skip_children (reader, info_ptr);
9367 /* Locate ORIG_PDI's sibling.
9368 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9370 static const gdb_byte *
9371 locate_pdi_sibling (const struct die_reader_specs *reader,
9372 struct partial_die_info *orig_pdi,
9373 const gdb_byte *info_ptr)
9375 /* Do we know the sibling already? */
9377 if (orig_pdi->sibling)
9378 return orig_pdi->sibling;
9380 /* Are there any children to deal with? */
9382 if (!orig_pdi->has_children)
9385 /* Skip the children the long way. */
9387 return skip_children (reader, info_ptr);
9390 /* Expand this partial symbol table into a full symbol table. SELF is
9394 dwarf2_read_symtab (struct partial_symtab *self,
9395 struct objfile *objfile)
9397 struct dwarf2_per_objfile *dwarf2_per_objfile
9398 = get_dwarf2_per_objfile (objfile);
9402 warning (_("bug: psymtab for %s is already read in."),
9409 printf_filtered (_("Reading in symbols for %s..."),
9411 gdb_flush (gdb_stdout);
9414 /* If this psymtab is constructed from a debug-only objfile, the
9415 has_section_at_zero flag will not necessarily be correct. We
9416 can get the correct value for this flag by looking at the data
9417 associated with the (presumably stripped) associated objfile. */
9418 if (objfile->separate_debug_objfile_backlink)
9420 struct dwarf2_per_objfile *dpo_backlink
9421 = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
9423 dwarf2_per_objfile->has_section_at_zero
9424 = dpo_backlink->has_section_at_zero;
9427 dwarf2_per_objfile->reading_partial_symbols = 0;
9429 psymtab_to_symtab_1 (self);
9431 /* Finish up the debug error message. */
9433 printf_filtered (_("done.\n"));
9436 process_cu_includes (dwarf2_per_objfile);
9439 /* Reading in full CUs. */
9441 /* Add PER_CU to the queue. */
9444 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
9445 enum language pretend_language)
9447 struct dwarf2_queue_item *item;
9450 item = XNEW (struct dwarf2_queue_item);
9451 item->per_cu = per_cu;
9452 item->pretend_language = pretend_language;
9455 if (dwarf2_queue == NULL)
9456 dwarf2_queue = item;
9458 dwarf2_queue_tail->next = item;
9460 dwarf2_queue_tail = item;
9463 /* If PER_CU is not yet queued, add it to the queue.
9464 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9466 The result is non-zero if PER_CU was queued, otherwise the result is zero
9467 meaning either PER_CU is already queued or it is already loaded.
9469 N.B. There is an invariant here that if a CU is queued then it is loaded.
9470 The caller is required to load PER_CU if we return non-zero. */
9473 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
9474 struct dwarf2_per_cu_data *per_cu,
9475 enum language pretend_language)
9477 /* We may arrive here during partial symbol reading, if we need full
9478 DIEs to process an unusual case (e.g. template arguments). Do
9479 not queue PER_CU, just tell our caller to load its DIEs. */
9480 if (per_cu->dwarf2_per_objfile->reading_partial_symbols)
9482 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
9487 /* Mark the dependence relation so that we don't flush PER_CU
9489 if (dependent_cu != NULL)
9490 dwarf2_add_dependence (dependent_cu, per_cu);
9492 /* If it's already on the queue, we have nothing to do. */
9496 /* If the compilation unit is already loaded, just mark it as
9498 if (per_cu->cu != NULL)
9500 per_cu->cu->last_used = 0;
9504 /* Add it to the queue. */
9505 queue_comp_unit (per_cu, pretend_language);
9510 /* Process the queue. */
9513 process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
9515 struct dwarf2_queue_item *item, *next_item;
9517 if (dwarf_read_debug)
9519 fprintf_unfiltered (gdb_stdlog,
9520 "Expanding one or more symtabs of objfile %s ...\n",
9521 objfile_name (dwarf2_per_objfile->objfile));
9524 /* The queue starts out with one item, but following a DIE reference
9525 may load a new CU, adding it to the end of the queue. */
9526 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
9528 if ((dwarf2_per_objfile->using_index
9529 ? !item->per_cu->v.quick->compunit_symtab
9530 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
9531 /* Skip dummy CUs. */
9532 && item->per_cu->cu != NULL)
9534 struct dwarf2_per_cu_data *per_cu = item->per_cu;
9535 unsigned int debug_print_threshold;
9538 if (per_cu->is_debug_types)
9540 struct signatured_type *sig_type =
9541 (struct signatured_type *) per_cu;
9543 sprintf (buf, "TU %s at offset %s",
9544 hex_string (sig_type->signature),
9545 sect_offset_str (per_cu->sect_off));
9546 /* There can be 100s of TUs.
9547 Only print them in verbose mode. */
9548 debug_print_threshold = 2;
9552 sprintf (buf, "CU at offset %s",
9553 sect_offset_str (per_cu->sect_off));
9554 debug_print_threshold = 1;
9557 if (dwarf_read_debug >= debug_print_threshold)
9558 fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
9560 if (per_cu->is_debug_types)
9561 process_full_type_unit (per_cu, item->pretend_language);
9563 process_full_comp_unit (per_cu, item->pretend_language);
9565 if (dwarf_read_debug >= debug_print_threshold)
9566 fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
9569 item->per_cu->queued = 0;
9570 next_item = item->next;
9574 dwarf2_queue_tail = NULL;
9576 if (dwarf_read_debug)
9578 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
9579 objfile_name (dwarf2_per_objfile->objfile));
9583 /* Read in full symbols for PST, and anything it depends on. */
9586 psymtab_to_symtab_1 (struct partial_symtab *pst)
9588 struct dwarf2_per_cu_data *per_cu;
9594 for (i = 0; i < pst->number_of_dependencies; i++)
9595 if (!pst->dependencies[i]->readin
9596 && pst->dependencies[i]->user == NULL)
9598 /* Inform about additional files that need to be read in. */
9601 /* FIXME: i18n: Need to make this a single string. */
9602 fputs_filtered (" ", gdb_stdout);
9604 fputs_filtered ("and ", gdb_stdout);
9606 printf_filtered ("%s...", pst->dependencies[i]->filename);
9607 wrap_here (""); /* Flush output. */
9608 gdb_flush (gdb_stdout);
9610 psymtab_to_symtab_1 (pst->dependencies[i]);
9613 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
9617 /* It's an include file, no symbols to read for it.
9618 Everything is in the parent symtab. */
9623 dw2_do_instantiate_symtab (per_cu, false);
9626 /* Trivial hash function for die_info: the hash value of a DIE
9627 is its offset in .debug_info for this objfile. */
9630 die_hash (const void *item)
9632 const struct die_info *die = (const struct die_info *) item;
9634 return to_underlying (die->sect_off);
9637 /* Trivial comparison function for die_info structures: two DIEs
9638 are equal if they have the same offset. */
9641 die_eq (const void *item_lhs, const void *item_rhs)
9643 const struct die_info *die_lhs = (const struct die_info *) item_lhs;
9644 const struct die_info *die_rhs = (const struct die_info *) item_rhs;
9646 return die_lhs->sect_off == die_rhs->sect_off;
9649 /* die_reader_func for load_full_comp_unit.
9650 This is identical to read_signatured_type_reader,
9651 but is kept separate for now. */
9654 load_full_comp_unit_reader (const struct die_reader_specs *reader,
9655 const gdb_byte *info_ptr,
9656 struct die_info *comp_unit_die,
9660 struct dwarf2_cu *cu = reader->cu;
9661 enum language *language_ptr = (enum language *) data;
9663 gdb_assert (cu->die_hash == NULL);
9665 htab_create_alloc_ex (cu->header.length / 12,
9669 &cu->comp_unit_obstack,
9670 hashtab_obstack_allocate,
9671 dummy_obstack_deallocate);
9674 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
9675 &info_ptr, comp_unit_die);
9676 cu->dies = comp_unit_die;
9677 /* comp_unit_die is not stored in die_hash, no need. */
9679 /* We try not to read any attributes in this function, because not
9680 all CUs needed for references have been loaded yet, and symbol
9681 table processing isn't initialized. But we have to set the CU language,
9682 or we won't be able to build types correctly.
9683 Similarly, if we do not read the producer, we can not apply
9684 producer-specific interpretation. */
9685 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
9688 /* Load the DIEs associated with PER_CU into memory. */
9691 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
9693 enum language pretend_language)
9695 gdb_assert (! this_cu->is_debug_types);
9697 init_cutu_and_read_dies (this_cu, NULL, 1, 1, skip_partial,
9698 load_full_comp_unit_reader, &pretend_language);
9701 /* Add a DIE to the delayed physname list. */
9704 add_to_method_list (struct type *type, int fnfield_index, int index,
9705 const char *name, struct die_info *die,
9706 struct dwarf2_cu *cu)
9708 struct delayed_method_info mi;
9710 mi.fnfield_index = fnfield_index;
9714 cu->method_list.push_back (mi);
9717 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9718 "const" / "volatile". If so, decrements LEN by the length of the
9719 modifier and return true. Otherwise return false. */
9723 check_modifier (const char *physname, size_t &len, const char (&mod)[N])
9725 size_t mod_len = sizeof (mod) - 1;
9726 if (len > mod_len && startswith (physname + (len - mod_len), mod))
9734 /* Compute the physnames of any methods on the CU's method list.
9736 The computation of method physnames is delayed in order to avoid the
9737 (bad) condition that one of the method's formal parameters is of an as yet
9741 compute_delayed_physnames (struct dwarf2_cu *cu)
9743 /* Only C++ delays computing physnames. */
9744 if (cu->method_list.empty ())
9746 gdb_assert (cu->language == language_cplus);
9748 for (const delayed_method_info &mi : cu->method_list)
9750 const char *physname;
9751 struct fn_fieldlist *fn_flp
9752 = &TYPE_FN_FIELDLIST (mi.type, mi.fnfield_index);
9753 physname = dwarf2_physname (mi.name, mi.die, cu);
9754 TYPE_FN_FIELD_PHYSNAME (fn_flp->fn_fields, mi.index)
9755 = physname ? physname : "";
9757 /* Since there's no tag to indicate whether a method is a
9758 const/volatile overload, extract that information out of the
9760 if (physname != NULL)
9762 size_t len = strlen (physname);
9766 if (physname[len] == ')') /* shortcut */
9768 else if (check_modifier (physname, len, " const"))
9769 TYPE_FN_FIELD_CONST (fn_flp->fn_fields, mi.index) = 1;
9770 else if (check_modifier (physname, len, " volatile"))
9771 TYPE_FN_FIELD_VOLATILE (fn_flp->fn_fields, mi.index) = 1;
9778 /* The list is no longer needed. */
9779 cu->method_list.clear ();
9782 /* Go objects should be embedded in a DW_TAG_module DIE,
9783 and it's not clear if/how imported objects will appear.
9784 To keep Go support simple until that's worked out,
9785 go back through what we've read and create something usable.
9786 We could do this while processing each DIE, and feels kinda cleaner,
9787 but that way is more invasive.
9788 This is to, for example, allow the user to type "p var" or "b main"
9789 without having to specify the package name, and allow lookups
9790 of module.object to work in contexts that use the expression
9794 fixup_go_packaging (struct dwarf2_cu *cu)
9796 char *package_name = NULL;
9797 struct pending *list;
9800 for (list = *cu->builder->get_global_symbols ();
9804 for (i = 0; i < list->nsyms; ++i)
9806 struct symbol *sym = list->symbol[i];
9808 if (SYMBOL_LANGUAGE (sym) == language_go
9809 && SYMBOL_CLASS (sym) == LOC_BLOCK)
9811 char *this_package_name = go_symbol_package_name (sym);
9813 if (this_package_name == NULL)
9815 if (package_name == NULL)
9816 package_name = this_package_name;
9819 struct objfile *objfile
9820 = cu->per_cu->dwarf2_per_objfile->objfile;
9821 if (strcmp (package_name, this_package_name) != 0)
9822 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9823 (symbol_symtab (sym) != NULL
9824 ? symtab_to_filename_for_display
9825 (symbol_symtab (sym))
9826 : objfile_name (objfile)),
9827 this_package_name, package_name);
9828 xfree (this_package_name);
9834 if (package_name != NULL)
9836 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9837 const char *saved_package_name
9838 = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
9840 strlen (package_name));
9841 struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
9842 saved_package_name);
9845 sym = allocate_symbol (objfile);
9846 SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
9847 SYMBOL_SET_NAMES (sym, saved_package_name,
9848 strlen (saved_package_name), 0, objfile);
9849 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9850 e.g., "main" finds the "main" module and not C's main(). */
9851 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
9852 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
9853 SYMBOL_TYPE (sym) = type;
9855 add_symbol_to_list (sym, cu->builder->get_global_symbols ());
9857 xfree (package_name);
9861 /* Allocate a fully-qualified name consisting of the two parts on the
9865 rust_fully_qualify (struct obstack *obstack, const char *p1, const char *p2)
9867 return obconcat (obstack, p1, "::", p2, (char *) NULL);
9870 /* A helper that allocates a struct discriminant_info to attach to a
9873 static struct discriminant_info *
9874 alloc_discriminant_info (struct type *type, int discriminant_index,
9877 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9878 gdb_assert (discriminant_index == -1
9879 || (discriminant_index >= 0
9880 && discriminant_index < TYPE_NFIELDS (type)));
9881 gdb_assert (default_index == -1
9882 || (default_index >= 0 && default_index < TYPE_NFIELDS (type)));
9884 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
9886 struct discriminant_info *disc
9887 = ((struct discriminant_info *)
9889 offsetof (struct discriminant_info, discriminants)
9890 + TYPE_NFIELDS (type) * sizeof (disc->discriminants[0])));
9891 disc->default_index = default_index;
9892 disc->discriminant_index = discriminant_index;
9894 struct dynamic_prop prop;
9895 prop.kind = PROP_UNDEFINED;
9896 prop.data.baton = disc;
9898 add_dyn_prop (DYN_PROP_DISCRIMINATED, prop, type);
9903 /* Some versions of rustc emitted enums in an unusual way.
9905 Ordinary enums were emitted as unions. The first element of each
9906 structure in the union was named "RUST$ENUM$DISR". This element
9907 held the discriminant.
9909 These versions of Rust also implemented the "non-zero"
9910 optimization. When the enum had two values, and one is empty and
9911 the other holds a pointer that cannot be zero, the pointer is used
9912 as the discriminant, with a zero value meaning the empty variant.
9913 Here, the union's first member is of the form
9914 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9915 where the fieldnos are the indices of the fields that should be
9916 traversed in order to find the field (which may be several fields deep)
9917 and the variantname is the name of the variant of the case when the
9920 This function recognizes whether TYPE is of one of these forms,
9921 and, if so, smashes it to be a variant type. */
9924 quirk_rust_enum (struct type *type, struct objfile *objfile)
9926 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9928 /* We don't need to deal with empty enums. */
9929 if (TYPE_NFIELDS (type) == 0)
9932 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9933 if (TYPE_NFIELDS (type) == 1
9934 && startswith (TYPE_FIELD_NAME (type, 0), RUST_ENUM_PREFIX))
9936 const char *name = TYPE_FIELD_NAME (type, 0) + strlen (RUST_ENUM_PREFIX);
9938 /* Decode the field name to find the offset of the
9940 ULONGEST bit_offset = 0;
9941 struct type *field_type = TYPE_FIELD_TYPE (type, 0);
9942 while (name[0] >= '0' && name[0] <= '9')
9945 unsigned long index = strtoul (name, &tail, 10);
9948 || index >= TYPE_NFIELDS (field_type)
9949 || (TYPE_FIELD_LOC_KIND (field_type, index)
9950 != FIELD_LOC_KIND_BITPOS))
9952 complaint (_("Could not parse Rust enum encoding string \"%s\""
9954 TYPE_FIELD_NAME (type, 0),
9955 objfile_name (objfile));
9960 bit_offset += TYPE_FIELD_BITPOS (field_type, index);
9961 field_type = TYPE_FIELD_TYPE (field_type, index);
9964 /* Make a union to hold the variants. */
9965 struct type *union_type = alloc_type (objfile);
9966 TYPE_CODE (union_type) = TYPE_CODE_UNION;
9967 TYPE_NFIELDS (union_type) = 3;
9968 TYPE_FIELDS (union_type)
9969 = (struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field));
9970 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
9971 set_type_align (union_type, TYPE_RAW_ALIGN (type));
9973 /* Put the discriminant must at index 0. */
9974 TYPE_FIELD_TYPE (union_type, 0) = field_type;
9975 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
9976 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
9977 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 0), bit_offset);
9979 /* The order of fields doesn't really matter, so put the real
9980 field at index 1 and the data-less field at index 2. */
9981 struct discriminant_info *disc
9982 = alloc_discriminant_info (union_type, 0, 1);
9983 TYPE_FIELD (union_type, 1) = TYPE_FIELD (type, 0);
9984 TYPE_FIELD_NAME (union_type, 1)
9985 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1)));
9986 TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1))
9987 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
9988 TYPE_FIELD_NAME (union_type, 1));
9990 const char *dataless_name
9991 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
9993 struct type *dataless_type = init_type (objfile, TYPE_CODE_VOID, 0,
9995 TYPE_FIELD_TYPE (union_type, 2) = dataless_type;
9996 /* NAME points into the original discriminant name, which
9997 already has the correct lifetime. */
9998 TYPE_FIELD_NAME (union_type, 2) = name;
9999 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 2), 0);
10000 disc->discriminants[2] = 0;
10002 /* Smash this type to be a structure type. We have to do this
10003 because the type has already been recorded. */
10004 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10005 TYPE_NFIELDS (type) = 1;
10007 = (struct field *) TYPE_ZALLOC (type, sizeof (struct field));
10009 /* Install the variant part. */
10010 TYPE_FIELD_TYPE (type, 0) = union_type;
10011 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10012 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10014 else if (TYPE_NFIELDS (type) == 1)
10016 /* We assume that a union with a single field is a univariant
10018 /* Smash this type to be a structure type. We have to do this
10019 because the type has already been recorded. */
10020 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10022 /* Make a union to hold the variants. */
10023 struct type *union_type = alloc_type (objfile);
10024 TYPE_CODE (union_type) = TYPE_CODE_UNION;
10025 TYPE_NFIELDS (union_type) = TYPE_NFIELDS (type);
10026 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10027 set_type_align (union_type, TYPE_RAW_ALIGN (type));
10028 TYPE_FIELDS (union_type) = TYPE_FIELDS (type);
10030 struct type *field_type = TYPE_FIELD_TYPE (union_type, 0);
10031 const char *variant_name
10032 = rust_last_path_segment (TYPE_NAME (field_type));
10033 TYPE_FIELD_NAME (union_type, 0) = variant_name;
10034 TYPE_NAME (field_type)
10035 = rust_fully_qualify (&objfile->objfile_obstack,
10036 TYPE_NAME (type), variant_name);
10038 /* Install the union in the outer struct type. */
10039 TYPE_NFIELDS (type) = 1;
10041 = (struct field *) TYPE_ZALLOC (union_type, sizeof (struct field));
10042 TYPE_FIELD_TYPE (type, 0) = union_type;
10043 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10044 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10046 alloc_discriminant_info (union_type, -1, 0);
10050 struct type *disr_type = nullptr;
10051 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
10053 disr_type = TYPE_FIELD_TYPE (type, i);
10055 if (TYPE_CODE (disr_type) != TYPE_CODE_STRUCT)
10057 /* All fields of a true enum will be structs. */
10060 else if (TYPE_NFIELDS (disr_type) == 0)
10062 /* Could be data-less variant, so keep going. */
10063 disr_type = nullptr;
10065 else if (strcmp (TYPE_FIELD_NAME (disr_type, 0),
10066 "RUST$ENUM$DISR") != 0)
10068 /* Not a Rust enum. */
10078 /* If we got here without a discriminant, then it's probably
10080 if (disr_type == nullptr)
10083 /* Smash this type to be a structure type. We have to do this
10084 because the type has already been recorded. */
10085 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10087 /* Make a union to hold the variants. */
10088 struct field *disr_field = &TYPE_FIELD (disr_type, 0);
10089 struct type *union_type = alloc_type (objfile);
10090 TYPE_CODE (union_type) = TYPE_CODE_UNION;
10091 TYPE_NFIELDS (union_type) = 1 + TYPE_NFIELDS (type);
10092 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10093 set_type_align (union_type, TYPE_RAW_ALIGN (type));
10094 TYPE_FIELDS (union_type)
10095 = (struct field *) TYPE_ZALLOC (union_type,
10096 (TYPE_NFIELDS (union_type)
10097 * sizeof (struct field)));
10099 memcpy (TYPE_FIELDS (union_type) + 1, TYPE_FIELDS (type),
10100 TYPE_NFIELDS (type) * sizeof (struct field));
10102 /* Install the discriminant at index 0 in the union. */
10103 TYPE_FIELD (union_type, 0) = *disr_field;
10104 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10105 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10107 /* Install the union in the outer struct type. */
10108 TYPE_FIELD_TYPE (type, 0) = union_type;
10109 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10110 TYPE_NFIELDS (type) = 1;
10112 /* Set the size and offset of the union type. */
10113 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10115 /* We need a way to find the correct discriminant given a
10116 variant name. For convenience we build a map here. */
10117 struct type *enum_type = FIELD_TYPE (*disr_field);
10118 std::unordered_map<std::string, ULONGEST> discriminant_map;
10119 for (int i = 0; i < TYPE_NFIELDS (enum_type); ++i)
10121 if (TYPE_FIELD_LOC_KIND (enum_type, i) == FIELD_LOC_KIND_ENUMVAL)
10124 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type, i));
10125 discriminant_map[name] = TYPE_FIELD_ENUMVAL (enum_type, i);
10129 int n_fields = TYPE_NFIELDS (union_type);
10130 struct discriminant_info *disc
10131 = alloc_discriminant_info (union_type, 0, -1);
10132 /* Skip the discriminant here. */
10133 for (int i = 1; i < n_fields; ++i)
10135 /* Find the final word in the name of this variant's type.
10136 That name can be used to look up the correct
10138 const char *variant_name
10139 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type,
10142 auto iter = discriminant_map.find (variant_name);
10143 if (iter != discriminant_map.end ())
10144 disc->discriminants[i] = iter->second;
10146 /* Remove the discriminant field, if it exists. */
10147 struct type *sub_type = TYPE_FIELD_TYPE (union_type, i);
10148 if (TYPE_NFIELDS (sub_type) > 0)
10150 --TYPE_NFIELDS (sub_type);
10151 ++TYPE_FIELDS (sub_type);
10153 TYPE_FIELD_NAME (union_type, i) = variant_name;
10154 TYPE_NAME (sub_type)
10155 = rust_fully_qualify (&objfile->objfile_obstack,
10156 TYPE_NAME (type), variant_name);
10161 /* Rewrite some Rust unions to be structures with variants parts. */
10164 rust_union_quirks (struct dwarf2_cu *cu)
10166 gdb_assert (cu->language == language_rust);
10167 for (type *type_ : cu->rust_unions)
10168 quirk_rust_enum (type_, cu->per_cu->dwarf2_per_objfile->objfile);
10169 /* We don't need this any more. */
10170 cu->rust_unions.clear ();
10173 /* Return the symtab for PER_CU. This works properly regardless of
10174 whether we're using the index or psymtabs. */
10176 static struct compunit_symtab *
10177 get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
10179 return (per_cu->dwarf2_per_objfile->using_index
10180 ? per_cu->v.quick->compunit_symtab
10181 : per_cu->v.psymtab->compunit_symtab);
10184 /* A helper function for computing the list of all symbol tables
10185 included by PER_CU. */
10188 recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
10189 htab_t all_children, htab_t all_type_symtabs,
10190 struct dwarf2_per_cu_data *per_cu,
10191 struct compunit_symtab *immediate_parent)
10195 struct compunit_symtab *cust;
10196 struct dwarf2_per_cu_data *iter;
10198 slot = htab_find_slot (all_children, per_cu, INSERT);
10201 /* This inclusion and its children have been processed. */
10206 /* Only add a CU if it has a symbol table. */
10207 cust = get_compunit_symtab (per_cu);
10210 /* If this is a type unit only add its symbol table if we haven't
10211 seen it yet (type unit per_cu's can share symtabs). */
10212 if (per_cu->is_debug_types)
10214 slot = htab_find_slot (all_type_symtabs, cust, INSERT);
10218 result->push_back (cust);
10219 if (cust->user == NULL)
10220 cust->user = immediate_parent;
10225 result->push_back (cust);
10226 if (cust->user == NULL)
10227 cust->user = immediate_parent;
10232 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
10235 recursively_compute_inclusions (result, all_children,
10236 all_type_symtabs, iter, cust);
10240 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10244 compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
10246 gdb_assert (! per_cu->is_debug_types);
10248 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
10251 struct dwarf2_per_cu_data *per_cu_iter;
10252 std::vector<compunit_symtab *> result_symtabs;
10253 htab_t all_children, all_type_symtabs;
10254 struct compunit_symtab *cust = get_compunit_symtab (per_cu);
10256 /* If we don't have a symtab, we can just skip this case. */
10260 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10261 NULL, xcalloc, xfree);
10262 all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10263 NULL, xcalloc, xfree);
10266 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
10270 recursively_compute_inclusions (&result_symtabs, all_children,
10271 all_type_symtabs, per_cu_iter,
10275 /* Now we have a transitive closure of all the included symtabs. */
10276 len = result_symtabs.size ();
10278 = XOBNEWVEC (&per_cu->dwarf2_per_objfile->objfile->objfile_obstack,
10279 struct compunit_symtab *, len + 1);
10280 memcpy (cust->includes, result_symtabs.data (),
10281 len * sizeof (compunit_symtab *));
10282 cust->includes[len] = NULL;
10284 htab_delete (all_children);
10285 htab_delete (all_type_symtabs);
10289 /* Compute the 'includes' field for the symtabs of all the CUs we just
10293 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
10295 for (dwarf2_per_cu_data *iter : dwarf2_per_objfile->just_read_cus)
10297 if (! iter->is_debug_types)
10298 compute_compunit_symtab_includes (iter);
10301 dwarf2_per_objfile->just_read_cus.clear ();
10304 /* Generate full symbol information for PER_CU, whose DIEs have
10305 already been loaded into memory. */
10308 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
10309 enum language pretend_language)
10311 struct dwarf2_cu *cu = per_cu->cu;
10312 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10313 struct objfile *objfile = dwarf2_per_objfile->objfile;
10314 struct gdbarch *gdbarch = get_objfile_arch (objfile);
10315 CORE_ADDR lowpc, highpc;
10316 struct compunit_symtab *cust;
10317 CORE_ADDR baseaddr;
10318 struct block *static_block;
10321 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
10323 /* Clear the list here in case something was left over. */
10324 cu->method_list.clear ();
10326 cu->language = pretend_language;
10327 cu->language_defn = language_def (cu->language);
10329 /* Do line number decoding in read_file_scope () */
10330 process_die (cu->dies, cu);
10332 /* For now fudge the Go package. */
10333 if (cu->language == language_go)
10334 fixup_go_packaging (cu);
10336 /* Now that we have processed all the DIEs in the CU, all the types
10337 should be complete, and it should now be safe to compute all of the
10339 compute_delayed_physnames (cu);
10341 if (cu->language == language_rust)
10342 rust_union_quirks (cu);
10344 /* Some compilers don't define a DW_AT_high_pc attribute for the
10345 compilation unit. If the DW_AT_high_pc is missing, synthesize
10346 it, by scanning the DIE's below the compilation unit. */
10347 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
10349 addr = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
10350 static_block = cu->builder->end_symtab_get_static_block (addr, 0, 1);
10352 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10353 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10354 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10355 addrmap to help ensure it has an accurate map of pc values belonging to
10357 dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
10359 cust = cu->builder->end_symtab_from_static_block (static_block,
10360 SECT_OFF_TEXT (objfile),
10365 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
10367 /* Set symtab language to language from DW_AT_language. If the
10368 compilation is from a C file generated by language preprocessors, do
10369 not set the language if it was already deduced by start_subfile. */
10370 if (!(cu->language == language_c
10371 && COMPUNIT_FILETABS (cust)->language != language_unknown))
10372 COMPUNIT_FILETABS (cust)->language = cu->language;
10374 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10375 produce DW_AT_location with location lists but it can be possibly
10376 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10377 there were bugs in prologue debug info, fixed later in GCC-4.5
10378 by "unwind info for epilogues" patch (which is not directly related).
10380 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10381 needed, it would be wrong due to missing DW_AT_producer there.
10383 Still one can confuse GDB by using non-standard GCC compilation
10384 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10386 if (cu->has_loclist && gcc_4_minor >= 5)
10387 cust->locations_valid = 1;
10389 if (gcc_4_minor >= 5)
10390 cust->epilogue_unwind_valid = 1;
10392 cust->call_site_htab = cu->call_site_htab;
10395 if (dwarf2_per_objfile->using_index)
10396 per_cu->v.quick->compunit_symtab = cust;
10399 struct partial_symtab *pst = per_cu->v.psymtab;
10400 pst->compunit_symtab = cust;
10404 /* Push it for inclusion processing later. */
10405 dwarf2_per_objfile->just_read_cus.push_back (per_cu);
10407 /* Not needed any more. */
10408 cu->builder.reset ();
10411 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10412 already been loaded into memory. */
10415 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
10416 enum language pretend_language)
10418 struct dwarf2_cu *cu = per_cu->cu;
10419 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10420 struct objfile *objfile = dwarf2_per_objfile->objfile;
10421 struct compunit_symtab *cust;
10422 struct signatured_type *sig_type;
10424 gdb_assert (per_cu->is_debug_types);
10425 sig_type = (struct signatured_type *) per_cu;
10427 /* Clear the list here in case something was left over. */
10428 cu->method_list.clear ();
10430 cu->language = pretend_language;
10431 cu->language_defn = language_def (cu->language);
10433 /* The symbol tables are set up in read_type_unit_scope. */
10434 process_die (cu->dies, cu);
10436 /* For now fudge the Go package. */
10437 if (cu->language == language_go)
10438 fixup_go_packaging (cu);
10440 /* Now that we have processed all the DIEs in the CU, all the types
10441 should be complete, and it should now be safe to compute all of the
10443 compute_delayed_physnames (cu);
10445 if (cu->language == language_rust)
10446 rust_union_quirks (cu);
10448 /* TUs share symbol tables.
10449 If this is the first TU to use this symtab, complete the construction
10450 of it with end_expandable_symtab. Otherwise, complete the addition of
10451 this TU's symbols to the existing symtab. */
10452 if (sig_type->type_unit_group->compunit_symtab == NULL)
10454 cust = cu->builder->end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
10455 sig_type->type_unit_group->compunit_symtab = cust;
10459 /* Set symtab language to language from DW_AT_language. If the
10460 compilation is from a C file generated by language preprocessors,
10461 do not set the language if it was already deduced by
10463 if (!(cu->language == language_c
10464 && COMPUNIT_FILETABS (cust)->language != language_c))
10465 COMPUNIT_FILETABS (cust)->language = cu->language;
10470 cu->builder->augment_type_symtab ();
10471 cust = sig_type->type_unit_group->compunit_symtab;
10474 if (dwarf2_per_objfile->using_index)
10475 per_cu->v.quick->compunit_symtab = cust;
10478 struct partial_symtab *pst = per_cu->v.psymtab;
10479 pst->compunit_symtab = cust;
10483 /* Not needed any more. */
10484 cu->builder.reset ();
10487 /* Process an imported unit DIE. */
10490 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
10492 struct attribute *attr;
10494 /* For now we don't handle imported units in type units. */
10495 if (cu->per_cu->is_debug_types)
10497 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10498 " supported in type units [in module %s]"),
10499 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
10502 attr = dwarf2_attr (die, DW_AT_import, cu);
10505 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
10506 bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
10507 dwarf2_per_cu_data *per_cu
10508 = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
10509 cu->per_cu->dwarf2_per_objfile);
10511 /* If necessary, add it to the queue and load its DIEs. */
10512 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
10513 load_full_comp_unit (per_cu, false, cu->language);
10515 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
10520 /* RAII object that represents a process_die scope: i.e.,
10521 starts/finishes processing a DIE. */
10522 class process_die_scope
10525 process_die_scope (die_info *die, dwarf2_cu *cu)
10526 : m_die (die), m_cu (cu)
10528 /* We should only be processing DIEs not already in process. */
10529 gdb_assert (!m_die->in_process);
10530 m_die->in_process = true;
10533 ~process_die_scope ()
10535 m_die->in_process = false;
10537 /* If we're done processing the DIE for the CU that owns the line
10538 header, we don't need the line header anymore. */
10539 if (m_cu->line_header_die_owner == m_die)
10541 delete m_cu->line_header;
10542 m_cu->line_header = NULL;
10543 m_cu->line_header_die_owner = NULL;
10552 /* Process a die and its children. */
10555 process_die (struct die_info *die, struct dwarf2_cu *cu)
10557 process_die_scope scope (die, cu);
10561 case DW_TAG_padding:
10563 case DW_TAG_compile_unit:
10564 case DW_TAG_partial_unit:
10565 read_file_scope (die, cu);
10567 case DW_TAG_type_unit:
10568 read_type_unit_scope (die, cu);
10570 case DW_TAG_subprogram:
10571 case DW_TAG_inlined_subroutine:
10572 read_func_scope (die, cu);
10574 case DW_TAG_lexical_block:
10575 case DW_TAG_try_block:
10576 case DW_TAG_catch_block:
10577 read_lexical_block_scope (die, cu);
10579 case DW_TAG_call_site:
10580 case DW_TAG_GNU_call_site:
10581 read_call_site_scope (die, cu);
10583 case DW_TAG_class_type:
10584 case DW_TAG_interface_type:
10585 case DW_TAG_structure_type:
10586 case DW_TAG_union_type:
10587 process_structure_scope (die, cu);
10589 case DW_TAG_enumeration_type:
10590 process_enumeration_scope (die, cu);
10593 /* These dies have a type, but processing them does not create
10594 a symbol or recurse to process the children. Therefore we can
10595 read them on-demand through read_type_die. */
10596 case DW_TAG_subroutine_type:
10597 case DW_TAG_set_type:
10598 case DW_TAG_array_type:
10599 case DW_TAG_pointer_type:
10600 case DW_TAG_ptr_to_member_type:
10601 case DW_TAG_reference_type:
10602 case DW_TAG_rvalue_reference_type:
10603 case DW_TAG_string_type:
10606 case DW_TAG_base_type:
10607 case DW_TAG_subrange_type:
10608 case DW_TAG_typedef:
10609 /* Add a typedef symbol for the type definition, if it has a
10611 new_symbol (die, read_type_die (die, cu), cu);
10613 case DW_TAG_common_block:
10614 read_common_block (die, cu);
10616 case DW_TAG_common_inclusion:
10618 case DW_TAG_namespace:
10619 cu->processing_has_namespace_info = true;
10620 read_namespace (die, cu);
10622 case DW_TAG_module:
10623 cu->processing_has_namespace_info = true;
10624 read_module (die, cu);
10626 case DW_TAG_imported_declaration:
10627 cu->processing_has_namespace_info = true;
10628 if (read_namespace_alias (die, cu))
10630 /* The declaration is not a global namespace alias. */
10631 /* Fall through. */
10632 case DW_TAG_imported_module:
10633 cu->processing_has_namespace_info = true;
10634 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
10635 || cu->language != language_fortran))
10636 complaint (_("Tag '%s' has unexpected children"),
10637 dwarf_tag_name (die->tag));
10638 read_import_statement (die, cu);
10641 case DW_TAG_imported_unit:
10642 process_imported_unit_die (die, cu);
10645 case DW_TAG_variable:
10646 read_variable (die, cu);
10650 new_symbol (die, NULL, cu);
10655 /* DWARF name computation. */
10657 /* A helper function for dwarf2_compute_name which determines whether DIE
10658 needs to have the name of the scope prepended to the name listed in the
10662 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
10664 struct attribute *attr;
10668 case DW_TAG_namespace:
10669 case DW_TAG_typedef:
10670 case DW_TAG_class_type:
10671 case DW_TAG_interface_type:
10672 case DW_TAG_structure_type:
10673 case DW_TAG_union_type:
10674 case DW_TAG_enumeration_type:
10675 case DW_TAG_enumerator:
10676 case DW_TAG_subprogram:
10677 case DW_TAG_inlined_subroutine:
10678 case DW_TAG_member:
10679 case DW_TAG_imported_declaration:
10682 case DW_TAG_variable:
10683 case DW_TAG_constant:
10684 /* We only need to prefix "globally" visible variables. These include
10685 any variable marked with DW_AT_external or any variable that
10686 lives in a namespace. [Variables in anonymous namespaces
10687 require prefixing, but they are not DW_AT_external.] */
10689 if (dwarf2_attr (die, DW_AT_specification, cu))
10691 struct dwarf2_cu *spec_cu = cu;
10693 return die_needs_namespace (die_specification (die, &spec_cu),
10697 attr = dwarf2_attr (die, DW_AT_external, cu);
10698 if (attr == NULL && die->parent->tag != DW_TAG_namespace
10699 && die->parent->tag != DW_TAG_module)
10701 /* A variable in a lexical block of some kind does not need a
10702 namespace, even though in C++ such variables may be external
10703 and have a mangled name. */
10704 if (die->parent->tag == DW_TAG_lexical_block
10705 || die->parent->tag == DW_TAG_try_block
10706 || die->parent->tag == DW_TAG_catch_block
10707 || die->parent->tag == DW_TAG_subprogram)
10716 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10717 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10718 defined for the given DIE. */
10720 static struct attribute *
10721 dw2_linkage_name_attr (struct die_info *die, struct dwarf2_cu *cu)
10723 struct attribute *attr;
10725 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
10727 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
10732 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10733 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10734 defined for the given DIE. */
10736 static const char *
10737 dw2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
10739 const char *linkage_name;
10741 linkage_name = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
10742 if (linkage_name == NULL)
10743 linkage_name = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
10745 return linkage_name;
10748 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10749 compute the physname for the object, which include a method's:
10750 - formal parameters (C++),
10751 - receiver type (Go),
10753 The term "physname" is a bit confusing.
10754 For C++, for example, it is the demangled name.
10755 For Go, for example, it's the mangled name.
10757 For Ada, return the DIE's linkage name rather than the fully qualified
10758 name. PHYSNAME is ignored..
10760 The result is allocated on the objfile_obstack and canonicalized. */
10762 static const char *
10763 dwarf2_compute_name (const char *name,
10764 struct die_info *die, struct dwarf2_cu *cu,
10767 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10770 name = dwarf2_name (die, cu);
10772 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10773 but otherwise compute it by typename_concat inside GDB.
10774 FIXME: Actually this is not really true, or at least not always true.
10775 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
10776 Fortran names because there is no mangling standard. So new_symbol
10777 will set the demangled name to the result of dwarf2_full_name, and it is
10778 the demangled name that GDB uses if it exists. */
10779 if (cu->language == language_ada
10780 || (cu->language == language_fortran && physname))
10782 /* For Ada unit, we prefer the linkage name over the name, as
10783 the former contains the exported name, which the user expects
10784 to be able to reference. Ideally, we want the user to be able
10785 to reference this entity using either natural or linkage name,
10786 but we haven't started looking at this enhancement yet. */
10787 const char *linkage_name = dw2_linkage_name (die, cu);
10789 if (linkage_name != NULL)
10790 return linkage_name;
10793 /* These are the only languages we know how to qualify names in. */
10795 && (cu->language == language_cplus
10796 || cu->language == language_fortran || cu->language == language_d
10797 || cu->language == language_rust))
10799 if (die_needs_namespace (die, cu))
10801 const char *prefix;
10802 const char *canonical_name = NULL;
10806 prefix = determine_prefix (die, cu);
10807 if (*prefix != '\0')
10809 char *prefixed_name = typename_concat (NULL, prefix, name,
10812 buf.puts (prefixed_name);
10813 xfree (prefixed_name);
10818 /* Template parameters may be specified in the DIE's DW_AT_name, or
10819 as children with DW_TAG_template_type_param or
10820 DW_TAG_value_type_param. If the latter, add them to the name
10821 here. If the name already has template parameters, then
10822 skip this step; some versions of GCC emit both, and
10823 it is more efficient to use the pre-computed name.
10825 Something to keep in mind about this process: it is very
10826 unlikely, or in some cases downright impossible, to produce
10827 something that will match the mangled name of a function.
10828 If the definition of the function has the same debug info,
10829 we should be able to match up with it anyway. But fallbacks
10830 using the minimal symbol, for instance to find a method
10831 implemented in a stripped copy of libstdc++, will not work.
10832 If we do not have debug info for the definition, we will have to
10833 match them up some other way.
10835 When we do name matching there is a related problem with function
10836 templates; two instantiated function templates are allowed to
10837 differ only by their return types, which we do not add here. */
10839 if (cu->language == language_cplus && strchr (name, '<') == NULL)
10841 struct attribute *attr;
10842 struct die_info *child;
10845 die->building_fullname = 1;
10847 for (child = die->child; child != NULL; child = child->sibling)
10851 const gdb_byte *bytes;
10852 struct dwarf2_locexpr_baton *baton;
10855 if (child->tag != DW_TAG_template_type_param
10856 && child->tag != DW_TAG_template_value_param)
10867 attr = dwarf2_attr (child, DW_AT_type, cu);
10870 complaint (_("template parameter missing DW_AT_type"));
10871 buf.puts ("UNKNOWN_TYPE");
10874 type = die_type (child, cu);
10876 if (child->tag == DW_TAG_template_type_param)
10878 c_print_type (type, "", &buf, -1, 0, cu->language,
10879 &type_print_raw_options);
10883 attr = dwarf2_attr (child, DW_AT_const_value, cu);
10886 complaint (_("template parameter missing "
10887 "DW_AT_const_value"));
10888 buf.puts ("UNKNOWN_VALUE");
10892 dwarf2_const_value_attr (attr, type, name,
10893 &cu->comp_unit_obstack, cu,
10894 &value, &bytes, &baton);
10896 if (TYPE_NOSIGN (type))
10897 /* GDB prints characters as NUMBER 'CHAR'. If that's
10898 changed, this can use value_print instead. */
10899 c_printchar (value, type, &buf);
10902 struct value_print_options opts;
10905 v = dwarf2_evaluate_loc_desc (type, NULL,
10909 else if (bytes != NULL)
10911 v = allocate_value (type);
10912 memcpy (value_contents_writeable (v), bytes,
10913 TYPE_LENGTH (type));
10916 v = value_from_longest (type, value);
10918 /* Specify decimal so that we do not depend on
10920 get_formatted_print_options (&opts, 'd');
10922 value_print (v, &buf, &opts);
10927 die->building_fullname = 0;
10931 /* Close the argument list, with a space if necessary
10932 (nested templates). */
10933 if (!buf.empty () && buf.string ().back () == '>')
10940 /* For C++ methods, append formal parameter type
10941 information, if PHYSNAME. */
10943 if (physname && die->tag == DW_TAG_subprogram
10944 && cu->language == language_cplus)
10946 struct type *type = read_type_die (die, cu);
10948 c_type_print_args (type, &buf, 1, cu->language,
10949 &type_print_raw_options);
10951 if (cu->language == language_cplus)
10953 /* Assume that an artificial first parameter is
10954 "this", but do not crash if it is not. RealView
10955 marks unnamed (and thus unused) parameters as
10956 artificial; there is no way to differentiate
10958 if (TYPE_NFIELDS (type) > 0
10959 && TYPE_FIELD_ARTIFICIAL (type, 0)
10960 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
10961 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
10963 buf.puts (" const");
10967 const std::string &intermediate_name = buf.string ();
10969 if (cu->language == language_cplus)
10971 = dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
10972 &objfile->per_bfd->storage_obstack);
10974 /* If we only computed INTERMEDIATE_NAME, or if
10975 INTERMEDIATE_NAME is already canonical, then we need to
10976 copy it to the appropriate obstack. */
10977 if (canonical_name == NULL || canonical_name == intermediate_name.c_str ())
10978 name = ((const char *)
10979 obstack_copy0 (&objfile->per_bfd->storage_obstack,
10980 intermediate_name.c_str (),
10981 intermediate_name.length ()));
10983 name = canonical_name;
10990 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10991 If scope qualifiers are appropriate they will be added. The result
10992 will be allocated on the storage_obstack, or NULL if the DIE does
10993 not have a name. NAME may either be from a previous call to
10994 dwarf2_name or NULL.
10996 The output string will be canonicalized (if C++). */
10998 static const char *
10999 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11001 return dwarf2_compute_name (name, die, cu, 0);
11004 /* Construct a physname for the given DIE in CU. NAME may either be
11005 from a previous call to dwarf2_name or NULL. The result will be
11006 allocated on the objfile_objstack or NULL if the DIE does not have a
11009 The output string will be canonicalized (if C++). */
11011 static const char *
11012 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11014 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11015 const char *retval, *mangled = NULL, *canon = NULL;
11018 /* In this case dwarf2_compute_name is just a shortcut not building anything
11020 if (!die_needs_namespace (die, cu))
11021 return dwarf2_compute_name (name, die, cu, 1);
11023 mangled = dw2_linkage_name (die, cu);
11025 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
11026 See https://github.com/rust-lang/rust/issues/32925. */
11027 if (cu->language == language_rust && mangled != NULL
11028 && strchr (mangled, '{') != NULL)
11031 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11033 gdb::unique_xmalloc_ptr<char> demangled;
11034 if (mangled != NULL)
11037 if (language_def (cu->language)->la_store_sym_names_in_linkage_form_p)
11039 /* Do nothing (do not demangle the symbol name). */
11041 else if (cu->language == language_go)
11043 /* This is a lie, but we already lie to the caller new_symbol.
11044 new_symbol assumes we return the mangled name.
11045 This just undoes that lie until things are cleaned up. */
11049 /* Use DMGL_RET_DROP for C++ template functions to suppress
11050 their return type. It is easier for GDB users to search
11051 for such functions as `name(params)' than `long name(params)'.
11052 In such case the minimal symbol names do not match the full
11053 symbol names but for template functions there is never a need
11054 to look up their definition from their declaration so
11055 the only disadvantage remains the minimal symbol variant
11056 `long name(params)' does not have the proper inferior type. */
11057 demangled.reset (gdb_demangle (mangled,
11058 (DMGL_PARAMS | DMGL_ANSI
11059 | DMGL_RET_DROP)));
11062 canon = demangled.get ();
11070 if (canon == NULL || check_physname)
11072 const char *physname = dwarf2_compute_name (name, die, cu, 1);
11074 if (canon != NULL && strcmp (physname, canon) != 0)
11076 /* It may not mean a bug in GDB. The compiler could also
11077 compute DW_AT_linkage_name incorrectly. But in such case
11078 GDB would need to be bug-to-bug compatible. */
11080 complaint (_("Computed physname <%s> does not match demangled <%s> "
11081 "(from linkage <%s>) - DIE at %s [in module %s]"),
11082 physname, canon, mangled, sect_offset_str (die->sect_off),
11083 objfile_name (objfile));
11085 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11086 is available here - over computed PHYSNAME. It is safer
11087 against both buggy GDB and buggy compilers. */
11101 retval = ((const char *)
11102 obstack_copy0 (&objfile->per_bfd->storage_obstack,
11103 retval, strlen (retval)));
11108 /* Inspect DIE in CU for a namespace alias. If one exists, record
11109 a new symbol for it.
11111 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11114 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
11116 struct attribute *attr;
11118 /* If the die does not have a name, this is not a namespace
11120 attr = dwarf2_attr (die, DW_AT_name, cu);
11124 struct die_info *d = die;
11125 struct dwarf2_cu *imported_cu = cu;
11127 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11128 keep inspecting DIEs until we hit the underlying import. */
11129 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11130 for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
11132 attr = dwarf2_attr (d, DW_AT_import, cu);
11136 d = follow_die_ref (d, attr, &imported_cu);
11137 if (d->tag != DW_TAG_imported_declaration)
11141 if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
11143 complaint (_("DIE at %s has too many recursively imported "
11144 "declarations"), sect_offset_str (d->sect_off));
11151 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
11153 type = get_die_type_at_offset (sect_off, cu->per_cu);
11154 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
11156 /* This declaration is a global namespace alias. Add
11157 a symbol for it whose type is the aliased namespace. */
11158 new_symbol (die, type, cu);
11167 /* Return the using directives repository (global or local?) to use in the
11168 current context for CU.
11170 For Ada, imported declarations can materialize renamings, which *may* be
11171 global. However it is impossible (for now?) in DWARF to distinguish
11172 "external" imported declarations and "static" ones. As all imported
11173 declarations seem to be static in all other languages, make them all CU-wide
11174 global only in Ada. */
11176 static struct using_direct **
11177 using_directives (struct dwarf2_cu *cu)
11179 if (cu->language == language_ada && cu->builder->outermost_context_p ())
11180 return cu->builder->get_global_using_directives ();
11182 return cu->builder->get_local_using_directives ();
11185 /* Read the import statement specified by the given die and record it. */
11188 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
11190 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11191 struct attribute *import_attr;
11192 struct die_info *imported_die, *child_die;
11193 struct dwarf2_cu *imported_cu;
11194 const char *imported_name;
11195 const char *imported_name_prefix;
11196 const char *canonical_name;
11197 const char *import_alias;
11198 const char *imported_declaration = NULL;
11199 const char *import_prefix;
11200 std::vector<const char *> excludes;
11202 import_attr = dwarf2_attr (die, DW_AT_import, cu);
11203 if (import_attr == NULL)
11205 complaint (_("Tag '%s' has no DW_AT_import"),
11206 dwarf_tag_name (die->tag));
11211 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
11212 imported_name = dwarf2_name (imported_die, imported_cu);
11213 if (imported_name == NULL)
11215 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11217 The import in the following code:
11231 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11232 <52> DW_AT_decl_file : 1
11233 <53> DW_AT_decl_line : 6
11234 <54> DW_AT_import : <0x75>
11235 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11236 <59> DW_AT_name : B
11237 <5b> DW_AT_decl_file : 1
11238 <5c> DW_AT_decl_line : 2
11239 <5d> DW_AT_type : <0x6e>
11241 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11242 <76> DW_AT_byte_size : 4
11243 <77> DW_AT_encoding : 5 (signed)
11245 imports the wrong die ( 0x75 instead of 0x58 ).
11246 This case will be ignored until the gcc bug is fixed. */
11250 /* Figure out the local name after import. */
11251 import_alias = dwarf2_name (die, cu);
11253 /* Figure out where the statement is being imported to. */
11254 import_prefix = determine_prefix (die, cu);
11256 /* Figure out what the scope of the imported die is and prepend it
11257 to the name of the imported die. */
11258 imported_name_prefix = determine_prefix (imported_die, imported_cu);
11260 if (imported_die->tag != DW_TAG_namespace
11261 && imported_die->tag != DW_TAG_module)
11263 imported_declaration = imported_name;
11264 canonical_name = imported_name_prefix;
11266 else if (strlen (imported_name_prefix) > 0)
11267 canonical_name = obconcat (&objfile->objfile_obstack,
11268 imported_name_prefix,
11269 (cu->language == language_d ? "." : "::"),
11270 imported_name, (char *) NULL);
11272 canonical_name = imported_name;
11274 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
11275 for (child_die = die->child; child_die && child_die->tag;
11276 child_die = sibling_die (child_die))
11278 /* DWARF-4: A Fortran use statement with a “rename list” may be
11279 represented by an imported module entry with an import attribute
11280 referring to the module and owned entries corresponding to those
11281 entities that are renamed as part of being imported. */
11283 if (child_die->tag != DW_TAG_imported_declaration)
11285 complaint (_("child DW_TAG_imported_declaration expected "
11286 "- DIE at %s [in module %s]"),
11287 sect_offset_str (child_die->sect_off),
11288 objfile_name (objfile));
11292 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
11293 if (import_attr == NULL)
11295 complaint (_("Tag '%s' has no DW_AT_import"),
11296 dwarf_tag_name (child_die->tag));
11301 imported_die = follow_die_ref_or_sig (child_die, import_attr,
11303 imported_name = dwarf2_name (imported_die, imported_cu);
11304 if (imported_name == NULL)
11306 complaint (_("child DW_TAG_imported_declaration has unknown "
11307 "imported name - DIE at %s [in module %s]"),
11308 sect_offset_str (child_die->sect_off),
11309 objfile_name (objfile));
11313 excludes.push_back (imported_name);
11315 process_die (child_die, cu);
11318 add_using_directive (using_directives (cu),
11322 imported_declaration,
11325 &objfile->objfile_obstack);
11328 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11329 types, but gives them a size of zero. Starting with version 14,
11330 ICC is compatible with GCC. */
11333 producer_is_icc_lt_14 (struct dwarf2_cu *cu)
11335 if (!cu->checked_producer)
11336 check_producer (cu);
11338 return cu->producer_is_icc_lt_14;
11341 /* ICC generates a DW_AT_type for C void functions. This was observed on
11342 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11343 which says that void functions should not have a DW_AT_type. */
11346 producer_is_icc (struct dwarf2_cu *cu)
11348 if (!cu->checked_producer)
11349 check_producer (cu);
11351 return cu->producer_is_icc;
11354 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11355 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11356 this, it was first present in GCC release 4.3.0. */
11359 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
11361 if (!cu->checked_producer)
11362 check_producer (cu);
11364 return cu->producer_is_gcc_lt_4_3;
11367 static file_and_directory
11368 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu)
11370 file_and_directory res;
11372 /* Find the filename. Do not use dwarf2_name here, since the filename
11373 is not a source language identifier. */
11374 res.name = dwarf2_string_attr (die, DW_AT_name, cu);
11375 res.comp_dir = dwarf2_string_attr (die, DW_AT_comp_dir, cu);
11377 if (res.comp_dir == NULL
11378 && producer_is_gcc_lt_4_3 (cu) && res.name != NULL
11379 && IS_ABSOLUTE_PATH (res.name))
11381 res.comp_dir_storage = ldirname (res.name);
11382 if (!res.comp_dir_storage.empty ())
11383 res.comp_dir = res.comp_dir_storage.c_str ();
11385 if (res.comp_dir != NULL)
11387 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11388 directory, get rid of it. */
11389 const char *cp = strchr (res.comp_dir, ':');
11391 if (cp && cp != res.comp_dir && cp[-1] == '.' && cp[1] == '/')
11392 res.comp_dir = cp + 1;
11395 if (res.name == NULL)
11396 res.name = "<unknown>";
11401 /* Handle DW_AT_stmt_list for a compilation unit.
11402 DIE is the DW_TAG_compile_unit die for CU.
11403 COMP_DIR is the compilation directory. LOWPC is passed to
11404 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11407 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
11408 const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
11410 struct dwarf2_per_objfile *dwarf2_per_objfile
11411 = cu->per_cu->dwarf2_per_objfile;
11412 struct objfile *objfile = dwarf2_per_objfile->objfile;
11413 struct attribute *attr;
11414 struct line_header line_header_local;
11415 hashval_t line_header_local_hash;
11417 int decode_mapping;
11419 gdb_assert (! cu->per_cu->is_debug_types);
11421 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11425 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11427 /* The line header hash table is only created if needed (it exists to
11428 prevent redundant reading of the line table for partial_units).
11429 If we're given a partial_unit, we'll need it. If we're given a
11430 compile_unit, then use the line header hash table if it's already
11431 created, but don't create one just yet. */
11433 if (dwarf2_per_objfile->line_header_hash == NULL
11434 && die->tag == DW_TAG_partial_unit)
11436 dwarf2_per_objfile->line_header_hash
11437 = htab_create_alloc_ex (127, line_header_hash_voidp,
11438 line_header_eq_voidp,
11439 free_line_header_voidp,
11440 &objfile->objfile_obstack,
11441 hashtab_obstack_allocate,
11442 dummy_obstack_deallocate);
11445 line_header_local.sect_off = line_offset;
11446 line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
11447 line_header_local_hash = line_header_hash (&line_header_local);
11448 if (dwarf2_per_objfile->line_header_hash != NULL)
11450 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11451 &line_header_local,
11452 line_header_local_hash, NO_INSERT);
11454 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11455 is not present in *SLOT (since if there is something in *SLOT then
11456 it will be for a partial_unit). */
11457 if (die->tag == DW_TAG_partial_unit && slot != NULL)
11459 gdb_assert (*slot != NULL);
11460 cu->line_header = (struct line_header *) *slot;
11465 /* dwarf_decode_line_header does not yet provide sufficient information.
11466 We always have to call also dwarf_decode_lines for it. */
11467 line_header_up lh = dwarf_decode_line_header (line_offset, cu);
11471 cu->line_header = lh.release ();
11472 cu->line_header_die_owner = die;
11474 if (dwarf2_per_objfile->line_header_hash == NULL)
11478 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11479 &line_header_local,
11480 line_header_local_hash, INSERT);
11481 gdb_assert (slot != NULL);
11483 if (slot != NULL && *slot == NULL)
11485 /* This newly decoded line number information unit will be owned
11486 by line_header_hash hash table. */
11487 *slot = cu->line_header;
11488 cu->line_header_die_owner = NULL;
11492 /* We cannot free any current entry in (*slot) as that struct line_header
11493 may be already used by multiple CUs. Create only temporary decoded
11494 line_header for this CU - it may happen at most once for each line
11495 number information unit. And if we're not using line_header_hash
11496 then this is what we want as well. */
11497 gdb_assert (die->tag != DW_TAG_partial_unit);
11499 decode_mapping = (die->tag != DW_TAG_partial_unit);
11500 dwarf_decode_lines (cu->line_header, comp_dir, cu, NULL, lowpc,
11505 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11508 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
11510 struct dwarf2_per_objfile *dwarf2_per_objfile
11511 = cu->per_cu->dwarf2_per_objfile;
11512 struct objfile *objfile = dwarf2_per_objfile->objfile;
11513 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11514 CORE_ADDR lowpc = ((CORE_ADDR) -1);
11515 CORE_ADDR highpc = ((CORE_ADDR) 0);
11516 struct attribute *attr;
11517 struct die_info *child_die;
11518 CORE_ADDR baseaddr;
11520 prepare_one_comp_unit (cu, die, cu->language);
11521 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11523 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
11525 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11526 from finish_block. */
11527 if (lowpc == ((CORE_ADDR) -1))
11529 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11531 file_and_directory fnd = find_file_and_directory (die, cu);
11533 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11534 standardised yet. As a workaround for the language detection we fall
11535 back to the DW_AT_producer string. */
11536 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
11537 cu->language = language_opencl;
11539 /* Similar hack for Go. */
11540 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
11541 set_cu_language (DW_LANG_Go, cu);
11543 dwarf2_start_symtab (cu, fnd.name, fnd.comp_dir, lowpc);
11545 /* Decode line number information if present. We do this before
11546 processing child DIEs, so that the line header table is available
11547 for DW_AT_decl_file. */
11548 handle_DW_AT_stmt_list (die, cu, fnd.comp_dir, lowpc);
11550 /* Process all dies in compilation unit. */
11551 if (die->child != NULL)
11553 child_die = die->child;
11554 while (child_die && child_die->tag)
11556 process_die (child_die, cu);
11557 child_die = sibling_die (child_die);
11561 /* Decode macro information, if present. Dwarf 2 macro information
11562 refers to information in the line number info statement program
11563 header, so we can only read it if we've read the header
11565 attr = dwarf2_attr (die, DW_AT_macros, cu);
11567 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
11568 if (attr && cu->line_header)
11570 if (dwarf2_attr (die, DW_AT_macro_info, cu))
11571 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11573 dwarf_decode_macros (cu, DW_UNSND (attr), 1);
11577 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
11578 if (attr && cu->line_header)
11580 unsigned int macro_offset = DW_UNSND (attr);
11582 dwarf_decode_macros (cu, macro_offset, 0);
11587 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
11588 Create the set of symtabs used by this TU, or if this TU is sharing
11589 symtabs with another TU and the symtabs have already been created
11590 then restore those symtabs in the line header.
11591 We don't need the pc/line-number mapping for type units. */
11594 setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
11596 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
11597 struct type_unit_group *tu_group;
11599 struct attribute *attr;
11601 struct signatured_type *sig_type;
11603 gdb_assert (per_cu->is_debug_types);
11604 sig_type = (struct signatured_type *) per_cu;
11606 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11608 /* If we're using .gdb_index (includes -readnow) then
11609 per_cu->type_unit_group may not have been set up yet. */
11610 if (sig_type->type_unit_group == NULL)
11611 sig_type->type_unit_group = get_type_unit_group (cu, attr);
11612 tu_group = sig_type->type_unit_group;
11614 /* If we've already processed this stmt_list there's no real need to
11615 do it again, we could fake it and just recreate the part we need
11616 (file name,index -> symtab mapping). If data shows this optimization
11617 is useful we can do it then. */
11618 first_time = tu_group->compunit_symtab == NULL;
11620 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11625 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11626 lh = dwarf_decode_line_header (line_offset, cu);
11631 dwarf2_start_symtab (cu, "", NULL, 0);
11634 gdb_assert (tu_group->symtabs == NULL);
11635 gdb_assert (cu->builder == nullptr);
11636 struct compunit_symtab *cust = tu_group->compunit_symtab;
11637 cu->builder.reset (new struct buildsym_compunit
11638 (COMPUNIT_OBJFILE (cust), "",
11639 COMPUNIT_DIRNAME (cust),
11640 compunit_language (cust),
11646 cu->line_header = lh.release ();
11647 cu->line_header_die_owner = die;
11651 struct compunit_symtab *cust = dwarf2_start_symtab (cu, "", NULL, 0);
11653 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11654 still initializing it, and our caller (a few levels up)
11655 process_full_type_unit still needs to know if this is the first
11658 tu_group->num_symtabs = cu->line_header->file_names.size ();
11659 tu_group->symtabs = XNEWVEC (struct symtab *,
11660 cu->line_header->file_names.size ());
11662 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11664 file_entry &fe = cu->line_header->file_names[i];
11666 dwarf2_start_subfile (cu, fe.name, fe.include_dir (cu->line_header));
11668 if (cu->builder->get_current_subfile ()->symtab == NULL)
11670 /* NOTE: start_subfile will recognize when it's been
11671 passed a file it has already seen. So we can't
11672 assume there's a simple mapping from
11673 cu->line_header->file_names to subfiles, plus
11674 cu->line_header->file_names may contain dups. */
11675 cu->builder->get_current_subfile ()->symtab
11676 = allocate_symtab (cust,
11677 cu->builder->get_current_subfile ()->name);
11680 fe.symtab = cu->builder->get_current_subfile ()->symtab;
11681 tu_group->symtabs[i] = fe.symtab;
11686 gdb_assert (cu->builder == nullptr);
11687 struct compunit_symtab *cust = tu_group->compunit_symtab;
11688 cu->builder.reset (new struct buildsym_compunit
11689 (COMPUNIT_OBJFILE (cust), "",
11690 COMPUNIT_DIRNAME (cust),
11691 compunit_language (cust),
11694 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11696 file_entry &fe = cu->line_header->file_names[i];
11698 fe.symtab = tu_group->symtabs[i];
11702 /* The main symtab is allocated last. Type units don't have DW_AT_name
11703 so they don't have a "real" (so to speak) symtab anyway.
11704 There is later code that will assign the main symtab to all symbols
11705 that don't have one. We need to handle the case of a symbol with a
11706 missing symtab (DW_AT_decl_file) anyway. */
11709 /* Process DW_TAG_type_unit.
11710 For TUs we want to skip the first top level sibling if it's not the
11711 actual type being defined by this TU. In this case the first top
11712 level sibling is there to provide context only. */
11715 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
11717 struct die_info *child_die;
11719 prepare_one_comp_unit (cu, die, language_minimal);
11721 /* Initialize (or reinitialize) the machinery for building symtabs.
11722 We do this before processing child DIEs, so that the line header table
11723 is available for DW_AT_decl_file. */
11724 setup_type_unit_groups (die, cu);
11726 if (die->child != NULL)
11728 child_die = die->child;
11729 while (child_die && child_die->tag)
11731 process_die (child_die, cu);
11732 child_die = sibling_die (child_die);
11739 http://gcc.gnu.org/wiki/DebugFission
11740 http://gcc.gnu.org/wiki/DebugFissionDWP
11742 To simplify handling of both DWO files ("object" files with the DWARF info)
11743 and DWP files (a file with the DWOs packaged up into one file), we treat
11744 DWP files as having a collection of virtual DWO files. */
11747 hash_dwo_file (const void *item)
11749 const struct dwo_file *dwo_file = (const struct dwo_file *) item;
11752 hash = htab_hash_string (dwo_file->dwo_name);
11753 if (dwo_file->comp_dir != NULL)
11754 hash += htab_hash_string (dwo_file->comp_dir);
11759 eq_dwo_file (const void *item_lhs, const void *item_rhs)
11761 const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
11762 const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
11764 if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
11766 if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
11767 return lhs->comp_dir == rhs->comp_dir;
11768 return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
11771 /* Allocate a hash table for DWO files. */
11774 allocate_dwo_file_hash_table (struct objfile *objfile)
11776 return htab_create_alloc_ex (41,
11780 &objfile->objfile_obstack,
11781 hashtab_obstack_allocate,
11782 dummy_obstack_deallocate);
11785 /* Lookup DWO file DWO_NAME. */
11788 lookup_dwo_file_slot (struct dwarf2_per_objfile *dwarf2_per_objfile,
11789 const char *dwo_name,
11790 const char *comp_dir)
11792 struct dwo_file find_entry;
11795 if (dwarf2_per_objfile->dwo_files == NULL)
11796 dwarf2_per_objfile->dwo_files
11797 = allocate_dwo_file_hash_table (dwarf2_per_objfile->objfile);
11799 memset (&find_entry, 0, sizeof (find_entry));
11800 find_entry.dwo_name = dwo_name;
11801 find_entry.comp_dir = comp_dir;
11802 slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
11808 hash_dwo_unit (const void *item)
11810 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
11812 /* This drops the top 32 bits of the id, but is ok for a hash. */
11813 return dwo_unit->signature;
11817 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
11819 const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
11820 const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
11822 /* The signature is assumed to be unique within the DWO file.
11823 So while object file CU dwo_id's always have the value zero,
11824 that's OK, assuming each object file DWO file has only one CU,
11825 and that's the rule for now. */
11826 return lhs->signature == rhs->signature;
11829 /* Allocate a hash table for DWO CUs,TUs.
11830 There is one of these tables for each of CUs,TUs for each DWO file. */
11833 allocate_dwo_unit_table (struct objfile *objfile)
11835 /* Start out with a pretty small number.
11836 Generally DWO files contain only one CU and maybe some TUs. */
11837 return htab_create_alloc_ex (3,
11841 &objfile->objfile_obstack,
11842 hashtab_obstack_allocate,
11843 dummy_obstack_deallocate);
11846 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11848 struct create_dwo_cu_data
11850 struct dwo_file *dwo_file;
11851 struct dwo_unit dwo_unit;
11854 /* die_reader_func for create_dwo_cu. */
11857 create_dwo_cu_reader (const struct die_reader_specs *reader,
11858 const gdb_byte *info_ptr,
11859 struct die_info *comp_unit_die,
11863 struct dwarf2_cu *cu = reader->cu;
11864 sect_offset sect_off = cu->per_cu->sect_off;
11865 struct dwarf2_section_info *section = cu->per_cu->section;
11866 struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
11867 struct dwo_file *dwo_file = data->dwo_file;
11868 struct dwo_unit *dwo_unit = &data->dwo_unit;
11869 struct attribute *attr;
11871 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
11874 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11875 " its dwo_id [in module %s]"),
11876 sect_offset_str (sect_off), dwo_file->dwo_name);
11880 dwo_unit->dwo_file = dwo_file;
11881 dwo_unit->signature = DW_UNSND (attr);
11882 dwo_unit->section = section;
11883 dwo_unit->sect_off = sect_off;
11884 dwo_unit->length = cu->per_cu->length;
11886 if (dwarf_read_debug)
11887 fprintf_unfiltered (gdb_stdlog, " offset %s, dwo_id %s\n",
11888 sect_offset_str (sect_off),
11889 hex_string (dwo_unit->signature));
11892 /* Create the dwo_units for the CUs in a DWO_FILE.
11893 Note: This function processes DWO files only, not DWP files. */
11896 create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
11897 struct dwo_file &dwo_file, dwarf2_section_info §ion,
11900 struct objfile *objfile = dwarf2_per_objfile->objfile;
11901 const gdb_byte *info_ptr, *end_ptr;
11903 dwarf2_read_section (objfile, §ion);
11904 info_ptr = section.buffer;
11906 if (info_ptr == NULL)
11909 if (dwarf_read_debug)
11911 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
11912 get_section_name (§ion),
11913 get_section_file_name (§ion));
11916 end_ptr = info_ptr + section.size;
11917 while (info_ptr < end_ptr)
11919 struct dwarf2_per_cu_data per_cu;
11920 struct create_dwo_cu_data create_dwo_cu_data;
11921 struct dwo_unit *dwo_unit;
11923 sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
11925 memset (&create_dwo_cu_data.dwo_unit, 0,
11926 sizeof (create_dwo_cu_data.dwo_unit));
11927 memset (&per_cu, 0, sizeof (per_cu));
11928 per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
11929 per_cu.is_debug_types = 0;
11930 per_cu.sect_off = sect_offset (info_ptr - section.buffer);
11931 per_cu.section = §ion;
11932 create_dwo_cu_data.dwo_file = &dwo_file;
11934 init_cutu_and_read_dies_no_follow (
11935 &per_cu, &dwo_file, create_dwo_cu_reader, &create_dwo_cu_data);
11936 info_ptr += per_cu.length;
11938 // If the unit could not be parsed, skip it.
11939 if (create_dwo_cu_data.dwo_unit.dwo_file == NULL)
11942 if (cus_htab == NULL)
11943 cus_htab = allocate_dwo_unit_table (objfile);
11945 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
11946 *dwo_unit = create_dwo_cu_data.dwo_unit;
11947 slot = htab_find_slot (cus_htab, dwo_unit, INSERT);
11948 gdb_assert (slot != NULL);
11951 const struct dwo_unit *dup_cu = (const struct dwo_unit *)*slot;
11952 sect_offset dup_sect_off = dup_cu->sect_off;
11954 complaint (_("debug cu entry at offset %s is duplicate to"
11955 " the entry at offset %s, signature %s"),
11956 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
11957 hex_string (dwo_unit->signature));
11959 *slot = (void *)dwo_unit;
11963 /* DWP file .debug_{cu,tu}_index section format:
11964 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11968 Both index sections have the same format, and serve to map a 64-bit
11969 signature to a set of section numbers. Each section begins with a header,
11970 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11971 indexes, and a pool of 32-bit section numbers. The index sections will be
11972 aligned at 8-byte boundaries in the file.
11974 The index section header consists of:
11976 V, 32 bit version number
11978 N, 32 bit number of compilation units or type units in the index
11979 M, 32 bit number of slots in the hash table
11981 Numbers are recorded using the byte order of the application binary.
11983 The hash table begins at offset 16 in the section, and consists of an array
11984 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11985 order of the application binary). Unused slots in the hash table are 0.
11986 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11988 The parallel table begins immediately after the hash table
11989 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11990 array of 32-bit indexes (using the byte order of the application binary),
11991 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11992 table contains a 32-bit index into the pool of section numbers. For unused
11993 hash table slots, the corresponding entry in the parallel table will be 0.
11995 The pool of section numbers begins immediately following the hash table
11996 (at offset 16 + 12 * M from the beginning of the section). The pool of
11997 section numbers consists of an array of 32-bit words (using the byte order
11998 of the application binary). Each item in the array is indexed starting
11999 from 0. The hash table entry provides the index of the first section
12000 number in the set. Additional section numbers in the set follow, and the
12001 set is terminated by a 0 entry (section number 0 is not used in ELF).
12003 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12004 section must be the first entry in the set, and the .debug_abbrev.dwo must
12005 be the second entry. Other members of the set may follow in any order.
12011 DWP Version 2 combines all the .debug_info, etc. sections into one,
12012 and the entries in the index tables are now offsets into these sections.
12013 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
12016 Index Section Contents:
12018 Hash Table of Signatures dwp_hash_table.hash_table
12019 Parallel Table of Indices dwp_hash_table.unit_table
12020 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
12021 Table of Section Sizes dwp_hash_table.v2.sizes
12023 The index section header consists of:
12025 V, 32 bit version number
12026 L, 32 bit number of columns in the table of section offsets
12027 N, 32 bit number of compilation units or type units in the index
12028 M, 32 bit number of slots in the hash table
12030 Numbers are recorded using the byte order of the application binary.
12032 The hash table has the same format as version 1.
12033 The parallel table of indices has the same format as version 1,
12034 except that the entries are origin-1 indices into the table of sections
12035 offsets and the table of section sizes.
12037 The table of offsets begins immediately following the parallel table
12038 (at offset 16 + 12 * M from the beginning of the section). The table is
12039 a two-dimensional array of 32-bit words (using the byte order of the
12040 application binary), with L columns and N+1 rows, in row-major order.
12041 Each row in the array is indexed starting from 0. The first row provides
12042 a key to the remaining rows: each column in this row provides an identifier
12043 for a debug section, and the offsets in the same column of subsequent rows
12044 refer to that section. The section identifiers are:
12046 DW_SECT_INFO 1 .debug_info.dwo
12047 DW_SECT_TYPES 2 .debug_types.dwo
12048 DW_SECT_ABBREV 3 .debug_abbrev.dwo
12049 DW_SECT_LINE 4 .debug_line.dwo
12050 DW_SECT_LOC 5 .debug_loc.dwo
12051 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
12052 DW_SECT_MACINFO 7 .debug_macinfo.dwo
12053 DW_SECT_MACRO 8 .debug_macro.dwo
12055 The offsets provided by the CU and TU index sections are the base offsets
12056 for the contributions made by each CU or TU to the corresponding section
12057 in the package file. Each CU and TU header contains an abbrev_offset
12058 field, used to find the abbreviations table for that CU or TU within the
12059 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12060 be interpreted as relative to the base offset given in the index section.
12061 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12062 should be interpreted as relative to the base offset for .debug_line.dwo,
12063 and offsets into other debug sections obtained from DWARF attributes should
12064 also be interpreted as relative to the corresponding base offset.
12066 The table of sizes begins immediately following the table of offsets.
12067 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12068 with L columns and N rows, in row-major order. Each row in the array is
12069 indexed starting from 1 (row 0 is shared by the two tables).
12073 Hash table lookup is handled the same in version 1 and 2:
12075 We assume that N and M will not exceed 2^32 - 1.
12076 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12078 Given a 64-bit compilation unit signature or a type signature S, an entry
12079 in the hash table is located as follows:
12081 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12082 the low-order k bits all set to 1.
12084 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12086 3) If the hash table entry at index H matches the signature, use that
12087 entry. If the hash table entry at index H is unused (all zeroes),
12088 terminate the search: the signature is not present in the table.
12090 4) Let H = (H + H') modulo M. Repeat at Step 3.
12092 Because M > N and H' and M are relatively prime, the search is guaranteed
12093 to stop at an unused slot or find the match. */
12095 /* Create a hash table to map DWO IDs to their CU/TU entry in
12096 .debug_{info,types}.dwo in DWP_FILE.
12097 Returns NULL if there isn't one.
12098 Note: This function processes DWP files only, not DWO files. */
12100 static struct dwp_hash_table *
12101 create_dwp_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
12102 struct dwp_file *dwp_file, int is_debug_types)
12104 struct objfile *objfile = dwarf2_per_objfile->objfile;
12105 bfd *dbfd = dwp_file->dbfd.get ();
12106 const gdb_byte *index_ptr, *index_end;
12107 struct dwarf2_section_info *index;
12108 uint32_t version, nr_columns, nr_units, nr_slots;
12109 struct dwp_hash_table *htab;
12111 if (is_debug_types)
12112 index = &dwp_file->sections.tu_index;
12114 index = &dwp_file->sections.cu_index;
12116 if (dwarf2_section_empty_p (index))
12118 dwarf2_read_section (objfile, index);
12120 index_ptr = index->buffer;
12121 index_end = index_ptr + index->size;
12123 version = read_4_bytes (dbfd, index_ptr);
12126 nr_columns = read_4_bytes (dbfd, index_ptr);
12130 nr_units = read_4_bytes (dbfd, index_ptr);
12132 nr_slots = read_4_bytes (dbfd, index_ptr);
12135 if (version != 1 && version != 2)
12137 error (_("Dwarf Error: unsupported DWP file version (%s)"
12138 " [in module %s]"),
12139 pulongest (version), dwp_file->name);
12141 if (nr_slots != (nr_slots & -nr_slots))
12143 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12144 " is not power of 2 [in module %s]"),
12145 pulongest (nr_slots), dwp_file->name);
12148 htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
12149 htab->version = version;
12150 htab->nr_columns = nr_columns;
12151 htab->nr_units = nr_units;
12152 htab->nr_slots = nr_slots;
12153 htab->hash_table = index_ptr;
12154 htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
12156 /* Exit early if the table is empty. */
12157 if (nr_slots == 0 || nr_units == 0
12158 || (version == 2 && nr_columns == 0))
12160 /* All must be zero. */
12161 if (nr_slots != 0 || nr_units != 0
12162 || (version == 2 && nr_columns != 0))
12164 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12165 " all zero [in modules %s]"),
12173 htab->section_pool.v1.indices =
12174 htab->unit_table + sizeof (uint32_t) * nr_slots;
12175 /* It's harder to decide whether the section is too small in v1.
12176 V1 is deprecated anyway so we punt. */
12180 const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
12181 int *ids = htab->section_pool.v2.section_ids;
12182 size_t sizeof_ids = sizeof (htab->section_pool.v2.section_ids);
12183 /* Reverse map for error checking. */
12184 int ids_seen[DW_SECT_MAX + 1];
12187 if (nr_columns < 2)
12189 error (_("Dwarf Error: bad DWP hash table, too few columns"
12190 " in section table [in module %s]"),
12193 if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
12195 error (_("Dwarf Error: bad DWP hash table, too many columns"
12196 " in section table [in module %s]"),
12199 memset (ids, 255, sizeof_ids);
12200 memset (ids_seen, 255, sizeof (ids_seen));
12201 for (i = 0; i < nr_columns; ++i)
12203 int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
12205 if (id < DW_SECT_MIN || id > DW_SECT_MAX)
12207 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12208 " in section table [in module %s]"),
12209 id, dwp_file->name);
12211 if (ids_seen[id] != -1)
12213 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12214 " id %d in section table [in module %s]"),
12215 id, dwp_file->name);
12220 /* Must have exactly one info or types section. */
12221 if (((ids_seen[DW_SECT_INFO] != -1)
12222 + (ids_seen[DW_SECT_TYPES] != -1))
12225 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12226 " DWO info/types section [in module %s]"),
12229 /* Must have an abbrev section. */
12230 if (ids_seen[DW_SECT_ABBREV] == -1)
12232 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12233 " section [in module %s]"),
12236 htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
12237 htab->section_pool.v2.sizes =
12238 htab->section_pool.v2.offsets + (sizeof (uint32_t)
12239 * nr_units * nr_columns);
12240 if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
12241 * nr_units * nr_columns))
12244 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12245 " [in module %s]"),
12253 /* Update SECTIONS with the data from SECTP.
12255 This function is like the other "locate" section routines that are
12256 passed to bfd_map_over_sections, but in this context the sections to
12257 read comes from the DWP V1 hash table, not the full ELF section table.
12259 The result is non-zero for success, or zero if an error was found. */
12262 locate_v1_virtual_dwo_sections (asection *sectp,
12263 struct virtual_v1_dwo_sections *sections)
12265 const struct dwop_section_names *names = &dwop_section_names;
12267 if (section_is_p (sectp->name, &names->abbrev_dwo))
12269 /* There can be only one. */
12270 if (sections->abbrev.s.section != NULL)
12272 sections->abbrev.s.section = sectp;
12273 sections->abbrev.size = bfd_get_section_size (sectp);
12275 else if (section_is_p (sectp->name, &names->info_dwo)
12276 || section_is_p (sectp->name, &names->types_dwo))
12278 /* There can be only one. */
12279 if (sections->info_or_types.s.section != NULL)
12281 sections->info_or_types.s.section = sectp;
12282 sections->info_or_types.size = bfd_get_section_size (sectp);
12284 else if (section_is_p (sectp->name, &names->line_dwo))
12286 /* There can be only one. */
12287 if (sections->line.s.section != NULL)
12289 sections->line.s.section = sectp;
12290 sections->line.size = bfd_get_section_size (sectp);
12292 else if (section_is_p (sectp->name, &names->loc_dwo))
12294 /* There can be only one. */
12295 if (sections->loc.s.section != NULL)
12297 sections->loc.s.section = sectp;
12298 sections->loc.size = bfd_get_section_size (sectp);
12300 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12302 /* There can be only one. */
12303 if (sections->macinfo.s.section != NULL)
12305 sections->macinfo.s.section = sectp;
12306 sections->macinfo.size = bfd_get_section_size (sectp);
12308 else if (section_is_p (sectp->name, &names->macro_dwo))
12310 /* There can be only one. */
12311 if (sections->macro.s.section != NULL)
12313 sections->macro.s.section = sectp;
12314 sections->macro.size = bfd_get_section_size (sectp);
12316 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12318 /* There can be only one. */
12319 if (sections->str_offsets.s.section != NULL)
12321 sections->str_offsets.s.section = sectp;
12322 sections->str_offsets.size = bfd_get_section_size (sectp);
12326 /* No other kind of section is valid. */
12333 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12334 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12335 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12336 This is for DWP version 1 files. */
12338 static struct dwo_unit *
12339 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12340 struct dwp_file *dwp_file,
12341 uint32_t unit_index,
12342 const char *comp_dir,
12343 ULONGEST signature, int is_debug_types)
12345 struct objfile *objfile = dwarf2_per_objfile->objfile;
12346 const struct dwp_hash_table *dwp_htab =
12347 is_debug_types ? dwp_file->tus : dwp_file->cus;
12348 bfd *dbfd = dwp_file->dbfd.get ();
12349 const char *kind = is_debug_types ? "TU" : "CU";
12350 struct dwo_file *dwo_file;
12351 struct dwo_unit *dwo_unit;
12352 struct virtual_v1_dwo_sections sections;
12353 void **dwo_file_slot;
12356 gdb_assert (dwp_file->version == 1);
12358 if (dwarf_read_debug)
12360 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
12362 pulongest (unit_index), hex_string (signature),
12366 /* Fetch the sections of this DWO unit.
12367 Put a limit on the number of sections we look for so that bad data
12368 doesn't cause us to loop forever. */
12370 #define MAX_NR_V1_DWO_SECTIONS \
12371 (1 /* .debug_info or .debug_types */ \
12372 + 1 /* .debug_abbrev */ \
12373 + 1 /* .debug_line */ \
12374 + 1 /* .debug_loc */ \
12375 + 1 /* .debug_str_offsets */ \
12376 + 1 /* .debug_macro or .debug_macinfo */ \
12377 + 1 /* trailing zero */)
12379 memset (§ions, 0, sizeof (sections));
12381 for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
12384 uint32_t section_nr =
12385 read_4_bytes (dbfd,
12386 dwp_htab->section_pool.v1.indices
12387 + (unit_index + i) * sizeof (uint32_t));
12389 if (section_nr == 0)
12391 if (section_nr >= dwp_file->num_sections)
12393 error (_("Dwarf Error: bad DWP hash table, section number too large"
12394 " [in module %s]"),
12398 sectp = dwp_file->elf_sections[section_nr];
12399 if (! locate_v1_virtual_dwo_sections (sectp, §ions))
12401 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12402 " [in module %s]"),
12408 || dwarf2_section_empty_p (§ions.info_or_types)
12409 || dwarf2_section_empty_p (§ions.abbrev))
12411 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12412 " [in module %s]"),
12415 if (i == MAX_NR_V1_DWO_SECTIONS)
12417 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12418 " [in module %s]"),
12422 /* It's easier for the rest of the code if we fake a struct dwo_file and
12423 have dwo_unit "live" in that. At least for now.
12425 The DWP file can be made up of a random collection of CUs and TUs.
12426 However, for each CU + set of TUs that came from the same original DWO
12427 file, we can combine them back into a virtual DWO file to save space
12428 (fewer struct dwo_file objects to allocate). Remember that for really
12429 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12431 std::string virtual_dwo_name =
12432 string_printf ("virtual-dwo/%d-%d-%d-%d",
12433 get_section_id (§ions.abbrev),
12434 get_section_id (§ions.line),
12435 get_section_id (§ions.loc),
12436 get_section_id (§ions.str_offsets));
12437 /* Can we use an existing virtual DWO file? */
12438 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12439 virtual_dwo_name.c_str (),
12441 /* Create one if necessary. */
12442 if (*dwo_file_slot == NULL)
12444 if (dwarf_read_debug)
12446 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12447 virtual_dwo_name.c_str ());
12449 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12451 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12452 virtual_dwo_name.c_str (),
12453 virtual_dwo_name.size ());
12454 dwo_file->comp_dir = comp_dir;
12455 dwo_file->sections.abbrev = sections.abbrev;
12456 dwo_file->sections.line = sections.line;
12457 dwo_file->sections.loc = sections.loc;
12458 dwo_file->sections.macinfo = sections.macinfo;
12459 dwo_file->sections.macro = sections.macro;
12460 dwo_file->sections.str_offsets = sections.str_offsets;
12461 /* The "str" section is global to the entire DWP file. */
12462 dwo_file->sections.str = dwp_file->sections.str;
12463 /* The info or types section is assigned below to dwo_unit,
12464 there's no need to record it in dwo_file.
12465 Also, we can't simply record type sections in dwo_file because
12466 we record a pointer into the vector in dwo_unit. As we collect more
12467 types we'll grow the vector and eventually have to reallocate space
12468 for it, invalidating all copies of pointers into the previous
12470 *dwo_file_slot = dwo_file;
12474 if (dwarf_read_debug)
12476 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12477 virtual_dwo_name.c_str ());
12479 dwo_file = (struct dwo_file *) *dwo_file_slot;
12482 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12483 dwo_unit->dwo_file = dwo_file;
12484 dwo_unit->signature = signature;
12485 dwo_unit->section =
12486 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12487 *dwo_unit->section = sections.info_or_types;
12488 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12493 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12494 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12495 piece within that section used by a TU/CU, return a virtual section
12496 of just that piece. */
12498 static struct dwarf2_section_info
12499 create_dwp_v2_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
12500 struct dwarf2_section_info *section,
12501 bfd_size_type offset, bfd_size_type size)
12503 struct dwarf2_section_info result;
12506 gdb_assert (section != NULL);
12507 gdb_assert (!section->is_virtual);
12509 memset (&result, 0, sizeof (result));
12510 result.s.containing_section = section;
12511 result.is_virtual = 1;
12516 sectp = get_section_bfd_section (section);
12518 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12519 bounds of the real section. This is a pretty-rare event, so just
12520 flag an error (easier) instead of a warning and trying to cope. */
12522 || offset + size > bfd_get_section_size (sectp))
12524 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12525 " in section %s [in module %s]"),
12526 sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
12527 objfile_name (dwarf2_per_objfile->objfile));
12530 result.virtual_offset = offset;
12531 result.size = size;
12535 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12536 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12537 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12538 This is for DWP version 2 files. */
12540 static struct dwo_unit *
12541 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12542 struct dwp_file *dwp_file,
12543 uint32_t unit_index,
12544 const char *comp_dir,
12545 ULONGEST signature, int is_debug_types)
12547 struct objfile *objfile = dwarf2_per_objfile->objfile;
12548 const struct dwp_hash_table *dwp_htab =
12549 is_debug_types ? dwp_file->tus : dwp_file->cus;
12550 bfd *dbfd = dwp_file->dbfd.get ();
12551 const char *kind = is_debug_types ? "TU" : "CU";
12552 struct dwo_file *dwo_file;
12553 struct dwo_unit *dwo_unit;
12554 struct virtual_v2_dwo_sections sections;
12555 void **dwo_file_slot;
12558 gdb_assert (dwp_file->version == 2);
12560 if (dwarf_read_debug)
12562 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
12564 pulongest (unit_index), hex_string (signature),
12568 /* Fetch the section offsets of this DWO unit. */
12570 memset (§ions, 0, sizeof (sections));
12572 for (i = 0; i < dwp_htab->nr_columns; ++i)
12574 uint32_t offset = read_4_bytes (dbfd,
12575 dwp_htab->section_pool.v2.offsets
12576 + (((unit_index - 1) * dwp_htab->nr_columns
12578 * sizeof (uint32_t)));
12579 uint32_t size = read_4_bytes (dbfd,
12580 dwp_htab->section_pool.v2.sizes
12581 + (((unit_index - 1) * dwp_htab->nr_columns
12583 * sizeof (uint32_t)));
12585 switch (dwp_htab->section_pool.v2.section_ids[i])
12588 case DW_SECT_TYPES:
12589 sections.info_or_types_offset = offset;
12590 sections.info_or_types_size = size;
12592 case DW_SECT_ABBREV:
12593 sections.abbrev_offset = offset;
12594 sections.abbrev_size = size;
12597 sections.line_offset = offset;
12598 sections.line_size = size;
12601 sections.loc_offset = offset;
12602 sections.loc_size = size;
12604 case DW_SECT_STR_OFFSETS:
12605 sections.str_offsets_offset = offset;
12606 sections.str_offsets_size = size;
12608 case DW_SECT_MACINFO:
12609 sections.macinfo_offset = offset;
12610 sections.macinfo_size = size;
12612 case DW_SECT_MACRO:
12613 sections.macro_offset = offset;
12614 sections.macro_size = size;
12619 /* It's easier for the rest of the code if we fake a struct dwo_file and
12620 have dwo_unit "live" in that. At least for now.
12622 The DWP file can be made up of a random collection of CUs and TUs.
12623 However, for each CU + set of TUs that came from the same original DWO
12624 file, we can combine them back into a virtual DWO file to save space
12625 (fewer struct dwo_file objects to allocate). Remember that for really
12626 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12628 std::string virtual_dwo_name =
12629 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12630 (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
12631 (long) (sections.line_size ? sections.line_offset : 0),
12632 (long) (sections.loc_size ? sections.loc_offset : 0),
12633 (long) (sections.str_offsets_size
12634 ? sections.str_offsets_offset : 0));
12635 /* Can we use an existing virtual DWO file? */
12636 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12637 virtual_dwo_name.c_str (),
12639 /* Create one if necessary. */
12640 if (*dwo_file_slot == NULL)
12642 if (dwarf_read_debug)
12644 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12645 virtual_dwo_name.c_str ());
12647 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12649 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12650 virtual_dwo_name.c_str (),
12651 virtual_dwo_name.size ());
12652 dwo_file->comp_dir = comp_dir;
12653 dwo_file->sections.abbrev =
12654 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,
12655 sections.abbrev_offset, sections.abbrev_size);
12656 dwo_file->sections.line =
12657 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.line,
12658 sections.line_offset, sections.line_size);
12659 dwo_file->sections.loc =
12660 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.loc,
12661 sections.loc_offset, sections.loc_size);
12662 dwo_file->sections.macinfo =
12663 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macinfo,
12664 sections.macinfo_offset, sections.macinfo_size);
12665 dwo_file->sections.macro =
12666 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macro,
12667 sections.macro_offset, sections.macro_size);
12668 dwo_file->sections.str_offsets =
12669 create_dwp_v2_section (dwarf2_per_objfile,
12670 &dwp_file->sections.str_offsets,
12671 sections.str_offsets_offset,
12672 sections.str_offsets_size);
12673 /* The "str" section is global to the entire DWP file. */
12674 dwo_file->sections.str = dwp_file->sections.str;
12675 /* The info or types section is assigned below to dwo_unit,
12676 there's no need to record it in dwo_file.
12677 Also, we can't simply record type sections in dwo_file because
12678 we record a pointer into the vector in dwo_unit. As we collect more
12679 types we'll grow the vector and eventually have to reallocate space
12680 for it, invalidating all copies of pointers into the previous
12682 *dwo_file_slot = dwo_file;
12686 if (dwarf_read_debug)
12688 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12689 virtual_dwo_name.c_str ());
12691 dwo_file = (struct dwo_file *) *dwo_file_slot;
12694 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12695 dwo_unit->dwo_file = dwo_file;
12696 dwo_unit->signature = signature;
12697 dwo_unit->section =
12698 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12699 *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
12701 ? &dwp_file->sections.types
12702 : &dwp_file->sections.info,
12703 sections.info_or_types_offset,
12704 sections.info_or_types_size);
12705 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12710 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12711 Returns NULL if the signature isn't found. */
12713 static struct dwo_unit *
12714 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile *dwarf2_per_objfile,
12715 struct dwp_file *dwp_file, const char *comp_dir,
12716 ULONGEST signature, int is_debug_types)
12718 const struct dwp_hash_table *dwp_htab =
12719 is_debug_types ? dwp_file->tus : dwp_file->cus;
12720 bfd *dbfd = dwp_file->dbfd.get ();
12721 uint32_t mask = dwp_htab->nr_slots - 1;
12722 uint32_t hash = signature & mask;
12723 uint32_t hash2 = ((signature >> 32) & mask) | 1;
12726 struct dwo_unit find_dwo_cu;
12728 memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
12729 find_dwo_cu.signature = signature;
12730 slot = htab_find_slot (is_debug_types
12731 ? dwp_file->loaded_tus
12732 : dwp_file->loaded_cus,
12733 &find_dwo_cu, INSERT);
12736 return (struct dwo_unit *) *slot;
12738 /* Use a for loop so that we don't loop forever on bad debug info. */
12739 for (i = 0; i < dwp_htab->nr_slots; ++i)
12741 ULONGEST signature_in_table;
12743 signature_in_table =
12744 read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
12745 if (signature_in_table == signature)
12747 uint32_t unit_index =
12748 read_4_bytes (dbfd,
12749 dwp_htab->unit_table + hash * sizeof (uint32_t));
12751 if (dwp_file->version == 1)
12753 *slot = create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile,
12754 dwp_file, unit_index,
12755 comp_dir, signature,
12760 *slot = create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile,
12761 dwp_file, unit_index,
12762 comp_dir, signature,
12765 return (struct dwo_unit *) *slot;
12767 if (signature_in_table == 0)
12769 hash = (hash + hash2) & mask;
12772 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12773 " [in module %s]"),
12777 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12778 Open the file specified by FILE_NAME and hand it off to BFD for
12779 preliminary analysis. Return a newly initialized bfd *, which
12780 includes a canonicalized copy of FILE_NAME.
12781 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12782 SEARCH_CWD is true if the current directory is to be searched.
12783 It will be searched before debug-file-directory.
12784 If successful, the file is added to the bfd include table of the
12785 objfile's bfd (see gdb_bfd_record_inclusion).
12786 If unable to find/open the file, return NULL.
12787 NOTE: This function is derived from symfile_bfd_open. */
12789 static gdb_bfd_ref_ptr
12790 try_open_dwop_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12791 const char *file_name, int is_dwp, int search_cwd)
12794 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12795 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12796 to debug_file_directory. */
12797 const char *search_path;
12798 static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
12800 gdb::unique_xmalloc_ptr<char> search_path_holder;
12803 if (*debug_file_directory != '\0')
12805 search_path_holder.reset (concat (".", dirname_separator_string,
12806 debug_file_directory,
12808 search_path = search_path_holder.get ();
12814 search_path = debug_file_directory;
12816 openp_flags flags = OPF_RETURN_REALPATH;
12818 flags |= OPF_SEARCH_IN_PATH;
12820 gdb::unique_xmalloc_ptr<char> absolute_name;
12821 desc = openp (search_path, flags, file_name,
12822 O_RDONLY | O_BINARY, &absolute_name);
12826 gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (absolute_name.get (),
12828 if (sym_bfd == NULL)
12830 bfd_set_cacheable (sym_bfd.get (), 1);
12832 if (!bfd_check_format (sym_bfd.get (), bfd_object))
12835 /* Success. Record the bfd as having been included by the objfile's bfd.
12836 This is important because things like demangled_names_hash lives in the
12837 objfile's per_bfd space and may have references to things like symbol
12838 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12839 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd.get ());
12844 /* Try to open DWO file FILE_NAME.
12845 COMP_DIR is the DW_AT_comp_dir attribute.
12846 The result is the bfd handle of the file.
12847 If there is a problem finding or opening the file, return NULL.
12848 Upon success, the canonicalized path of the file is stored in the bfd,
12849 same as symfile_bfd_open. */
12851 static gdb_bfd_ref_ptr
12852 open_dwo_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12853 const char *file_name, const char *comp_dir)
12855 if (IS_ABSOLUTE_PATH (file_name))
12856 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12857 0 /*is_dwp*/, 0 /*search_cwd*/);
12859 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12861 if (comp_dir != NULL)
12863 char *path_to_try = concat (comp_dir, SLASH_STRING,
12864 file_name, (char *) NULL);
12866 /* NOTE: If comp_dir is a relative path, this will also try the
12867 search path, which seems useful. */
12868 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile,
12871 1 /*search_cwd*/));
12872 xfree (path_to_try);
12877 /* That didn't work, try debug-file-directory, which, despite its name,
12878 is a list of paths. */
12880 if (*debug_file_directory == '\0')
12883 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12884 0 /*is_dwp*/, 1 /*search_cwd*/);
12887 /* This function is mapped across the sections and remembers the offset and
12888 size of each of the DWO debugging sections we are interested in. */
12891 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
12893 struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
12894 const struct dwop_section_names *names = &dwop_section_names;
12896 if (section_is_p (sectp->name, &names->abbrev_dwo))
12898 dwo_sections->abbrev.s.section = sectp;
12899 dwo_sections->abbrev.size = bfd_get_section_size (sectp);
12901 else if (section_is_p (sectp->name, &names->info_dwo))
12903 dwo_sections->info.s.section = sectp;
12904 dwo_sections->info.size = bfd_get_section_size (sectp);
12906 else if (section_is_p (sectp->name, &names->line_dwo))
12908 dwo_sections->line.s.section = sectp;
12909 dwo_sections->line.size = bfd_get_section_size (sectp);
12911 else if (section_is_p (sectp->name, &names->loc_dwo))
12913 dwo_sections->loc.s.section = sectp;
12914 dwo_sections->loc.size = bfd_get_section_size (sectp);
12916 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12918 dwo_sections->macinfo.s.section = sectp;
12919 dwo_sections->macinfo.size = bfd_get_section_size (sectp);
12921 else if (section_is_p (sectp->name, &names->macro_dwo))
12923 dwo_sections->macro.s.section = sectp;
12924 dwo_sections->macro.size = bfd_get_section_size (sectp);
12926 else if (section_is_p (sectp->name, &names->str_dwo))
12928 dwo_sections->str.s.section = sectp;
12929 dwo_sections->str.size = bfd_get_section_size (sectp);
12931 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12933 dwo_sections->str_offsets.s.section = sectp;
12934 dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
12936 else if (section_is_p (sectp->name, &names->types_dwo))
12938 struct dwarf2_section_info type_section;
12940 memset (&type_section, 0, sizeof (type_section));
12941 type_section.s.section = sectp;
12942 type_section.size = bfd_get_section_size (sectp);
12943 VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
12948 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12949 by PER_CU. This is for the non-DWP case.
12950 The result is NULL if DWO_NAME can't be found. */
12952 static struct dwo_file *
12953 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
12954 const char *dwo_name, const char *comp_dir)
12956 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
12957 struct objfile *objfile = dwarf2_per_objfile->objfile;
12959 gdb_bfd_ref_ptr dbfd (open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir));
12962 if (dwarf_read_debug)
12963 fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
12967 /* We use a unique pointer here, despite the obstack allocation,
12968 because a dwo_file needs some cleanup if it is abandoned. */
12969 dwo_file_up dwo_file (OBSTACK_ZALLOC (&objfile->objfile_obstack,
12971 dwo_file->dwo_name = dwo_name;
12972 dwo_file->comp_dir = comp_dir;
12973 dwo_file->dbfd = dbfd.release ();
12975 bfd_map_over_sections (dwo_file->dbfd, dwarf2_locate_dwo_sections,
12976 &dwo_file->sections);
12978 create_cus_hash_table (dwarf2_per_objfile, *dwo_file, dwo_file->sections.info,
12981 create_debug_types_hash_table (dwarf2_per_objfile, dwo_file.get (),
12982 dwo_file->sections.types, dwo_file->tus);
12984 if (dwarf_read_debug)
12985 fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
12987 return dwo_file.release ();
12990 /* This function is mapped across the sections and remembers the offset and
12991 size of each of the DWP debugging sections common to version 1 and 2 that
12992 we are interested in. */
12995 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
12996 void *dwp_file_ptr)
12998 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
12999 const struct dwop_section_names *names = &dwop_section_names;
13000 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13002 /* Record the ELF section number for later lookup: this is what the
13003 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13004 gdb_assert (elf_section_nr < dwp_file->num_sections);
13005 dwp_file->elf_sections[elf_section_nr] = sectp;
13007 /* Look for specific sections that we need. */
13008 if (section_is_p (sectp->name, &names->str_dwo))
13010 dwp_file->sections.str.s.section = sectp;
13011 dwp_file->sections.str.size = bfd_get_section_size (sectp);
13013 else if (section_is_p (sectp->name, &names->cu_index))
13015 dwp_file->sections.cu_index.s.section = sectp;
13016 dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
13018 else if (section_is_p (sectp->name, &names->tu_index))
13020 dwp_file->sections.tu_index.s.section = sectp;
13021 dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
13025 /* This function is mapped across the sections and remembers the offset and
13026 size of each of the DWP version 2 debugging sections that we are interested
13027 in. This is split into a separate function because we don't know if we
13028 have version 1 or 2 until we parse the cu_index/tu_index sections. */
13031 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
13033 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13034 const struct dwop_section_names *names = &dwop_section_names;
13035 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13037 /* Record the ELF section number for later lookup: this is what the
13038 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13039 gdb_assert (elf_section_nr < dwp_file->num_sections);
13040 dwp_file->elf_sections[elf_section_nr] = sectp;
13042 /* Look for specific sections that we need. */
13043 if (section_is_p (sectp->name, &names->abbrev_dwo))
13045 dwp_file->sections.abbrev.s.section = sectp;
13046 dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
13048 else if (section_is_p (sectp->name, &names->info_dwo))
13050 dwp_file->sections.info.s.section = sectp;
13051 dwp_file->sections.info.size = bfd_get_section_size (sectp);
13053 else if (section_is_p (sectp->name, &names->line_dwo))
13055 dwp_file->sections.line.s.section = sectp;
13056 dwp_file->sections.line.size = bfd_get_section_size (sectp);
13058 else if (section_is_p (sectp->name, &names->loc_dwo))
13060 dwp_file->sections.loc.s.section = sectp;
13061 dwp_file->sections.loc.size = bfd_get_section_size (sectp);
13063 else if (section_is_p (sectp->name, &names->macinfo_dwo))
13065 dwp_file->sections.macinfo.s.section = sectp;
13066 dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
13068 else if (section_is_p (sectp->name, &names->macro_dwo))
13070 dwp_file->sections.macro.s.section = sectp;
13071 dwp_file->sections.macro.size = bfd_get_section_size (sectp);
13073 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
13075 dwp_file->sections.str_offsets.s.section = sectp;
13076 dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
13078 else if (section_is_p (sectp->name, &names->types_dwo))
13080 dwp_file->sections.types.s.section = sectp;
13081 dwp_file->sections.types.size = bfd_get_section_size (sectp);
13085 /* Hash function for dwp_file loaded CUs/TUs. */
13088 hash_dwp_loaded_cutus (const void *item)
13090 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
13092 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13093 return dwo_unit->signature;
13096 /* Equality function for dwp_file loaded CUs/TUs. */
13099 eq_dwp_loaded_cutus (const void *a, const void *b)
13101 const struct dwo_unit *dua = (const struct dwo_unit *) a;
13102 const struct dwo_unit *dub = (const struct dwo_unit *) b;
13104 return dua->signature == dub->signature;
13107 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13110 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
13112 return htab_create_alloc_ex (3,
13113 hash_dwp_loaded_cutus,
13114 eq_dwp_loaded_cutus,
13116 &objfile->objfile_obstack,
13117 hashtab_obstack_allocate,
13118 dummy_obstack_deallocate);
13121 /* Try to open DWP file FILE_NAME.
13122 The result is the bfd handle of the file.
13123 If there is a problem finding or opening the file, return NULL.
13124 Upon success, the canonicalized path of the file is stored in the bfd,
13125 same as symfile_bfd_open. */
13127 static gdb_bfd_ref_ptr
13128 open_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
13129 const char *file_name)
13131 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile, file_name,
13133 1 /*search_cwd*/));
13137 /* Work around upstream bug 15652.
13138 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13139 [Whether that's a "bug" is debatable, but it is getting in our way.]
13140 We have no real idea where the dwp file is, because gdb's realpath-ing
13141 of the executable's path may have discarded the needed info.
13142 [IWBN if the dwp file name was recorded in the executable, akin to
13143 .gnu_debuglink, but that doesn't exist yet.]
13144 Strip the directory from FILE_NAME and search again. */
13145 if (*debug_file_directory != '\0')
13147 /* Don't implicitly search the current directory here.
13148 If the user wants to search "." to handle this case,
13149 it must be added to debug-file-directory. */
13150 return try_open_dwop_file (dwarf2_per_objfile,
13151 lbasename (file_name), 1 /*is_dwp*/,
13158 /* Initialize the use of the DWP file for the current objfile.
13159 By convention the name of the DWP file is ${objfile}.dwp.
13160 The result is NULL if it can't be found. */
13162 static std::unique_ptr<struct dwp_file>
13163 open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13165 struct objfile *objfile = dwarf2_per_objfile->objfile;
13167 /* Try to find first .dwp for the binary file before any symbolic links
13170 /* If the objfile is a debug file, find the name of the real binary
13171 file and get the name of dwp file from there. */
13172 std::string dwp_name;
13173 if (objfile->separate_debug_objfile_backlink != NULL)
13175 struct objfile *backlink = objfile->separate_debug_objfile_backlink;
13176 const char *backlink_basename = lbasename (backlink->original_name);
13178 dwp_name = ldirname (objfile->original_name) + SLASH_STRING + backlink_basename;
13181 dwp_name = objfile->original_name;
13183 dwp_name += ".dwp";
13185 gdb_bfd_ref_ptr dbfd (open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ()));
13187 && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
13189 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13190 dwp_name = objfile_name (objfile);
13191 dwp_name += ".dwp";
13192 dbfd = open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ());
13197 if (dwarf_read_debug)
13198 fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name.c_str ());
13199 return std::unique_ptr<dwp_file> ();
13202 const char *name = bfd_get_filename (dbfd.get ());
13203 std::unique_ptr<struct dwp_file> dwp_file
13204 (new struct dwp_file (name, std::move (dbfd)));
13206 /* +1: section 0 is unused */
13207 dwp_file->num_sections = bfd_count_sections (dwp_file->dbfd) + 1;
13208 dwp_file->elf_sections =
13209 OBSTACK_CALLOC (&objfile->objfile_obstack,
13210 dwp_file->num_sections, asection *);
13212 bfd_map_over_sections (dwp_file->dbfd.get (),
13213 dwarf2_locate_common_dwp_sections,
13216 dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13219 dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13222 /* The DWP file version is stored in the hash table. Oh well. */
13223 if (dwp_file->cus && dwp_file->tus
13224 && dwp_file->cus->version != dwp_file->tus->version)
13226 /* Technically speaking, we should try to limp along, but this is
13227 pretty bizarre. We use pulongest here because that's the established
13228 portability solution (e.g, we cannot use %u for uint32_t). */
13229 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13230 " TU version %s [in DWP file %s]"),
13231 pulongest (dwp_file->cus->version),
13232 pulongest (dwp_file->tus->version), dwp_name.c_str ());
13236 dwp_file->version = dwp_file->cus->version;
13237 else if (dwp_file->tus)
13238 dwp_file->version = dwp_file->tus->version;
13240 dwp_file->version = 2;
13242 if (dwp_file->version == 2)
13243 bfd_map_over_sections (dwp_file->dbfd.get (),
13244 dwarf2_locate_v2_dwp_sections,
13247 dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
13248 dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
13250 if (dwarf_read_debug)
13252 fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
13253 fprintf_unfiltered (gdb_stdlog,
13254 " %s CUs, %s TUs\n",
13255 pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
13256 pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
13262 /* Wrapper around open_and_init_dwp_file, only open it once. */
13264 static struct dwp_file *
13265 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13267 if (! dwarf2_per_objfile->dwp_checked)
13269 dwarf2_per_objfile->dwp_file
13270 = open_and_init_dwp_file (dwarf2_per_objfile);
13271 dwarf2_per_objfile->dwp_checked = 1;
13273 return dwarf2_per_objfile->dwp_file.get ();
13276 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13277 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13278 or in the DWP file for the objfile, referenced by THIS_UNIT.
13279 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13280 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13282 This is called, for example, when wanting to read a variable with a
13283 complex location. Therefore we don't want to do file i/o for every call.
13284 Therefore we don't want to look for a DWO file on every call.
13285 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13286 then we check if we've already seen DWO_NAME, and only THEN do we check
13289 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13290 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13292 static struct dwo_unit *
13293 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
13294 const char *dwo_name, const char *comp_dir,
13295 ULONGEST signature, int is_debug_types)
13297 struct dwarf2_per_objfile *dwarf2_per_objfile = this_unit->dwarf2_per_objfile;
13298 struct objfile *objfile = dwarf2_per_objfile->objfile;
13299 const char *kind = is_debug_types ? "TU" : "CU";
13300 void **dwo_file_slot;
13301 struct dwo_file *dwo_file;
13302 struct dwp_file *dwp_file;
13304 /* First see if there's a DWP file.
13305 If we have a DWP file but didn't find the DWO inside it, don't
13306 look for the original DWO file. It makes gdb behave differently
13307 depending on whether one is debugging in the build tree. */
13309 dwp_file = get_dwp_file (dwarf2_per_objfile);
13310 if (dwp_file != NULL)
13312 const struct dwp_hash_table *dwp_htab =
13313 is_debug_types ? dwp_file->tus : dwp_file->cus;
13315 if (dwp_htab != NULL)
13317 struct dwo_unit *dwo_cutu =
13318 lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, comp_dir,
13319 signature, is_debug_types);
13321 if (dwo_cutu != NULL)
13323 if (dwarf_read_debug)
13325 fprintf_unfiltered (gdb_stdlog,
13326 "Virtual DWO %s %s found: @%s\n",
13327 kind, hex_string (signature),
13328 host_address_to_string (dwo_cutu));
13336 /* No DWP file, look for the DWO file. */
13338 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
13339 dwo_name, comp_dir);
13340 if (*dwo_file_slot == NULL)
13342 /* Read in the file and build a table of the CUs/TUs it contains. */
13343 *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
13345 /* NOTE: This will be NULL if unable to open the file. */
13346 dwo_file = (struct dwo_file *) *dwo_file_slot;
13348 if (dwo_file != NULL)
13350 struct dwo_unit *dwo_cutu = NULL;
13352 if (is_debug_types && dwo_file->tus)
13354 struct dwo_unit find_dwo_cutu;
13356 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13357 find_dwo_cutu.signature = signature;
13359 = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
13361 else if (!is_debug_types && dwo_file->cus)
13363 struct dwo_unit find_dwo_cutu;
13365 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13366 find_dwo_cutu.signature = signature;
13367 dwo_cutu = (struct dwo_unit *)htab_find (dwo_file->cus,
13371 if (dwo_cutu != NULL)
13373 if (dwarf_read_debug)
13375 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
13376 kind, dwo_name, hex_string (signature),
13377 host_address_to_string (dwo_cutu));
13384 /* We didn't find it. This could mean a dwo_id mismatch, or
13385 someone deleted the DWO/DWP file, or the search path isn't set up
13386 correctly to find the file. */
13388 if (dwarf_read_debug)
13390 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
13391 kind, dwo_name, hex_string (signature));
13394 /* This is a warning and not a complaint because it can be caused by
13395 pilot error (e.g., user accidentally deleting the DWO). */
13397 /* Print the name of the DWP file if we looked there, helps the user
13398 better diagnose the problem. */
13399 std::string dwp_text;
13401 if (dwp_file != NULL)
13402 dwp_text = string_printf (" [in DWP file %s]",
13403 lbasename (dwp_file->name));
13405 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13406 " [in module %s]"),
13407 kind, dwo_name, hex_string (signature),
13409 this_unit->is_debug_types ? "TU" : "CU",
13410 sect_offset_str (this_unit->sect_off), objfile_name (objfile));
13415 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13416 See lookup_dwo_cutu_unit for details. */
13418 static struct dwo_unit *
13419 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
13420 const char *dwo_name, const char *comp_dir,
13421 ULONGEST signature)
13423 return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
13426 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13427 See lookup_dwo_cutu_unit for details. */
13429 static struct dwo_unit *
13430 lookup_dwo_type_unit (struct signatured_type *this_tu,
13431 const char *dwo_name, const char *comp_dir)
13433 return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
13436 /* Traversal function for queue_and_load_all_dwo_tus. */
13439 queue_and_load_dwo_tu (void **slot, void *info)
13441 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
13442 struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
13443 ULONGEST signature = dwo_unit->signature;
13444 struct signatured_type *sig_type =
13445 lookup_dwo_signatured_type (per_cu->cu, signature);
13447 if (sig_type != NULL)
13449 struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
13451 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13452 a real dependency of PER_CU on SIG_TYPE. That is detected later
13453 while processing PER_CU. */
13454 if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
13455 load_full_type_unit (sig_cu);
13456 VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
13462 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13463 The DWO may have the only definition of the type, though it may not be
13464 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13465 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13468 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
13470 struct dwo_unit *dwo_unit;
13471 struct dwo_file *dwo_file;
13473 gdb_assert (!per_cu->is_debug_types);
13474 gdb_assert (get_dwp_file (per_cu->dwarf2_per_objfile) == NULL);
13475 gdb_assert (per_cu->cu != NULL);
13477 dwo_unit = per_cu->cu->dwo_unit;
13478 gdb_assert (dwo_unit != NULL);
13480 dwo_file = dwo_unit->dwo_file;
13481 if (dwo_file->tus != NULL)
13482 htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
13485 /* Free all resources associated with DWO_FILE.
13486 Close the DWO file and munmap the sections. */
13489 free_dwo_file (struct dwo_file *dwo_file)
13491 /* Note: dbfd is NULL for virtual DWO files. */
13492 gdb_bfd_unref (dwo_file->dbfd);
13494 VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
13497 /* Traversal function for free_dwo_files. */
13500 free_dwo_file_from_slot (void **slot, void *info)
13502 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
13504 free_dwo_file (dwo_file);
13509 /* Free all resources associated with DWO_FILES. */
13512 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
13514 htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
13517 /* Read in various DIEs. */
13519 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13520 Inherit only the children of the DW_AT_abstract_origin DIE not being
13521 already referenced by DW_AT_abstract_origin from the children of the
13525 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
13527 struct die_info *child_die;
13528 sect_offset *offsetp;
13529 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13530 struct die_info *origin_die;
13531 /* Iterator of the ORIGIN_DIE children. */
13532 struct die_info *origin_child_die;
13533 struct attribute *attr;
13534 struct dwarf2_cu *origin_cu;
13535 struct pending **origin_previous_list_in_scope;
13537 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13541 /* Note that following die references may follow to a die in a
13545 origin_die = follow_die_ref (die, attr, &origin_cu);
13547 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13549 origin_previous_list_in_scope = origin_cu->list_in_scope;
13550 origin_cu->list_in_scope = cu->list_in_scope;
13552 if (die->tag != origin_die->tag
13553 && !(die->tag == DW_TAG_inlined_subroutine
13554 && origin_die->tag == DW_TAG_subprogram))
13555 complaint (_("DIE %s and its abstract origin %s have different tags"),
13556 sect_offset_str (die->sect_off),
13557 sect_offset_str (origin_die->sect_off));
13559 std::vector<sect_offset> offsets;
13561 for (child_die = die->child;
13562 child_die && child_die->tag;
13563 child_die = sibling_die (child_die))
13565 struct die_info *child_origin_die;
13566 struct dwarf2_cu *child_origin_cu;
13568 /* We are trying to process concrete instance entries:
13569 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13570 it's not relevant to our analysis here. i.e. detecting DIEs that are
13571 present in the abstract instance but not referenced in the concrete
13573 if (child_die->tag == DW_TAG_call_site
13574 || child_die->tag == DW_TAG_GNU_call_site)
13577 /* For each CHILD_DIE, find the corresponding child of
13578 ORIGIN_DIE. If there is more than one layer of
13579 DW_AT_abstract_origin, follow them all; there shouldn't be,
13580 but GCC versions at least through 4.4 generate this (GCC PR
13582 child_origin_die = child_die;
13583 child_origin_cu = cu;
13586 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
13590 child_origin_die = follow_die_ref (child_origin_die, attr,
13594 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13595 counterpart may exist. */
13596 if (child_origin_die != child_die)
13598 if (child_die->tag != child_origin_die->tag
13599 && !(child_die->tag == DW_TAG_inlined_subroutine
13600 && child_origin_die->tag == DW_TAG_subprogram))
13601 complaint (_("Child DIE %s and its abstract origin %s have "
13603 sect_offset_str (child_die->sect_off),
13604 sect_offset_str (child_origin_die->sect_off));
13605 if (child_origin_die->parent != origin_die)
13606 complaint (_("Child DIE %s and its abstract origin %s have "
13607 "different parents"),
13608 sect_offset_str (child_die->sect_off),
13609 sect_offset_str (child_origin_die->sect_off));
13611 offsets.push_back (child_origin_die->sect_off);
13614 std::sort (offsets.begin (), offsets.end ());
13615 sect_offset *offsets_end = offsets.data () + offsets.size ();
13616 for (offsetp = offsets.data () + 1; offsetp < offsets_end; offsetp++)
13617 if (offsetp[-1] == *offsetp)
13618 complaint (_("Multiple children of DIE %s refer "
13619 "to DIE %s as their abstract origin"),
13620 sect_offset_str (die->sect_off), sect_offset_str (*offsetp));
13622 offsetp = offsets.data ();
13623 origin_child_die = origin_die->child;
13624 while (origin_child_die && origin_child_die->tag)
13626 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13627 while (offsetp < offsets_end
13628 && *offsetp < origin_child_die->sect_off)
13630 if (offsetp >= offsets_end
13631 || *offsetp > origin_child_die->sect_off)
13633 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13634 Check whether we're already processing ORIGIN_CHILD_DIE.
13635 This can happen with mutually referenced abstract_origins.
13637 if (!origin_child_die->in_process)
13638 process_die (origin_child_die, origin_cu);
13640 origin_child_die = sibling_die (origin_child_die);
13642 origin_cu->list_in_scope = origin_previous_list_in_scope;
13646 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
13648 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13649 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13650 struct context_stack *newobj;
13653 struct die_info *child_die;
13654 struct attribute *attr, *call_line, *call_file;
13656 CORE_ADDR baseaddr;
13657 struct block *block;
13658 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
13659 std::vector<struct symbol *> template_args;
13660 struct template_symbol *templ_func = NULL;
13664 /* If we do not have call site information, we can't show the
13665 caller of this inlined function. That's too confusing, so
13666 only use the scope for local variables. */
13667 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
13668 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
13669 if (call_line == NULL || call_file == NULL)
13671 read_lexical_block_scope (die, cu);
13676 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13678 name = dwarf2_name (die, cu);
13680 /* Ignore functions with missing or empty names. These are actually
13681 illegal according to the DWARF standard. */
13684 complaint (_("missing name for subprogram DIE at %s"),
13685 sect_offset_str (die->sect_off));
13689 /* Ignore functions with missing or invalid low and high pc attributes. */
13690 if (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL)
13691 <= PC_BOUNDS_INVALID)
13693 attr = dwarf2_attr (die, DW_AT_external, cu);
13694 if (!attr || !DW_UNSND (attr))
13695 complaint (_("cannot get low and high bounds "
13696 "for subprogram DIE at %s"),
13697 sect_offset_str (die->sect_off));
13701 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13702 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13704 /* If we have any template arguments, then we must allocate a
13705 different sort of symbol. */
13706 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
13708 if (child_die->tag == DW_TAG_template_type_param
13709 || child_die->tag == DW_TAG_template_value_param)
13711 templ_func = allocate_template_symbol (objfile);
13712 templ_func->subclass = SYMBOL_TEMPLATE;
13717 newobj = cu->builder->push_context (0, lowpc);
13718 newobj->name = new_symbol (die, read_type_die (die, cu), cu,
13719 (struct symbol *) templ_func);
13721 /* If there is a location expression for DW_AT_frame_base, record
13723 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
13725 dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
13727 /* If there is a location for the static link, record it. */
13728 newobj->static_link = NULL;
13729 attr = dwarf2_attr (die, DW_AT_static_link, cu);
13732 newobj->static_link
13733 = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
13734 attr_to_dynamic_prop (attr, die, cu, newobj->static_link);
13737 cu->list_in_scope = cu->builder->get_local_symbols ();
13739 if (die->child != NULL)
13741 child_die = die->child;
13742 while (child_die && child_die->tag)
13744 if (child_die->tag == DW_TAG_template_type_param
13745 || child_die->tag == DW_TAG_template_value_param)
13747 struct symbol *arg = new_symbol (child_die, NULL, cu);
13750 template_args.push_back (arg);
13753 process_die (child_die, cu);
13754 child_die = sibling_die (child_die);
13758 inherit_abstract_dies (die, cu);
13760 /* If we have a DW_AT_specification, we might need to import using
13761 directives from the context of the specification DIE. See the
13762 comment in determine_prefix. */
13763 if (cu->language == language_cplus
13764 && dwarf2_attr (die, DW_AT_specification, cu))
13766 struct dwarf2_cu *spec_cu = cu;
13767 struct die_info *spec_die = die_specification (die, &spec_cu);
13771 child_die = spec_die->child;
13772 while (child_die && child_die->tag)
13774 if (child_die->tag == DW_TAG_imported_module)
13775 process_die (child_die, spec_cu);
13776 child_die = sibling_die (child_die);
13779 /* In some cases, GCC generates specification DIEs that
13780 themselves contain DW_AT_specification attributes. */
13781 spec_die = die_specification (spec_die, &spec_cu);
13785 struct context_stack cstk = cu->builder->pop_context ();
13786 /* Make a block for the local symbols within. */
13787 block = cu->builder->finish_block (cstk.name, cstk.old_blocks,
13788 cstk.static_link, lowpc, highpc);
13790 /* For C++, set the block's scope. */
13791 if ((cu->language == language_cplus
13792 || cu->language == language_fortran
13793 || cu->language == language_d
13794 || cu->language == language_rust)
13795 && cu->processing_has_namespace_info)
13796 block_set_scope (block, determine_prefix (die, cu),
13797 &objfile->objfile_obstack);
13799 /* If we have address ranges, record them. */
13800 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13802 gdbarch_make_symbol_special (gdbarch, cstk.name, objfile);
13804 /* Attach template arguments to function. */
13805 if (!template_args.empty ())
13807 gdb_assert (templ_func != NULL);
13809 templ_func->n_template_arguments = template_args.size ();
13810 templ_func->template_arguments
13811 = XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
13812 templ_func->n_template_arguments);
13813 memcpy (templ_func->template_arguments,
13814 template_args.data (),
13815 (templ_func->n_template_arguments * sizeof (struct symbol *)));
13817 /* Make sure that the symtab is set on the new symbols. Even
13818 though they don't appear in this symtab directly, other parts
13819 of gdb assume that symbols do, and this is reasonably
13821 for (symbol *sym : template_args)
13822 symbol_set_symtab (sym, symbol_symtab (templ_func));
13825 /* In C++, we can have functions nested inside functions (e.g., when
13826 a function declares a class that has methods). This means that
13827 when we finish processing a function scope, we may need to go
13828 back to building a containing block's symbol lists. */
13829 *cu->builder->get_local_symbols () = cstk.locals;
13830 cu->builder->set_local_using_directives (cstk.local_using_directives);
13832 /* If we've finished processing a top-level function, subsequent
13833 symbols go in the file symbol list. */
13834 if (cu->builder->outermost_context_p ())
13835 cu->list_in_scope = cu->builder->get_file_symbols ();
13838 /* Process all the DIES contained within a lexical block scope. Start
13839 a new scope, process the dies, and then close the scope. */
13842 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
13844 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13845 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13846 CORE_ADDR lowpc, highpc;
13847 struct die_info *child_die;
13848 CORE_ADDR baseaddr;
13850 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13852 /* Ignore blocks with missing or invalid low and high pc attributes. */
13853 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13854 as multiple lexical blocks? Handling children in a sane way would
13855 be nasty. Might be easier to properly extend generic blocks to
13856 describe ranges. */
13857 switch (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
13859 case PC_BOUNDS_NOT_PRESENT:
13860 /* DW_TAG_lexical_block has no attributes, process its children as if
13861 there was no wrapping by that DW_TAG_lexical_block.
13862 GCC does no longer produces such DWARF since GCC r224161. */
13863 for (child_die = die->child;
13864 child_die != NULL && child_die->tag;
13865 child_die = sibling_die (child_die))
13866 process_die (child_die, cu);
13868 case PC_BOUNDS_INVALID:
13871 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13872 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13874 cu->builder->push_context (0, lowpc);
13875 if (die->child != NULL)
13877 child_die = die->child;
13878 while (child_die && child_die->tag)
13880 process_die (child_die, cu);
13881 child_die = sibling_die (child_die);
13884 inherit_abstract_dies (die, cu);
13885 struct context_stack cstk = cu->builder->pop_context ();
13887 if (*cu->builder->get_local_symbols () != NULL
13888 || (*cu->builder->get_local_using_directives ()) != NULL)
13890 struct block *block
13891 = cu->builder->finish_block (0, cstk.old_blocks, NULL,
13892 cstk.start_addr, highpc);
13894 /* Note that recording ranges after traversing children, as we
13895 do here, means that recording a parent's ranges entails
13896 walking across all its children's ranges as they appear in
13897 the address map, which is quadratic behavior.
13899 It would be nicer to record the parent's ranges before
13900 traversing its children, simply overriding whatever you find
13901 there. But since we don't even decide whether to create a
13902 block until after we've traversed its children, that's hard
13904 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13906 *cu->builder->get_local_symbols () = cstk.locals;
13907 cu->builder->set_local_using_directives (cstk.local_using_directives);
13910 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13913 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
13915 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13916 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13917 CORE_ADDR pc, baseaddr;
13918 struct attribute *attr;
13919 struct call_site *call_site, call_site_local;
13922 struct die_info *child_die;
13924 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13926 attr = dwarf2_attr (die, DW_AT_call_return_pc, cu);
13929 /* This was a pre-DWARF-5 GNU extension alias
13930 for DW_AT_call_return_pc. */
13931 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
13935 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13936 "DIE %s [in module %s]"),
13937 sect_offset_str (die->sect_off), objfile_name (objfile));
13940 pc = attr_value_as_address (attr) + baseaddr;
13941 pc = gdbarch_adjust_dwarf2_addr (gdbarch, pc);
13943 if (cu->call_site_htab == NULL)
13944 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
13945 NULL, &objfile->objfile_obstack,
13946 hashtab_obstack_allocate, NULL);
13947 call_site_local.pc = pc;
13948 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
13951 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13952 "DIE %s [in module %s]"),
13953 paddress (gdbarch, pc), sect_offset_str (die->sect_off),
13954 objfile_name (objfile));
13958 /* Count parameters at the caller. */
13961 for (child_die = die->child; child_die && child_die->tag;
13962 child_die = sibling_die (child_die))
13964 if (child_die->tag != DW_TAG_call_site_parameter
13965 && child_die->tag != DW_TAG_GNU_call_site_parameter)
13967 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13968 "DW_TAG_call_site child DIE %s [in module %s]"),
13969 child_die->tag, sect_offset_str (child_die->sect_off),
13970 objfile_name (objfile));
13978 = ((struct call_site *)
13979 obstack_alloc (&objfile->objfile_obstack,
13980 sizeof (*call_site)
13981 + (sizeof (*call_site->parameter) * (nparams - 1))));
13983 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
13984 call_site->pc = pc;
13986 if (dwarf2_flag_true_p (die, DW_AT_call_tail_call, cu)
13987 || dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
13989 struct die_info *func_die;
13991 /* Skip also over DW_TAG_inlined_subroutine. */
13992 for (func_die = die->parent;
13993 func_die && func_die->tag != DW_TAG_subprogram
13994 && func_die->tag != DW_TAG_subroutine_type;
13995 func_die = func_die->parent);
13997 /* DW_AT_call_all_calls is a superset
13998 of DW_AT_call_all_tail_calls. */
14000 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_calls, cu)
14001 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
14002 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_tail_calls, cu)
14003 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
14005 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
14006 not complete. But keep CALL_SITE for look ups via call_site_htab,
14007 both the initial caller containing the real return address PC and
14008 the final callee containing the current PC of a chain of tail
14009 calls do not need to have the tail call list complete. But any
14010 function candidate for a virtual tail call frame searched via
14011 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14012 determined unambiguously. */
14016 struct type *func_type = NULL;
14019 func_type = get_die_type (func_die, cu);
14020 if (func_type != NULL)
14022 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
14024 /* Enlist this call site to the function. */
14025 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
14026 TYPE_TAIL_CALL_LIST (func_type) = call_site;
14029 complaint (_("Cannot find function owning DW_TAG_call_site "
14030 "DIE %s [in module %s]"),
14031 sect_offset_str (die->sect_off), objfile_name (objfile));
14035 attr = dwarf2_attr (die, DW_AT_call_target, cu);
14037 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
14039 attr = dwarf2_attr (die, DW_AT_call_origin, cu);
14042 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
14043 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14045 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
14046 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
14047 /* Keep NULL DWARF_BLOCK. */;
14048 else if (attr_form_is_block (attr))
14050 struct dwarf2_locexpr_baton *dlbaton;
14052 dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
14053 dlbaton->data = DW_BLOCK (attr)->data;
14054 dlbaton->size = DW_BLOCK (attr)->size;
14055 dlbaton->per_cu = cu->per_cu;
14057 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
14059 else if (attr_form_is_ref (attr))
14061 struct dwarf2_cu *target_cu = cu;
14062 struct die_info *target_die;
14064 target_die = follow_die_ref (die, attr, &target_cu);
14065 gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
14066 if (die_is_declaration (target_die, target_cu))
14068 const char *target_physname;
14070 /* Prefer the mangled name; otherwise compute the demangled one. */
14071 target_physname = dw2_linkage_name (target_die, target_cu);
14072 if (target_physname == NULL)
14073 target_physname = dwarf2_physname (NULL, target_die, target_cu);
14074 if (target_physname == NULL)
14075 complaint (_("DW_AT_call_target target DIE has invalid "
14076 "physname, for referencing DIE %s [in module %s]"),
14077 sect_offset_str (die->sect_off), objfile_name (objfile));
14079 SET_FIELD_PHYSNAME (call_site->target, target_physname);
14085 /* DW_AT_entry_pc should be preferred. */
14086 if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
14087 <= PC_BOUNDS_INVALID)
14088 complaint (_("DW_AT_call_target target DIE has invalid "
14089 "low pc, for referencing DIE %s [in module %s]"),
14090 sect_offset_str (die->sect_off), objfile_name (objfile));
14093 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
14094 SET_FIELD_PHYSADDR (call_site->target, lowpc);
14099 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14100 "block nor reference, for DIE %s [in module %s]"),
14101 sect_offset_str (die->sect_off), objfile_name (objfile));
14103 call_site->per_cu = cu->per_cu;
14105 for (child_die = die->child;
14106 child_die && child_die->tag;
14107 child_die = sibling_die (child_die))
14109 struct call_site_parameter *parameter;
14110 struct attribute *loc, *origin;
14112 if (child_die->tag != DW_TAG_call_site_parameter
14113 && child_die->tag != DW_TAG_GNU_call_site_parameter)
14115 /* Already printed the complaint above. */
14119 gdb_assert (call_site->parameter_count < nparams);
14120 parameter = &call_site->parameter[call_site->parameter_count];
14122 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14123 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14124 register is contained in DW_AT_call_value. */
14126 loc = dwarf2_attr (child_die, DW_AT_location, cu);
14127 origin = dwarf2_attr (child_die, DW_AT_call_parameter, cu);
14128 if (origin == NULL)
14130 /* This was a pre-DWARF-5 GNU extension alias
14131 for DW_AT_call_parameter. */
14132 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
14134 if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
14136 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
14138 sect_offset sect_off
14139 = (sect_offset) dwarf2_get_ref_die_offset (origin);
14140 if (!offset_in_cu_p (&cu->header, sect_off))
14142 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14143 binding can be done only inside one CU. Such referenced DIE
14144 therefore cannot be even moved to DW_TAG_partial_unit. */
14145 complaint (_("DW_AT_call_parameter offset is not in CU 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->u.param_cu_off
14152 = (cu_offset) (sect_off - cu->header.sect_off);
14154 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
14156 complaint (_("No DW_FORM_block* DW_AT_location for "
14157 "DW_TAG_call_site child DIE %s [in module %s]"),
14158 sect_offset_str (child_die->sect_off), objfile_name (objfile));
14163 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
14164 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
14165 if (parameter->u.dwarf_reg != -1)
14166 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
14167 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
14168 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
14169 ¶meter->u.fb_offset))
14170 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
14173 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14174 "for DW_FORM_block* DW_AT_location is supported for "
14175 "DW_TAG_call_site child DIE %s "
14177 sect_offset_str (child_die->sect_off),
14178 objfile_name (objfile));
14183 attr = dwarf2_attr (child_die, DW_AT_call_value, cu);
14185 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
14186 if (!attr_form_is_block (attr))
14188 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14189 "DW_TAG_call_site child DIE %s [in module %s]"),
14190 sect_offset_str (child_die->sect_off),
14191 objfile_name (objfile));
14194 parameter->value = DW_BLOCK (attr)->data;
14195 parameter->value_size = DW_BLOCK (attr)->size;
14197 /* Parameters are not pre-cleared by memset above. */
14198 parameter->data_value = NULL;
14199 parameter->data_value_size = 0;
14200 call_site->parameter_count++;
14202 attr = dwarf2_attr (child_die, DW_AT_call_data_value, cu);
14204 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
14207 if (!attr_form_is_block (attr))
14208 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14209 "DW_TAG_call_site child DIE %s [in module %s]"),
14210 sect_offset_str (child_die->sect_off),
14211 objfile_name (objfile));
14214 parameter->data_value = DW_BLOCK (attr)->data;
14215 parameter->data_value_size = DW_BLOCK (attr)->size;
14221 /* Helper function for read_variable. If DIE represents a virtual
14222 table, then return the type of the concrete object that is
14223 associated with the virtual table. Otherwise, return NULL. */
14225 static struct type *
14226 rust_containing_type (struct die_info *die, struct dwarf2_cu *cu)
14228 struct attribute *attr = dwarf2_attr (die, DW_AT_type, cu);
14232 /* Find the type DIE. */
14233 struct die_info *type_die = NULL;
14234 struct dwarf2_cu *type_cu = cu;
14236 if (attr_form_is_ref (attr))
14237 type_die = follow_die_ref (die, attr, &type_cu);
14238 if (type_die == NULL)
14241 if (dwarf2_attr (type_die, DW_AT_containing_type, type_cu) == NULL)
14243 return die_containing_type (type_die, type_cu);
14246 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14249 read_variable (struct die_info *die, struct dwarf2_cu *cu)
14251 struct rust_vtable_symbol *storage = NULL;
14253 if (cu->language == language_rust)
14255 struct type *containing_type = rust_containing_type (die, cu);
14257 if (containing_type != NULL)
14259 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14261 storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
14262 struct rust_vtable_symbol);
14263 initialize_objfile_symbol (storage);
14264 storage->concrete_type = containing_type;
14265 storage->subclass = SYMBOL_RUST_VTABLE;
14269 struct symbol *res = new_symbol (die, NULL, cu, storage);
14270 struct attribute *abstract_origin
14271 = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14272 struct attribute *loc = dwarf2_attr (die, DW_AT_location, cu);
14273 if (res == NULL && loc && abstract_origin)
14275 /* We have a variable without a name, but with a location and an abstract
14276 origin. This may be a concrete instance of an abstract variable
14277 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14279 struct dwarf2_cu *origin_cu = cu;
14280 struct die_info *origin_die
14281 = follow_die_ref (die, abstract_origin, &origin_cu);
14282 dwarf2_per_objfile *dpo = cu->per_cu->dwarf2_per_objfile;
14283 dpo->abstract_to_concrete[origin_die].push_back (die);
14287 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14288 reading .debug_rnglists.
14289 Callback's type should be:
14290 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14291 Return true if the attributes are present and valid, otherwise,
14294 template <typename Callback>
14296 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
14297 Callback &&callback)
14299 struct dwarf2_per_objfile *dwarf2_per_objfile
14300 = cu->per_cu->dwarf2_per_objfile;
14301 struct objfile *objfile = dwarf2_per_objfile->objfile;
14302 bfd *obfd = objfile->obfd;
14303 /* Base address selection entry. */
14306 const gdb_byte *buffer;
14307 CORE_ADDR baseaddr;
14308 bool overflow = false;
14310 found_base = cu->base_known;
14311 base = cu->base_address;
14313 dwarf2_read_section (objfile, &dwarf2_per_objfile->rnglists);
14314 if (offset >= dwarf2_per_objfile->rnglists.size)
14316 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14320 buffer = dwarf2_per_objfile->rnglists.buffer + offset;
14322 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14326 /* Initialize it due to a false compiler warning. */
14327 CORE_ADDR range_beginning = 0, range_end = 0;
14328 const gdb_byte *buf_end = (dwarf2_per_objfile->rnglists.buffer
14329 + dwarf2_per_objfile->rnglists.size);
14330 unsigned int bytes_read;
14332 if (buffer == buf_end)
14337 const auto rlet = static_cast<enum dwarf_range_list_entry>(*buffer++);
14340 case DW_RLE_end_of_list:
14342 case DW_RLE_base_address:
14343 if (buffer + cu->header.addr_size > buf_end)
14348 base = read_address (obfd, buffer, cu, &bytes_read);
14350 buffer += bytes_read;
14352 case DW_RLE_start_length:
14353 if (buffer + cu->header.addr_size > buf_end)
14358 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14359 buffer += bytes_read;
14360 range_end = (range_beginning
14361 + read_unsigned_leb128 (obfd, buffer, &bytes_read));
14362 buffer += bytes_read;
14363 if (buffer > buf_end)
14369 case DW_RLE_offset_pair:
14370 range_beginning = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14371 buffer += bytes_read;
14372 if (buffer > buf_end)
14377 range_end = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14378 buffer += bytes_read;
14379 if (buffer > buf_end)
14385 case DW_RLE_start_end:
14386 if (buffer + 2 * cu->header.addr_size > buf_end)
14391 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14392 buffer += bytes_read;
14393 range_end = read_address (obfd, buffer, cu, &bytes_read);
14394 buffer += bytes_read;
14397 complaint (_("Invalid .debug_rnglists data (no base address)"));
14400 if (rlet == DW_RLE_end_of_list || overflow)
14402 if (rlet == DW_RLE_base_address)
14407 /* We have no valid base address for the ranges
14409 complaint (_("Invalid .debug_rnglists data (no base address)"));
14413 if (range_beginning > range_end)
14415 /* Inverted range entries are invalid. */
14416 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14420 /* Empty range entries have no effect. */
14421 if (range_beginning == range_end)
14424 range_beginning += base;
14427 /* A not-uncommon case of bad debug info.
14428 Don't pollute the addrmap with bad data. */
14429 if (range_beginning + baseaddr == 0
14430 && !dwarf2_per_objfile->has_section_at_zero)
14432 complaint (_(".debug_rnglists entry has start address of zero"
14433 " [in module %s]"), objfile_name (objfile));
14437 callback (range_beginning, range_end);
14442 complaint (_("Offset %d is not terminated "
14443 "for DW_AT_ranges attribute"),
14451 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14452 Callback's type should be:
14453 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14454 Return 1 if the attributes are present and valid, otherwise, return 0. */
14456 template <typename Callback>
14458 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
14459 Callback &&callback)
14461 struct dwarf2_per_objfile *dwarf2_per_objfile
14462 = cu->per_cu->dwarf2_per_objfile;
14463 struct objfile *objfile = dwarf2_per_objfile->objfile;
14464 struct comp_unit_head *cu_header = &cu->header;
14465 bfd *obfd = objfile->obfd;
14466 unsigned int addr_size = cu_header->addr_size;
14467 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
14468 /* Base address selection entry. */
14471 unsigned int dummy;
14472 const gdb_byte *buffer;
14473 CORE_ADDR baseaddr;
14475 if (cu_header->version >= 5)
14476 return dwarf2_rnglists_process (offset, cu, callback);
14478 found_base = cu->base_known;
14479 base = cu->base_address;
14481 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
14482 if (offset >= dwarf2_per_objfile->ranges.size)
14484 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14488 buffer = dwarf2_per_objfile->ranges.buffer + offset;
14490 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14494 CORE_ADDR range_beginning, range_end;
14496 range_beginning = read_address (obfd, buffer, cu, &dummy);
14497 buffer += addr_size;
14498 range_end = read_address (obfd, buffer, cu, &dummy);
14499 buffer += addr_size;
14500 offset += 2 * addr_size;
14502 /* An end of list marker is a pair of zero addresses. */
14503 if (range_beginning == 0 && range_end == 0)
14504 /* Found the end of list entry. */
14507 /* Each base address selection entry is a pair of 2 values.
14508 The first is the largest possible address, the second is
14509 the base address. Check for a base address here. */
14510 if ((range_beginning & mask) == mask)
14512 /* If we found the largest possible address, then we already
14513 have the base address in range_end. */
14521 /* We have no valid base address for the ranges
14523 complaint (_("Invalid .debug_ranges data (no base address)"));
14527 if (range_beginning > range_end)
14529 /* Inverted range entries are invalid. */
14530 complaint (_("Invalid .debug_ranges data (inverted range)"));
14534 /* Empty range entries have no effect. */
14535 if (range_beginning == range_end)
14538 range_beginning += base;
14541 /* A not-uncommon case of bad debug info.
14542 Don't pollute the addrmap with bad data. */
14543 if (range_beginning + baseaddr == 0
14544 && !dwarf2_per_objfile->has_section_at_zero)
14546 complaint (_(".debug_ranges entry has start address of zero"
14547 " [in module %s]"), objfile_name (objfile));
14551 callback (range_beginning, range_end);
14557 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14558 Return 1 if the attributes are present and valid, otherwise, return 0.
14559 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14562 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
14563 CORE_ADDR *high_return, struct dwarf2_cu *cu,
14564 struct partial_symtab *ranges_pst)
14566 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14567 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14568 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
14569 SECT_OFF_TEXT (objfile));
14572 CORE_ADDR high = 0;
14575 retval = dwarf2_ranges_process (offset, cu,
14576 [&] (CORE_ADDR range_beginning, CORE_ADDR range_end)
14578 if (ranges_pst != NULL)
14583 lowpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14584 range_beginning + baseaddr)
14586 highpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14587 range_end + baseaddr)
14589 addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
14590 lowpc, highpc - 1, ranges_pst);
14593 /* FIXME: This is recording everything as a low-high
14594 segment of consecutive addresses. We should have a
14595 data structure for discontiguous block ranges
14599 low = range_beginning;
14605 if (range_beginning < low)
14606 low = range_beginning;
14607 if (range_end > high)
14615 /* If the first entry is an end-of-list marker, the range
14616 describes an empty scope, i.e. no instructions. */
14622 *high_return = high;
14626 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14627 definition for the return value. *LOWPC and *HIGHPC are set iff
14628 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14630 static enum pc_bounds_kind
14631 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
14632 CORE_ADDR *highpc, struct dwarf2_cu *cu,
14633 struct partial_symtab *pst)
14635 struct dwarf2_per_objfile *dwarf2_per_objfile
14636 = cu->per_cu->dwarf2_per_objfile;
14637 struct attribute *attr;
14638 struct attribute *attr_high;
14640 CORE_ADDR high = 0;
14641 enum pc_bounds_kind ret;
14643 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14646 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14649 low = attr_value_as_address (attr);
14650 high = attr_value_as_address (attr_high);
14651 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14655 /* Found high w/o low attribute. */
14656 return PC_BOUNDS_INVALID;
14658 /* Found consecutive range of addresses. */
14659 ret = PC_BOUNDS_HIGH_LOW;
14663 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14666 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14667 We take advantage of the fact that DW_AT_ranges does not appear
14668 in DW_TAG_compile_unit of DWO files. */
14669 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14670 unsigned int ranges_offset = (DW_UNSND (attr)
14671 + (need_ranges_base
14675 /* Value of the DW_AT_ranges attribute is the offset in the
14676 .debug_ranges section. */
14677 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
14678 return PC_BOUNDS_INVALID;
14679 /* Found discontinuous range of addresses. */
14680 ret = PC_BOUNDS_RANGES;
14683 return PC_BOUNDS_NOT_PRESENT;
14686 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14688 return PC_BOUNDS_INVALID;
14690 /* When using the GNU linker, .gnu.linkonce. sections are used to
14691 eliminate duplicate copies of functions and vtables and such.
14692 The linker will arbitrarily choose one and discard the others.
14693 The AT_*_pc values for such functions refer to local labels in
14694 these sections. If the section from that file was discarded, the
14695 labels are not in the output, so the relocs get a value of 0.
14696 If this is a discarded function, mark the pc bounds as invalid,
14697 so that GDB will ignore it. */
14698 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
14699 return PC_BOUNDS_INVALID;
14707 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14708 its low and high PC addresses. Do nothing if these addresses could not
14709 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14710 and HIGHPC to the high address if greater than HIGHPC. */
14713 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
14714 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14715 struct dwarf2_cu *cu)
14717 CORE_ADDR low, high;
14718 struct die_info *child = die->child;
14720 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL) >= PC_BOUNDS_RANGES)
14722 *lowpc = std::min (*lowpc, low);
14723 *highpc = std::max (*highpc, high);
14726 /* If the language does not allow nested subprograms (either inside
14727 subprograms or lexical blocks), we're done. */
14728 if (cu->language != language_ada)
14731 /* Check all the children of the given DIE. If it contains nested
14732 subprograms, then check their pc bounds. Likewise, we need to
14733 check lexical blocks as well, as they may also contain subprogram
14735 while (child && child->tag)
14737 if (child->tag == DW_TAG_subprogram
14738 || child->tag == DW_TAG_lexical_block)
14739 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
14740 child = sibling_die (child);
14744 /* Get the low and high pc's represented by the scope DIE, and store
14745 them in *LOWPC and *HIGHPC. If the correct values can't be
14746 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14749 get_scope_pc_bounds (struct die_info *die,
14750 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14751 struct dwarf2_cu *cu)
14753 CORE_ADDR best_low = (CORE_ADDR) -1;
14754 CORE_ADDR best_high = (CORE_ADDR) 0;
14755 CORE_ADDR current_low, current_high;
14757 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL)
14758 >= PC_BOUNDS_RANGES)
14760 best_low = current_low;
14761 best_high = current_high;
14765 struct die_info *child = die->child;
14767 while (child && child->tag)
14769 switch (child->tag) {
14770 case DW_TAG_subprogram:
14771 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
14773 case DW_TAG_namespace:
14774 case DW_TAG_module:
14775 /* FIXME: carlton/2004-01-16: Should we do this for
14776 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14777 that current GCC's always emit the DIEs corresponding
14778 to definitions of methods of classes as children of a
14779 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14780 the DIEs giving the declarations, which could be
14781 anywhere). But I don't see any reason why the
14782 standards says that they have to be there. */
14783 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
14785 if (current_low != ((CORE_ADDR) -1))
14787 best_low = std::min (best_low, current_low);
14788 best_high = std::max (best_high, current_high);
14796 child = sibling_die (child);
14801 *highpc = best_high;
14804 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14808 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
14809 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
14811 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14812 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14813 struct attribute *attr;
14814 struct attribute *attr_high;
14816 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14819 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14822 CORE_ADDR low = attr_value_as_address (attr);
14823 CORE_ADDR high = attr_value_as_address (attr_high);
14825 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14828 low = gdbarch_adjust_dwarf2_addr (gdbarch, low + baseaddr);
14829 high = gdbarch_adjust_dwarf2_addr (gdbarch, high + baseaddr);
14830 cu->builder->record_block_range (block, low, high - 1);
14834 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14837 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14838 We take advantage of the fact that DW_AT_ranges does not appear
14839 in DW_TAG_compile_unit of DWO files. */
14840 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14842 /* The value of the DW_AT_ranges attribute is the offset of the
14843 address range list in the .debug_ranges section. */
14844 unsigned long offset = (DW_UNSND (attr)
14845 + (need_ranges_base ? cu->ranges_base : 0));
14847 std::vector<blockrange> blockvec;
14848 dwarf2_ranges_process (offset, cu,
14849 [&] (CORE_ADDR start, CORE_ADDR end)
14853 start = gdbarch_adjust_dwarf2_addr (gdbarch, start);
14854 end = gdbarch_adjust_dwarf2_addr (gdbarch, end);
14855 cu->builder->record_block_range (block, start, end - 1);
14856 blockvec.emplace_back (start, end);
14859 BLOCK_RANGES(block) = make_blockranges (objfile, blockvec);
14863 /* Check whether the producer field indicates either of GCC < 4.6, or the
14864 Intel C/C++ compiler, and cache the result in CU. */
14867 check_producer (struct dwarf2_cu *cu)
14871 if (cu->producer == NULL)
14873 /* For unknown compilers expect their behavior is DWARF version
14876 GCC started to support .debug_types sections by -gdwarf-4 since
14877 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14878 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14879 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14880 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14882 else if (producer_is_gcc (cu->producer, &major, &minor))
14884 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
14885 cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
14887 else if (producer_is_icc (cu->producer, &major, &minor))
14889 cu->producer_is_icc = true;
14890 cu->producer_is_icc_lt_14 = major < 14;
14892 else if (startswith (cu->producer, "CodeWarrior S12/L-ISA"))
14893 cu->producer_is_codewarrior = true;
14896 /* For other non-GCC compilers, expect their behavior is DWARF version
14900 cu->checked_producer = true;
14903 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14904 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14905 during 4.6.0 experimental. */
14908 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
14910 if (!cu->checked_producer)
14911 check_producer (cu);
14913 return cu->producer_is_gxx_lt_4_6;
14917 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14918 with incorrect is_stmt attributes. */
14921 producer_is_codewarrior (struct dwarf2_cu *cu)
14923 if (!cu->checked_producer)
14924 check_producer (cu);
14926 return cu->producer_is_codewarrior;
14929 /* Return the default accessibility type if it is not overriden by
14930 DW_AT_accessibility. */
14932 static enum dwarf_access_attribute
14933 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
14935 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
14937 /* The default DWARF 2 accessibility for members is public, the default
14938 accessibility for inheritance is private. */
14940 if (die->tag != DW_TAG_inheritance)
14941 return DW_ACCESS_public;
14943 return DW_ACCESS_private;
14947 /* DWARF 3+ defines the default accessibility a different way. The same
14948 rules apply now for DW_TAG_inheritance as for the members and it only
14949 depends on the container kind. */
14951 if (die->parent->tag == DW_TAG_class_type)
14952 return DW_ACCESS_private;
14954 return DW_ACCESS_public;
14958 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14959 offset. If the attribute was not found return 0, otherwise return
14960 1. If it was found but could not properly be handled, set *OFFSET
14964 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
14967 struct attribute *attr;
14969 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
14974 /* Note that we do not check for a section offset first here.
14975 This is because DW_AT_data_member_location is new in DWARF 4,
14976 so if we see it, we can assume that a constant form is really
14977 a constant and not a section offset. */
14978 if (attr_form_is_constant (attr))
14979 *offset = dwarf2_get_attr_constant_value (attr, 0);
14980 else if (attr_form_is_section_offset (attr))
14981 dwarf2_complex_location_expr_complaint ();
14982 else if (attr_form_is_block (attr))
14983 *offset = decode_locdesc (DW_BLOCK (attr), cu);
14985 dwarf2_complex_location_expr_complaint ();
14993 /* Add an aggregate field to the field list. */
14996 dwarf2_add_field (struct field_info *fip, struct die_info *die,
14997 struct dwarf2_cu *cu)
14999 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15000 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15001 struct nextfield *new_field;
15002 struct attribute *attr;
15004 const char *fieldname = "";
15006 if (die->tag == DW_TAG_inheritance)
15008 fip->baseclasses.emplace_back ();
15009 new_field = &fip->baseclasses.back ();
15013 fip->fields.emplace_back ();
15014 new_field = &fip->fields.back ();
15019 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15021 new_field->accessibility = DW_UNSND (attr);
15023 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
15024 if (new_field->accessibility != DW_ACCESS_public)
15025 fip->non_public_fields = 1;
15027 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15029 new_field->virtuality = DW_UNSND (attr);
15031 new_field->virtuality = DW_VIRTUALITY_none;
15033 fp = &new_field->field;
15035 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
15039 /* Data member other than a C++ static data member. */
15041 /* Get type of field. */
15042 fp->type = die_type (die, cu);
15044 SET_FIELD_BITPOS (*fp, 0);
15046 /* Get bit size of field (zero if none). */
15047 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
15050 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
15054 FIELD_BITSIZE (*fp) = 0;
15057 /* Get bit offset of field. */
15058 if (handle_data_member_location (die, cu, &offset))
15059 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15060 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
15063 if (gdbarch_bits_big_endian (gdbarch))
15065 /* For big endian bits, the DW_AT_bit_offset gives the
15066 additional bit offset from the MSB of the containing
15067 anonymous object to the MSB of the field. We don't
15068 have to do anything special since we don't need to
15069 know the size of the anonymous object. */
15070 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
15074 /* For little endian bits, compute the bit offset to the
15075 MSB of the anonymous object, subtract off the number of
15076 bits from the MSB of the field to the MSB of the
15077 object, and then subtract off the number of bits of
15078 the field itself. The result is the bit offset of
15079 the LSB of the field. */
15080 int anonymous_size;
15081 int bit_offset = DW_UNSND (attr);
15083 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15086 /* The size of the anonymous object containing
15087 the bit field is explicit, so use the
15088 indicated size (in bytes). */
15089 anonymous_size = DW_UNSND (attr);
15093 /* The size of the anonymous object containing
15094 the bit field must be inferred from the type
15095 attribute of the data member containing the
15097 anonymous_size = TYPE_LENGTH (fp->type);
15099 SET_FIELD_BITPOS (*fp,
15100 (FIELD_BITPOS (*fp)
15101 + anonymous_size * bits_per_byte
15102 - bit_offset - FIELD_BITSIZE (*fp)));
15105 attr = dwarf2_attr (die, DW_AT_data_bit_offset, cu);
15107 SET_FIELD_BITPOS (*fp, (FIELD_BITPOS (*fp)
15108 + dwarf2_get_attr_constant_value (attr, 0)));
15110 /* Get name of field. */
15111 fieldname = dwarf2_name (die, cu);
15112 if (fieldname == NULL)
15115 /* The name is already allocated along with this objfile, so we don't
15116 need to duplicate it for the type. */
15117 fp->name = fieldname;
15119 /* Change accessibility for artificial fields (e.g. virtual table
15120 pointer or virtual base class pointer) to private. */
15121 if (dwarf2_attr (die, DW_AT_artificial, cu))
15123 FIELD_ARTIFICIAL (*fp) = 1;
15124 new_field->accessibility = DW_ACCESS_private;
15125 fip->non_public_fields = 1;
15128 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
15130 /* C++ static member. */
15132 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15133 is a declaration, but all versions of G++ as of this writing
15134 (so through at least 3.2.1) incorrectly generate
15135 DW_TAG_variable tags. */
15137 const char *physname;
15139 /* Get name of field. */
15140 fieldname = dwarf2_name (die, cu);
15141 if (fieldname == NULL)
15144 attr = dwarf2_attr (die, DW_AT_const_value, cu);
15146 /* Only create a symbol if this is an external value.
15147 new_symbol checks this and puts the value in the global symbol
15148 table, which we want. If it is not external, new_symbol
15149 will try to put the value in cu->list_in_scope which is wrong. */
15150 && dwarf2_flag_true_p (die, DW_AT_external, cu))
15152 /* A static const member, not much different than an enum as far as
15153 we're concerned, except that we can support more types. */
15154 new_symbol (die, NULL, cu);
15157 /* Get physical name. */
15158 physname = dwarf2_physname (fieldname, die, cu);
15160 /* The name is already allocated along with this objfile, so we don't
15161 need to duplicate it for the type. */
15162 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
15163 FIELD_TYPE (*fp) = die_type (die, cu);
15164 FIELD_NAME (*fp) = fieldname;
15166 else if (die->tag == DW_TAG_inheritance)
15170 /* C++ base class field. */
15171 if (handle_data_member_location (die, cu, &offset))
15172 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15173 FIELD_BITSIZE (*fp) = 0;
15174 FIELD_TYPE (*fp) = die_type (die, cu);
15175 FIELD_NAME (*fp) = TYPE_NAME (fp->type);
15177 else if (die->tag == DW_TAG_variant_part)
15179 /* process_structure_scope will treat this DIE as a union. */
15180 process_structure_scope (die, cu);
15182 /* The variant part is relative to the start of the enclosing
15184 SET_FIELD_BITPOS (*fp, 0);
15185 fp->type = get_die_type (die, cu);
15186 fp->artificial = 1;
15187 fp->name = "<<variant>>";
15189 /* Normally a DW_TAG_variant_part won't have a size, but our
15190 representation requires one, so set it to the maximum of the
15192 if (TYPE_LENGTH (fp->type) == 0)
15195 for (int i = 0; i < TYPE_NFIELDS (fp->type); ++i)
15196 if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i)) > max)
15197 max = TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i));
15198 TYPE_LENGTH (fp->type) = max;
15202 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15205 /* Can the type given by DIE define another type? */
15208 type_can_define_types (const struct die_info *die)
15212 case DW_TAG_typedef:
15213 case DW_TAG_class_type:
15214 case DW_TAG_structure_type:
15215 case DW_TAG_union_type:
15216 case DW_TAG_enumeration_type:
15224 /* Add a type definition defined in the scope of the FIP's class. */
15227 dwarf2_add_type_defn (struct field_info *fip, struct die_info *die,
15228 struct dwarf2_cu *cu)
15230 struct decl_field fp;
15231 memset (&fp, 0, sizeof (fp));
15233 gdb_assert (type_can_define_types (die));
15235 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15236 fp.name = dwarf2_name (die, cu);
15237 fp.type = read_type_die (die, cu);
15239 /* Save accessibility. */
15240 enum dwarf_access_attribute accessibility;
15241 struct attribute *attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15243 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15245 accessibility = dwarf2_default_access_attribute (die, cu);
15246 switch (accessibility)
15248 case DW_ACCESS_public:
15249 /* The assumed value if neither private nor protected. */
15251 case DW_ACCESS_private:
15254 case DW_ACCESS_protected:
15255 fp.is_protected = 1;
15258 complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility);
15261 if (die->tag == DW_TAG_typedef)
15262 fip->typedef_field_list.push_back (fp);
15264 fip->nested_types_list.push_back (fp);
15267 /* Create the vector of fields, and attach it to the type. */
15270 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
15271 struct dwarf2_cu *cu)
15273 int nfields = fip->nfields;
15275 /* Record the field count, allocate space for the array of fields,
15276 and create blank accessibility bitfields if necessary. */
15277 TYPE_NFIELDS (type) = nfields;
15278 TYPE_FIELDS (type) = (struct field *)
15279 TYPE_ZALLOC (type, sizeof (struct field) * nfields);
15281 if (fip->non_public_fields && cu->language != language_ada)
15283 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15285 TYPE_FIELD_PRIVATE_BITS (type) =
15286 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15287 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
15289 TYPE_FIELD_PROTECTED_BITS (type) =
15290 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15291 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
15293 TYPE_FIELD_IGNORE_BITS (type) =
15294 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15295 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
15298 /* If the type has baseclasses, allocate and clear a bit vector for
15299 TYPE_FIELD_VIRTUAL_BITS. */
15300 if (!fip->baseclasses.empty () && cu->language != language_ada)
15302 int num_bytes = B_BYTES (fip->baseclasses.size ());
15303 unsigned char *pointer;
15305 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15306 pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes);
15307 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
15308 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->baseclasses.size ());
15309 TYPE_N_BASECLASSES (type) = fip->baseclasses.size ();
15312 if (TYPE_FLAG_DISCRIMINATED_UNION (type))
15314 struct discriminant_info *di = alloc_discriminant_info (type, -1, -1);
15316 for (int index = 0; index < nfields; ++index)
15318 struct nextfield &field = fip->fields[index];
15320 if (field.variant.is_discriminant)
15321 di->discriminant_index = index;
15322 else if (field.variant.default_branch)
15323 di->default_index = index;
15325 di->discriminants[index] = field.variant.discriminant_value;
15329 /* Copy the saved-up fields into the field vector. */
15330 for (int i = 0; i < nfields; ++i)
15332 struct nextfield &field
15333 = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i]
15334 : fip->fields[i - fip->baseclasses.size ()]);
15336 TYPE_FIELD (type, i) = field.field;
15337 switch (field.accessibility)
15339 case DW_ACCESS_private:
15340 if (cu->language != language_ada)
15341 SET_TYPE_FIELD_PRIVATE (type, i);
15344 case DW_ACCESS_protected:
15345 if (cu->language != language_ada)
15346 SET_TYPE_FIELD_PROTECTED (type, i);
15349 case DW_ACCESS_public:
15353 /* Unknown accessibility. Complain and treat it as public. */
15355 complaint (_("unsupported accessibility %d"),
15356 field.accessibility);
15360 if (i < fip->baseclasses.size ())
15362 switch (field.virtuality)
15364 case DW_VIRTUALITY_virtual:
15365 case DW_VIRTUALITY_pure_virtual:
15366 if (cu->language == language_ada)
15367 error (_("unexpected virtuality in component of Ada type"));
15368 SET_TYPE_FIELD_VIRTUAL (type, i);
15375 /* Return true if this member function is a constructor, false
15379 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
15381 const char *fieldname;
15382 const char *type_name;
15385 if (die->parent == NULL)
15388 if (die->parent->tag != DW_TAG_structure_type
15389 && die->parent->tag != DW_TAG_union_type
15390 && die->parent->tag != DW_TAG_class_type)
15393 fieldname = dwarf2_name (die, cu);
15394 type_name = dwarf2_name (die->parent, cu);
15395 if (fieldname == NULL || type_name == NULL)
15398 len = strlen (fieldname);
15399 return (strncmp (fieldname, type_name, len) == 0
15400 && (type_name[len] == '\0' || type_name[len] == '<'));
15403 /* Add a member function to the proper fieldlist. */
15406 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
15407 struct type *type, struct dwarf2_cu *cu)
15409 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15410 struct attribute *attr;
15412 struct fnfieldlist *flp = nullptr;
15413 struct fn_field *fnp;
15414 const char *fieldname;
15415 struct type *this_type;
15416 enum dwarf_access_attribute accessibility;
15418 if (cu->language == language_ada)
15419 error (_("unexpected member function in Ada type"));
15421 /* Get name of member function. */
15422 fieldname = dwarf2_name (die, cu);
15423 if (fieldname == NULL)
15426 /* Look up member function name in fieldlist. */
15427 for (i = 0; i < fip->fnfieldlists.size (); i++)
15429 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
15431 flp = &fip->fnfieldlists[i];
15436 /* Create a new fnfieldlist if necessary. */
15437 if (flp == nullptr)
15439 fip->fnfieldlists.emplace_back ();
15440 flp = &fip->fnfieldlists.back ();
15441 flp->name = fieldname;
15442 i = fip->fnfieldlists.size () - 1;
15445 /* Create a new member function field and add it to the vector of
15447 flp->fnfields.emplace_back ();
15448 fnp = &flp->fnfields.back ();
15450 /* Delay processing of the physname until later. */
15451 if (cu->language == language_cplus)
15452 add_to_method_list (type, i, flp->fnfields.size () - 1, fieldname,
15456 const char *physname = dwarf2_physname (fieldname, die, cu);
15457 fnp->physname = physname ? physname : "";
15460 fnp->type = alloc_type (objfile);
15461 this_type = read_type_die (die, cu);
15462 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
15464 int nparams = TYPE_NFIELDS (this_type);
15466 /* TYPE is the domain of this method, and THIS_TYPE is the type
15467 of the method itself (TYPE_CODE_METHOD). */
15468 smash_to_method_type (fnp->type, type,
15469 TYPE_TARGET_TYPE (this_type),
15470 TYPE_FIELDS (this_type),
15471 TYPE_NFIELDS (this_type),
15472 TYPE_VARARGS (this_type));
15474 /* Handle static member functions.
15475 Dwarf2 has no clean way to discern C++ static and non-static
15476 member functions. G++ helps GDB by marking the first
15477 parameter for non-static member functions (which is the this
15478 pointer) as artificial. We obtain this information from
15479 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15480 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
15481 fnp->voffset = VOFFSET_STATIC;
15484 complaint (_("member function type missing for '%s'"),
15485 dwarf2_full_name (fieldname, die, cu));
15487 /* Get fcontext from DW_AT_containing_type if present. */
15488 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
15489 fnp->fcontext = die_containing_type (die, cu);
15491 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15492 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15494 /* Get accessibility. */
15495 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15497 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15499 accessibility = dwarf2_default_access_attribute (die, cu);
15500 switch (accessibility)
15502 case DW_ACCESS_private:
15503 fnp->is_private = 1;
15505 case DW_ACCESS_protected:
15506 fnp->is_protected = 1;
15510 /* Check for artificial methods. */
15511 attr = dwarf2_attr (die, DW_AT_artificial, cu);
15512 if (attr && DW_UNSND (attr) != 0)
15513 fnp->is_artificial = 1;
15515 fnp->is_constructor = dwarf2_is_constructor (die, cu);
15517 /* Get index in virtual function table if it is a virtual member
15518 function. For older versions of GCC, this is an offset in the
15519 appropriate virtual table, as specified by DW_AT_containing_type.
15520 For everyone else, it is an expression to be evaluated relative
15521 to the object address. */
15523 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
15526 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
15528 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
15530 /* Old-style GCC. */
15531 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
15533 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
15534 || (DW_BLOCK (attr)->size > 1
15535 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
15536 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
15538 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
15539 if ((fnp->voffset % cu->header.addr_size) != 0)
15540 dwarf2_complex_location_expr_complaint ();
15542 fnp->voffset /= cu->header.addr_size;
15546 dwarf2_complex_location_expr_complaint ();
15548 if (!fnp->fcontext)
15550 /* If there is no `this' field and no DW_AT_containing_type,
15551 we cannot actually find a base class context for the
15553 if (TYPE_NFIELDS (this_type) == 0
15554 || !TYPE_FIELD_ARTIFICIAL (this_type, 0))
15556 complaint (_("cannot determine context for virtual member "
15557 "function \"%s\" (offset %s)"),
15558 fieldname, sect_offset_str (die->sect_off));
15563 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
15567 else if (attr_form_is_section_offset (attr))
15569 dwarf2_complex_location_expr_complaint ();
15573 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15579 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15580 if (attr && DW_UNSND (attr))
15582 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15583 complaint (_("Member function \"%s\" (offset %s) is virtual "
15584 "but the vtable offset is not specified"),
15585 fieldname, sect_offset_str (die->sect_off));
15586 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15587 TYPE_CPLUS_DYNAMIC (type) = 1;
15592 /* Create the vector of member function fields, and attach it to the type. */
15595 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
15596 struct dwarf2_cu *cu)
15598 if (cu->language == language_ada)
15599 error (_("unexpected member functions in Ada type"));
15601 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15602 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
15604 sizeof (struct fn_fieldlist) * fip->fnfieldlists.size ());
15606 for (int i = 0; i < fip->fnfieldlists.size (); i++)
15608 struct fnfieldlist &nf = fip->fnfieldlists[i];
15609 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
15611 TYPE_FN_FIELDLIST_NAME (type, i) = nf.name;
15612 TYPE_FN_FIELDLIST_LENGTH (type, i) = nf.fnfields.size ();
15613 fn_flp->fn_fields = (struct fn_field *)
15614 TYPE_ALLOC (type, sizeof (struct fn_field) * nf.fnfields.size ());
15616 for (int k = 0; k < nf.fnfields.size (); ++k)
15617 fn_flp->fn_fields[k] = nf.fnfields[k];
15620 TYPE_NFN_FIELDS (type) = fip->fnfieldlists.size ();
15623 /* Returns non-zero if NAME is the name of a vtable member in CU's
15624 language, zero otherwise. */
15626 is_vtable_name (const char *name, struct dwarf2_cu *cu)
15628 static const char vptr[] = "_vptr";
15630 /* Look for the C++ form of the vtable. */
15631 if (startswith (name, vptr) && is_cplus_marker (name[sizeof (vptr) - 1]))
15637 /* GCC outputs unnamed structures that are really pointers to member
15638 functions, with the ABI-specified layout. If TYPE describes
15639 such a structure, smash it into a member function type.
15641 GCC shouldn't do this; it should just output pointer to member DIEs.
15642 This is GCC PR debug/28767. */
15645 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
15647 struct type *pfn_type, *self_type, *new_type;
15649 /* Check for a structure with no name and two children. */
15650 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
15653 /* Check for __pfn and __delta members. */
15654 if (TYPE_FIELD_NAME (type, 0) == NULL
15655 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
15656 || TYPE_FIELD_NAME (type, 1) == NULL
15657 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
15660 /* Find the type of the method. */
15661 pfn_type = TYPE_FIELD_TYPE (type, 0);
15662 if (pfn_type == NULL
15663 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
15664 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
15667 /* Look for the "this" argument. */
15668 pfn_type = TYPE_TARGET_TYPE (pfn_type);
15669 if (TYPE_NFIELDS (pfn_type) == 0
15670 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15671 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
15674 self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
15675 new_type = alloc_type (objfile);
15676 smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
15677 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
15678 TYPE_VARARGS (pfn_type));
15679 smash_to_methodptr_type (type, new_type);
15682 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15683 appropriate error checking and issuing complaints if there is a
15687 get_alignment (struct dwarf2_cu *cu, struct die_info *die)
15689 struct attribute *attr = dwarf2_attr (die, DW_AT_alignment, cu);
15691 if (attr == nullptr)
15694 if (!attr_form_is_constant (attr))
15696 complaint (_("DW_AT_alignment must have constant form"
15697 " - DIE at %s [in module %s]"),
15698 sect_offset_str (die->sect_off),
15699 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15704 if (attr->form == DW_FORM_sdata)
15706 LONGEST val = DW_SND (attr);
15709 complaint (_("DW_AT_alignment value must not be negative"
15710 " - DIE at %s [in module %s]"),
15711 sect_offset_str (die->sect_off),
15712 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15718 align = DW_UNSND (attr);
15722 complaint (_("DW_AT_alignment value must not be zero"
15723 " - DIE at %s [in module %s]"),
15724 sect_offset_str (die->sect_off),
15725 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15728 if ((align & (align - 1)) != 0)
15730 complaint (_("DW_AT_alignment value must be a power of 2"
15731 " - DIE at %s [in module %s]"),
15732 sect_offset_str (die->sect_off),
15733 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15740 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15741 the alignment for TYPE. */
15744 maybe_set_alignment (struct dwarf2_cu *cu, struct die_info *die,
15747 if (!set_type_align (type, get_alignment (cu, die)))
15748 complaint (_("DW_AT_alignment value too large"
15749 " - DIE at %s [in module %s]"),
15750 sect_offset_str (die->sect_off),
15751 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15754 /* Called when we find the DIE that starts a structure or union scope
15755 (definition) to create a type for the structure or union. Fill in
15756 the type's name and general properties; the members will not be
15757 processed until process_structure_scope. A symbol table entry for
15758 the type will also not be done until process_structure_scope (assuming
15759 the type has a name).
15761 NOTE: we need to call these functions regardless of whether or not the
15762 DIE has a DW_AT_name attribute, since it might be an anonymous
15763 structure or union. This gets the type entered into our set of
15764 user defined types. */
15766 static struct type *
15767 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
15769 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15771 struct attribute *attr;
15774 /* If the definition of this type lives in .debug_types, read that type.
15775 Don't follow DW_AT_specification though, that will take us back up
15776 the chain and we want to go down. */
15777 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
15780 type = get_DW_AT_signature_type (die, attr, cu);
15782 /* The type's CU may not be the same as CU.
15783 Ensure TYPE is recorded with CU in die_type_hash. */
15784 return set_die_type (die, type, cu);
15787 type = alloc_type (objfile);
15788 INIT_CPLUS_SPECIFIC (type);
15790 name = dwarf2_name (die, cu);
15793 if (cu->language == language_cplus
15794 || cu->language == language_d
15795 || cu->language == language_rust)
15797 const char *full_name = dwarf2_full_name (name, die, cu);
15799 /* dwarf2_full_name might have already finished building the DIE's
15800 type. If so, there is no need to continue. */
15801 if (get_die_type (die, cu) != NULL)
15802 return get_die_type (die, cu);
15804 TYPE_NAME (type) = full_name;
15808 /* The name is already allocated along with this objfile, so
15809 we don't need to duplicate it for the type. */
15810 TYPE_NAME (type) = name;
15814 if (die->tag == DW_TAG_structure_type)
15816 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15818 else if (die->tag == DW_TAG_union_type)
15820 TYPE_CODE (type) = TYPE_CODE_UNION;
15822 else if (die->tag == DW_TAG_variant_part)
15824 TYPE_CODE (type) = TYPE_CODE_UNION;
15825 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
15829 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15832 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
15833 TYPE_DECLARED_CLASS (type) = 1;
15835 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15838 if (attr_form_is_constant (attr))
15839 TYPE_LENGTH (type) = DW_UNSND (attr);
15842 /* For the moment, dynamic type sizes are not supported
15843 by GDB's struct type. The actual size is determined
15844 on-demand when resolving the type of a given object,
15845 so set the type's length to zero for now. Otherwise,
15846 we record an expression as the length, and that expression
15847 could lead to a very large value, which could eventually
15848 lead to us trying to allocate that much memory when creating
15849 a value of that type. */
15850 TYPE_LENGTH (type) = 0;
15855 TYPE_LENGTH (type) = 0;
15858 maybe_set_alignment (cu, die, type);
15860 if (producer_is_icc_lt_14 (cu) && (TYPE_LENGTH (type) == 0))
15862 /* ICC<14 does not output the required DW_AT_declaration on
15863 incomplete types, but gives them a size of zero. */
15864 TYPE_STUB (type) = 1;
15867 TYPE_STUB_SUPPORTED (type) = 1;
15869 if (die_is_declaration (die, cu))
15870 TYPE_STUB (type) = 1;
15871 else if (attr == NULL && die->child == NULL
15872 && producer_is_realview (cu->producer))
15873 /* RealView does not output the required DW_AT_declaration
15874 on incomplete types. */
15875 TYPE_STUB (type) = 1;
15877 /* We need to add the type field to the die immediately so we don't
15878 infinitely recurse when dealing with pointers to the structure
15879 type within the structure itself. */
15880 set_die_type (die, type, cu);
15882 /* set_die_type should be already done. */
15883 set_descriptive_type (type, die, cu);
15888 /* A helper for process_structure_scope that handles a single member
15892 handle_struct_member_die (struct die_info *child_die, struct type *type,
15893 struct field_info *fi,
15894 std::vector<struct symbol *> *template_args,
15895 struct dwarf2_cu *cu)
15897 if (child_die->tag == DW_TAG_member
15898 || child_die->tag == DW_TAG_variable
15899 || child_die->tag == DW_TAG_variant_part)
15901 /* NOTE: carlton/2002-11-05: A C++ static data member
15902 should be a DW_TAG_member that is a declaration, but
15903 all versions of G++ as of this writing (so through at
15904 least 3.2.1) incorrectly generate DW_TAG_variable
15905 tags for them instead. */
15906 dwarf2_add_field (fi, child_die, cu);
15908 else if (child_die->tag == DW_TAG_subprogram)
15910 /* Rust doesn't have member functions in the C++ sense.
15911 However, it does emit ordinary functions as children
15912 of a struct DIE. */
15913 if (cu->language == language_rust)
15914 read_func_scope (child_die, cu);
15917 /* C++ member function. */
15918 dwarf2_add_member_fn (fi, child_die, type, cu);
15921 else if (child_die->tag == DW_TAG_inheritance)
15923 /* C++ base class field. */
15924 dwarf2_add_field (fi, child_die, cu);
15926 else if (type_can_define_types (child_die))
15927 dwarf2_add_type_defn (fi, child_die, cu);
15928 else if (child_die->tag == DW_TAG_template_type_param
15929 || child_die->tag == DW_TAG_template_value_param)
15931 struct symbol *arg = new_symbol (child_die, NULL, cu);
15934 template_args->push_back (arg);
15936 else if (child_die->tag == DW_TAG_variant)
15938 /* In a variant we want to get the discriminant and also add a
15939 field for our sole member child. */
15940 struct attribute *discr = dwarf2_attr (child_die, DW_AT_discr_value, cu);
15942 for (struct die_info *variant_child = child_die->child;
15943 variant_child != NULL;
15944 variant_child = sibling_die (variant_child))
15946 if (variant_child->tag == DW_TAG_member)
15948 handle_struct_member_die (variant_child, type, fi,
15949 template_args, cu);
15950 /* Only handle the one. */
15955 /* We don't handle this but we might as well report it if we see
15957 if (dwarf2_attr (child_die, DW_AT_discr_list, cu) != nullptr)
15958 complaint (_("DW_AT_discr_list is not supported yet"
15959 " - DIE at %s [in module %s]"),
15960 sect_offset_str (child_die->sect_off),
15961 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15963 /* The first field was just added, so we can stash the
15964 discriminant there. */
15965 gdb_assert (!fi->fields.empty ());
15967 fi->fields.back ().variant.default_branch = true;
15969 fi->fields.back ().variant.discriminant_value = DW_UNSND (discr);
15973 /* Finish creating a structure or union type, including filling in
15974 its members and creating a symbol for it. */
15977 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
15979 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15980 struct die_info *child_die;
15983 type = get_die_type (die, cu);
15985 type = read_structure_type (die, cu);
15987 /* When reading a DW_TAG_variant_part, we need to notice when we
15988 read the discriminant member, so we can record it later in the
15989 discriminant_info. */
15990 bool is_variant_part = TYPE_FLAG_DISCRIMINATED_UNION (type);
15991 sect_offset discr_offset;
15992 bool has_template_parameters = false;
15994 if (is_variant_part)
15996 struct attribute *discr = dwarf2_attr (die, DW_AT_discr, cu);
15999 /* Maybe it's a univariant form, an extension we support.
16000 In this case arrange not to check the offset. */
16001 is_variant_part = false;
16003 else if (attr_form_is_ref (discr))
16005 struct dwarf2_cu *target_cu = cu;
16006 struct die_info *target_die = follow_die_ref (die, discr, &target_cu);
16008 discr_offset = target_die->sect_off;
16012 complaint (_("DW_AT_discr does not have DIE reference form"
16013 " - DIE at %s [in module %s]"),
16014 sect_offset_str (die->sect_off),
16015 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16016 is_variant_part = false;
16020 if (die->child != NULL && ! die_is_declaration (die, cu))
16022 struct field_info fi;
16023 std::vector<struct symbol *> template_args;
16025 child_die = die->child;
16027 while (child_die && child_die->tag)
16029 handle_struct_member_die (child_die, type, &fi, &template_args, cu);
16031 if (is_variant_part && discr_offset == child_die->sect_off)
16032 fi.fields.back ().variant.is_discriminant = true;
16034 child_die = sibling_die (child_die);
16037 /* Attach template arguments to type. */
16038 if (!template_args.empty ())
16040 has_template_parameters = true;
16041 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16042 TYPE_N_TEMPLATE_ARGUMENTS (type) = template_args.size ();
16043 TYPE_TEMPLATE_ARGUMENTS (type)
16044 = XOBNEWVEC (&objfile->objfile_obstack,
16046 TYPE_N_TEMPLATE_ARGUMENTS (type));
16047 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
16048 template_args.data (),
16049 (TYPE_N_TEMPLATE_ARGUMENTS (type)
16050 * sizeof (struct symbol *)));
16053 /* Attach fields and member functions to the type. */
16055 dwarf2_attach_fields_to_type (&fi, type, cu);
16056 if (!fi.fnfieldlists.empty ())
16058 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
16060 /* Get the type which refers to the base class (possibly this
16061 class itself) which contains the vtable pointer for the current
16062 class from the DW_AT_containing_type attribute. This use of
16063 DW_AT_containing_type is a GNU extension. */
16065 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
16067 struct type *t = die_containing_type (die, cu);
16069 set_type_vptr_basetype (type, t);
16074 /* Our own class provides vtbl ptr. */
16075 for (i = TYPE_NFIELDS (t) - 1;
16076 i >= TYPE_N_BASECLASSES (t);
16079 const char *fieldname = TYPE_FIELD_NAME (t, i);
16081 if (is_vtable_name (fieldname, cu))
16083 set_type_vptr_fieldno (type, i);
16088 /* Complain if virtual function table field not found. */
16089 if (i < TYPE_N_BASECLASSES (t))
16090 complaint (_("virtual function table pointer "
16091 "not found when defining class '%s'"),
16092 TYPE_NAME (type) ? TYPE_NAME (type) : "");
16096 set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
16099 else if (cu->producer
16100 && startswith (cu->producer, "IBM(R) XL C/C++ Advanced Edition"))
16102 /* The IBM XLC compiler does not provide direct indication
16103 of the containing type, but the vtable pointer is
16104 always named __vfp. */
16108 for (i = TYPE_NFIELDS (type) - 1;
16109 i >= TYPE_N_BASECLASSES (type);
16112 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
16114 set_type_vptr_fieldno (type, i);
16115 set_type_vptr_basetype (type, type);
16122 /* Copy fi.typedef_field_list linked list elements content into the
16123 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16124 if (!fi.typedef_field_list.empty ())
16126 int count = fi.typedef_field_list.size ();
16128 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16129 TYPE_TYPEDEF_FIELD_ARRAY (type)
16130 = ((struct decl_field *)
16132 sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * count));
16133 TYPE_TYPEDEF_FIELD_COUNT (type) = count;
16135 for (int i = 0; i < fi.typedef_field_list.size (); ++i)
16136 TYPE_TYPEDEF_FIELD (type, i) = fi.typedef_field_list[i];
16139 /* Copy fi.nested_types_list linked list elements content into the
16140 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16141 if (!fi.nested_types_list.empty () && cu->language != language_ada)
16143 int count = fi.nested_types_list.size ();
16145 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16146 TYPE_NESTED_TYPES_ARRAY (type)
16147 = ((struct decl_field *)
16148 TYPE_ALLOC (type, sizeof (struct decl_field) * count));
16149 TYPE_NESTED_TYPES_COUNT (type) = count;
16151 for (int i = 0; i < fi.nested_types_list.size (); ++i)
16152 TYPE_NESTED_TYPES_FIELD (type, i) = fi.nested_types_list[i];
16156 quirk_gcc_member_function_pointer (type, objfile);
16157 if (cu->language == language_rust && die->tag == DW_TAG_union_type)
16158 cu->rust_unions.push_back (type);
16160 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16161 snapshots) has been known to create a die giving a declaration
16162 for a class that has, as a child, a die giving a definition for a
16163 nested class. So we have to process our children even if the
16164 current die is a declaration. Normally, of course, a declaration
16165 won't have any children at all. */
16167 child_die = die->child;
16169 while (child_die != NULL && child_die->tag)
16171 if (child_die->tag == DW_TAG_member
16172 || child_die->tag == DW_TAG_variable
16173 || child_die->tag == DW_TAG_inheritance
16174 || child_die->tag == DW_TAG_template_value_param
16175 || child_die->tag == DW_TAG_template_type_param)
16180 process_die (child_die, cu);
16182 child_die = sibling_die (child_die);
16185 /* Do not consider external references. According to the DWARF standard,
16186 these DIEs are identified by the fact that they have no byte_size
16187 attribute, and a declaration attribute. */
16188 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
16189 || !die_is_declaration (die, cu))
16191 struct symbol *sym = new_symbol (die, type, cu);
16193 if (has_template_parameters)
16195 /* Make sure that the symtab is set on the new symbols.
16196 Even though they don't appear in this symtab directly,
16197 other parts of gdb assume that symbols do, and this is
16198 reasonably true. */
16199 for (int i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
16200 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type, i),
16201 symbol_symtab (sym));
16206 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16207 update TYPE using some information only available in DIE's children. */
16210 update_enumeration_type_from_children (struct die_info *die,
16212 struct dwarf2_cu *cu)
16214 struct die_info *child_die;
16215 int unsigned_enum = 1;
16219 auto_obstack obstack;
16221 for (child_die = die->child;
16222 child_die != NULL && child_die->tag;
16223 child_die = sibling_die (child_die))
16225 struct attribute *attr;
16227 const gdb_byte *bytes;
16228 struct dwarf2_locexpr_baton *baton;
16231 if (child_die->tag != DW_TAG_enumerator)
16234 attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
16238 name = dwarf2_name (child_die, cu);
16240 name = "<anonymous enumerator>";
16242 dwarf2_const_value_attr (attr, type, name, &obstack, cu,
16243 &value, &bytes, &baton);
16249 else if ((mask & value) != 0)
16254 /* If we already know that the enum type is neither unsigned, nor
16255 a flag type, no need to look at the rest of the enumerates. */
16256 if (!unsigned_enum && !flag_enum)
16261 TYPE_UNSIGNED (type) = 1;
16263 TYPE_FLAG_ENUM (type) = 1;
16266 /* Given a DW_AT_enumeration_type die, set its type. We do not
16267 complete the type's fields yet, or create any symbols. */
16269 static struct type *
16270 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
16272 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16274 struct attribute *attr;
16277 /* If the definition of this type lives in .debug_types, read that type.
16278 Don't follow DW_AT_specification though, that will take us back up
16279 the chain and we want to go down. */
16280 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
16283 type = get_DW_AT_signature_type (die, attr, cu);
16285 /* The type's CU may not be the same as CU.
16286 Ensure TYPE is recorded with CU in die_type_hash. */
16287 return set_die_type (die, type, cu);
16290 type = alloc_type (objfile);
16292 TYPE_CODE (type) = TYPE_CODE_ENUM;
16293 name = dwarf2_full_name (NULL, die, cu);
16295 TYPE_NAME (type) = name;
16297 attr = dwarf2_attr (die, DW_AT_type, cu);
16300 struct type *underlying_type = die_type (die, cu);
16302 TYPE_TARGET_TYPE (type) = underlying_type;
16305 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16308 TYPE_LENGTH (type) = DW_UNSND (attr);
16312 TYPE_LENGTH (type) = 0;
16315 maybe_set_alignment (cu, die, type);
16317 /* The enumeration DIE can be incomplete. In Ada, any type can be
16318 declared as private in the package spec, and then defined only
16319 inside the package body. Such types are known as Taft Amendment
16320 Types. When another package uses such a type, an incomplete DIE
16321 may be generated by the compiler. */
16322 if (die_is_declaration (die, cu))
16323 TYPE_STUB (type) = 1;
16325 /* Finish the creation of this type by using the enum's children.
16326 We must call this even when the underlying type has been provided
16327 so that we can determine if we're looking at a "flag" enum. */
16328 update_enumeration_type_from_children (die, type, cu);
16330 /* If this type has an underlying type that is not a stub, then we
16331 may use its attributes. We always use the "unsigned" attribute
16332 in this situation, because ordinarily we guess whether the type
16333 is unsigned -- but the guess can be wrong and the underlying type
16334 can tell us the reality. However, we defer to a local size
16335 attribute if one exists, because this lets the compiler override
16336 the underlying type if needed. */
16337 if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
16339 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
16340 if (TYPE_LENGTH (type) == 0)
16341 TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
16342 if (TYPE_RAW_ALIGN (type) == 0
16343 && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)) != 0)
16344 set_type_align (type, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)));
16347 TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
16349 return set_die_type (die, type, cu);
16352 /* Given a pointer to a die which begins an enumeration, process all
16353 the dies that define the members of the enumeration, and create the
16354 symbol for the enumeration type.
16356 NOTE: We reverse the order of the element list. */
16359 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
16361 struct type *this_type;
16363 this_type = get_die_type (die, cu);
16364 if (this_type == NULL)
16365 this_type = read_enumeration_type (die, cu);
16367 if (die->child != NULL)
16369 struct die_info *child_die;
16370 struct symbol *sym;
16371 struct field *fields = NULL;
16372 int num_fields = 0;
16375 child_die = die->child;
16376 while (child_die && child_die->tag)
16378 if (child_die->tag != DW_TAG_enumerator)
16380 process_die (child_die, cu);
16384 name = dwarf2_name (child_die, cu);
16387 sym = new_symbol (child_die, this_type, cu);
16389 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
16391 fields = (struct field *)
16393 (num_fields + DW_FIELD_ALLOC_CHUNK)
16394 * sizeof (struct field));
16397 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
16398 FIELD_TYPE (fields[num_fields]) = NULL;
16399 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
16400 FIELD_BITSIZE (fields[num_fields]) = 0;
16406 child_die = sibling_die (child_die);
16411 TYPE_NFIELDS (this_type) = num_fields;
16412 TYPE_FIELDS (this_type) = (struct field *)
16413 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
16414 memcpy (TYPE_FIELDS (this_type), fields,
16415 sizeof (struct field) * num_fields);
16420 /* If we are reading an enum from a .debug_types unit, and the enum
16421 is a declaration, and the enum is not the signatured type in the
16422 unit, then we do not want to add a symbol for it. Adding a
16423 symbol would in some cases obscure the true definition of the
16424 enum, giving users an incomplete type when the definition is
16425 actually available. Note that we do not want to do this for all
16426 enums which are just declarations, because C++0x allows forward
16427 enum declarations. */
16428 if (cu->per_cu->is_debug_types
16429 && die_is_declaration (die, cu))
16431 struct signatured_type *sig_type;
16433 sig_type = (struct signatured_type *) cu->per_cu;
16434 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
16435 if (sig_type->type_offset_in_section != die->sect_off)
16439 new_symbol (die, this_type, cu);
16442 /* Extract all information from a DW_TAG_array_type DIE and put it in
16443 the DIE's type field. For now, this only handles one dimensional
16446 static struct type *
16447 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
16449 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16450 struct die_info *child_die;
16452 struct type *element_type, *range_type, *index_type;
16453 struct attribute *attr;
16455 struct dynamic_prop *byte_stride_prop = NULL;
16456 unsigned int bit_stride = 0;
16458 element_type = die_type (die, cu);
16460 /* The die_type call above may have already set the type for this DIE. */
16461 type = get_die_type (die, cu);
16465 attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
16471 = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
16472 stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop);
16475 complaint (_("unable to read array DW_AT_byte_stride "
16476 " - DIE at %s [in module %s]"),
16477 sect_offset_str (die->sect_off),
16478 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16479 /* Ignore this attribute. We will likely not be able to print
16480 arrays of this type correctly, but there is little we can do
16481 to help if we cannot read the attribute's value. */
16482 byte_stride_prop = NULL;
16486 attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
16488 bit_stride = DW_UNSND (attr);
16490 /* Irix 6.2 native cc creates array types without children for
16491 arrays with unspecified length. */
16492 if (die->child == NULL)
16494 index_type = objfile_type (objfile)->builtin_int;
16495 range_type = create_static_range_type (NULL, index_type, 0, -1);
16496 type = create_array_type_with_stride (NULL, element_type, range_type,
16497 byte_stride_prop, bit_stride);
16498 return set_die_type (die, type, cu);
16501 std::vector<struct type *> range_types;
16502 child_die = die->child;
16503 while (child_die && child_die->tag)
16505 if (child_die->tag == DW_TAG_subrange_type)
16507 struct type *child_type = read_type_die (child_die, cu);
16509 if (child_type != NULL)
16511 /* The range type was succesfully read. Save it for the
16512 array type creation. */
16513 range_types.push_back (child_type);
16516 child_die = sibling_die (child_die);
16519 /* Dwarf2 dimensions are output from left to right, create the
16520 necessary array types in backwards order. */
16522 type = element_type;
16524 if (read_array_order (die, cu) == DW_ORD_col_major)
16528 while (i < range_types.size ())
16529 type = create_array_type_with_stride (NULL, type, range_types[i++],
16530 byte_stride_prop, bit_stride);
16534 size_t ndim = range_types.size ();
16536 type = create_array_type_with_stride (NULL, type, range_types[ndim],
16537 byte_stride_prop, bit_stride);
16540 /* Understand Dwarf2 support for vector types (like they occur on
16541 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16542 array type. This is not part of the Dwarf2/3 standard yet, but a
16543 custom vendor extension. The main difference between a regular
16544 array and the vector variant is that vectors are passed by value
16546 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
16548 make_vector_type (type);
16550 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16551 implementation may choose to implement triple vectors using this
16553 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16556 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
16557 TYPE_LENGTH (type) = DW_UNSND (attr);
16559 complaint (_("DW_AT_byte_size for array type smaller "
16560 "than the total size of elements"));
16563 name = dwarf2_name (die, cu);
16565 TYPE_NAME (type) = name;
16567 maybe_set_alignment (cu, die, type);
16569 /* Install the type in the die. */
16570 set_die_type (die, type, cu);
16572 /* set_die_type should be already done. */
16573 set_descriptive_type (type, die, cu);
16578 static enum dwarf_array_dim_ordering
16579 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
16581 struct attribute *attr;
16583 attr = dwarf2_attr (die, DW_AT_ordering, cu);
16586 return (enum dwarf_array_dim_ordering) DW_SND (attr);
16588 /* GNU F77 is a special case, as at 08/2004 array type info is the
16589 opposite order to the dwarf2 specification, but data is still
16590 laid out as per normal fortran.
16592 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16593 version checking. */
16595 if (cu->language == language_fortran
16596 && cu->producer && strstr (cu->producer, "GNU F77"))
16598 return DW_ORD_row_major;
16601 switch (cu->language_defn->la_array_ordering)
16603 case array_column_major:
16604 return DW_ORD_col_major;
16605 case array_row_major:
16607 return DW_ORD_row_major;
16611 /* Extract all information from a DW_TAG_set_type DIE and put it in
16612 the DIE's type field. */
16614 static struct type *
16615 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
16617 struct type *domain_type, *set_type;
16618 struct attribute *attr;
16620 domain_type = die_type (die, cu);
16622 /* The die_type call above may have already set the type for this DIE. */
16623 set_type = get_die_type (die, cu);
16627 set_type = create_set_type (NULL, domain_type);
16629 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16631 TYPE_LENGTH (set_type) = DW_UNSND (attr);
16633 maybe_set_alignment (cu, die, set_type);
16635 return set_die_type (die, set_type, cu);
16638 /* A helper for read_common_block that creates a locexpr baton.
16639 SYM is the symbol which we are marking as computed.
16640 COMMON_DIE is the DIE for the common block.
16641 COMMON_LOC is the location expression attribute for the common
16643 MEMBER_LOC is the location expression attribute for the particular
16644 member of the common block that we are processing.
16645 CU is the CU from which the above come. */
16648 mark_common_block_symbol_computed (struct symbol *sym,
16649 struct die_info *common_die,
16650 struct attribute *common_loc,
16651 struct attribute *member_loc,
16652 struct dwarf2_cu *cu)
16654 struct dwarf2_per_objfile *dwarf2_per_objfile
16655 = cu->per_cu->dwarf2_per_objfile;
16656 struct objfile *objfile = dwarf2_per_objfile->objfile;
16657 struct dwarf2_locexpr_baton *baton;
16659 unsigned int cu_off;
16660 enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
16661 LONGEST offset = 0;
16663 gdb_assert (common_loc && member_loc);
16664 gdb_assert (attr_form_is_block (common_loc));
16665 gdb_assert (attr_form_is_block (member_loc)
16666 || attr_form_is_constant (member_loc));
16668 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
16669 baton->per_cu = cu->per_cu;
16670 gdb_assert (baton->per_cu);
16672 baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16674 if (attr_form_is_constant (member_loc))
16676 offset = dwarf2_get_attr_constant_value (member_loc, 0);
16677 baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
16680 baton->size += DW_BLOCK (member_loc)->size;
16682 ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
16685 *ptr++ = DW_OP_call4;
16686 cu_off = common_die->sect_off - cu->per_cu->sect_off;
16687 store_unsigned_integer (ptr, 4, byte_order, cu_off);
16690 if (attr_form_is_constant (member_loc))
16692 *ptr++ = DW_OP_addr;
16693 store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
16694 ptr += cu->header.addr_size;
16698 /* We have to copy the data here, because DW_OP_call4 will only
16699 use a DW_AT_location attribute. */
16700 memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
16701 ptr += DW_BLOCK (member_loc)->size;
16704 *ptr++ = DW_OP_plus;
16705 gdb_assert (ptr - baton->data == baton->size);
16707 SYMBOL_LOCATION_BATON (sym) = baton;
16708 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
16711 /* Create appropriate locally-scoped variables for all the
16712 DW_TAG_common_block entries. Also create a struct common_block
16713 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16714 is used to sepate the common blocks name namespace from regular
16718 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
16720 struct attribute *attr;
16722 attr = dwarf2_attr (die, DW_AT_location, cu);
16725 /* Support the .debug_loc offsets. */
16726 if (attr_form_is_block (attr))
16730 else if (attr_form_is_section_offset (attr))
16732 dwarf2_complex_location_expr_complaint ();
16737 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16738 "common block member");
16743 if (die->child != NULL)
16745 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16746 struct die_info *child_die;
16747 size_t n_entries = 0, size;
16748 struct common_block *common_block;
16749 struct symbol *sym;
16751 for (child_die = die->child;
16752 child_die && child_die->tag;
16753 child_die = sibling_die (child_die))
16756 size = (sizeof (struct common_block)
16757 + (n_entries - 1) * sizeof (struct symbol *));
16759 = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
16761 memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
16762 common_block->n_entries = 0;
16764 for (child_die = die->child;
16765 child_die && child_die->tag;
16766 child_die = sibling_die (child_die))
16768 /* Create the symbol in the DW_TAG_common_block block in the current
16770 sym = new_symbol (child_die, NULL, cu);
16773 struct attribute *member_loc;
16775 common_block->contents[common_block->n_entries++] = sym;
16777 member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
16781 /* GDB has handled this for a long time, but it is
16782 not specified by DWARF. It seems to have been
16783 emitted by gfortran at least as recently as:
16784 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16785 complaint (_("Variable in common block has "
16786 "DW_AT_data_member_location "
16787 "- DIE at %s [in module %s]"),
16788 sect_offset_str (child_die->sect_off),
16789 objfile_name (objfile));
16791 if (attr_form_is_section_offset (member_loc))
16792 dwarf2_complex_location_expr_complaint ();
16793 else if (attr_form_is_constant (member_loc)
16794 || attr_form_is_block (member_loc))
16797 mark_common_block_symbol_computed (sym, die, attr,
16801 dwarf2_complex_location_expr_complaint ();
16806 sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
16807 SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
16811 /* Create a type for a C++ namespace. */
16813 static struct type *
16814 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
16816 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16817 const char *previous_prefix, *name;
16821 /* For extensions, reuse the type of the original namespace. */
16822 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
16824 struct die_info *ext_die;
16825 struct dwarf2_cu *ext_cu = cu;
16827 ext_die = dwarf2_extension (die, &ext_cu);
16828 type = read_type_die (ext_die, ext_cu);
16830 /* EXT_CU may not be the same as CU.
16831 Ensure TYPE is recorded with CU in die_type_hash. */
16832 return set_die_type (die, type, cu);
16835 name = namespace_name (die, &is_anonymous, cu);
16837 /* Now build the name of the current namespace. */
16839 previous_prefix = determine_prefix (die, cu);
16840 if (previous_prefix[0] != '\0')
16841 name = typename_concat (&objfile->objfile_obstack,
16842 previous_prefix, name, 0, cu);
16844 /* Create the type. */
16845 type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
16847 return set_die_type (die, type, cu);
16850 /* Read a namespace scope. */
16853 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
16855 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16858 /* Add a symbol associated to this if we haven't seen the namespace
16859 before. Also, add a using directive if it's an anonymous
16862 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
16866 type = read_type_die (die, cu);
16867 new_symbol (die, type, cu);
16869 namespace_name (die, &is_anonymous, cu);
16872 const char *previous_prefix = determine_prefix (die, cu);
16874 std::vector<const char *> excludes;
16875 add_using_directive (using_directives (cu),
16876 previous_prefix, TYPE_NAME (type), NULL,
16877 NULL, excludes, 0, &objfile->objfile_obstack);
16881 if (die->child != NULL)
16883 struct die_info *child_die = die->child;
16885 while (child_die && child_die->tag)
16887 process_die (child_die, cu);
16888 child_die = sibling_die (child_die);
16893 /* Read a Fortran module as type. This DIE can be only a declaration used for
16894 imported module. Still we need that type as local Fortran "use ... only"
16895 declaration imports depend on the created type in determine_prefix. */
16897 static struct type *
16898 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
16900 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16901 const char *module_name;
16904 module_name = dwarf2_name (die, cu);
16906 complaint (_("DW_TAG_module has no name, offset %s"),
16907 sect_offset_str (die->sect_off));
16908 type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
16910 return set_die_type (die, type, cu);
16913 /* Read a Fortran module. */
16916 read_module (struct die_info *die, struct dwarf2_cu *cu)
16918 struct die_info *child_die = die->child;
16921 type = read_type_die (die, cu);
16922 new_symbol (die, type, cu);
16924 while (child_die && child_die->tag)
16926 process_die (child_die, cu);
16927 child_die = sibling_die (child_die);
16931 /* Return the name of the namespace represented by DIE. Set
16932 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16935 static const char *
16936 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
16938 struct die_info *current_die;
16939 const char *name = NULL;
16941 /* Loop through the extensions until we find a name. */
16943 for (current_die = die;
16944 current_die != NULL;
16945 current_die = dwarf2_extension (die, &cu))
16947 /* We don't use dwarf2_name here so that we can detect the absence
16948 of a name -> anonymous namespace. */
16949 name = dwarf2_string_attr (die, DW_AT_name, cu);
16955 /* Is it an anonymous namespace? */
16957 *is_anonymous = (name == NULL);
16959 name = CP_ANONYMOUS_NAMESPACE_STR;
16964 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16965 the user defined type vector. */
16967 static struct type *
16968 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
16970 struct gdbarch *gdbarch
16971 = get_objfile_arch (cu->per_cu->dwarf2_per_objfile->objfile);
16972 struct comp_unit_head *cu_header = &cu->header;
16974 struct attribute *attr_byte_size;
16975 struct attribute *attr_address_class;
16976 int byte_size, addr_class;
16977 struct type *target_type;
16979 target_type = die_type (die, cu);
16981 /* The die_type call above may have already set the type for this DIE. */
16982 type = get_die_type (die, cu);
16986 type = lookup_pointer_type (target_type);
16988 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
16989 if (attr_byte_size)
16990 byte_size = DW_UNSND (attr_byte_size);
16992 byte_size = cu_header->addr_size;
16994 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
16995 if (attr_address_class)
16996 addr_class = DW_UNSND (attr_address_class);
16998 addr_class = DW_ADDR_none;
17000 ULONGEST alignment = get_alignment (cu, die);
17002 /* If the pointer size, alignment, or address class is different
17003 than the default, create a type variant marked as such and set
17004 the length accordingly. */
17005 if (TYPE_LENGTH (type) != byte_size
17006 || (alignment != 0 && TYPE_RAW_ALIGN (type) != 0
17007 && alignment != TYPE_RAW_ALIGN (type))
17008 || addr_class != DW_ADDR_none)
17010 if (gdbarch_address_class_type_flags_p (gdbarch))
17014 type_flags = gdbarch_address_class_type_flags
17015 (gdbarch, byte_size, addr_class);
17016 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
17018 type = make_type_with_address_space (type, type_flags);
17020 else if (TYPE_LENGTH (type) != byte_size)
17022 complaint (_("invalid pointer size %d"), byte_size);
17024 else if (TYPE_RAW_ALIGN (type) != alignment)
17026 complaint (_("Invalid DW_AT_alignment"
17027 " - DIE at %s [in module %s]"),
17028 sect_offset_str (die->sect_off),
17029 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17033 /* Should we also complain about unhandled address classes? */
17037 TYPE_LENGTH (type) = byte_size;
17038 set_type_align (type, alignment);
17039 return set_die_type (die, type, cu);
17042 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17043 the user defined type vector. */
17045 static struct type *
17046 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
17049 struct type *to_type;
17050 struct type *domain;
17052 to_type = die_type (die, cu);
17053 domain = die_containing_type (die, cu);
17055 /* The calls above may have already set the type for this DIE. */
17056 type = get_die_type (die, cu);
17060 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
17061 type = lookup_methodptr_type (to_type);
17062 else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
17064 struct type *new_type
17065 = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
17067 smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
17068 TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
17069 TYPE_VARARGS (to_type));
17070 type = lookup_methodptr_type (new_type);
17073 type = lookup_memberptr_type (to_type, domain);
17075 return set_die_type (die, type, cu);
17078 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17079 the user defined type vector. */
17081 static struct type *
17082 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
17083 enum type_code refcode)
17085 struct comp_unit_head *cu_header = &cu->header;
17086 struct type *type, *target_type;
17087 struct attribute *attr;
17089 gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
17091 target_type = die_type (die, cu);
17093 /* The die_type call above may have already set the type for this DIE. */
17094 type = get_die_type (die, cu);
17098 type = lookup_reference_type (target_type, refcode);
17099 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17102 TYPE_LENGTH (type) = DW_UNSND (attr);
17106 TYPE_LENGTH (type) = cu_header->addr_size;
17108 maybe_set_alignment (cu, die, type);
17109 return set_die_type (die, type, cu);
17112 /* Add the given cv-qualifiers to the element type of the array. GCC
17113 outputs DWARF type qualifiers that apply to an array, not the
17114 element type. But GDB relies on the array element type to carry
17115 the cv-qualifiers. This mimics section 6.7.3 of the C99
17118 static struct type *
17119 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
17120 struct type *base_type, int cnst, int voltl)
17122 struct type *el_type, *inner_array;
17124 base_type = copy_type (base_type);
17125 inner_array = base_type;
17127 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
17129 TYPE_TARGET_TYPE (inner_array) =
17130 copy_type (TYPE_TARGET_TYPE (inner_array));
17131 inner_array = TYPE_TARGET_TYPE (inner_array);
17134 el_type = TYPE_TARGET_TYPE (inner_array);
17135 cnst |= TYPE_CONST (el_type);
17136 voltl |= TYPE_VOLATILE (el_type);
17137 TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
17139 return set_die_type (die, base_type, cu);
17142 static struct type *
17143 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
17145 struct type *base_type, *cv_type;
17147 base_type = die_type (die, cu);
17149 /* The die_type call above may have already set the type for this DIE. */
17150 cv_type = get_die_type (die, cu);
17154 /* In case the const qualifier is applied to an array type, the element type
17155 is so qualified, not the array type (section 6.7.3 of C99). */
17156 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17157 return add_array_cv_type (die, cu, base_type, 1, 0);
17159 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
17160 return set_die_type (die, cv_type, cu);
17163 static struct type *
17164 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
17166 struct type *base_type, *cv_type;
17168 base_type = die_type (die, cu);
17170 /* The die_type call above may have already set the type for this DIE. */
17171 cv_type = get_die_type (die, cu);
17175 /* In case the volatile qualifier is applied to an array type, the
17176 element type is so qualified, not the array type (section 6.7.3
17178 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17179 return add_array_cv_type (die, cu, base_type, 0, 1);
17181 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
17182 return set_die_type (die, cv_type, cu);
17185 /* Handle DW_TAG_restrict_type. */
17187 static struct type *
17188 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
17190 struct type *base_type, *cv_type;
17192 base_type = die_type (die, cu);
17194 /* The die_type call above may have already set the type for this DIE. */
17195 cv_type = get_die_type (die, cu);
17199 cv_type = make_restrict_type (base_type);
17200 return set_die_type (die, cv_type, cu);
17203 /* Handle DW_TAG_atomic_type. */
17205 static struct type *
17206 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
17208 struct type *base_type, *cv_type;
17210 base_type = die_type (die, cu);
17212 /* The die_type call above may have already set the type for this DIE. */
17213 cv_type = get_die_type (die, cu);
17217 cv_type = make_atomic_type (base_type);
17218 return set_die_type (die, cv_type, cu);
17221 /* Extract all information from a DW_TAG_string_type DIE and add to
17222 the user defined type vector. It isn't really a user defined type,
17223 but it behaves like one, with other DIE's using an AT_user_def_type
17224 attribute to reference it. */
17226 static struct type *
17227 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
17229 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17230 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17231 struct type *type, *range_type, *index_type, *char_type;
17232 struct attribute *attr;
17233 unsigned int length;
17235 attr = dwarf2_attr (die, DW_AT_string_length, cu);
17238 length = DW_UNSND (attr);
17242 /* Check for the DW_AT_byte_size attribute. */
17243 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17246 length = DW_UNSND (attr);
17254 index_type = objfile_type (objfile)->builtin_int;
17255 range_type = create_static_range_type (NULL, index_type, 1, length);
17256 char_type = language_string_char_type (cu->language_defn, gdbarch);
17257 type = create_string_type (NULL, char_type, range_type);
17259 return set_die_type (die, type, cu);
17262 /* Assuming that DIE corresponds to a function, returns nonzero
17263 if the function is prototyped. */
17266 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
17268 struct attribute *attr;
17270 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
17271 if (attr && (DW_UNSND (attr) != 0))
17274 /* The DWARF standard implies that the DW_AT_prototyped attribute
17275 is only meaninful for C, but the concept also extends to other
17276 languages that allow unprototyped functions (Eg: Objective C).
17277 For all other languages, assume that functions are always
17279 if (cu->language != language_c
17280 && cu->language != language_objc
17281 && cu->language != language_opencl)
17284 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17285 prototyped and unprototyped functions; default to prototyped,
17286 since that is more common in modern code (and RealView warns
17287 about unprototyped functions). */
17288 if (producer_is_realview (cu->producer))
17294 /* Handle DIES due to C code like:
17298 int (*funcp)(int a, long l);
17302 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17304 static struct type *
17305 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
17307 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17308 struct type *type; /* Type that this function returns. */
17309 struct type *ftype; /* Function that returns above type. */
17310 struct attribute *attr;
17312 type = die_type (die, cu);
17314 /* The die_type call above may have already set the type for this DIE. */
17315 ftype = get_die_type (die, cu);
17319 ftype = lookup_function_type (type);
17321 if (prototyped_function_p (die, cu))
17322 TYPE_PROTOTYPED (ftype) = 1;
17324 /* Store the calling convention in the type if it's available in
17325 the subroutine die. Otherwise set the calling convention to
17326 the default value DW_CC_normal. */
17327 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
17329 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
17330 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
17331 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
17333 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
17335 /* Record whether the function returns normally to its caller or not
17336 if the DWARF producer set that information. */
17337 attr = dwarf2_attr (die, DW_AT_noreturn, cu);
17338 if (attr && (DW_UNSND (attr) != 0))
17339 TYPE_NO_RETURN (ftype) = 1;
17341 /* We need to add the subroutine type to the die immediately so
17342 we don't infinitely recurse when dealing with parameters
17343 declared as the same subroutine type. */
17344 set_die_type (die, ftype, cu);
17346 if (die->child != NULL)
17348 struct type *void_type = objfile_type (objfile)->builtin_void;
17349 struct die_info *child_die;
17350 int nparams, iparams;
17352 /* Count the number of parameters.
17353 FIXME: GDB currently ignores vararg functions, but knows about
17354 vararg member functions. */
17356 child_die = die->child;
17357 while (child_die && child_die->tag)
17359 if (child_die->tag == DW_TAG_formal_parameter)
17361 else if (child_die->tag == DW_TAG_unspecified_parameters)
17362 TYPE_VARARGS (ftype) = 1;
17363 child_die = sibling_die (child_die);
17366 /* Allocate storage for parameters and fill them in. */
17367 TYPE_NFIELDS (ftype) = nparams;
17368 TYPE_FIELDS (ftype) = (struct field *)
17369 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
17371 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17372 even if we error out during the parameters reading below. */
17373 for (iparams = 0; iparams < nparams; iparams++)
17374 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
17377 child_die = die->child;
17378 while (child_die && child_die->tag)
17380 if (child_die->tag == DW_TAG_formal_parameter)
17382 struct type *arg_type;
17384 /* DWARF version 2 has no clean way to discern C++
17385 static and non-static member functions. G++ helps
17386 GDB by marking the first parameter for non-static
17387 member functions (which is the this pointer) as
17388 artificial. We pass this information to
17389 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17391 DWARF version 3 added DW_AT_object_pointer, which GCC
17392 4.5 does not yet generate. */
17393 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
17395 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
17397 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
17398 arg_type = die_type (child_die, cu);
17400 /* RealView does not mark THIS as const, which the testsuite
17401 expects. GCC marks THIS as const in method definitions,
17402 but not in the class specifications (GCC PR 43053). */
17403 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
17404 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
17407 struct dwarf2_cu *arg_cu = cu;
17408 const char *name = dwarf2_name (child_die, cu);
17410 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
17413 /* If the compiler emits this, use it. */
17414 if (follow_die_ref (die, attr, &arg_cu) == child_die)
17417 else if (name && strcmp (name, "this") == 0)
17418 /* Function definitions will have the argument names. */
17420 else if (name == NULL && iparams == 0)
17421 /* Declarations may not have the names, so like
17422 elsewhere in GDB, assume an artificial first
17423 argument is "this". */
17427 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
17431 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
17434 child_die = sibling_die (child_die);
17441 static struct type *
17442 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
17444 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17445 const char *name = NULL;
17446 struct type *this_type, *target_type;
17448 name = dwarf2_full_name (NULL, die, cu);
17449 this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
17450 TYPE_TARGET_STUB (this_type) = 1;
17451 set_die_type (die, this_type, cu);
17452 target_type = die_type (die, cu);
17453 if (target_type != this_type)
17454 TYPE_TARGET_TYPE (this_type) = target_type;
17457 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17458 spec and cause infinite loops in GDB. */
17459 complaint (_("Self-referential DW_TAG_typedef "
17460 "- DIE at %s [in module %s]"),
17461 sect_offset_str (die->sect_off), objfile_name (objfile));
17462 TYPE_TARGET_TYPE (this_type) = NULL;
17467 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17468 (which may be different from NAME) to the architecture back-end to allow
17469 it to guess the correct format if necessary. */
17471 static struct type *
17472 dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
17473 const char *name_hint)
17475 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17476 const struct floatformat **format;
17479 format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
17481 type = init_float_type (objfile, bits, name, format);
17483 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17488 /* Allocate an integer type of size BITS and name NAME. */
17490 static struct type *
17491 dwarf2_init_integer_type (struct dwarf2_cu *cu, struct objfile *objfile,
17492 int bits, int unsigned_p, const char *name)
17496 /* Versions of Intel's C Compiler generate an integer type called "void"
17497 instead of using DW_TAG_unspecified_type. This has been seen on
17498 at least versions 14, 17, and 18. */
17499 if (bits == 0 && producer_is_icc (cu) && name != nullptr
17500 && strcmp (name, "void") == 0)
17501 type = objfile_type (objfile)->builtin_void;
17503 type = init_integer_type (objfile, bits, unsigned_p, name);
17508 /* Find a representation of a given base type and install
17509 it in the TYPE field of the die. */
17511 static struct type *
17512 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
17514 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17516 struct attribute *attr;
17517 int encoding = 0, bits = 0;
17520 attr = dwarf2_attr (die, DW_AT_encoding, cu);
17523 encoding = DW_UNSND (attr);
17525 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17528 bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
17530 name = dwarf2_name (die, cu);
17533 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17538 case DW_ATE_address:
17539 /* Turn DW_ATE_address into a void * pointer. */
17540 type = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
17541 type = init_pointer_type (objfile, bits, name, type);
17543 case DW_ATE_boolean:
17544 type = init_boolean_type (objfile, bits, 1, name);
17546 case DW_ATE_complex_float:
17547 type = dwarf2_init_float_type (objfile, bits / 2, NULL, name);
17548 type = init_complex_type (objfile, name, type);
17550 case DW_ATE_decimal_float:
17551 type = init_decfloat_type (objfile, bits, name);
17554 type = dwarf2_init_float_type (objfile, bits, name, name);
17556 case DW_ATE_signed:
17557 type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17559 case DW_ATE_unsigned:
17560 if (cu->language == language_fortran
17562 && startswith (name, "character("))
17563 type = init_character_type (objfile, bits, 1, name);
17565 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17567 case DW_ATE_signed_char:
17568 if (cu->language == language_ada || cu->language == language_m2
17569 || cu->language == language_pascal
17570 || cu->language == language_fortran)
17571 type = init_character_type (objfile, bits, 0, name);
17573 type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17575 case DW_ATE_unsigned_char:
17576 if (cu->language == language_ada || cu->language == language_m2
17577 || cu->language == language_pascal
17578 || cu->language == language_fortran
17579 || cu->language == language_rust)
17580 type = init_character_type (objfile, bits, 1, name);
17582 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17586 gdbarch *arch = get_objfile_arch (objfile);
17589 type = builtin_type (arch)->builtin_char16;
17590 else if (bits == 32)
17591 type = builtin_type (arch)->builtin_char32;
17594 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17596 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17598 return set_die_type (die, type, cu);
17603 complaint (_("unsupported DW_AT_encoding: '%s'"),
17604 dwarf_type_encoding_name (encoding));
17605 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17609 if (name && strcmp (name, "char") == 0)
17610 TYPE_NOSIGN (type) = 1;
17612 maybe_set_alignment (cu, die, type);
17614 return set_die_type (die, type, cu);
17617 /* Parse dwarf attribute if it's a block, reference or constant and put the
17618 resulting value of the attribute into struct bound_prop.
17619 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17622 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
17623 struct dwarf2_cu *cu, struct dynamic_prop *prop)
17625 struct dwarf2_property_baton *baton;
17626 struct obstack *obstack
17627 = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
17629 if (attr == NULL || prop == NULL)
17632 if (attr_form_is_block (attr))
17634 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17635 baton->referenced_type = NULL;
17636 baton->locexpr.per_cu = cu->per_cu;
17637 baton->locexpr.size = DW_BLOCK (attr)->size;
17638 baton->locexpr.data = DW_BLOCK (attr)->data;
17639 prop->data.baton = baton;
17640 prop->kind = PROP_LOCEXPR;
17641 gdb_assert (prop->data.baton != NULL);
17643 else if (attr_form_is_ref (attr))
17645 struct dwarf2_cu *target_cu = cu;
17646 struct die_info *target_die;
17647 struct attribute *target_attr;
17649 target_die = follow_die_ref (die, attr, &target_cu);
17650 target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
17651 if (target_attr == NULL)
17652 target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
17654 if (target_attr == NULL)
17657 switch (target_attr->name)
17659 case DW_AT_location:
17660 if (attr_form_is_section_offset (target_attr))
17662 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17663 baton->referenced_type = die_type (target_die, target_cu);
17664 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
17665 prop->data.baton = baton;
17666 prop->kind = PROP_LOCLIST;
17667 gdb_assert (prop->data.baton != NULL);
17669 else if (attr_form_is_block (target_attr))
17671 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17672 baton->referenced_type = die_type (target_die, target_cu);
17673 baton->locexpr.per_cu = cu->per_cu;
17674 baton->locexpr.size = DW_BLOCK (target_attr)->size;
17675 baton->locexpr.data = DW_BLOCK (target_attr)->data;
17676 prop->data.baton = baton;
17677 prop->kind = PROP_LOCEXPR;
17678 gdb_assert (prop->data.baton != NULL);
17682 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17683 "dynamic property");
17687 case DW_AT_data_member_location:
17691 if (!handle_data_member_location (target_die, target_cu,
17695 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17696 baton->referenced_type = read_type_die (target_die->parent,
17698 baton->offset_info.offset = offset;
17699 baton->offset_info.type = die_type (target_die, target_cu);
17700 prop->data.baton = baton;
17701 prop->kind = PROP_ADDR_OFFSET;
17706 else if (attr_form_is_constant (attr))
17708 prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
17709 prop->kind = PROP_CONST;
17713 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
17714 dwarf2_name (die, cu));
17721 /* Read the given DW_AT_subrange DIE. */
17723 static struct type *
17724 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
17726 struct type *base_type, *orig_base_type;
17727 struct type *range_type;
17728 struct attribute *attr;
17729 struct dynamic_prop low, high;
17730 int low_default_is_valid;
17731 int high_bound_is_count = 0;
17733 ULONGEST negative_mask;
17735 orig_base_type = die_type (die, cu);
17736 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17737 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17738 creating the range type, but we use the result of check_typedef
17739 when examining properties of the type. */
17740 base_type = check_typedef (orig_base_type);
17742 /* The die_type call above may have already set the type for this DIE. */
17743 range_type = get_die_type (die, cu);
17747 low.kind = PROP_CONST;
17748 high.kind = PROP_CONST;
17749 high.data.const_val = 0;
17751 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17752 omitting DW_AT_lower_bound. */
17753 switch (cu->language)
17756 case language_cplus:
17757 low.data.const_val = 0;
17758 low_default_is_valid = 1;
17760 case language_fortran:
17761 low.data.const_val = 1;
17762 low_default_is_valid = 1;
17765 case language_objc:
17766 case language_rust:
17767 low.data.const_val = 0;
17768 low_default_is_valid = (cu->header.version >= 4);
17772 case language_pascal:
17773 low.data.const_val = 1;
17774 low_default_is_valid = (cu->header.version >= 4);
17777 low.data.const_val = 0;
17778 low_default_is_valid = 0;
17782 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
17784 attr_to_dynamic_prop (attr, die, cu, &low);
17785 else if (!low_default_is_valid)
17786 complaint (_("Missing DW_AT_lower_bound "
17787 "- DIE at %s [in module %s]"),
17788 sect_offset_str (die->sect_off),
17789 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17791 struct attribute *attr_ub, *attr_count;
17792 attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);
17793 if (!attr_to_dynamic_prop (attr, die, cu, &high))
17795 attr = attr_count = dwarf2_attr (die, DW_AT_count, cu);
17796 if (attr_to_dynamic_prop (attr, die, cu, &high))
17798 /* If bounds are constant do the final calculation here. */
17799 if (low.kind == PROP_CONST && high.kind == PROP_CONST)
17800 high.data.const_val = low.data.const_val + high.data.const_val - 1;
17802 high_bound_is_count = 1;
17806 if (attr_ub != NULL)
17807 complaint (_("Unresolved DW_AT_upper_bound "
17808 "- DIE at %s [in module %s]"),
17809 sect_offset_str (die->sect_off),
17810 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17811 if (attr_count != NULL)
17812 complaint (_("Unresolved DW_AT_count "
17813 "- DIE at %s [in module %s]"),
17814 sect_offset_str (die->sect_off),
17815 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17820 /* Dwarf-2 specifications explicitly allows to create subrange types
17821 without specifying a base type.
17822 In that case, the base type must be set to the type of
17823 the lower bound, upper bound or count, in that order, if any of these
17824 three attributes references an object that has a type.
17825 If no base type is found, the Dwarf-2 specifications say that
17826 a signed integer type of size equal to the size of an address should
17828 For the following C code: `extern char gdb_int [];'
17829 GCC produces an empty range DIE.
17830 FIXME: muller/2010-05-28: Possible references to object for low bound,
17831 high bound or count are not yet handled by this code. */
17832 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
17834 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17835 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17836 int addr_size = gdbarch_addr_bit (gdbarch) /8;
17837 struct type *int_type = objfile_type (objfile)->builtin_int;
17839 /* Test "int", "long int", and "long long int" objfile types,
17840 and select the first one having a size above or equal to the
17841 architecture address size. */
17842 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17843 base_type = int_type;
17846 int_type = objfile_type (objfile)->builtin_long;
17847 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17848 base_type = int_type;
17851 int_type = objfile_type (objfile)->builtin_long_long;
17852 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17853 base_type = int_type;
17858 /* Normally, the DWARF producers are expected to use a signed
17859 constant form (Eg. DW_FORM_sdata) to express negative bounds.
17860 But this is unfortunately not always the case, as witnessed
17861 with GCC, for instance, where the ambiguous DW_FORM_dataN form
17862 is used instead. To work around that ambiguity, we treat
17863 the bounds as signed, and thus sign-extend their values, when
17864 the base type is signed. */
17866 -((ULONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
17867 if (low.kind == PROP_CONST
17868 && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
17869 low.data.const_val |= negative_mask;
17870 if (high.kind == PROP_CONST
17871 && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
17872 high.data.const_val |= negative_mask;
17874 range_type = create_range_type (NULL, orig_base_type, &low, &high);
17876 if (high_bound_is_count)
17877 TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
17879 /* Ada expects an empty array on no boundary attributes. */
17880 if (attr == NULL && cu->language != language_ada)
17881 TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
17883 name = dwarf2_name (die, cu);
17885 TYPE_NAME (range_type) = name;
17887 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17889 TYPE_LENGTH (range_type) = DW_UNSND (attr);
17891 maybe_set_alignment (cu, die, range_type);
17893 set_die_type (die, range_type, cu);
17895 /* set_die_type should be already done. */
17896 set_descriptive_type (range_type, die, cu);
17901 static struct type *
17902 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
17906 type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
17908 TYPE_NAME (type) = dwarf2_name (die, cu);
17910 /* In Ada, an unspecified type is typically used when the description
17911 of the type is defered to a different unit. When encountering
17912 such a type, we treat it as a stub, and try to resolve it later on,
17914 if (cu->language == language_ada)
17915 TYPE_STUB (type) = 1;
17917 return set_die_type (die, type, cu);
17920 /* Read a single die and all its descendents. Set the die's sibling
17921 field to NULL; set other fields in the die correctly, and set all
17922 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
17923 location of the info_ptr after reading all of those dies. PARENT
17924 is the parent of the die in question. */
17926 static struct die_info *
17927 read_die_and_children (const struct die_reader_specs *reader,
17928 const gdb_byte *info_ptr,
17929 const gdb_byte **new_info_ptr,
17930 struct die_info *parent)
17932 struct die_info *die;
17933 const gdb_byte *cur_ptr;
17936 cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
17939 *new_info_ptr = cur_ptr;
17942 store_in_ref_table (die, reader->cu);
17945 die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
17949 *new_info_ptr = cur_ptr;
17952 die->sibling = NULL;
17953 die->parent = parent;
17957 /* Read a die, all of its descendents, and all of its siblings; set
17958 all of the fields of all of the dies correctly. Arguments are as
17959 in read_die_and_children. */
17961 static struct die_info *
17962 read_die_and_siblings_1 (const struct die_reader_specs *reader,
17963 const gdb_byte *info_ptr,
17964 const gdb_byte **new_info_ptr,
17965 struct die_info *parent)
17967 struct die_info *first_die, *last_sibling;
17968 const gdb_byte *cur_ptr;
17970 cur_ptr = info_ptr;
17971 first_die = last_sibling = NULL;
17975 struct die_info *die
17976 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
17980 *new_info_ptr = cur_ptr;
17987 last_sibling->sibling = die;
17989 last_sibling = die;
17993 /* Read a die, all of its descendents, and all of its siblings; set
17994 all of the fields of all of the dies correctly. Arguments are as
17995 in read_die_and_children.
17996 This the main entry point for reading a DIE and all its children. */
17998 static struct die_info *
17999 read_die_and_siblings (const struct die_reader_specs *reader,
18000 const gdb_byte *info_ptr,
18001 const gdb_byte **new_info_ptr,
18002 struct die_info *parent)
18004 struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
18005 new_info_ptr, parent);
18007 if (dwarf_die_debug)
18009 fprintf_unfiltered (gdb_stdlog,
18010 "Read die from %s@0x%x of %s:\n",
18011 get_section_name (reader->die_section),
18012 (unsigned) (info_ptr - reader->die_section->buffer),
18013 bfd_get_filename (reader->abfd));
18014 dump_die (die, dwarf_die_debug);
18020 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18022 The caller is responsible for filling in the extra attributes
18023 and updating (*DIEP)->num_attrs.
18024 Set DIEP to point to a newly allocated die with its information,
18025 except for its child, sibling, and parent fields.
18026 Set HAS_CHILDREN to tell whether the die has children or not. */
18028 static const gdb_byte *
18029 read_full_die_1 (const struct die_reader_specs *reader,
18030 struct die_info **diep, const gdb_byte *info_ptr,
18031 int *has_children, int num_extra_attrs)
18033 unsigned int abbrev_number, bytes_read, i;
18034 struct abbrev_info *abbrev;
18035 struct die_info *die;
18036 struct dwarf2_cu *cu = reader->cu;
18037 bfd *abfd = reader->abfd;
18039 sect_offset sect_off = (sect_offset) (info_ptr - reader->buffer);
18040 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
18041 info_ptr += bytes_read;
18042 if (!abbrev_number)
18049 abbrev = reader->abbrev_table->lookup_abbrev (abbrev_number);
18051 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18053 bfd_get_filename (abfd));
18055 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
18056 die->sect_off = sect_off;
18057 die->tag = abbrev->tag;
18058 die->abbrev = abbrev_number;
18060 /* Make the result usable.
18061 The caller needs to update num_attrs after adding the extra
18063 die->num_attrs = abbrev->num_attrs;
18065 for (i = 0; i < abbrev->num_attrs; ++i)
18066 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
18070 *has_children = abbrev->has_children;
18074 /* Read a die and all its attributes.
18075 Set DIEP to point to a newly allocated die with its information,
18076 except for its child, sibling, and parent fields.
18077 Set HAS_CHILDREN to tell whether the die has children or not. */
18079 static const gdb_byte *
18080 read_full_die (const struct die_reader_specs *reader,
18081 struct die_info **diep, const gdb_byte *info_ptr,
18084 const gdb_byte *result;
18086 result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
18088 if (dwarf_die_debug)
18090 fprintf_unfiltered (gdb_stdlog,
18091 "Read die from %s@0x%x of %s:\n",
18092 get_section_name (reader->die_section),
18093 (unsigned) (info_ptr - reader->die_section->buffer),
18094 bfd_get_filename (reader->abfd));
18095 dump_die (*diep, dwarf_die_debug);
18101 /* Abbreviation tables.
18103 In DWARF version 2, the description of the debugging information is
18104 stored in a separate .debug_abbrev section. Before we read any
18105 dies from a section we read in all abbreviations and install them
18106 in a hash table. */
18108 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18110 struct abbrev_info *
18111 abbrev_table::alloc_abbrev ()
18113 struct abbrev_info *abbrev;
18115 abbrev = XOBNEW (&abbrev_obstack, struct abbrev_info);
18116 memset (abbrev, 0, sizeof (struct abbrev_info));
18121 /* Add an abbreviation to the table. */
18124 abbrev_table::add_abbrev (unsigned int abbrev_number,
18125 struct abbrev_info *abbrev)
18127 unsigned int hash_number;
18129 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18130 abbrev->next = m_abbrevs[hash_number];
18131 m_abbrevs[hash_number] = abbrev;
18134 /* Look up an abbrev in the table.
18135 Returns NULL if the abbrev is not found. */
18137 struct abbrev_info *
18138 abbrev_table::lookup_abbrev (unsigned int abbrev_number)
18140 unsigned int hash_number;
18141 struct abbrev_info *abbrev;
18143 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18144 abbrev = m_abbrevs[hash_number];
18148 if (abbrev->number == abbrev_number)
18150 abbrev = abbrev->next;
18155 /* Read in an abbrev table. */
18157 static abbrev_table_up
18158 abbrev_table_read_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
18159 struct dwarf2_section_info *section,
18160 sect_offset sect_off)
18162 struct objfile *objfile = dwarf2_per_objfile->objfile;
18163 bfd *abfd = get_section_bfd_owner (section);
18164 const gdb_byte *abbrev_ptr;
18165 struct abbrev_info *cur_abbrev;
18166 unsigned int abbrev_number, bytes_read, abbrev_name;
18167 unsigned int abbrev_form;
18168 struct attr_abbrev *cur_attrs;
18169 unsigned int allocated_attrs;
18171 abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
18173 dwarf2_read_section (objfile, section);
18174 abbrev_ptr = section->buffer + to_underlying (sect_off);
18175 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18176 abbrev_ptr += bytes_read;
18178 allocated_attrs = ATTR_ALLOC_CHUNK;
18179 cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
18181 /* Loop until we reach an abbrev number of 0. */
18182 while (abbrev_number)
18184 cur_abbrev = abbrev_table->alloc_abbrev ();
18186 /* read in abbrev header */
18187 cur_abbrev->number = abbrev_number;
18189 = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18190 abbrev_ptr += bytes_read;
18191 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
18194 /* now read in declarations */
18197 LONGEST implicit_const;
18199 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18200 abbrev_ptr += bytes_read;
18201 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18202 abbrev_ptr += bytes_read;
18203 if (abbrev_form == DW_FORM_implicit_const)
18205 implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
18207 abbrev_ptr += bytes_read;
18211 /* Initialize it due to a false compiler warning. */
18212 implicit_const = -1;
18215 if (abbrev_name == 0)
18218 if (cur_abbrev->num_attrs == allocated_attrs)
18220 allocated_attrs += ATTR_ALLOC_CHUNK;
18222 = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
18225 cur_attrs[cur_abbrev->num_attrs].name
18226 = (enum dwarf_attribute) abbrev_name;
18227 cur_attrs[cur_abbrev->num_attrs].form
18228 = (enum dwarf_form) abbrev_form;
18229 cur_attrs[cur_abbrev->num_attrs].implicit_const = implicit_const;
18230 ++cur_abbrev->num_attrs;
18233 cur_abbrev->attrs =
18234 XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
18235 cur_abbrev->num_attrs);
18236 memcpy (cur_abbrev->attrs, cur_attrs,
18237 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
18239 abbrev_table->add_abbrev (abbrev_number, cur_abbrev);
18241 /* Get next abbreviation.
18242 Under Irix6 the abbreviations for a compilation unit are not
18243 always properly terminated with an abbrev number of 0.
18244 Exit loop if we encounter an abbreviation which we have
18245 already read (which means we are about to read the abbreviations
18246 for the next compile unit) or if the end of the abbreviation
18247 table is reached. */
18248 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
18250 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18251 abbrev_ptr += bytes_read;
18252 if (abbrev_table->lookup_abbrev (abbrev_number) != NULL)
18257 return abbrev_table;
18260 /* Returns nonzero if TAG represents a type that we might generate a partial
18264 is_type_tag_for_partial (int tag)
18269 /* Some types that would be reasonable to generate partial symbols for,
18270 that we don't at present. */
18271 case DW_TAG_array_type:
18272 case DW_TAG_file_type:
18273 case DW_TAG_ptr_to_member_type:
18274 case DW_TAG_set_type:
18275 case DW_TAG_string_type:
18276 case DW_TAG_subroutine_type:
18278 case DW_TAG_base_type:
18279 case DW_TAG_class_type:
18280 case DW_TAG_interface_type:
18281 case DW_TAG_enumeration_type:
18282 case DW_TAG_structure_type:
18283 case DW_TAG_subrange_type:
18284 case DW_TAG_typedef:
18285 case DW_TAG_union_type:
18292 /* Load all DIEs that are interesting for partial symbols into memory. */
18294 static struct partial_die_info *
18295 load_partial_dies (const struct die_reader_specs *reader,
18296 const gdb_byte *info_ptr, int building_psymtab)
18298 struct dwarf2_cu *cu = reader->cu;
18299 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18300 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
18301 unsigned int bytes_read;
18302 unsigned int load_all = 0;
18303 int nesting_level = 1;
18308 gdb_assert (cu->per_cu != NULL);
18309 if (cu->per_cu->load_all_dies)
18313 = htab_create_alloc_ex (cu->header.length / 12,
18317 &cu->comp_unit_obstack,
18318 hashtab_obstack_allocate,
18319 dummy_obstack_deallocate);
18323 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
18325 /* A NULL abbrev means the end of a series of children. */
18326 if (abbrev == NULL)
18328 if (--nesting_level == 0)
18331 info_ptr += bytes_read;
18332 last_die = parent_die;
18333 parent_die = parent_die->die_parent;
18337 /* Check for template arguments. We never save these; if
18338 they're seen, we just mark the parent, and go on our way. */
18339 if (parent_die != NULL
18340 && cu->language == language_cplus
18341 && (abbrev->tag == DW_TAG_template_type_param
18342 || abbrev->tag == DW_TAG_template_value_param))
18344 parent_die->has_template_arguments = 1;
18348 /* We don't need a partial DIE for the template argument. */
18349 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18354 /* We only recurse into c++ subprograms looking for template arguments.
18355 Skip their other children. */
18357 && cu->language == language_cplus
18358 && parent_die != NULL
18359 && parent_die->tag == DW_TAG_subprogram)
18361 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18365 /* Check whether this DIE is interesting enough to save. Normally
18366 we would not be interested in members here, but there may be
18367 later variables referencing them via DW_AT_specification (for
18368 static members). */
18370 && !is_type_tag_for_partial (abbrev->tag)
18371 && abbrev->tag != DW_TAG_constant
18372 && abbrev->tag != DW_TAG_enumerator
18373 && abbrev->tag != DW_TAG_subprogram
18374 && abbrev->tag != DW_TAG_inlined_subroutine
18375 && abbrev->tag != DW_TAG_lexical_block
18376 && abbrev->tag != DW_TAG_variable
18377 && abbrev->tag != DW_TAG_namespace
18378 && abbrev->tag != DW_TAG_module
18379 && abbrev->tag != DW_TAG_member
18380 && abbrev->tag != DW_TAG_imported_unit
18381 && abbrev->tag != DW_TAG_imported_declaration)
18383 /* Otherwise we skip to the next sibling, if any. */
18384 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18388 struct partial_die_info pdi ((sect_offset) (info_ptr - reader->buffer),
18391 info_ptr = pdi.read (reader, *abbrev, info_ptr + bytes_read);
18393 /* This two-pass algorithm for processing partial symbols has a
18394 high cost in cache pressure. Thus, handle some simple cases
18395 here which cover the majority of C partial symbols. DIEs
18396 which neither have specification tags in them, nor could have
18397 specification tags elsewhere pointing at them, can simply be
18398 processed and discarded.
18400 This segment is also optional; scan_partial_symbols and
18401 add_partial_symbol will handle these DIEs if we chain
18402 them in normally. When compilers which do not emit large
18403 quantities of duplicate debug information are more common,
18404 this code can probably be removed. */
18406 /* Any complete simple types at the top level (pretty much all
18407 of them, for a language without namespaces), can be processed
18409 if (parent_die == NULL
18410 && pdi.has_specification == 0
18411 && pdi.is_declaration == 0
18412 && ((pdi.tag == DW_TAG_typedef && !pdi.has_children)
18413 || pdi.tag == DW_TAG_base_type
18414 || pdi.tag == DW_TAG_subrange_type))
18416 if (building_psymtab && pdi.name != NULL)
18417 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18418 VAR_DOMAIN, LOC_TYPEDEF, -1,
18419 psymbol_placement::STATIC,
18420 0, cu->language, objfile);
18421 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18425 /* The exception for DW_TAG_typedef with has_children above is
18426 a workaround of GCC PR debug/47510. In the case of this complaint
18427 type_name_or_error will error on such types later.
18429 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18430 it could not find the child DIEs referenced later, this is checked
18431 above. In correct DWARF DW_TAG_typedef should have no children. */
18433 if (pdi.tag == DW_TAG_typedef && pdi.has_children)
18434 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18435 "- DIE at %s [in module %s]"),
18436 sect_offset_str (pdi.sect_off), objfile_name (objfile));
18438 /* If we're at the second level, and we're an enumerator, and
18439 our parent has no specification (meaning possibly lives in a
18440 namespace elsewhere), then we can add the partial symbol now
18441 instead of queueing it. */
18442 if (pdi.tag == DW_TAG_enumerator
18443 && parent_die != NULL
18444 && parent_die->die_parent == NULL
18445 && parent_die->tag == DW_TAG_enumeration_type
18446 && parent_die->has_specification == 0)
18448 if (pdi.name == NULL)
18449 complaint (_("malformed enumerator DIE ignored"));
18450 else if (building_psymtab)
18451 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18452 VAR_DOMAIN, LOC_CONST, -1,
18453 cu->language == language_cplus
18454 ? psymbol_placement::GLOBAL
18455 : psymbol_placement::STATIC,
18456 0, cu->language, objfile);
18458 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18462 struct partial_die_info *part_die
18463 = new (&cu->comp_unit_obstack) partial_die_info (pdi);
18465 /* We'll save this DIE so link it in. */
18466 part_die->die_parent = parent_die;
18467 part_die->die_sibling = NULL;
18468 part_die->die_child = NULL;
18470 if (last_die && last_die == parent_die)
18471 last_die->die_child = part_die;
18473 last_die->die_sibling = part_die;
18475 last_die = part_die;
18477 if (first_die == NULL)
18478 first_die = part_die;
18480 /* Maybe add the DIE to the hash table. Not all DIEs that we
18481 find interesting need to be in the hash table, because we
18482 also have the parent/sibling/child chains; only those that we
18483 might refer to by offset later during partial symbol reading.
18485 For now this means things that might have be the target of a
18486 DW_AT_specification, DW_AT_abstract_origin, or
18487 DW_AT_extension. DW_AT_extension will refer only to
18488 namespaces; DW_AT_abstract_origin refers to functions (and
18489 many things under the function DIE, but we do not recurse
18490 into function DIEs during partial symbol reading) and
18491 possibly variables as well; DW_AT_specification refers to
18492 declarations. Declarations ought to have the DW_AT_declaration
18493 flag. It happens that GCC forgets to put it in sometimes, but
18494 only for functions, not for types.
18496 Adding more things than necessary to the hash table is harmless
18497 except for the performance cost. Adding too few will result in
18498 wasted time in find_partial_die, when we reread the compilation
18499 unit with load_all_dies set. */
18502 || abbrev->tag == DW_TAG_constant
18503 || abbrev->tag == DW_TAG_subprogram
18504 || abbrev->tag == DW_TAG_variable
18505 || abbrev->tag == DW_TAG_namespace
18506 || part_die->is_declaration)
18510 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
18511 to_underlying (part_die->sect_off),
18516 /* For some DIEs we want to follow their children (if any). For C
18517 we have no reason to follow the children of structures; for other
18518 languages we have to, so that we can get at method physnames
18519 to infer fully qualified class names, for DW_AT_specification,
18520 and for C++ template arguments. For C++, we also look one level
18521 inside functions to find template arguments (if the name of the
18522 function does not already contain the template arguments).
18524 For Ada, we need to scan the children of subprograms and lexical
18525 blocks as well because Ada allows the definition of nested
18526 entities that could be interesting for the debugger, such as
18527 nested subprograms for instance. */
18528 if (last_die->has_children
18530 || last_die->tag == DW_TAG_namespace
18531 || last_die->tag == DW_TAG_module
18532 || last_die->tag == DW_TAG_enumeration_type
18533 || (cu->language == language_cplus
18534 && last_die->tag == DW_TAG_subprogram
18535 && (last_die->name == NULL
18536 || strchr (last_die->name, '<') == NULL))
18537 || (cu->language != language_c
18538 && (last_die->tag == DW_TAG_class_type
18539 || last_die->tag == DW_TAG_interface_type
18540 || last_die->tag == DW_TAG_structure_type
18541 || last_die->tag == DW_TAG_union_type))
18542 || (cu->language == language_ada
18543 && (last_die->tag == DW_TAG_subprogram
18544 || last_die->tag == DW_TAG_lexical_block))))
18547 parent_die = last_die;
18551 /* Otherwise we skip to the next sibling, if any. */
18552 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
18554 /* Back to the top, do it again. */
18558 partial_die_info::partial_die_info (sect_offset sect_off_,
18559 struct abbrev_info *abbrev)
18560 : partial_die_info (sect_off_, abbrev->tag, abbrev->has_children)
18564 /* Read a minimal amount of information into the minimal die structure.
18565 INFO_PTR should point just after the initial uleb128 of a DIE. */
18568 partial_die_info::read (const struct die_reader_specs *reader,
18569 const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
18571 struct dwarf2_cu *cu = reader->cu;
18572 struct dwarf2_per_objfile *dwarf2_per_objfile
18573 = cu->per_cu->dwarf2_per_objfile;
18575 int has_low_pc_attr = 0;
18576 int has_high_pc_attr = 0;
18577 int high_pc_relative = 0;
18579 for (i = 0; i < abbrev.num_attrs; ++i)
18581 struct attribute attr;
18583 info_ptr = read_attribute (reader, &attr, &abbrev.attrs[i], info_ptr);
18585 /* Store the data if it is of an attribute we want to keep in a
18586 partial symbol table. */
18592 case DW_TAG_compile_unit:
18593 case DW_TAG_partial_unit:
18594 case DW_TAG_type_unit:
18595 /* Compilation units have a DW_AT_name that is a filename, not
18596 a source language identifier. */
18597 case DW_TAG_enumeration_type:
18598 case DW_TAG_enumerator:
18599 /* These tags always have simple identifiers already; no need
18600 to canonicalize them. */
18601 name = DW_STRING (&attr);
18605 struct objfile *objfile = dwarf2_per_objfile->objfile;
18608 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
18609 &objfile->per_bfd->storage_obstack);
18614 case DW_AT_linkage_name:
18615 case DW_AT_MIPS_linkage_name:
18616 /* Note that both forms of linkage name might appear. We
18617 assume they will be the same, and we only store the last
18619 if (cu->language == language_ada)
18620 name = DW_STRING (&attr);
18621 linkage_name = DW_STRING (&attr);
18624 has_low_pc_attr = 1;
18625 lowpc = attr_value_as_address (&attr);
18627 case DW_AT_high_pc:
18628 has_high_pc_attr = 1;
18629 highpc = attr_value_as_address (&attr);
18630 if (cu->header.version >= 4 && attr_form_is_constant (&attr))
18631 high_pc_relative = 1;
18633 case DW_AT_location:
18634 /* Support the .debug_loc offsets. */
18635 if (attr_form_is_block (&attr))
18637 d.locdesc = DW_BLOCK (&attr);
18639 else if (attr_form_is_section_offset (&attr))
18641 dwarf2_complex_location_expr_complaint ();
18645 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18646 "partial symbol information");
18649 case DW_AT_external:
18650 is_external = DW_UNSND (&attr);
18652 case DW_AT_declaration:
18653 is_declaration = DW_UNSND (&attr);
18658 case DW_AT_abstract_origin:
18659 case DW_AT_specification:
18660 case DW_AT_extension:
18661 has_specification = 1;
18662 spec_offset = dwarf2_get_ref_die_offset (&attr);
18663 spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18664 || cu->per_cu->is_dwz);
18666 case DW_AT_sibling:
18667 /* Ignore absolute siblings, they might point outside of
18668 the current compile unit. */
18669 if (attr.form == DW_FORM_ref_addr)
18670 complaint (_("ignoring absolute DW_AT_sibling"));
18673 const gdb_byte *buffer = reader->buffer;
18674 sect_offset off = dwarf2_get_ref_die_offset (&attr);
18675 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
18677 if (sibling_ptr < info_ptr)
18678 complaint (_("DW_AT_sibling points backwards"));
18679 else if (sibling_ptr > reader->buffer_end)
18680 dwarf2_section_buffer_overflow_complaint (reader->die_section);
18682 sibling = sibling_ptr;
18685 case DW_AT_byte_size:
18688 case DW_AT_const_value:
18689 has_const_value = 1;
18691 case DW_AT_calling_convention:
18692 /* DWARF doesn't provide a way to identify a program's source-level
18693 entry point. DW_AT_calling_convention attributes are only meant
18694 to describe functions' calling conventions.
18696 However, because it's a necessary piece of information in
18697 Fortran, and before DWARF 4 DW_CC_program was the only
18698 piece of debugging information whose definition refers to
18699 a 'main program' at all, several compilers marked Fortran
18700 main programs with DW_CC_program --- even when those
18701 functions use the standard calling conventions.
18703 Although DWARF now specifies a way to provide this
18704 information, we support this practice for backward
18706 if (DW_UNSND (&attr) == DW_CC_program
18707 && cu->language == language_fortran)
18708 main_subprogram = 1;
18711 if (DW_UNSND (&attr) == DW_INL_inlined
18712 || DW_UNSND (&attr) == DW_INL_declared_inlined)
18713 may_be_inlined = 1;
18717 if (tag == DW_TAG_imported_unit)
18719 d.sect_off = dwarf2_get_ref_die_offset (&attr);
18720 is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18721 || cu->per_cu->is_dwz);
18725 case DW_AT_main_subprogram:
18726 main_subprogram = DW_UNSND (&attr);
18734 if (high_pc_relative)
18737 if (has_low_pc_attr && has_high_pc_attr)
18739 /* When using the GNU linker, .gnu.linkonce. sections are used to
18740 eliminate duplicate copies of functions and vtables and such.
18741 The linker will arbitrarily choose one and discard the others.
18742 The AT_*_pc values for such functions refer to local labels in
18743 these sections. If the section from that file was discarded, the
18744 labels are not in the output, so the relocs get a value of 0.
18745 If this is a discarded function, mark the pc bounds as invalid,
18746 so that GDB will ignore it. */
18747 if (lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
18749 struct objfile *objfile = dwarf2_per_objfile->objfile;
18750 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18752 complaint (_("DW_AT_low_pc %s is zero "
18753 "for DIE at %s [in module %s]"),
18754 paddress (gdbarch, lowpc),
18755 sect_offset_str (sect_off),
18756 objfile_name (objfile));
18758 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18759 else if (lowpc >= highpc)
18761 struct objfile *objfile = dwarf2_per_objfile->objfile;
18762 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18764 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18765 "for DIE at %s [in module %s]"),
18766 paddress (gdbarch, lowpc),
18767 paddress (gdbarch, highpc),
18768 sect_offset_str (sect_off),
18769 objfile_name (objfile));
18778 /* Find a cached partial DIE at OFFSET in CU. */
18780 struct partial_die_info *
18781 dwarf2_cu::find_partial_die (sect_offset sect_off)
18783 struct partial_die_info *lookup_die = NULL;
18784 struct partial_die_info part_die (sect_off);
18786 lookup_die = ((struct partial_die_info *)
18787 htab_find_with_hash (partial_dies, &part_die,
18788 to_underlying (sect_off)));
18793 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18794 except in the case of .debug_types DIEs which do not reference
18795 outside their CU (they do however referencing other types via
18796 DW_FORM_ref_sig8). */
18798 static struct partial_die_info *
18799 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
18801 struct dwarf2_per_objfile *dwarf2_per_objfile
18802 = cu->per_cu->dwarf2_per_objfile;
18803 struct objfile *objfile = dwarf2_per_objfile->objfile;
18804 struct dwarf2_per_cu_data *per_cu = NULL;
18805 struct partial_die_info *pd = NULL;
18807 if (offset_in_dwz == cu->per_cu->is_dwz
18808 && offset_in_cu_p (&cu->header, sect_off))
18810 pd = cu->find_partial_die (sect_off);
18813 /* We missed recording what we needed.
18814 Load all dies and try again. */
18815 per_cu = cu->per_cu;
18819 /* TUs don't reference other CUs/TUs (except via type signatures). */
18820 if (cu->per_cu->is_debug_types)
18822 error (_("Dwarf Error: Type Unit at offset %s contains"
18823 " external reference to offset %s [in module %s].\n"),
18824 sect_offset_str (cu->header.sect_off), sect_offset_str (sect_off),
18825 bfd_get_filename (objfile->obfd));
18827 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
18828 dwarf2_per_objfile);
18830 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
18831 load_partial_comp_unit (per_cu);
18833 per_cu->cu->last_used = 0;
18834 pd = per_cu->cu->find_partial_die (sect_off);
18837 /* If we didn't find it, and not all dies have been loaded,
18838 load them all and try again. */
18840 if (pd == NULL && per_cu->load_all_dies == 0)
18842 per_cu->load_all_dies = 1;
18844 /* This is nasty. When we reread the DIEs, somewhere up the call chain
18845 THIS_CU->cu may already be in use. So we can't just free it and
18846 replace its DIEs with the ones we read in. Instead, we leave those
18847 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18848 and clobber THIS_CU->cu->partial_dies with the hash table for the new
18850 load_partial_comp_unit (per_cu);
18852 pd = per_cu->cu->find_partial_die (sect_off);
18856 internal_error (__FILE__, __LINE__,
18857 _("could not find partial DIE %s "
18858 "in cache [from module %s]\n"),
18859 sect_offset_str (sect_off), bfd_get_filename (objfile->obfd));
18863 /* See if we can figure out if the class lives in a namespace. We do
18864 this by looking for a member function; its demangled name will
18865 contain namespace info, if there is any. */
18868 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
18869 struct dwarf2_cu *cu)
18871 /* NOTE: carlton/2003-10-07: Getting the info this way changes
18872 what template types look like, because the demangler
18873 frequently doesn't give the same name as the debug info. We
18874 could fix this by only using the demangled name to get the
18875 prefix (but see comment in read_structure_type). */
18877 struct partial_die_info *real_pdi;
18878 struct partial_die_info *child_pdi;
18880 /* If this DIE (this DIE's specification, if any) has a parent, then
18881 we should not do this. We'll prepend the parent's fully qualified
18882 name when we create the partial symbol. */
18884 real_pdi = struct_pdi;
18885 while (real_pdi->has_specification)
18886 real_pdi = find_partial_die (real_pdi->spec_offset,
18887 real_pdi->spec_is_dwz, cu);
18889 if (real_pdi->die_parent != NULL)
18892 for (child_pdi = struct_pdi->die_child;
18894 child_pdi = child_pdi->die_sibling)
18896 if (child_pdi->tag == DW_TAG_subprogram
18897 && child_pdi->linkage_name != NULL)
18899 char *actual_class_name
18900 = language_class_name_from_physname (cu->language_defn,
18901 child_pdi->linkage_name);
18902 if (actual_class_name != NULL)
18904 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18907 obstack_copy0 (&objfile->per_bfd->storage_obstack,
18909 strlen (actual_class_name)));
18910 xfree (actual_class_name);
18918 partial_die_info::fixup (struct dwarf2_cu *cu)
18920 /* Once we've fixed up a die, there's no point in doing so again.
18921 This also avoids a memory leak if we were to call
18922 guess_partial_die_structure_name multiple times. */
18926 /* If we found a reference attribute and the DIE has no name, try
18927 to find a name in the referred to DIE. */
18929 if (name == NULL && has_specification)
18931 struct partial_die_info *spec_die;
18933 spec_die = find_partial_die (spec_offset, spec_is_dwz, cu);
18935 spec_die->fixup (cu);
18937 if (spec_die->name)
18939 name = spec_die->name;
18941 /* Copy DW_AT_external attribute if it is set. */
18942 if (spec_die->is_external)
18943 is_external = spec_die->is_external;
18947 /* Set default names for some unnamed DIEs. */
18949 if (name == NULL && tag == DW_TAG_namespace)
18950 name = CP_ANONYMOUS_NAMESPACE_STR;
18952 /* If there is no parent die to provide a namespace, and there are
18953 children, see if we can determine the namespace from their linkage
18955 if (cu->language == language_cplus
18956 && !VEC_empty (dwarf2_section_info_def,
18957 cu->per_cu->dwarf2_per_objfile->types)
18958 && die_parent == NULL
18960 && (tag == DW_TAG_class_type
18961 || tag == DW_TAG_structure_type
18962 || tag == DW_TAG_union_type))
18963 guess_partial_die_structure_name (this, cu);
18965 /* GCC might emit a nameless struct or union that has a linkage
18966 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18968 && (tag == DW_TAG_class_type
18969 || tag == DW_TAG_interface_type
18970 || tag == DW_TAG_structure_type
18971 || tag == DW_TAG_union_type)
18972 && linkage_name != NULL)
18976 demangled = gdb_demangle (linkage_name, DMGL_TYPES);
18981 /* Strip any leading namespaces/classes, keep only the base name.
18982 DW_AT_name for named DIEs does not contain the prefixes. */
18983 base = strrchr (demangled, ':');
18984 if (base && base > demangled && base[-1] == ':')
18989 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18992 obstack_copy0 (&objfile->per_bfd->storage_obstack,
18993 base, strlen (base)));
19001 /* Read an attribute value described by an attribute form. */
19003 static const gdb_byte *
19004 read_attribute_value (const struct die_reader_specs *reader,
19005 struct attribute *attr, unsigned form,
19006 LONGEST implicit_const, const gdb_byte *info_ptr)
19008 struct dwarf2_cu *cu = reader->cu;
19009 struct dwarf2_per_objfile *dwarf2_per_objfile
19010 = cu->per_cu->dwarf2_per_objfile;
19011 struct objfile *objfile = dwarf2_per_objfile->objfile;
19012 struct gdbarch *gdbarch = get_objfile_arch (objfile);
19013 bfd *abfd = reader->abfd;
19014 struct comp_unit_head *cu_header = &cu->header;
19015 unsigned int bytes_read;
19016 struct dwarf_block *blk;
19018 attr->form = (enum dwarf_form) form;
19021 case DW_FORM_ref_addr:
19022 if (cu->header.version == 2)
19023 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19025 DW_UNSND (attr) = read_offset (abfd, info_ptr,
19026 &cu->header, &bytes_read);
19027 info_ptr += bytes_read;
19029 case DW_FORM_GNU_ref_alt:
19030 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19031 info_ptr += bytes_read;
19034 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19035 DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
19036 info_ptr += bytes_read;
19038 case DW_FORM_block2:
19039 blk = dwarf_alloc_block (cu);
19040 blk->size = read_2_bytes (abfd, info_ptr);
19042 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19043 info_ptr += blk->size;
19044 DW_BLOCK (attr) = blk;
19046 case DW_FORM_block4:
19047 blk = dwarf_alloc_block (cu);
19048 blk->size = read_4_bytes (abfd, info_ptr);
19050 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19051 info_ptr += blk->size;
19052 DW_BLOCK (attr) = blk;
19054 case DW_FORM_data2:
19055 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
19058 case DW_FORM_data4:
19059 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
19062 case DW_FORM_data8:
19063 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
19066 case DW_FORM_data16:
19067 blk = dwarf_alloc_block (cu);
19069 blk->data = read_n_bytes (abfd, info_ptr, 16);
19071 DW_BLOCK (attr) = blk;
19073 case DW_FORM_sec_offset:
19074 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19075 info_ptr += bytes_read;
19077 case DW_FORM_string:
19078 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
19079 DW_STRING_IS_CANONICAL (attr) = 0;
19080 info_ptr += bytes_read;
19083 if (!cu->per_cu->is_dwz)
19085 DW_STRING (attr) = read_indirect_string (dwarf2_per_objfile,
19086 abfd, info_ptr, cu_header,
19088 DW_STRING_IS_CANONICAL (attr) = 0;
19089 info_ptr += bytes_read;
19093 case DW_FORM_line_strp:
19094 if (!cu->per_cu->is_dwz)
19096 DW_STRING (attr) = read_indirect_line_string (dwarf2_per_objfile,
19098 cu_header, &bytes_read);
19099 DW_STRING_IS_CANONICAL (attr) = 0;
19100 info_ptr += bytes_read;
19104 case DW_FORM_GNU_strp_alt:
19106 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19107 LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
19110 DW_STRING (attr) = read_indirect_string_from_dwz (objfile,
19112 DW_STRING_IS_CANONICAL (attr) = 0;
19113 info_ptr += bytes_read;
19116 case DW_FORM_exprloc:
19117 case DW_FORM_block:
19118 blk = dwarf_alloc_block (cu);
19119 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19120 info_ptr += bytes_read;
19121 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19122 info_ptr += blk->size;
19123 DW_BLOCK (attr) = blk;
19125 case DW_FORM_block1:
19126 blk = dwarf_alloc_block (cu);
19127 blk->size = read_1_byte (abfd, info_ptr);
19129 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19130 info_ptr += blk->size;
19131 DW_BLOCK (attr) = blk;
19133 case DW_FORM_data1:
19134 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19138 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19141 case DW_FORM_flag_present:
19142 DW_UNSND (attr) = 1;
19144 case DW_FORM_sdata:
19145 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19146 info_ptr += bytes_read;
19148 case DW_FORM_udata:
19149 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19150 info_ptr += bytes_read;
19153 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19154 + read_1_byte (abfd, info_ptr));
19158 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19159 + read_2_bytes (abfd, info_ptr));
19163 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19164 + read_4_bytes (abfd, info_ptr));
19168 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19169 + read_8_bytes (abfd, info_ptr));
19172 case DW_FORM_ref_sig8:
19173 DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
19176 case DW_FORM_ref_udata:
19177 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19178 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
19179 info_ptr += bytes_read;
19181 case DW_FORM_indirect:
19182 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19183 info_ptr += bytes_read;
19184 if (form == DW_FORM_implicit_const)
19186 implicit_const = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19187 info_ptr += bytes_read;
19189 info_ptr = read_attribute_value (reader, attr, form, implicit_const,
19192 case DW_FORM_implicit_const:
19193 DW_SND (attr) = implicit_const;
19195 case DW_FORM_GNU_addr_index:
19196 if (reader->dwo_file == NULL)
19198 /* For now flag a hard error.
19199 Later we can turn this into a complaint. */
19200 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19201 dwarf_form_name (form),
19202 bfd_get_filename (abfd));
19204 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
19205 info_ptr += bytes_read;
19207 case DW_FORM_GNU_str_index:
19208 if (reader->dwo_file == NULL)
19210 /* For now flag a hard error.
19211 Later we can turn this into a complaint if warranted. */
19212 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19213 dwarf_form_name (form),
19214 bfd_get_filename (abfd));
19217 ULONGEST str_index =
19218 read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19220 DW_STRING (attr) = read_str_index (reader, str_index);
19221 DW_STRING_IS_CANONICAL (attr) = 0;
19222 info_ptr += bytes_read;
19226 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19227 dwarf_form_name (form),
19228 bfd_get_filename (abfd));
19232 if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
19233 attr->form = DW_FORM_GNU_ref_alt;
19235 /* We have seen instances where the compiler tried to emit a byte
19236 size attribute of -1 which ended up being encoded as an unsigned
19237 0xffffffff. Although 0xffffffff is technically a valid size value,
19238 an object of this size seems pretty unlikely so we can relatively
19239 safely treat these cases as if the size attribute was invalid and
19240 treat them as zero by default. */
19241 if (attr->name == DW_AT_byte_size
19242 && form == DW_FORM_data4
19243 && DW_UNSND (attr) >= 0xffffffff)
19246 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19247 hex_string (DW_UNSND (attr)));
19248 DW_UNSND (attr) = 0;
19254 /* Read an attribute described by an abbreviated attribute. */
19256 static const gdb_byte *
19257 read_attribute (const struct die_reader_specs *reader,
19258 struct attribute *attr, struct attr_abbrev *abbrev,
19259 const gdb_byte *info_ptr)
19261 attr->name = abbrev->name;
19262 return read_attribute_value (reader, attr, abbrev->form,
19263 abbrev->implicit_const, info_ptr);
19266 /* Read dwarf information from a buffer. */
19268 static unsigned int
19269 read_1_byte (bfd *abfd, const gdb_byte *buf)
19271 return bfd_get_8 (abfd, buf);
19275 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
19277 return bfd_get_signed_8 (abfd, buf);
19280 static unsigned int
19281 read_2_bytes (bfd *abfd, const gdb_byte *buf)
19283 return bfd_get_16 (abfd, buf);
19287 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
19289 return bfd_get_signed_16 (abfd, buf);
19292 static unsigned int
19293 read_4_bytes (bfd *abfd, const gdb_byte *buf)
19295 return bfd_get_32 (abfd, buf);
19299 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
19301 return bfd_get_signed_32 (abfd, buf);
19305 read_8_bytes (bfd *abfd, const gdb_byte *buf)
19307 return bfd_get_64 (abfd, buf);
19311 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
19312 unsigned int *bytes_read)
19314 struct comp_unit_head *cu_header = &cu->header;
19315 CORE_ADDR retval = 0;
19317 if (cu_header->signed_addr_p)
19319 switch (cu_header->addr_size)
19322 retval = bfd_get_signed_16 (abfd, buf);
19325 retval = bfd_get_signed_32 (abfd, buf);
19328 retval = bfd_get_signed_64 (abfd, buf);
19331 internal_error (__FILE__, __LINE__,
19332 _("read_address: bad switch, signed [in module %s]"),
19333 bfd_get_filename (abfd));
19338 switch (cu_header->addr_size)
19341 retval = bfd_get_16 (abfd, buf);
19344 retval = bfd_get_32 (abfd, buf);
19347 retval = bfd_get_64 (abfd, buf);
19350 internal_error (__FILE__, __LINE__,
19351 _("read_address: bad switch, "
19352 "unsigned [in module %s]"),
19353 bfd_get_filename (abfd));
19357 *bytes_read = cu_header->addr_size;
19361 /* Read the initial length from a section. The (draft) DWARF 3
19362 specification allows the initial length to take up either 4 bytes
19363 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19364 bytes describe the length and all offsets will be 8 bytes in length
19367 An older, non-standard 64-bit format is also handled by this
19368 function. The older format in question stores the initial length
19369 as an 8-byte quantity without an escape value. Lengths greater
19370 than 2^32 aren't very common which means that the initial 4 bytes
19371 is almost always zero. Since a length value of zero doesn't make
19372 sense for the 32-bit format, this initial zero can be considered to
19373 be an escape value which indicates the presence of the older 64-bit
19374 format. As written, the code can't detect (old format) lengths
19375 greater than 4GB. If it becomes necessary to handle lengths
19376 somewhat larger than 4GB, we could allow other small values (such
19377 as the non-sensical values of 1, 2, and 3) to also be used as
19378 escape values indicating the presence of the old format.
19380 The value returned via bytes_read should be used to increment the
19381 relevant pointer after calling read_initial_length().
19383 [ Note: read_initial_length() and read_offset() are based on the
19384 document entitled "DWARF Debugging Information Format", revision
19385 3, draft 8, dated November 19, 2001. This document was obtained
19388 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19390 This document is only a draft and is subject to change. (So beware.)
19392 Details regarding the older, non-standard 64-bit format were
19393 determined empirically by examining 64-bit ELF files produced by
19394 the SGI toolchain on an IRIX 6.5 machine.
19396 - Kevin, July 16, 2002
19400 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
19402 LONGEST length = bfd_get_32 (abfd, buf);
19404 if (length == 0xffffffff)
19406 length = bfd_get_64 (abfd, buf + 4);
19409 else if (length == 0)
19411 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19412 length = bfd_get_64 (abfd, buf);
19423 /* Cover function for read_initial_length.
19424 Returns the length of the object at BUF, and stores the size of the
19425 initial length in *BYTES_READ and stores the size that offsets will be in
19427 If the initial length size is not equivalent to that specified in
19428 CU_HEADER then issue a complaint.
19429 This is useful when reading non-comp-unit headers. */
19432 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
19433 const struct comp_unit_head *cu_header,
19434 unsigned int *bytes_read,
19435 unsigned int *offset_size)
19437 LONGEST length = read_initial_length (abfd, buf, bytes_read);
19439 gdb_assert (cu_header->initial_length_size == 4
19440 || cu_header->initial_length_size == 8
19441 || cu_header->initial_length_size == 12);
19443 if (cu_header->initial_length_size != *bytes_read)
19444 complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19446 *offset_size = (*bytes_read == 4) ? 4 : 8;
19450 /* Read an offset from the data stream. The size of the offset is
19451 given by cu_header->offset_size. */
19454 read_offset (bfd *abfd, const gdb_byte *buf,
19455 const struct comp_unit_head *cu_header,
19456 unsigned int *bytes_read)
19458 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
19460 *bytes_read = cu_header->offset_size;
19464 /* Read an offset from the data stream. */
19467 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
19469 LONGEST retval = 0;
19471 switch (offset_size)
19474 retval = bfd_get_32 (abfd, buf);
19477 retval = bfd_get_64 (abfd, buf);
19480 internal_error (__FILE__, __LINE__,
19481 _("read_offset_1: bad switch [in module %s]"),
19482 bfd_get_filename (abfd));
19488 static const gdb_byte *
19489 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
19491 /* If the size of a host char is 8 bits, we can return a pointer
19492 to the buffer, otherwise we have to copy the data to a buffer
19493 allocated on the temporary obstack. */
19494 gdb_assert (HOST_CHAR_BIT == 8);
19498 static const char *
19499 read_direct_string (bfd *abfd, const gdb_byte *buf,
19500 unsigned int *bytes_read_ptr)
19502 /* If the size of a host char is 8 bits, we can return a pointer
19503 to the string, otherwise we have to copy the string to a buffer
19504 allocated on the temporary obstack. */
19505 gdb_assert (HOST_CHAR_BIT == 8);
19508 *bytes_read_ptr = 1;
19511 *bytes_read_ptr = strlen ((const char *) buf) + 1;
19512 return (const char *) buf;
19515 /* Return pointer to string at section SECT offset STR_OFFSET with error
19516 reporting strings FORM_NAME and SECT_NAME. */
19518 static const char *
19519 read_indirect_string_at_offset_from (struct objfile *objfile,
19520 bfd *abfd, LONGEST str_offset,
19521 struct dwarf2_section_info *sect,
19522 const char *form_name,
19523 const char *sect_name)
19525 dwarf2_read_section (objfile, sect);
19526 if (sect->buffer == NULL)
19527 error (_("%s used without %s section [in module %s]"),
19528 form_name, sect_name, bfd_get_filename (abfd));
19529 if (str_offset >= sect->size)
19530 error (_("%s pointing outside of %s section [in module %s]"),
19531 form_name, sect_name, bfd_get_filename (abfd));
19532 gdb_assert (HOST_CHAR_BIT == 8);
19533 if (sect->buffer[str_offset] == '\0')
19535 return (const char *) (sect->buffer + str_offset);
19538 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19540 static const char *
19541 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19542 bfd *abfd, LONGEST str_offset)
19544 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19546 &dwarf2_per_objfile->str,
19547 "DW_FORM_strp", ".debug_str");
19550 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
19552 static const char *
19553 read_indirect_line_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19554 bfd *abfd, LONGEST str_offset)
19556 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19558 &dwarf2_per_objfile->line_str,
19559 "DW_FORM_line_strp",
19560 ".debug_line_str");
19563 /* Read a string at offset STR_OFFSET in the .debug_str section from
19564 the .dwz file DWZ. Throw an error if the offset is too large. If
19565 the string consists of a single NUL byte, return NULL; otherwise
19566 return a pointer to the string. */
19568 static const char *
19569 read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz,
19570 LONGEST str_offset)
19572 dwarf2_read_section (objfile, &dwz->str);
19574 if (dwz->str.buffer == NULL)
19575 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19576 "section [in module %s]"),
19577 bfd_get_filename (dwz->dwz_bfd));
19578 if (str_offset >= dwz->str.size)
19579 error (_("DW_FORM_GNU_strp_alt pointing outside of "
19580 ".debug_str section [in module %s]"),
19581 bfd_get_filename (dwz->dwz_bfd));
19582 gdb_assert (HOST_CHAR_BIT == 8);
19583 if (dwz->str.buffer[str_offset] == '\0')
19585 return (const char *) (dwz->str.buffer + str_offset);
19588 /* Return pointer to string at .debug_str offset as read from BUF.
19589 BUF is assumed to be in a compilation unit described by CU_HEADER.
19590 Return *BYTES_READ_PTR count of bytes read from BUF. */
19592 static const char *
19593 read_indirect_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
19594 const gdb_byte *buf,
19595 const struct comp_unit_head *cu_header,
19596 unsigned int *bytes_read_ptr)
19598 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19600 return read_indirect_string_at_offset (dwarf2_per_objfile, abfd, str_offset);
19603 /* Return pointer to string at .debug_line_str offset as read from BUF.
19604 BUF is assumed to be in a compilation unit described by CU_HEADER.
19605 Return *BYTES_READ_PTR count of bytes read from BUF. */
19607 static const char *
19608 read_indirect_line_string (struct dwarf2_per_objfile *dwarf2_per_objfile,
19609 bfd *abfd, const gdb_byte *buf,
19610 const struct comp_unit_head *cu_header,
19611 unsigned int *bytes_read_ptr)
19613 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19615 return read_indirect_line_string_at_offset (dwarf2_per_objfile, abfd,
19620 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
19621 unsigned int *bytes_read_ptr)
19624 unsigned int num_read;
19626 unsigned char byte;
19633 byte = bfd_get_8 (abfd, buf);
19636 result |= ((ULONGEST) (byte & 127) << shift);
19637 if ((byte & 128) == 0)
19643 *bytes_read_ptr = num_read;
19648 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
19649 unsigned int *bytes_read_ptr)
19652 int shift, num_read;
19653 unsigned char byte;
19660 byte = bfd_get_8 (abfd, buf);
19663 result |= ((ULONGEST) (byte & 127) << shift);
19665 if ((byte & 128) == 0)
19670 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
19671 result |= -(((ULONGEST) 1) << shift);
19672 *bytes_read_ptr = num_read;
19676 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19677 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19678 ADDR_SIZE is the size of addresses from the CU header. */
19681 read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
19682 unsigned int addr_index, ULONGEST addr_base, int addr_size)
19684 struct objfile *objfile = dwarf2_per_objfile->objfile;
19685 bfd *abfd = objfile->obfd;
19686 const gdb_byte *info_ptr;
19688 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
19689 if (dwarf2_per_objfile->addr.buffer == NULL)
19690 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19691 objfile_name (objfile));
19692 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
19693 error (_("DW_FORM_addr_index pointing outside of "
19694 ".debug_addr section [in module %s]"),
19695 objfile_name (objfile));
19696 info_ptr = (dwarf2_per_objfile->addr.buffer
19697 + addr_base + addr_index * addr_size);
19698 if (addr_size == 4)
19699 return bfd_get_32 (abfd, info_ptr);
19701 return bfd_get_64 (abfd, info_ptr);
19704 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
19707 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
19709 return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
19710 cu->addr_base, cu->header.addr_size);
19713 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
19716 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
19717 unsigned int *bytes_read)
19719 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
19720 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
19722 return read_addr_index (cu, addr_index);
19725 /* Data structure to pass results from dwarf2_read_addr_index_reader
19726 back to dwarf2_read_addr_index. */
19728 struct dwarf2_read_addr_index_data
19730 ULONGEST addr_base;
19734 /* die_reader_func for dwarf2_read_addr_index. */
19737 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
19738 const gdb_byte *info_ptr,
19739 struct die_info *comp_unit_die,
19743 struct dwarf2_cu *cu = reader->cu;
19744 struct dwarf2_read_addr_index_data *aidata =
19745 (struct dwarf2_read_addr_index_data *) data;
19747 aidata->addr_base = cu->addr_base;
19748 aidata->addr_size = cu->header.addr_size;
19751 /* Given an index in .debug_addr, fetch the value.
19752 NOTE: This can be called during dwarf expression evaluation,
19753 long after the debug information has been read, and thus per_cu->cu
19754 may no longer exist. */
19757 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
19758 unsigned int addr_index)
19760 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
19761 struct dwarf2_cu *cu = per_cu->cu;
19762 ULONGEST addr_base;
19765 /* We need addr_base and addr_size.
19766 If we don't have PER_CU->cu, we have to get it.
19767 Nasty, but the alternative is storing the needed info in PER_CU,
19768 which at this point doesn't seem justified: it's not clear how frequently
19769 it would get used and it would increase the size of every PER_CU.
19770 Entry points like dwarf2_per_cu_addr_size do a similar thing
19771 so we're not in uncharted territory here.
19772 Alas we need to be a bit more complicated as addr_base is contained
19775 We don't need to read the entire CU(/TU).
19776 We just need the header and top level die.
19778 IWBN to use the aging mechanism to let us lazily later discard the CU.
19779 For now we skip this optimization. */
19783 addr_base = cu->addr_base;
19784 addr_size = cu->header.addr_size;
19788 struct dwarf2_read_addr_index_data aidata;
19790 /* Note: We can't use init_cutu_and_read_dies_simple here,
19791 we need addr_base. */
19792 init_cutu_and_read_dies (per_cu, NULL, 0, 0, false,
19793 dwarf2_read_addr_index_reader, &aidata);
19794 addr_base = aidata.addr_base;
19795 addr_size = aidata.addr_size;
19798 return read_addr_index_1 (dwarf2_per_objfile, addr_index, addr_base,
19802 /* Given a DW_FORM_GNU_str_index, fetch the string.
19803 This is only used by the Fission support. */
19805 static const char *
19806 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
19808 struct dwarf2_cu *cu = reader->cu;
19809 struct dwarf2_per_objfile *dwarf2_per_objfile
19810 = cu->per_cu->dwarf2_per_objfile;
19811 struct objfile *objfile = dwarf2_per_objfile->objfile;
19812 const char *objf_name = objfile_name (objfile);
19813 bfd *abfd = objfile->obfd;
19814 struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
19815 struct dwarf2_section_info *str_offsets_section =
19816 &reader->dwo_file->sections.str_offsets;
19817 const gdb_byte *info_ptr;
19818 ULONGEST str_offset;
19819 static const char form_name[] = "DW_FORM_GNU_str_index";
19821 dwarf2_read_section (objfile, str_section);
19822 dwarf2_read_section (objfile, str_offsets_section);
19823 if (str_section->buffer == NULL)
19824 error (_("%s used without .debug_str.dwo section"
19825 " in CU at offset %s [in module %s]"),
19826 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19827 if (str_offsets_section->buffer == NULL)
19828 error (_("%s used without .debug_str_offsets.dwo section"
19829 " in CU at offset %s [in module %s]"),
19830 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19831 if (str_index * cu->header.offset_size >= str_offsets_section->size)
19832 error (_("%s pointing outside of .debug_str_offsets.dwo"
19833 " section in CU at offset %s [in module %s]"),
19834 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19835 info_ptr = (str_offsets_section->buffer
19836 + str_index * cu->header.offset_size);
19837 if (cu->header.offset_size == 4)
19838 str_offset = bfd_get_32 (abfd, info_ptr);
19840 str_offset = bfd_get_64 (abfd, info_ptr);
19841 if (str_offset >= str_section->size)
19842 error (_("Offset from %s pointing outside of"
19843 " .debug_str.dwo section in CU at offset %s [in module %s]"),
19844 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19845 return (const char *) (str_section->buffer + str_offset);
19848 /* Return the length of an LEB128 number in BUF. */
19851 leb128_size (const gdb_byte *buf)
19853 const gdb_byte *begin = buf;
19859 if ((byte & 128) == 0)
19860 return buf - begin;
19865 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
19874 cu->language = language_c;
19877 case DW_LANG_C_plus_plus:
19878 case DW_LANG_C_plus_plus_11:
19879 case DW_LANG_C_plus_plus_14:
19880 cu->language = language_cplus;
19883 cu->language = language_d;
19885 case DW_LANG_Fortran77:
19886 case DW_LANG_Fortran90:
19887 case DW_LANG_Fortran95:
19888 case DW_LANG_Fortran03:
19889 case DW_LANG_Fortran08:
19890 cu->language = language_fortran;
19893 cu->language = language_go;
19895 case DW_LANG_Mips_Assembler:
19896 cu->language = language_asm;
19898 case DW_LANG_Ada83:
19899 case DW_LANG_Ada95:
19900 cu->language = language_ada;
19902 case DW_LANG_Modula2:
19903 cu->language = language_m2;
19905 case DW_LANG_Pascal83:
19906 cu->language = language_pascal;
19909 cu->language = language_objc;
19912 case DW_LANG_Rust_old:
19913 cu->language = language_rust;
19915 case DW_LANG_Cobol74:
19916 case DW_LANG_Cobol85:
19918 cu->language = language_minimal;
19921 cu->language_defn = language_def (cu->language);
19924 /* Return the named attribute or NULL if not there. */
19926 static struct attribute *
19927 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
19932 struct attribute *spec = NULL;
19934 for (i = 0; i < die->num_attrs; ++i)
19936 if (die->attrs[i].name == name)
19937 return &die->attrs[i];
19938 if (die->attrs[i].name == DW_AT_specification
19939 || die->attrs[i].name == DW_AT_abstract_origin)
19940 spec = &die->attrs[i];
19946 die = follow_die_ref (die, spec, &cu);
19952 /* Return the named attribute or NULL if not there,
19953 but do not follow DW_AT_specification, etc.
19954 This is for use in contexts where we're reading .debug_types dies.
19955 Following DW_AT_specification, DW_AT_abstract_origin will take us
19956 back up the chain, and we want to go down. */
19958 static struct attribute *
19959 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
19963 for (i = 0; i < die->num_attrs; ++i)
19964 if (die->attrs[i].name == name)
19965 return &die->attrs[i];
19970 /* Return the string associated with a string-typed attribute, or NULL if it
19971 is either not found or is of an incorrect type. */
19973 static const char *
19974 dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
19976 struct attribute *attr;
19977 const char *str = NULL;
19979 attr = dwarf2_attr (die, name, cu);
19983 if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp
19984 || attr->form == DW_FORM_string
19985 || attr->form == DW_FORM_GNU_str_index
19986 || attr->form == DW_FORM_GNU_strp_alt)
19987 str = DW_STRING (attr);
19989 complaint (_("string type expected for attribute %s for "
19990 "DIE at %s in module %s"),
19991 dwarf_attr_name (name), sect_offset_str (die->sect_off),
19992 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
19998 /* Return non-zero iff the attribute NAME is defined for the given DIE,
19999 and holds a non-zero value. This function should only be used for
20000 DW_FORM_flag or DW_FORM_flag_present attributes. */
20003 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
20005 struct attribute *attr = dwarf2_attr (die, name, cu);
20007 return (attr && DW_UNSND (attr));
20011 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
20013 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20014 which value is non-zero. However, we have to be careful with
20015 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20016 (via dwarf2_flag_true_p) follows this attribute. So we may
20017 end up accidently finding a declaration attribute that belongs
20018 to a different DIE referenced by the specification attribute,
20019 even though the given DIE does not have a declaration attribute. */
20020 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
20021 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
20024 /* Return the die giving the specification for DIE, if there is
20025 one. *SPEC_CU is the CU containing DIE on input, and the CU
20026 containing the return value on output. If there is no
20027 specification, but there is an abstract origin, that is
20030 static struct die_info *
20031 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
20033 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
20036 if (spec_attr == NULL)
20037 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
20039 if (spec_attr == NULL)
20042 return follow_die_ref (die, spec_attr, spec_cu);
20045 /* Stub for free_line_header to match void * callback types. */
20048 free_line_header_voidp (void *arg)
20050 struct line_header *lh = (struct line_header *) arg;
20056 line_header::add_include_dir (const char *include_dir)
20058 if (dwarf_line_debug >= 2)
20059 fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
20060 include_dirs.size () + 1, include_dir);
20062 include_dirs.push_back (include_dir);
20066 line_header::add_file_name (const char *name,
20068 unsigned int mod_time,
20069 unsigned int length)
20071 if (dwarf_line_debug >= 2)
20072 fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
20073 (unsigned) file_names.size () + 1, name);
20075 file_names.emplace_back (name, d_index, mod_time, length);
20078 /* A convenience function to find the proper .debug_line section for a CU. */
20080 static struct dwarf2_section_info *
20081 get_debug_line_section (struct dwarf2_cu *cu)
20083 struct dwarf2_section_info *section;
20084 struct dwarf2_per_objfile *dwarf2_per_objfile
20085 = cu->per_cu->dwarf2_per_objfile;
20087 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20089 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20090 section = &cu->dwo_unit->dwo_file->sections.line;
20091 else if (cu->per_cu->is_dwz)
20093 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
20095 section = &dwz->line;
20098 section = &dwarf2_per_objfile->line;
20103 /* Read directory or file name entry format, starting with byte of
20104 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20105 entries count and the entries themselves in the described entry
20109 read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
20110 bfd *abfd, const gdb_byte **bufp,
20111 struct line_header *lh,
20112 const struct comp_unit_head *cu_header,
20113 void (*callback) (struct line_header *lh,
20116 unsigned int mod_time,
20117 unsigned int length))
20119 gdb_byte format_count, formati;
20120 ULONGEST data_count, datai;
20121 const gdb_byte *buf = *bufp;
20122 const gdb_byte *format_header_data;
20123 unsigned int bytes_read;
20125 format_count = read_1_byte (abfd, buf);
20127 format_header_data = buf;
20128 for (formati = 0; formati < format_count; formati++)
20130 read_unsigned_leb128 (abfd, buf, &bytes_read);
20132 read_unsigned_leb128 (abfd, buf, &bytes_read);
20136 data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
20138 for (datai = 0; datai < data_count; datai++)
20140 const gdb_byte *format = format_header_data;
20141 struct file_entry fe;
20143 for (formati = 0; formati < format_count; formati++)
20145 ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
20146 format += bytes_read;
20148 ULONGEST form = read_unsigned_leb128 (abfd, format, &bytes_read);
20149 format += bytes_read;
20151 gdb::optional<const char *> string;
20152 gdb::optional<unsigned int> uint;
20156 case DW_FORM_string:
20157 string.emplace (read_direct_string (abfd, buf, &bytes_read));
20161 case DW_FORM_line_strp:
20162 string.emplace (read_indirect_line_string (dwarf2_per_objfile,
20169 case DW_FORM_data1:
20170 uint.emplace (read_1_byte (abfd, buf));
20174 case DW_FORM_data2:
20175 uint.emplace (read_2_bytes (abfd, buf));
20179 case DW_FORM_data4:
20180 uint.emplace (read_4_bytes (abfd, buf));
20184 case DW_FORM_data8:
20185 uint.emplace (read_8_bytes (abfd, buf));
20189 case DW_FORM_udata:
20190 uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
20194 case DW_FORM_block:
20195 /* It is valid only for DW_LNCT_timestamp which is ignored by
20200 switch (content_type)
20203 if (string.has_value ())
20206 case DW_LNCT_directory_index:
20207 if (uint.has_value ())
20208 fe.d_index = (dir_index) *uint;
20210 case DW_LNCT_timestamp:
20211 if (uint.has_value ())
20212 fe.mod_time = *uint;
20215 if (uint.has_value ())
20221 complaint (_("Unknown format content type %s"),
20222 pulongest (content_type));
20226 callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
20232 /* Read the statement program header starting at OFFSET in
20233 .debug_line, or .debug_line.dwo. Return a pointer
20234 to a struct line_header, allocated using xmalloc.
20235 Returns NULL if there is a problem reading the header, e.g., if it
20236 has a version we don't understand.
20238 NOTE: the strings in the include directory and file name tables of
20239 the returned object point into the dwarf line section buffer,
20240 and must not be freed. */
20242 static line_header_up
20243 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
20245 const gdb_byte *line_ptr;
20246 unsigned int bytes_read, offset_size;
20248 const char *cur_dir, *cur_file;
20249 struct dwarf2_section_info *section;
20251 struct dwarf2_per_objfile *dwarf2_per_objfile
20252 = cu->per_cu->dwarf2_per_objfile;
20254 section = get_debug_line_section (cu);
20255 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20256 if (section->buffer == NULL)
20258 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20259 complaint (_("missing .debug_line.dwo section"));
20261 complaint (_("missing .debug_line section"));
20265 /* We can't do this until we know the section is non-empty.
20266 Only then do we know we have such a section. */
20267 abfd = get_section_bfd_owner (section);
20269 /* Make sure that at least there's room for the total_length field.
20270 That could be 12 bytes long, but we're just going to fudge that. */
20271 if (to_underlying (sect_off) + 4 >= section->size)
20273 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20277 line_header_up lh (new line_header ());
20279 lh->sect_off = sect_off;
20280 lh->offset_in_dwz = cu->per_cu->is_dwz;
20282 line_ptr = section->buffer + to_underlying (sect_off);
20284 /* Read in the header. */
20286 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
20287 &bytes_read, &offset_size);
20288 line_ptr += bytes_read;
20289 if (line_ptr + lh->total_length > (section->buffer + section->size))
20291 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20294 lh->statement_program_end = line_ptr + lh->total_length;
20295 lh->version = read_2_bytes (abfd, line_ptr);
20297 if (lh->version > 5)
20299 /* This is a version we don't understand. The format could have
20300 changed in ways we don't handle properly so just punt. */
20301 complaint (_("unsupported version in .debug_line section"));
20304 if (lh->version >= 5)
20306 gdb_byte segment_selector_size;
20308 /* Skip address size. */
20309 read_1_byte (abfd, line_ptr);
20312 segment_selector_size = read_1_byte (abfd, line_ptr);
20314 if (segment_selector_size != 0)
20316 complaint (_("unsupported segment selector size %u "
20317 "in .debug_line section"),
20318 segment_selector_size);
20322 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
20323 line_ptr += offset_size;
20324 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
20326 if (lh->version >= 4)
20328 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
20332 lh->maximum_ops_per_instruction = 1;
20334 if (lh->maximum_ops_per_instruction == 0)
20336 lh->maximum_ops_per_instruction = 1;
20337 complaint (_("invalid maximum_ops_per_instruction "
20338 "in `.debug_line' section"));
20341 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
20343 lh->line_base = read_1_signed_byte (abfd, line_ptr);
20345 lh->line_range = read_1_byte (abfd, line_ptr);
20347 lh->opcode_base = read_1_byte (abfd, line_ptr);
20349 lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
20351 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
20352 for (i = 1; i < lh->opcode_base; ++i)
20354 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
20358 if (lh->version >= 5)
20360 /* Read directory table. */
20361 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20363 [] (struct line_header *header, const char *name,
20364 dir_index d_index, unsigned int mod_time,
20365 unsigned int length)
20367 header->add_include_dir (name);
20370 /* Read file name table. */
20371 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20373 [] (struct line_header *header, const char *name,
20374 dir_index d_index, unsigned int mod_time,
20375 unsigned int length)
20377 header->add_file_name (name, d_index, mod_time, length);
20382 /* Read directory table. */
20383 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20385 line_ptr += bytes_read;
20386 lh->add_include_dir (cur_dir);
20388 line_ptr += bytes_read;
20390 /* Read file name table. */
20391 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20393 unsigned int mod_time, length;
20396 line_ptr += bytes_read;
20397 d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20398 line_ptr += bytes_read;
20399 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20400 line_ptr += bytes_read;
20401 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20402 line_ptr += bytes_read;
20404 lh->add_file_name (cur_file, d_index, mod_time, length);
20406 line_ptr += bytes_read;
20408 lh->statement_program_start = line_ptr;
20410 if (line_ptr > (section->buffer + section->size))
20411 complaint (_("line number info header doesn't "
20412 "fit in `.debug_line' section"));
20417 /* Subroutine of dwarf_decode_lines to simplify it.
20418 Return the file name of the psymtab for included file FILE_INDEX
20419 in line header LH of PST.
20420 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20421 If space for the result is malloc'd, *NAME_HOLDER will be set.
20422 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20424 static const char *
20425 psymtab_include_file_name (const struct line_header *lh, int file_index,
20426 const struct partial_symtab *pst,
20427 const char *comp_dir,
20428 gdb::unique_xmalloc_ptr<char> *name_holder)
20430 const file_entry &fe = lh->file_names[file_index];
20431 const char *include_name = fe.name;
20432 const char *include_name_to_compare = include_name;
20433 const char *pst_filename;
20436 const char *dir_name = fe.include_dir (lh);
20438 gdb::unique_xmalloc_ptr<char> hold_compare;
20439 if (!IS_ABSOLUTE_PATH (include_name)
20440 && (dir_name != NULL || comp_dir != NULL))
20442 /* Avoid creating a duplicate psymtab for PST.
20443 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20444 Before we do the comparison, however, we need to account
20445 for DIR_NAME and COMP_DIR.
20446 First prepend dir_name (if non-NULL). If we still don't
20447 have an absolute path prepend comp_dir (if non-NULL).
20448 However, the directory we record in the include-file's
20449 psymtab does not contain COMP_DIR (to match the
20450 corresponding symtab(s)).
20455 bash$ gcc -g ./hello.c
20456 include_name = "hello.c"
20458 DW_AT_comp_dir = comp_dir = "/tmp"
20459 DW_AT_name = "./hello.c"
20463 if (dir_name != NULL)
20465 name_holder->reset (concat (dir_name, SLASH_STRING,
20466 include_name, (char *) NULL));
20467 include_name = name_holder->get ();
20468 include_name_to_compare = include_name;
20470 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
20472 hold_compare.reset (concat (comp_dir, SLASH_STRING,
20473 include_name, (char *) NULL));
20474 include_name_to_compare = hold_compare.get ();
20478 pst_filename = pst->filename;
20479 gdb::unique_xmalloc_ptr<char> copied_name;
20480 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
20482 copied_name.reset (concat (pst->dirname, SLASH_STRING,
20483 pst_filename, (char *) NULL));
20484 pst_filename = copied_name.get ();
20487 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
20491 return include_name;
20494 /* State machine to track the state of the line number program. */
20496 class lnp_state_machine
20499 /* Initialize a machine state for the start of a line number
20501 lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch, line_header *lh,
20502 bool record_lines_p);
20504 file_entry *current_file ()
20506 /* lh->file_names is 0-based, but the file name numbers in the
20507 statement program are 1-based. */
20508 return m_line_header->file_name_at (m_file);
20511 /* Record the line in the state machine. END_SEQUENCE is true if
20512 we're processing the end of a sequence. */
20513 void record_line (bool end_sequence);
20515 /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20516 nop-out rest of the lines in this sequence. */
20517 void check_line_address (struct dwarf2_cu *cu,
20518 const gdb_byte *line_ptr,
20519 CORE_ADDR unrelocated_lowpc, CORE_ADDR address);
20521 void handle_set_discriminator (unsigned int discriminator)
20523 m_discriminator = discriminator;
20524 m_line_has_non_zero_discriminator |= discriminator != 0;
20527 /* Handle DW_LNE_set_address. */
20528 void handle_set_address (CORE_ADDR baseaddr, CORE_ADDR address)
20531 address += baseaddr;
20532 m_address = gdbarch_adjust_dwarf2_line (m_gdbarch, address, false);
20535 /* Handle DW_LNS_advance_pc. */
20536 void handle_advance_pc (CORE_ADDR adjust);
20538 /* Handle a special opcode. */
20539 void handle_special_opcode (unsigned char op_code);
20541 /* Handle DW_LNS_advance_line. */
20542 void handle_advance_line (int line_delta)
20544 advance_line (line_delta);
20547 /* Handle DW_LNS_set_file. */
20548 void handle_set_file (file_name_index file);
20550 /* Handle DW_LNS_negate_stmt. */
20551 void handle_negate_stmt ()
20553 m_is_stmt = !m_is_stmt;
20556 /* Handle DW_LNS_const_add_pc. */
20557 void handle_const_add_pc ();
20559 /* Handle DW_LNS_fixed_advance_pc. */
20560 void handle_fixed_advance_pc (CORE_ADDR addr_adj)
20562 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20566 /* Handle DW_LNS_copy. */
20567 void handle_copy ()
20569 record_line (false);
20570 m_discriminator = 0;
20573 /* Handle DW_LNE_end_sequence. */
20574 void handle_end_sequence ()
20576 m_currently_recording_lines = true;
20580 /* Advance the line by LINE_DELTA. */
20581 void advance_line (int line_delta)
20583 m_line += line_delta;
20585 if (line_delta != 0)
20586 m_line_has_non_zero_discriminator = m_discriminator != 0;
20589 struct dwarf2_cu *m_cu;
20591 gdbarch *m_gdbarch;
20593 /* True if we're recording lines.
20594 Otherwise we're building partial symtabs and are just interested in
20595 finding include files mentioned by the line number program. */
20596 bool m_record_lines_p;
20598 /* The line number header. */
20599 line_header *m_line_header;
20601 /* These are part of the standard DWARF line number state machine,
20602 and initialized according to the DWARF spec. */
20604 unsigned char m_op_index = 0;
20605 /* The line table index (1-based) of the current file. */
20606 file_name_index m_file = (file_name_index) 1;
20607 unsigned int m_line = 1;
20609 /* These are initialized in the constructor. */
20611 CORE_ADDR m_address;
20613 unsigned int m_discriminator;
20615 /* Additional bits of state we need to track. */
20617 /* The last file that we called dwarf2_start_subfile for.
20618 This is only used for TLLs. */
20619 unsigned int m_last_file = 0;
20620 /* The last file a line number was recorded for. */
20621 struct subfile *m_last_subfile = NULL;
20623 /* When true, record the lines we decode. */
20624 bool m_currently_recording_lines = false;
20626 /* The last line number that was recorded, used to coalesce
20627 consecutive entries for the same line. This can happen, for
20628 example, when discriminators are present. PR 17276. */
20629 unsigned int m_last_line = 0;
20630 bool m_line_has_non_zero_discriminator = false;
20634 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust)
20636 CORE_ADDR addr_adj = (((m_op_index + adjust)
20637 / m_line_header->maximum_ops_per_instruction)
20638 * m_line_header->minimum_instruction_length);
20639 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20640 m_op_index = ((m_op_index + adjust)
20641 % m_line_header->maximum_ops_per_instruction);
20645 lnp_state_machine::handle_special_opcode (unsigned char op_code)
20647 unsigned char adj_opcode = op_code - m_line_header->opcode_base;
20648 CORE_ADDR addr_adj = (((m_op_index
20649 + (adj_opcode / m_line_header->line_range))
20650 / m_line_header->maximum_ops_per_instruction)
20651 * m_line_header->minimum_instruction_length);
20652 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20653 m_op_index = ((m_op_index + (adj_opcode / m_line_header->line_range))
20654 % m_line_header->maximum_ops_per_instruction);
20656 int line_delta = (m_line_header->line_base
20657 + (adj_opcode % m_line_header->line_range));
20658 advance_line (line_delta);
20659 record_line (false);
20660 m_discriminator = 0;
20664 lnp_state_machine::handle_set_file (file_name_index file)
20668 const file_entry *fe = current_file ();
20670 dwarf2_debug_line_missing_file_complaint ();
20671 else if (m_record_lines_p)
20673 const char *dir = fe->include_dir (m_line_header);
20675 m_last_subfile = m_cu->builder->get_current_subfile ();
20676 m_line_has_non_zero_discriminator = m_discriminator != 0;
20677 dwarf2_start_subfile (m_cu, fe->name, dir);
20682 lnp_state_machine::handle_const_add_pc ()
20685 = (255 - m_line_header->opcode_base) / m_line_header->line_range;
20688 = (((m_op_index + adjust)
20689 / m_line_header->maximum_ops_per_instruction)
20690 * m_line_header->minimum_instruction_length);
20692 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20693 m_op_index = ((m_op_index + adjust)
20694 % m_line_header->maximum_ops_per_instruction);
20697 /* Return non-zero if we should add LINE to the line number table.
20698 LINE is the line to add, LAST_LINE is the last line that was added,
20699 LAST_SUBFILE is the subfile for LAST_LINE.
20700 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20701 had a non-zero discriminator.
20703 We have to be careful in the presence of discriminators.
20704 E.g., for this line:
20706 for (i = 0; i < 100000; i++);
20708 clang can emit four line number entries for that one line,
20709 each with a different discriminator.
20710 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20712 However, we want gdb to coalesce all four entries into one.
20713 Otherwise the user could stepi into the middle of the line and
20714 gdb would get confused about whether the pc really was in the
20715 middle of the line.
20717 Things are further complicated by the fact that two consecutive
20718 line number entries for the same line is a heuristic used by gcc
20719 to denote the end of the prologue. So we can't just discard duplicate
20720 entries, we have to be selective about it. The heuristic we use is
20721 that we only collapse consecutive entries for the same line if at least
20722 one of those entries has a non-zero discriminator. PR 17276.
20724 Note: Addresses in the line number state machine can never go backwards
20725 within one sequence, thus this coalescing is ok. */
20728 dwarf_record_line_p (struct dwarf2_cu *cu,
20729 unsigned int line, unsigned int last_line,
20730 int line_has_non_zero_discriminator,
20731 struct subfile *last_subfile)
20733 if (cu->builder->get_current_subfile () != last_subfile)
20735 if (line != last_line)
20737 /* Same line for the same file that we've seen already.
20738 As a last check, for pr 17276, only record the line if the line
20739 has never had a non-zero discriminator. */
20740 if (!line_has_non_zero_discriminator)
20745 /* Use the CU's builder to record line number LINE beginning at
20746 address ADDRESS in the line table of subfile SUBFILE. */
20749 dwarf_record_line_1 (struct gdbarch *gdbarch, struct subfile *subfile,
20750 unsigned int line, CORE_ADDR address,
20751 struct dwarf2_cu *cu)
20753 CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
20755 if (dwarf_line_debug)
20757 fprintf_unfiltered (gdb_stdlog,
20758 "Recording line %u, file %s, address %s\n",
20759 line, lbasename (subfile->name),
20760 paddress (gdbarch, address));
20764 cu->builder->record_line (subfile, line, addr);
20767 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20768 Mark the end of a set of line number records.
20769 The arguments are the same as for dwarf_record_line_1.
20770 If SUBFILE is NULL the request is ignored. */
20773 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
20774 CORE_ADDR address, struct dwarf2_cu *cu)
20776 if (subfile == NULL)
20779 if (dwarf_line_debug)
20781 fprintf_unfiltered (gdb_stdlog,
20782 "Finishing current line, file %s, address %s\n",
20783 lbasename (subfile->name),
20784 paddress (gdbarch, address));
20787 dwarf_record_line_1 (gdbarch, subfile, 0, address, cu);
20791 lnp_state_machine::record_line (bool end_sequence)
20793 if (dwarf_line_debug)
20795 fprintf_unfiltered (gdb_stdlog,
20796 "Processing actual line %u: file %u,"
20797 " address %s, is_stmt %u, discrim %u\n",
20798 m_line, to_underlying (m_file),
20799 paddress (m_gdbarch, m_address),
20800 m_is_stmt, m_discriminator);
20803 file_entry *fe = current_file ();
20806 dwarf2_debug_line_missing_file_complaint ();
20807 /* For now we ignore lines not starting on an instruction boundary.
20808 But not when processing end_sequence for compatibility with the
20809 previous version of the code. */
20810 else if (m_op_index == 0 || end_sequence)
20812 fe->included_p = 1;
20813 if (m_record_lines_p && (producer_is_codewarrior (m_cu) || m_is_stmt))
20815 if (m_last_subfile != m_cu->builder->get_current_subfile ()
20818 dwarf_finish_line (m_gdbarch, m_last_subfile, m_address,
20819 m_currently_recording_lines ? m_cu : nullptr);
20824 if (dwarf_record_line_p (m_cu, m_line, m_last_line,
20825 m_line_has_non_zero_discriminator,
20828 dwarf_record_line_1 (m_gdbarch,
20829 m_cu->builder->get_current_subfile (),
20831 m_currently_recording_lines ? m_cu : nullptr);
20833 m_last_subfile = m_cu->builder->get_current_subfile ();
20834 m_last_line = m_line;
20840 lnp_state_machine::lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch,
20841 line_header *lh, bool record_lines_p)
20845 m_record_lines_p = record_lines_p;
20846 m_line_header = lh;
20848 m_currently_recording_lines = true;
20850 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20851 was a line entry for it so that the backend has a chance to adjust it
20852 and also record it in case it needs it. This is currently used by MIPS
20853 code, cf. `mips_adjust_dwarf2_line'. */
20854 m_address = gdbarch_adjust_dwarf2_line (arch, 0, 0);
20855 m_is_stmt = lh->default_is_stmt;
20856 m_discriminator = 0;
20860 lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
20861 const gdb_byte *line_ptr,
20862 CORE_ADDR unrelocated_lowpc, CORE_ADDR address)
20864 /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
20865 the pc range of the CU. However, we restrict the test to only ADDRESS
20866 values of zero to preserve GDB's previous behaviour which is to handle
20867 the specific case of a function being GC'd by the linker. */
20869 if (address == 0 && address < unrelocated_lowpc)
20871 /* This line table is for a function which has been
20872 GCd by the linker. Ignore it. PR gdb/12528 */
20874 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20875 long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
20877 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20878 line_offset, objfile_name (objfile));
20879 m_currently_recording_lines = false;
20880 /* Note: m_currently_recording_lines is left as false until we see
20881 DW_LNE_end_sequence. */
20885 /* Subroutine of dwarf_decode_lines to simplify it.
20886 Process the line number information in LH.
20887 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20888 program in order to set included_p for every referenced header. */
20891 dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
20892 const int decode_for_pst_p, CORE_ADDR lowpc)
20894 const gdb_byte *line_ptr, *extended_end;
20895 const gdb_byte *line_end;
20896 unsigned int bytes_read, extended_len;
20897 unsigned char op_code, extended_op;
20898 CORE_ADDR baseaddr;
20899 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20900 bfd *abfd = objfile->obfd;
20901 struct gdbarch *gdbarch = get_objfile_arch (objfile);
20902 /* True if we're recording line info (as opposed to building partial
20903 symtabs and just interested in finding include files mentioned by
20904 the line number program). */
20905 bool record_lines_p = !decode_for_pst_p;
20907 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
20909 line_ptr = lh->statement_program_start;
20910 line_end = lh->statement_program_end;
20912 /* Read the statement sequences until there's nothing left. */
20913 while (line_ptr < line_end)
20915 /* The DWARF line number program state machine. Reset the state
20916 machine at the start of each sequence. */
20917 lnp_state_machine state_machine (cu, gdbarch, lh, record_lines_p);
20918 bool end_sequence = false;
20920 if (record_lines_p)
20922 /* Start a subfile for the current file of the state
20924 const file_entry *fe = state_machine.current_file ();
20927 dwarf2_start_subfile (cu, fe->name, fe->include_dir (lh));
20930 /* Decode the table. */
20931 while (line_ptr < line_end && !end_sequence)
20933 op_code = read_1_byte (abfd, line_ptr);
20936 if (op_code >= lh->opcode_base)
20938 /* Special opcode. */
20939 state_machine.handle_special_opcode (op_code);
20941 else switch (op_code)
20943 case DW_LNS_extended_op:
20944 extended_len = read_unsigned_leb128 (abfd, line_ptr,
20946 line_ptr += bytes_read;
20947 extended_end = line_ptr + extended_len;
20948 extended_op = read_1_byte (abfd, line_ptr);
20950 switch (extended_op)
20952 case DW_LNE_end_sequence:
20953 state_machine.handle_end_sequence ();
20954 end_sequence = true;
20956 case DW_LNE_set_address:
20959 = read_address (abfd, line_ptr, cu, &bytes_read);
20960 line_ptr += bytes_read;
20962 state_machine.check_line_address (cu, line_ptr,
20963 lowpc - baseaddr, address);
20964 state_machine.handle_set_address (baseaddr, address);
20967 case DW_LNE_define_file:
20969 const char *cur_file;
20970 unsigned int mod_time, length;
20973 cur_file = read_direct_string (abfd, line_ptr,
20975 line_ptr += bytes_read;
20976 dindex = (dir_index)
20977 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20978 line_ptr += bytes_read;
20980 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20981 line_ptr += bytes_read;
20983 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20984 line_ptr += bytes_read;
20985 lh->add_file_name (cur_file, dindex, mod_time, length);
20988 case DW_LNE_set_discriminator:
20990 /* The discriminator is not interesting to the
20991 debugger; just ignore it. We still need to
20992 check its value though:
20993 if there are consecutive entries for the same
20994 (non-prologue) line we want to coalesce them.
20997 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20998 line_ptr += bytes_read;
21000 state_machine.handle_set_discriminator (discr);
21004 complaint (_("mangled .debug_line section"));
21007 /* Make sure that we parsed the extended op correctly. If e.g.
21008 we expected a different address size than the producer used,
21009 we may have read the wrong number of bytes. */
21010 if (line_ptr != extended_end)
21012 complaint (_("mangled .debug_line section"));
21017 state_machine.handle_copy ();
21019 case DW_LNS_advance_pc:
21022 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21023 line_ptr += bytes_read;
21025 state_machine.handle_advance_pc (adjust);
21028 case DW_LNS_advance_line:
21031 = read_signed_leb128 (abfd, line_ptr, &bytes_read);
21032 line_ptr += bytes_read;
21034 state_machine.handle_advance_line (line_delta);
21037 case DW_LNS_set_file:
21039 file_name_index file
21040 = (file_name_index) read_unsigned_leb128 (abfd, line_ptr,
21042 line_ptr += bytes_read;
21044 state_machine.handle_set_file (file);
21047 case DW_LNS_set_column:
21048 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21049 line_ptr += bytes_read;
21051 case DW_LNS_negate_stmt:
21052 state_machine.handle_negate_stmt ();
21054 case DW_LNS_set_basic_block:
21056 /* Add to the address register of the state machine the
21057 address increment value corresponding to special opcode
21058 255. I.e., this value is scaled by the minimum
21059 instruction length since special opcode 255 would have
21060 scaled the increment. */
21061 case DW_LNS_const_add_pc:
21062 state_machine.handle_const_add_pc ();
21064 case DW_LNS_fixed_advance_pc:
21066 CORE_ADDR addr_adj = read_2_bytes (abfd, line_ptr);
21069 state_machine.handle_fixed_advance_pc (addr_adj);
21074 /* Unknown standard opcode, ignore it. */
21077 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
21079 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21080 line_ptr += bytes_read;
21087 dwarf2_debug_line_missing_end_sequence_complaint ();
21089 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21090 in which case we still finish recording the last line). */
21091 state_machine.record_line (true);
21095 /* Decode the Line Number Program (LNP) for the given line_header
21096 structure and CU. The actual information extracted and the type
21097 of structures created from the LNP depends on the value of PST.
21099 1. If PST is NULL, then this procedure uses the data from the program
21100 to create all necessary symbol tables, and their linetables.
21102 2. If PST is not NULL, this procedure reads the program to determine
21103 the list of files included by the unit represented by PST, and
21104 builds all the associated partial symbol tables.
21106 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21107 It is used for relative paths in the line table.
21108 NOTE: When processing partial symtabs (pst != NULL),
21109 comp_dir == pst->dirname.
21111 NOTE: It is important that psymtabs have the same file name (via strcmp)
21112 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21113 symtab we don't use it in the name of the psymtabs we create.
21114 E.g. expand_line_sal requires this when finding psymtabs to expand.
21115 A good testcase for this is mb-inline.exp.
21117 LOWPC is the lowest address in CU (or 0 if not known).
21119 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21120 for its PC<->lines mapping information. Otherwise only the filename
21121 table is read in. */
21124 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
21125 struct dwarf2_cu *cu, struct partial_symtab *pst,
21126 CORE_ADDR lowpc, int decode_mapping)
21128 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21129 const int decode_for_pst_p = (pst != NULL);
21131 if (decode_mapping)
21132 dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
21134 if (decode_for_pst_p)
21138 /* Now that we're done scanning the Line Header Program, we can
21139 create the psymtab of each included file. */
21140 for (file_index = 0; file_index < lh->file_names.size (); file_index++)
21141 if (lh->file_names[file_index].included_p == 1)
21143 gdb::unique_xmalloc_ptr<char> name_holder;
21144 const char *include_name =
21145 psymtab_include_file_name (lh, file_index, pst, comp_dir,
21147 if (include_name != NULL)
21148 dwarf2_create_include_psymtab (include_name, pst, objfile);
21153 /* Make sure a symtab is created for every file, even files
21154 which contain only variables (i.e. no code with associated
21156 struct compunit_symtab *cust = cu->builder->get_compunit_symtab ();
21159 for (i = 0; i < lh->file_names.size (); i++)
21161 file_entry &fe = lh->file_names[i];
21163 dwarf2_start_subfile (cu, fe.name, fe.include_dir (lh));
21165 if (cu->builder->get_current_subfile ()->symtab == NULL)
21167 cu->builder->get_current_subfile ()->symtab
21168 = allocate_symtab (cust,
21169 cu->builder->get_current_subfile ()->name);
21171 fe.symtab = cu->builder->get_current_subfile ()->symtab;
21176 /* Start a subfile for DWARF. FILENAME is the name of the file and
21177 DIRNAME the name of the source directory which contains FILENAME
21178 or NULL if not known.
21179 This routine tries to keep line numbers from identical absolute and
21180 relative file names in a common subfile.
21182 Using the `list' example from the GDB testsuite, which resides in
21183 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21184 of /srcdir/list0.c yields the following debugging information for list0.c:
21186 DW_AT_name: /srcdir/list0.c
21187 DW_AT_comp_dir: /compdir
21188 files.files[0].name: list0.h
21189 files.files[0].dir: /srcdir
21190 files.files[1].name: list0.c
21191 files.files[1].dir: /srcdir
21193 The line number information for list0.c has to end up in a single
21194 subfile, so that `break /srcdir/list0.c:1' works as expected.
21195 start_subfile will ensure that this happens provided that we pass the
21196 concatenation of files.files[1].dir and files.files[1].name as the
21200 dwarf2_start_subfile (struct dwarf2_cu *cu, const char *filename,
21201 const char *dirname)
21205 /* In order not to lose the line information directory,
21206 we concatenate it to the filename when it makes sense.
21207 Note that the Dwarf3 standard says (speaking of filenames in line
21208 information): ``The directory index is ignored for file names
21209 that represent full path names''. Thus ignoring dirname in the
21210 `else' branch below isn't an issue. */
21212 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
21214 copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
21218 cu->builder->start_subfile (filename);
21224 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21225 buildsym_compunit constructor. */
21227 static struct compunit_symtab *
21228 dwarf2_start_symtab (struct dwarf2_cu *cu,
21229 const char *name, const char *comp_dir, CORE_ADDR low_pc)
21231 gdb_assert (cu->builder == nullptr);
21233 cu->builder.reset (new struct buildsym_compunit
21234 (cu->per_cu->dwarf2_per_objfile->objfile,
21235 name, comp_dir, cu->language, low_pc));
21237 cu->list_in_scope = cu->builder->get_file_symbols ();
21239 cu->builder->record_debugformat ("DWARF 2");
21240 cu->builder->record_producer (cu->producer);
21242 cu->processing_has_namespace_info = false;
21244 return cu->builder->get_compunit_symtab ();
21248 var_decode_location (struct attribute *attr, struct symbol *sym,
21249 struct dwarf2_cu *cu)
21251 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21252 struct comp_unit_head *cu_header = &cu->header;
21254 /* NOTE drow/2003-01-30: There used to be a comment and some special
21255 code here to turn a symbol with DW_AT_external and a
21256 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21257 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21258 with some versions of binutils) where shared libraries could have
21259 relocations against symbols in their debug information - the
21260 minimal symbol would have the right address, but the debug info
21261 would not. It's no longer necessary, because we will explicitly
21262 apply relocations when we read in the debug information now. */
21264 /* A DW_AT_location attribute with no contents indicates that a
21265 variable has been optimized away. */
21266 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
21268 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21272 /* Handle one degenerate form of location expression specially, to
21273 preserve GDB's previous behavior when section offsets are
21274 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
21275 then mark this symbol as LOC_STATIC. */
21277 if (attr_form_is_block (attr)
21278 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
21279 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
21280 || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
21281 && (DW_BLOCK (attr)->size
21282 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
21284 unsigned int dummy;
21286 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
21287 SYMBOL_VALUE_ADDRESS (sym) =
21288 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
21290 SYMBOL_VALUE_ADDRESS (sym) =
21291 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
21292 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
21293 fixup_symbol_section (sym, objfile);
21294 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
21295 SYMBOL_SECTION (sym));
21299 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21300 expression evaluator, and use LOC_COMPUTED only when necessary
21301 (i.e. when the value of a register or memory location is
21302 referenced, or a thread-local block, etc.). Then again, it might
21303 not be worthwhile. I'm assuming that it isn't unless performance
21304 or memory numbers show me otherwise. */
21306 dwarf2_symbol_mark_computed (attr, sym, cu, 0);
21308 if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
21309 cu->has_loclist = true;
21312 /* Given a pointer to a DWARF information entry, figure out if we need
21313 to make a symbol table entry for it, and if so, create a new entry
21314 and return a pointer to it.
21315 If TYPE is NULL, determine symbol type from the die, otherwise
21316 used the passed type.
21317 If SPACE is not NULL, use it to hold the new symbol. If it is
21318 NULL, allocate a new symbol on the objfile's obstack. */
21320 static struct symbol *
21321 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
21322 struct symbol *space)
21324 struct dwarf2_per_objfile *dwarf2_per_objfile
21325 = cu->per_cu->dwarf2_per_objfile;
21326 struct objfile *objfile = dwarf2_per_objfile->objfile;
21327 struct gdbarch *gdbarch = get_objfile_arch (objfile);
21328 struct symbol *sym = NULL;
21330 struct attribute *attr = NULL;
21331 struct attribute *attr2 = NULL;
21332 CORE_ADDR baseaddr;
21333 struct pending **list_to_add = NULL;
21335 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
21337 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21339 name = dwarf2_name (die, cu);
21342 const char *linkagename;
21343 int suppress_add = 0;
21348 sym = allocate_symbol (objfile);
21349 OBJSTAT (objfile, n_syms++);
21351 /* Cache this symbol's name and the name's demangled form (if any). */
21352 SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
21353 linkagename = dwarf2_physname (name, die, cu);
21354 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
21356 /* Fortran does not have mangling standard and the mangling does differ
21357 between gfortran, iFort etc. */
21358 if (cu->language == language_fortran
21359 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
21360 symbol_set_demangled_name (&(sym->ginfo),
21361 dwarf2_full_name (name, die, cu),
21364 /* Default assumptions.
21365 Use the passed type or decode it from the die. */
21366 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21367 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21369 SYMBOL_TYPE (sym) = type;
21371 SYMBOL_TYPE (sym) = die_type (die, cu);
21372 attr = dwarf2_attr (die,
21373 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
21377 SYMBOL_LINE (sym) = DW_UNSND (attr);
21380 attr = dwarf2_attr (die,
21381 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
21385 file_name_index file_index = (file_name_index) DW_UNSND (attr);
21386 struct file_entry *fe;
21388 if (cu->line_header != NULL)
21389 fe = cu->line_header->file_name_at (file_index);
21394 complaint (_("file index out of range"));
21396 symbol_set_symtab (sym, fe->symtab);
21402 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
21407 addr = attr_value_as_address (attr);
21408 addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
21409 SYMBOL_VALUE_ADDRESS (sym) = addr;
21411 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
21412 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
21413 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
21414 add_symbol_to_list (sym, cu->list_in_scope);
21416 case DW_TAG_subprogram:
21417 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21419 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21420 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21421 if ((attr2 && (DW_UNSND (attr2) != 0))
21422 || cu->language == language_ada)
21424 /* Subprograms marked external are stored as a global symbol.
21425 Ada subprograms, whether marked external or not, are always
21426 stored as a global symbol, because we want to be able to
21427 access them globally. For instance, we want to be able
21428 to break on a nested subprogram without having to
21429 specify the context. */
21430 list_to_add = cu->builder->get_global_symbols ();
21434 list_to_add = cu->list_in_scope;
21437 case DW_TAG_inlined_subroutine:
21438 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21440 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21441 SYMBOL_INLINED (sym) = 1;
21442 list_to_add = cu->list_in_scope;
21444 case DW_TAG_template_value_param:
21446 /* Fall through. */
21447 case DW_TAG_constant:
21448 case DW_TAG_variable:
21449 case DW_TAG_member:
21450 /* Compilation with minimal debug info may result in
21451 variables with missing type entries. Change the
21452 misleading `void' type to something sensible. */
21453 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
21454 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
21456 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21457 /* In the case of DW_TAG_member, we should only be called for
21458 static const members. */
21459 if (die->tag == DW_TAG_member)
21461 /* dwarf2_add_field uses die_is_declaration,
21462 so we do the same. */
21463 gdb_assert (die_is_declaration (die, cu));
21468 dwarf2_const_value (attr, sym, cu);
21469 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21472 if (attr2 && (DW_UNSND (attr2) != 0))
21473 list_to_add = cu->builder->get_global_symbols ();
21475 list_to_add = cu->list_in_scope;
21479 attr = dwarf2_attr (die, DW_AT_location, cu);
21482 var_decode_location (attr, sym, cu);
21483 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21485 /* Fortran explicitly imports any global symbols to the local
21486 scope by DW_TAG_common_block. */
21487 if (cu->language == language_fortran && die->parent
21488 && die->parent->tag == DW_TAG_common_block)
21491 if (SYMBOL_CLASS (sym) == LOC_STATIC
21492 && SYMBOL_VALUE_ADDRESS (sym) == 0
21493 && !dwarf2_per_objfile->has_section_at_zero)
21495 /* When a static variable is eliminated by the linker,
21496 the corresponding debug information is not stripped
21497 out, but the variable address is set to null;
21498 do not add such variables into symbol table. */
21500 else if (attr2 && (DW_UNSND (attr2) != 0))
21502 /* Workaround gfortran PR debug/40040 - it uses
21503 DW_AT_location for variables in -fPIC libraries which may
21504 get overriden by other libraries/executable and get
21505 a different address. Resolve it by the minimal symbol
21506 which may come from inferior's executable using copy
21507 relocation. Make this workaround only for gfortran as for
21508 other compilers GDB cannot guess the minimal symbol
21509 Fortran mangling kind. */
21510 if (cu->language == language_fortran && die->parent
21511 && die->parent->tag == DW_TAG_module
21513 && startswith (cu->producer, "GNU Fortran"))
21514 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21516 /* A variable with DW_AT_external is never static,
21517 but it may be block-scoped. */
21519 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21520 ? cu->builder->get_global_symbols ()
21521 : cu->list_in_scope);
21524 list_to_add = cu->list_in_scope;
21528 /* We do not know the address of this symbol.
21529 If it is an external symbol and we have type information
21530 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21531 The address of the variable will then be determined from
21532 the minimal symbol table whenever the variable is
21534 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21536 /* Fortran explicitly imports any global symbols to the local
21537 scope by DW_TAG_common_block. */
21538 if (cu->language == language_fortran && die->parent
21539 && die->parent->tag == DW_TAG_common_block)
21541 /* SYMBOL_CLASS doesn't matter here because
21542 read_common_block is going to reset it. */
21544 list_to_add = cu->list_in_scope;
21546 else if (attr2 && (DW_UNSND (attr2) != 0)
21547 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
21549 /* A variable with DW_AT_external is never static, but it
21550 may be block-scoped. */
21552 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21553 ? cu->builder->get_global_symbols ()
21554 : cu->list_in_scope);
21556 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21558 else if (!die_is_declaration (die, cu))
21560 /* Use the default LOC_OPTIMIZED_OUT class. */
21561 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
21563 list_to_add = cu->list_in_scope;
21567 case DW_TAG_formal_parameter:
21569 /* If we are inside a function, mark this as an argument. If
21570 not, we might be looking at an argument to an inlined function
21571 when we do not have enough information to show inlined frames;
21572 pretend it's a local variable in that case so that the user can
21574 struct context_stack *curr
21575 = cu->builder->get_current_context_stack ();
21576 if (curr != nullptr && curr->name != nullptr)
21577 SYMBOL_IS_ARGUMENT (sym) = 1;
21578 attr = dwarf2_attr (die, DW_AT_location, cu);
21581 var_decode_location (attr, sym, cu);
21583 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21586 dwarf2_const_value (attr, sym, cu);
21589 list_to_add = cu->list_in_scope;
21592 case DW_TAG_unspecified_parameters:
21593 /* From varargs functions; gdb doesn't seem to have any
21594 interest in this information, so just ignore it for now.
21597 case DW_TAG_template_type_param:
21599 /* Fall through. */
21600 case DW_TAG_class_type:
21601 case DW_TAG_interface_type:
21602 case DW_TAG_structure_type:
21603 case DW_TAG_union_type:
21604 case DW_TAG_set_type:
21605 case DW_TAG_enumeration_type:
21606 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21607 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
21610 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21611 really ever be static objects: otherwise, if you try
21612 to, say, break of a class's method and you're in a file
21613 which doesn't mention that class, it won't work unless
21614 the check for all static symbols in lookup_symbol_aux
21615 saves you. See the OtherFileClass tests in
21616 gdb.c++/namespace.exp. */
21621 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21622 && cu->language == language_cplus
21623 ? cu->builder->get_global_symbols ()
21624 : cu->list_in_scope);
21626 /* The semantics of C++ state that "struct foo {
21627 ... }" also defines a typedef for "foo". */
21628 if (cu->language == language_cplus
21629 || cu->language == language_ada
21630 || cu->language == language_d
21631 || cu->language == language_rust)
21633 /* The symbol's name is already allocated along
21634 with this objfile, so we don't need to
21635 duplicate it for the type. */
21636 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
21637 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
21642 case DW_TAG_typedef:
21643 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21644 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21645 list_to_add = cu->list_in_scope;
21647 case DW_TAG_base_type:
21648 case DW_TAG_subrange_type:
21649 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21650 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21651 list_to_add = cu->list_in_scope;
21653 case DW_TAG_enumerator:
21654 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21657 dwarf2_const_value (attr, sym, cu);
21660 /* NOTE: carlton/2003-11-10: See comment above in the
21661 DW_TAG_class_type, etc. block. */
21664 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21665 && cu->language == language_cplus
21666 ? cu->builder->get_global_symbols ()
21667 : cu->list_in_scope);
21670 case DW_TAG_imported_declaration:
21671 case DW_TAG_namespace:
21672 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21673 list_to_add = cu->builder->get_global_symbols ();
21675 case DW_TAG_module:
21676 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21677 SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
21678 list_to_add = cu->builder->get_global_symbols ();
21680 case DW_TAG_common_block:
21681 SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
21682 SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
21683 add_symbol_to_list (sym, cu->list_in_scope);
21686 /* Not a tag we recognize. Hopefully we aren't processing
21687 trash data, but since we must specifically ignore things
21688 we don't recognize, there is nothing else we should do at
21690 complaint (_("unsupported tag: '%s'"),
21691 dwarf_tag_name (die->tag));
21697 sym->hash_next = objfile->template_symbols;
21698 objfile->template_symbols = sym;
21699 list_to_add = NULL;
21702 if (list_to_add != NULL)
21703 add_symbol_to_list (sym, list_to_add);
21705 /* For the benefit of old versions of GCC, check for anonymous
21706 namespaces based on the demangled name. */
21707 if (!cu->processing_has_namespace_info
21708 && cu->language == language_cplus)
21709 cp_scan_for_anonymous_namespaces (cu->builder.get (), sym, objfile);
21714 /* Given an attr with a DW_FORM_dataN value in host byte order,
21715 zero-extend it as appropriate for the symbol's type. The DWARF
21716 standard (v4) is not entirely clear about the meaning of using
21717 DW_FORM_dataN for a constant with a signed type, where the type is
21718 wider than the data. The conclusion of a discussion on the DWARF
21719 list was that this is unspecified. We choose to always zero-extend
21720 because that is the interpretation long in use by GCC. */
21723 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
21724 struct dwarf2_cu *cu, LONGEST *value, int bits)
21726 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21727 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
21728 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
21729 LONGEST l = DW_UNSND (attr);
21731 if (bits < sizeof (*value) * 8)
21733 l &= ((LONGEST) 1 << bits) - 1;
21736 else if (bits == sizeof (*value) * 8)
21740 gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
21741 store_unsigned_integer (bytes, bits / 8, byte_order, l);
21748 /* Read a constant value from an attribute. Either set *VALUE, or if
21749 the value does not fit in *VALUE, set *BYTES - either already
21750 allocated on the objfile obstack, or newly allocated on OBSTACK,
21751 or, set *BATON, if we translated the constant to a location
21755 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
21756 const char *name, struct obstack *obstack,
21757 struct dwarf2_cu *cu,
21758 LONGEST *value, const gdb_byte **bytes,
21759 struct dwarf2_locexpr_baton **baton)
21761 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21762 struct comp_unit_head *cu_header = &cu->header;
21763 struct dwarf_block *blk;
21764 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
21765 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
21771 switch (attr->form)
21774 case DW_FORM_GNU_addr_index:
21778 if (TYPE_LENGTH (type) != cu_header->addr_size)
21779 dwarf2_const_value_length_mismatch_complaint (name,
21780 cu_header->addr_size,
21781 TYPE_LENGTH (type));
21782 /* Symbols of this form are reasonably rare, so we just
21783 piggyback on the existing location code rather than writing
21784 a new implementation of symbol_computed_ops. */
21785 *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
21786 (*baton)->per_cu = cu->per_cu;
21787 gdb_assert ((*baton)->per_cu);
21789 (*baton)->size = 2 + cu_header->addr_size;
21790 data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
21791 (*baton)->data = data;
21793 data[0] = DW_OP_addr;
21794 store_unsigned_integer (&data[1], cu_header->addr_size,
21795 byte_order, DW_ADDR (attr));
21796 data[cu_header->addr_size + 1] = DW_OP_stack_value;
21799 case DW_FORM_string:
21801 case DW_FORM_GNU_str_index:
21802 case DW_FORM_GNU_strp_alt:
21803 /* DW_STRING is already allocated on the objfile obstack, point
21805 *bytes = (const gdb_byte *) DW_STRING (attr);
21807 case DW_FORM_block1:
21808 case DW_FORM_block2:
21809 case DW_FORM_block4:
21810 case DW_FORM_block:
21811 case DW_FORM_exprloc:
21812 case DW_FORM_data16:
21813 blk = DW_BLOCK (attr);
21814 if (TYPE_LENGTH (type) != blk->size)
21815 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
21816 TYPE_LENGTH (type));
21817 *bytes = blk->data;
21820 /* The DW_AT_const_value attributes are supposed to carry the
21821 symbol's value "represented as it would be on the target
21822 architecture." By the time we get here, it's already been
21823 converted to host endianness, so we just need to sign- or
21824 zero-extend it as appropriate. */
21825 case DW_FORM_data1:
21826 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
21828 case DW_FORM_data2:
21829 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
21831 case DW_FORM_data4:
21832 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
21834 case DW_FORM_data8:
21835 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
21838 case DW_FORM_sdata:
21839 case DW_FORM_implicit_const:
21840 *value = DW_SND (attr);
21843 case DW_FORM_udata:
21844 *value = DW_UNSND (attr);
21848 complaint (_("unsupported const value attribute form: '%s'"),
21849 dwarf_form_name (attr->form));
21856 /* Copy constant value from an attribute to a symbol. */
21859 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
21860 struct dwarf2_cu *cu)
21862 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21864 const gdb_byte *bytes;
21865 struct dwarf2_locexpr_baton *baton;
21867 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
21868 SYMBOL_PRINT_NAME (sym),
21869 &objfile->objfile_obstack, cu,
21870 &value, &bytes, &baton);
21874 SYMBOL_LOCATION_BATON (sym) = baton;
21875 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
21877 else if (bytes != NULL)
21879 SYMBOL_VALUE_BYTES (sym) = bytes;
21880 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
21884 SYMBOL_VALUE (sym) = value;
21885 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
21889 /* Return the type of the die in question using its DW_AT_type attribute. */
21891 static struct type *
21892 die_type (struct die_info *die, struct dwarf2_cu *cu)
21894 struct attribute *type_attr;
21896 type_attr = dwarf2_attr (die, DW_AT_type, cu);
21899 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21900 /* A missing DW_AT_type represents a void type. */
21901 return objfile_type (objfile)->builtin_void;
21904 return lookup_die_type (die, type_attr, cu);
21907 /* True iff CU's producer generates GNAT Ada auxiliary information
21908 that allows to find parallel types through that information instead
21909 of having to do expensive parallel lookups by type name. */
21912 need_gnat_info (struct dwarf2_cu *cu)
21914 /* Assume that the Ada compiler was GNAT, which always produces
21915 the auxiliary information. */
21916 return (cu->language == language_ada);
21919 /* Return the auxiliary type of the die in question using its
21920 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
21921 attribute is not present. */
21923 static struct type *
21924 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
21926 struct attribute *type_attr;
21928 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
21932 return lookup_die_type (die, type_attr, cu);
21935 /* If DIE has a descriptive_type attribute, then set the TYPE's
21936 descriptive type accordingly. */
21939 set_descriptive_type (struct type *type, struct die_info *die,
21940 struct dwarf2_cu *cu)
21942 struct type *descriptive_type = die_descriptive_type (die, cu);
21944 if (descriptive_type)
21946 ALLOCATE_GNAT_AUX_TYPE (type);
21947 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
21951 /* Return the containing type of the die in question using its
21952 DW_AT_containing_type attribute. */
21954 static struct type *
21955 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
21957 struct attribute *type_attr;
21958 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21960 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
21962 error (_("Dwarf Error: Problem turning containing type into gdb type "
21963 "[in module %s]"), objfile_name (objfile));
21965 return lookup_die_type (die, type_attr, cu);
21968 /* Return an error marker type to use for the ill formed type in DIE/CU. */
21970 static struct type *
21971 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
21973 struct dwarf2_per_objfile *dwarf2_per_objfile
21974 = cu->per_cu->dwarf2_per_objfile;
21975 struct objfile *objfile = dwarf2_per_objfile->objfile;
21978 std::string message
21979 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
21980 objfile_name (objfile),
21981 sect_offset_str (cu->header.sect_off),
21982 sect_offset_str (die->sect_off));
21983 saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
21984 message.c_str (), message.length ());
21986 return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
21989 /* Look up the type of DIE in CU using its type attribute ATTR.
21990 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
21991 DW_AT_containing_type.
21992 If there is no type substitute an error marker. */
21994 static struct type *
21995 lookup_die_type (struct die_info *die, const struct attribute *attr,
21996 struct dwarf2_cu *cu)
21998 struct dwarf2_per_objfile *dwarf2_per_objfile
21999 = cu->per_cu->dwarf2_per_objfile;
22000 struct objfile *objfile = dwarf2_per_objfile->objfile;
22001 struct type *this_type;
22003 gdb_assert (attr->name == DW_AT_type
22004 || attr->name == DW_AT_GNAT_descriptive_type
22005 || attr->name == DW_AT_containing_type);
22007 /* First see if we have it cached. */
22009 if (attr->form == DW_FORM_GNU_ref_alt)
22011 struct dwarf2_per_cu_data *per_cu;
22012 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22014 per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
22015 dwarf2_per_objfile);
22016 this_type = get_die_type_at_offset (sect_off, per_cu);
22018 else if (attr_form_is_ref (attr))
22020 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22022 this_type = get_die_type_at_offset (sect_off, cu->per_cu);
22024 else if (attr->form == DW_FORM_ref_sig8)
22026 ULONGEST signature = DW_SIGNATURE (attr);
22028 return get_signatured_type (die, signature, cu);
22032 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22033 " at %s [in module %s]"),
22034 dwarf_attr_name (attr->name), sect_offset_str (die->sect_off),
22035 objfile_name (objfile));
22036 return build_error_marker_type (cu, die);
22039 /* If not cached we need to read it in. */
22041 if (this_type == NULL)
22043 struct die_info *type_die = NULL;
22044 struct dwarf2_cu *type_cu = cu;
22046 if (attr_form_is_ref (attr))
22047 type_die = follow_die_ref (die, attr, &type_cu);
22048 if (type_die == NULL)
22049 return build_error_marker_type (cu, die);
22050 /* If we find the type now, it's probably because the type came
22051 from an inter-CU reference and the type's CU got expanded before
22053 this_type = read_type_die (type_die, type_cu);
22056 /* If we still don't have a type use an error marker. */
22058 if (this_type == NULL)
22059 return build_error_marker_type (cu, die);
22064 /* Return the type in DIE, CU.
22065 Returns NULL for invalid types.
22067 This first does a lookup in die_type_hash,
22068 and only reads the die in if necessary.
22070 NOTE: This can be called when reading in partial or full symbols. */
22072 static struct type *
22073 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
22075 struct type *this_type;
22077 this_type = get_die_type (die, cu);
22081 return read_type_die_1 (die, cu);
22084 /* Read the type in DIE, CU.
22085 Returns NULL for invalid types. */
22087 static struct type *
22088 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
22090 struct type *this_type = NULL;
22094 case DW_TAG_class_type:
22095 case DW_TAG_interface_type:
22096 case DW_TAG_structure_type:
22097 case DW_TAG_union_type:
22098 this_type = read_structure_type (die, cu);
22100 case DW_TAG_enumeration_type:
22101 this_type = read_enumeration_type (die, cu);
22103 case DW_TAG_subprogram:
22104 case DW_TAG_subroutine_type:
22105 case DW_TAG_inlined_subroutine:
22106 this_type = read_subroutine_type (die, cu);
22108 case DW_TAG_array_type:
22109 this_type = read_array_type (die, cu);
22111 case DW_TAG_set_type:
22112 this_type = read_set_type (die, cu);
22114 case DW_TAG_pointer_type:
22115 this_type = read_tag_pointer_type (die, cu);
22117 case DW_TAG_ptr_to_member_type:
22118 this_type = read_tag_ptr_to_member_type (die, cu);
22120 case DW_TAG_reference_type:
22121 this_type = read_tag_reference_type (die, cu, TYPE_CODE_REF);
22123 case DW_TAG_rvalue_reference_type:
22124 this_type = read_tag_reference_type (die, cu, TYPE_CODE_RVALUE_REF);
22126 case DW_TAG_const_type:
22127 this_type = read_tag_const_type (die, cu);
22129 case DW_TAG_volatile_type:
22130 this_type = read_tag_volatile_type (die, cu);
22132 case DW_TAG_restrict_type:
22133 this_type = read_tag_restrict_type (die, cu);
22135 case DW_TAG_string_type:
22136 this_type = read_tag_string_type (die, cu);
22138 case DW_TAG_typedef:
22139 this_type = read_typedef (die, cu);
22141 case DW_TAG_subrange_type:
22142 this_type = read_subrange_type (die, cu);
22144 case DW_TAG_base_type:
22145 this_type = read_base_type (die, cu);
22147 case DW_TAG_unspecified_type:
22148 this_type = read_unspecified_type (die, cu);
22150 case DW_TAG_namespace:
22151 this_type = read_namespace_type (die, cu);
22153 case DW_TAG_module:
22154 this_type = read_module_type (die, cu);
22156 case DW_TAG_atomic_type:
22157 this_type = read_tag_atomic_type (die, cu);
22160 complaint (_("unexpected tag in read_type_die: '%s'"),
22161 dwarf_tag_name (die->tag));
22168 /* See if we can figure out if the class lives in a namespace. We do
22169 this by looking for a member function; its demangled name will
22170 contain namespace info, if there is any.
22171 Return the computed name or NULL.
22172 Space for the result is allocated on the objfile's obstack.
22173 This is the full-die version of guess_partial_die_structure_name.
22174 In this case we know DIE has no useful parent. */
22177 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
22179 struct die_info *spec_die;
22180 struct dwarf2_cu *spec_cu;
22181 struct die_info *child;
22182 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22185 spec_die = die_specification (die, &spec_cu);
22186 if (spec_die != NULL)
22192 for (child = die->child;
22194 child = child->sibling)
22196 if (child->tag == DW_TAG_subprogram)
22198 const char *linkage_name = dw2_linkage_name (child, cu);
22200 if (linkage_name != NULL)
22203 = language_class_name_from_physname (cu->language_defn,
22207 if (actual_name != NULL)
22209 const char *die_name = dwarf2_name (die, cu);
22211 if (die_name != NULL
22212 && strcmp (die_name, actual_name) != 0)
22214 /* Strip off the class name from the full name.
22215 We want the prefix. */
22216 int die_name_len = strlen (die_name);
22217 int actual_name_len = strlen (actual_name);
22219 /* Test for '::' as a sanity check. */
22220 if (actual_name_len > die_name_len + 2
22221 && actual_name[actual_name_len
22222 - die_name_len - 1] == ':')
22223 name = (char *) obstack_copy0 (
22224 &objfile->per_bfd->storage_obstack,
22225 actual_name, actual_name_len - die_name_len - 2);
22228 xfree (actual_name);
22237 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22238 prefix part in such case. See
22239 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22241 static const char *
22242 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
22244 struct attribute *attr;
22247 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
22248 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
22251 if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
22254 attr = dw2_linkage_name_attr (die, cu);
22255 if (attr == NULL || DW_STRING (attr) == NULL)
22258 /* dwarf2_name had to be already called. */
22259 gdb_assert (DW_STRING_IS_CANONICAL (attr));
22261 /* Strip the base name, keep any leading namespaces/classes. */
22262 base = strrchr (DW_STRING (attr), ':');
22263 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
22266 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22267 return (char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
22269 &base[-1] - DW_STRING (attr));
22272 /* Return the name of the namespace/class that DIE is defined within,
22273 or "" if we can't tell. The caller should not xfree the result.
22275 For example, if we're within the method foo() in the following
22285 then determine_prefix on foo's die will return "N::C". */
22287 static const char *
22288 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
22290 struct dwarf2_per_objfile *dwarf2_per_objfile
22291 = cu->per_cu->dwarf2_per_objfile;
22292 struct die_info *parent, *spec_die;
22293 struct dwarf2_cu *spec_cu;
22294 struct type *parent_type;
22295 const char *retval;
22297 if (cu->language != language_cplus
22298 && cu->language != language_fortran && cu->language != language_d
22299 && cu->language != language_rust)
22302 retval = anonymous_struct_prefix (die, cu);
22306 /* We have to be careful in the presence of DW_AT_specification.
22307 For example, with GCC 3.4, given the code
22311 // Definition of N::foo.
22315 then we'll have a tree of DIEs like this:
22317 1: DW_TAG_compile_unit
22318 2: DW_TAG_namespace // N
22319 3: DW_TAG_subprogram // declaration of N::foo
22320 4: DW_TAG_subprogram // definition of N::foo
22321 DW_AT_specification // refers to die #3
22323 Thus, when processing die #4, we have to pretend that we're in
22324 the context of its DW_AT_specification, namely the contex of die
22327 spec_die = die_specification (die, &spec_cu);
22328 if (spec_die == NULL)
22329 parent = die->parent;
22332 parent = spec_die->parent;
22336 if (parent == NULL)
22338 else if (parent->building_fullname)
22341 const char *parent_name;
22343 /* It has been seen on RealView 2.2 built binaries,
22344 DW_TAG_template_type_param types actually _defined_ as
22345 children of the parent class:
22348 template class <class Enum> Class{};
22349 Class<enum E> class_e;
22351 1: DW_TAG_class_type (Class)
22352 2: DW_TAG_enumeration_type (E)
22353 3: DW_TAG_enumerator (enum1:0)
22354 3: DW_TAG_enumerator (enum2:1)
22356 2: DW_TAG_template_type_param
22357 DW_AT_type DW_FORM_ref_udata (E)
22359 Besides being broken debug info, it can put GDB into an
22360 infinite loop. Consider:
22362 When we're building the full name for Class<E>, we'll start
22363 at Class, and go look over its template type parameters,
22364 finding E. We'll then try to build the full name of E, and
22365 reach here. We're now trying to build the full name of E,
22366 and look over the parent DIE for containing scope. In the
22367 broken case, if we followed the parent DIE of E, we'd again
22368 find Class, and once again go look at its template type
22369 arguments, etc., etc. Simply don't consider such parent die
22370 as source-level parent of this die (it can't be, the language
22371 doesn't allow it), and break the loop here. */
22372 name = dwarf2_name (die, cu);
22373 parent_name = dwarf2_name (parent, cu);
22374 complaint (_("template param type '%s' defined within parent '%s'"),
22375 name ? name : "<unknown>",
22376 parent_name ? parent_name : "<unknown>");
22380 switch (parent->tag)
22382 case DW_TAG_namespace:
22383 parent_type = read_type_die (parent, cu);
22384 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22385 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22386 Work around this problem here. */
22387 if (cu->language == language_cplus
22388 && strcmp (TYPE_NAME (parent_type), "::") == 0)
22390 /* We give a name to even anonymous namespaces. */
22391 return TYPE_NAME (parent_type);
22392 case DW_TAG_class_type:
22393 case DW_TAG_interface_type:
22394 case DW_TAG_structure_type:
22395 case DW_TAG_union_type:
22396 case DW_TAG_module:
22397 parent_type = read_type_die (parent, cu);
22398 if (TYPE_NAME (parent_type) != NULL)
22399 return TYPE_NAME (parent_type);
22401 /* An anonymous structure is only allowed non-static data
22402 members; no typedefs, no member functions, et cetera.
22403 So it does not need a prefix. */
22405 case DW_TAG_compile_unit:
22406 case DW_TAG_partial_unit:
22407 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22408 if (cu->language == language_cplus
22409 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
22410 && die->child != NULL
22411 && (die->tag == DW_TAG_class_type
22412 || die->tag == DW_TAG_structure_type
22413 || die->tag == DW_TAG_union_type))
22415 char *name = guess_full_die_structure_name (die, cu);
22420 case DW_TAG_enumeration_type:
22421 parent_type = read_type_die (parent, cu);
22422 if (TYPE_DECLARED_CLASS (parent_type))
22424 if (TYPE_NAME (parent_type) != NULL)
22425 return TYPE_NAME (parent_type);
22428 /* Fall through. */
22430 return determine_prefix (parent, cu);
22434 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22435 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22436 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22437 an obconcat, otherwise allocate storage for the result. The CU argument is
22438 used to determine the language and hence, the appropriate separator. */
22440 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22443 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
22444 int physname, struct dwarf2_cu *cu)
22446 const char *lead = "";
22449 if (suffix == NULL || suffix[0] == '\0'
22450 || prefix == NULL || prefix[0] == '\0')
22452 else if (cu->language == language_d)
22454 /* For D, the 'main' function could be defined in any module, but it
22455 should never be prefixed. */
22456 if (strcmp (suffix, "D main") == 0)
22464 else if (cu->language == language_fortran && physname)
22466 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22467 DW_AT_MIPS_linkage_name is preferred and used instead. */
22475 if (prefix == NULL)
22477 if (suffix == NULL)
22484 xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
22486 strcpy (retval, lead);
22487 strcat (retval, prefix);
22488 strcat (retval, sep);
22489 strcat (retval, suffix);
22494 /* We have an obstack. */
22495 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
22499 /* Return sibling of die, NULL if no sibling. */
22501 static struct die_info *
22502 sibling_die (struct die_info *die)
22504 return die->sibling;
22507 /* Get name of a die, return NULL if not found. */
22509 static const char *
22510 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
22511 struct obstack *obstack)
22513 if (name && cu->language == language_cplus)
22515 std::string canon_name = cp_canonicalize_string (name);
22517 if (!canon_name.empty ())
22519 if (canon_name != name)
22520 name = (const char *) obstack_copy0 (obstack,
22521 canon_name.c_str (),
22522 canon_name.length ());
22529 /* Get name of a die, return NULL if not found.
22530 Anonymous namespaces are converted to their magic string. */
22532 static const char *
22533 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
22535 struct attribute *attr;
22536 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22538 attr = dwarf2_attr (die, DW_AT_name, cu);
22539 if ((!attr || !DW_STRING (attr))
22540 && die->tag != DW_TAG_namespace
22541 && die->tag != DW_TAG_class_type
22542 && die->tag != DW_TAG_interface_type
22543 && die->tag != DW_TAG_structure_type
22544 && die->tag != DW_TAG_union_type)
22549 case DW_TAG_compile_unit:
22550 case DW_TAG_partial_unit:
22551 /* Compilation units have a DW_AT_name that is a filename, not
22552 a source language identifier. */
22553 case DW_TAG_enumeration_type:
22554 case DW_TAG_enumerator:
22555 /* These tags always have simple identifiers already; no need
22556 to canonicalize them. */
22557 return DW_STRING (attr);
22559 case DW_TAG_namespace:
22560 if (attr != NULL && DW_STRING (attr) != NULL)
22561 return DW_STRING (attr);
22562 return CP_ANONYMOUS_NAMESPACE_STR;
22564 case DW_TAG_class_type:
22565 case DW_TAG_interface_type:
22566 case DW_TAG_structure_type:
22567 case DW_TAG_union_type:
22568 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22569 structures or unions. These were of the form "._%d" in GCC 4.1,
22570 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22571 and GCC 4.4. We work around this problem by ignoring these. */
22572 if (attr && DW_STRING (attr)
22573 && (startswith (DW_STRING (attr), "._")
22574 || startswith (DW_STRING (attr), "<anonymous")))
22577 /* GCC might emit a nameless typedef that has a linkage name. See
22578 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22579 if (!attr || DW_STRING (attr) == NULL)
22581 char *demangled = NULL;
22583 attr = dw2_linkage_name_attr (die, cu);
22584 if (attr == NULL || DW_STRING (attr) == NULL)
22587 /* Avoid demangling DW_STRING (attr) the second time on a second
22588 call for the same DIE. */
22589 if (!DW_STRING_IS_CANONICAL (attr))
22590 demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
22596 /* FIXME: we already did this for the partial symbol... */
22599 obstack_copy0 (&objfile->per_bfd->storage_obstack,
22600 demangled, strlen (demangled)));
22601 DW_STRING_IS_CANONICAL (attr) = 1;
22604 /* Strip any leading namespaces/classes, keep only the base name.
22605 DW_AT_name for named DIEs does not contain the prefixes. */
22606 base = strrchr (DW_STRING (attr), ':');
22607 if (base && base > DW_STRING (attr) && base[-1] == ':')
22610 return DW_STRING (attr);
22619 if (!DW_STRING_IS_CANONICAL (attr))
22622 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
22623 &objfile->per_bfd->storage_obstack);
22624 DW_STRING_IS_CANONICAL (attr) = 1;
22626 return DW_STRING (attr);
22629 /* Return the die that this die in an extension of, or NULL if there
22630 is none. *EXT_CU is the CU containing DIE on input, and the CU
22631 containing the return value on output. */
22633 static struct die_info *
22634 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
22636 struct attribute *attr;
22638 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
22642 return follow_die_ref (die, attr, ext_cu);
22645 /* Convert a DIE tag into its string name. */
22647 static const char *
22648 dwarf_tag_name (unsigned tag)
22650 const char *name = get_DW_TAG_name (tag);
22653 return "DW_TAG_<unknown>";
22658 /* Convert a DWARF attribute code into its string name. */
22660 static const char *
22661 dwarf_attr_name (unsigned attr)
22665 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22666 if (attr == DW_AT_MIPS_fde)
22667 return "DW_AT_MIPS_fde";
22669 if (attr == DW_AT_HP_block_index)
22670 return "DW_AT_HP_block_index";
22673 name = get_DW_AT_name (attr);
22676 return "DW_AT_<unknown>";
22681 /* Convert a DWARF value form code into its string name. */
22683 static const char *
22684 dwarf_form_name (unsigned form)
22686 const char *name = get_DW_FORM_name (form);
22689 return "DW_FORM_<unknown>";
22694 static const char *
22695 dwarf_bool_name (unsigned mybool)
22703 /* Convert a DWARF type code into its string name. */
22705 static const char *
22706 dwarf_type_encoding_name (unsigned enc)
22708 const char *name = get_DW_ATE_name (enc);
22711 return "DW_ATE_<unknown>";
22717 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
22721 print_spaces (indent, f);
22722 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset %s)\n",
22723 dwarf_tag_name (die->tag), die->abbrev,
22724 sect_offset_str (die->sect_off));
22726 if (die->parent != NULL)
22728 print_spaces (indent, f);
22729 fprintf_unfiltered (f, " parent at offset: %s\n",
22730 sect_offset_str (die->parent->sect_off));
22733 print_spaces (indent, f);
22734 fprintf_unfiltered (f, " has children: %s\n",
22735 dwarf_bool_name (die->child != NULL));
22737 print_spaces (indent, f);
22738 fprintf_unfiltered (f, " attributes:\n");
22740 for (i = 0; i < die->num_attrs; ++i)
22742 print_spaces (indent, f);
22743 fprintf_unfiltered (f, " %s (%s) ",
22744 dwarf_attr_name (die->attrs[i].name),
22745 dwarf_form_name (die->attrs[i].form));
22747 switch (die->attrs[i].form)
22750 case DW_FORM_GNU_addr_index:
22751 fprintf_unfiltered (f, "address: ");
22752 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
22754 case DW_FORM_block2:
22755 case DW_FORM_block4:
22756 case DW_FORM_block:
22757 case DW_FORM_block1:
22758 fprintf_unfiltered (f, "block: size %s",
22759 pulongest (DW_BLOCK (&die->attrs[i])->size));
22761 case DW_FORM_exprloc:
22762 fprintf_unfiltered (f, "expression: size %s",
22763 pulongest (DW_BLOCK (&die->attrs[i])->size));
22765 case DW_FORM_data16:
22766 fprintf_unfiltered (f, "constant of 16 bytes");
22768 case DW_FORM_ref_addr:
22769 fprintf_unfiltered (f, "ref address: ");
22770 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22772 case DW_FORM_GNU_ref_alt:
22773 fprintf_unfiltered (f, "alt ref address: ");
22774 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22780 case DW_FORM_ref_udata:
22781 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
22782 (long) (DW_UNSND (&die->attrs[i])));
22784 case DW_FORM_data1:
22785 case DW_FORM_data2:
22786 case DW_FORM_data4:
22787 case DW_FORM_data8:
22788 case DW_FORM_udata:
22789 case DW_FORM_sdata:
22790 fprintf_unfiltered (f, "constant: %s",
22791 pulongest (DW_UNSND (&die->attrs[i])));
22793 case DW_FORM_sec_offset:
22794 fprintf_unfiltered (f, "section offset: %s",
22795 pulongest (DW_UNSND (&die->attrs[i])));
22797 case DW_FORM_ref_sig8:
22798 fprintf_unfiltered (f, "signature: %s",
22799 hex_string (DW_SIGNATURE (&die->attrs[i])));
22801 case DW_FORM_string:
22803 case DW_FORM_line_strp:
22804 case DW_FORM_GNU_str_index:
22805 case DW_FORM_GNU_strp_alt:
22806 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
22807 DW_STRING (&die->attrs[i])
22808 ? DW_STRING (&die->attrs[i]) : "",
22809 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
22812 if (DW_UNSND (&die->attrs[i]))
22813 fprintf_unfiltered (f, "flag: TRUE");
22815 fprintf_unfiltered (f, "flag: FALSE");
22817 case DW_FORM_flag_present:
22818 fprintf_unfiltered (f, "flag: TRUE");
22820 case DW_FORM_indirect:
22821 /* The reader will have reduced the indirect form to
22822 the "base form" so this form should not occur. */
22823 fprintf_unfiltered (f,
22824 "unexpected attribute form: DW_FORM_indirect");
22826 case DW_FORM_implicit_const:
22827 fprintf_unfiltered (f, "constant: %s",
22828 plongest (DW_SND (&die->attrs[i])));
22831 fprintf_unfiltered (f, "unsupported attribute form: %d.",
22832 die->attrs[i].form);
22835 fprintf_unfiltered (f, "\n");
22840 dump_die_for_error (struct die_info *die)
22842 dump_die_shallow (gdb_stderr, 0, die);
22846 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
22848 int indent = level * 4;
22850 gdb_assert (die != NULL);
22852 if (level >= max_level)
22855 dump_die_shallow (f, indent, die);
22857 if (die->child != NULL)
22859 print_spaces (indent, f);
22860 fprintf_unfiltered (f, " Children:");
22861 if (level + 1 < max_level)
22863 fprintf_unfiltered (f, "\n");
22864 dump_die_1 (f, level + 1, max_level, die->child);
22868 fprintf_unfiltered (f,
22869 " [not printed, max nesting level reached]\n");
22873 if (die->sibling != NULL && level > 0)
22875 dump_die_1 (f, level, max_level, die->sibling);
22879 /* This is called from the pdie macro in gdbinit.in.
22880 It's not static so gcc will keep a copy callable from gdb. */
22883 dump_die (struct die_info *die, int max_level)
22885 dump_die_1 (gdb_stdlog, 0, max_level, die);
22889 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
22893 slot = htab_find_slot_with_hash (cu->die_hash, die,
22894 to_underlying (die->sect_off),
22900 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
22904 dwarf2_get_ref_die_offset (const struct attribute *attr)
22906 if (attr_form_is_ref (attr))
22907 return (sect_offset) DW_UNSND (attr);
22909 complaint (_("unsupported die ref attribute form: '%s'"),
22910 dwarf_form_name (attr->form));
22914 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
22915 * the value held by the attribute is not constant. */
22918 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
22920 if (attr->form == DW_FORM_sdata || attr->form == DW_FORM_implicit_const)
22921 return DW_SND (attr);
22922 else if (attr->form == DW_FORM_udata
22923 || attr->form == DW_FORM_data1
22924 || attr->form == DW_FORM_data2
22925 || attr->form == DW_FORM_data4
22926 || attr->form == DW_FORM_data8)
22927 return DW_UNSND (attr);
22930 /* For DW_FORM_data16 see attr_form_is_constant. */
22931 complaint (_("Attribute value is not a constant (%s)"),
22932 dwarf_form_name (attr->form));
22933 return default_value;
22937 /* Follow reference or signature attribute ATTR of SRC_DIE.
22938 On entry *REF_CU is the CU of SRC_DIE.
22939 On exit *REF_CU is the CU of the result. */
22941 static struct die_info *
22942 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
22943 struct dwarf2_cu **ref_cu)
22945 struct die_info *die;
22947 if (attr_form_is_ref (attr))
22948 die = follow_die_ref (src_die, attr, ref_cu);
22949 else if (attr->form == DW_FORM_ref_sig8)
22950 die = follow_die_sig (src_die, attr, ref_cu);
22953 dump_die_for_error (src_die);
22954 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
22955 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
22961 /* Follow reference OFFSET.
22962 On entry *REF_CU is the CU of the source die referencing OFFSET.
22963 On exit *REF_CU is the CU of the result.
22964 Returns NULL if OFFSET is invalid. */
22966 static struct die_info *
22967 follow_die_offset (sect_offset sect_off, int offset_in_dwz,
22968 struct dwarf2_cu **ref_cu)
22970 struct die_info temp_die;
22971 struct dwarf2_cu *target_cu, *cu = *ref_cu;
22972 struct dwarf2_per_objfile *dwarf2_per_objfile
22973 = cu->per_cu->dwarf2_per_objfile;
22975 gdb_assert (cu->per_cu != NULL);
22979 if (cu->per_cu->is_debug_types)
22981 /* .debug_types CUs cannot reference anything outside their CU.
22982 If they need to, they have to reference a signatured type via
22983 DW_FORM_ref_sig8. */
22984 if (!offset_in_cu_p (&cu->header, sect_off))
22987 else if (offset_in_dwz != cu->per_cu->is_dwz
22988 || !offset_in_cu_p (&cu->header, sect_off))
22990 struct dwarf2_per_cu_data *per_cu;
22992 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
22993 dwarf2_per_objfile);
22995 /* If necessary, add it to the queue and load its DIEs. */
22996 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
22997 load_full_comp_unit (per_cu, false, cu->language);
22999 target_cu = per_cu->cu;
23001 else if (cu->dies == NULL)
23003 /* We're loading full DIEs during partial symbol reading. */
23004 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
23005 load_full_comp_unit (cu->per_cu, false, language_minimal);
23008 *ref_cu = target_cu;
23009 temp_die.sect_off = sect_off;
23010 return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
23012 to_underlying (sect_off));
23015 /* Follow reference attribute ATTR of SRC_DIE.
23016 On entry *REF_CU is the CU of SRC_DIE.
23017 On exit *REF_CU is the CU of the result. */
23019 static struct die_info *
23020 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
23021 struct dwarf2_cu **ref_cu)
23023 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
23024 struct dwarf2_cu *cu = *ref_cu;
23025 struct die_info *die;
23027 die = follow_die_offset (sect_off,
23028 (attr->form == DW_FORM_GNU_ref_alt
23029 || cu->per_cu->is_dwz),
23032 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23033 "at %s [in module %s]"),
23034 sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
23035 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
23040 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23041 Returned value is intended for DW_OP_call*. Returned
23042 dwarf2_locexpr_baton->data has lifetime of
23043 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
23045 struct dwarf2_locexpr_baton
23046 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
23047 struct dwarf2_per_cu_data *per_cu,
23048 CORE_ADDR (*get_frame_pc) (void *baton),
23049 void *baton, bool resolve_abstract_p)
23051 struct dwarf2_cu *cu;
23052 struct die_info *die;
23053 struct attribute *attr;
23054 struct dwarf2_locexpr_baton retval;
23055 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
23056 struct objfile *objfile = dwarf2_per_objfile->objfile;
23058 if (per_cu->cu == NULL)
23059 load_cu (per_cu, false);
23063 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23064 Instead just throw an error, not much else we can do. */
23065 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23066 sect_offset_str (sect_off), objfile_name (objfile));
23069 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23071 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23072 sect_offset_str (sect_off), objfile_name (objfile));
23074 attr = dwarf2_attr (die, DW_AT_location, cu);
23075 if (!attr && resolve_abstract_p
23076 && (dwarf2_per_objfile->abstract_to_concrete.find (die)
23077 != dwarf2_per_objfile->abstract_to_concrete.end ()))
23079 CORE_ADDR pc = (*get_frame_pc) (baton);
23081 for (const auto &cand : dwarf2_per_objfile->abstract_to_concrete[die])
23084 || cand->parent->tag != DW_TAG_subprogram)
23087 CORE_ADDR pc_low, pc_high;
23088 get_scope_pc_bounds (cand->parent, &pc_low, &pc_high, cu);
23089 if (pc_low == ((CORE_ADDR) -1)
23090 || !(pc_low <= pc && pc < pc_high))
23094 attr = dwarf2_attr (die, DW_AT_location, cu);
23101 /* DWARF: "If there is no such attribute, then there is no effect.".
23102 DATA is ignored if SIZE is 0. */
23104 retval.data = NULL;
23107 else if (attr_form_is_section_offset (attr))
23109 struct dwarf2_loclist_baton loclist_baton;
23110 CORE_ADDR pc = (*get_frame_pc) (baton);
23113 fill_in_loclist_baton (cu, &loclist_baton, attr);
23115 retval.data = dwarf2_find_location_expression (&loclist_baton,
23117 retval.size = size;
23121 if (!attr_form_is_block (attr))
23122 error (_("Dwarf Error: DIE at %s referenced in module %s "
23123 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23124 sect_offset_str (sect_off), objfile_name (objfile));
23126 retval.data = DW_BLOCK (attr)->data;
23127 retval.size = DW_BLOCK (attr)->size;
23129 retval.per_cu = cu->per_cu;
23131 age_cached_comp_units (dwarf2_per_objfile);
23136 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23139 struct dwarf2_locexpr_baton
23140 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
23141 struct dwarf2_per_cu_data *per_cu,
23142 CORE_ADDR (*get_frame_pc) (void *baton),
23145 sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
23147 return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
23150 /* Write a constant of a given type as target-ordered bytes into
23153 static const gdb_byte *
23154 write_constant_as_bytes (struct obstack *obstack,
23155 enum bfd_endian byte_order,
23162 *len = TYPE_LENGTH (type);
23163 result = (gdb_byte *) obstack_alloc (obstack, *len);
23164 store_unsigned_integer (result, *len, byte_order, value);
23169 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23170 pointer to the constant bytes and set LEN to the length of the
23171 data. If memory is needed, allocate it on OBSTACK. If the DIE
23172 does not have a DW_AT_const_value, return NULL. */
23175 dwarf2_fetch_constant_bytes (sect_offset sect_off,
23176 struct dwarf2_per_cu_data *per_cu,
23177 struct obstack *obstack,
23180 struct dwarf2_cu *cu;
23181 struct die_info *die;
23182 struct attribute *attr;
23183 const gdb_byte *result = NULL;
23186 enum bfd_endian byte_order;
23187 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23189 if (per_cu->cu == NULL)
23190 load_cu (per_cu, false);
23194 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23195 Instead just throw an error, not much else we can do. */
23196 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23197 sect_offset_str (sect_off), objfile_name (objfile));
23200 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23202 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23203 sect_offset_str (sect_off), objfile_name (objfile));
23205 attr = dwarf2_attr (die, DW_AT_const_value, cu);
23209 byte_order = (bfd_big_endian (objfile->obfd)
23210 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
23212 switch (attr->form)
23215 case DW_FORM_GNU_addr_index:
23219 *len = cu->header.addr_size;
23220 tem = (gdb_byte *) obstack_alloc (obstack, *len);
23221 store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
23225 case DW_FORM_string:
23227 case DW_FORM_GNU_str_index:
23228 case DW_FORM_GNU_strp_alt:
23229 /* DW_STRING is already allocated on the objfile obstack, point
23231 result = (const gdb_byte *) DW_STRING (attr);
23232 *len = strlen (DW_STRING (attr));
23234 case DW_FORM_block1:
23235 case DW_FORM_block2:
23236 case DW_FORM_block4:
23237 case DW_FORM_block:
23238 case DW_FORM_exprloc:
23239 case DW_FORM_data16:
23240 result = DW_BLOCK (attr)->data;
23241 *len = DW_BLOCK (attr)->size;
23244 /* The DW_AT_const_value attributes are supposed to carry the
23245 symbol's value "represented as it would be on the target
23246 architecture." By the time we get here, it's already been
23247 converted to host endianness, so we just need to sign- or
23248 zero-extend it as appropriate. */
23249 case DW_FORM_data1:
23250 type = die_type (die, cu);
23251 result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
23252 if (result == NULL)
23253 result = write_constant_as_bytes (obstack, byte_order,
23256 case DW_FORM_data2:
23257 type = die_type (die, cu);
23258 result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
23259 if (result == NULL)
23260 result = write_constant_as_bytes (obstack, byte_order,
23263 case DW_FORM_data4:
23264 type = die_type (die, cu);
23265 result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
23266 if (result == NULL)
23267 result = write_constant_as_bytes (obstack, byte_order,
23270 case DW_FORM_data8:
23271 type = die_type (die, cu);
23272 result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
23273 if (result == NULL)
23274 result = write_constant_as_bytes (obstack, byte_order,
23278 case DW_FORM_sdata:
23279 case DW_FORM_implicit_const:
23280 type = die_type (die, cu);
23281 result = write_constant_as_bytes (obstack, byte_order,
23282 type, DW_SND (attr), len);
23285 case DW_FORM_udata:
23286 type = die_type (die, cu);
23287 result = write_constant_as_bytes (obstack, byte_order,
23288 type, DW_UNSND (attr), len);
23292 complaint (_("unsupported const value attribute form: '%s'"),
23293 dwarf_form_name (attr->form));
23300 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23301 valid type for this die is found. */
23304 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
23305 struct dwarf2_per_cu_data *per_cu)
23307 struct dwarf2_cu *cu;
23308 struct die_info *die;
23310 if (per_cu->cu == NULL)
23311 load_cu (per_cu, false);
23316 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23320 return die_type (die, cu);
23323 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23327 dwarf2_get_die_type (cu_offset die_offset,
23328 struct dwarf2_per_cu_data *per_cu)
23330 sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
23331 return get_die_type_at_offset (die_offset_sect, per_cu);
23334 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23335 On entry *REF_CU is the CU of SRC_DIE.
23336 On exit *REF_CU is the CU of the result.
23337 Returns NULL if the referenced DIE isn't found. */
23339 static struct die_info *
23340 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
23341 struct dwarf2_cu **ref_cu)
23343 struct die_info temp_die;
23344 struct dwarf2_cu *sig_cu;
23345 struct die_info *die;
23347 /* While it might be nice to assert sig_type->type == NULL here,
23348 we can get here for DW_AT_imported_declaration where we need
23349 the DIE not the type. */
23351 /* If necessary, add it to the queue and load its DIEs. */
23353 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
23354 read_signatured_type (sig_type);
23356 sig_cu = sig_type->per_cu.cu;
23357 gdb_assert (sig_cu != NULL);
23358 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
23359 temp_die.sect_off = sig_type->type_offset_in_section;
23360 die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
23361 to_underlying (temp_die.sect_off));
23364 struct dwarf2_per_objfile *dwarf2_per_objfile
23365 = (*ref_cu)->per_cu->dwarf2_per_objfile;
23367 /* For .gdb_index version 7 keep track of included TUs.
23368 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23369 if (dwarf2_per_objfile->index_table != NULL
23370 && dwarf2_per_objfile->index_table->version <= 7)
23372 VEC_safe_push (dwarf2_per_cu_ptr,
23373 (*ref_cu)->per_cu->imported_symtabs,
23384 /* Follow signatured type referenced by ATTR in SRC_DIE.
23385 On entry *REF_CU is the CU of SRC_DIE.
23386 On exit *REF_CU is the CU of the result.
23387 The result is the DIE of the type.
23388 If the referenced type cannot be found an error is thrown. */
23390 static struct die_info *
23391 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
23392 struct dwarf2_cu **ref_cu)
23394 ULONGEST signature = DW_SIGNATURE (attr);
23395 struct signatured_type *sig_type;
23396 struct die_info *die;
23398 gdb_assert (attr->form == DW_FORM_ref_sig8);
23400 sig_type = lookup_signatured_type (*ref_cu, signature);
23401 /* sig_type will be NULL if the signatured type is missing from
23403 if (sig_type == NULL)
23405 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23406 " from DIE at %s [in module %s]"),
23407 hex_string (signature), sect_offset_str (src_die->sect_off),
23408 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23411 die = follow_die_sig_1 (src_die, sig_type, ref_cu);
23414 dump_die_for_error (src_die);
23415 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23416 " from DIE at %s [in module %s]"),
23417 hex_string (signature), sect_offset_str (src_die->sect_off),
23418 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23424 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23425 reading in and processing the type unit if necessary. */
23427 static struct type *
23428 get_signatured_type (struct die_info *die, ULONGEST signature,
23429 struct dwarf2_cu *cu)
23431 struct dwarf2_per_objfile *dwarf2_per_objfile
23432 = cu->per_cu->dwarf2_per_objfile;
23433 struct signatured_type *sig_type;
23434 struct dwarf2_cu *type_cu;
23435 struct die_info *type_die;
23438 sig_type = lookup_signatured_type (cu, signature);
23439 /* sig_type will be NULL if the signatured type is missing from
23441 if (sig_type == NULL)
23443 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23444 " from DIE at %s [in module %s]"),
23445 hex_string (signature), sect_offset_str (die->sect_off),
23446 objfile_name (dwarf2_per_objfile->objfile));
23447 return build_error_marker_type (cu, die);
23450 /* If we already know the type we're done. */
23451 if (sig_type->type != NULL)
23452 return sig_type->type;
23455 type_die = follow_die_sig_1 (die, sig_type, &type_cu);
23456 if (type_die != NULL)
23458 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23459 is created. This is important, for example, because for c++ classes
23460 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23461 type = read_type_die (type_die, type_cu);
23464 complaint (_("Dwarf Error: Cannot build signatured type %s"
23465 " referenced from DIE at %s [in module %s]"),
23466 hex_string (signature), sect_offset_str (die->sect_off),
23467 objfile_name (dwarf2_per_objfile->objfile));
23468 type = build_error_marker_type (cu, die);
23473 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23474 " from DIE at %s [in module %s]"),
23475 hex_string (signature), sect_offset_str (die->sect_off),
23476 objfile_name (dwarf2_per_objfile->objfile));
23477 type = build_error_marker_type (cu, die);
23479 sig_type->type = type;
23484 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23485 reading in and processing the type unit if necessary. */
23487 static struct type *
23488 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
23489 struct dwarf2_cu *cu) /* ARI: editCase function */
23491 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23492 if (attr_form_is_ref (attr))
23494 struct dwarf2_cu *type_cu = cu;
23495 struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
23497 return read_type_die (type_die, type_cu);
23499 else if (attr->form == DW_FORM_ref_sig8)
23501 return get_signatured_type (die, DW_SIGNATURE (attr), cu);
23505 struct dwarf2_per_objfile *dwarf2_per_objfile
23506 = cu->per_cu->dwarf2_per_objfile;
23508 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23509 " at %s [in module %s]"),
23510 dwarf_form_name (attr->form), sect_offset_str (die->sect_off),
23511 objfile_name (dwarf2_per_objfile->objfile));
23512 return build_error_marker_type (cu, die);
23516 /* Load the DIEs associated with type unit PER_CU into memory. */
23519 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
23521 struct signatured_type *sig_type;
23523 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23524 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
23526 /* We have the per_cu, but we need the signatured_type.
23527 Fortunately this is an easy translation. */
23528 gdb_assert (per_cu->is_debug_types);
23529 sig_type = (struct signatured_type *) per_cu;
23531 gdb_assert (per_cu->cu == NULL);
23533 read_signatured_type (sig_type);
23535 gdb_assert (per_cu->cu != NULL);
23538 /* die_reader_func for read_signatured_type.
23539 This is identical to load_full_comp_unit_reader,
23540 but is kept separate for now. */
23543 read_signatured_type_reader (const struct die_reader_specs *reader,
23544 const gdb_byte *info_ptr,
23545 struct die_info *comp_unit_die,
23549 struct dwarf2_cu *cu = reader->cu;
23551 gdb_assert (cu->die_hash == NULL);
23553 htab_create_alloc_ex (cu->header.length / 12,
23557 &cu->comp_unit_obstack,
23558 hashtab_obstack_allocate,
23559 dummy_obstack_deallocate);
23562 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
23563 &info_ptr, comp_unit_die);
23564 cu->dies = comp_unit_die;
23565 /* comp_unit_die is not stored in die_hash, no need. */
23567 /* We try not to read any attributes in this function, because not
23568 all CUs needed for references have been loaded yet, and symbol
23569 table processing isn't initialized. But we have to set the CU language,
23570 or we won't be able to build types correctly.
23571 Similarly, if we do not read the producer, we can not apply
23572 producer-specific interpretation. */
23573 prepare_one_comp_unit (cu, cu->dies, language_minimal);
23576 /* Read in a signatured type and build its CU and DIEs.
23577 If the type is a stub for the real type in a DWO file,
23578 read in the real type from the DWO file as well. */
23581 read_signatured_type (struct signatured_type *sig_type)
23583 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
23585 gdb_assert (per_cu->is_debug_types);
23586 gdb_assert (per_cu->cu == NULL);
23588 init_cutu_and_read_dies (per_cu, NULL, 0, 1, false,
23589 read_signatured_type_reader, NULL);
23590 sig_type->per_cu.tu_read = 1;
23593 /* Decode simple location descriptions.
23594 Given a pointer to a dwarf block that defines a location, compute
23595 the location and return the value.
23597 NOTE drow/2003-11-18: This function is called in two situations
23598 now: for the address of static or global variables (partial symbols
23599 only) and for offsets into structures which are expected to be
23600 (more or less) constant. The partial symbol case should go away,
23601 and only the constant case should remain. That will let this
23602 function complain more accurately. A few special modes are allowed
23603 without complaint for global variables (for instance, global
23604 register values and thread-local values).
23606 A location description containing no operations indicates that the
23607 object is optimized out. The return value is 0 for that case.
23608 FIXME drow/2003-11-16: No callers check for this case any more; soon all
23609 callers will only want a very basic result and this can become a
23612 Note that stack[0] is unused except as a default error return. */
23615 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
23617 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
23619 size_t size = blk->size;
23620 const gdb_byte *data = blk->data;
23621 CORE_ADDR stack[64];
23623 unsigned int bytes_read, unsnd;
23629 stack[++stacki] = 0;
23668 stack[++stacki] = op - DW_OP_lit0;
23703 stack[++stacki] = op - DW_OP_reg0;
23705 dwarf2_complex_location_expr_complaint ();
23709 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
23711 stack[++stacki] = unsnd;
23713 dwarf2_complex_location_expr_complaint ();
23717 stack[++stacki] = read_address (objfile->obfd, &data[i],
23722 case DW_OP_const1u:
23723 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
23727 case DW_OP_const1s:
23728 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
23732 case DW_OP_const2u:
23733 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
23737 case DW_OP_const2s:
23738 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
23742 case DW_OP_const4u:
23743 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
23747 case DW_OP_const4s:
23748 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
23752 case DW_OP_const8u:
23753 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
23758 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
23764 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
23769 stack[stacki + 1] = stack[stacki];
23774 stack[stacki - 1] += stack[stacki];
23778 case DW_OP_plus_uconst:
23779 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
23785 stack[stacki - 1] -= stack[stacki];
23790 /* If we're not the last op, then we definitely can't encode
23791 this using GDB's address_class enum. This is valid for partial
23792 global symbols, although the variable's address will be bogus
23795 dwarf2_complex_location_expr_complaint ();
23798 case DW_OP_GNU_push_tls_address:
23799 case DW_OP_form_tls_address:
23800 /* The top of the stack has the offset from the beginning
23801 of the thread control block at which the variable is located. */
23802 /* Nothing should follow this operator, so the top of stack would
23804 /* This is valid for partial global symbols, but the variable's
23805 address will be bogus in the psymtab. Make it always at least
23806 non-zero to not look as a variable garbage collected by linker
23807 which have DW_OP_addr 0. */
23809 dwarf2_complex_location_expr_complaint ();
23813 case DW_OP_GNU_uninit:
23816 case DW_OP_GNU_addr_index:
23817 case DW_OP_GNU_const_index:
23818 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
23825 const char *name = get_DW_OP_name (op);
23828 complaint (_("unsupported stack op: '%s'"),
23831 complaint (_("unsupported stack op: '%02x'"),
23835 return (stack[stacki]);
23838 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23839 outside of the allocated space. Also enforce minimum>0. */
23840 if (stacki >= ARRAY_SIZE (stack) - 1)
23842 complaint (_("location description stack overflow"));
23848 complaint (_("location description stack underflow"));
23852 return (stack[stacki]);
23855 /* memory allocation interface */
23857 static struct dwarf_block *
23858 dwarf_alloc_block (struct dwarf2_cu *cu)
23860 return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
23863 static struct die_info *
23864 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
23866 struct die_info *die;
23867 size_t size = sizeof (struct die_info);
23870 size += (num_attrs - 1) * sizeof (struct attribute);
23872 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
23873 memset (die, 0, sizeof (struct die_info));
23878 /* Macro support. */
23880 /* Return file name relative to the compilation directory of file number I in
23881 *LH's file name table. The result is allocated using xmalloc; the caller is
23882 responsible for freeing it. */
23885 file_file_name (int file, struct line_header *lh)
23887 /* Is the file number a valid index into the line header's file name
23888 table? Remember that file numbers start with one, not zero. */
23889 if (1 <= file && file <= lh->file_names.size ())
23891 const file_entry &fe = lh->file_names[file - 1];
23893 if (!IS_ABSOLUTE_PATH (fe.name))
23895 const char *dir = fe.include_dir (lh);
23897 return concat (dir, SLASH_STRING, fe.name, (char *) NULL);
23899 return xstrdup (fe.name);
23903 /* The compiler produced a bogus file number. We can at least
23904 record the macro definitions made in the file, even if we
23905 won't be able to find the file by name. */
23906 char fake_name[80];
23908 xsnprintf (fake_name, sizeof (fake_name),
23909 "<bad macro file number %d>", file);
23911 complaint (_("bad file number in macro information (%d)"),
23914 return xstrdup (fake_name);
23918 /* Return the full name of file number I in *LH's file name table.
23919 Use COMP_DIR as the name of the current directory of the
23920 compilation. The result is allocated using xmalloc; the caller is
23921 responsible for freeing it. */
23923 file_full_name (int file, struct line_header *lh, const char *comp_dir)
23925 /* Is the file number a valid index into the line header's file name
23926 table? Remember that file numbers start with one, not zero. */
23927 if (1 <= file && file <= lh->file_names.size ())
23929 char *relative = file_file_name (file, lh);
23931 if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
23933 return reconcat (relative, comp_dir, SLASH_STRING,
23934 relative, (char *) NULL);
23937 return file_file_name (file, lh);
23941 static struct macro_source_file *
23942 macro_start_file (struct dwarf2_cu *cu,
23943 int file, int line,
23944 struct macro_source_file *current_file,
23945 struct line_header *lh)
23947 /* File name relative to the compilation directory of this source file. */
23948 char *file_name = file_file_name (file, lh);
23950 if (! current_file)
23952 /* Note: We don't create a macro table for this compilation unit
23953 at all until we actually get a filename. */
23954 struct macro_table *macro_table = cu->builder->get_macro_table ();
23956 /* If we have no current file, then this must be the start_file
23957 directive for the compilation unit's main source file. */
23958 current_file = macro_set_main (macro_table, file_name);
23959 macro_define_special (macro_table);
23962 current_file = macro_include (current_file, line, file_name);
23966 return current_file;
23969 static const char *
23970 consume_improper_spaces (const char *p, const char *body)
23974 complaint (_("macro definition contains spaces "
23975 "in formal argument list:\n`%s'"),
23987 parse_macro_definition (struct macro_source_file *file, int line,
23992 /* The body string takes one of two forms. For object-like macro
23993 definitions, it should be:
23995 <macro name> " " <definition>
23997 For function-like macro definitions, it should be:
23999 <macro name> "() " <definition>
24001 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24003 Spaces may appear only where explicitly indicated, and in the
24006 The Dwarf 2 spec says that an object-like macro's name is always
24007 followed by a space, but versions of GCC around March 2002 omit
24008 the space when the macro's definition is the empty string.
24010 The Dwarf 2 spec says that there should be no spaces between the
24011 formal arguments in a function-like macro's formal argument list,
24012 but versions of GCC around March 2002 include spaces after the
24016 /* Find the extent of the macro name. The macro name is terminated
24017 by either a space or null character (for an object-like macro) or
24018 an opening paren (for a function-like macro). */
24019 for (p = body; *p; p++)
24020 if (*p == ' ' || *p == '(')
24023 if (*p == ' ' || *p == '\0')
24025 /* It's an object-like macro. */
24026 int name_len = p - body;
24027 char *name = savestring (body, name_len);
24028 const char *replacement;
24031 replacement = body + name_len + 1;
24034 dwarf2_macro_malformed_definition_complaint (body);
24035 replacement = body + name_len;
24038 macro_define_object (file, line, name, replacement);
24042 else if (*p == '(')
24044 /* It's a function-like macro. */
24045 char *name = savestring (body, p - body);
24048 char **argv = XNEWVEC (char *, argv_size);
24052 p = consume_improper_spaces (p, body);
24054 /* Parse the formal argument list. */
24055 while (*p && *p != ')')
24057 /* Find the extent of the current argument name. */
24058 const char *arg_start = p;
24060 while (*p && *p != ',' && *p != ')' && *p != ' ')
24063 if (! *p || p == arg_start)
24064 dwarf2_macro_malformed_definition_complaint (body);
24067 /* Make sure argv has room for the new argument. */
24068 if (argc >= argv_size)
24071 argv = XRESIZEVEC (char *, argv, argv_size);
24074 argv[argc++] = savestring (arg_start, p - arg_start);
24077 p = consume_improper_spaces (p, body);
24079 /* Consume the comma, if present. */
24084 p = consume_improper_spaces (p, body);
24093 /* Perfectly formed definition, no complaints. */
24094 macro_define_function (file, line, name,
24095 argc, (const char **) argv,
24097 else if (*p == '\0')
24099 /* Complain, but do define it. */
24100 dwarf2_macro_malformed_definition_complaint (body);
24101 macro_define_function (file, line, name,
24102 argc, (const char **) argv,
24106 /* Just complain. */
24107 dwarf2_macro_malformed_definition_complaint (body);
24110 /* Just complain. */
24111 dwarf2_macro_malformed_definition_complaint (body);
24117 for (i = 0; i < argc; i++)
24123 dwarf2_macro_malformed_definition_complaint (body);
24126 /* Skip some bytes from BYTES according to the form given in FORM.
24127 Returns the new pointer. */
24129 static const gdb_byte *
24130 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
24131 enum dwarf_form form,
24132 unsigned int offset_size,
24133 struct dwarf2_section_info *section)
24135 unsigned int bytes_read;
24139 case DW_FORM_data1:
24144 case DW_FORM_data2:
24148 case DW_FORM_data4:
24152 case DW_FORM_data8:
24156 case DW_FORM_data16:
24160 case DW_FORM_string:
24161 read_direct_string (abfd, bytes, &bytes_read);
24162 bytes += bytes_read;
24165 case DW_FORM_sec_offset:
24167 case DW_FORM_GNU_strp_alt:
24168 bytes += offset_size;
24171 case DW_FORM_block:
24172 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
24173 bytes += bytes_read;
24176 case DW_FORM_block1:
24177 bytes += 1 + read_1_byte (abfd, bytes);
24179 case DW_FORM_block2:
24180 bytes += 2 + read_2_bytes (abfd, bytes);
24182 case DW_FORM_block4:
24183 bytes += 4 + read_4_bytes (abfd, bytes);
24186 case DW_FORM_sdata:
24187 case DW_FORM_udata:
24188 case DW_FORM_GNU_addr_index:
24189 case DW_FORM_GNU_str_index:
24190 bytes = gdb_skip_leb128 (bytes, buffer_end);
24193 dwarf2_section_buffer_overflow_complaint (section);
24198 case DW_FORM_implicit_const:
24203 complaint (_("invalid form 0x%x in `%s'"),
24204 form, get_section_name (section));
24212 /* A helper for dwarf_decode_macros that handles skipping an unknown
24213 opcode. Returns an updated pointer to the macro data buffer; or,
24214 on error, issues a complaint and returns NULL. */
24216 static const gdb_byte *
24217 skip_unknown_opcode (unsigned int opcode,
24218 const gdb_byte **opcode_definitions,
24219 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24221 unsigned int offset_size,
24222 struct dwarf2_section_info *section)
24224 unsigned int bytes_read, i;
24226 const gdb_byte *defn;
24228 if (opcode_definitions[opcode] == NULL)
24230 complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24235 defn = opcode_definitions[opcode];
24236 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
24237 defn += bytes_read;
24239 for (i = 0; i < arg; ++i)
24241 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end,
24242 (enum dwarf_form) defn[i], offset_size,
24244 if (mac_ptr == NULL)
24246 /* skip_form_bytes already issued the complaint. */
24254 /* A helper function which parses the header of a macro section.
24255 If the macro section is the extended (for now called "GNU") type,
24256 then this updates *OFFSET_SIZE. Returns a pointer to just after
24257 the header, or issues a complaint and returns NULL on error. */
24259 static const gdb_byte *
24260 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
24262 const gdb_byte *mac_ptr,
24263 unsigned int *offset_size,
24264 int section_is_gnu)
24266 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
24268 if (section_is_gnu)
24270 unsigned int version, flags;
24272 version = read_2_bytes (abfd, mac_ptr);
24273 if (version != 4 && version != 5)
24275 complaint (_("unrecognized version `%d' in .debug_macro section"),
24281 flags = read_1_byte (abfd, mac_ptr);
24283 *offset_size = (flags & 1) ? 8 : 4;
24285 if ((flags & 2) != 0)
24286 /* We don't need the line table offset. */
24287 mac_ptr += *offset_size;
24289 /* Vendor opcode descriptions. */
24290 if ((flags & 4) != 0)
24292 unsigned int i, count;
24294 count = read_1_byte (abfd, mac_ptr);
24296 for (i = 0; i < count; ++i)
24298 unsigned int opcode, bytes_read;
24301 opcode = read_1_byte (abfd, mac_ptr);
24303 opcode_definitions[opcode] = mac_ptr;
24304 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24305 mac_ptr += bytes_read;
24314 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24315 including DW_MACRO_import. */
24318 dwarf_decode_macro_bytes (struct dwarf2_cu *cu,
24320 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24321 struct macro_source_file *current_file,
24322 struct line_header *lh,
24323 struct dwarf2_section_info *section,
24324 int section_is_gnu, int section_is_dwz,
24325 unsigned int offset_size,
24326 htab_t include_hash)
24328 struct dwarf2_per_objfile *dwarf2_per_objfile
24329 = cu->per_cu->dwarf2_per_objfile;
24330 struct objfile *objfile = dwarf2_per_objfile->objfile;
24331 enum dwarf_macro_record_type macinfo_type;
24332 int at_commandline;
24333 const gdb_byte *opcode_definitions[256];
24335 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24336 &offset_size, section_is_gnu);
24337 if (mac_ptr == NULL)
24339 /* We already issued a complaint. */
24343 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24344 GDB is still reading the definitions from command line. First
24345 DW_MACINFO_start_file will need to be ignored as it was already executed
24346 to create CURRENT_FILE for the main source holding also the command line
24347 definitions. On first met DW_MACINFO_start_file this flag is reset to
24348 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24350 at_commandline = 1;
24354 /* Do we at least have room for a macinfo type byte? */
24355 if (mac_ptr >= mac_end)
24357 dwarf2_section_buffer_overflow_complaint (section);
24361 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24364 /* Note that we rely on the fact that the corresponding GNU and
24365 DWARF constants are the same. */
24367 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24368 switch (macinfo_type)
24370 /* A zero macinfo type indicates the end of the macro
24375 case DW_MACRO_define:
24376 case DW_MACRO_undef:
24377 case DW_MACRO_define_strp:
24378 case DW_MACRO_undef_strp:
24379 case DW_MACRO_define_sup:
24380 case DW_MACRO_undef_sup:
24382 unsigned int bytes_read;
24387 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24388 mac_ptr += bytes_read;
24390 if (macinfo_type == DW_MACRO_define
24391 || macinfo_type == DW_MACRO_undef)
24393 body = read_direct_string (abfd, mac_ptr, &bytes_read);
24394 mac_ptr += bytes_read;
24398 LONGEST str_offset;
24400 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
24401 mac_ptr += offset_size;
24403 if (macinfo_type == DW_MACRO_define_sup
24404 || macinfo_type == DW_MACRO_undef_sup
24407 struct dwz_file *dwz
24408 = dwarf2_get_dwz_file (dwarf2_per_objfile);
24410 body = read_indirect_string_from_dwz (objfile,
24414 body = read_indirect_string_at_offset (dwarf2_per_objfile,
24418 is_define = (macinfo_type == DW_MACRO_define
24419 || macinfo_type == DW_MACRO_define_strp
24420 || macinfo_type == DW_MACRO_define_sup);
24421 if (! current_file)
24423 /* DWARF violation as no main source is present. */
24424 complaint (_("debug info with no main source gives macro %s "
24426 is_define ? _("definition") : _("undefinition"),
24430 if ((line == 0 && !at_commandline)
24431 || (line != 0 && at_commandline))
24432 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24433 at_commandline ? _("command-line") : _("in-file"),
24434 is_define ? _("definition") : _("undefinition"),
24435 line == 0 ? _("zero") : _("non-zero"), line, body);
24438 parse_macro_definition (current_file, line, body);
24441 gdb_assert (macinfo_type == DW_MACRO_undef
24442 || macinfo_type == DW_MACRO_undef_strp
24443 || macinfo_type == DW_MACRO_undef_sup);
24444 macro_undef (current_file, line, body);
24449 case DW_MACRO_start_file:
24451 unsigned int bytes_read;
24454 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24455 mac_ptr += bytes_read;
24456 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24457 mac_ptr += bytes_read;
24459 if ((line == 0 && !at_commandline)
24460 || (line != 0 && at_commandline))
24461 complaint (_("debug info gives source %d included "
24462 "from %s at %s line %d"),
24463 file, at_commandline ? _("command-line") : _("file"),
24464 line == 0 ? _("zero") : _("non-zero"), line);
24466 if (at_commandline)
24468 /* This DW_MACRO_start_file was executed in the
24470 at_commandline = 0;
24473 current_file = macro_start_file (cu, file, line, current_file,
24478 case DW_MACRO_end_file:
24479 if (! current_file)
24480 complaint (_("macro debug info has an unmatched "
24481 "`close_file' directive"));
24484 current_file = current_file->included_by;
24485 if (! current_file)
24487 enum dwarf_macro_record_type next_type;
24489 /* GCC circa March 2002 doesn't produce the zero
24490 type byte marking the end of the compilation
24491 unit. Complain if it's not there, but exit no
24494 /* Do we at least have room for a macinfo type byte? */
24495 if (mac_ptr >= mac_end)
24497 dwarf2_section_buffer_overflow_complaint (section);
24501 /* We don't increment mac_ptr here, so this is just
24504 = (enum dwarf_macro_record_type) read_1_byte (abfd,
24506 if (next_type != 0)
24507 complaint (_("no terminating 0-type entry for "
24508 "macros in `.debug_macinfo' section"));
24515 case DW_MACRO_import:
24516 case DW_MACRO_import_sup:
24520 bfd *include_bfd = abfd;
24521 struct dwarf2_section_info *include_section = section;
24522 const gdb_byte *include_mac_end = mac_end;
24523 int is_dwz = section_is_dwz;
24524 const gdb_byte *new_mac_ptr;
24526 offset = read_offset_1 (abfd, mac_ptr, offset_size);
24527 mac_ptr += offset_size;
24529 if (macinfo_type == DW_MACRO_import_sup)
24531 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
24533 dwarf2_read_section (objfile, &dwz->macro);
24535 include_section = &dwz->macro;
24536 include_bfd = get_section_bfd_owner (include_section);
24537 include_mac_end = dwz->macro.buffer + dwz->macro.size;
24541 new_mac_ptr = include_section->buffer + offset;
24542 slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
24546 /* This has actually happened; see
24547 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
24548 complaint (_("recursive DW_MACRO_import in "
24549 ".debug_macro section"));
24553 *slot = (void *) new_mac_ptr;
24555 dwarf_decode_macro_bytes (cu, include_bfd, new_mac_ptr,
24556 include_mac_end, current_file, lh,
24557 section, section_is_gnu, is_dwz,
24558 offset_size, include_hash);
24560 htab_remove_elt (include_hash, (void *) new_mac_ptr);
24565 case DW_MACINFO_vendor_ext:
24566 if (!section_is_gnu)
24568 unsigned int bytes_read;
24570 /* This reads the constant, but since we don't recognize
24571 any vendor extensions, we ignore it. */
24572 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24573 mac_ptr += bytes_read;
24574 read_direct_string (abfd, mac_ptr, &bytes_read);
24575 mac_ptr += bytes_read;
24577 /* We don't recognize any vendor extensions. */
24583 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24584 mac_ptr, mac_end, abfd, offset_size,
24586 if (mac_ptr == NULL)
24591 } while (macinfo_type != 0);
24595 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
24596 int section_is_gnu)
24598 struct dwarf2_per_objfile *dwarf2_per_objfile
24599 = cu->per_cu->dwarf2_per_objfile;
24600 struct objfile *objfile = dwarf2_per_objfile->objfile;
24601 struct line_header *lh = cu->line_header;
24603 const gdb_byte *mac_ptr, *mac_end;
24604 struct macro_source_file *current_file = 0;
24605 enum dwarf_macro_record_type macinfo_type;
24606 unsigned int offset_size = cu->header.offset_size;
24607 const gdb_byte *opcode_definitions[256];
24609 struct dwarf2_section_info *section;
24610 const char *section_name;
24612 if (cu->dwo_unit != NULL)
24614 if (section_is_gnu)
24616 section = &cu->dwo_unit->dwo_file->sections.macro;
24617 section_name = ".debug_macro.dwo";
24621 section = &cu->dwo_unit->dwo_file->sections.macinfo;
24622 section_name = ".debug_macinfo.dwo";
24627 if (section_is_gnu)
24629 section = &dwarf2_per_objfile->macro;
24630 section_name = ".debug_macro";
24634 section = &dwarf2_per_objfile->macinfo;
24635 section_name = ".debug_macinfo";
24639 dwarf2_read_section (objfile, section);
24640 if (section->buffer == NULL)
24642 complaint (_("missing %s section"), section_name);
24645 abfd = get_section_bfd_owner (section);
24647 /* First pass: Find the name of the base filename.
24648 This filename is needed in order to process all macros whose definition
24649 (or undefinition) comes from the command line. These macros are defined
24650 before the first DW_MACINFO_start_file entry, and yet still need to be
24651 associated to the base file.
24653 To determine the base file name, we scan the macro definitions until we
24654 reach the first DW_MACINFO_start_file entry. We then initialize
24655 CURRENT_FILE accordingly so that any macro definition found before the
24656 first DW_MACINFO_start_file can still be associated to the base file. */
24658 mac_ptr = section->buffer + offset;
24659 mac_end = section->buffer + section->size;
24661 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24662 &offset_size, section_is_gnu);
24663 if (mac_ptr == NULL)
24665 /* We already issued a complaint. */
24671 /* Do we at least have room for a macinfo type byte? */
24672 if (mac_ptr >= mac_end)
24674 /* Complaint is printed during the second pass as GDB will probably
24675 stop the first pass earlier upon finding
24676 DW_MACINFO_start_file. */
24680 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24683 /* Note that we rely on the fact that the corresponding GNU and
24684 DWARF constants are the same. */
24686 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24687 switch (macinfo_type)
24689 /* A zero macinfo type indicates the end of the macro
24694 case DW_MACRO_define:
24695 case DW_MACRO_undef:
24696 /* Only skip the data by MAC_PTR. */
24698 unsigned int bytes_read;
24700 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24701 mac_ptr += bytes_read;
24702 read_direct_string (abfd, mac_ptr, &bytes_read);
24703 mac_ptr += bytes_read;
24707 case DW_MACRO_start_file:
24709 unsigned int bytes_read;
24712 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24713 mac_ptr += bytes_read;
24714 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24715 mac_ptr += bytes_read;
24717 current_file = macro_start_file (cu, file, line, current_file, lh);
24721 case DW_MACRO_end_file:
24722 /* No data to skip by MAC_PTR. */
24725 case DW_MACRO_define_strp:
24726 case DW_MACRO_undef_strp:
24727 case DW_MACRO_define_sup:
24728 case DW_MACRO_undef_sup:
24730 unsigned int bytes_read;
24732 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24733 mac_ptr += bytes_read;
24734 mac_ptr += offset_size;
24738 case DW_MACRO_import:
24739 case DW_MACRO_import_sup:
24740 /* Note that, according to the spec, a transparent include
24741 chain cannot call DW_MACRO_start_file. So, we can just
24742 skip this opcode. */
24743 mac_ptr += offset_size;
24746 case DW_MACINFO_vendor_ext:
24747 /* Only skip the data by MAC_PTR. */
24748 if (!section_is_gnu)
24750 unsigned int bytes_read;
24752 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24753 mac_ptr += bytes_read;
24754 read_direct_string (abfd, mac_ptr, &bytes_read);
24755 mac_ptr += bytes_read;
24760 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24761 mac_ptr, mac_end, abfd, offset_size,
24763 if (mac_ptr == NULL)
24768 } while (macinfo_type != 0 && current_file == NULL);
24770 /* Second pass: Process all entries.
24772 Use the AT_COMMAND_LINE flag to determine whether we are still processing
24773 command-line macro definitions/undefinitions. This flag is unset when we
24774 reach the first DW_MACINFO_start_file entry. */
24776 htab_up include_hash (htab_create_alloc (1, htab_hash_pointer,
24778 NULL, xcalloc, xfree));
24779 mac_ptr = section->buffer + offset;
24780 slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT);
24781 *slot = (void *) mac_ptr;
24782 dwarf_decode_macro_bytes (cu, abfd, mac_ptr, mac_end,
24783 current_file, lh, section,
24784 section_is_gnu, 0, offset_size,
24785 include_hash.get ());
24788 /* Check if the attribute's form is a DW_FORM_block*
24789 if so return true else false. */
24792 attr_form_is_block (const struct attribute *attr)
24794 return (attr == NULL ? 0 :
24795 attr->form == DW_FORM_block1
24796 || attr->form == DW_FORM_block2
24797 || attr->form == DW_FORM_block4
24798 || attr->form == DW_FORM_block
24799 || attr->form == DW_FORM_exprloc);
24802 /* Return non-zero if ATTR's value is a section offset --- classes
24803 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24804 You may use DW_UNSND (attr) to retrieve such offsets.
24806 Section 7.5.4, "Attribute Encodings", explains that no attribute
24807 may have a value that belongs to more than one of these classes; it
24808 would be ambiguous if we did, because we use the same forms for all
24812 attr_form_is_section_offset (const struct attribute *attr)
24814 return (attr->form == DW_FORM_data4
24815 || attr->form == DW_FORM_data8
24816 || attr->form == DW_FORM_sec_offset);
24819 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24820 zero otherwise. When this function returns true, you can apply
24821 dwarf2_get_attr_constant_value to it.
24823 However, note that for some attributes you must check
24824 attr_form_is_section_offset before using this test. DW_FORM_data4
24825 and DW_FORM_data8 are members of both the constant class, and of
24826 the classes that contain offsets into other debug sections
24827 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
24828 that, if an attribute's can be either a constant or one of the
24829 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
24830 taken as section offsets, not constants.
24832 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
24833 cannot handle that. */
24836 attr_form_is_constant (const struct attribute *attr)
24838 switch (attr->form)
24840 case DW_FORM_sdata:
24841 case DW_FORM_udata:
24842 case DW_FORM_data1:
24843 case DW_FORM_data2:
24844 case DW_FORM_data4:
24845 case DW_FORM_data8:
24846 case DW_FORM_implicit_const:
24854 /* DW_ADDR is always stored already as sect_offset; despite for the forms
24855 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
24858 attr_form_is_ref (const struct attribute *attr)
24860 switch (attr->form)
24862 case DW_FORM_ref_addr:
24867 case DW_FORM_ref_udata:
24868 case DW_FORM_GNU_ref_alt:
24875 /* Return the .debug_loc section to use for CU.
24876 For DWO files use .debug_loc.dwo. */
24878 static struct dwarf2_section_info *
24879 cu_debug_loc_section (struct dwarf2_cu *cu)
24881 struct dwarf2_per_objfile *dwarf2_per_objfile
24882 = cu->per_cu->dwarf2_per_objfile;
24886 struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections;
24888 return cu->header.version >= 5 ? §ions->loclists : §ions->loc;
24890 return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
24891 : &dwarf2_per_objfile->loc);
24894 /* A helper function that fills in a dwarf2_loclist_baton. */
24897 fill_in_loclist_baton (struct dwarf2_cu *cu,
24898 struct dwarf2_loclist_baton *baton,
24899 const struct attribute *attr)
24901 struct dwarf2_per_objfile *dwarf2_per_objfile
24902 = cu->per_cu->dwarf2_per_objfile;
24903 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24905 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
24907 baton->per_cu = cu->per_cu;
24908 gdb_assert (baton->per_cu);
24909 /* We don't know how long the location list is, but make sure we
24910 don't run off the edge of the section. */
24911 baton->size = section->size - DW_UNSND (attr);
24912 baton->data = section->buffer + DW_UNSND (attr);
24913 baton->base_address = cu->base_address;
24914 baton->from_dwo = cu->dwo_unit != NULL;
24918 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
24919 struct dwarf2_cu *cu, int is_block)
24921 struct dwarf2_per_objfile *dwarf2_per_objfile
24922 = cu->per_cu->dwarf2_per_objfile;
24923 struct objfile *objfile = dwarf2_per_objfile->objfile;
24924 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24926 if (attr_form_is_section_offset (attr)
24927 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24928 the section. If so, fall through to the complaint in the
24930 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
24932 struct dwarf2_loclist_baton *baton;
24934 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
24936 fill_in_loclist_baton (cu, baton, attr);
24938 if (cu->base_known == 0)
24939 complaint (_("Location list used without "
24940 "specifying the CU base address."));
24942 SYMBOL_ACLASS_INDEX (sym) = (is_block
24943 ? dwarf2_loclist_block_index
24944 : dwarf2_loclist_index);
24945 SYMBOL_LOCATION_BATON (sym) = baton;
24949 struct dwarf2_locexpr_baton *baton;
24951 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
24952 baton->per_cu = cu->per_cu;
24953 gdb_assert (baton->per_cu);
24955 if (attr_form_is_block (attr))
24957 /* Note that we're just copying the block's data pointer
24958 here, not the actual data. We're still pointing into the
24959 info_buffer for SYM's objfile; right now we never release
24960 that buffer, but when we do clean up properly this may
24962 baton->size = DW_BLOCK (attr)->size;
24963 baton->data = DW_BLOCK (attr)->data;
24967 dwarf2_invalid_attrib_class_complaint ("location description",
24968 SYMBOL_NATURAL_NAME (sym));
24972 SYMBOL_ACLASS_INDEX (sym) = (is_block
24973 ? dwarf2_locexpr_block_index
24974 : dwarf2_locexpr_index);
24975 SYMBOL_LOCATION_BATON (sym) = baton;
24979 /* Return the OBJFILE associated with the compilation unit CU. If CU
24980 came from a separate debuginfo file, then the master objfile is
24984 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
24986 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
24988 /* Return the master objfile, so that we can report and look up the
24989 correct file containing this variable. */
24990 if (objfile->separate_debug_objfile_backlink)
24991 objfile = objfile->separate_debug_objfile_backlink;
24996 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
24997 (CU_HEADERP is unused in such case) or prepare a temporary copy at
24998 CU_HEADERP first. */
25000 static const struct comp_unit_head *
25001 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
25002 struct dwarf2_per_cu_data *per_cu)
25004 const gdb_byte *info_ptr;
25007 return &per_cu->cu->header;
25009 info_ptr = per_cu->section->buffer + to_underlying (per_cu->sect_off);
25011 memset (cu_headerp, 0, sizeof (*cu_headerp));
25012 read_comp_unit_head (cu_headerp, info_ptr, per_cu->section,
25013 rcuh_kind::COMPILE);
25018 /* Return the address size given in the compilation unit header for CU. */
25021 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
25023 struct comp_unit_head cu_header_local;
25024 const struct comp_unit_head *cu_headerp;
25026 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25028 return cu_headerp->addr_size;
25031 /* Return the offset size given in the compilation unit header for CU. */
25034 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
25036 struct comp_unit_head cu_header_local;
25037 const struct comp_unit_head *cu_headerp;
25039 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25041 return cu_headerp->offset_size;
25044 /* See its dwarf2loc.h declaration. */
25047 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
25049 struct comp_unit_head cu_header_local;
25050 const struct comp_unit_head *cu_headerp;
25052 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25054 if (cu_headerp->version == 2)
25055 return cu_headerp->addr_size;
25057 return cu_headerp->offset_size;
25060 /* Return the text offset of the CU. The returned offset comes from
25061 this CU's objfile. If this objfile came from a separate debuginfo
25062 file, then the offset may be different from the corresponding
25063 offset in the parent objfile. */
25066 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
25068 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25070 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
25073 /* Return DWARF version number of PER_CU. */
25076 dwarf2_version (struct dwarf2_per_cu_data *per_cu)
25078 return per_cu->dwarf_version;
25081 /* Locate the .debug_info compilation unit from CU's objfile which contains
25082 the DIE at OFFSET. Raises an error on failure. */
25084 static struct dwarf2_per_cu_data *
25085 dwarf2_find_containing_comp_unit (sect_offset sect_off,
25086 unsigned int offset_in_dwz,
25087 struct dwarf2_per_objfile *dwarf2_per_objfile)
25089 struct dwarf2_per_cu_data *this_cu;
25093 high = dwarf2_per_objfile->all_comp_units.size () - 1;
25096 struct dwarf2_per_cu_data *mid_cu;
25097 int mid = low + (high - low) / 2;
25099 mid_cu = dwarf2_per_objfile->all_comp_units[mid];
25100 if (mid_cu->is_dwz > offset_in_dwz
25101 || (mid_cu->is_dwz == offset_in_dwz
25102 && mid_cu->sect_off + mid_cu->length >= sect_off))
25107 gdb_assert (low == high);
25108 this_cu = dwarf2_per_objfile->all_comp_units[low];
25109 if (this_cu->is_dwz != offset_in_dwz || this_cu->sect_off > sect_off)
25111 if (low == 0 || this_cu->is_dwz != offset_in_dwz)
25112 error (_("Dwarf Error: could not find partial DIE containing "
25113 "offset %s [in module %s]"),
25114 sect_offset_str (sect_off),
25115 bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
25117 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
25119 return dwarf2_per_objfile->all_comp_units[low-1];
25123 this_cu = dwarf2_per_objfile->all_comp_units[low];
25124 if (low == dwarf2_per_objfile->all_comp_units.size () - 1
25125 && sect_off >= this_cu->sect_off + this_cu->length)
25126 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
25127 gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
25132 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25134 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data *per_cu_)
25135 : per_cu (per_cu_),
25137 has_loclist (false),
25138 checked_producer (false),
25139 producer_is_gxx_lt_4_6 (false),
25140 producer_is_gcc_lt_4_3 (false),
25141 producer_is_icc (false),
25142 producer_is_icc_lt_14 (false),
25143 producer_is_codewarrior (false),
25144 processing_has_namespace_info (false)
25149 /* Destroy a dwarf2_cu. */
25151 dwarf2_cu::~dwarf2_cu ()
25156 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25159 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
25160 enum language pretend_language)
25162 struct attribute *attr;
25164 /* Set the language we're debugging. */
25165 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
25167 set_cu_language (DW_UNSND (attr), cu);
25170 cu->language = pretend_language;
25171 cu->language_defn = language_def (cu->language);
25174 cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
25177 /* Increase the age counter on each cached compilation unit, and free
25178 any that are too old. */
25181 age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
25183 struct dwarf2_per_cu_data *per_cu, **last_chain;
25185 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
25186 per_cu = dwarf2_per_objfile->read_in_chain;
25187 while (per_cu != NULL)
25189 per_cu->cu->last_used ++;
25190 if (per_cu->cu->last_used <= dwarf_max_cache_age)
25191 dwarf2_mark (per_cu->cu);
25192 per_cu = per_cu->cu->read_in_chain;
25195 per_cu = dwarf2_per_objfile->read_in_chain;
25196 last_chain = &dwarf2_per_objfile->read_in_chain;
25197 while (per_cu != NULL)
25199 struct dwarf2_per_cu_data *next_cu;
25201 next_cu = per_cu->cu->read_in_chain;
25203 if (!per_cu->cu->mark)
25206 *last_chain = next_cu;
25209 last_chain = &per_cu->cu->read_in_chain;
25215 /* Remove a single compilation unit from the cache. */
25218 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
25220 struct dwarf2_per_cu_data *per_cu, **last_chain;
25221 struct dwarf2_per_objfile *dwarf2_per_objfile
25222 = target_per_cu->dwarf2_per_objfile;
25224 per_cu = dwarf2_per_objfile->read_in_chain;
25225 last_chain = &dwarf2_per_objfile->read_in_chain;
25226 while (per_cu != NULL)
25228 struct dwarf2_per_cu_data *next_cu;
25230 next_cu = per_cu->cu->read_in_chain;
25232 if (per_cu == target_per_cu)
25236 *last_chain = next_cu;
25240 last_chain = &per_cu->cu->read_in_chain;
25246 /* Cleanup function for the dwarf2_per_objfile data. */
25249 dwarf2_free_objfile (struct objfile *objfile, void *datum)
25251 struct dwarf2_per_objfile *dwarf2_per_objfile
25252 = static_cast<struct dwarf2_per_objfile *> (datum);
25254 delete dwarf2_per_objfile;
25257 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25258 We store these in a hash table separate from the DIEs, and preserve them
25259 when the DIEs are flushed out of cache.
25261 The CU "per_cu" pointer is needed because offset alone is not enough to
25262 uniquely identify the type. A file may have multiple .debug_types sections,
25263 or the type may come from a DWO file. Furthermore, while it's more logical
25264 to use per_cu->section+offset, with Fission the section with the data is in
25265 the DWO file but we don't know that section at the point we need it.
25266 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25267 because we can enter the lookup routine, get_die_type_at_offset, from
25268 outside this file, and thus won't necessarily have PER_CU->cu.
25269 Fortunately, PER_CU is stable for the life of the objfile. */
25271 struct dwarf2_per_cu_offset_and_type
25273 const struct dwarf2_per_cu_data *per_cu;
25274 sect_offset sect_off;
25278 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25281 per_cu_offset_and_type_hash (const void *item)
25283 const struct dwarf2_per_cu_offset_and_type *ofs
25284 = (const struct dwarf2_per_cu_offset_and_type *) item;
25286 return (uintptr_t) ofs->per_cu + to_underlying (ofs->sect_off);
25289 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25292 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
25294 const struct dwarf2_per_cu_offset_and_type *ofs_lhs
25295 = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
25296 const struct dwarf2_per_cu_offset_and_type *ofs_rhs
25297 = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
25299 return (ofs_lhs->per_cu == ofs_rhs->per_cu
25300 && ofs_lhs->sect_off == ofs_rhs->sect_off);
25303 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25304 table if necessary. For convenience, return TYPE.
25306 The DIEs reading must have careful ordering to:
25307 * Not cause infite loops trying to read in DIEs as a prerequisite for
25308 reading current DIE.
25309 * Not trying to dereference contents of still incompletely read in types
25310 while reading in other DIEs.
25311 * Enable referencing still incompletely read in types just by a pointer to
25312 the type without accessing its fields.
25314 Therefore caller should follow these rules:
25315 * Try to fetch any prerequisite types we may need to build this DIE type
25316 before building the type and calling set_die_type.
25317 * After building type call set_die_type for current DIE as soon as
25318 possible before fetching more types to complete the current type.
25319 * Make the type as complete as possible before fetching more types. */
25321 static struct type *
25322 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
25324 struct dwarf2_per_objfile *dwarf2_per_objfile
25325 = cu->per_cu->dwarf2_per_objfile;
25326 struct dwarf2_per_cu_offset_and_type **slot, ofs;
25327 struct objfile *objfile = dwarf2_per_objfile->objfile;
25328 struct attribute *attr;
25329 struct dynamic_prop prop;
25331 /* For Ada types, make sure that the gnat-specific data is always
25332 initialized (if not already set). There are a few types where
25333 we should not be doing so, because the type-specific area is
25334 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25335 where the type-specific area is used to store the floatformat).
25336 But this is not a problem, because the gnat-specific information
25337 is actually not needed for these types. */
25338 if (need_gnat_info (cu)
25339 && TYPE_CODE (type) != TYPE_CODE_FUNC
25340 && TYPE_CODE (type) != TYPE_CODE_FLT
25341 && TYPE_CODE (type) != TYPE_CODE_METHODPTR
25342 && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
25343 && TYPE_CODE (type) != TYPE_CODE_METHOD
25344 && !HAVE_GNAT_AUX_INFO (type))
25345 INIT_GNAT_SPECIFIC (type);
25347 /* Read DW_AT_allocated and set in type. */
25348 attr = dwarf2_attr (die, DW_AT_allocated, cu);
25349 if (attr_form_is_block (attr))
25351 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25352 add_dyn_prop (DYN_PROP_ALLOCATED, prop, type);
25354 else if (attr != NULL)
25356 complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25357 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25358 sect_offset_str (die->sect_off));
25361 /* Read DW_AT_associated and set in type. */
25362 attr = dwarf2_attr (die, DW_AT_associated, cu);
25363 if (attr_form_is_block (attr))
25365 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25366 add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type);
25368 else if (attr != NULL)
25370 complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25371 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25372 sect_offset_str (die->sect_off));
25375 /* Read DW_AT_data_location and set in type. */
25376 attr = dwarf2_attr (die, DW_AT_data_location, cu);
25377 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25378 add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type);
25380 if (dwarf2_per_objfile->die_type_hash == NULL)
25382 dwarf2_per_objfile->die_type_hash =
25383 htab_create_alloc_ex (127,
25384 per_cu_offset_and_type_hash,
25385 per_cu_offset_and_type_eq,
25387 &objfile->objfile_obstack,
25388 hashtab_obstack_allocate,
25389 dummy_obstack_deallocate);
25392 ofs.per_cu = cu->per_cu;
25393 ofs.sect_off = die->sect_off;
25395 slot = (struct dwarf2_per_cu_offset_and_type **)
25396 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
25398 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25399 sect_offset_str (die->sect_off));
25400 *slot = XOBNEW (&objfile->objfile_obstack,
25401 struct dwarf2_per_cu_offset_and_type);
25406 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25407 or return NULL if the die does not have a saved type. */
25409 static struct type *
25410 get_die_type_at_offset (sect_offset sect_off,
25411 struct dwarf2_per_cu_data *per_cu)
25413 struct dwarf2_per_cu_offset_and_type *slot, ofs;
25414 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
25416 if (dwarf2_per_objfile->die_type_hash == NULL)
25419 ofs.per_cu = per_cu;
25420 ofs.sect_off = sect_off;
25421 slot = ((struct dwarf2_per_cu_offset_and_type *)
25422 htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
25429 /* Look up the type for DIE in CU in die_type_hash,
25430 or return NULL if DIE does not have a saved type. */
25432 static struct type *
25433 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
25435 return get_die_type_at_offset (die->sect_off, cu->per_cu);
25438 /* Add a dependence relationship from CU to REF_PER_CU. */
25441 dwarf2_add_dependence (struct dwarf2_cu *cu,
25442 struct dwarf2_per_cu_data *ref_per_cu)
25446 if (cu->dependencies == NULL)
25448 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
25449 NULL, &cu->comp_unit_obstack,
25450 hashtab_obstack_allocate,
25451 dummy_obstack_deallocate);
25453 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
25455 *slot = ref_per_cu;
25458 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25459 Set the mark field in every compilation unit in the
25460 cache that we must keep because we are keeping CU. */
25463 dwarf2_mark_helper (void **slot, void *data)
25465 struct dwarf2_per_cu_data *per_cu;
25467 per_cu = (struct dwarf2_per_cu_data *) *slot;
25469 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25470 reading of the chain. As such dependencies remain valid it is not much
25471 useful to track and undo them during QUIT cleanups. */
25472 if (per_cu->cu == NULL)
25475 if (per_cu->cu->mark)
25477 per_cu->cu->mark = true;
25479 if (per_cu->cu->dependencies != NULL)
25480 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
25485 /* Set the mark field in CU and in every other compilation unit in the
25486 cache that we must keep because we are keeping CU. */
25489 dwarf2_mark (struct dwarf2_cu *cu)
25494 if (cu->dependencies != NULL)
25495 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
25499 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
25503 per_cu->cu->mark = false;
25504 per_cu = per_cu->cu->read_in_chain;
25508 /* Trivial hash function for partial_die_info: the hash value of a DIE
25509 is its offset in .debug_info for this objfile. */
25512 partial_die_hash (const void *item)
25514 const struct partial_die_info *part_die
25515 = (const struct partial_die_info *) item;
25517 return to_underlying (part_die->sect_off);
25520 /* Trivial comparison function for partial_die_info structures: two DIEs
25521 are equal if they have the same offset. */
25524 partial_die_eq (const void *item_lhs, const void *item_rhs)
25526 const struct partial_die_info *part_die_lhs
25527 = (const struct partial_die_info *) item_lhs;
25528 const struct partial_die_info *part_die_rhs
25529 = (const struct partial_die_info *) item_rhs;
25531 return part_die_lhs->sect_off == part_die_rhs->sect_off;
25534 struct cmd_list_element *set_dwarf_cmdlist;
25535 struct cmd_list_element *show_dwarf_cmdlist;
25538 set_dwarf_cmd (const char *args, int from_tty)
25540 help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
25545 show_dwarf_cmd (const char *args, int from_tty)
25547 cmd_show_list (show_dwarf_cmdlist, from_tty, "");
25550 int dwarf_always_disassemble;
25553 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
25554 struct cmd_list_element *c, const char *value)
25556 fprintf_filtered (file,
25557 _("Whether to always disassemble "
25558 "DWARF expressions is %s.\n"),
25563 show_check_physname (struct ui_file *file, int from_tty,
25564 struct cmd_list_element *c, const char *value)
25566 fprintf_filtered (file,
25567 _("Whether to check \"physname\" is %s.\n"),
25572 _initialize_dwarf2_read (void)
25574 dwarf2_objfile_data_key
25575 = register_objfile_data_with_cleanup (nullptr, dwarf2_free_objfile);
25577 add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
25578 Set DWARF specific variables.\n\
25579 Configure DWARF variables such as the cache size"),
25580 &set_dwarf_cmdlist, "maintenance set dwarf ",
25581 0/*allow-unknown*/, &maintenance_set_cmdlist);
25583 add_prefix_cmd ("dwarf", class_maintenance, show_dwarf_cmd, _("\
25584 Show DWARF specific variables\n\
25585 Show DWARF variables such as the cache size"),
25586 &show_dwarf_cmdlist, "maintenance show dwarf ",
25587 0/*allow-unknown*/, &maintenance_show_cmdlist);
25589 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
25590 &dwarf_max_cache_age, _("\
25591 Set the upper bound on the age of cached DWARF compilation units."), _("\
25592 Show the upper bound on the age of cached DWARF compilation units."), _("\
25593 A higher limit means that cached compilation units will be stored\n\
25594 in memory longer, and more total memory will be used. Zero disables\n\
25595 caching, which can slow down startup."),
25597 show_dwarf_max_cache_age,
25598 &set_dwarf_cmdlist,
25599 &show_dwarf_cmdlist);
25601 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
25602 &dwarf_always_disassemble, _("\
25603 Set whether `info address' always disassembles DWARF expressions."), _("\
25604 Show whether `info address' always disassembles DWARF expressions."), _("\
25605 When enabled, DWARF expressions are always printed in an assembly-like\n\
25606 syntax. When disabled, expressions will be printed in a more\n\
25607 conversational style, when possible."),
25609 show_dwarf_always_disassemble,
25610 &set_dwarf_cmdlist,
25611 &show_dwarf_cmdlist);
25613 add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
25614 Set debugging of the DWARF reader."), _("\
25615 Show debugging of the DWARF reader."), _("\
25616 When enabled (non-zero), debugging messages are printed during DWARF\n\
25617 reading and symtab expansion. A value of 1 (one) provides basic\n\
25618 information. A value greater than 1 provides more verbose information."),
25621 &setdebuglist, &showdebuglist);
25623 add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
25624 Set debugging of the DWARF DIE reader."), _("\
25625 Show debugging of the DWARF DIE reader."), _("\
25626 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25627 The value is the maximum depth to print."),
25630 &setdebuglist, &showdebuglist);
25632 add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
25633 Set debugging of the dwarf line reader."), _("\
25634 Show debugging of the dwarf line reader."), _("\
25635 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25636 A value of 1 (one) provides basic information.\n\
25637 A value greater than 1 provides more verbose information."),
25640 &setdebuglist, &showdebuglist);
25642 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
25643 Set cross-checking of \"physname\" code against demangler."), _("\
25644 Show cross-checking of \"physname\" code against demangler."), _("\
25645 When enabled, GDB's internal \"physname\" code is checked against\n\
25647 NULL, show_check_physname,
25648 &setdebuglist, &showdebuglist);
25650 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25651 no_class, &use_deprecated_index_sections, _("\
25652 Set whether to use deprecated gdb_index sections."), _("\
25653 Show whether to use deprecated gdb_index sections."), _("\
25654 When enabled, deprecated .gdb_index sections are used anyway.\n\
25655 Normally they are ignored either because of a missing feature or\n\
25656 performance issue.\n\
25657 Warning: This option must be enabled before gdb reads the file."),
25660 &setlist, &showlist);
25662 dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
25663 &dwarf2_locexpr_funcs);
25664 dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
25665 &dwarf2_loclist_funcs);
25667 dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
25668 &dwarf2_block_frame_base_locexpr_funcs);
25669 dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
25670 &dwarf2_block_frame_base_loclist_funcs);
25673 selftests::register_test ("dw2_expand_symtabs_matching",
25674 selftests::dw2_expand_symtabs_matching::run_test);