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->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
3194 &objfile->objfile_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->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
3355 &objfile->objfile_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->psymtabs_addrmap)
5251 CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
5252 SECT_OFF_TEXT (objfile));
5253 data = (struct dwarf2_per_cu_data *) addrmap_find (objfile->psymtabs_addrmap,
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 if (objfile->global_psymbols.capacity () == 0
6303 && objfile->static_psymbols.capacity () == 0)
6304 init_psymbol_list (objfile, 1024);
6308 /* This isn't really ideal: all the data we allocate on the
6309 objfile's obstack is still uselessly kept around. However,
6310 freeing it seems unsafe. */
6311 psymtab_discarder psymtabs (objfile);
6312 dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
6315 /* (maybe) store an index in the cache. */
6316 global_index_cache.store (dwarf2_per_objfile);
6318 CATCH (except, RETURN_MASK_ERROR)
6320 exception_print (gdb_stderr, except);
6325 /* Return the total length of the CU described by HEADER. */
6328 get_cu_length (const struct comp_unit_head *header)
6330 return header->initial_length_size + header->length;
6333 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6336 offset_in_cu_p (const comp_unit_head *cu_header, sect_offset sect_off)
6338 sect_offset bottom = cu_header->sect_off;
6339 sect_offset top = cu_header->sect_off + get_cu_length (cu_header);
6341 return sect_off >= bottom && sect_off < top;
6344 /* Find the base address of the compilation unit for range lists and
6345 location lists. It will normally be specified by DW_AT_low_pc.
6346 In DWARF-3 draft 4, the base address could be overridden by
6347 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6348 compilation units with discontinuous ranges. */
6351 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
6353 struct attribute *attr;
6356 cu->base_address = 0;
6358 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
6361 cu->base_address = attr_value_as_address (attr);
6366 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6369 cu->base_address = attr_value_as_address (attr);
6375 /* Read in the comp unit header information from the debug_info at info_ptr.
6376 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6377 NOTE: This leaves members offset, first_die_offset to be filled in
6380 static const gdb_byte *
6381 read_comp_unit_head (struct comp_unit_head *cu_header,
6382 const gdb_byte *info_ptr,
6383 struct dwarf2_section_info *section,
6384 rcuh_kind section_kind)
6387 unsigned int bytes_read;
6388 const char *filename = get_section_file_name (section);
6389 bfd *abfd = get_section_bfd_owner (section);
6391 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
6392 cu_header->initial_length_size = bytes_read;
6393 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
6394 info_ptr += bytes_read;
6395 cu_header->version = read_2_bytes (abfd, info_ptr);
6396 if (cu_header->version < 2 || cu_header->version > 5)
6397 error (_("Dwarf Error: wrong version in compilation unit header "
6398 "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6399 cu_header->version, filename);
6401 if (cu_header->version < 5)
6402 switch (section_kind)
6404 case rcuh_kind::COMPILE:
6405 cu_header->unit_type = DW_UT_compile;
6407 case rcuh_kind::TYPE:
6408 cu_header->unit_type = DW_UT_type;
6411 internal_error (__FILE__, __LINE__,
6412 _("read_comp_unit_head: invalid section_kind"));
6416 cu_header->unit_type = static_cast<enum dwarf_unit_type>
6417 (read_1_byte (abfd, info_ptr));
6419 switch (cu_header->unit_type)
6422 if (section_kind != rcuh_kind::COMPILE)
6423 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6424 "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6428 section_kind = rcuh_kind::TYPE;
6431 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6432 "(is %d, should be %d or %d) [in module %s]"),
6433 cu_header->unit_type, DW_UT_compile, DW_UT_type, filename);
6436 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6439 cu_header->abbrev_sect_off = (sect_offset) read_offset (abfd, info_ptr,
6442 info_ptr += bytes_read;
6443 if (cu_header->version < 5)
6445 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6448 signed_addr = bfd_get_sign_extend_vma (abfd);
6449 if (signed_addr < 0)
6450 internal_error (__FILE__, __LINE__,
6451 _("read_comp_unit_head: dwarf from non elf file"));
6452 cu_header->signed_addr_p = signed_addr;
6454 if (section_kind == rcuh_kind::TYPE)
6456 LONGEST type_offset;
6458 cu_header->signature = read_8_bytes (abfd, info_ptr);
6461 type_offset = read_offset (abfd, info_ptr, cu_header, &bytes_read);
6462 info_ptr += bytes_read;
6463 cu_header->type_cu_offset_in_tu = (cu_offset) type_offset;
6464 if (to_underlying (cu_header->type_cu_offset_in_tu) != type_offset)
6465 error (_("Dwarf Error: Too big type_offset in compilation unit "
6466 "header (is %s) [in module %s]"), plongest (type_offset),
6473 /* Helper function that returns the proper abbrev section for
6476 static struct dwarf2_section_info *
6477 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
6479 struct dwarf2_section_info *abbrev;
6480 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
6482 if (this_cu->is_dwz)
6483 abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
6485 abbrev = &dwarf2_per_objfile->abbrev;
6490 /* Subroutine of read_and_check_comp_unit_head and
6491 read_and_check_type_unit_head to simplify them.
6492 Perform various error checking on the header. */
6495 error_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6496 struct comp_unit_head *header,
6497 struct dwarf2_section_info *section,
6498 struct dwarf2_section_info *abbrev_section)
6500 const char *filename = get_section_file_name (section);
6502 if (to_underlying (header->abbrev_sect_off)
6503 >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
6504 error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6505 "(offset %s + 6) [in module %s]"),
6506 sect_offset_str (header->abbrev_sect_off),
6507 sect_offset_str (header->sect_off),
6510 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6511 avoid potential 32-bit overflow. */
6512 if (((ULONGEST) header->sect_off + get_cu_length (header))
6514 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6515 "(offset %s + 0) [in module %s]"),
6516 header->length, sect_offset_str (header->sect_off),
6520 /* Read in a CU/TU header and perform some basic error checking.
6521 The contents of the header are stored in HEADER.
6522 The result is a pointer to the start of the first DIE. */
6524 static const gdb_byte *
6525 read_and_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6526 struct comp_unit_head *header,
6527 struct dwarf2_section_info *section,
6528 struct dwarf2_section_info *abbrev_section,
6529 const gdb_byte *info_ptr,
6530 rcuh_kind section_kind)
6532 const gdb_byte *beg_of_comp_unit = info_ptr;
6534 header->sect_off = (sect_offset) (beg_of_comp_unit - section->buffer);
6536 info_ptr = read_comp_unit_head (header, info_ptr, section, section_kind);
6538 header->first_die_cu_offset = (cu_offset) (info_ptr - beg_of_comp_unit);
6540 error_check_comp_unit_head (dwarf2_per_objfile, header, section,
6546 /* Fetch the abbreviation table offset from a comp or type unit header. */
6549 read_abbrev_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
6550 struct dwarf2_section_info *section,
6551 sect_offset sect_off)
6553 bfd *abfd = get_section_bfd_owner (section);
6554 const gdb_byte *info_ptr;
6555 unsigned int initial_length_size, offset_size;
6558 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
6559 info_ptr = section->buffer + to_underlying (sect_off);
6560 read_initial_length (abfd, info_ptr, &initial_length_size);
6561 offset_size = initial_length_size == 4 ? 4 : 8;
6562 info_ptr += initial_length_size;
6564 version = read_2_bytes (abfd, info_ptr);
6568 /* Skip unit type and address size. */
6572 return (sect_offset) read_offset_1 (abfd, info_ptr, offset_size);
6575 /* Allocate a new partial symtab for file named NAME and mark this new
6576 partial symtab as being an include of PST. */
6579 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
6580 struct objfile *objfile)
6582 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
6584 if (!IS_ABSOLUTE_PATH (subpst->filename))
6586 /* It shares objfile->objfile_obstack. */
6587 subpst->dirname = pst->dirname;
6590 subpst->dependencies
6591 = XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
6592 subpst->dependencies[0] = pst;
6593 subpst->number_of_dependencies = 1;
6595 subpst->read_symtab = pst->read_symtab;
6597 /* No private part is necessary for include psymtabs. This property
6598 can be used to differentiate between such include psymtabs and
6599 the regular ones. */
6600 subpst->read_symtab_private = NULL;
6603 /* Read the Line Number Program data and extract the list of files
6604 included by the source file represented by PST. Build an include
6605 partial symtab for each of these included files. */
6608 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
6609 struct die_info *die,
6610 struct partial_symtab *pst)
6613 struct attribute *attr;
6615 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
6617 lh = dwarf_decode_line_header ((sect_offset) DW_UNSND (attr), cu);
6619 return; /* No linetable, so no includes. */
6621 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6622 that we pass in the raw text_low here; that is ok because we're
6623 only decoding the line table to make include partial symtabs, and
6624 so the addresses aren't really used. */
6625 dwarf_decode_lines (lh.get (), pst->dirname, cu, pst,
6626 pst->raw_text_low (), 1);
6630 hash_signatured_type (const void *item)
6632 const struct signatured_type *sig_type
6633 = (const struct signatured_type *) item;
6635 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6636 return sig_type->signature;
6640 eq_signatured_type (const void *item_lhs, const void *item_rhs)
6642 const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
6643 const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
6645 return lhs->signature == rhs->signature;
6648 /* Allocate a hash table for signatured types. */
6651 allocate_signatured_type_table (struct objfile *objfile)
6653 return htab_create_alloc_ex (41,
6654 hash_signatured_type,
6657 &objfile->objfile_obstack,
6658 hashtab_obstack_allocate,
6659 dummy_obstack_deallocate);
6662 /* A helper function to add a signatured type CU to a table. */
6665 add_signatured_type_cu_to_table (void **slot, void *datum)
6667 struct signatured_type *sigt = (struct signatured_type *) *slot;
6668 std::vector<signatured_type *> *all_type_units
6669 = (std::vector<signatured_type *> *) datum;
6671 all_type_units->push_back (sigt);
6676 /* A helper for create_debug_types_hash_table. Read types from SECTION
6677 and fill them into TYPES_HTAB. It will process only type units,
6678 therefore DW_UT_type. */
6681 create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6682 struct dwo_file *dwo_file,
6683 dwarf2_section_info *section, htab_t &types_htab,
6684 rcuh_kind section_kind)
6686 struct objfile *objfile = dwarf2_per_objfile->objfile;
6687 struct dwarf2_section_info *abbrev_section;
6689 const gdb_byte *info_ptr, *end_ptr;
6691 abbrev_section = (dwo_file != NULL
6692 ? &dwo_file->sections.abbrev
6693 : &dwarf2_per_objfile->abbrev);
6695 if (dwarf_read_debug)
6696 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
6697 get_section_name (section),
6698 get_section_file_name (abbrev_section));
6700 dwarf2_read_section (objfile, section);
6701 info_ptr = section->buffer;
6703 if (info_ptr == NULL)
6706 /* We can't set abfd until now because the section may be empty or
6707 not present, in which case the bfd is unknown. */
6708 abfd = get_section_bfd_owner (section);
6710 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6711 because we don't need to read any dies: the signature is in the
6714 end_ptr = info_ptr + section->size;
6715 while (info_ptr < end_ptr)
6717 struct signatured_type *sig_type;
6718 struct dwo_unit *dwo_tu;
6720 const gdb_byte *ptr = info_ptr;
6721 struct comp_unit_head header;
6722 unsigned int length;
6724 sect_offset sect_off = (sect_offset) (ptr - section->buffer);
6726 /* Initialize it due to a false compiler warning. */
6727 header.signature = -1;
6728 header.type_cu_offset_in_tu = (cu_offset) -1;
6730 /* We need to read the type's signature in order to build the hash
6731 table, but we don't need anything else just yet. */
6733 ptr = read_and_check_comp_unit_head (dwarf2_per_objfile, &header, section,
6734 abbrev_section, ptr, section_kind);
6736 length = get_cu_length (&header);
6738 /* Skip dummy type units. */
6739 if (ptr >= info_ptr + length
6740 || peek_abbrev_code (abfd, ptr) == 0
6741 || header.unit_type != DW_UT_type)
6747 if (types_htab == NULL)
6750 types_htab = allocate_dwo_unit_table (objfile);
6752 types_htab = allocate_signatured_type_table (objfile);
6758 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6760 dwo_tu->dwo_file = dwo_file;
6761 dwo_tu->signature = header.signature;
6762 dwo_tu->type_offset_in_tu = header.type_cu_offset_in_tu;
6763 dwo_tu->section = section;
6764 dwo_tu->sect_off = sect_off;
6765 dwo_tu->length = length;
6769 /* N.B.: type_offset is not usable if this type uses a DWO file.
6770 The real type_offset is in the DWO file. */
6772 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6773 struct signatured_type);
6774 sig_type->signature = header.signature;
6775 sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;
6776 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6777 sig_type->per_cu.is_debug_types = 1;
6778 sig_type->per_cu.section = section;
6779 sig_type->per_cu.sect_off = sect_off;
6780 sig_type->per_cu.length = length;
6783 slot = htab_find_slot (types_htab,
6784 dwo_file ? (void*) dwo_tu : (void *) sig_type,
6786 gdb_assert (slot != NULL);
6789 sect_offset dup_sect_off;
6793 const struct dwo_unit *dup_tu
6794 = (const struct dwo_unit *) *slot;
6796 dup_sect_off = dup_tu->sect_off;
6800 const struct signatured_type *dup_tu
6801 = (const struct signatured_type *) *slot;
6803 dup_sect_off = dup_tu->per_cu.sect_off;
6806 complaint (_("debug type entry at offset %s is duplicate to"
6807 " the entry at offset %s, signature %s"),
6808 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
6809 hex_string (header.signature));
6811 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
6813 if (dwarf_read_debug > 1)
6814 fprintf_unfiltered (gdb_stdlog, " offset %s, signature %s\n",
6815 sect_offset_str (sect_off),
6816 hex_string (header.signature));
6822 /* Create the hash table of all entries in the .debug_types
6823 (or .debug_types.dwo) section(s).
6824 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6825 otherwise it is NULL.
6827 The result is a pointer to the hash table or NULL if there are no types.
6829 Note: This function processes DWO files only, not DWP files. */
6832 create_debug_types_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6833 struct dwo_file *dwo_file,
6834 VEC (dwarf2_section_info_def) *types,
6838 struct dwarf2_section_info *section;
6840 if (VEC_empty (dwarf2_section_info_def, types))
6844 VEC_iterate (dwarf2_section_info_def, types, ix, section);
6846 create_debug_type_hash_table (dwarf2_per_objfile, dwo_file, section,
6847 types_htab, rcuh_kind::TYPE);
6850 /* Create the hash table of all entries in the .debug_types section,
6851 and initialize all_type_units.
6852 The result is zero if there is an error (e.g. missing .debug_types section),
6853 otherwise non-zero. */
6856 create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
6858 htab_t types_htab = NULL;
6860 create_debug_type_hash_table (dwarf2_per_objfile, NULL,
6861 &dwarf2_per_objfile->info, types_htab,
6862 rcuh_kind::COMPILE);
6863 create_debug_types_hash_table (dwarf2_per_objfile, NULL,
6864 dwarf2_per_objfile->types, types_htab);
6865 if (types_htab == NULL)
6867 dwarf2_per_objfile->signatured_types = NULL;
6871 dwarf2_per_objfile->signatured_types = types_htab;
6873 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
6874 dwarf2_per_objfile->all_type_units.reserve (htab_elements (types_htab));
6876 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table,
6877 &dwarf2_per_objfile->all_type_units);
6882 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6883 If SLOT is non-NULL, it is the entry to use in the hash table.
6884 Otherwise we find one. */
6886 static struct signatured_type *
6887 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
6890 struct objfile *objfile = dwarf2_per_objfile->objfile;
6892 if (dwarf2_per_objfile->all_type_units.size ()
6893 == dwarf2_per_objfile->all_type_units.capacity ())
6894 ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
6896 signatured_type *sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6897 struct signatured_type);
6899 dwarf2_per_objfile->all_type_units.push_back (sig_type);
6900 sig_type->signature = sig;
6901 sig_type->per_cu.is_debug_types = 1;
6902 if (dwarf2_per_objfile->using_index)
6904 sig_type->per_cu.v.quick =
6905 OBSTACK_ZALLOC (&objfile->objfile_obstack,
6906 struct dwarf2_per_cu_quick_data);
6911 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6914 gdb_assert (*slot == NULL);
6916 /* The rest of sig_type must be filled in by the caller. */
6920 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6921 Fill in SIG_ENTRY with DWO_ENTRY. */
6924 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
6925 struct signatured_type *sig_entry,
6926 struct dwo_unit *dwo_entry)
6928 /* Make sure we're not clobbering something we don't expect to. */
6929 gdb_assert (! sig_entry->per_cu.queued);
6930 gdb_assert (sig_entry->per_cu.cu == NULL);
6931 if (dwarf2_per_objfile->using_index)
6933 gdb_assert (sig_entry->per_cu.v.quick != NULL);
6934 gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
6937 gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
6938 gdb_assert (sig_entry->signature == dwo_entry->signature);
6939 gdb_assert (to_underlying (sig_entry->type_offset_in_section) == 0);
6940 gdb_assert (sig_entry->type_unit_group == NULL);
6941 gdb_assert (sig_entry->dwo_unit == NULL);
6943 sig_entry->per_cu.section = dwo_entry->section;
6944 sig_entry->per_cu.sect_off = dwo_entry->sect_off;
6945 sig_entry->per_cu.length = dwo_entry->length;
6946 sig_entry->per_cu.reading_dwo_directly = 1;
6947 sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6948 sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
6949 sig_entry->dwo_unit = dwo_entry;
6952 /* Subroutine of lookup_signatured_type.
6953 If we haven't read the TU yet, create the signatured_type data structure
6954 for a TU to be read in directly from a DWO file, bypassing the stub.
6955 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6956 using .gdb_index, then when reading a CU we want to stay in the DWO file
6957 containing that CU. Otherwise we could end up reading several other DWO
6958 files (due to comdat folding) to process the transitive closure of all the
6959 mentioned TUs, and that can be slow. The current DWO file will have every
6960 type signature that it needs.
6961 We only do this for .gdb_index because in the psymtab case we already have
6962 to read all the DWOs to build the type unit groups. */
6964 static struct signatured_type *
6965 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
6967 struct dwarf2_per_objfile *dwarf2_per_objfile
6968 = cu->per_cu->dwarf2_per_objfile;
6969 struct objfile *objfile = dwarf2_per_objfile->objfile;
6970 struct dwo_file *dwo_file;
6971 struct dwo_unit find_dwo_entry, *dwo_entry;
6972 struct signatured_type find_sig_entry, *sig_entry;
6975 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
6977 /* If TU skeletons have been removed then we may not have read in any
6979 if (dwarf2_per_objfile->signatured_types == NULL)
6981 dwarf2_per_objfile->signatured_types
6982 = allocate_signatured_type_table (objfile);
6985 /* We only ever need to read in one copy of a signatured type.
6986 Use the global signatured_types array to do our own comdat-folding
6987 of types. If this is the first time we're reading this TU, and
6988 the TU has an entry in .gdb_index, replace the recorded data from
6989 .gdb_index with this TU. */
6991 find_sig_entry.signature = sig;
6992 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6993 &find_sig_entry, INSERT);
6994 sig_entry = (struct signatured_type *) *slot;
6996 /* We can get here with the TU already read, *or* in the process of being
6997 read. Don't reassign the global entry to point to this DWO if that's
6998 the case. Also note that if the TU is already being read, it may not
6999 have come from a DWO, the program may be a mix of Fission-compiled
7000 code and non-Fission-compiled code. */
7002 /* Have we already tried to read this TU?
7003 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7004 needn't exist in the global table yet). */
7005 if (sig_entry != NULL && sig_entry->per_cu.tu_read)
7008 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
7009 dwo_unit of the TU itself. */
7010 dwo_file = cu->dwo_unit->dwo_file;
7012 /* Ok, this is the first time we're reading this TU. */
7013 if (dwo_file->tus == NULL)
7015 find_dwo_entry.signature = sig;
7016 dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
7017 if (dwo_entry == NULL)
7020 /* If the global table doesn't have an entry for this TU, add one. */
7021 if (sig_entry == NULL)
7022 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7024 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7025 sig_entry->per_cu.tu_read = 1;
7029 /* Subroutine of lookup_signatured_type.
7030 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7031 then try the DWP file. If the TU stub (skeleton) has been removed then
7032 it won't be in .gdb_index. */
7034 static struct signatured_type *
7035 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7037 struct dwarf2_per_objfile *dwarf2_per_objfile
7038 = cu->per_cu->dwarf2_per_objfile;
7039 struct objfile *objfile = dwarf2_per_objfile->objfile;
7040 struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
7041 struct dwo_unit *dwo_entry;
7042 struct signatured_type find_sig_entry, *sig_entry;
7045 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7046 gdb_assert (dwp_file != NULL);
7048 /* If TU skeletons have been removed then we may not have read in any
7050 if (dwarf2_per_objfile->signatured_types == NULL)
7052 dwarf2_per_objfile->signatured_types
7053 = allocate_signatured_type_table (objfile);
7056 find_sig_entry.signature = sig;
7057 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7058 &find_sig_entry, INSERT);
7059 sig_entry = (struct signatured_type *) *slot;
7061 /* Have we already tried to read this TU?
7062 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7063 needn't exist in the global table yet). */
7064 if (sig_entry != NULL)
7067 if (dwp_file->tus == NULL)
7069 dwo_entry = lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, NULL,
7070 sig, 1 /* is_debug_types */);
7071 if (dwo_entry == NULL)
7074 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7075 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7080 /* Lookup a signature based type for DW_FORM_ref_sig8.
7081 Returns NULL if signature SIG is not present in the table.
7082 It is up to the caller to complain about this. */
7084 static struct signatured_type *
7085 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7087 struct dwarf2_per_objfile *dwarf2_per_objfile
7088 = cu->per_cu->dwarf2_per_objfile;
7091 && dwarf2_per_objfile->using_index)
7093 /* We're in a DWO/DWP file, and we're using .gdb_index.
7094 These cases require special processing. */
7095 if (get_dwp_file (dwarf2_per_objfile) == NULL)
7096 return lookup_dwo_signatured_type (cu, sig);
7098 return lookup_dwp_signatured_type (cu, sig);
7102 struct signatured_type find_entry, *entry;
7104 if (dwarf2_per_objfile->signatured_types == NULL)
7106 find_entry.signature = sig;
7107 entry = ((struct signatured_type *)
7108 htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
7113 /* Low level DIE reading support. */
7115 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7118 init_cu_die_reader (struct die_reader_specs *reader,
7119 struct dwarf2_cu *cu,
7120 struct dwarf2_section_info *section,
7121 struct dwo_file *dwo_file,
7122 struct abbrev_table *abbrev_table)
7124 gdb_assert (section->readin && section->buffer != NULL);
7125 reader->abfd = get_section_bfd_owner (section);
7127 reader->dwo_file = dwo_file;
7128 reader->die_section = section;
7129 reader->buffer = section->buffer;
7130 reader->buffer_end = section->buffer + section->size;
7131 reader->comp_dir = NULL;
7132 reader->abbrev_table = abbrev_table;
7135 /* Subroutine of init_cutu_and_read_dies to simplify it.
7136 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7137 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7140 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7141 from it to the DIE in the DWO. If NULL we are skipping the stub.
7142 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7143 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7144 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7145 STUB_COMP_DIR may be non-NULL.
7146 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7147 are filled in with the info of the DIE from the DWO file.
7148 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7149 from the dwo. Since *RESULT_READER references this abbrev table, it must be
7150 kept around for at least as long as *RESULT_READER.
7152 The result is non-zero if a valid (non-dummy) DIE was found. */
7155 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
7156 struct dwo_unit *dwo_unit,
7157 struct die_info *stub_comp_unit_die,
7158 const char *stub_comp_dir,
7159 struct die_reader_specs *result_reader,
7160 const gdb_byte **result_info_ptr,
7161 struct die_info **result_comp_unit_die,
7162 int *result_has_children,
7163 abbrev_table_up *result_dwo_abbrev_table)
7165 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7166 struct objfile *objfile = dwarf2_per_objfile->objfile;
7167 struct dwarf2_cu *cu = this_cu->cu;
7169 const gdb_byte *begin_info_ptr, *info_ptr;
7170 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
7171 int i,num_extra_attrs;
7172 struct dwarf2_section_info *dwo_abbrev_section;
7173 struct attribute *attr;
7174 struct die_info *comp_unit_die;
7176 /* At most one of these may be provided. */
7177 gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
7179 /* These attributes aren't processed until later:
7180 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7181 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7182 referenced later. However, these attributes are found in the stub
7183 which we won't have later. In order to not impose this complication
7184 on the rest of the code, we read them here and copy them to the
7193 if (stub_comp_unit_die != NULL)
7195 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7197 if (! this_cu->is_debug_types)
7198 stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
7199 low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
7200 high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
7201 ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
7202 comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
7204 /* There should be a DW_AT_addr_base attribute here (if needed).
7205 We need the value before we can process DW_FORM_GNU_addr_index. */
7207 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
7209 cu->addr_base = DW_UNSND (attr);
7211 /* There should be a DW_AT_ranges_base attribute here (if needed).
7212 We need the value before we can process DW_AT_ranges. */
7213 cu->ranges_base = 0;
7214 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
7216 cu->ranges_base = DW_UNSND (attr);
7218 else if (stub_comp_dir != NULL)
7220 /* Reconstruct the comp_dir attribute to simplify the code below. */
7221 comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
7222 comp_dir->name = DW_AT_comp_dir;
7223 comp_dir->form = DW_FORM_string;
7224 DW_STRING_IS_CANONICAL (comp_dir) = 0;
7225 DW_STRING (comp_dir) = stub_comp_dir;
7228 /* Set up for reading the DWO CU/TU. */
7229 cu->dwo_unit = dwo_unit;
7230 dwarf2_section_info *section = dwo_unit->section;
7231 dwarf2_read_section (objfile, section);
7232 abfd = get_section_bfd_owner (section);
7233 begin_info_ptr = info_ptr = (section->buffer
7234 + to_underlying (dwo_unit->sect_off));
7235 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
7237 if (this_cu->is_debug_types)
7239 struct signatured_type *sig_type = (struct signatured_type *) this_cu;
7241 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7242 &cu->header, section,
7244 info_ptr, rcuh_kind::TYPE);
7245 /* This is not an assert because it can be caused by bad debug info. */
7246 if (sig_type->signature != cu->header.signature)
7248 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7249 " TU at offset %s [in module %s]"),
7250 hex_string (sig_type->signature),
7251 hex_string (cu->header.signature),
7252 sect_offset_str (dwo_unit->sect_off),
7253 bfd_get_filename (abfd));
7255 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7256 /* For DWOs coming from DWP files, we don't know the CU length
7257 nor the type's offset in the TU until now. */
7258 dwo_unit->length = get_cu_length (&cu->header);
7259 dwo_unit->type_offset_in_tu = cu->header.type_cu_offset_in_tu;
7261 /* Establish the type offset that can be used to lookup the type.
7262 For DWO files, we don't know it until now. */
7263 sig_type->type_offset_in_section
7264 = dwo_unit->sect_off + to_underlying (dwo_unit->type_offset_in_tu);
7268 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7269 &cu->header, section,
7271 info_ptr, rcuh_kind::COMPILE);
7272 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7273 /* For DWOs coming from DWP files, we don't know the CU length
7275 dwo_unit->length = get_cu_length (&cu->header);
7278 *result_dwo_abbrev_table
7279 = abbrev_table_read_table (dwarf2_per_objfile, dwo_abbrev_section,
7280 cu->header.abbrev_sect_off);
7281 init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file,
7282 result_dwo_abbrev_table->get ());
7284 /* Read in the die, but leave space to copy over the attributes
7285 from the stub. This has the benefit of simplifying the rest of
7286 the code - all the work to maintain the illusion of a single
7287 DW_TAG_{compile,type}_unit DIE is done here. */
7288 num_extra_attrs = ((stmt_list != NULL)
7292 + (comp_dir != NULL));
7293 info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
7294 result_has_children, num_extra_attrs);
7296 /* Copy over the attributes from the stub to the DIE we just read in. */
7297 comp_unit_die = *result_comp_unit_die;
7298 i = comp_unit_die->num_attrs;
7299 if (stmt_list != NULL)
7300 comp_unit_die->attrs[i++] = *stmt_list;
7302 comp_unit_die->attrs[i++] = *low_pc;
7303 if (high_pc != NULL)
7304 comp_unit_die->attrs[i++] = *high_pc;
7306 comp_unit_die->attrs[i++] = *ranges;
7307 if (comp_dir != NULL)
7308 comp_unit_die->attrs[i++] = *comp_dir;
7309 comp_unit_die->num_attrs += num_extra_attrs;
7311 if (dwarf_die_debug)
7313 fprintf_unfiltered (gdb_stdlog,
7314 "Read die from %s@0x%x of %s:\n",
7315 get_section_name (section),
7316 (unsigned) (begin_info_ptr - section->buffer),
7317 bfd_get_filename (abfd));
7318 dump_die (comp_unit_die, dwarf_die_debug);
7321 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7322 TUs by skipping the stub and going directly to the entry in the DWO file.
7323 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7324 to get it via circuitous means. Blech. */
7325 if (comp_dir != NULL)
7326 result_reader->comp_dir = DW_STRING (comp_dir);
7328 /* Skip dummy compilation units. */
7329 if (info_ptr >= begin_info_ptr + dwo_unit->length
7330 || peek_abbrev_code (abfd, info_ptr) == 0)
7333 *result_info_ptr = info_ptr;
7337 /* Subroutine of init_cutu_and_read_dies to simplify it.
7338 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7339 Returns NULL if the specified DWO unit cannot be found. */
7341 static struct dwo_unit *
7342 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
7343 struct die_info *comp_unit_die)
7345 struct dwarf2_cu *cu = this_cu->cu;
7347 struct dwo_unit *dwo_unit;
7348 const char *comp_dir, *dwo_name;
7350 gdb_assert (cu != NULL);
7352 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7353 dwo_name = dwarf2_string_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7354 comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7356 if (this_cu->is_debug_types)
7358 struct signatured_type *sig_type;
7360 /* Since this_cu is the first member of struct signatured_type,
7361 we can go from a pointer to one to a pointer to the other. */
7362 sig_type = (struct signatured_type *) this_cu;
7363 signature = sig_type->signature;
7364 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
7368 struct attribute *attr;
7370 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
7372 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7374 dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
7375 signature = DW_UNSND (attr);
7376 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
7383 /* Subroutine of init_cutu_and_read_dies to simplify it.
7384 See it for a description of the parameters.
7385 Read a TU directly from a DWO file, bypassing the stub. */
7388 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
7389 int use_existing_cu, int keep,
7390 die_reader_func_ftype *die_reader_func,
7393 std::unique_ptr<dwarf2_cu> new_cu;
7394 struct signatured_type *sig_type;
7395 struct die_reader_specs reader;
7396 const gdb_byte *info_ptr;
7397 struct die_info *comp_unit_die;
7399 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7401 /* Verify we can do the following downcast, and that we have the
7403 gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
7404 sig_type = (struct signatured_type *) this_cu;
7405 gdb_assert (sig_type->dwo_unit != NULL);
7407 if (use_existing_cu && this_cu->cu != NULL)
7409 gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
7410 /* There's no need to do the rereading_dwo_cu handling that
7411 init_cutu_and_read_dies does since we don't read the stub. */
7415 /* If !use_existing_cu, this_cu->cu must be NULL. */
7416 gdb_assert (this_cu->cu == NULL);
7417 new_cu.reset (new dwarf2_cu (this_cu));
7420 /* A future optimization, if needed, would be to use an existing
7421 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7422 could share abbrev tables. */
7424 /* The abbreviation table used by READER, this must live at least as long as
7426 abbrev_table_up dwo_abbrev_table;
7428 if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
7429 NULL /* stub_comp_unit_die */,
7430 sig_type->dwo_unit->dwo_file->comp_dir,
7432 &comp_unit_die, &has_children,
7433 &dwo_abbrev_table) == 0)
7439 /* All the "real" work is done here. */
7440 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7442 /* This duplicates the code in init_cutu_and_read_dies,
7443 but the alternative is making the latter more complex.
7444 This function is only for the special case of using DWO files directly:
7445 no point in overly complicating the general case just to handle this. */
7446 if (new_cu != NULL && keep)
7448 /* Link this CU into read_in_chain. */
7449 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7450 dwarf2_per_objfile->read_in_chain = this_cu;
7451 /* The chain owns it now. */
7456 /* Initialize a CU (or TU) and read its DIEs.
7457 If the CU defers to a DWO file, read the DWO file as well.
7459 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7460 Otherwise the table specified in the comp unit header is read in and used.
7461 This is an optimization for when we already have the abbrev table.
7463 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7464 Otherwise, a new CU is allocated with xmalloc.
7466 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7467 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7469 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7470 linker) then DIE_READER_FUNC will not get called. */
7473 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
7474 struct abbrev_table *abbrev_table,
7475 int use_existing_cu, int keep,
7477 die_reader_func_ftype *die_reader_func,
7480 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7481 struct objfile *objfile = dwarf2_per_objfile->objfile;
7482 struct dwarf2_section_info *section = this_cu->section;
7483 bfd *abfd = get_section_bfd_owner (section);
7484 struct dwarf2_cu *cu;
7485 const gdb_byte *begin_info_ptr, *info_ptr;
7486 struct die_reader_specs reader;
7487 struct die_info *comp_unit_die;
7489 struct attribute *attr;
7490 struct signatured_type *sig_type = NULL;
7491 struct dwarf2_section_info *abbrev_section;
7492 /* Non-zero if CU currently points to a DWO file and we need to
7493 reread it. When this happens we need to reread the skeleton die
7494 before we can reread the DWO file (this only applies to CUs, not TUs). */
7495 int rereading_dwo_cu = 0;
7497 if (dwarf_die_debug)
7498 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7499 this_cu->is_debug_types ? "type" : "comp",
7500 sect_offset_str (this_cu->sect_off));
7502 if (use_existing_cu)
7505 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7506 file (instead of going through the stub), short-circuit all of this. */
7507 if (this_cu->reading_dwo_directly)
7509 /* Narrow down the scope of possibilities to have to understand. */
7510 gdb_assert (this_cu->is_debug_types);
7511 gdb_assert (abbrev_table == NULL);
7512 init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
7513 die_reader_func, data);
7517 /* This is cheap if the section is already read in. */
7518 dwarf2_read_section (objfile, section);
7520 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7522 abbrev_section = get_abbrev_section_for_cu (this_cu);
7524 std::unique_ptr<dwarf2_cu> new_cu;
7525 if (use_existing_cu && this_cu->cu != NULL)
7528 /* If this CU is from a DWO file we need to start over, we need to
7529 refetch the attributes from the skeleton CU.
7530 This could be optimized by retrieving those attributes from when we
7531 were here the first time: the previous comp_unit_die was stored in
7532 comp_unit_obstack. But there's no data yet that we need this
7534 if (cu->dwo_unit != NULL)
7535 rereading_dwo_cu = 1;
7539 /* If !use_existing_cu, this_cu->cu must be NULL. */
7540 gdb_assert (this_cu->cu == NULL);
7541 new_cu.reset (new dwarf2_cu (this_cu));
7545 /* Get the header. */
7546 if (to_underlying (cu->header.first_die_cu_offset) != 0 && !rereading_dwo_cu)
7548 /* We already have the header, there's no need to read it in again. */
7549 info_ptr += to_underlying (cu->header.first_die_cu_offset);
7553 if (this_cu->is_debug_types)
7555 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7556 &cu->header, section,
7557 abbrev_section, info_ptr,
7560 /* Since per_cu is the first member of struct signatured_type,
7561 we can go from a pointer to one to a pointer to the other. */
7562 sig_type = (struct signatured_type *) this_cu;
7563 gdb_assert (sig_type->signature == cu->header.signature);
7564 gdb_assert (sig_type->type_offset_in_tu
7565 == cu->header.type_cu_offset_in_tu);
7566 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7568 /* LENGTH has not been set yet for type units if we're
7569 using .gdb_index. */
7570 this_cu->length = get_cu_length (&cu->header);
7572 /* Establish the type offset that can be used to lookup the type. */
7573 sig_type->type_offset_in_section =
7574 this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu);
7576 this_cu->dwarf_version = cu->header.version;
7580 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7581 &cu->header, section,
7584 rcuh_kind::COMPILE);
7586 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7587 gdb_assert (this_cu->length == get_cu_length (&cu->header));
7588 this_cu->dwarf_version = cu->header.version;
7592 /* Skip dummy compilation units. */
7593 if (info_ptr >= begin_info_ptr + this_cu->length
7594 || peek_abbrev_code (abfd, info_ptr) == 0)
7597 /* If we don't have them yet, read the abbrevs for this compilation unit.
7598 And if we need to read them now, make sure they're freed when we're
7599 done (own the table through ABBREV_TABLE_HOLDER). */
7600 abbrev_table_up abbrev_table_holder;
7601 if (abbrev_table != NULL)
7602 gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off);
7606 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7607 cu->header.abbrev_sect_off);
7608 abbrev_table = abbrev_table_holder.get ();
7611 /* Read the top level CU/TU die. */
7612 init_cu_die_reader (&reader, cu, section, NULL, abbrev_table);
7613 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7615 if (skip_partial && comp_unit_die->tag == DW_TAG_partial_unit)
7618 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7619 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7620 table from the DWO file and pass the ownership over to us. It will be
7621 referenced from READER, so we must make sure to free it after we're done
7624 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7625 DWO CU, that this test will fail (the attribute will not be present). */
7626 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7627 abbrev_table_up dwo_abbrev_table;
7630 struct dwo_unit *dwo_unit;
7631 struct die_info *dwo_comp_unit_die;
7635 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7636 " has children (offset %s) [in module %s]"),
7637 sect_offset_str (this_cu->sect_off),
7638 bfd_get_filename (abfd));
7640 dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
7641 if (dwo_unit != NULL)
7643 if (read_cutu_die_from_dwo (this_cu, dwo_unit,
7644 comp_unit_die, NULL,
7646 &dwo_comp_unit_die, &has_children,
7647 &dwo_abbrev_table) == 0)
7652 comp_unit_die = dwo_comp_unit_die;
7656 /* Yikes, we couldn't find the rest of the DIE, we only have
7657 the stub. A complaint has already been logged. There's
7658 not much more we can do except pass on the stub DIE to
7659 die_reader_func. We don't want to throw an error on bad
7664 /* All of the above is setup for this call. Yikes. */
7665 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7667 /* Done, clean up. */
7668 if (new_cu != NULL && keep)
7670 /* Link this CU into read_in_chain. */
7671 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7672 dwarf2_per_objfile->read_in_chain = this_cu;
7673 /* The chain owns it now. */
7678 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7679 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7680 to have already done the lookup to find the DWO file).
7682 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7683 THIS_CU->is_debug_types, but nothing else.
7685 We fill in THIS_CU->length.
7687 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7688 linker) then DIE_READER_FUNC will not get called.
7690 THIS_CU->cu is always freed when done.
7691 This is done in order to not leave THIS_CU->cu in a state where we have
7692 to care whether it refers to the "main" CU or the DWO CU. */
7695 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
7696 struct dwo_file *dwo_file,
7697 die_reader_func_ftype *die_reader_func,
7700 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7701 struct objfile *objfile = dwarf2_per_objfile->objfile;
7702 struct dwarf2_section_info *section = this_cu->section;
7703 bfd *abfd = get_section_bfd_owner (section);
7704 struct dwarf2_section_info *abbrev_section;
7705 const gdb_byte *begin_info_ptr, *info_ptr;
7706 struct die_reader_specs reader;
7707 struct die_info *comp_unit_die;
7710 if (dwarf_die_debug)
7711 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7712 this_cu->is_debug_types ? "type" : "comp",
7713 sect_offset_str (this_cu->sect_off));
7715 gdb_assert (this_cu->cu == NULL);
7717 abbrev_section = (dwo_file != NULL
7718 ? &dwo_file->sections.abbrev
7719 : get_abbrev_section_for_cu (this_cu));
7721 /* This is cheap if the section is already read in. */
7722 dwarf2_read_section (objfile, section);
7724 struct dwarf2_cu cu (this_cu);
7726 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7727 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7728 &cu.header, section,
7729 abbrev_section, info_ptr,
7730 (this_cu->is_debug_types
7732 : rcuh_kind::COMPILE));
7734 this_cu->length = get_cu_length (&cu.header);
7736 /* Skip dummy compilation units. */
7737 if (info_ptr >= begin_info_ptr + this_cu->length
7738 || peek_abbrev_code (abfd, info_ptr) == 0)
7741 abbrev_table_up abbrev_table
7742 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7743 cu.header.abbrev_sect_off);
7745 init_cu_die_reader (&reader, &cu, section, dwo_file, abbrev_table.get ());
7746 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7748 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7751 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7752 does not lookup the specified DWO file.
7753 This cannot be used to read DWO files.
7755 THIS_CU->cu is always freed when done.
7756 This is done in order to not leave THIS_CU->cu in a state where we have
7757 to care whether it refers to the "main" CU or the DWO CU.
7758 We can revisit this if the data shows there's a performance issue. */
7761 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
7762 die_reader_func_ftype *die_reader_func,
7765 init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
7768 /* Type Unit Groups.
7770 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7771 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7772 so that all types coming from the same compilation (.o file) are grouped
7773 together. A future step could be to put the types in the same symtab as
7774 the CU the types ultimately came from. */
7777 hash_type_unit_group (const void *item)
7779 const struct type_unit_group *tu_group
7780 = (const struct type_unit_group *) item;
7782 return hash_stmt_list_entry (&tu_group->hash);
7786 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
7788 const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
7789 const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
7791 return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
7794 /* Allocate a hash table for type unit groups. */
7797 allocate_type_unit_groups_table (struct objfile *objfile)
7799 return htab_create_alloc_ex (3,
7800 hash_type_unit_group,
7803 &objfile->objfile_obstack,
7804 hashtab_obstack_allocate,
7805 dummy_obstack_deallocate);
7808 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7809 partial symtabs. We combine several TUs per psymtab to not let the size
7810 of any one psymtab grow too big. */
7811 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7812 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7814 /* Helper routine for get_type_unit_group.
7815 Create the type_unit_group object used to hold one or more TUs. */
7817 static struct type_unit_group *
7818 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
7820 struct dwarf2_per_objfile *dwarf2_per_objfile
7821 = cu->per_cu->dwarf2_per_objfile;
7822 struct objfile *objfile = dwarf2_per_objfile->objfile;
7823 struct dwarf2_per_cu_data *per_cu;
7824 struct type_unit_group *tu_group;
7826 tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7827 struct type_unit_group);
7828 per_cu = &tu_group->per_cu;
7829 per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
7831 if (dwarf2_per_objfile->using_index)
7833 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7834 struct dwarf2_per_cu_quick_data);
7838 unsigned int line_offset = to_underlying (line_offset_struct);
7839 struct partial_symtab *pst;
7842 /* Give the symtab a useful name for debug purposes. */
7843 if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
7844 name = string_printf ("<type_units_%d>",
7845 (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
7847 name = string_printf ("<type_units_at_0x%x>", line_offset);
7849 pst = create_partial_symtab (per_cu, name.c_str ());
7853 tu_group->hash.dwo_unit = cu->dwo_unit;
7854 tu_group->hash.line_sect_off = line_offset_struct;
7859 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7860 STMT_LIST is a DW_AT_stmt_list attribute. */
7862 static struct type_unit_group *
7863 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
7865 struct dwarf2_per_objfile *dwarf2_per_objfile
7866 = cu->per_cu->dwarf2_per_objfile;
7867 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
7868 struct type_unit_group *tu_group;
7870 unsigned int line_offset;
7871 struct type_unit_group type_unit_group_for_lookup;
7873 if (dwarf2_per_objfile->type_unit_groups == NULL)
7875 dwarf2_per_objfile->type_unit_groups =
7876 allocate_type_unit_groups_table (dwarf2_per_objfile->objfile);
7879 /* Do we need to create a new group, or can we use an existing one? */
7883 line_offset = DW_UNSND (stmt_list);
7884 ++tu_stats->nr_symtab_sharers;
7888 /* Ugh, no stmt_list. Rare, but we have to handle it.
7889 We can do various things here like create one group per TU or
7890 spread them over multiple groups to split up the expansion work.
7891 To avoid worst case scenarios (too many groups or too large groups)
7892 we, umm, group them in bunches. */
7893 line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7894 | (tu_stats->nr_stmt_less_type_units
7895 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
7896 ++tu_stats->nr_stmt_less_type_units;
7899 type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
7900 type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;
7901 slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
7902 &type_unit_group_for_lookup, INSERT);
7905 tu_group = (struct type_unit_group *) *slot;
7906 gdb_assert (tu_group != NULL);
7910 sect_offset line_offset_struct = (sect_offset) line_offset;
7911 tu_group = create_type_unit_group (cu, line_offset_struct);
7913 ++tu_stats->nr_symtabs;
7919 /* Partial symbol tables. */
7921 /* Create a psymtab named NAME and assign it to PER_CU.
7923 The caller must fill in the following details:
7924 dirname, textlow, texthigh. */
7926 static struct partial_symtab *
7927 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
7929 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
7930 struct partial_symtab *pst;
7932 pst = start_psymtab_common (objfile, name, 0);
7934 pst->psymtabs_addrmap_supported = 1;
7936 /* This is the glue that links PST into GDB's symbol API. */
7937 pst->read_symtab_private = per_cu;
7938 pst->read_symtab = dwarf2_read_symtab;
7939 per_cu->v.psymtab = pst;
7944 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7947 struct process_psymtab_comp_unit_data
7949 /* True if we are reading a DW_TAG_partial_unit. */
7951 int want_partial_unit;
7953 /* The "pretend" language that is used if the CU doesn't declare a
7956 enum language pretend_language;
7959 /* die_reader_func for process_psymtab_comp_unit. */
7962 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
7963 const gdb_byte *info_ptr,
7964 struct die_info *comp_unit_die,
7968 struct dwarf2_cu *cu = reader->cu;
7969 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
7970 struct gdbarch *gdbarch = get_objfile_arch (objfile);
7971 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
7973 CORE_ADDR best_lowpc = 0, best_highpc = 0;
7974 struct partial_symtab *pst;
7975 enum pc_bounds_kind cu_bounds_kind;
7976 const char *filename;
7977 struct process_psymtab_comp_unit_data *info
7978 = (struct process_psymtab_comp_unit_data *) data;
7980 if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
7983 gdb_assert (! per_cu->is_debug_types);
7985 prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
7987 /* Allocate a new partial symbol table structure. */
7988 filename = dwarf2_string_attr (comp_unit_die, DW_AT_name, cu);
7989 if (filename == NULL)
7992 pst = create_partial_symtab (per_cu, filename);
7994 /* This must be done before calling dwarf2_build_include_psymtabs. */
7995 pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7997 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7999 dwarf2_find_base_address (comp_unit_die, cu);
8001 /* Possibly set the default values of LOWPC and HIGHPC from
8003 cu_bounds_kind = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
8004 &best_highpc, cu, pst);
8005 if (cu_bounds_kind == PC_BOUNDS_HIGH_LOW && best_lowpc < best_highpc)
8008 = (gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr)
8011 = (gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr)
8013 /* Store the contiguous range if it is not empty; it can be
8014 empty for CUs with no code. */
8015 addrmap_set_empty (objfile->psymtabs_addrmap, low, high, pst);
8018 /* Check if comp unit has_children.
8019 If so, read the rest of the partial symbols from this comp unit.
8020 If not, there's no more debug_info for this comp unit. */
8023 struct partial_die_info *first_die;
8024 CORE_ADDR lowpc, highpc;
8026 lowpc = ((CORE_ADDR) -1);
8027 highpc = ((CORE_ADDR) 0);
8029 first_die = load_partial_dies (reader, info_ptr, 1);
8031 scan_partial_symbols (first_die, &lowpc, &highpc,
8032 cu_bounds_kind <= PC_BOUNDS_INVALID, cu);
8034 /* If we didn't find a lowpc, set it to highpc to avoid
8035 complaints from `maint check'. */
8036 if (lowpc == ((CORE_ADDR) -1))
8039 /* If the compilation unit didn't have an explicit address range,
8040 then use the information extracted from its child dies. */
8041 if (cu_bounds_kind <= PC_BOUNDS_INVALID)
8044 best_highpc = highpc;
8047 pst->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch,
8048 best_lowpc + baseaddr)
8050 pst->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch,
8051 best_highpc + baseaddr)
8054 end_psymtab_common (objfile, pst);
8056 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
8059 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8060 struct dwarf2_per_cu_data *iter;
8062 /* Fill in 'dependencies' here; we fill in 'users' in a
8064 pst->number_of_dependencies = len;
8066 XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
8068 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8071 pst->dependencies[i] = iter->v.psymtab;
8073 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8076 /* Get the list of files included in the current compilation unit,
8077 and build a psymtab for each of them. */
8078 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
8080 if (dwarf_read_debug)
8081 fprintf_unfiltered (gdb_stdlog,
8082 "Psymtab for %s unit @%s: %s - %s"
8083 ", %d global, %d static syms\n",
8084 per_cu->is_debug_types ? "type" : "comp",
8085 sect_offset_str (per_cu->sect_off),
8086 paddress (gdbarch, pst->text_low (objfile)),
8087 paddress (gdbarch, pst->text_high (objfile)),
8088 pst->n_global_syms, pst->n_static_syms);
8091 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8092 Process compilation unit THIS_CU for a psymtab. */
8095 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
8096 int want_partial_unit,
8097 enum language pretend_language)
8099 /* If this compilation unit was already read in, free the
8100 cached copy in order to read it in again. This is
8101 necessary because we skipped some symbols when we first
8102 read in the compilation unit (see load_partial_dies).
8103 This problem could be avoided, but the benefit is unclear. */
8104 if (this_cu->cu != NULL)
8105 free_one_cached_comp_unit (this_cu);
8107 if (this_cu->is_debug_types)
8108 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8109 build_type_psymtabs_reader, NULL);
8112 process_psymtab_comp_unit_data info;
8113 info.want_partial_unit = want_partial_unit;
8114 info.pretend_language = pretend_language;
8115 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8116 process_psymtab_comp_unit_reader, &info);
8119 /* Age out any secondary CUs. */
8120 age_cached_comp_units (this_cu->dwarf2_per_objfile);
8123 /* Reader function for build_type_psymtabs. */
8126 build_type_psymtabs_reader (const struct die_reader_specs *reader,
8127 const gdb_byte *info_ptr,
8128 struct die_info *type_unit_die,
8132 struct dwarf2_per_objfile *dwarf2_per_objfile
8133 = reader->cu->per_cu->dwarf2_per_objfile;
8134 struct objfile *objfile = dwarf2_per_objfile->objfile;
8135 struct dwarf2_cu *cu = reader->cu;
8136 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8137 struct signatured_type *sig_type;
8138 struct type_unit_group *tu_group;
8139 struct attribute *attr;
8140 struct partial_die_info *first_die;
8141 CORE_ADDR lowpc, highpc;
8142 struct partial_symtab *pst;
8144 gdb_assert (data == NULL);
8145 gdb_assert (per_cu->is_debug_types);
8146 sig_type = (struct signatured_type *) per_cu;
8151 attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
8152 tu_group = get_type_unit_group (cu, attr);
8154 VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
8156 prepare_one_comp_unit (cu, type_unit_die, language_minimal);
8157 pst = create_partial_symtab (per_cu, "");
8160 first_die = load_partial_dies (reader, info_ptr, 1);
8162 lowpc = (CORE_ADDR) -1;
8163 highpc = (CORE_ADDR) 0;
8164 scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
8166 end_psymtab_common (objfile, pst);
8169 /* Struct used to sort TUs by their abbreviation table offset. */
8171 struct tu_abbrev_offset
8173 tu_abbrev_offset (signatured_type *sig_type_, sect_offset abbrev_offset_)
8174 : sig_type (sig_type_), abbrev_offset (abbrev_offset_)
8177 signatured_type *sig_type;
8178 sect_offset abbrev_offset;
8181 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
8184 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset &a,
8185 const struct tu_abbrev_offset &b)
8187 return a.abbrev_offset < b.abbrev_offset;
8190 /* Efficiently read all the type units.
8191 This does the bulk of the work for build_type_psymtabs.
8193 The efficiency is because we sort TUs by the abbrev table they use and
8194 only read each abbrev table once. In one program there are 200K TUs
8195 sharing 8K abbrev tables.
8197 The main purpose of this function is to support building the
8198 dwarf2_per_objfile->type_unit_groups table.
8199 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8200 can collapse the search space by grouping them by stmt_list.
8201 The savings can be significant, in the same program from above the 200K TUs
8202 share 8K stmt_list tables.
8204 FUNC is expected to call get_type_unit_group, which will create the
8205 struct type_unit_group if necessary and add it to
8206 dwarf2_per_objfile->type_unit_groups. */
8209 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
8211 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8212 abbrev_table_up abbrev_table;
8213 sect_offset abbrev_offset;
8215 /* It's up to the caller to not call us multiple times. */
8216 gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
8218 if (dwarf2_per_objfile->all_type_units.empty ())
8221 /* TUs typically share abbrev tables, and there can be way more TUs than
8222 abbrev tables. Sort by abbrev table to reduce the number of times we
8223 read each abbrev table in.
8224 Alternatives are to punt or to maintain a cache of abbrev tables.
8225 This is simpler and efficient enough for now.
8227 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8228 symtab to use). Typically TUs with the same abbrev offset have the same
8229 stmt_list value too so in practice this should work well.
8231 The basic algorithm here is:
8233 sort TUs by abbrev table
8234 for each TU with same abbrev table:
8235 read abbrev table if first user
8236 read TU top level DIE
8237 [IWBN if DWO skeletons had DW_AT_stmt_list]
8240 if (dwarf_read_debug)
8241 fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
8243 /* Sort in a separate table to maintain the order of all_type_units
8244 for .gdb_index: TU indices directly index all_type_units. */
8245 std::vector<tu_abbrev_offset> sorted_by_abbrev;
8246 sorted_by_abbrev.reserve (dwarf2_per_objfile->all_type_units.size ());
8248 for (signatured_type *sig_type : dwarf2_per_objfile->all_type_units)
8249 sorted_by_abbrev.emplace_back
8250 (sig_type, read_abbrev_offset (dwarf2_per_objfile,
8251 sig_type->per_cu.section,
8252 sig_type->per_cu.sect_off));
8254 std::sort (sorted_by_abbrev.begin (), sorted_by_abbrev.end (),
8255 sort_tu_by_abbrev_offset);
8257 abbrev_offset = (sect_offset) ~(unsigned) 0;
8259 for (const tu_abbrev_offset &tu : sorted_by_abbrev)
8261 /* Switch to the next abbrev table if necessary. */
8262 if (abbrev_table == NULL
8263 || tu.abbrev_offset != abbrev_offset)
8265 abbrev_offset = tu.abbrev_offset;
8267 abbrev_table_read_table (dwarf2_per_objfile,
8268 &dwarf2_per_objfile->abbrev,
8270 ++tu_stats->nr_uniq_abbrev_tables;
8273 init_cutu_and_read_dies (&tu.sig_type->per_cu, abbrev_table.get (),
8274 0, 0, false, build_type_psymtabs_reader, NULL);
8278 /* Print collected type unit statistics. */
8281 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
8283 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8285 fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
8286 fprintf_unfiltered (gdb_stdlog, " %zu TUs\n",
8287 dwarf2_per_objfile->all_type_units.size ());
8288 fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
8289 tu_stats->nr_uniq_abbrev_tables);
8290 fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
8291 tu_stats->nr_symtabs);
8292 fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
8293 tu_stats->nr_symtab_sharers);
8294 fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
8295 tu_stats->nr_stmt_less_type_units);
8296 fprintf_unfiltered (gdb_stdlog, " %d all_type_units reallocs\n",
8297 tu_stats->nr_all_type_units_reallocs);
8300 /* Traversal function for build_type_psymtabs. */
8303 build_type_psymtab_dependencies (void **slot, void *info)
8305 struct dwarf2_per_objfile *dwarf2_per_objfile
8306 = (struct dwarf2_per_objfile *) info;
8307 struct objfile *objfile = dwarf2_per_objfile->objfile;
8308 struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
8309 struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
8310 struct partial_symtab *pst = per_cu->v.psymtab;
8311 int len = VEC_length (sig_type_ptr, tu_group->tus);
8312 struct signatured_type *iter;
8315 gdb_assert (len > 0);
8316 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
8318 pst->number_of_dependencies = len;
8320 XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
8322 VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
8325 gdb_assert (iter->per_cu.is_debug_types);
8326 pst->dependencies[i] = iter->per_cu.v.psymtab;
8327 iter->type_unit_group = tu_group;
8330 VEC_free (sig_type_ptr, tu_group->tus);
8335 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8336 Build partial symbol tables for the .debug_types comp-units. */
8339 build_type_psymtabs (struct dwarf2_per_objfile *dwarf2_per_objfile)
8341 if (! create_all_type_units (dwarf2_per_objfile))
8344 build_type_psymtabs_1 (dwarf2_per_objfile);
8347 /* Traversal function for process_skeletonless_type_unit.
8348 Read a TU in a DWO file and build partial symbols for it. */
8351 process_skeletonless_type_unit (void **slot, void *info)
8353 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
8354 struct dwarf2_per_objfile *dwarf2_per_objfile
8355 = (struct dwarf2_per_objfile *) info;
8356 struct signatured_type find_entry, *entry;
8358 /* If this TU doesn't exist in the global table, add it and read it in. */
8360 if (dwarf2_per_objfile->signatured_types == NULL)
8362 dwarf2_per_objfile->signatured_types
8363 = allocate_signatured_type_table (dwarf2_per_objfile->objfile);
8366 find_entry.signature = dwo_unit->signature;
8367 slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
8369 /* If we've already seen this type there's nothing to do. What's happening
8370 is we're doing our own version of comdat-folding here. */
8374 /* This does the job that create_all_type_units would have done for
8376 entry = add_type_unit (dwarf2_per_objfile, dwo_unit->signature, slot);
8377 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, entry, dwo_unit);
8380 /* This does the job that build_type_psymtabs_1 would have done. */
8381 init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0, false,
8382 build_type_psymtabs_reader, NULL);
8387 /* Traversal function for process_skeletonless_type_units. */
8390 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
8392 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
8394 if (dwo_file->tus != NULL)
8396 htab_traverse_noresize (dwo_file->tus,
8397 process_skeletonless_type_unit, info);
8403 /* Scan all TUs of DWO files, verifying we've processed them.
8404 This is needed in case a TU was emitted without its skeleton.
8405 Note: This can't be done until we know what all the DWO files are. */
8408 process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8410 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8411 if (get_dwp_file (dwarf2_per_objfile) == NULL
8412 && dwarf2_per_objfile->dwo_files != NULL)
8414 htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
8415 process_dwo_file_for_skeletonless_type_units,
8416 dwarf2_per_objfile);
8420 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8423 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
8425 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8427 struct partial_symtab *pst = per_cu->v.psymtab;
8432 for (int j = 0; j < pst->number_of_dependencies; ++j)
8434 /* Set the 'user' field only if it is not already set. */
8435 if (pst->dependencies[j]->user == NULL)
8436 pst->dependencies[j]->user = pst;
8441 /* Build the partial symbol table by doing a quick pass through the
8442 .debug_info and .debug_abbrev sections. */
8445 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
8447 struct objfile *objfile = dwarf2_per_objfile->objfile;
8449 if (dwarf_read_debug)
8451 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
8452 objfile_name (objfile));
8455 dwarf2_per_objfile->reading_partial_symbols = 1;
8457 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
8459 /* Any cached compilation units will be linked by the per-objfile
8460 read_in_chain. Make sure to free them when we're done. */
8461 free_cached_comp_units freer (dwarf2_per_objfile);
8463 build_type_psymtabs (dwarf2_per_objfile);
8465 create_all_comp_units (dwarf2_per_objfile);
8467 /* Create a temporary address map on a temporary obstack. We later
8468 copy this to the final obstack. */
8469 auto_obstack temp_obstack;
8471 scoped_restore save_psymtabs_addrmap
8472 = make_scoped_restore (&objfile->psymtabs_addrmap,
8473 addrmap_create_mutable (&temp_obstack));
8475 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8476 process_psymtab_comp_unit (per_cu, 0, language_minimal);
8478 /* This has to wait until we read the CUs, we need the list of DWOs. */
8479 process_skeletonless_type_units (dwarf2_per_objfile);
8481 /* Now that all TUs have been processed we can fill in the dependencies. */
8482 if (dwarf2_per_objfile->type_unit_groups != NULL)
8484 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
8485 build_type_psymtab_dependencies, dwarf2_per_objfile);
8488 if (dwarf_read_debug)
8489 print_tu_stats (dwarf2_per_objfile);
8491 set_partial_user (dwarf2_per_objfile);
8493 objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
8494 &objfile->objfile_obstack);
8495 /* At this point we want to keep the address map. */
8496 save_psymtabs_addrmap.release ();
8498 if (dwarf_read_debug)
8499 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
8500 objfile_name (objfile));
8503 /* die_reader_func for load_partial_comp_unit. */
8506 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
8507 const gdb_byte *info_ptr,
8508 struct die_info *comp_unit_die,
8512 struct dwarf2_cu *cu = reader->cu;
8514 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
8516 /* Check if comp unit has_children.
8517 If so, read the rest of the partial symbols from this comp unit.
8518 If not, there's no more debug_info for this comp unit. */
8520 load_partial_dies (reader, info_ptr, 0);
8523 /* Load the partial DIEs for a secondary CU into memory.
8524 This is also used when rereading a primary CU with load_all_dies. */
8527 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
8529 init_cutu_and_read_dies (this_cu, NULL, 1, 1, false,
8530 load_partial_comp_unit_reader, NULL);
8534 read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
8535 struct dwarf2_section_info *section,
8536 struct dwarf2_section_info *abbrev_section,
8537 unsigned int is_dwz)
8539 const gdb_byte *info_ptr;
8540 struct objfile *objfile = dwarf2_per_objfile->objfile;
8542 if (dwarf_read_debug)
8543 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
8544 get_section_name (section),
8545 get_section_file_name (section));
8547 dwarf2_read_section (objfile, section);
8549 info_ptr = section->buffer;
8551 while (info_ptr < section->buffer + section->size)
8553 struct dwarf2_per_cu_data *this_cu;
8555 sect_offset sect_off = (sect_offset) (info_ptr - section->buffer);
8557 comp_unit_head cu_header;
8558 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
8559 abbrev_section, info_ptr,
8560 rcuh_kind::COMPILE);
8562 /* Save the compilation unit for later lookup. */
8563 if (cu_header.unit_type != DW_UT_type)
8565 this_cu = XOBNEW (&objfile->objfile_obstack,
8566 struct dwarf2_per_cu_data);
8567 memset (this_cu, 0, sizeof (*this_cu));
8571 auto sig_type = XOBNEW (&objfile->objfile_obstack,
8572 struct signatured_type);
8573 memset (sig_type, 0, sizeof (*sig_type));
8574 sig_type->signature = cu_header.signature;
8575 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
8576 this_cu = &sig_type->per_cu;
8578 this_cu->is_debug_types = (cu_header.unit_type == DW_UT_type);
8579 this_cu->sect_off = sect_off;
8580 this_cu->length = cu_header.length + cu_header.initial_length_size;
8581 this_cu->is_dwz = is_dwz;
8582 this_cu->dwarf2_per_objfile = dwarf2_per_objfile;
8583 this_cu->section = section;
8585 dwarf2_per_objfile->all_comp_units.push_back (this_cu);
8587 info_ptr = info_ptr + this_cu->length;
8591 /* Create a list of all compilation units in OBJFILE.
8592 This is only done for -readnow and building partial symtabs. */
8595 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8597 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
8598 read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
8599 &dwarf2_per_objfile->abbrev, 0);
8601 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
8603 read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
8607 /* Process all loaded DIEs for compilation unit CU, starting at
8608 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8609 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8610 DW_AT_ranges). See the comments of add_partial_subprogram on how
8611 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8614 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
8615 CORE_ADDR *highpc, int set_addrmap,
8616 struct dwarf2_cu *cu)
8618 struct partial_die_info *pdi;
8620 /* Now, march along the PDI's, descending into ones which have
8621 interesting children but skipping the children of the other ones,
8622 until we reach the end of the compilation unit. */
8630 /* Anonymous namespaces or modules have no name but have interesting
8631 children, so we need to look at them. Ditto for anonymous
8634 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
8635 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
8636 || pdi->tag == DW_TAG_imported_unit
8637 || pdi->tag == DW_TAG_inlined_subroutine)
8641 case DW_TAG_subprogram:
8642 case DW_TAG_inlined_subroutine:
8643 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
8645 case DW_TAG_constant:
8646 case DW_TAG_variable:
8647 case DW_TAG_typedef:
8648 case DW_TAG_union_type:
8649 if (!pdi->is_declaration)
8651 add_partial_symbol (pdi, cu);
8654 case DW_TAG_class_type:
8655 case DW_TAG_interface_type:
8656 case DW_TAG_structure_type:
8657 if (!pdi->is_declaration)
8659 add_partial_symbol (pdi, cu);
8661 if ((cu->language == language_rust
8662 || cu->language == language_cplus) && pdi->has_children)
8663 scan_partial_symbols (pdi->die_child, lowpc, highpc,
8666 case DW_TAG_enumeration_type:
8667 if (!pdi->is_declaration)
8668 add_partial_enumeration (pdi, cu);
8670 case DW_TAG_base_type:
8671 case DW_TAG_subrange_type:
8672 /* File scope base type definitions are added to the partial
8674 add_partial_symbol (pdi, cu);
8676 case DW_TAG_namespace:
8677 add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
8680 add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
8682 case DW_TAG_imported_unit:
8684 struct dwarf2_per_cu_data *per_cu;
8686 /* For now we don't handle imported units in type units. */
8687 if (cu->per_cu->is_debug_types)
8689 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8690 " supported in type units [in module %s]"),
8691 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
8694 per_cu = dwarf2_find_containing_comp_unit
8695 (pdi->d.sect_off, pdi->is_dwz,
8696 cu->per_cu->dwarf2_per_objfile);
8698 /* Go read the partial unit, if needed. */
8699 if (per_cu->v.psymtab == NULL)
8700 process_psymtab_comp_unit (per_cu, 1, cu->language);
8702 VEC_safe_push (dwarf2_per_cu_ptr,
8703 cu->per_cu->imported_symtabs, per_cu);
8706 case DW_TAG_imported_declaration:
8707 add_partial_symbol (pdi, cu);
8714 /* If the die has a sibling, skip to the sibling. */
8716 pdi = pdi->die_sibling;
8720 /* Functions used to compute the fully scoped name of a partial DIE.
8722 Normally, this is simple. For C++, the parent DIE's fully scoped
8723 name is concatenated with "::" and the partial DIE's name.
8724 Enumerators are an exception; they use the scope of their parent
8725 enumeration type, i.e. the name of the enumeration type is not
8726 prepended to the enumerator.
8728 There are two complexities. One is DW_AT_specification; in this
8729 case "parent" means the parent of the target of the specification,
8730 instead of the direct parent of the DIE. The other is compilers
8731 which do not emit DW_TAG_namespace; in this case we try to guess
8732 the fully qualified name of structure types from their members'
8733 linkage names. This must be done using the DIE's children rather
8734 than the children of any DW_AT_specification target. We only need
8735 to do this for structures at the top level, i.e. if the target of
8736 any DW_AT_specification (if any; otherwise the DIE itself) does not
8739 /* Compute the scope prefix associated with PDI's parent, in
8740 compilation unit CU. The result will be allocated on CU's
8741 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8742 field. NULL is returned if no prefix is necessary. */
8744 partial_die_parent_scope (struct partial_die_info *pdi,
8745 struct dwarf2_cu *cu)
8747 const char *grandparent_scope;
8748 struct partial_die_info *parent, *real_pdi;
8750 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8751 then this means the parent of the specification DIE. */
8754 while (real_pdi->has_specification)
8755 real_pdi = find_partial_die (real_pdi->spec_offset,
8756 real_pdi->spec_is_dwz, cu);
8758 parent = real_pdi->die_parent;
8762 if (parent->scope_set)
8763 return parent->scope;
8767 grandparent_scope = partial_die_parent_scope (parent, cu);
8769 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8770 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8771 Work around this problem here. */
8772 if (cu->language == language_cplus
8773 && parent->tag == DW_TAG_namespace
8774 && strcmp (parent->name, "::") == 0
8775 && grandparent_scope == NULL)
8777 parent->scope = NULL;
8778 parent->scope_set = 1;
8782 if (pdi->tag == DW_TAG_enumerator)
8783 /* Enumerators should not get the name of the enumeration as a prefix. */
8784 parent->scope = grandparent_scope;
8785 else if (parent->tag == DW_TAG_namespace
8786 || parent->tag == DW_TAG_module
8787 || parent->tag == DW_TAG_structure_type
8788 || parent->tag == DW_TAG_class_type
8789 || parent->tag == DW_TAG_interface_type
8790 || parent->tag == DW_TAG_union_type
8791 || parent->tag == DW_TAG_enumeration_type)
8793 if (grandparent_scope == NULL)
8794 parent->scope = parent->name;
8796 parent->scope = typename_concat (&cu->comp_unit_obstack,
8798 parent->name, 0, cu);
8802 /* FIXME drow/2004-04-01: What should we be doing with
8803 function-local names? For partial symbols, we should probably be
8805 complaint (_("unhandled containing DIE tag %d for DIE at %s"),
8806 parent->tag, sect_offset_str (pdi->sect_off));
8807 parent->scope = grandparent_scope;
8810 parent->scope_set = 1;
8811 return parent->scope;
8814 /* Return the fully scoped name associated with PDI, from compilation unit
8815 CU. The result will be allocated with malloc. */
8818 partial_die_full_name (struct partial_die_info *pdi,
8819 struct dwarf2_cu *cu)
8821 const char *parent_scope;
8823 /* If this is a template instantiation, we can not work out the
8824 template arguments from partial DIEs. So, unfortunately, we have
8825 to go through the full DIEs. At least any work we do building
8826 types here will be reused if full symbols are loaded later. */
8827 if (pdi->has_template_arguments)
8831 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
8833 struct die_info *die;
8834 struct attribute attr;
8835 struct dwarf2_cu *ref_cu = cu;
8837 /* DW_FORM_ref_addr is using section offset. */
8838 attr.name = (enum dwarf_attribute) 0;
8839 attr.form = DW_FORM_ref_addr;
8840 attr.u.unsnd = to_underlying (pdi->sect_off);
8841 die = follow_die_ref (NULL, &attr, &ref_cu);
8843 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
8847 parent_scope = partial_die_parent_scope (pdi, cu);
8848 if (parent_scope == NULL)
8851 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
8855 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
8857 struct dwarf2_per_objfile *dwarf2_per_objfile
8858 = cu->per_cu->dwarf2_per_objfile;
8859 struct objfile *objfile = dwarf2_per_objfile->objfile;
8860 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8862 const char *actual_name = NULL;
8864 char *built_actual_name;
8866 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8868 built_actual_name = partial_die_full_name (pdi, cu);
8869 if (built_actual_name != NULL)
8870 actual_name = built_actual_name;
8872 if (actual_name == NULL)
8873 actual_name = pdi->name;
8877 case DW_TAG_inlined_subroutine:
8878 case DW_TAG_subprogram:
8879 addr = (gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr)
8881 if (pdi->is_external || cu->language == language_ada)
8883 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8884 of the global scope. But in Ada, we want to be able to access
8885 nested procedures globally. So all Ada subprograms are stored
8886 in the global scope. */
8887 add_psymbol_to_list (actual_name, strlen (actual_name),
8888 built_actual_name != NULL,
8889 VAR_DOMAIN, LOC_BLOCK,
8890 SECT_OFF_TEXT (objfile),
8891 &objfile->global_psymbols,
8893 cu->language, objfile);
8897 add_psymbol_to_list (actual_name, strlen (actual_name),
8898 built_actual_name != NULL,
8899 VAR_DOMAIN, LOC_BLOCK,
8900 SECT_OFF_TEXT (objfile),
8901 &objfile->static_psymbols,
8902 addr, cu->language, objfile);
8905 if (pdi->main_subprogram && actual_name != NULL)
8906 set_objfile_main_name (objfile, actual_name, cu->language);
8908 case DW_TAG_constant:
8910 std::vector<partial_symbol *> *list;
8912 if (pdi->is_external)
8913 list = &objfile->global_psymbols;
8915 list = &objfile->static_psymbols;
8916 add_psymbol_to_list (actual_name, strlen (actual_name),
8917 built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
8918 -1, list, 0, cu->language, objfile);
8921 case DW_TAG_variable:
8923 addr = decode_locdesc (pdi->d.locdesc, cu);
8927 && !dwarf2_per_objfile->has_section_at_zero)
8929 /* A global or static variable may also have been stripped
8930 out by the linker if unused, in which case its address
8931 will be nullified; do not add such variables into partial
8932 symbol table then. */
8934 else if (pdi->is_external)
8937 Don't enter into the minimal symbol tables as there is
8938 a minimal symbol table entry from the ELF symbols already.
8939 Enter into partial symbol table if it has a location
8940 descriptor or a type.
8941 If the location descriptor is missing, new_symbol will create
8942 a LOC_UNRESOLVED symbol, the address of the variable will then
8943 be determined from the minimal symbol table whenever the variable
8945 The address for the partial symbol table entry is not
8946 used by GDB, but it comes in handy for debugging partial symbol
8949 if (pdi->d.locdesc || pdi->has_type)
8950 add_psymbol_to_list (actual_name, strlen (actual_name),
8951 built_actual_name != NULL,
8952 VAR_DOMAIN, LOC_STATIC,
8953 SECT_OFF_TEXT (objfile),
8954 &objfile->global_psymbols,
8955 addr, cu->language, objfile);
8959 int has_loc = pdi->d.locdesc != NULL;
8961 /* Static Variable. Skip symbols whose value we cannot know (those
8962 without location descriptors or constant values). */
8963 if (!has_loc && !pdi->has_const_value)
8965 xfree (built_actual_name);
8969 add_psymbol_to_list (actual_name, strlen (actual_name),
8970 built_actual_name != NULL,
8971 VAR_DOMAIN, LOC_STATIC,
8972 SECT_OFF_TEXT (objfile),
8973 &objfile->static_psymbols,
8975 cu->language, objfile);
8978 case DW_TAG_typedef:
8979 case DW_TAG_base_type:
8980 case DW_TAG_subrange_type:
8981 add_psymbol_to_list (actual_name, strlen (actual_name),
8982 built_actual_name != NULL,
8983 VAR_DOMAIN, LOC_TYPEDEF, -1,
8984 &objfile->static_psymbols,
8985 0, cu->language, objfile);
8987 case DW_TAG_imported_declaration:
8988 case DW_TAG_namespace:
8989 add_psymbol_to_list (actual_name, strlen (actual_name),
8990 built_actual_name != NULL,
8991 VAR_DOMAIN, LOC_TYPEDEF, -1,
8992 &objfile->global_psymbols,
8993 0, cu->language, objfile);
8996 add_psymbol_to_list (actual_name, strlen (actual_name),
8997 built_actual_name != NULL,
8998 MODULE_DOMAIN, LOC_TYPEDEF, -1,
8999 &objfile->global_psymbols,
9000 0, cu->language, objfile);
9002 case DW_TAG_class_type:
9003 case DW_TAG_interface_type:
9004 case DW_TAG_structure_type:
9005 case DW_TAG_union_type:
9006 case DW_TAG_enumeration_type:
9007 /* Skip external references. The DWARF standard says in the section
9008 about "Structure, Union, and Class Type Entries": "An incomplete
9009 structure, union or class type is represented by a structure,
9010 union or class entry that does not have a byte size attribute
9011 and that has a DW_AT_declaration attribute." */
9012 if (!pdi->has_byte_size && pdi->is_declaration)
9014 xfree (built_actual_name);
9018 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9019 static vs. global. */
9020 add_psymbol_to_list (actual_name, strlen (actual_name),
9021 built_actual_name != NULL,
9022 STRUCT_DOMAIN, LOC_TYPEDEF, -1,
9023 cu->language == language_cplus
9024 ? &objfile->global_psymbols
9025 : &objfile->static_psymbols,
9026 0, cu->language, objfile);
9029 case DW_TAG_enumerator:
9030 add_psymbol_to_list (actual_name, strlen (actual_name),
9031 built_actual_name != NULL,
9032 VAR_DOMAIN, LOC_CONST, -1,
9033 cu->language == language_cplus
9034 ? &objfile->global_psymbols
9035 : &objfile->static_psymbols,
9036 0, cu->language, objfile);
9042 xfree (built_actual_name);
9045 /* Read a partial die corresponding to a namespace; also, add a symbol
9046 corresponding to that namespace to the symbol table. NAMESPACE is
9047 the name of the enclosing namespace. */
9050 add_partial_namespace (struct partial_die_info *pdi,
9051 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9052 int set_addrmap, struct dwarf2_cu *cu)
9054 /* Add a symbol for the namespace. */
9056 add_partial_symbol (pdi, cu);
9058 /* Now scan partial symbols in that namespace. */
9060 if (pdi->has_children)
9061 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9064 /* Read a partial die corresponding to a Fortran module. */
9067 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
9068 CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
9070 /* Add a symbol for the namespace. */
9072 add_partial_symbol (pdi, cu);
9074 /* Now scan partial symbols in that module. */
9076 if (pdi->has_children)
9077 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9080 /* Read a partial die corresponding to a subprogram or an inlined
9081 subprogram and create a partial symbol for that subprogram.
9082 When the CU language allows it, this routine also defines a partial
9083 symbol for each nested subprogram that this subprogram contains.
9084 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9085 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9087 PDI may also be a lexical block, in which case we simply search
9088 recursively for subprograms defined inside that lexical block.
9089 Again, this is only performed when the CU language allows this
9090 type of definitions. */
9093 add_partial_subprogram (struct partial_die_info *pdi,
9094 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9095 int set_addrmap, struct dwarf2_cu *cu)
9097 if (pdi->tag == DW_TAG_subprogram || pdi->tag == DW_TAG_inlined_subroutine)
9099 if (pdi->has_pc_info)
9101 if (pdi->lowpc < *lowpc)
9102 *lowpc = pdi->lowpc;
9103 if (pdi->highpc > *highpc)
9104 *highpc = pdi->highpc;
9107 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9108 struct gdbarch *gdbarch = get_objfile_arch (objfile);
9110 CORE_ADDR this_highpc;
9111 CORE_ADDR this_lowpc;
9113 baseaddr = ANOFFSET (objfile->section_offsets,
9114 SECT_OFF_TEXT (objfile));
9116 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9117 pdi->lowpc + baseaddr)
9120 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9121 pdi->highpc + baseaddr)
9123 addrmap_set_empty (objfile->psymtabs_addrmap,
9124 this_lowpc, this_highpc - 1,
9125 cu->per_cu->v.psymtab);
9129 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
9131 if (!pdi->is_declaration)
9132 /* Ignore subprogram DIEs that do not have a name, they are
9133 illegal. Do not emit a complaint at this point, we will
9134 do so when we convert this psymtab into a symtab. */
9136 add_partial_symbol (pdi, cu);
9140 if (! pdi->has_children)
9143 if (cu->language == language_ada)
9145 pdi = pdi->die_child;
9149 if (pdi->tag == DW_TAG_subprogram
9150 || pdi->tag == DW_TAG_inlined_subroutine
9151 || pdi->tag == DW_TAG_lexical_block)
9152 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
9153 pdi = pdi->die_sibling;
9158 /* Read a partial die corresponding to an enumeration type. */
9161 add_partial_enumeration (struct partial_die_info *enum_pdi,
9162 struct dwarf2_cu *cu)
9164 struct partial_die_info *pdi;
9166 if (enum_pdi->name != NULL)
9167 add_partial_symbol (enum_pdi, cu);
9169 pdi = enum_pdi->die_child;
9172 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
9173 complaint (_("malformed enumerator DIE ignored"));
9175 add_partial_symbol (pdi, cu);
9176 pdi = pdi->die_sibling;
9180 /* Return the initial uleb128 in the die at INFO_PTR. */
9183 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
9185 unsigned int bytes_read;
9187 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9190 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9191 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
9193 Return the corresponding abbrev, or NULL if the number is zero (indicating
9194 an empty DIE). In either case *BYTES_READ will be set to the length of
9195 the initial number. */
9197 static struct abbrev_info *
9198 peek_die_abbrev (const die_reader_specs &reader,
9199 const gdb_byte *info_ptr, unsigned int *bytes_read)
9201 dwarf2_cu *cu = reader.cu;
9202 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
9203 unsigned int abbrev_number
9204 = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
9206 if (abbrev_number == 0)
9209 abbrev_info *abbrev = reader.abbrev_table->lookup_abbrev (abbrev_number);
9212 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9213 " at offset %s [in module %s]"),
9214 abbrev_number, cu->per_cu->is_debug_types ? "TU" : "CU",
9215 sect_offset_str (cu->header.sect_off), bfd_get_filename (abfd));
9221 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9222 Returns a pointer to the end of a series of DIEs, terminated by an empty
9223 DIE. Any children of the skipped DIEs will also be skipped. */
9225 static const gdb_byte *
9226 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
9230 unsigned int bytes_read;
9231 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
9234 return info_ptr + bytes_read;
9236 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
9240 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9241 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9242 abbrev corresponding to that skipped uleb128 should be passed in
9243 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9246 static const gdb_byte *
9247 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
9248 struct abbrev_info *abbrev)
9250 unsigned int bytes_read;
9251 struct attribute attr;
9252 bfd *abfd = reader->abfd;
9253 struct dwarf2_cu *cu = reader->cu;
9254 const gdb_byte *buffer = reader->buffer;
9255 const gdb_byte *buffer_end = reader->buffer_end;
9256 unsigned int form, i;
9258 for (i = 0; i < abbrev->num_attrs; i++)
9260 /* The only abbrev we care about is DW_AT_sibling. */
9261 if (abbrev->attrs[i].name == DW_AT_sibling)
9263 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
9264 if (attr.form == DW_FORM_ref_addr)
9265 complaint (_("ignoring absolute DW_AT_sibling"));
9268 sect_offset off = dwarf2_get_ref_die_offset (&attr);
9269 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
9271 if (sibling_ptr < info_ptr)
9272 complaint (_("DW_AT_sibling points backwards"));
9273 else if (sibling_ptr > reader->buffer_end)
9274 dwarf2_section_buffer_overflow_complaint (reader->die_section);
9280 /* If it isn't DW_AT_sibling, skip this attribute. */
9281 form = abbrev->attrs[i].form;
9285 case DW_FORM_ref_addr:
9286 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9287 and later it is offset sized. */
9288 if (cu->header.version == 2)
9289 info_ptr += cu->header.addr_size;
9291 info_ptr += cu->header.offset_size;
9293 case DW_FORM_GNU_ref_alt:
9294 info_ptr += cu->header.offset_size;
9297 info_ptr += cu->header.addr_size;
9304 case DW_FORM_flag_present:
9305 case DW_FORM_implicit_const:
9317 case DW_FORM_ref_sig8:
9320 case DW_FORM_data16:
9323 case DW_FORM_string:
9324 read_direct_string (abfd, info_ptr, &bytes_read);
9325 info_ptr += bytes_read;
9327 case DW_FORM_sec_offset:
9329 case DW_FORM_GNU_strp_alt:
9330 info_ptr += cu->header.offset_size;
9332 case DW_FORM_exprloc:
9334 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9335 info_ptr += bytes_read;
9337 case DW_FORM_block1:
9338 info_ptr += 1 + read_1_byte (abfd, info_ptr);
9340 case DW_FORM_block2:
9341 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
9343 case DW_FORM_block4:
9344 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
9348 case DW_FORM_ref_udata:
9349 case DW_FORM_GNU_addr_index:
9350 case DW_FORM_GNU_str_index:
9351 info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
9353 case DW_FORM_indirect:
9354 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9355 info_ptr += bytes_read;
9356 /* We need to continue parsing from here, so just go back to
9358 goto skip_attribute;
9361 error (_("Dwarf Error: Cannot handle %s "
9362 "in DWARF reader [in module %s]"),
9363 dwarf_form_name (form),
9364 bfd_get_filename (abfd));
9368 if (abbrev->has_children)
9369 return skip_children (reader, info_ptr);
9374 /* Locate ORIG_PDI's sibling.
9375 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9377 static const gdb_byte *
9378 locate_pdi_sibling (const struct die_reader_specs *reader,
9379 struct partial_die_info *orig_pdi,
9380 const gdb_byte *info_ptr)
9382 /* Do we know the sibling already? */
9384 if (orig_pdi->sibling)
9385 return orig_pdi->sibling;
9387 /* Are there any children to deal with? */
9389 if (!orig_pdi->has_children)
9392 /* Skip the children the long way. */
9394 return skip_children (reader, info_ptr);
9397 /* Expand this partial symbol table into a full symbol table. SELF is
9401 dwarf2_read_symtab (struct partial_symtab *self,
9402 struct objfile *objfile)
9404 struct dwarf2_per_objfile *dwarf2_per_objfile
9405 = get_dwarf2_per_objfile (objfile);
9409 warning (_("bug: psymtab for %s is already read in."),
9416 printf_filtered (_("Reading in symbols for %s..."),
9418 gdb_flush (gdb_stdout);
9421 /* If this psymtab is constructed from a debug-only objfile, the
9422 has_section_at_zero flag will not necessarily be correct. We
9423 can get the correct value for this flag by looking at the data
9424 associated with the (presumably stripped) associated objfile. */
9425 if (objfile->separate_debug_objfile_backlink)
9427 struct dwarf2_per_objfile *dpo_backlink
9428 = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
9430 dwarf2_per_objfile->has_section_at_zero
9431 = dpo_backlink->has_section_at_zero;
9434 dwarf2_per_objfile->reading_partial_symbols = 0;
9436 psymtab_to_symtab_1 (self);
9438 /* Finish up the debug error message. */
9440 printf_filtered (_("done.\n"));
9443 process_cu_includes (dwarf2_per_objfile);
9446 /* Reading in full CUs. */
9448 /* Add PER_CU to the queue. */
9451 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
9452 enum language pretend_language)
9454 struct dwarf2_queue_item *item;
9457 item = XNEW (struct dwarf2_queue_item);
9458 item->per_cu = per_cu;
9459 item->pretend_language = pretend_language;
9462 if (dwarf2_queue == NULL)
9463 dwarf2_queue = item;
9465 dwarf2_queue_tail->next = item;
9467 dwarf2_queue_tail = item;
9470 /* If PER_CU is not yet queued, add it to the queue.
9471 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9473 The result is non-zero if PER_CU was queued, otherwise the result is zero
9474 meaning either PER_CU is already queued or it is already loaded.
9476 N.B. There is an invariant here that if a CU is queued then it is loaded.
9477 The caller is required to load PER_CU if we return non-zero. */
9480 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
9481 struct dwarf2_per_cu_data *per_cu,
9482 enum language pretend_language)
9484 /* We may arrive here during partial symbol reading, if we need full
9485 DIEs to process an unusual case (e.g. template arguments). Do
9486 not queue PER_CU, just tell our caller to load its DIEs. */
9487 if (per_cu->dwarf2_per_objfile->reading_partial_symbols)
9489 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
9494 /* Mark the dependence relation so that we don't flush PER_CU
9496 if (dependent_cu != NULL)
9497 dwarf2_add_dependence (dependent_cu, per_cu);
9499 /* If it's already on the queue, we have nothing to do. */
9503 /* If the compilation unit is already loaded, just mark it as
9505 if (per_cu->cu != NULL)
9507 per_cu->cu->last_used = 0;
9511 /* Add it to the queue. */
9512 queue_comp_unit (per_cu, pretend_language);
9517 /* Process the queue. */
9520 process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
9522 struct dwarf2_queue_item *item, *next_item;
9524 if (dwarf_read_debug)
9526 fprintf_unfiltered (gdb_stdlog,
9527 "Expanding one or more symtabs of objfile %s ...\n",
9528 objfile_name (dwarf2_per_objfile->objfile));
9531 /* The queue starts out with one item, but following a DIE reference
9532 may load a new CU, adding it to the end of the queue. */
9533 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
9535 if ((dwarf2_per_objfile->using_index
9536 ? !item->per_cu->v.quick->compunit_symtab
9537 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
9538 /* Skip dummy CUs. */
9539 && item->per_cu->cu != NULL)
9541 struct dwarf2_per_cu_data *per_cu = item->per_cu;
9542 unsigned int debug_print_threshold;
9545 if (per_cu->is_debug_types)
9547 struct signatured_type *sig_type =
9548 (struct signatured_type *) per_cu;
9550 sprintf (buf, "TU %s at offset %s",
9551 hex_string (sig_type->signature),
9552 sect_offset_str (per_cu->sect_off));
9553 /* There can be 100s of TUs.
9554 Only print them in verbose mode. */
9555 debug_print_threshold = 2;
9559 sprintf (buf, "CU at offset %s",
9560 sect_offset_str (per_cu->sect_off));
9561 debug_print_threshold = 1;
9564 if (dwarf_read_debug >= debug_print_threshold)
9565 fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
9567 if (per_cu->is_debug_types)
9568 process_full_type_unit (per_cu, item->pretend_language);
9570 process_full_comp_unit (per_cu, item->pretend_language);
9572 if (dwarf_read_debug >= debug_print_threshold)
9573 fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
9576 item->per_cu->queued = 0;
9577 next_item = item->next;
9581 dwarf2_queue_tail = NULL;
9583 if (dwarf_read_debug)
9585 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
9586 objfile_name (dwarf2_per_objfile->objfile));
9590 /* Read in full symbols for PST, and anything it depends on. */
9593 psymtab_to_symtab_1 (struct partial_symtab *pst)
9595 struct dwarf2_per_cu_data *per_cu;
9601 for (i = 0; i < pst->number_of_dependencies; i++)
9602 if (!pst->dependencies[i]->readin
9603 && pst->dependencies[i]->user == NULL)
9605 /* Inform about additional files that need to be read in. */
9608 /* FIXME: i18n: Need to make this a single string. */
9609 fputs_filtered (" ", gdb_stdout);
9611 fputs_filtered ("and ", gdb_stdout);
9613 printf_filtered ("%s...", pst->dependencies[i]->filename);
9614 wrap_here (""); /* Flush output. */
9615 gdb_flush (gdb_stdout);
9617 psymtab_to_symtab_1 (pst->dependencies[i]);
9620 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
9624 /* It's an include file, no symbols to read for it.
9625 Everything is in the parent symtab. */
9630 dw2_do_instantiate_symtab (per_cu, false);
9633 /* Trivial hash function for die_info: the hash value of a DIE
9634 is its offset in .debug_info for this objfile. */
9637 die_hash (const void *item)
9639 const struct die_info *die = (const struct die_info *) item;
9641 return to_underlying (die->sect_off);
9644 /* Trivial comparison function for die_info structures: two DIEs
9645 are equal if they have the same offset. */
9648 die_eq (const void *item_lhs, const void *item_rhs)
9650 const struct die_info *die_lhs = (const struct die_info *) item_lhs;
9651 const struct die_info *die_rhs = (const struct die_info *) item_rhs;
9653 return die_lhs->sect_off == die_rhs->sect_off;
9656 /* die_reader_func for load_full_comp_unit.
9657 This is identical to read_signatured_type_reader,
9658 but is kept separate for now. */
9661 load_full_comp_unit_reader (const struct die_reader_specs *reader,
9662 const gdb_byte *info_ptr,
9663 struct die_info *comp_unit_die,
9667 struct dwarf2_cu *cu = reader->cu;
9668 enum language *language_ptr = (enum language *) data;
9670 gdb_assert (cu->die_hash == NULL);
9672 htab_create_alloc_ex (cu->header.length / 12,
9676 &cu->comp_unit_obstack,
9677 hashtab_obstack_allocate,
9678 dummy_obstack_deallocate);
9681 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
9682 &info_ptr, comp_unit_die);
9683 cu->dies = comp_unit_die;
9684 /* comp_unit_die is not stored in die_hash, no need. */
9686 /* We try not to read any attributes in this function, because not
9687 all CUs needed for references have been loaded yet, and symbol
9688 table processing isn't initialized. But we have to set the CU language,
9689 or we won't be able to build types correctly.
9690 Similarly, if we do not read the producer, we can not apply
9691 producer-specific interpretation. */
9692 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
9695 /* Load the DIEs associated with PER_CU into memory. */
9698 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
9700 enum language pretend_language)
9702 gdb_assert (! this_cu->is_debug_types);
9704 init_cutu_and_read_dies (this_cu, NULL, 1, 1, skip_partial,
9705 load_full_comp_unit_reader, &pretend_language);
9708 /* Add a DIE to the delayed physname list. */
9711 add_to_method_list (struct type *type, int fnfield_index, int index,
9712 const char *name, struct die_info *die,
9713 struct dwarf2_cu *cu)
9715 struct delayed_method_info mi;
9717 mi.fnfield_index = fnfield_index;
9721 cu->method_list.push_back (mi);
9724 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9725 "const" / "volatile". If so, decrements LEN by the length of the
9726 modifier and return true. Otherwise return false. */
9730 check_modifier (const char *physname, size_t &len, const char (&mod)[N])
9732 size_t mod_len = sizeof (mod) - 1;
9733 if (len > mod_len && startswith (physname + (len - mod_len), mod))
9741 /* Compute the physnames of any methods on the CU's method list.
9743 The computation of method physnames is delayed in order to avoid the
9744 (bad) condition that one of the method's formal parameters is of an as yet
9748 compute_delayed_physnames (struct dwarf2_cu *cu)
9750 /* Only C++ delays computing physnames. */
9751 if (cu->method_list.empty ())
9753 gdb_assert (cu->language == language_cplus);
9755 for (const delayed_method_info &mi : cu->method_list)
9757 const char *physname;
9758 struct fn_fieldlist *fn_flp
9759 = &TYPE_FN_FIELDLIST (mi.type, mi.fnfield_index);
9760 physname = dwarf2_physname (mi.name, mi.die, cu);
9761 TYPE_FN_FIELD_PHYSNAME (fn_flp->fn_fields, mi.index)
9762 = physname ? physname : "";
9764 /* Since there's no tag to indicate whether a method is a
9765 const/volatile overload, extract that information out of the
9767 if (physname != NULL)
9769 size_t len = strlen (physname);
9773 if (physname[len] == ')') /* shortcut */
9775 else if (check_modifier (physname, len, " const"))
9776 TYPE_FN_FIELD_CONST (fn_flp->fn_fields, mi.index) = 1;
9777 else if (check_modifier (physname, len, " volatile"))
9778 TYPE_FN_FIELD_VOLATILE (fn_flp->fn_fields, mi.index) = 1;
9785 /* The list is no longer needed. */
9786 cu->method_list.clear ();
9789 /* A wrapper for add_symbol_to_list to ensure that SYMBOL's language is
9790 the same as all other symbols in LISTHEAD. If a new symbol is added
9791 with a different language, this function asserts. */
9794 dw2_add_symbol_to_list (struct symbol *symbol, struct pending **listhead)
9796 /* Only assert if LISTHEAD already contains symbols of a different
9797 language (dict_create_hashed/insert_symbol_hashed requires that all
9798 symbols in this list are of the same language). */
9799 gdb_assert ((*listhead) == NULL
9800 || (SYMBOL_LANGUAGE ((*listhead)->symbol[0])
9801 == SYMBOL_LANGUAGE (symbol)));
9803 add_symbol_to_list (symbol, listhead);
9806 /* Go objects should be embedded in a DW_TAG_module DIE,
9807 and it's not clear if/how imported objects will appear.
9808 To keep Go support simple until that's worked out,
9809 go back through what we've read and create something usable.
9810 We could do this while processing each DIE, and feels kinda cleaner,
9811 but that way is more invasive.
9812 This is to, for example, allow the user to type "p var" or "b main"
9813 without having to specify the package name, and allow lookups
9814 of module.object to work in contexts that use the expression
9818 fixup_go_packaging (struct dwarf2_cu *cu)
9820 char *package_name = NULL;
9821 struct pending *list;
9824 for (list = *cu->builder->get_global_symbols ();
9828 for (i = 0; i < list->nsyms; ++i)
9830 struct symbol *sym = list->symbol[i];
9832 if (SYMBOL_LANGUAGE (sym) == language_go
9833 && SYMBOL_CLASS (sym) == LOC_BLOCK)
9835 char *this_package_name = go_symbol_package_name (sym);
9837 if (this_package_name == NULL)
9839 if (package_name == NULL)
9840 package_name = this_package_name;
9843 struct objfile *objfile
9844 = cu->per_cu->dwarf2_per_objfile->objfile;
9845 if (strcmp (package_name, this_package_name) != 0)
9846 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9847 (symbol_symtab (sym) != NULL
9848 ? symtab_to_filename_for_display
9849 (symbol_symtab (sym))
9850 : objfile_name (objfile)),
9851 this_package_name, package_name);
9852 xfree (this_package_name);
9858 if (package_name != NULL)
9860 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9861 const char *saved_package_name
9862 = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
9864 strlen (package_name));
9865 struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
9866 saved_package_name);
9869 sym = allocate_symbol (objfile);
9870 SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
9871 SYMBOL_SET_NAMES (sym, saved_package_name,
9872 strlen (saved_package_name), 0, objfile);
9873 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9874 e.g., "main" finds the "main" module and not C's main(). */
9875 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
9876 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
9877 SYMBOL_TYPE (sym) = type;
9879 dw2_add_symbol_to_list (sym, cu->builder->get_global_symbols ());
9881 xfree (package_name);
9885 /* Allocate a fully-qualified name consisting of the two parts on the
9889 rust_fully_qualify (struct obstack *obstack, const char *p1, const char *p2)
9891 return obconcat (obstack, p1, "::", p2, (char *) NULL);
9894 /* A helper that allocates a struct discriminant_info to attach to a
9897 static struct discriminant_info *
9898 alloc_discriminant_info (struct type *type, int discriminant_index,
9901 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9902 gdb_assert (discriminant_index == -1
9903 || (discriminant_index >= 0
9904 && discriminant_index < TYPE_NFIELDS (type)));
9905 gdb_assert (default_index == -1
9906 || (default_index >= 0 && default_index < TYPE_NFIELDS (type)));
9908 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
9910 struct discriminant_info *disc
9911 = ((struct discriminant_info *)
9913 offsetof (struct discriminant_info, discriminants)
9914 + TYPE_NFIELDS (type) * sizeof (disc->discriminants[0])));
9915 disc->default_index = default_index;
9916 disc->discriminant_index = discriminant_index;
9918 struct dynamic_prop prop;
9919 prop.kind = PROP_UNDEFINED;
9920 prop.data.baton = disc;
9922 add_dyn_prop (DYN_PROP_DISCRIMINATED, prop, type);
9927 /* Some versions of rustc emitted enums in an unusual way.
9929 Ordinary enums were emitted as unions. The first element of each
9930 structure in the union was named "RUST$ENUM$DISR". This element
9931 held the discriminant.
9933 These versions of Rust also implemented the "non-zero"
9934 optimization. When the enum had two values, and one is empty and
9935 the other holds a pointer that cannot be zero, the pointer is used
9936 as the discriminant, with a zero value meaning the empty variant.
9937 Here, the union's first member is of the form
9938 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9939 where the fieldnos are the indices of the fields that should be
9940 traversed in order to find the field (which may be several fields deep)
9941 and the variantname is the name of the variant of the case when the
9944 This function recognizes whether TYPE is of one of these forms,
9945 and, if so, smashes it to be a variant type. */
9948 quirk_rust_enum (struct type *type, struct objfile *objfile)
9950 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9952 /* We don't need to deal with empty enums. */
9953 if (TYPE_NFIELDS (type) == 0)
9956 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9957 if (TYPE_NFIELDS (type) == 1
9958 && startswith (TYPE_FIELD_NAME (type, 0), RUST_ENUM_PREFIX))
9960 const char *name = TYPE_FIELD_NAME (type, 0) + strlen (RUST_ENUM_PREFIX);
9962 /* Decode the field name to find the offset of the
9964 ULONGEST bit_offset = 0;
9965 struct type *field_type = TYPE_FIELD_TYPE (type, 0);
9966 while (name[0] >= '0' && name[0] <= '9')
9969 unsigned long index = strtoul (name, &tail, 10);
9972 || index >= TYPE_NFIELDS (field_type)
9973 || (TYPE_FIELD_LOC_KIND (field_type, index)
9974 != FIELD_LOC_KIND_BITPOS))
9976 complaint (_("Could not parse Rust enum encoding string \"%s\""
9978 TYPE_FIELD_NAME (type, 0),
9979 objfile_name (objfile));
9984 bit_offset += TYPE_FIELD_BITPOS (field_type, index);
9985 field_type = TYPE_FIELD_TYPE (field_type, index);
9988 /* Make a union to hold the variants. */
9989 struct type *union_type = alloc_type (objfile);
9990 TYPE_CODE (union_type) = TYPE_CODE_UNION;
9991 TYPE_NFIELDS (union_type) = 3;
9992 TYPE_FIELDS (union_type)
9993 = (struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field));
9994 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
9995 set_type_align (union_type, TYPE_RAW_ALIGN (type));
9997 /* Put the discriminant must at index 0. */
9998 TYPE_FIELD_TYPE (union_type, 0) = field_type;
9999 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10000 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10001 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 0), bit_offset);
10003 /* The order of fields doesn't really matter, so put the real
10004 field at index 1 and the data-less field at index 2. */
10005 struct discriminant_info *disc
10006 = alloc_discriminant_info (union_type, 0, 1);
10007 TYPE_FIELD (union_type, 1) = TYPE_FIELD (type, 0);
10008 TYPE_FIELD_NAME (union_type, 1)
10009 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1)));
10010 TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1))
10011 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10012 TYPE_FIELD_NAME (union_type, 1));
10014 const char *dataless_name
10015 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10017 struct type *dataless_type = init_type (objfile, TYPE_CODE_VOID, 0,
10019 TYPE_FIELD_TYPE (union_type, 2) = dataless_type;
10020 /* NAME points into the original discriminant name, which
10021 already has the correct lifetime. */
10022 TYPE_FIELD_NAME (union_type, 2) = name;
10023 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 2), 0);
10024 disc->discriminants[2] = 0;
10026 /* Smash this type to be a structure type. We have to do this
10027 because the type has already been recorded. */
10028 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10029 TYPE_NFIELDS (type) = 1;
10031 = (struct field *) TYPE_ZALLOC (type, sizeof (struct field));
10033 /* Install the variant part. */
10034 TYPE_FIELD_TYPE (type, 0) = union_type;
10035 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10036 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10038 else if (TYPE_NFIELDS (type) == 1)
10040 /* We assume that a union with a single field is a univariant
10042 /* Smash this type to be a structure type. We have to do this
10043 because the type has already been recorded. */
10044 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10046 /* Make a union to hold the variants. */
10047 struct type *union_type = alloc_type (objfile);
10048 TYPE_CODE (union_type) = TYPE_CODE_UNION;
10049 TYPE_NFIELDS (union_type) = TYPE_NFIELDS (type);
10050 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10051 set_type_align (union_type, TYPE_RAW_ALIGN (type));
10052 TYPE_FIELDS (union_type) = TYPE_FIELDS (type);
10054 struct type *field_type = TYPE_FIELD_TYPE (union_type, 0);
10055 const char *variant_name
10056 = rust_last_path_segment (TYPE_NAME (field_type));
10057 TYPE_FIELD_NAME (union_type, 0) = variant_name;
10058 TYPE_NAME (field_type)
10059 = rust_fully_qualify (&objfile->objfile_obstack,
10060 TYPE_NAME (type), variant_name);
10062 /* Install the union in the outer struct type. */
10063 TYPE_NFIELDS (type) = 1;
10065 = (struct field *) TYPE_ZALLOC (union_type, sizeof (struct field));
10066 TYPE_FIELD_TYPE (type, 0) = union_type;
10067 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10068 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10070 alloc_discriminant_info (union_type, -1, 0);
10074 struct type *disr_type = nullptr;
10075 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
10077 disr_type = TYPE_FIELD_TYPE (type, i);
10079 if (TYPE_CODE (disr_type) != TYPE_CODE_STRUCT)
10081 /* All fields of a true enum will be structs. */
10084 else if (TYPE_NFIELDS (disr_type) == 0)
10086 /* Could be data-less variant, so keep going. */
10087 disr_type = nullptr;
10089 else if (strcmp (TYPE_FIELD_NAME (disr_type, 0),
10090 "RUST$ENUM$DISR") != 0)
10092 /* Not a Rust enum. */
10102 /* If we got here without a discriminant, then it's probably
10104 if (disr_type == nullptr)
10107 /* Smash this type to be a structure type. We have to do this
10108 because the type has already been recorded. */
10109 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10111 /* Make a union to hold the variants. */
10112 struct field *disr_field = &TYPE_FIELD (disr_type, 0);
10113 struct type *union_type = alloc_type (objfile);
10114 TYPE_CODE (union_type) = TYPE_CODE_UNION;
10115 TYPE_NFIELDS (union_type) = 1 + TYPE_NFIELDS (type);
10116 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10117 set_type_align (union_type, TYPE_RAW_ALIGN (type));
10118 TYPE_FIELDS (union_type)
10119 = (struct field *) TYPE_ZALLOC (union_type,
10120 (TYPE_NFIELDS (union_type)
10121 * sizeof (struct field)));
10123 memcpy (TYPE_FIELDS (union_type) + 1, TYPE_FIELDS (type),
10124 TYPE_NFIELDS (type) * sizeof (struct field));
10126 /* Install the discriminant at index 0 in the union. */
10127 TYPE_FIELD (union_type, 0) = *disr_field;
10128 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10129 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10131 /* Install the union in the outer struct type. */
10132 TYPE_FIELD_TYPE (type, 0) = union_type;
10133 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10134 TYPE_NFIELDS (type) = 1;
10136 /* Set the size and offset of the union type. */
10137 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10139 /* We need a way to find the correct discriminant given a
10140 variant name. For convenience we build a map here. */
10141 struct type *enum_type = FIELD_TYPE (*disr_field);
10142 std::unordered_map<std::string, ULONGEST> discriminant_map;
10143 for (int i = 0; i < TYPE_NFIELDS (enum_type); ++i)
10145 if (TYPE_FIELD_LOC_KIND (enum_type, i) == FIELD_LOC_KIND_ENUMVAL)
10148 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type, i));
10149 discriminant_map[name] = TYPE_FIELD_ENUMVAL (enum_type, i);
10153 int n_fields = TYPE_NFIELDS (union_type);
10154 struct discriminant_info *disc
10155 = alloc_discriminant_info (union_type, 0, -1);
10156 /* Skip the discriminant here. */
10157 for (int i = 1; i < n_fields; ++i)
10159 /* Find the final word in the name of this variant's type.
10160 That name can be used to look up the correct
10162 const char *variant_name
10163 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type,
10166 auto iter = discriminant_map.find (variant_name);
10167 if (iter != discriminant_map.end ())
10168 disc->discriminants[i] = iter->second;
10170 /* Remove the discriminant field, if it exists. */
10171 struct type *sub_type = TYPE_FIELD_TYPE (union_type, i);
10172 if (TYPE_NFIELDS (sub_type) > 0)
10174 --TYPE_NFIELDS (sub_type);
10175 ++TYPE_FIELDS (sub_type);
10177 TYPE_FIELD_NAME (union_type, i) = variant_name;
10178 TYPE_NAME (sub_type)
10179 = rust_fully_qualify (&objfile->objfile_obstack,
10180 TYPE_NAME (type), variant_name);
10185 /* Rewrite some Rust unions to be structures with variants parts. */
10188 rust_union_quirks (struct dwarf2_cu *cu)
10190 gdb_assert (cu->language == language_rust);
10191 for (type *type_ : cu->rust_unions)
10192 quirk_rust_enum (type_, cu->per_cu->dwarf2_per_objfile->objfile);
10193 /* We don't need this any more. */
10194 cu->rust_unions.clear ();
10197 /* Return the symtab for PER_CU. This works properly regardless of
10198 whether we're using the index or psymtabs. */
10200 static struct compunit_symtab *
10201 get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
10203 return (per_cu->dwarf2_per_objfile->using_index
10204 ? per_cu->v.quick->compunit_symtab
10205 : per_cu->v.psymtab->compunit_symtab);
10208 /* A helper function for computing the list of all symbol tables
10209 included by PER_CU. */
10212 recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
10213 htab_t all_children, htab_t all_type_symtabs,
10214 struct dwarf2_per_cu_data *per_cu,
10215 struct compunit_symtab *immediate_parent)
10219 struct compunit_symtab *cust;
10220 struct dwarf2_per_cu_data *iter;
10222 slot = htab_find_slot (all_children, per_cu, INSERT);
10225 /* This inclusion and its children have been processed. */
10230 /* Only add a CU if it has a symbol table. */
10231 cust = get_compunit_symtab (per_cu);
10234 /* If this is a type unit only add its symbol table if we haven't
10235 seen it yet (type unit per_cu's can share symtabs). */
10236 if (per_cu->is_debug_types)
10238 slot = htab_find_slot (all_type_symtabs, cust, INSERT);
10242 result->push_back (cust);
10243 if (cust->user == NULL)
10244 cust->user = immediate_parent;
10249 result->push_back (cust);
10250 if (cust->user == NULL)
10251 cust->user = immediate_parent;
10256 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
10259 recursively_compute_inclusions (result, all_children,
10260 all_type_symtabs, iter, cust);
10264 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10268 compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
10270 gdb_assert (! per_cu->is_debug_types);
10272 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
10275 struct dwarf2_per_cu_data *per_cu_iter;
10276 std::vector<compunit_symtab *> result_symtabs;
10277 htab_t all_children, all_type_symtabs;
10278 struct compunit_symtab *cust = get_compunit_symtab (per_cu);
10280 /* If we don't have a symtab, we can just skip this case. */
10284 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10285 NULL, xcalloc, xfree);
10286 all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10287 NULL, xcalloc, xfree);
10290 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
10294 recursively_compute_inclusions (&result_symtabs, all_children,
10295 all_type_symtabs, per_cu_iter,
10299 /* Now we have a transitive closure of all the included symtabs. */
10300 len = result_symtabs.size ();
10302 = XOBNEWVEC (&per_cu->dwarf2_per_objfile->objfile->objfile_obstack,
10303 struct compunit_symtab *, len + 1);
10304 memcpy (cust->includes, result_symtabs.data (),
10305 len * sizeof (compunit_symtab *));
10306 cust->includes[len] = NULL;
10308 htab_delete (all_children);
10309 htab_delete (all_type_symtabs);
10313 /* Compute the 'includes' field for the symtabs of all the CUs we just
10317 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
10319 for (dwarf2_per_cu_data *iter : dwarf2_per_objfile->just_read_cus)
10321 if (! iter->is_debug_types)
10322 compute_compunit_symtab_includes (iter);
10325 dwarf2_per_objfile->just_read_cus.clear ();
10328 /* Generate full symbol information for PER_CU, whose DIEs have
10329 already been loaded into memory. */
10332 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
10333 enum language pretend_language)
10335 struct dwarf2_cu *cu = per_cu->cu;
10336 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10337 struct objfile *objfile = dwarf2_per_objfile->objfile;
10338 struct gdbarch *gdbarch = get_objfile_arch (objfile);
10339 CORE_ADDR lowpc, highpc;
10340 struct compunit_symtab *cust;
10341 CORE_ADDR baseaddr;
10342 struct block *static_block;
10345 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
10347 /* Clear the list here in case something was left over. */
10348 cu->method_list.clear ();
10350 cu->language = pretend_language;
10351 cu->language_defn = language_def (cu->language);
10353 /* Do line number decoding in read_file_scope () */
10354 process_die (cu->dies, cu);
10356 /* For now fudge the Go package. */
10357 if (cu->language == language_go)
10358 fixup_go_packaging (cu);
10360 /* Now that we have processed all the DIEs in the CU, all the types
10361 should be complete, and it should now be safe to compute all of the
10363 compute_delayed_physnames (cu);
10365 if (cu->language == language_rust)
10366 rust_union_quirks (cu);
10368 /* Some compilers don't define a DW_AT_high_pc attribute for the
10369 compilation unit. If the DW_AT_high_pc is missing, synthesize
10370 it, by scanning the DIE's below the compilation unit. */
10371 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
10373 addr = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
10374 static_block = cu->builder->end_symtab_get_static_block (addr, 0, 1);
10376 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10377 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10378 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10379 addrmap to help ensure it has an accurate map of pc values belonging to
10381 dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
10383 cust = cu->builder->end_symtab_from_static_block (static_block,
10384 SECT_OFF_TEXT (objfile),
10389 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
10391 /* Set symtab language to language from DW_AT_language. If the
10392 compilation is from a C file generated by language preprocessors, do
10393 not set the language if it was already deduced by start_subfile. */
10394 if (!(cu->language == language_c
10395 && COMPUNIT_FILETABS (cust)->language != language_unknown))
10396 COMPUNIT_FILETABS (cust)->language = cu->language;
10398 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10399 produce DW_AT_location with location lists but it can be possibly
10400 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10401 there were bugs in prologue debug info, fixed later in GCC-4.5
10402 by "unwind info for epilogues" patch (which is not directly related).
10404 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10405 needed, it would be wrong due to missing DW_AT_producer there.
10407 Still one can confuse GDB by using non-standard GCC compilation
10408 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10410 if (cu->has_loclist && gcc_4_minor >= 5)
10411 cust->locations_valid = 1;
10413 if (gcc_4_minor >= 5)
10414 cust->epilogue_unwind_valid = 1;
10416 cust->call_site_htab = cu->call_site_htab;
10419 if (dwarf2_per_objfile->using_index)
10420 per_cu->v.quick->compunit_symtab = cust;
10423 struct partial_symtab *pst = per_cu->v.psymtab;
10424 pst->compunit_symtab = cust;
10428 /* Push it for inclusion processing later. */
10429 dwarf2_per_objfile->just_read_cus.push_back (per_cu);
10431 /* Not needed any more. */
10432 cu->builder.reset ();
10435 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10436 already been loaded into memory. */
10439 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
10440 enum language pretend_language)
10442 struct dwarf2_cu *cu = per_cu->cu;
10443 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10444 struct objfile *objfile = dwarf2_per_objfile->objfile;
10445 struct compunit_symtab *cust;
10446 struct signatured_type *sig_type;
10448 gdb_assert (per_cu->is_debug_types);
10449 sig_type = (struct signatured_type *) per_cu;
10451 /* Clear the list here in case something was left over. */
10452 cu->method_list.clear ();
10454 cu->language = pretend_language;
10455 cu->language_defn = language_def (cu->language);
10457 /* The symbol tables are set up in read_type_unit_scope. */
10458 process_die (cu->dies, cu);
10460 /* For now fudge the Go package. */
10461 if (cu->language == language_go)
10462 fixup_go_packaging (cu);
10464 /* Now that we have processed all the DIEs in the CU, all the types
10465 should be complete, and it should now be safe to compute all of the
10467 compute_delayed_physnames (cu);
10469 if (cu->language == language_rust)
10470 rust_union_quirks (cu);
10472 /* TUs share symbol tables.
10473 If this is the first TU to use this symtab, complete the construction
10474 of it with end_expandable_symtab. Otherwise, complete the addition of
10475 this TU's symbols to the existing symtab. */
10476 if (sig_type->type_unit_group->compunit_symtab == NULL)
10478 cust = cu->builder->end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
10479 sig_type->type_unit_group->compunit_symtab = cust;
10483 /* Set symtab language to language from DW_AT_language. If the
10484 compilation is from a C file generated by language preprocessors,
10485 do not set the language if it was already deduced by
10487 if (!(cu->language == language_c
10488 && COMPUNIT_FILETABS (cust)->language != language_c))
10489 COMPUNIT_FILETABS (cust)->language = cu->language;
10494 cu->builder->augment_type_symtab ();
10495 cust = sig_type->type_unit_group->compunit_symtab;
10498 if (dwarf2_per_objfile->using_index)
10499 per_cu->v.quick->compunit_symtab = cust;
10502 struct partial_symtab *pst = per_cu->v.psymtab;
10503 pst->compunit_symtab = cust;
10507 /* Not needed any more. */
10508 cu->builder.reset ();
10511 /* Process an imported unit DIE. */
10514 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
10516 struct attribute *attr;
10518 /* For now we don't handle imported units in type units. */
10519 if (cu->per_cu->is_debug_types)
10521 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10522 " supported in type units [in module %s]"),
10523 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
10526 attr = dwarf2_attr (die, DW_AT_import, cu);
10529 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
10530 bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
10531 dwarf2_per_cu_data *per_cu
10532 = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
10533 cu->per_cu->dwarf2_per_objfile);
10535 /* If necessary, add it to the queue and load its DIEs. */
10536 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
10537 load_full_comp_unit (per_cu, false, cu->language);
10539 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
10544 /* RAII object that represents a process_die scope: i.e.,
10545 starts/finishes processing a DIE. */
10546 class process_die_scope
10549 process_die_scope (die_info *die, dwarf2_cu *cu)
10550 : m_die (die), m_cu (cu)
10552 /* We should only be processing DIEs not already in process. */
10553 gdb_assert (!m_die->in_process);
10554 m_die->in_process = true;
10557 ~process_die_scope ()
10559 m_die->in_process = false;
10561 /* If we're done processing the DIE for the CU that owns the line
10562 header, we don't need the line header anymore. */
10563 if (m_cu->line_header_die_owner == m_die)
10565 delete m_cu->line_header;
10566 m_cu->line_header = NULL;
10567 m_cu->line_header_die_owner = NULL;
10576 /* Process a die and its children. */
10579 process_die (struct die_info *die, struct dwarf2_cu *cu)
10581 process_die_scope scope (die, cu);
10585 case DW_TAG_padding:
10587 case DW_TAG_compile_unit:
10588 case DW_TAG_partial_unit:
10589 read_file_scope (die, cu);
10591 case DW_TAG_type_unit:
10592 read_type_unit_scope (die, cu);
10594 case DW_TAG_subprogram:
10595 case DW_TAG_inlined_subroutine:
10596 read_func_scope (die, cu);
10598 case DW_TAG_lexical_block:
10599 case DW_TAG_try_block:
10600 case DW_TAG_catch_block:
10601 read_lexical_block_scope (die, cu);
10603 case DW_TAG_call_site:
10604 case DW_TAG_GNU_call_site:
10605 read_call_site_scope (die, cu);
10607 case DW_TAG_class_type:
10608 case DW_TAG_interface_type:
10609 case DW_TAG_structure_type:
10610 case DW_TAG_union_type:
10611 process_structure_scope (die, cu);
10613 case DW_TAG_enumeration_type:
10614 process_enumeration_scope (die, cu);
10617 /* These dies have a type, but processing them does not create
10618 a symbol or recurse to process the children. Therefore we can
10619 read them on-demand through read_type_die. */
10620 case DW_TAG_subroutine_type:
10621 case DW_TAG_set_type:
10622 case DW_TAG_array_type:
10623 case DW_TAG_pointer_type:
10624 case DW_TAG_ptr_to_member_type:
10625 case DW_TAG_reference_type:
10626 case DW_TAG_rvalue_reference_type:
10627 case DW_TAG_string_type:
10630 case DW_TAG_base_type:
10631 case DW_TAG_subrange_type:
10632 case DW_TAG_typedef:
10633 /* Add a typedef symbol for the type definition, if it has a
10635 new_symbol (die, read_type_die (die, cu), cu);
10637 case DW_TAG_common_block:
10638 read_common_block (die, cu);
10640 case DW_TAG_common_inclusion:
10642 case DW_TAG_namespace:
10643 cu->processing_has_namespace_info = true;
10644 read_namespace (die, cu);
10646 case DW_TAG_module:
10647 cu->processing_has_namespace_info = true;
10648 read_module (die, cu);
10650 case DW_TAG_imported_declaration:
10651 cu->processing_has_namespace_info = true;
10652 if (read_namespace_alias (die, cu))
10654 /* The declaration is not a global namespace alias. */
10655 /* Fall through. */
10656 case DW_TAG_imported_module:
10657 cu->processing_has_namespace_info = true;
10658 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
10659 || cu->language != language_fortran))
10660 complaint (_("Tag '%s' has unexpected children"),
10661 dwarf_tag_name (die->tag));
10662 read_import_statement (die, cu);
10665 case DW_TAG_imported_unit:
10666 process_imported_unit_die (die, cu);
10669 case DW_TAG_variable:
10670 read_variable (die, cu);
10674 new_symbol (die, NULL, cu);
10679 /* DWARF name computation. */
10681 /* A helper function for dwarf2_compute_name which determines whether DIE
10682 needs to have the name of the scope prepended to the name listed in the
10686 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
10688 struct attribute *attr;
10692 case DW_TAG_namespace:
10693 case DW_TAG_typedef:
10694 case DW_TAG_class_type:
10695 case DW_TAG_interface_type:
10696 case DW_TAG_structure_type:
10697 case DW_TAG_union_type:
10698 case DW_TAG_enumeration_type:
10699 case DW_TAG_enumerator:
10700 case DW_TAG_subprogram:
10701 case DW_TAG_inlined_subroutine:
10702 case DW_TAG_member:
10703 case DW_TAG_imported_declaration:
10706 case DW_TAG_variable:
10707 case DW_TAG_constant:
10708 /* We only need to prefix "globally" visible variables. These include
10709 any variable marked with DW_AT_external or any variable that
10710 lives in a namespace. [Variables in anonymous namespaces
10711 require prefixing, but they are not DW_AT_external.] */
10713 if (dwarf2_attr (die, DW_AT_specification, cu))
10715 struct dwarf2_cu *spec_cu = cu;
10717 return die_needs_namespace (die_specification (die, &spec_cu),
10721 attr = dwarf2_attr (die, DW_AT_external, cu);
10722 if (attr == NULL && die->parent->tag != DW_TAG_namespace
10723 && die->parent->tag != DW_TAG_module)
10725 /* A variable in a lexical block of some kind does not need a
10726 namespace, even though in C++ such variables may be external
10727 and have a mangled name. */
10728 if (die->parent->tag == DW_TAG_lexical_block
10729 || die->parent->tag == DW_TAG_try_block
10730 || die->parent->tag == DW_TAG_catch_block
10731 || die->parent->tag == DW_TAG_subprogram)
10740 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10741 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10742 defined for the given DIE. */
10744 static struct attribute *
10745 dw2_linkage_name_attr (struct die_info *die, struct dwarf2_cu *cu)
10747 struct attribute *attr;
10749 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
10751 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
10756 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10757 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10758 defined for the given DIE. */
10760 static const char *
10761 dw2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
10763 const char *linkage_name;
10765 linkage_name = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
10766 if (linkage_name == NULL)
10767 linkage_name = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
10769 return linkage_name;
10772 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10773 compute the physname for the object, which include a method's:
10774 - formal parameters (C++),
10775 - receiver type (Go),
10777 The term "physname" is a bit confusing.
10778 For C++, for example, it is the demangled name.
10779 For Go, for example, it's the mangled name.
10781 For Ada, return the DIE's linkage name rather than the fully qualified
10782 name. PHYSNAME is ignored..
10784 The result is allocated on the objfile_obstack and canonicalized. */
10786 static const char *
10787 dwarf2_compute_name (const char *name,
10788 struct die_info *die, struct dwarf2_cu *cu,
10791 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10794 name = dwarf2_name (die, cu);
10796 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10797 but otherwise compute it by typename_concat inside GDB.
10798 FIXME: Actually this is not really true, or at least not always true.
10799 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
10800 Fortran names because there is no mangling standard. So new_symbol
10801 will set the demangled name to the result of dwarf2_full_name, and it is
10802 the demangled name that GDB uses if it exists. */
10803 if (cu->language == language_ada
10804 || (cu->language == language_fortran && physname))
10806 /* For Ada unit, we prefer the linkage name over the name, as
10807 the former contains the exported name, which the user expects
10808 to be able to reference. Ideally, we want the user to be able
10809 to reference this entity using either natural or linkage name,
10810 but we haven't started looking at this enhancement yet. */
10811 const char *linkage_name = dw2_linkage_name (die, cu);
10813 if (linkage_name != NULL)
10814 return linkage_name;
10817 /* These are the only languages we know how to qualify names in. */
10819 && (cu->language == language_cplus
10820 || cu->language == language_fortran || cu->language == language_d
10821 || cu->language == language_rust))
10823 if (die_needs_namespace (die, cu))
10825 const char *prefix;
10826 const char *canonical_name = NULL;
10830 prefix = determine_prefix (die, cu);
10831 if (*prefix != '\0')
10833 char *prefixed_name = typename_concat (NULL, prefix, name,
10836 buf.puts (prefixed_name);
10837 xfree (prefixed_name);
10842 /* Template parameters may be specified in the DIE's DW_AT_name, or
10843 as children with DW_TAG_template_type_param or
10844 DW_TAG_value_type_param. If the latter, add them to the name
10845 here. If the name already has template parameters, then
10846 skip this step; some versions of GCC emit both, and
10847 it is more efficient to use the pre-computed name.
10849 Something to keep in mind about this process: it is very
10850 unlikely, or in some cases downright impossible, to produce
10851 something that will match the mangled name of a function.
10852 If the definition of the function has the same debug info,
10853 we should be able to match up with it anyway. But fallbacks
10854 using the minimal symbol, for instance to find a method
10855 implemented in a stripped copy of libstdc++, will not work.
10856 If we do not have debug info for the definition, we will have to
10857 match them up some other way.
10859 When we do name matching there is a related problem with function
10860 templates; two instantiated function templates are allowed to
10861 differ only by their return types, which we do not add here. */
10863 if (cu->language == language_cplus && strchr (name, '<') == NULL)
10865 struct attribute *attr;
10866 struct die_info *child;
10869 die->building_fullname = 1;
10871 for (child = die->child; child != NULL; child = child->sibling)
10875 const gdb_byte *bytes;
10876 struct dwarf2_locexpr_baton *baton;
10879 if (child->tag != DW_TAG_template_type_param
10880 && child->tag != DW_TAG_template_value_param)
10891 attr = dwarf2_attr (child, DW_AT_type, cu);
10894 complaint (_("template parameter missing DW_AT_type"));
10895 buf.puts ("UNKNOWN_TYPE");
10898 type = die_type (child, cu);
10900 if (child->tag == DW_TAG_template_type_param)
10902 c_print_type (type, "", &buf, -1, 0, cu->language,
10903 &type_print_raw_options);
10907 attr = dwarf2_attr (child, DW_AT_const_value, cu);
10910 complaint (_("template parameter missing "
10911 "DW_AT_const_value"));
10912 buf.puts ("UNKNOWN_VALUE");
10916 dwarf2_const_value_attr (attr, type, name,
10917 &cu->comp_unit_obstack, cu,
10918 &value, &bytes, &baton);
10920 if (TYPE_NOSIGN (type))
10921 /* GDB prints characters as NUMBER 'CHAR'. If that's
10922 changed, this can use value_print instead. */
10923 c_printchar (value, type, &buf);
10926 struct value_print_options opts;
10929 v = dwarf2_evaluate_loc_desc (type, NULL,
10933 else if (bytes != NULL)
10935 v = allocate_value (type);
10936 memcpy (value_contents_writeable (v), bytes,
10937 TYPE_LENGTH (type));
10940 v = value_from_longest (type, value);
10942 /* Specify decimal so that we do not depend on
10944 get_formatted_print_options (&opts, 'd');
10946 value_print (v, &buf, &opts);
10951 die->building_fullname = 0;
10955 /* Close the argument list, with a space if necessary
10956 (nested templates). */
10957 if (!buf.empty () && buf.string ().back () == '>')
10964 /* For C++ methods, append formal parameter type
10965 information, if PHYSNAME. */
10967 if (physname && die->tag == DW_TAG_subprogram
10968 && cu->language == language_cplus)
10970 struct type *type = read_type_die (die, cu);
10972 c_type_print_args (type, &buf, 1, cu->language,
10973 &type_print_raw_options);
10975 if (cu->language == language_cplus)
10977 /* Assume that an artificial first parameter is
10978 "this", but do not crash if it is not. RealView
10979 marks unnamed (and thus unused) parameters as
10980 artificial; there is no way to differentiate
10982 if (TYPE_NFIELDS (type) > 0
10983 && TYPE_FIELD_ARTIFICIAL (type, 0)
10984 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
10985 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
10987 buf.puts (" const");
10991 const std::string &intermediate_name = buf.string ();
10993 if (cu->language == language_cplus)
10995 = dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
10996 &objfile->per_bfd->storage_obstack);
10998 /* If we only computed INTERMEDIATE_NAME, or if
10999 INTERMEDIATE_NAME is already canonical, then we need to
11000 copy it to the appropriate obstack. */
11001 if (canonical_name == NULL || canonical_name == intermediate_name.c_str ())
11002 name = ((const char *)
11003 obstack_copy0 (&objfile->per_bfd->storage_obstack,
11004 intermediate_name.c_str (),
11005 intermediate_name.length ()));
11007 name = canonical_name;
11014 /* Return the fully qualified name of DIE, based on its DW_AT_name.
11015 If scope qualifiers are appropriate they will be added. The result
11016 will be allocated on the storage_obstack, or NULL if the DIE does
11017 not have a name. NAME may either be from a previous call to
11018 dwarf2_name or NULL.
11020 The output string will be canonicalized (if C++). */
11022 static const char *
11023 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11025 return dwarf2_compute_name (name, die, cu, 0);
11028 /* Construct a physname for the given DIE in CU. NAME may either be
11029 from a previous call to dwarf2_name or NULL. The result will be
11030 allocated on the objfile_objstack or NULL if the DIE does not have a
11033 The output string will be canonicalized (if C++). */
11035 static const char *
11036 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11038 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11039 const char *retval, *mangled = NULL, *canon = NULL;
11042 /* In this case dwarf2_compute_name is just a shortcut not building anything
11044 if (!die_needs_namespace (die, cu))
11045 return dwarf2_compute_name (name, die, cu, 1);
11047 mangled = dw2_linkage_name (die, cu);
11049 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
11050 See https://github.com/rust-lang/rust/issues/32925. */
11051 if (cu->language == language_rust && mangled != NULL
11052 && strchr (mangled, '{') != NULL)
11055 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11057 gdb::unique_xmalloc_ptr<char> demangled;
11058 if (mangled != NULL)
11061 if (language_def (cu->language)->la_store_sym_names_in_linkage_form_p)
11063 /* Do nothing (do not demangle the symbol name). */
11065 else if (cu->language == language_go)
11067 /* This is a lie, but we already lie to the caller new_symbol.
11068 new_symbol assumes we return the mangled name.
11069 This just undoes that lie until things are cleaned up. */
11073 /* Use DMGL_RET_DROP for C++ template functions to suppress
11074 their return type. It is easier for GDB users to search
11075 for such functions as `name(params)' than `long name(params)'.
11076 In such case the minimal symbol names do not match the full
11077 symbol names but for template functions there is never a need
11078 to look up their definition from their declaration so
11079 the only disadvantage remains the minimal symbol variant
11080 `long name(params)' does not have the proper inferior type. */
11081 demangled.reset (gdb_demangle (mangled,
11082 (DMGL_PARAMS | DMGL_ANSI
11083 | DMGL_RET_DROP)));
11086 canon = demangled.get ();
11094 if (canon == NULL || check_physname)
11096 const char *physname = dwarf2_compute_name (name, die, cu, 1);
11098 if (canon != NULL && strcmp (physname, canon) != 0)
11100 /* It may not mean a bug in GDB. The compiler could also
11101 compute DW_AT_linkage_name incorrectly. But in such case
11102 GDB would need to be bug-to-bug compatible. */
11104 complaint (_("Computed physname <%s> does not match demangled <%s> "
11105 "(from linkage <%s>) - DIE at %s [in module %s]"),
11106 physname, canon, mangled, sect_offset_str (die->sect_off),
11107 objfile_name (objfile));
11109 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11110 is available here - over computed PHYSNAME. It is safer
11111 against both buggy GDB and buggy compilers. */
11125 retval = ((const char *)
11126 obstack_copy0 (&objfile->per_bfd->storage_obstack,
11127 retval, strlen (retval)));
11132 /* Inspect DIE in CU for a namespace alias. If one exists, record
11133 a new symbol for it.
11135 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11138 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
11140 struct attribute *attr;
11142 /* If the die does not have a name, this is not a namespace
11144 attr = dwarf2_attr (die, DW_AT_name, cu);
11148 struct die_info *d = die;
11149 struct dwarf2_cu *imported_cu = cu;
11151 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11152 keep inspecting DIEs until we hit the underlying import. */
11153 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11154 for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
11156 attr = dwarf2_attr (d, DW_AT_import, cu);
11160 d = follow_die_ref (d, attr, &imported_cu);
11161 if (d->tag != DW_TAG_imported_declaration)
11165 if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
11167 complaint (_("DIE at %s has too many recursively imported "
11168 "declarations"), sect_offset_str (d->sect_off));
11175 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
11177 type = get_die_type_at_offset (sect_off, cu->per_cu);
11178 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
11180 /* This declaration is a global namespace alias. Add
11181 a symbol for it whose type is the aliased namespace. */
11182 new_symbol (die, type, cu);
11191 /* Return the using directives repository (global or local?) to use in the
11192 current context for CU.
11194 For Ada, imported declarations can materialize renamings, which *may* be
11195 global. However it is impossible (for now?) in DWARF to distinguish
11196 "external" imported declarations and "static" ones. As all imported
11197 declarations seem to be static in all other languages, make them all CU-wide
11198 global only in Ada. */
11200 static struct using_direct **
11201 using_directives (struct dwarf2_cu *cu)
11203 if (cu->language == language_ada && cu->builder->outermost_context_p ())
11204 return cu->builder->get_global_using_directives ();
11206 return cu->builder->get_local_using_directives ();
11209 /* Read the import statement specified by the given die and record it. */
11212 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
11214 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11215 struct attribute *import_attr;
11216 struct die_info *imported_die, *child_die;
11217 struct dwarf2_cu *imported_cu;
11218 const char *imported_name;
11219 const char *imported_name_prefix;
11220 const char *canonical_name;
11221 const char *import_alias;
11222 const char *imported_declaration = NULL;
11223 const char *import_prefix;
11224 std::vector<const char *> excludes;
11226 import_attr = dwarf2_attr (die, DW_AT_import, cu);
11227 if (import_attr == NULL)
11229 complaint (_("Tag '%s' has no DW_AT_import"),
11230 dwarf_tag_name (die->tag));
11235 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
11236 imported_name = dwarf2_name (imported_die, imported_cu);
11237 if (imported_name == NULL)
11239 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11241 The import in the following code:
11255 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11256 <52> DW_AT_decl_file : 1
11257 <53> DW_AT_decl_line : 6
11258 <54> DW_AT_import : <0x75>
11259 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11260 <59> DW_AT_name : B
11261 <5b> DW_AT_decl_file : 1
11262 <5c> DW_AT_decl_line : 2
11263 <5d> DW_AT_type : <0x6e>
11265 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11266 <76> DW_AT_byte_size : 4
11267 <77> DW_AT_encoding : 5 (signed)
11269 imports the wrong die ( 0x75 instead of 0x58 ).
11270 This case will be ignored until the gcc bug is fixed. */
11274 /* Figure out the local name after import. */
11275 import_alias = dwarf2_name (die, cu);
11277 /* Figure out where the statement is being imported to. */
11278 import_prefix = determine_prefix (die, cu);
11280 /* Figure out what the scope of the imported die is and prepend it
11281 to the name of the imported die. */
11282 imported_name_prefix = determine_prefix (imported_die, imported_cu);
11284 if (imported_die->tag != DW_TAG_namespace
11285 && imported_die->tag != DW_TAG_module)
11287 imported_declaration = imported_name;
11288 canonical_name = imported_name_prefix;
11290 else if (strlen (imported_name_prefix) > 0)
11291 canonical_name = obconcat (&objfile->objfile_obstack,
11292 imported_name_prefix,
11293 (cu->language == language_d ? "." : "::"),
11294 imported_name, (char *) NULL);
11296 canonical_name = imported_name;
11298 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
11299 for (child_die = die->child; child_die && child_die->tag;
11300 child_die = sibling_die (child_die))
11302 /* DWARF-4: A Fortran use statement with a “rename list” may be
11303 represented by an imported module entry with an import attribute
11304 referring to the module and owned entries corresponding to those
11305 entities that are renamed as part of being imported. */
11307 if (child_die->tag != DW_TAG_imported_declaration)
11309 complaint (_("child DW_TAG_imported_declaration expected "
11310 "- DIE at %s [in module %s]"),
11311 sect_offset_str (child_die->sect_off),
11312 objfile_name (objfile));
11316 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
11317 if (import_attr == NULL)
11319 complaint (_("Tag '%s' has no DW_AT_import"),
11320 dwarf_tag_name (child_die->tag));
11325 imported_die = follow_die_ref_or_sig (child_die, import_attr,
11327 imported_name = dwarf2_name (imported_die, imported_cu);
11328 if (imported_name == NULL)
11330 complaint (_("child DW_TAG_imported_declaration has unknown "
11331 "imported name - DIE at %s [in module %s]"),
11332 sect_offset_str (child_die->sect_off),
11333 objfile_name (objfile));
11337 excludes.push_back (imported_name);
11339 process_die (child_die, cu);
11342 add_using_directive (using_directives (cu),
11346 imported_declaration,
11349 &objfile->objfile_obstack);
11352 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11353 types, but gives them a size of zero. Starting with version 14,
11354 ICC is compatible with GCC. */
11357 producer_is_icc_lt_14 (struct dwarf2_cu *cu)
11359 if (!cu->checked_producer)
11360 check_producer (cu);
11362 return cu->producer_is_icc_lt_14;
11365 /* ICC generates a DW_AT_type for C void functions. This was observed on
11366 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11367 which says that void functions should not have a DW_AT_type. */
11370 producer_is_icc (struct dwarf2_cu *cu)
11372 if (!cu->checked_producer)
11373 check_producer (cu);
11375 return cu->producer_is_icc;
11378 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11379 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11380 this, it was first present in GCC release 4.3.0. */
11383 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
11385 if (!cu->checked_producer)
11386 check_producer (cu);
11388 return cu->producer_is_gcc_lt_4_3;
11391 static file_and_directory
11392 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu)
11394 file_and_directory res;
11396 /* Find the filename. Do not use dwarf2_name here, since the filename
11397 is not a source language identifier. */
11398 res.name = dwarf2_string_attr (die, DW_AT_name, cu);
11399 res.comp_dir = dwarf2_string_attr (die, DW_AT_comp_dir, cu);
11401 if (res.comp_dir == NULL
11402 && producer_is_gcc_lt_4_3 (cu) && res.name != NULL
11403 && IS_ABSOLUTE_PATH (res.name))
11405 res.comp_dir_storage = ldirname (res.name);
11406 if (!res.comp_dir_storage.empty ())
11407 res.comp_dir = res.comp_dir_storage.c_str ();
11409 if (res.comp_dir != NULL)
11411 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11412 directory, get rid of it. */
11413 const char *cp = strchr (res.comp_dir, ':');
11415 if (cp && cp != res.comp_dir && cp[-1] == '.' && cp[1] == '/')
11416 res.comp_dir = cp + 1;
11419 if (res.name == NULL)
11420 res.name = "<unknown>";
11425 /* Handle DW_AT_stmt_list for a compilation unit.
11426 DIE is the DW_TAG_compile_unit die for CU.
11427 COMP_DIR is the compilation directory. LOWPC is passed to
11428 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11431 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
11432 const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
11434 struct dwarf2_per_objfile *dwarf2_per_objfile
11435 = cu->per_cu->dwarf2_per_objfile;
11436 struct objfile *objfile = dwarf2_per_objfile->objfile;
11437 struct attribute *attr;
11438 struct line_header line_header_local;
11439 hashval_t line_header_local_hash;
11441 int decode_mapping;
11443 gdb_assert (! cu->per_cu->is_debug_types);
11445 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11449 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11451 /* The line header hash table is only created if needed (it exists to
11452 prevent redundant reading of the line table for partial_units).
11453 If we're given a partial_unit, we'll need it. If we're given a
11454 compile_unit, then use the line header hash table if it's already
11455 created, but don't create one just yet. */
11457 if (dwarf2_per_objfile->line_header_hash == NULL
11458 && die->tag == DW_TAG_partial_unit)
11460 dwarf2_per_objfile->line_header_hash
11461 = htab_create_alloc_ex (127, line_header_hash_voidp,
11462 line_header_eq_voidp,
11463 free_line_header_voidp,
11464 &objfile->objfile_obstack,
11465 hashtab_obstack_allocate,
11466 dummy_obstack_deallocate);
11469 line_header_local.sect_off = line_offset;
11470 line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
11471 line_header_local_hash = line_header_hash (&line_header_local);
11472 if (dwarf2_per_objfile->line_header_hash != NULL)
11474 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11475 &line_header_local,
11476 line_header_local_hash, NO_INSERT);
11478 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11479 is not present in *SLOT (since if there is something in *SLOT then
11480 it will be for a partial_unit). */
11481 if (die->tag == DW_TAG_partial_unit && slot != NULL)
11483 gdb_assert (*slot != NULL);
11484 cu->line_header = (struct line_header *) *slot;
11489 /* dwarf_decode_line_header does not yet provide sufficient information.
11490 We always have to call also dwarf_decode_lines for it. */
11491 line_header_up lh = dwarf_decode_line_header (line_offset, cu);
11495 cu->line_header = lh.release ();
11496 cu->line_header_die_owner = die;
11498 if (dwarf2_per_objfile->line_header_hash == NULL)
11502 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11503 &line_header_local,
11504 line_header_local_hash, INSERT);
11505 gdb_assert (slot != NULL);
11507 if (slot != NULL && *slot == NULL)
11509 /* This newly decoded line number information unit will be owned
11510 by line_header_hash hash table. */
11511 *slot = cu->line_header;
11512 cu->line_header_die_owner = NULL;
11516 /* We cannot free any current entry in (*slot) as that struct line_header
11517 may be already used by multiple CUs. Create only temporary decoded
11518 line_header for this CU - it may happen at most once for each line
11519 number information unit. And if we're not using line_header_hash
11520 then this is what we want as well. */
11521 gdb_assert (die->tag != DW_TAG_partial_unit);
11523 decode_mapping = (die->tag != DW_TAG_partial_unit);
11524 dwarf_decode_lines (cu->line_header, comp_dir, cu, NULL, lowpc,
11529 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11532 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
11534 struct dwarf2_per_objfile *dwarf2_per_objfile
11535 = cu->per_cu->dwarf2_per_objfile;
11536 struct objfile *objfile = dwarf2_per_objfile->objfile;
11537 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11538 CORE_ADDR lowpc = ((CORE_ADDR) -1);
11539 CORE_ADDR highpc = ((CORE_ADDR) 0);
11540 struct attribute *attr;
11541 struct die_info *child_die;
11542 CORE_ADDR baseaddr;
11544 prepare_one_comp_unit (cu, die, cu->language);
11545 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11547 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
11549 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11550 from finish_block. */
11551 if (lowpc == ((CORE_ADDR) -1))
11553 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11555 file_and_directory fnd = find_file_and_directory (die, cu);
11557 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11558 standardised yet. As a workaround for the language detection we fall
11559 back to the DW_AT_producer string. */
11560 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
11561 cu->language = language_opencl;
11563 /* Similar hack for Go. */
11564 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
11565 set_cu_language (DW_LANG_Go, cu);
11567 dwarf2_start_symtab (cu, fnd.name, fnd.comp_dir, lowpc);
11569 /* Decode line number information if present. We do this before
11570 processing child DIEs, so that the line header table is available
11571 for DW_AT_decl_file. */
11572 handle_DW_AT_stmt_list (die, cu, fnd.comp_dir, lowpc);
11574 /* Process all dies in compilation unit. */
11575 if (die->child != NULL)
11577 child_die = die->child;
11578 while (child_die && child_die->tag)
11580 process_die (child_die, cu);
11581 child_die = sibling_die (child_die);
11585 /* Decode macro information, if present. Dwarf 2 macro information
11586 refers to information in the line number info statement program
11587 header, so we can only read it if we've read the header
11589 attr = dwarf2_attr (die, DW_AT_macros, cu);
11591 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
11592 if (attr && cu->line_header)
11594 if (dwarf2_attr (die, DW_AT_macro_info, cu))
11595 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11597 dwarf_decode_macros (cu, DW_UNSND (attr), 1);
11601 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
11602 if (attr && cu->line_header)
11604 unsigned int macro_offset = DW_UNSND (attr);
11606 dwarf_decode_macros (cu, macro_offset, 0);
11611 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
11612 Create the set of symtabs used by this TU, or if this TU is sharing
11613 symtabs with another TU and the symtabs have already been created
11614 then restore those symtabs in the line header.
11615 We don't need the pc/line-number mapping for type units. */
11618 setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
11620 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
11621 struct type_unit_group *tu_group;
11623 struct attribute *attr;
11625 struct signatured_type *sig_type;
11627 gdb_assert (per_cu->is_debug_types);
11628 sig_type = (struct signatured_type *) per_cu;
11630 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11632 /* If we're using .gdb_index (includes -readnow) then
11633 per_cu->type_unit_group may not have been set up yet. */
11634 if (sig_type->type_unit_group == NULL)
11635 sig_type->type_unit_group = get_type_unit_group (cu, attr);
11636 tu_group = sig_type->type_unit_group;
11638 /* If we've already processed this stmt_list there's no real need to
11639 do it again, we could fake it and just recreate the part we need
11640 (file name,index -> symtab mapping). If data shows this optimization
11641 is useful we can do it then. */
11642 first_time = tu_group->compunit_symtab == NULL;
11644 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11649 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11650 lh = dwarf_decode_line_header (line_offset, cu);
11655 dwarf2_start_symtab (cu, "", NULL, 0);
11658 gdb_assert (tu_group->symtabs == NULL);
11659 gdb_assert (cu->builder == nullptr);
11660 struct compunit_symtab *cust = tu_group->compunit_symtab;
11661 cu->builder.reset (new struct buildsym_compunit
11662 (COMPUNIT_OBJFILE (cust), "",
11663 COMPUNIT_DIRNAME (cust),
11664 compunit_language (cust),
11670 cu->line_header = lh.release ();
11671 cu->line_header_die_owner = die;
11675 struct compunit_symtab *cust = dwarf2_start_symtab (cu, "", NULL, 0);
11677 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11678 still initializing it, and our caller (a few levels up)
11679 process_full_type_unit still needs to know if this is the first
11682 tu_group->num_symtabs = cu->line_header->file_names.size ();
11683 tu_group->symtabs = XNEWVEC (struct symtab *,
11684 cu->line_header->file_names.size ());
11686 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11688 file_entry &fe = cu->line_header->file_names[i];
11690 dwarf2_start_subfile (cu, fe.name, fe.include_dir (cu->line_header));
11692 if (cu->builder->get_current_subfile ()->symtab == NULL)
11694 /* NOTE: start_subfile will recognize when it's been
11695 passed a file it has already seen. So we can't
11696 assume there's a simple mapping from
11697 cu->line_header->file_names to subfiles, plus
11698 cu->line_header->file_names may contain dups. */
11699 cu->builder->get_current_subfile ()->symtab
11700 = allocate_symtab (cust,
11701 cu->builder->get_current_subfile ()->name);
11704 fe.symtab = cu->builder->get_current_subfile ()->symtab;
11705 tu_group->symtabs[i] = fe.symtab;
11710 gdb_assert (cu->builder == nullptr);
11711 struct compunit_symtab *cust = tu_group->compunit_symtab;
11712 cu->builder.reset (new struct buildsym_compunit
11713 (COMPUNIT_OBJFILE (cust), "",
11714 COMPUNIT_DIRNAME (cust),
11715 compunit_language (cust),
11718 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11720 file_entry &fe = cu->line_header->file_names[i];
11722 fe.symtab = tu_group->symtabs[i];
11726 /* The main symtab is allocated last. Type units don't have DW_AT_name
11727 so they don't have a "real" (so to speak) symtab anyway.
11728 There is later code that will assign the main symtab to all symbols
11729 that don't have one. We need to handle the case of a symbol with a
11730 missing symtab (DW_AT_decl_file) anyway. */
11733 /* Process DW_TAG_type_unit.
11734 For TUs we want to skip the first top level sibling if it's not the
11735 actual type being defined by this TU. In this case the first top
11736 level sibling is there to provide context only. */
11739 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
11741 struct die_info *child_die;
11743 prepare_one_comp_unit (cu, die, language_minimal);
11745 /* Initialize (or reinitialize) the machinery for building symtabs.
11746 We do this before processing child DIEs, so that the line header table
11747 is available for DW_AT_decl_file. */
11748 setup_type_unit_groups (die, cu);
11750 if (die->child != NULL)
11752 child_die = die->child;
11753 while (child_die && child_die->tag)
11755 process_die (child_die, cu);
11756 child_die = sibling_die (child_die);
11763 http://gcc.gnu.org/wiki/DebugFission
11764 http://gcc.gnu.org/wiki/DebugFissionDWP
11766 To simplify handling of both DWO files ("object" files with the DWARF info)
11767 and DWP files (a file with the DWOs packaged up into one file), we treat
11768 DWP files as having a collection of virtual DWO files. */
11771 hash_dwo_file (const void *item)
11773 const struct dwo_file *dwo_file = (const struct dwo_file *) item;
11776 hash = htab_hash_string (dwo_file->dwo_name);
11777 if (dwo_file->comp_dir != NULL)
11778 hash += htab_hash_string (dwo_file->comp_dir);
11783 eq_dwo_file (const void *item_lhs, const void *item_rhs)
11785 const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
11786 const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
11788 if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
11790 if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
11791 return lhs->comp_dir == rhs->comp_dir;
11792 return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
11795 /* Allocate a hash table for DWO files. */
11798 allocate_dwo_file_hash_table (struct objfile *objfile)
11800 return htab_create_alloc_ex (41,
11804 &objfile->objfile_obstack,
11805 hashtab_obstack_allocate,
11806 dummy_obstack_deallocate);
11809 /* Lookup DWO file DWO_NAME. */
11812 lookup_dwo_file_slot (struct dwarf2_per_objfile *dwarf2_per_objfile,
11813 const char *dwo_name,
11814 const char *comp_dir)
11816 struct dwo_file find_entry;
11819 if (dwarf2_per_objfile->dwo_files == NULL)
11820 dwarf2_per_objfile->dwo_files
11821 = allocate_dwo_file_hash_table (dwarf2_per_objfile->objfile);
11823 memset (&find_entry, 0, sizeof (find_entry));
11824 find_entry.dwo_name = dwo_name;
11825 find_entry.comp_dir = comp_dir;
11826 slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
11832 hash_dwo_unit (const void *item)
11834 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
11836 /* This drops the top 32 bits of the id, but is ok for a hash. */
11837 return dwo_unit->signature;
11841 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
11843 const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
11844 const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
11846 /* The signature is assumed to be unique within the DWO file.
11847 So while object file CU dwo_id's always have the value zero,
11848 that's OK, assuming each object file DWO file has only one CU,
11849 and that's the rule for now. */
11850 return lhs->signature == rhs->signature;
11853 /* Allocate a hash table for DWO CUs,TUs.
11854 There is one of these tables for each of CUs,TUs for each DWO file. */
11857 allocate_dwo_unit_table (struct objfile *objfile)
11859 /* Start out with a pretty small number.
11860 Generally DWO files contain only one CU and maybe some TUs. */
11861 return htab_create_alloc_ex (3,
11865 &objfile->objfile_obstack,
11866 hashtab_obstack_allocate,
11867 dummy_obstack_deallocate);
11870 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11872 struct create_dwo_cu_data
11874 struct dwo_file *dwo_file;
11875 struct dwo_unit dwo_unit;
11878 /* die_reader_func for create_dwo_cu. */
11881 create_dwo_cu_reader (const struct die_reader_specs *reader,
11882 const gdb_byte *info_ptr,
11883 struct die_info *comp_unit_die,
11887 struct dwarf2_cu *cu = reader->cu;
11888 sect_offset sect_off = cu->per_cu->sect_off;
11889 struct dwarf2_section_info *section = cu->per_cu->section;
11890 struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
11891 struct dwo_file *dwo_file = data->dwo_file;
11892 struct dwo_unit *dwo_unit = &data->dwo_unit;
11893 struct attribute *attr;
11895 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
11898 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11899 " its dwo_id [in module %s]"),
11900 sect_offset_str (sect_off), dwo_file->dwo_name);
11904 dwo_unit->dwo_file = dwo_file;
11905 dwo_unit->signature = DW_UNSND (attr);
11906 dwo_unit->section = section;
11907 dwo_unit->sect_off = sect_off;
11908 dwo_unit->length = cu->per_cu->length;
11910 if (dwarf_read_debug)
11911 fprintf_unfiltered (gdb_stdlog, " offset %s, dwo_id %s\n",
11912 sect_offset_str (sect_off),
11913 hex_string (dwo_unit->signature));
11916 /* Create the dwo_units for the CUs in a DWO_FILE.
11917 Note: This function processes DWO files only, not DWP files. */
11920 create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
11921 struct dwo_file &dwo_file, dwarf2_section_info §ion,
11924 struct objfile *objfile = dwarf2_per_objfile->objfile;
11925 const gdb_byte *info_ptr, *end_ptr;
11927 dwarf2_read_section (objfile, §ion);
11928 info_ptr = section.buffer;
11930 if (info_ptr == NULL)
11933 if (dwarf_read_debug)
11935 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
11936 get_section_name (§ion),
11937 get_section_file_name (§ion));
11940 end_ptr = info_ptr + section.size;
11941 while (info_ptr < end_ptr)
11943 struct dwarf2_per_cu_data per_cu;
11944 struct create_dwo_cu_data create_dwo_cu_data;
11945 struct dwo_unit *dwo_unit;
11947 sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
11949 memset (&create_dwo_cu_data.dwo_unit, 0,
11950 sizeof (create_dwo_cu_data.dwo_unit));
11951 memset (&per_cu, 0, sizeof (per_cu));
11952 per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
11953 per_cu.is_debug_types = 0;
11954 per_cu.sect_off = sect_offset (info_ptr - section.buffer);
11955 per_cu.section = §ion;
11956 create_dwo_cu_data.dwo_file = &dwo_file;
11958 init_cutu_and_read_dies_no_follow (
11959 &per_cu, &dwo_file, create_dwo_cu_reader, &create_dwo_cu_data);
11960 info_ptr += per_cu.length;
11962 // If the unit could not be parsed, skip it.
11963 if (create_dwo_cu_data.dwo_unit.dwo_file == NULL)
11966 if (cus_htab == NULL)
11967 cus_htab = allocate_dwo_unit_table (objfile);
11969 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
11970 *dwo_unit = create_dwo_cu_data.dwo_unit;
11971 slot = htab_find_slot (cus_htab, dwo_unit, INSERT);
11972 gdb_assert (slot != NULL);
11975 const struct dwo_unit *dup_cu = (const struct dwo_unit *)*slot;
11976 sect_offset dup_sect_off = dup_cu->sect_off;
11978 complaint (_("debug cu entry at offset %s is duplicate to"
11979 " the entry at offset %s, signature %s"),
11980 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
11981 hex_string (dwo_unit->signature));
11983 *slot = (void *)dwo_unit;
11987 /* DWP file .debug_{cu,tu}_index section format:
11988 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11992 Both index sections have the same format, and serve to map a 64-bit
11993 signature to a set of section numbers. Each section begins with a header,
11994 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11995 indexes, and a pool of 32-bit section numbers. The index sections will be
11996 aligned at 8-byte boundaries in the file.
11998 The index section header consists of:
12000 V, 32 bit version number
12002 N, 32 bit number of compilation units or type units in the index
12003 M, 32 bit number of slots in the hash table
12005 Numbers are recorded using the byte order of the application binary.
12007 The hash table begins at offset 16 in the section, and consists of an array
12008 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
12009 order of the application binary). Unused slots in the hash table are 0.
12010 (We rely on the extreme unlikeliness of a signature being exactly 0.)
12012 The parallel table begins immediately after the hash table
12013 (at offset 16 + 8 * M from the beginning of the section), and consists of an
12014 array of 32-bit indexes (using the byte order of the application binary),
12015 corresponding 1-1 with slots in the hash table. Each entry in the parallel
12016 table contains a 32-bit index into the pool of section numbers. For unused
12017 hash table slots, the corresponding entry in the parallel table will be 0.
12019 The pool of section numbers begins immediately following the hash table
12020 (at offset 16 + 12 * M from the beginning of the section). The pool of
12021 section numbers consists of an array of 32-bit words (using the byte order
12022 of the application binary). Each item in the array is indexed starting
12023 from 0. The hash table entry provides the index of the first section
12024 number in the set. Additional section numbers in the set follow, and the
12025 set is terminated by a 0 entry (section number 0 is not used in ELF).
12027 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12028 section must be the first entry in the set, and the .debug_abbrev.dwo must
12029 be the second entry. Other members of the set may follow in any order.
12035 DWP Version 2 combines all the .debug_info, etc. sections into one,
12036 and the entries in the index tables are now offsets into these sections.
12037 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
12040 Index Section Contents:
12042 Hash Table of Signatures dwp_hash_table.hash_table
12043 Parallel Table of Indices dwp_hash_table.unit_table
12044 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
12045 Table of Section Sizes dwp_hash_table.v2.sizes
12047 The index section header consists of:
12049 V, 32 bit version number
12050 L, 32 bit number of columns in the table of section offsets
12051 N, 32 bit number of compilation units or type units in the index
12052 M, 32 bit number of slots in the hash table
12054 Numbers are recorded using the byte order of the application binary.
12056 The hash table has the same format as version 1.
12057 The parallel table of indices has the same format as version 1,
12058 except that the entries are origin-1 indices into the table of sections
12059 offsets and the table of section sizes.
12061 The table of offsets begins immediately following the parallel table
12062 (at offset 16 + 12 * M from the beginning of the section). The table is
12063 a two-dimensional array of 32-bit words (using the byte order of the
12064 application binary), with L columns and N+1 rows, in row-major order.
12065 Each row in the array is indexed starting from 0. The first row provides
12066 a key to the remaining rows: each column in this row provides an identifier
12067 for a debug section, and the offsets in the same column of subsequent rows
12068 refer to that section. The section identifiers are:
12070 DW_SECT_INFO 1 .debug_info.dwo
12071 DW_SECT_TYPES 2 .debug_types.dwo
12072 DW_SECT_ABBREV 3 .debug_abbrev.dwo
12073 DW_SECT_LINE 4 .debug_line.dwo
12074 DW_SECT_LOC 5 .debug_loc.dwo
12075 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
12076 DW_SECT_MACINFO 7 .debug_macinfo.dwo
12077 DW_SECT_MACRO 8 .debug_macro.dwo
12079 The offsets provided by the CU and TU index sections are the base offsets
12080 for the contributions made by each CU or TU to the corresponding section
12081 in the package file. Each CU and TU header contains an abbrev_offset
12082 field, used to find the abbreviations table for that CU or TU within the
12083 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12084 be interpreted as relative to the base offset given in the index section.
12085 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12086 should be interpreted as relative to the base offset for .debug_line.dwo,
12087 and offsets into other debug sections obtained from DWARF attributes should
12088 also be interpreted as relative to the corresponding base offset.
12090 The table of sizes begins immediately following the table of offsets.
12091 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12092 with L columns and N rows, in row-major order. Each row in the array is
12093 indexed starting from 1 (row 0 is shared by the two tables).
12097 Hash table lookup is handled the same in version 1 and 2:
12099 We assume that N and M will not exceed 2^32 - 1.
12100 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12102 Given a 64-bit compilation unit signature or a type signature S, an entry
12103 in the hash table is located as follows:
12105 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12106 the low-order k bits all set to 1.
12108 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12110 3) If the hash table entry at index H matches the signature, use that
12111 entry. If the hash table entry at index H is unused (all zeroes),
12112 terminate the search: the signature is not present in the table.
12114 4) Let H = (H + H') modulo M. Repeat at Step 3.
12116 Because M > N and H' and M are relatively prime, the search is guaranteed
12117 to stop at an unused slot or find the match. */
12119 /* Create a hash table to map DWO IDs to their CU/TU entry in
12120 .debug_{info,types}.dwo in DWP_FILE.
12121 Returns NULL if there isn't one.
12122 Note: This function processes DWP files only, not DWO files. */
12124 static struct dwp_hash_table *
12125 create_dwp_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
12126 struct dwp_file *dwp_file, int is_debug_types)
12128 struct objfile *objfile = dwarf2_per_objfile->objfile;
12129 bfd *dbfd = dwp_file->dbfd.get ();
12130 const gdb_byte *index_ptr, *index_end;
12131 struct dwarf2_section_info *index;
12132 uint32_t version, nr_columns, nr_units, nr_slots;
12133 struct dwp_hash_table *htab;
12135 if (is_debug_types)
12136 index = &dwp_file->sections.tu_index;
12138 index = &dwp_file->sections.cu_index;
12140 if (dwarf2_section_empty_p (index))
12142 dwarf2_read_section (objfile, index);
12144 index_ptr = index->buffer;
12145 index_end = index_ptr + index->size;
12147 version = read_4_bytes (dbfd, index_ptr);
12150 nr_columns = read_4_bytes (dbfd, index_ptr);
12154 nr_units = read_4_bytes (dbfd, index_ptr);
12156 nr_slots = read_4_bytes (dbfd, index_ptr);
12159 if (version != 1 && version != 2)
12161 error (_("Dwarf Error: unsupported DWP file version (%s)"
12162 " [in module %s]"),
12163 pulongest (version), dwp_file->name);
12165 if (nr_slots != (nr_slots & -nr_slots))
12167 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12168 " is not power of 2 [in module %s]"),
12169 pulongest (nr_slots), dwp_file->name);
12172 htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
12173 htab->version = version;
12174 htab->nr_columns = nr_columns;
12175 htab->nr_units = nr_units;
12176 htab->nr_slots = nr_slots;
12177 htab->hash_table = index_ptr;
12178 htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
12180 /* Exit early if the table is empty. */
12181 if (nr_slots == 0 || nr_units == 0
12182 || (version == 2 && nr_columns == 0))
12184 /* All must be zero. */
12185 if (nr_slots != 0 || nr_units != 0
12186 || (version == 2 && nr_columns != 0))
12188 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12189 " all zero [in modules %s]"),
12197 htab->section_pool.v1.indices =
12198 htab->unit_table + sizeof (uint32_t) * nr_slots;
12199 /* It's harder to decide whether the section is too small in v1.
12200 V1 is deprecated anyway so we punt. */
12204 const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
12205 int *ids = htab->section_pool.v2.section_ids;
12206 size_t sizeof_ids = sizeof (htab->section_pool.v2.section_ids);
12207 /* Reverse map for error checking. */
12208 int ids_seen[DW_SECT_MAX + 1];
12211 if (nr_columns < 2)
12213 error (_("Dwarf Error: bad DWP hash table, too few columns"
12214 " in section table [in module %s]"),
12217 if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
12219 error (_("Dwarf Error: bad DWP hash table, too many columns"
12220 " in section table [in module %s]"),
12223 memset (ids, 255, sizeof_ids);
12224 memset (ids_seen, 255, sizeof (ids_seen));
12225 for (i = 0; i < nr_columns; ++i)
12227 int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
12229 if (id < DW_SECT_MIN || id > DW_SECT_MAX)
12231 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12232 " in section table [in module %s]"),
12233 id, dwp_file->name);
12235 if (ids_seen[id] != -1)
12237 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12238 " id %d in section table [in module %s]"),
12239 id, dwp_file->name);
12244 /* Must have exactly one info or types section. */
12245 if (((ids_seen[DW_SECT_INFO] != -1)
12246 + (ids_seen[DW_SECT_TYPES] != -1))
12249 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12250 " DWO info/types section [in module %s]"),
12253 /* Must have an abbrev section. */
12254 if (ids_seen[DW_SECT_ABBREV] == -1)
12256 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12257 " section [in module %s]"),
12260 htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
12261 htab->section_pool.v2.sizes =
12262 htab->section_pool.v2.offsets + (sizeof (uint32_t)
12263 * nr_units * nr_columns);
12264 if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
12265 * nr_units * nr_columns))
12268 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12269 " [in module %s]"),
12277 /* Update SECTIONS with the data from SECTP.
12279 This function is like the other "locate" section routines that are
12280 passed to bfd_map_over_sections, but in this context the sections to
12281 read comes from the DWP V1 hash table, not the full ELF section table.
12283 The result is non-zero for success, or zero if an error was found. */
12286 locate_v1_virtual_dwo_sections (asection *sectp,
12287 struct virtual_v1_dwo_sections *sections)
12289 const struct dwop_section_names *names = &dwop_section_names;
12291 if (section_is_p (sectp->name, &names->abbrev_dwo))
12293 /* There can be only one. */
12294 if (sections->abbrev.s.section != NULL)
12296 sections->abbrev.s.section = sectp;
12297 sections->abbrev.size = bfd_get_section_size (sectp);
12299 else if (section_is_p (sectp->name, &names->info_dwo)
12300 || section_is_p (sectp->name, &names->types_dwo))
12302 /* There can be only one. */
12303 if (sections->info_or_types.s.section != NULL)
12305 sections->info_or_types.s.section = sectp;
12306 sections->info_or_types.size = bfd_get_section_size (sectp);
12308 else if (section_is_p (sectp->name, &names->line_dwo))
12310 /* There can be only one. */
12311 if (sections->line.s.section != NULL)
12313 sections->line.s.section = sectp;
12314 sections->line.size = bfd_get_section_size (sectp);
12316 else if (section_is_p (sectp->name, &names->loc_dwo))
12318 /* There can be only one. */
12319 if (sections->loc.s.section != NULL)
12321 sections->loc.s.section = sectp;
12322 sections->loc.size = bfd_get_section_size (sectp);
12324 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12326 /* There can be only one. */
12327 if (sections->macinfo.s.section != NULL)
12329 sections->macinfo.s.section = sectp;
12330 sections->macinfo.size = bfd_get_section_size (sectp);
12332 else if (section_is_p (sectp->name, &names->macro_dwo))
12334 /* There can be only one. */
12335 if (sections->macro.s.section != NULL)
12337 sections->macro.s.section = sectp;
12338 sections->macro.size = bfd_get_section_size (sectp);
12340 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12342 /* There can be only one. */
12343 if (sections->str_offsets.s.section != NULL)
12345 sections->str_offsets.s.section = sectp;
12346 sections->str_offsets.size = bfd_get_section_size (sectp);
12350 /* No other kind of section is valid. */
12357 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12358 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12359 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12360 This is for DWP version 1 files. */
12362 static struct dwo_unit *
12363 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12364 struct dwp_file *dwp_file,
12365 uint32_t unit_index,
12366 const char *comp_dir,
12367 ULONGEST signature, int is_debug_types)
12369 struct objfile *objfile = dwarf2_per_objfile->objfile;
12370 const struct dwp_hash_table *dwp_htab =
12371 is_debug_types ? dwp_file->tus : dwp_file->cus;
12372 bfd *dbfd = dwp_file->dbfd.get ();
12373 const char *kind = is_debug_types ? "TU" : "CU";
12374 struct dwo_file *dwo_file;
12375 struct dwo_unit *dwo_unit;
12376 struct virtual_v1_dwo_sections sections;
12377 void **dwo_file_slot;
12380 gdb_assert (dwp_file->version == 1);
12382 if (dwarf_read_debug)
12384 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
12386 pulongest (unit_index), hex_string (signature),
12390 /* Fetch the sections of this DWO unit.
12391 Put a limit on the number of sections we look for so that bad data
12392 doesn't cause us to loop forever. */
12394 #define MAX_NR_V1_DWO_SECTIONS \
12395 (1 /* .debug_info or .debug_types */ \
12396 + 1 /* .debug_abbrev */ \
12397 + 1 /* .debug_line */ \
12398 + 1 /* .debug_loc */ \
12399 + 1 /* .debug_str_offsets */ \
12400 + 1 /* .debug_macro or .debug_macinfo */ \
12401 + 1 /* trailing zero */)
12403 memset (§ions, 0, sizeof (sections));
12405 for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
12408 uint32_t section_nr =
12409 read_4_bytes (dbfd,
12410 dwp_htab->section_pool.v1.indices
12411 + (unit_index + i) * sizeof (uint32_t));
12413 if (section_nr == 0)
12415 if (section_nr >= dwp_file->num_sections)
12417 error (_("Dwarf Error: bad DWP hash table, section number too large"
12418 " [in module %s]"),
12422 sectp = dwp_file->elf_sections[section_nr];
12423 if (! locate_v1_virtual_dwo_sections (sectp, §ions))
12425 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12426 " [in module %s]"),
12432 || dwarf2_section_empty_p (§ions.info_or_types)
12433 || dwarf2_section_empty_p (§ions.abbrev))
12435 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12436 " [in module %s]"),
12439 if (i == MAX_NR_V1_DWO_SECTIONS)
12441 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12442 " [in module %s]"),
12446 /* It's easier for the rest of the code if we fake a struct dwo_file and
12447 have dwo_unit "live" in that. At least for now.
12449 The DWP file can be made up of a random collection of CUs and TUs.
12450 However, for each CU + set of TUs that came from the same original DWO
12451 file, we can combine them back into a virtual DWO file to save space
12452 (fewer struct dwo_file objects to allocate). Remember that for really
12453 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12455 std::string virtual_dwo_name =
12456 string_printf ("virtual-dwo/%d-%d-%d-%d",
12457 get_section_id (§ions.abbrev),
12458 get_section_id (§ions.line),
12459 get_section_id (§ions.loc),
12460 get_section_id (§ions.str_offsets));
12461 /* Can we use an existing virtual DWO file? */
12462 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12463 virtual_dwo_name.c_str (),
12465 /* Create one if necessary. */
12466 if (*dwo_file_slot == NULL)
12468 if (dwarf_read_debug)
12470 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12471 virtual_dwo_name.c_str ());
12473 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12475 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12476 virtual_dwo_name.c_str (),
12477 virtual_dwo_name.size ());
12478 dwo_file->comp_dir = comp_dir;
12479 dwo_file->sections.abbrev = sections.abbrev;
12480 dwo_file->sections.line = sections.line;
12481 dwo_file->sections.loc = sections.loc;
12482 dwo_file->sections.macinfo = sections.macinfo;
12483 dwo_file->sections.macro = sections.macro;
12484 dwo_file->sections.str_offsets = sections.str_offsets;
12485 /* The "str" section is global to the entire DWP file. */
12486 dwo_file->sections.str = dwp_file->sections.str;
12487 /* The info or types section is assigned below to dwo_unit,
12488 there's no need to record it in dwo_file.
12489 Also, we can't simply record type sections in dwo_file because
12490 we record a pointer into the vector in dwo_unit. As we collect more
12491 types we'll grow the vector and eventually have to reallocate space
12492 for it, invalidating all copies of pointers into the previous
12494 *dwo_file_slot = dwo_file;
12498 if (dwarf_read_debug)
12500 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12501 virtual_dwo_name.c_str ());
12503 dwo_file = (struct dwo_file *) *dwo_file_slot;
12506 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12507 dwo_unit->dwo_file = dwo_file;
12508 dwo_unit->signature = signature;
12509 dwo_unit->section =
12510 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12511 *dwo_unit->section = sections.info_or_types;
12512 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12517 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12518 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12519 piece within that section used by a TU/CU, return a virtual section
12520 of just that piece. */
12522 static struct dwarf2_section_info
12523 create_dwp_v2_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
12524 struct dwarf2_section_info *section,
12525 bfd_size_type offset, bfd_size_type size)
12527 struct dwarf2_section_info result;
12530 gdb_assert (section != NULL);
12531 gdb_assert (!section->is_virtual);
12533 memset (&result, 0, sizeof (result));
12534 result.s.containing_section = section;
12535 result.is_virtual = 1;
12540 sectp = get_section_bfd_section (section);
12542 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12543 bounds of the real section. This is a pretty-rare event, so just
12544 flag an error (easier) instead of a warning and trying to cope. */
12546 || offset + size > bfd_get_section_size (sectp))
12548 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12549 " in section %s [in module %s]"),
12550 sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
12551 objfile_name (dwarf2_per_objfile->objfile));
12554 result.virtual_offset = offset;
12555 result.size = size;
12559 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12560 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12561 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12562 This is for DWP version 2 files. */
12564 static struct dwo_unit *
12565 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12566 struct dwp_file *dwp_file,
12567 uint32_t unit_index,
12568 const char *comp_dir,
12569 ULONGEST signature, int is_debug_types)
12571 struct objfile *objfile = dwarf2_per_objfile->objfile;
12572 const struct dwp_hash_table *dwp_htab =
12573 is_debug_types ? dwp_file->tus : dwp_file->cus;
12574 bfd *dbfd = dwp_file->dbfd.get ();
12575 const char *kind = is_debug_types ? "TU" : "CU";
12576 struct dwo_file *dwo_file;
12577 struct dwo_unit *dwo_unit;
12578 struct virtual_v2_dwo_sections sections;
12579 void **dwo_file_slot;
12582 gdb_assert (dwp_file->version == 2);
12584 if (dwarf_read_debug)
12586 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
12588 pulongest (unit_index), hex_string (signature),
12592 /* Fetch the section offsets of this DWO unit. */
12594 memset (§ions, 0, sizeof (sections));
12596 for (i = 0; i < dwp_htab->nr_columns; ++i)
12598 uint32_t offset = read_4_bytes (dbfd,
12599 dwp_htab->section_pool.v2.offsets
12600 + (((unit_index - 1) * dwp_htab->nr_columns
12602 * sizeof (uint32_t)));
12603 uint32_t size = read_4_bytes (dbfd,
12604 dwp_htab->section_pool.v2.sizes
12605 + (((unit_index - 1) * dwp_htab->nr_columns
12607 * sizeof (uint32_t)));
12609 switch (dwp_htab->section_pool.v2.section_ids[i])
12612 case DW_SECT_TYPES:
12613 sections.info_or_types_offset = offset;
12614 sections.info_or_types_size = size;
12616 case DW_SECT_ABBREV:
12617 sections.abbrev_offset = offset;
12618 sections.abbrev_size = size;
12621 sections.line_offset = offset;
12622 sections.line_size = size;
12625 sections.loc_offset = offset;
12626 sections.loc_size = size;
12628 case DW_SECT_STR_OFFSETS:
12629 sections.str_offsets_offset = offset;
12630 sections.str_offsets_size = size;
12632 case DW_SECT_MACINFO:
12633 sections.macinfo_offset = offset;
12634 sections.macinfo_size = size;
12636 case DW_SECT_MACRO:
12637 sections.macro_offset = offset;
12638 sections.macro_size = size;
12643 /* It's easier for the rest of the code if we fake a struct dwo_file and
12644 have dwo_unit "live" in that. At least for now.
12646 The DWP file can be made up of a random collection of CUs and TUs.
12647 However, for each CU + set of TUs that came from the same original DWO
12648 file, we can combine them back into a virtual DWO file to save space
12649 (fewer struct dwo_file objects to allocate). Remember that for really
12650 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12652 std::string virtual_dwo_name =
12653 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12654 (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
12655 (long) (sections.line_size ? sections.line_offset : 0),
12656 (long) (sections.loc_size ? sections.loc_offset : 0),
12657 (long) (sections.str_offsets_size
12658 ? sections.str_offsets_offset : 0));
12659 /* Can we use an existing virtual DWO file? */
12660 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12661 virtual_dwo_name.c_str (),
12663 /* Create one if necessary. */
12664 if (*dwo_file_slot == NULL)
12666 if (dwarf_read_debug)
12668 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12669 virtual_dwo_name.c_str ());
12671 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12673 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12674 virtual_dwo_name.c_str (),
12675 virtual_dwo_name.size ());
12676 dwo_file->comp_dir = comp_dir;
12677 dwo_file->sections.abbrev =
12678 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,
12679 sections.abbrev_offset, sections.abbrev_size);
12680 dwo_file->sections.line =
12681 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.line,
12682 sections.line_offset, sections.line_size);
12683 dwo_file->sections.loc =
12684 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.loc,
12685 sections.loc_offset, sections.loc_size);
12686 dwo_file->sections.macinfo =
12687 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macinfo,
12688 sections.macinfo_offset, sections.macinfo_size);
12689 dwo_file->sections.macro =
12690 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macro,
12691 sections.macro_offset, sections.macro_size);
12692 dwo_file->sections.str_offsets =
12693 create_dwp_v2_section (dwarf2_per_objfile,
12694 &dwp_file->sections.str_offsets,
12695 sections.str_offsets_offset,
12696 sections.str_offsets_size);
12697 /* The "str" section is global to the entire DWP file. */
12698 dwo_file->sections.str = dwp_file->sections.str;
12699 /* The info or types section is assigned below to dwo_unit,
12700 there's no need to record it in dwo_file.
12701 Also, we can't simply record type sections in dwo_file because
12702 we record a pointer into the vector in dwo_unit. As we collect more
12703 types we'll grow the vector and eventually have to reallocate space
12704 for it, invalidating all copies of pointers into the previous
12706 *dwo_file_slot = dwo_file;
12710 if (dwarf_read_debug)
12712 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12713 virtual_dwo_name.c_str ());
12715 dwo_file = (struct dwo_file *) *dwo_file_slot;
12718 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12719 dwo_unit->dwo_file = dwo_file;
12720 dwo_unit->signature = signature;
12721 dwo_unit->section =
12722 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12723 *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
12725 ? &dwp_file->sections.types
12726 : &dwp_file->sections.info,
12727 sections.info_or_types_offset,
12728 sections.info_or_types_size);
12729 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12734 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12735 Returns NULL if the signature isn't found. */
12737 static struct dwo_unit *
12738 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile *dwarf2_per_objfile,
12739 struct dwp_file *dwp_file, const char *comp_dir,
12740 ULONGEST signature, int is_debug_types)
12742 const struct dwp_hash_table *dwp_htab =
12743 is_debug_types ? dwp_file->tus : dwp_file->cus;
12744 bfd *dbfd = dwp_file->dbfd.get ();
12745 uint32_t mask = dwp_htab->nr_slots - 1;
12746 uint32_t hash = signature & mask;
12747 uint32_t hash2 = ((signature >> 32) & mask) | 1;
12750 struct dwo_unit find_dwo_cu;
12752 memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
12753 find_dwo_cu.signature = signature;
12754 slot = htab_find_slot (is_debug_types
12755 ? dwp_file->loaded_tus
12756 : dwp_file->loaded_cus,
12757 &find_dwo_cu, INSERT);
12760 return (struct dwo_unit *) *slot;
12762 /* Use a for loop so that we don't loop forever on bad debug info. */
12763 for (i = 0; i < dwp_htab->nr_slots; ++i)
12765 ULONGEST signature_in_table;
12767 signature_in_table =
12768 read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
12769 if (signature_in_table == signature)
12771 uint32_t unit_index =
12772 read_4_bytes (dbfd,
12773 dwp_htab->unit_table + hash * sizeof (uint32_t));
12775 if (dwp_file->version == 1)
12777 *slot = create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile,
12778 dwp_file, unit_index,
12779 comp_dir, signature,
12784 *slot = create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile,
12785 dwp_file, unit_index,
12786 comp_dir, signature,
12789 return (struct dwo_unit *) *slot;
12791 if (signature_in_table == 0)
12793 hash = (hash + hash2) & mask;
12796 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12797 " [in module %s]"),
12801 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12802 Open the file specified by FILE_NAME and hand it off to BFD for
12803 preliminary analysis. Return a newly initialized bfd *, which
12804 includes a canonicalized copy of FILE_NAME.
12805 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12806 SEARCH_CWD is true if the current directory is to be searched.
12807 It will be searched before debug-file-directory.
12808 If successful, the file is added to the bfd include table of the
12809 objfile's bfd (see gdb_bfd_record_inclusion).
12810 If unable to find/open the file, return NULL.
12811 NOTE: This function is derived from symfile_bfd_open. */
12813 static gdb_bfd_ref_ptr
12814 try_open_dwop_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12815 const char *file_name, int is_dwp, int search_cwd)
12818 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12819 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12820 to debug_file_directory. */
12821 const char *search_path;
12822 static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
12824 gdb::unique_xmalloc_ptr<char> search_path_holder;
12827 if (*debug_file_directory != '\0')
12829 search_path_holder.reset (concat (".", dirname_separator_string,
12830 debug_file_directory,
12832 search_path = search_path_holder.get ();
12838 search_path = debug_file_directory;
12840 openp_flags flags = OPF_RETURN_REALPATH;
12842 flags |= OPF_SEARCH_IN_PATH;
12844 gdb::unique_xmalloc_ptr<char> absolute_name;
12845 desc = openp (search_path, flags, file_name,
12846 O_RDONLY | O_BINARY, &absolute_name);
12850 gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (absolute_name.get (),
12852 if (sym_bfd == NULL)
12854 bfd_set_cacheable (sym_bfd.get (), 1);
12856 if (!bfd_check_format (sym_bfd.get (), bfd_object))
12859 /* Success. Record the bfd as having been included by the objfile's bfd.
12860 This is important because things like demangled_names_hash lives in the
12861 objfile's per_bfd space and may have references to things like symbol
12862 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12863 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd.get ());
12868 /* Try to open DWO file FILE_NAME.
12869 COMP_DIR is the DW_AT_comp_dir attribute.
12870 The result is the bfd handle of the file.
12871 If there is a problem finding or opening the file, return NULL.
12872 Upon success, the canonicalized path of the file is stored in the bfd,
12873 same as symfile_bfd_open. */
12875 static gdb_bfd_ref_ptr
12876 open_dwo_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12877 const char *file_name, const char *comp_dir)
12879 if (IS_ABSOLUTE_PATH (file_name))
12880 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12881 0 /*is_dwp*/, 0 /*search_cwd*/);
12883 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12885 if (comp_dir != NULL)
12887 char *path_to_try = concat (comp_dir, SLASH_STRING,
12888 file_name, (char *) NULL);
12890 /* NOTE: If comp_dir is a relative path, this will also try the
12891 search path, which seems useful. */
12892 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile,
12895 1 /*search_cwd*/));
12896 xfree (path_to_try);
12901 /* That didn't work, try debug-file-directory, which, despite its name,
12902 is a list of paths. */
12904 if (*debug_file_directory == '\0')
12907 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12908 0 /*is_dwp*/, 1 /*search_cwd*/);
12911 /* This function is mapped across the sections and remembers the offset and
12912 size of each of the DWO debugging sections we are interested in. */
12915 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
12917 struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
12918 const struct dwop_section_names *names = &dwop_section_names;
12920 if (section_is_p (sectp->name, &names->abbrev_dwo))
12922 dwo_sections->abbrev.s.section = sectp;
12923 dwo_sections->abbrev.size = bfd_get_section_size (sectp);
12925 else if (section_is_p (sectp->name, &names->info_dwo))
12927 dwo_sections->info.s.section = sectp;
12928 dwo_sections->info.size = bfd_get_section_size (sectp);
12930 else if (section_is_p (sectp->name, &names->line_dwo))
12932 dwo_sections->line.s.section = sectp;
12933 dwo_sections->line.size = bfd_get_section_size (sectp);
12935 else if (section_is_p (sectp->name, &names->loc_dwo))
12937 dwo_sections->loc.s.section = sectp;
12938 dwo_sections->loc.size = bfd_get_section_size (sectp);
12940 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12942 dwo_sections->macinfo.s.section = sectp;
12943 dwo_sections->macinfo.size = bfd_get_section_size (sectp);
12945 else if (section_is_p (sectp->name, &names->macro_dwo))
12947 dwo_sections->macro.s.section = sectp;
12948 dwo_sections->macro.size = bfd_get_section_size (sectp);
12950 else if (section_is_p (sectp->name, &names->str_dwo))
12952 dwo_sections->str.s.section = sectp;
12953 dwo_sections->str.size = bfd_get_section_size (sectp);
12955 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12957 dwo_sections->str_offsets.s.section = sectp;
12958 dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
12960 else if (section_is_p (sectp->name, &names->types_dwo))
12962 struct dwarf2_section_info type_section;
12964 memset (&type_section, 0, sizeof (type_section));
12965 type_section.s.section = sectp;
12966 type_section.size = bfd_get_section_size (sectp);
12967 VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
12972 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12973 by PER_CU. This is for the non-DWP case.
12974 The result is NULL if DWO_NAME can't be found. */
12976 static struct dwo_file *
12977 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
12978 const char *dwo_name, const char *comp_dir)
12980 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
12981 struct objfile *objfile = dwarf2_per_objfile->objfile;
12983 gdb_bfd_ref_ptr dbfd (open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir));
12986 if (dwarf_read_debug)
12987 fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
12991 /* We use a unique pointer here, despite the obstack allocation,
12992 because a dwo_file needs some cleanup if it is abandoned. */
12993 dwo_file_up dwo_file (OBSTACK_ZALLOC (&objfile->objfile_obstack,
12995 dwo_file->dwo_name = dwo_name;
12996 dwo_file->comp_dir = comp_dir;
12997 dwo_file->dbfd = dbfd.release ();
12999 bfd_map_over_sections (dwo_file->dbfd, dwarf2_locate_dwo_sections,
13000 &dwo_file->sections);
13002 create_cus_hash_table (dwarf2_per_objfile, *dwo_file, dwo_file->sections.info,
13005 create_debug_types_hash_table (dwarf2_per_objfile, dwo_file.get (),
13006 dwo_file->sections.types, dwo_file->tus);
13008 if (dwarf_read_debug)
13009 fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
13011 return dwo_file.release ();
13014 /* This function is mapped across the sections and remembers the offset and
13015 size of each of the DWP debugging sections common to version 1 and 2 that
13016 we are interested in. */
13019 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
13020 void *dwp_file_ptr)
13022 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13023 const struct dwop_section_names *names = &dwop_section_names;
13024 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13026 /* Record the ELF section number for later lookup: this is what the
13027 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13028 gdb_assert (elf_section_nr < dwp_file->num_sections);
13029 dwp_file->elf_sections[elf_section_nr] = sectp;
13031 /* Look for specific sections that we need. */
13032 if (section_is_p (sectp->name, &names->str_dwo))
13034 dwp_file->sections.str.s.section = sectp;
13035 dwp_file->sections.str.size = bfd_get_section_size (sectp);
13037 else if (section_is_p (sectp->name, &names->cu_index))
13039 dwp_file->sections.cu_index.s.section = sectp;
13040 dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
13042 else if (section_is_p (sectp->name, &names->tu_index))
13044 dwp_file->sections.tu_index.s.section = sectp;
13045 dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
13049 /* This function is mapped across the sections and remembers the offset and
13050 size of each of the DWP version 2 debugging sections that we are interested
13051 in. This is split into a separate function because we don't know if we
13052 have version 1 or 2 until we parse the cu_index/tu_index sections. */
13055 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
13057 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13058 const struct dwop_section_names *names = &dwop_section_names;
13059 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13061 /* Record the ELF section number for later lookup: this is what the
13062 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13063 gdb_assert (elf_section_nr < dwp_file->num_sections);
13064 dwp_file->elf_sections[elf_section_nr] = sectp;
13066 /* Look for specific sections that we need. */
13067 if (section_is_p (sectp->name, &names->abbrev_dwo))
13069 dwp_file->sections.abbrev.s.section = sectp;
13070 dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
13072 else if (section_is_p (sectp->name, &names->info_dwo))
13074 dwp_file->sections.info.s.section = sectp;
13075 dwp_file->sections.info.size = bfd_get_section_size (sectp);
13077 else if (section_is_p (sectp->name, &names->line_dwo))
13079 dwp_file->sections.line.s.section = sectp;
13080 dwp_file->sections.line.size = bfd_get_section_size (sectp);
13082 else if (section_is_p (sectp->name, &names->loc_dwo))
13084 dwp_file->sections.loc.s.section = sectp;
13085 dwp_file->sections.loc.size = bfd_get_section_size (sectp);
13087 else if (section_is_p (sectp->name, &names->macinfo_dwo))
13089 dwp_file->sections.macinfo.s.section = sectp;
13090 dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
13092 else if (section_is_p (sectp->name, &names->macro_dwo))
13094 dwp_file->sections.macro.s.section = sectp;
13095 dwp_file->sections.macro.size = bfd_get_section_size (sectp);
13097 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
13099 dwp_file->sections.str_offsets.s.section = sectp;
13100 dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
13102 else if (section_is_p (sectp->name, &names->types_dwo))
13104 dwp_file->sections.types.s.section = sectp;
13105 dwp_file->sections.types.size = bfd_get_section_size (sectp);
13109 /* Hash function for dwp_file loaded CUs/TUs. */
13112 hash_dwp_loaded_cutus (const void *item)
13114 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
13116 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13117 return dwo_unit->signature;
13120 /* Equality function for dwp_file loaded CUs/TUs. */
13123 eq_dwp_loaded_cutus (const void *a, const void *b)
13125 const struct dwo_unit *dua = (const struct dwo_unit *) a;
13126 const struct dwo_unit *dub = (const struct dwo_unit *) b;
13128 return dua->signature == dub->signature;
13131 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13134 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
13136 return htab_create_alloc_ex (3,
13137 hash_dwp_loaded_cutus,
13138 eq_dwp_loaded_cutus,
13140 &objfile->objfile_obstack,
13141 hashtab_obstack_allocate,
13142 dummy_obstack_deallocate);
13145 /* Try to open DWP file FILE_NAME.
13146 The result is the bfd handle of the file.
13147 If there is a problem finding or opening the file, return NULL.
13148 Upon success, the canonicalized path of the file is stored in the bfd,
13149 same as symfile_bfd_open. */
13151 static gdb_bfd_ref_ptr
13152 open_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
13153 const char *file_name)
13155 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile, file_name,
13157 1 /*search_cwd*/));
13161 /* Work around upstream bug 15652.
13162 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13163 [Whether that's a "bug" is debatable, but it is getting in our way.]
13164 We have no real idea where the dwp file is, because gdb's realpath-ing
13165 of the executable's path may have discarded the needed info.
13166 [IWBN if the dwp file name was recorded in the executable, akin to
13167 .gnu_debuglink, but that doesn't exist yet.]
13168 Strip the directory from FILE_NAME and search again. */
13169 if (*debug_file_directory != '\0')
13171 /* Don't implicitly search the current directory here.
13172 If the user wants to search "." to handle this case,
13173 it must be added to debug-file-directory. */
13174 return try_open_dwop_file (dwarf2_per_objfile,
13175 lbasename (file_name), 1 /*is_dwp*/,
13182 /* Initialize the use of the DWP file for the current objfile.
13183 By convention the name of the DWP file is ${objfile}.dwp.
13184 The result is NULL if it can't be found. */
13186 static std::unique_ptr<struct dwp_file>
13187 open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13189 struct objfile *objfile = dwarf2_per_objfile->objfile;
13191 /* Try to find first .dwp for the binary file before any symbolic links
13194 /* If the objfile is a debug file, find the name of the real binary
13195 file and get the name of dwp file from there. */
13196 std::string dwp_name;
13197 if (objfile->separate_debug_objfile_backlink != NULL)
13199 struct objfile *backlink = objfile->separate_debug_objfile_backlink;
13200 const char *backlink_basename = lbasename (backlink->original_name);
13202 dwp_name = ldirname (objfile->original_name) + SLASH_STRING + backlink_basename;
13205 dwp_name = objfile->original_name;
13207 dwp_name += ".dwp";
13209 gdb_bfd_ref_ptr dbfd (open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ()));
13211 && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
13213 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13214 dwp_name = objfile_name (objfile);
13215 dwp_name += ".dwp";
13216 dbfd = open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ());
13221 if (dwarf_read_debug)
13222 fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name.c_str ());
13223 return std::unique_ptr<dwp_file> ();
13226 const char *name = bfd_get_filename (dbfd.get ());
13227 std::unique_ptr<struct dwp_file> dwp_file
13228 (new struct dwp_file (name, std::move (dbfd)));
13230 /* +1: section 0 is unused */
13231 dwp_file->num_sections = bfd_count_sections (dwp_file->dbfd) + 1;
13232 dwp_file->elf_sections =
13233 OBSTACK_CALLOC (&objfile->objfile_obstack,
13234 dwp_file->num_sections, asection *);
13236 bfd_map_over_sections (dwp_file->dbfd.get (),
13237 dwarf2_locate_common_dwp_sections,
13240 dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13243 dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13246 /* The DWP file version is stored in the hash table. Oh well. */
13247 if (dwp_file->cus && dwp_file->tus
13248 && dwp_file->cus->version != dwp_file->tus->version)
13250 /* Technically speaking, we should try to limp along, but this is
13251 pretty bizarre. We use pulongest here because that's the established
13252 portability solution (e.g, we cannot use %u for uint32_t). */
13253 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13254 " TU version %s [in DWP file %s]"),
13255 pulongest (dwp_file->cus->version),
13256 pulongest (dwp_file->tus->version), dwp_name.c_str ());
13260 dwp_file->version = dwp_file->cus->version;
13261 else if (dwp_file->tus)
13262 dwp_file->version = dwp_file->tus->version;
13264 dwp_file->version = 2;
13266 if (dwp_file->version == 2)
13267 bfd_map_over_sections (dwp_file->dbfd.get (),
13268 dwarf2_locate_v2_dwp_sections,
13271 dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
13272 dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
13274 if (dwarf_read_debug)
13276 fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
13277 fprintf_unfiltered (gdb_stdlog,
13278 " %s CUs, %s TUs\n",
13279 pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
13280 pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
13286 /* Wrapper around open_and_init_dwp_file, only open it once. */
13288 static struct dwp_file *
13289 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13291 if (! dwarf2_per_objfile->dwp_checked)
13293 dwarf2_per_objfile->dwp_file
13294 = open_and_init_dwp_file (dwarf2_per_objfile);
13295 dwarf2_per_objfile->dwp_checked = 1;
13297 return dwarf2_per_objfile->dwp_file.get ();
13300 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13301 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13302 or in the DWP file for the objfile, referenced by THIS_UNIT.
13303 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13304 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13306 This is called, for example, when wanting to read a variable with a
13307 complex location. Therefore we don't want to do file i/o for every call.
13308 Therefore we don't want to look for a DWO file on every call.
13309 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13310 then we check if we've already seen DWO_NAME, and only THEN do we check
13313 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13314 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13316 static struct dwo_unit *
13317 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
13318 const char *dwo_name, const char *comp_dir,
13319 ULONGEST signature, int is_debug_types)
13321 struct dwarf2_per_objfile *dwarf2_per_objfile = this_unit->dwarf2_per_objfile;
13322 struct objfile *objfile = dwarf2_per_objfile->objfile;
13323 const char *kind = is_debug_types ? "TU" : "CU";
13324 void **dwo_file_slot;
13325 struct dwo_file *dwo_file;
13326 struct dwp_file *dwp_file;
13328 /* First see if there's a DWP file.
13329 If we have a DWP file but didn't find the DWO inside it, don't
13330 look for the original DWO file. It makes gdb behave differently
13331 depending on whether one is debugging in the build tree. */
13333 dwp_file = get_dwp_file (dwarf2_per_objfile);
13334 if (dwp_file != NULL)
13336 const struct dwp_hash_table *dwp_htab =
13337 is_debug_types ? dwp_file->tus : dwp_file->cus;
13339 if (dwp_htab != NULL)
13341 struct dwo_unit *dwo_cutu =
13342 lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, comp_dir,
13343 signature, is_debug_types);
13345 if (dwo_cutu != NULL)
13347 if (dwarf_read_debug)
13349 fprintf_unfiltered (gdb_stdlog,
13350 "Virtual DWO %s %s found: @%s\n",
13351 kind, hex_string (signature),
13352 host_address_to_string (dwo_cutu));
13360 /* No DWP file, look for the DWO file. */
13362 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
13363 dwo_name, comp_dir);
13364 if (*dwo_file_slot == NULL)
13366 /* Read in the file and build a table of the CUs/TUs it contains. */
13367 *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
13369 /* NOTE: This will be NULL if unable to open the file. */
13370 dwo_file = (struct dwo_file *) *dwo_file_slot;
13372 if (dwo_file != NULL)
13374 struct dwo_unit *dwo_cutu = NULL;
13376 if (is_debug_types && dwo_file->tus)
13378 struct dwo_unit find_dwo_cutu;
13380 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13381 find_dwo_cutu.signature = signature;
13383 = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
13385 else if (!is_debug_types && dwo_file->cus)
13387 struct dwo_unit find_dwo_cutu;
13389 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13390 find_dwo_cutu.signature = signature;
13391 dwo_cutu = (struct dwo_unit *)htab_find (dwo_file->cus,
13395 if (dwo_cutu != NULL)
13397 if (dwarf_read_debug)
13399 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
13400 kind, dwo_name, hex_string (signature),
13401 host_address_to_string (dwo_cutu));
13408 /* We didn't find it. This could mean a dwo_id mismatch, or
13409 someone deleted the DWO/DWP file, or the search path isn't set up
13410 correctly to find the file. */
13412 if (dwarf_read_debug)
13414 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
13415 kind, dwo_name, hex_string (signature));
13418 /* This is a warning and not a complaint because it can be caused by
13419 pilot error (e.g., user accidentally deleting the DWO). */
13421 /* Print the name of the DWP file if we looked there, helps the user
13422 better diagnose the problem. */
13423 std::string dwp_text;
13425 if (dwp_file != NULL)
13426 dwp_text = string_printf (" [in DWP file %s]",
13427 lbasename (dwp_file->name));
13429 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13430 " [in module %s]"),
13431 kind, dwo_name, hex_string (signature),
13433 this_unit->is_debug_types ? "TU" : "CU",
13434 sect_offset_str (this_unit->sect_off), objfile_name (objfile));
13439 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13440 See lookup_dwo_cutu_unit for details. */
13442 static struct dwo_unit *
13443 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
13444 const char *dwo_name, const char *comp_dir,
13445 ULONGEST signature)
13447 return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
13450 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13451 See lookup_dwo_cutu_unit for details. */
13453 static struct dwo_unit *
13454 lookup_dwo_type_unit (struct signatured_type *this_tu,
13455 const char *dwo_name, const char *comp_dir)
13457 return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
13460 /* Traversal function for queue_and_load_all_dwo_tus. */
13463 queue_and_load_dwo_tu (void **slot, void *info)
13465 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
13466 struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
13467 ULONGEST signature = dwo_unit->signature;
13468 struct signatured_type *sig_type =
13469 lookup_dwo_signatured_type (per_cu->cu, signature);
13471 if (sig_type != NULL)
13473 struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
13475 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13476 a real dependency of PER_CU on SIG_TYPE. That is detected later
13477 while processing PER_CU. */
13478 if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
13479 load_full_type_unit (sig_cu);
13480 VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
13486 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13487 The DWO may have the only definition of the type, though it may not be
13488 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13489 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13492 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
13494 struct dwo_unit *dwo_unit;
13495 struct dwo_file *dwo_file;
13497 gdb_assert (!per_cu->is_debug_types);
13498 gdb_assert (get_dwp_file (per_cu->dwarf2_per_objfile) == NULL);
13499 gdb_assert (per_cu->cu != NULL);
13501 dwo_unit = per_cu->cu->dwo_unit;
13502 gdb_assert (dwo_unit != NULL);
13504 dwo_file = dwo_unit->dwo_file;
13505 if (dwo_file->tus != NULL)
13506 htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
13509 /* Free all resources associated with DWO_FILE.
13510 Close the DWO file and munmap the sections. */
13513 free_dwo_file (struct dwo_file *dwo_file)
13515 /* Note: dbfd is NULL for virtual DWO files. */
13516 gdb_bfd_unref (dwo_file->dbfd);
13518 VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
13521 /* Traversal function for free_dwo_files. */
13524 free_dwo_file_from_slot (void **slot, void *info)
13526 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
13528 free_dwo_file (dwo_file);
13533 /* Free all resources associated with DWO_FILES. */
13536 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
13538 htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
13541 /* Read in various DIEs. */
13543 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13544 Inherit only the children of the DW_AT_abstract_origin DIE not being
13545 already referenced by DW_AT_abstract_origin from the children of the
13549 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
13551 struct die_info *child_die;
13552 sect_offset *offsetp;
13553 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13554 struct die_info *origin_die;
13555 /* Iterator of the ORIGIN_DIE children. */
13556 struct die_info *origin_child_die;
13557 struct attribute *attr;
13558 struct dwarf2_cu *origin_cu;
13559 struct pending **origin_previous_list_in_scope;
13561 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13565 /* Note that following die references may follow to a die in a
13569 origin_die = follow_die_ref (die, attr, &origin_cu);
13571 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13573 origin_previous_list_in_scope = origin_cu->list_in_scope;
13574 origin_cu->list_in_scope = cu->list_in_scope;
13576 if (die->tag != origin_die->tag
13577 && !(die->tag == DW_TAG_inlined_subroutine
13578 && origin_die->tag == DW_TAG_subprogram))
13579 complaint (_("DIE %s and its abstract origin %s have different tags"),
13580 sect_offset_str (die->sect_off),
13581 sect_offset_str (origin_die->sect_off));
13583 std::vector<sect_offset> offsets;
13585 for (child_die = die->child;
13586 child_die && child_die->tag;
13587 child_die = sibling_die (child_die))
13589 struct die_info *child_origin_die;
13590 struct dwarf2_cu *child_origin_cu;
13592 /* We are trying to process concrete instance entries:
13593 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13594 it's not relevant to our analysis here. i.e. detecting DIEs that are
13595 present in the abstract instance but not referenced in the concrete
13597 if (child_die->tag == DW_TAG_call_site
13598 || child_die->tag == DW_TAG_GNU_call_site)
13601 /* For each CHILD_DIE, find the corresponding child of
13602 ORIGIN_DIE. If there is more than one layer of
13603 DW_AT_abstract_origin, follow them all; there shouldn't be,
13604 but GCC versions at least through 4.4 generate this (GCC PR
13606 child_origin_die = child_die;
13607 child_origin_cu = cu;
13610 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
13614 child_origin_die = follow_die_ref (child_origin_die, attr,
13618 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13619 counterpart may exist. */
13620 if (child_origin_die != child_die)
13622 if (child_die->tag != child_origin_die->tag
13623 && !(child_die->tag == DW_TAG_inlined_subroutine
13624 && child_origin_die->tag == DW_TAG_subprogram))
13625 complaint (_("Child DIE %s and its abstract origin %s have "
13627 sect_offset_str (child_die->sect_off),
13628 sect_offset_str (child_origin_die->sect_off));
13629 if (child_origin_die->parent != origin_die)
13630 complaint (_("Child DIE %s and its abstract origin %s have "
13631 "different parents"),
13632 sect_offset_str (child_die->sect_off),
13633 sect_offset_str (child_origin_die->sect_off));
13635 offsets.push_back (child_origin_die->sect_off);
13638 std::sort (offsets.begin (), offsets.end ());
13639 sect_offset *offsets_end = offsets.data () + offsets.size ();
13640 for (offsetp = offsets.data () + 1; offsetp < offsets_end; offsetp++)
13641 if (offsetp[-1] == *offsetp)
13642 complaint (_("Multiple children of DIE %s refer "
13643 "to DIE %s as their abstract origin"),
13644 sect_offset_str (die->sect_off), sect_offset_str (*offsetp));
13646 offsetp = offsets.data ();
13647 origin_child_die = origin_die->child;
13648 while (origin_child_die && origin_child_die->tag)
13650 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13651 while (offsetp < offsets_end
13652 && *offsetp < origin_child_die->sect_off)
13654 if (offsetp >= offsets_end
13655 || *offsetp > origin_child_die->sect_off)
13657 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13658 Check whether we're already processing ORIGIN_CHILD_DIE.
13659 This can happen with mutually referenced abstract_origins.
13661 if (!origin_child_die->in_process)
13662 process_die (origin_child_die, origin_cu);
13664 origin_child_die = sibling_die (origin_child_die);
13666 origin_cu->list_in_scope = origin_previous_list_in_scope;
13670 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
13672 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13673 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13674 struct context_stack *newobj;
13677 struct die_info *child_die;
13678 struct attribute *attr, *call_line, *call_file;
13680 CORE_ADDR baseaddr;
13681 struct block *block;
13682 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
13683 std::vector<struct symbol *> template_args;
13684 struct template_symbol *templ_func = NULL;
13688 /* If we do not have call site information, we can't show the
13689 caller of this inlined function. That's too confusing, so
13690 only use the scope for local variables. */
13691 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
13692 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
13693 if (call_line == NULL || call_file == NULL)
13695 read_lexical_block_scope (die, cu);
13700 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13702 name = dwarf2_name (die, cu);
13704 /* Ignore functions with missing or empty names. These are actually
13705 illegal according to the DWARF standard. */
13708 complaint (_("missing name for subprogram DIE at %s"),
13709 sect_offset_str (die->sect_off));
13713 /* Ignore functions with missing or invalid low and high pc attributes. */
13714 if (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL)
13715 <= PC_BOUNDS_INVALID)
13717 attr = dwarf2_attr (die, DW_AT_external, cu);
13718 if (!attr || !DW_UNSND (attr))
13719 complaint (_("cannot get low and high bounds "
13720 "for subprogram DIE at %s"),
13721 sect_offset_str (die->sect_off));
13725 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13726 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13728 /* If we have any template arguments, then we must allocate a
13729 different sort of symbol. */
13730 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
13732 if (child_die->tag == DW_TAG_template_type_param
13733 || child_die->tag == DW_TAG_template_value_param)
13735 templ_func = allocate_template_symbol (objfile);
13736 templ_func->subclass = SYMBOL_TEMPLATE;
13741 newobj = cu->builder->push_context (0, lowpc);
13742 newobj->name = new_symbol (die, read_type_die (die, cu), cu,
13743 (struct symbol *) templ_func);
13745 /* If there is a location expression for DW_AT_frame_base, record
13747 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
13749 dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
13751 /* If there is a location for the static link, record it. */
13752 newobj->static_link = NULL;
13753 attr = dwarf2_attr (die, DW_AT_static_link, cu);
13756 newobj->static_link
13757 = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
13758 attr_to_dynamic_prop (attr, die, cu, newobj->static_link);
13761 cu->list_in_scope = cu->builder->get_local_symbols ();
13763 if (die->child != NULL)
13765 child_die = die->child;
13766 while (child_die && child_die->tag)
13768 if (child_die->tag == DW_TAG_template_type_param
13769 || child_die->tag == DW_TAG_template_value_param)
13771 struct symbol *arg = new_symbol (child_die, NULL, cu);
13774 template_args.push_back (arg);
13777 process_die (child_die, cu);
13778 child_die = sibling_die (child_die);
13782 inherit_abstract_dies (die, cu);
13784 /* If we have a DW_AT_specification, we might need to import using
13785 directives from the context of the specification DIE. See the
13786 comment in determine_prefix. */
13787 if (cu->language == language_cplus
13788 && dwarf2_attr (die, DW_AT_specification, cu))
13790 struct dwarf2_cu *spec_cu = cu;
13791 struct die_info *spec_die = die_specification (die, &spec_cu);
13795 child_die = spec_die->child;
13796 while (child_die && child_die->tag)
13798 if (child_die->tag == DW_TAG_imported_module)
13799 process_die (child_die, spec_cu);
13800 child_die = sibling_die (child_die);
13803 /* In some cases, GCC generates specification DIEs that
13804 themselves contain DW_AT_specification attributes. */
13805 spec_die = die_specification (spec_die, &spec_cu);
13809 struct context_stack cstk = cu->builder->pop_context ();
13810 /* Make a block for the local symbols within. */
13811 block = cu->builder->finish_block (cstk.name, cstk.old_blocks,
13812 cstk.static_link, lowpc, highpc);
13814 /* For C++, set the block's scope. */
13815 if ((cu->language == language_cplus
13816 || cu->language == language_fortran
13817 || cu->language == language_d
13818 || cu->language == language_rust)
13819 && cu->processing_has_namespace_info)
13820 block_set_scope (block, determine_prefix (die, cu),
13821 &objfile->objfile_obstack);
13823 /* If we have address ranges, record them. */
13824 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13826 gdbarch_make_symbol_special (gdbarch, cstk.name, objfile);
13828 /* Attach template arguments to function. */
13829 if (!template_args.empty ())
13831 gdb_assert (templ_func != NULL);
13833 templ_func->n_template_arguments = template_args.size ();
13834 templ_func->template_arguments
13835 = XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
13836 templ_func->n_template_arguments);
13837 memcpy (templ_func->template_arguments,
13838 template_args.data (),
13839 (templ_func->n_template_arguments * sizeof (struct symbol *)));
13841 /* Make sure that the symtab is set on the new symbols. Even
13842 though they don't appear in this symtab directly, other parts
13843 of gdb assume that symbols do, and this is reasonably
13845 for (symbol *sym : template_args)
13846 symbol_set_symtab (sym, symbol_symtab (templ_func));
13849 /* In C++, we can have functions nested inside functions (e.g., when
13850 a function declares a class that has methods). This means that
13851 when we finish processing a function scope, we may need to go
13852 back to building a containing block's symbol lists. */
13853 *cu->builder->get_local_symbols () = cstk.locals;
13854 cu->builder->set_local_using_directives (cstk.local_using_directives);
13856 /* If we've finished processing a top-level function, subsequent
13857 symbols go in the file symbol list. */
13858 if (cu->builder->outermost_context_p ())
13859 cu->list_in_scope = cu->builder->get_file_symbols ();
13862 /* Process all the DIES contained within a lexical block scope. Start
13863 a new scope, process the dies, and then close the scope. */
13866 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
13868 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13869 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13870 CORE_ADDR lowpc, highpc;
13871 struct die_info *child_die;
13872 CORE_ADDR baseaddr;
13874 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13876 /* Ignore blocks with missing or invalid low and high pc attributes. */
13877 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13878 as multiple lexical blocks? Handling children in a sane way would
13879 be nasty. Might be easier to properly extend generic blocks to
13880 describe ranges. */
13881 switch (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
13883 case PC_BOUNDS_NOT_PRESENT:
13884 /* DW_TAG_lexical_block has no attributes, process its children as if
13885 there was no wrapping by that DW_TAG_lexical_block.
13886 GCC does no longer produces such DWARF since GCC r224161. */
13887 for (child_die = die->child;
13888 child_die != NULL && child_die->tag;
13889 child_die = sibling_die (child_die))
13890 process_die (child_die, cu);
13892 case PC_BOUNDS_INVALID:
13895 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13896 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13898 cu->builder->push_context (0, lowpc);
13899 if (die->child != NULL)
13901 child_die = die->child;
13902 while (child_die && child_die->tag)
13904 process_die (child_die, cu);
13905 child_die = sibling_die (child_die);
13908 inherit_abstract_dies (die, cu);
13909 struct context_stack cstk = cu->builder->pop_context ();
13911 if (*cu->builder->get_local_symbols () != NULL
13912 || (*cu->builder->get_local_using_directives ()) != NULL)
13914 struct block *block
13915 = cu->builder->finish_block (0, cstk.old_blocks, NULL,
13916 cstk.start_addr, highpc);
13918 /* Note that recording ranges after traversing children, as we
13919 do here, means that recording a parent's ranges entails
13920 walking across all its children's ranges as they appear in
13921 the address map, which is quadratic behavior.
13923 It would be nicer to record the parent's ranges before
13924 traversing its children, simply overriding whatever you find
13925 there. But since we don't even decide whether to create a
13926 block until after we've traversed its children, that's hard
13928 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13930 *cu->builder->get_local_symbols () = cstk.locals;
13931 cu->builder->set_local_using_directives (cstk.local_using_directives);
13934 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13937 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
13939 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13940 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13941 CORE_ADDR pc, baseaddr;
13942 struct attribute *attr;
13943 struct call_site *call_site, call_site_local;
13946 struct die_info *child_die;
13948 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13950 attr = dwarf2_attr (die, DW_AT_call_return_pc, cu);
13953 /* This was a pre-DWARF-5 GNU extension alias
13954 for DW_AT_call_return_pc. */
13955 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
13959 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13960 "DIE %s [in module %s]"),
13961 sect_offset_str (die->sect_off), objfile_name (objfile));
13964 pc = attr_value_as_address (attr) + baseaddr;
13965 pc = gdbarch_adjust_dwarf2_addr (gdbarch, pc);
13967 if (cu->call_site_htab == NULL)
13968 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
13969 NULL, &objfile->objfile_obstack,
13970 hashtab_obstack_allocate, NULL);
13971 call_site_local.pc = pc;
13972 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
13975 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13976 "DIE %s [in module %s]"),
13977 paddress (gdbarch, pc), sect_offset_str (die->sect_off),
13978 objfile_name (objfile));
13982 /* Count parameters at the caller. */
13985 for (child_die = die->child; child_die && child_die->tag;
13986 child_die = sibling_die (child_die))
13988 if (child_die->tag != DW_TAG_call_site_parameter
13989 && child_die->tag != DW_TAG_GNU_call_site_parameter)
13991 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13992 "DW_TAG_call_site child DIE %s [in module %s]"),
13993 child_die->tag, sect_offset_str (child_die->sect_off),
13994 objfile_name (objfile));
14002 = ((struct call_site *)
14003 obstack_alloc (&objfile->objfile_obstack,
14004 sizeof (*call_site)
14005 + (sizeof (*call_site->parameter) * (nparams - 1))));
14007 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
14008 call_site->pc = pc;
14010 if (dwarf2_flag_true_p (die, DW_AT_call_tail_call, cu)
14011 || dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
14013 struct die_info *func_die;
14015 /* Skip also over DW_TAG_inlined_subroutine. */
14016 for (func_die = die->parent;
14017 func_die && func_die->tag != DW_TAG_subprogram
14018 && func_die->tag != DW_TAG_subroutine_type;
14019 func_die = func_die->parent);
14021 /* DW_AT_call_all_calls is a superset
14022 of DW_AT_call_all_tail_calls. */
14024 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_calls, cu)
14025 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
14026 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_tail_calls, cu)
14027 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
14029 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
14030 not complete. But keep CALL_SITE for look ups via call_site_htab,
14031 both the initial caller containing the real return address PC and
14032 the final callee containing the current PC of a chain of tail
14033 calls do not need to have the tail call list complete. But any
14034 function candidate for a virtual tail call frame searched via
14035 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14036 determined unambiguously. */
14040 struct type *func_type = NULL;
14043 func_type = get_die_type (func_die, cu);
14044 if (func_type != NULL)
14046 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
14048 /* Enlist this call site to the function. */
14049 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
14050 TYPE_TAIL_CALL_LIST (func_type) = call_site;
14053 complaint (_("Cannot find function owning DW_TAG_call_site "
14054 "DIE %s [in module %s]"),
14055 sect_offset_str (die->sect_off), objfile_name (objfile));
14059 attr = dwarf2_attr (die, DW_AT_call_target, cu);
14061 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
14063 attr = dwarf2_attr (die, DW_AT_call_origin, cu);
14066 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
14067 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14069 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
14070 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
14071 /* Keep NULL DWARF_BLOCK. */;
14072 else if (attr_form_is_block (attr))
14074 struct dwarf2_locexpr_baton *dlbaton;
14076 dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
14077 dlbaton->data = DW_BLOCK (attr)->data;
14078 dlbaton->size = DW_BLOCK (attr)->size;
14079 dlbaton->per_cu = cu->per_cu;
14081 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
14083 else if (attr_form_is_ref (attr))
14085 struct dwarf2_cu *target_cu = cu;
14086 struct die_info *target_die;
14088 target_die = follow_die_ref (die, attr, &target_cu);
14089 gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
14090 if (die_is_declaration (target_die, target_cu))
14092 const char *target_physname;
14094 /* Prefer the mangled name; otherwise compute the demangled one. */
14095 target_physname = dw2_linkage_name (target_die, target_cu);
14096 if (target_physname == NULL)
14097 target_physname = dwarf2_physname (NULL, target_die, target_cu);
14098 if (target_physname == NULL)
14099 complaint (_("DW_AT_call_target target DIE has invalid "
14100 "physname, for referencing DIE %s [in module %s]"),
14101 sect_offset_str (die->sect_off), objfile_name (objfile));
14103 SET_FIELD_PHYSNAME (call_site->target, target_physname);
14109 /* DW_AT_entry_pc should be preferred. */
14110 if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
14111 <= PC_BOUNDS_INVALID)
14112 complaint (_("DW_AT_call_target target DIE has invalid "
14113 "low pc, for referencing DIE %s [in module %s]"),
14114 sect_offset_str (die->sect_off), objfile_name (objfile));
14117 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
14118 SET_FIELD_PHYSADDR (call_site->target, lowpc);
14123 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14124 "block nor reference, for DIE %s [in module %s]"),
14125 sect_offset_str (die->sect_off), objfile_name (objfile));
14127 call_site->per_cu = cu->per_cu;
14129 for (child_die = die->child;
14130 child_die && child_die->tag;
14131 child_die = sibling_die (child_die))
14133 struct call_site_parameter *parameter;
14134 struct attribute *loc, *origin;
14136 if (child_die->tag != DW_TAG_call_site_parameter
14137 && child_die->tag != DW_TAG_GNU_call_site_parameter)
14139 /* Already printed the complaint above. */
14143 gdb_assert (call_site->parameter_count < nparams);
14144 parameter = &call_site->parameter[call_site->parameter_count];
14146 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14147 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14148 register is contained in DW_AT_call_value. */
14150 loc = dwarf2_attr (child_die, DW_AT_location, cu);
14151 origin = dwarf2_attr (child_die, DW_AT_call_parameter, cu);
14152 if (origin == NULL)
14154 /* This was a pre-DWARF-5 GNU extension alias
14155 for DW_AT_call_parameter. */
14156 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
14158 if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
14160 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
14162 sect_offset sect_off
14163 = (sect_offset) dwarf2_get_ref_die_offset (origin);
14164 if (!offset_in_cu_p (&cu->header, sect_off))
14166 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14167 binding can be done only inside one CU. Such referenced DIE
14168 therefore cannot be even moved to DW_TAG_partial_unit. */
14169 complaint (_("DW_AT_call_parameter offset is not in CU for "
14170 "DW_TAG_call_site child DIE %s [in module %s]"),
14171 sect_offset_str (child_die->sect_off),
14172 objfile_name (objfile));
14175 parameter->u.param_cu_off
14176 = (cu_offset) (sect_off - cu->header.sect_off);
14178 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
14180 complaint (_("No DW_FORM_block* DW_AT_location for "
14181 "DW_TAG_call_site child DIE %s [in module %s]"),
14182 sect_offset_str (child_die->sect_off), objfile_name (objfile));
14187 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
14188 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
14189 if (parameter->u.dwarf_reg != -1)
14190 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
14191 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
14192 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
14193 ¶meter->u.fb_offset))
14194 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
14197 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14198 "for DW_FORM_block* DW_AT_location is supported for "
14199 "DW_TAG_call_site child DIE %s "
14201 sect_offset_str (child_die->sect_off),
14202 objfile_name (objfile));
14207 attr = dwarf2_attr (child_die, DW_AT_call_value, cu);
14209 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
14210 if (!attr_form_is_block (attr))
14212 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14213 "DW_TAG_call_site child DIE %s [in module %s]"),
14214 sect_offset_str (child_die->sect_off),
14215 objfile_name (objfile));
14218 parameter->value = DW_BLOCK (attr)->data;
14219 parameter->value_size = DW_BLOCK (attr)->size;
14221 /* Parameters are not pre-cleared by memset above. */
14222 parameter->data_value = NULL;
14223 parameter->data_value_size = 0;
14224 call_site->parameter_count++;
14226 attr = dwarf2_attr (child_die, DW_AT_call_data_value, cu);
14228 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
14231 if (!attr_form_is_block (attr))
14232 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14233 "DW_TAG_call_site child DIE %s [in module %s]"),
14234 sect_offset_str (child_die->sect_off),
14235 objfile_name (objfile));
14238 parameter->data_value = DW_BLOCK (attr)->data;
14239 parameter->data_value_size = DW_BLOCK (attr)->size;
14245 /* Helper function for read_variable. If DIE represents a virtual
14246 table, then return the type of the concrete object that is
14247 associated with the virtual table. Otherwise, return NULL. */
14249 static struct type *
14250 rust_containing_type (struct die_info *die, struct dwarf2_cu *cu)
14252 struct attribute *attr = dwarf2_attr (die, DW_AT_type, cu);
14256 /* Find the type DIE. */
14257 struct die_info *type_die = NULL;
14258 struct dwarf2_cu *type_cu = cu;
14260 if (attr_form_is_ref (attr))
14261 type_die = follow_die_ref (die, attr, &type_cu);
14262 if (type_die == NULL)
14265 if (dwarf2_attr (type_die, DW_AT_containing_type, type_cu) == NULL)
14267 return die_containing_type (type_die, type_cu);
14270 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14273 read_variable (struct die_info *die, struct dwarf2_cu *cu)
14275 struct rust_vtable_symbol *storage = NULL;
14277 if (cu->language == language_rust)
14279 struct type *containing_type = rust_containing_type (die, cu);
14281 if (containing_type != NULL)
14283 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14285 storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
14286 struct rust_vtable_symbol);
14287 initialize_objfile_symbol (storage);
14288 storage->concrete_type = containing_type;
14289 storage->subclass = SYMBOL_RUST_VTABLE;
14293 struct symbol *res = new_symbol (die, NULL, cu, storage);
14294 struct attribute *abstract_origin
14295 = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14296 struct attribute *loc = dwarf2_attr (die, DW_AT_location, cu);
14297 if (res == NULL && loc && abstract_origin)
14299 /* We have a variable without a name, but with a location and an abstract
14300 origin. This may be a concrete instance of an abstract variable
14301 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14303 struct dwarf2_cu *origin_cu = cu;
14304 struct die_info *origin_die
14305 = follow_die_ref (die, abstract_origin, &origin_cu);
14306 dwarf2_per_objfile *dpo = cu->per_cu->dwarf2_per_objfile;
14307 dpo->abstract_to_concrete[origin_die].push_back (die);
14311 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14312 reading .debug_rnglists.
14313 Callback's type should be:
14314 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14315 Return true if the attributes are present and valid, otherwise,
14318 template <typename Callback>
14320 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
14321 Callback &&callback)
14323 struct dwarf2_per_objfile *dwarf2_per_objfile
14324 = cu->per_cu->dwarf2_per_objfile;
14325 struct objfile *objfile = dwarf2_per_objfile->objfile;
14326 bfd *obfd = objfile->obfd;
14327 /* Base address selection entry. */
14330 const gdb_byte *buffer;
14331 CORE_ADDR baseaddr;
14332 bool overflow = false;
14334 found_base = cu->base_known;
14335 base = cu->base_address;
14337 dwarf2_read_section (objfile, &dwarf2_per_objfile->rnglists);
14338 if (offset >= dwarf2_per_objfile->rnglists.size)
14340 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14344 buffer = dwarf2_per_objfile->rnglists.buffer + offset;
14346 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14350 /* Initialize it due to a false compiler warning. */
14351 CORE_ADDR range_beginning = 0, range_end = 0;
14352 const gdb_byte *buf_end = (dwarf2_per_objfile->rnglists.buffer
14353 + dwarf2_per_objfile->rnglists.size);
14354 unsigned int bytes_read;
14356 if (buffer == buf_end)
14361 const auto rlet = static_cast<enum dwarf_range_list_entry>(*buffer++);
14364 case DW_RLE_end_of_list:
14366 case DW_RLE_base_address:
14367 if (buffer + cu->header.addr_size > buf_end)
14372 base = read_address (obfd, buffer, cu, &bytes_read);
14374 buffer += bytes_read;
14376 case DW_RLE_start_length:
14377 if (buffer + cu->header.addr_size > buf_end)
14382 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14383 buffer += bytes_read;
14384 range_end = (range_beginning
14385 + read_unsigned_leb128 (obfd, buffer, &bytes_read));
14386 buffer += bytes_read;
14387 if (buffer > buf_end)
14393 case DW_RLE_offset_pair:
14394 range_beginning = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14395 buffer += bytes_read;
14396 if (buffer > buf_end)
14401 range_end = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14402 buffer += bytes_read;
14403 if (buffer > buf_end)
14409 case DW_RLE_start_end:
14410 if (buffer + 2 * cu->header.addr_size > buf_end)
14415 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14416 buffer += bytes_read;
14417 range_end = read_address (obfd, buffer, cu, &bytes_read);
14418 buffer += bytes_read;
14421 complaint (_("Invalid .debug_rnglists data (no base address)"));
14424 if (rlet == DW_RLE_end_of_list || overflow)
14426 if (rlet == DW_RLE_base_address)
14431 /* We have no valid base address for the ranges
14433 complaint (_("Invalid .debug_rnglists data (no base address)"));
14437 if (range_beginning > range_end)
14439 /* Inverted range entries are invalid. */
14440 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14444 /* Empty range entries have no effect. */
14445 if (range_beginning == range_end)
14448 range_beginning += base;
14451 /* A not-uncommon case of bad debug info.
14452 Don't pollute the addrmap with bad data. */
14453 if (range_beginning + baseaddr == 0
14454 && !dwarf2_per_objfile->has_section_at_zero)
14456 complaint (_(".debug_rnglists entry has start address of zero"
14457 " [in module %s]"), objfile_name (objfile));
14461 callback (range_beginning, range_end);
14466 complaint (_("Offset %d is not terminated "
14467 "for DW_AT_ranges attribute"),
14475 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14476 Callback's type should be:
14477 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14478 Return 1 if the attributes are present and valid, otherwise, return 0. */
14480 template <typename Callback>
14482 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
14483 Callback &&callback)
14485 struct dwarf2_per_objfile *dwarf2_per_objfile
14486 = cu->per_cu->dwarf2_per_objfile;
14487 struct objfile *objfile = dwarf2_per_objfile->objfile;
14488 struct comp_unit_head *cu_header = &cu->header;
14489 bfd *obfd = objfile->obfd;
14490 unsigned int addr_size = cu_header->addr_size;
14491 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
14492 /* Base address selection entry. */
14495 unsigned int dummy;
14496 const gdb_byte *buffer;
14497 CORE_ADDR baseaddr;
14499 if (cu_header->version >= 5)
14500 return dwarf2_rnglists_process (offset, cu, callback);
14502 found_base = cu->base_known;
14503 base = cu->base_address;
14505 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
14506 if (offset >= dwarf2_per_objfile->ranges.size)
14508 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14512 buffer = dwarf2_per_objfile->ranges.buffer + offset;
14514 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14518 CORE_ADDR range_beginning, range_end;
14520 range_beginning = read_address (obfd, buffer, cu, &dummy);
14521 buffer += addr_size;
14522 range_end = read_address (obfd, buffer, cu, &dummy);
14523 buffer += addr_size;
14524 offset += 2 * addr_size;
14526 /* An end of list marker is a pair of zero addresses. */
14527 if (range_beginning == 0 && range_end == 0)
14528 /* Found the end of list entry. */
14531 /* Each base address selection entry is a pair of 2 values.
14532 The first is the largest possible address, the second is
14533 the base address. Check for a base address here. */
14534 if ((range_beginning & mask) == mask)
14536 /* If we found the largest possible address, then we already
14537 have the base address in range_end. */
14545 /* We have no valid base address for the ranges
14547 complaint (_("Invalid .debug_ranges data (no base address)"));
14551 if (range_beginning > range_end)
14553 /* Inverted range entries are invalid. */
14554 complaint (_("Invalid .debug_ranges data (inverted range)"));
14558 /* Empty range entries have no effect. */
14559 if (range_beginning == range_end)
14562 range_beginning += base;
14565 /* A not-uncommon case of bad debug info.
14566 Don't pollute the addrmap with bad data. */
14567 if (range_beginning + baseaddr == 0
14568 && !dwarf2_per_objfile->has_section_at_zero)
14570 complaint (_(".debug_ranges entry has start address of zero"
14571 " [in module %s]"), objfile_name (objfile));
14575 callback (range_beginning, range_end);
14581 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14582 Return 1 if the attributes are present and valid, otherwise, return 0.
14583 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14586 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
14587 CORE_ADDR *high_return, struct dwarf2_cu *cu,
14588 struct partial_symtab *ranges_pst)
14590 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14591 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14592 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
14593 SECT_OFF_TEXT (objfile));
14596 CORE_ADDR high = 0;
14599 retval = dwarf2_ranges_process (offset, cu,
14600 [&] (CORE_ADDR range_beginning, CORE_ADDR range_end)
14602 if (ranges_pst != NULL)
14607 lowpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14608 range_beginning + baseaddr)
14610 highpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14611 range_end + baseaddr)
14613 addrmap_set_empty (objfile->psymtabs_addrmap, lowpc, highpc - 1,
14617 /* FIXME: This is recording everything as a low-high
14618 segment of consecutive addresses. We should have a
14619 data structure for discontiguous block ranges
14623 low = range_beginning;
14629 if (range_beginning < low)
14630 low = range_beginning;
14631 if (range_end > high)
14639 /* If the first entry is an end-of-list marker, the range
14640 describes an empty scope, i.e. no instructions. */
14646 *high_return = high;
14650 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14651 definition for the return value. *LOWPC and *HIGHPC are set iff
14652 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14654 static enum pc_bounds_kind
14655 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
14656 CORE_ADDR *highpc, struct dwarf2_cu *cu,
14657 struct partial_symtab *pst)
14659 struct dwarf2_per_objfile *dwarf2_per_objfile
14660 = cu->per_cu->dwarf2_per_objfile;
14661 struct attribute *attr;
14662 struct attribute *attr_high;
14664 CORE_ADDR high = 0;
14665 enum pc_bounds_kind ret;
14667 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14670 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14673 low = attr_value_as_address (attr);
14674 high = attr_value_as_address (attr_high);
14675 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14679 /* Found high w/o low attribute. */
14680 return PC_BOUNDS_INVALID;
14682 /* Found consecutive range of addresses. */
14683 ret = PC_BOUNDS_HIGH_LOW;
14687 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14690 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14691 We take advantage of the fact that DW_AT_ranges does not appear
14692 in DW_TAG_compile_unit of DWO files. */
14693 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14694 unsigned int ranges_offset = (DW_UNSND (attr)
14695 + (need_ranges_base
14699 /* Value of the DW_AT_ranges attribute is the offset in the
14700 .debug_ranges section. */
14701 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
14702 return PC_BOUNDS_INVALID;
14703 /* Found discontinuous range of addresses. */
14704 ret = PC_BOUNDS_RANGES;
14707 return PC_BOUNDS_NOT_PRESENT;
14710 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14712 return PC_BOUNDS_INVALID;
14714 /* When using the GNU linker, .gnu.linkonce. sections are used to
14715 eliminate duplicate copies of functions and vtables and such.
14716 The linker will arbitrarily choose one and discard the others.
14717 The AT_*_pc values for such functions refer to local labels in
14718 these sections. If the section from that file was discarded, the
14719 labels are not in the output, so the relocs get a value of 0.
14720 If this is a discarded function, mark the pc bounds as invalid,
14721 so that GDB will ignore it. */
14722 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
14723 return PC_BOUNDS_INVALID;
14731 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14732 its low and high PC addresses. Do nothing if these addresses could not
14733 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14734 and HIGHPC to the high address if greater than HIGHPC. */
14737 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
14738 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14739 struct dwarf2_cu *cu)
14741 CORE_ADDR low, high;
14742 struct die_info *child = die->child;
14744 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL) >= PC_BOUNDS_RANGES)
14746 *lowpc = std::min (*lowpc, low);
14747 *highpc = std::max (*highpc, high);
14750 /* If the language does not allow nested subprograms (either inside
14751 subprograms or lexical blocks), we're done. */
14752 if (cu->language != language_ada)
14755 /* Check all the children of the given DIE. If it contains nested
14756 subprograms, then check their pc bounds. Likewise, we need to
14757 check lexical blocks as well, as they may also contain subprogram
14759 while (child && child->tag)
14761 if (child->tag == DW_TAG_subprogram
14762 || child->tag == DW_TAG_lexical_block)
14763 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
14764 child = sibling_die (child);
14768 /* Get the low and high pc's represented by the scope DIE, and store
14769 them in *LOWPC and *HIGHPC. If the correct values can't be
14770 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14773 get_scope_pc_bounds (struct die_info *die,
14774 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14775 struct dwarf2_cu *cu)
14777 CORE_ADDR best_low = (CORE_ADDR) -1;
14778 CORE_ADDR best_high = (CORE_ADDR) 0;
14779 CORE_ADDR current_low, current_high;
14781 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL)
14782 >= PC_BOUNDS_RANGES)
14784 best_low = current_low;
14785 best_high = current_high;
14789 struct die_info *child = die->child;
14791 while (child && child->tag)
14793 switch (child->tag) {
14794 case DW_TAG_subprogram:
14795 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
14797 case DW_TAG_namespace:
14798 case DW_TAG_module:
14799 /* FIXME: carlton/2004-01-16: Should we do this for
14800 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14801 that current GCC's always emit the DIEs corresponding
14802 to definitions of methods of classes as children of a
14803 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14804 the DIEs giving the declarations, which could be
14805 anywhere). But I don't see any reason why the
14806 standards says that they have to be there. */
14807 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
14809 if (current_low != ((CORE_ADDR) -1))
14811 best_low = std::min (best_low, current_low);
14812 best_high = std::max (best_high, current_high);
14820 child = sibling_die (child);
14825 *highpc = best_high;
14828 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14832 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
14833 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
14835 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14836 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14837 struct attribute *attr;
14838 struct attribute *attr_high;
14840 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14843 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14846 CORE_ADDR low = attr_value_as_address (attr);
14847 CORE_ADDR high = attr_value_as_address (attr_high);
14849 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14852 low = gdbarch_adjust_dwarf2_addr (gdbarch, low + baseaddr);
14853 high = gdbarch_adjust_dwarf2_addr (gdbarch, high + baseaddr);
14854 cu->builder->record_block_range (block, low, high - 1);
14858 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14861 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14862 We take advantage of the fact that DW_AT_ranges does not appear
14863 in DW_TAG_compile_unit of DWO files. */
14864 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14866 /* The value of the DW_AT_ranges attribute is the offset of the
14867 address range list in the .debug_ranges section. */
14868 unsigned long offset = (DW_UNSND (attr)
14869 + (need_ranges_base ? cu->ranges_base : 0));
14871 std::vector<blockrange> blockvec;
14872 dwarf2_ranges_process (offset, cu,
14873 [&] (CORE_ADDR start, CORE_ADDR end)
14877 start = gdbarch_adjust_dwarf2_addr (gdbarch, start);
14878 end = gdbarch_adjust_dwarf2_addr (gdbarch, end);
14879 cu->builder->record_block_range (block, start, end - 1);
14880 blockvec.emplace_back (start, end);
14883 BLOCK_RANGES(block) = make_blockranges (objfile, blockvec);
14887 /* Check whether the producer field indicates either of GCC < 4.6, or the
14888 Intel C/C++ compiler, and cache the result in CU. */
14891 check_producer (struct dwarf2_cu *cu)
14895 if (cu->producer == NULL)
14897 /* For unknown compilers expect their behavior is DWARF version
14900 GCC started to support .debug_types sections by -gdwarf-4 since
14901 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14902 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14903 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14904 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14906 else if (producer_is_gcc (cu->producer, &major, &minor))
14908 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
14909 cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
14911 else if (producer_is_icc (cu->producer, &major, &minor))
14913 cu->producer_is_icc = true;
14914 cu->producer_is_icc_lt_14 = major < 14;
14916 else if (startswith (cu->producer, "CodeWarrior S12/L-ISA"))
14917 cu->producer_is_codewarrior = true;
14920 /* For other non-GCC compilers, expect their behavior is DWARF version
14924 cu->checked_producer = true;
14927 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14928 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14929 during 4.6.0 experimental. */
14932 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
14934 if (!cu->checked_producer)
14935 check_producer (cu);
14937 return cu->producer_is_gxx_lt_4_6;
14941 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14942 with incorrect is_stmt attributes. */
14945 producer_is_codewarrior (struct dwarf2_cu *cu)
14947 if (!cu->checked_producer)
14948 check_producer (cu);
14950 return cu->producer_is_codewarrior;
14953 /* Return the default accessibility type if it is not overriden by
14954 DW_AT_accessibility. */
14956 static enum dwarf_access_attribute
14957 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
14959 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
14961 /* The default DWARF 2 accessibility for members is public, the default
14962 accessibility for inheritance is private. */
14964 if (die->tag != DW_TAG_inheritance)
14965 return DW_ACCESS_public;
14967 return DW_ACCESS_private;
14971 /* DWARF 3+ defines the default accessibility a different way. The same
14972 rules apply now for DW_TAG_inheritance as for the members and it only
14973 depends on the container kind. */
14975 if (die->parent->tag == DW_TAG_class_type)
14976 return DW_ACCESS_private;
14978 return DW_ACCESS_public;
14982 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14983 offset. If the attribute was not found return 0, otherwise return
14984 1. If it was found but could not properly be handled, set *OFFSET
14988 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
14991 struct attribute *attr;
14993 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
14998 /* Note that we do not check for a section offset first here.
14999 This is because DW_AT_data_member_location is new in DWARF 4,
15000 so if we see it, we can assume that a constant form is really
15001 a constant and not a section offset. */
15002 if (attr_form_is_constant (attr))
15003 *offset = dwarf2_get_attr_constant_value (attr, 0);
15004 else if (attr_form_is_section_offset (attr))
15005 dwarf2_complex_location_expr_complaint ();
15006 else if (attr_form_is_block (attr))
15007 *offset = decode_locdesc (DW_BLOCK (attr), cu);
15009 dwarf2_complex_location_expr_complaint ();
15017 /* Add an aggregate field to the field list. */
15020 dwarf2_add_field (struct field_info *fip, struct die_info *die,
15021 struct dwarf2_cu *cu)
15023 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15024 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15025 struct nextfield *new_field;
15026 struct attribute *attr;
15028 const char *fieldname = "";
15030 if (die->tag == DW_TAG_inheritance)
15032 fip->baseclasses.emplace_back ();
15033 new_field = &fip->baseclasses.back ();
15037 fip->fields.emplace_back ();
15038 new_field = &fip->fields.back ();
15043 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15045 new_field->accessibility = DW_UNSND (attr);
15047 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
15048 if (new_field->accessibility != DW_ACCESS_public)
15049 fip->non_public_fields = 1;
15051 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15053 new_field->virtuality = DW_UNSND (attr);
15055 new_field->virtuality = DW_VIRTUALITY_none;
15057 fp = &new_field->field;
15059 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
15063 /* Data member other than a C++ static data member. */
15065 /* Get type of field. */
15066 fp->type = die_type (die, cu);
15068 SET_FIELD_BITPOS (*fp, 0);
15070 /* Get bit size of field (zero if none). */
15071 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
15074 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
15078 FIELD_BITSIZE (*fp) = 0;
15081 /* Get bit offset of field. */
15082 if (handle_data_member_location (die, cu, &offset))
15083 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15084 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
15087 if (gdbarch_bits_big_endian (gdbarch))
15089 /* For big endian bits, the DW_AT_bit_offset gives the
15090 additional bit offset from the MSB of the containing
15091 anonymous object to the MSB of the field. We don't
15092 have to do anything special since we don't need to
15093 know the size of the anonymous object. */
15094 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
15098 /* For little endian bits, compute the bit offset to the
15099 MSB of the anonymous object, subtract off the number of
15100 bits from the MSB of the field to the MSB of the
15101 object, and then subtract off the number of bits of
15102 the field itself. The result is the bit offset of
15103 the LSB of the field. */
15104 int anonymous_size;
15105 int bit_offset = DW_UNSND (attr);
15107 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15110 /* The size of the anonymous object containing
15111 the bit field is explicit, so use the
15112 indicated size (in bytes). */
15113 anonymous_size = DW_UNSND (attr);
15117 /* The size of the anonymous object containing
15118 the bit field must be inferred from the type
15119 attribute of the data member containing the
15121 anonymous_size = TYPE_LENGTH (fp->type);
15123 SET_FIELD_BITPOS (*fp,
15124 (FIELD_BITPOS (*fp)
15125 + anonymous_size * bits_per_byte
15126 - bit_offset - FIELD_BITSIZE (*fp)));
15129 attr = dwarf2_attr (die, DW_AT_data_bit_offset, cu);
15131 SET_FIELD_BITPOS (*fp, (FIELD_BITPOS (*fp)
15132 + dwarf2_get_attr_constant_value (attr, 0)));
15134 /* Get name of field. */
15135 fieldname = dwarf2_name (die, cu);
15136 if (fieldname == NULL)
15139 /* The name is already allocated along with this objfile, so we don't
15140 need to duplicate it for the type. */
15141 fp->name = fieldname;
15143 /* Change accessibility for artificial fields (e.g. virtual table
15144 pointer or virtual base class pointer) to private. */
15145 if (dwarf2_attr (die, DW_AT_artificial, cu))
15147 FIELD_ARTIFICIAL (*fp) = 1;
15148 new_field->accessibility = DW_ACCESS_private;
15149 fip->non_public_fields = 1;
15152 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
15154 /* C++ static member. */
15156 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15157 is a declaration, but all versions of G++ as of this writing
15158 (so through at least 3.2.1) incorrectly generate
15159 DW_TAG_variable tags. */
15161 const char *physname;
15163 /* Get name of field. */
15164 fieldname = dwarf2_name (die, cu);
15165 if (fieldname == NULL)
15168 attr = dwarf2_attr (die, DW_AT_const_value, cu);
15170 /* Only create a symbol if this is an external value.
15171 new_symbol checks this and puts the value in the global symbol
15172 table, which we want. If it is not external, new_symbol
15173 will try to put the value in cu->list_in_scope which is wrong. */
15174 && dwarf2_flag_true_p (die, DW_AT_external, cu))
15176 /* A static const member, not much different than an enum as far as
15177 we're concerned, except that we can support more types. */
15178 new_symbol (die, NULL, cu);
15181 /* Get physical name. */
15182 physname = dwarf2_physname (fieldname, die, cu);
15184 /* The name is already allocated along with this objfile, so we don't
15185 need to duplicate it for the type. */
15186 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
15187 FIELD_TYPE (*fp) = die_type (die, cu);
15188 FIELD_NAME (*fp) = fieldname;
15190 else if (die->tag == DW_TAG_inheritance)
15194 /* C++ base class field. */
15195 if (handle_data_member_location (die, cu, &offset))
15196 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15197 FIELD_BITSIZE (*fp) = 0;
15198 FIELD_TYPE (*fp) = die_type (die, cu);
15199 FIELD_NAME (*fp) = TYPE_NAME (fp->type);
15201 else if (die->tag == DW_TAG_variant_part)
15203 /* process_structure_scope will treat this DIE as a union. */
15204 process_structure_scope (die, cu);
15206 /* The variant part is relative to the start of the enclosing
15208 SET_FIELD_BITPOS (*fp, 0);
15209 fp->type = get_die_type (die, cu);
15210 fp->artificial = 1;
15211 fp->name = "<<variant>>";
15213 /* Normally a DW_TAG_variant_part won't have a size, but our
15214 representation requires one, so set it to the maximum of the
15216 if (TYPE_LENGTH (fp->type) == 0)
15219 for (int i = 0; i < TYPE_NFIELDS (fp->type); ++i)
15220 if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i)) > max)
15221 max = TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i));
15222 TYPE_LENGTH (fp->type) = max;
15226 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15229 /* Can the type given by DIE define another type? */
15232 type_can_define_types (const struct die_info *die)
15236 case DW_TAG_typedef:
15237 case DW_TAG_class_type:
15238 case DW_TAG_structure_type:
15239 case DW_TAG_union_type:
15240 case DW_TAG_enumeration_type:
15248 /* Add a type definition defined in the scope of the FIP's class. */
15251 dwarf2_add_type_defn (struct field_info *fip, struct die_info *die,
15252 struct dwarf2_cu *cu)
15254 struct decl_field fp;
15255 memset (&fp, 0, sizeof (fp));
15257 gdb_assert (type_can_define_types (die));
15259 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15260 fp.name = dwarf2_name (die, cu);
15261 fp.type = read_type_die (die, cu);
15263 /* Save accessibility. */
15264 enum dwarf_access_attribute accessibility;
15265 struct attribute *attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15267 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15269 accessibility = dwarf2_default_access_attribute (die, cu);
15270 switch (accessibility)
15272 case DW_ACCESS_public:
15273 /* The assumed value if neither private nor protected. */
15275 case DW_ACCESS_private:
15278 case DW_ACCESS_protected:
15279 fp.is_protected = 1;
15282 complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility);
15285 if (die->tag == DW_TAG_typedef)
15286 fip->typedef_field_list.push_back (fp);
15288 fip->nested_types_list.push_back (fp);
15291 /* Create the vector of fields, and attach it to the type. */
15294 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
15295 struct dwarf2_cu *cu)
15297 int nfields = fip->nfields;
15299 /* Record the field count, allocate space for the array of fields,
15300 and create blank accessibility bitfields if necessary. */
15301 TYPE_NFIELDS (type) = nfields;
15302 TYPE_FIELDS (type) = (struct field *)
15303 TYPE_ZALLOC (type, sizeof (struct field) * nfields);
15305 if (fip->non_public_fields && cu->language != language_ada)
15307 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15309 TYPE_FIELD_PRIVATE_BITS (type) =
15310 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15311 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
15313 TYPE_FIELD_PROTECTED_BITS (type) =
15314 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15315 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
15317 TYPE_FIELD_IGNORE_BITS (type) =
15318 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15319 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
15322 /* If the type has baseclasses, allocate and clear a bit vector for
15323 TYPE_FIELD_VIRTUAL_BITS. */
15324 if (!fip->baseclasses.empty () && cu->language != language_ada)
15326 int num_bytes = B_BYTES (fip->baseclasses.size ());
15327 unsigned char *pointer;
15329 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15330 pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes);
15331 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
15332 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->baseclasses.size ());
15333 TYPE_N_BASECLASSES (type) = fip->baseclasses.size ();
15336 if (TYPE_FLAG_DISCRIMINATED_UNION (type))
15338 struct discriminant_info *di = alloc_discriminant_info (type, -1, -1);
15340 for (int index = 0; index < nfields; ++index)
15342 struct nextfield &field = fip->fields[index];
15344 if (field.variant.is_discriminant)
15345 di->discriminant_index = index;
15346 else if (field.variant.default_branch)
15347 di->default_index = index;
15349 di->discriminants[index] = field.variant.discriminant_value;
15353 /* Copy the saved-up fields into the field vector. */
15354 for (int i = 0; i < nfields; ++i)
15356 struct nextfield &field
15357 = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i]
15358 : fip->fields[i - fip->baseclasses.size ()]);
15360 TYPE_FIELD (type, i) = field.field;
15361 switch (field.accessibility)
15363 case DW_ACCESS_private:
15364 if (cu->language != language_ada)
15365 SET_TYPE_FIELD_PRIVATE (type, i);
15368 case DW_ACCESS_protected:
15369 if (cu->language != language_ada)
15370 SET_TYPE_FIELD_PROTECTED (type, i);
15373 case DW_ACCESS_public:
15377 /* Unknown accessibility. Complain and treat it as public. */
15379 complaint (_("unsupported accessibility %d"),
15380 field.accessibility);
15384 if (i < fip->baseclasses.size ())
15386 switch (field.virtuality)
15388 case DW_VIRTUALITY_virtual:
15389 case DW_VIRTUALITY_pure_virtual:
15390 if (cu->language == language_ada)
15391 error (_("unexpected virtuality in component of Ada type"));
15392 SET_TYPE_FIELD_VIRTUAL (type, i);
15399 /* Return true if this member function is a constructor, false
15403 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
15405 const char *fieldname;
15406 const char *type_name;
15409 if (die->parent == NULL)
15412 if (die->parent->tag != DW_TAG_structure_type
15413 && die->parent->tag != DW_TAG_union_type
15414 && die->parent->tag != DW_TAG_class_type)
15417 fieldname = dwarf2_name (die, cu);
15418 type_name = dwarf2_name (die->parent, cu);
15419 if (fieldname == NULL || type_name == NULL)
15422 len = strlen (fieldname);
15423 return (strncmp (fieldname, type_name, len) == 0
15424 && (type_name[len] == '\0' || type_name[len] == '<'));
15427 /* Add a member function to the proper fieldlist. */
15430 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
15431 struct type *type, struct dwarf2_cu *cu)
15433 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15434 struct attribute *attr;
15436 struct fnfieldlist *flp = nullptr;
15437 struct fn_field *fnp;
15438 const char *fieldname;
15439 struct type *this_type;
15440 enum dwarf_access_attribute accessibility;
15442 if (cu->language == language_ada)
15443 error (_("unexpected member function in Ada type"));
15445 /* Get name of member function. */
15446 fieldname = dwarf2_name (die, cu);
15447 if (fieldname == NULL)
15450 /* Look up member function name in fieldlist. */
15451 for (i = 0; i < fip->fnfieldlists.size (); i++)
15453 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
15455 flp = &fip->fnfieldlists[i];
15460 /* Create a new fnfieldlist if necessary. */
15461 if (flp == nullptr)
15463 fip->fnfieldlists.emplace_back ();
15464 flp = &fip->fnfieldlists.back ();
15465 flp->name = fieldname;
15466 i = fip->fnfieldlists.size () - 1;
15469 /* Create a new member function field and add it to the vector of
15471 flp->fnfields.emplace_back ();
15472 fnp = &flp->fnfields.back ();
15474 /* Delay processing of the physname until later. */
15475 if (cu->language == language_cplus)
15476 add_to_method_list (type, i, flp->fnfields.size () - 1, fieldname,
15480 const char *physname = dwarf2_physname (fieldname, die, cu);
15481 fnp->physname = physname ? physname : "";
15484 fnp->type = alloc_type (objfile);
15485 this_type = read_type_die (die, cu);
15486 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
15488 int nparams = TYPE_NFIELDS (this_type);
15490 /* TYPE is the domain of this method, and THIS_TYPE is the type
15491 of the method itself (TYPE_CODE_METHOD). */
15492 smash_to_method_type (fnp->type, type,
15493 TYPE_TARGET_TYPE (this_type),
15494 TYPE_FIELDS (this_type),
15495 TYPE_NFIELDS (this_type),
15496 TYPE_VARARGS (this_type));
15498 /* Handle static member functions.
15499 Dwarf2 has no clean way to discern C++ static and non-static
15500 member functions. G++ helps GDB by marking the first
15501 parameter for non-static member functions (which is the this
15502 pointer) as artificial. We obtain this information from
15503 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15504 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
15505 fnp->voffset = VOFFSET_STATIC;
15508 complaint (_("member function type missing for '%s'"),
15509 dwarf2_full_name (fieldname, die, cu));
15511 /* Get fcontext from DW_AT_containing_type if present. */
15512 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
15513 fnp->fcontext = die_containing_type (die, cu);
15515 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15516 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15518 /* Get accessibility. */
15519 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15521 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15523 accessibility = dwarf2_default_access_attribute (die, cu);
15524 switch (accessibility)
15526 case DW_ACCESS_private:
15527 fnp->is_private = 1;
15529 case DW_ACCESS_protected:
15530 fnp->is_protected = 1;
15534 /* Check for artificial methods. */
15535 attr = dwarf2_attr (die, DW_AT_artificial, cu);
15536 if (attr && DW_UNSND (attr) != 0)
15537 fnp->is_artificial = 1;
15539 fnp->is_constructor = dwarf2_is_constructor (die, cu);
15541 /* Get index in virtual function table if it is a virtual member
15542 function. For older versions of GCC, this is an offset in the
15543 appropriate virtual table, as specified by DW_AT_containing_type.
15544 For everyone else, it is an expression to be evaluated relative
15545 to the object address. */
15547 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
15550 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
15552 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
15554 /* Old-style GCC. */
15555 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
15557 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
15558 || (DW_BLOCK (attr)->size > 1
15559 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
15560 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
15562 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
15563 if ((fnp->voffset % cu->header.addr_size) != 0)
15564 dwarf2_complex_location_expr_complaint ();
15566 fnp->voffset /= cu->header.addr_size;
15570 dwarf2_complex_location_expr_complaint ();
15572 if (!fnp->fcontext)
15574 /* If there is no `this' field and no DW_AT_containing_type,
15575 we cannot actually find a base class context for the
15577 if (TYPE_NFIELDS (this_type) == 0
15578 || !TYPE_FIELD_ARTIFICIAL (this_type, 0))
15580 complaint (_("cannot determine context for virtual member "
15581 "function \"%s\" (offset %s)"),
15582 fieldname, sect_offset_str (die->sect_off));
15587 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
15591 else if (attr_form_is_section_offset (attr))
15593 dwarf2_complex_location_expr_complaint ();
15597 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15603 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15604 if (attr && DW_UNSND (attr))
15606 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15607 complaint (_("Member function \"%s\" (offset %s) is virtual "
15608 "but the vtable offset is not specified"),
15609 fieldname, sect_offset_str (die->sect_off));
15610 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15611 TYPE_CPLUS_DYNAMIC (type) = 1;
15616 /* Create the vector of member function fields, and attach it to the type. */
15619 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
15620 struct dwarf2_cu *cu)
15622 if (cu->language == language_ada)
15623 error (_("unexpected member functions in Ada type"));
15625 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15626 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
15628 sizeof (struct fn_fieldlist) * fip->fnfieldlists.size ());
15630 for (int i = 0; i < fip->fnfieldlists.size (); i++)
15632 struct fnfieldlist &nf = fip->fnfieldlists[i];
15633 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
15635 TYPE_FN_FIELDLIST_NAME (type, i) = nf.name;
15636 TYPE_FN_FIELDLIST_LENGTH (type, i) = nf.fnfields.size ();
15637 fn_flp->fn_fields = (struct fn_field *)
15638 TYPE_ALLOC (type, sizeof (struct fn_field) * nf.fnfields.size ());
15640 for (int k = 0; k < nf.fnfields.size (); ++k)
15641 fn_flp->fn_fields[k] = nf.fnfields[k];
15644 TYPE_NFN_FIELDS (type) = fip->fnfieldlists.size ();
15647 /* Returns non-zero if NAME is the name of a vtable member in CU's
15648 language, zero otherwise. */
15650 is_vtable_name (const char *name, struct dwarf2_cu *cu)
15652 static const char vptr[] = "_vptr";
15654 /* Look for the C++ form of the vtable. */
15655 if (startswith (name, vptr) && is_cplus_marker (name[sizeof (vptr) - 1]))
15661 /* GCC outputs unnamed structures that are really pointers to member
15662 functions, with the ABI-specified layout. If TYPE describes
15663 such a structure, smash it into a member function type.
15665 GCC shouldn't do this; it should just output pointer to member DIEs.
15666 This is GCC PR debug/28767. */
15669 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
15671 struct type *pfn_type, *self_type, *new_type;
15673 /* Check for a structure with no name and two children. */
15674 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
15677 /* Check for __pfn and __delta members. */
15678 if (TYPE_FIELD_NAME (type, 0) == NULL
15679 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
15680 || TYPE_FIELD_NAME (type, 1) == NULL
15681 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
15684 /* Find the type of the method. */
15685 pfn_type = TYPE_FIELD_TYPE (type, 0);
15686 if (pfn_type == NULL
15687 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
15688 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
15691 /* Look for the "this" argument. */
15692 pfn_type = TYPE_TARGET_TYPE (pfn_type);
15693 if (TYPE_NFIELDS (pfn_type) == 0
15694 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15695 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
15698 self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
15699 new_type = alloc_type (objfile);
15700 smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
15701 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
15702 TYPE_VARARGS (pfn_type));
15703 smash_to_methodptr_type (type, new_type);
15706 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15707 appropriate error checking and issuing complaints if there is a
15711 get_alignment (struct dwarf2_cu *cu, struct die_info *die)
15713 struct attribute *attr = dwarf2_attr (die, DW_AT_alignment, cu);
15715 if (attr == nullptr)
15718 if (!attr_form_is_constant (attr))
15720 complaint (_("DW_AT_alignment must have constant form"
15721 " - DIE at %s [in module %s]"),
15722 sect_offset_str (die->sect_off),
15723 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15728 if (attr->form == DW_FORM_sdata)
15730 LONGEST val = DW_SND (attr);
15733 complaint (_("DW_AT_alignment value must not be negative"
15734 " - DIE at %s [in module %s]"),
15735 sect_offset_str (die->sect_off),
15736 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15742 align = DW_UNSND (attr);
15746 complaint (_("DW_AT_alignment value must not be zero"
15747 " - DIE at %s [in module %s]"),
15748 sect_offset_str (die->sect_off),
15749 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15752 if ((align & (align - 1)) != 0)
15754 complaint (_("DW_AT_alignment value must be a power of 2"
15755 " - DIE at %s [in module %s]"),
15756 sect_offset_str (die->sect_off),
15757 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15764 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15765 the alignment for TYPE. */
15768 maybe_set_alignment (struct dwarf2_cu *cu, struct die_info *die,
15771 if (!set_type_align (type, get_alignment (cu, die)))
15772 complaint (_("DW_AT_alignment value too large"
15773 " - DIE at %s [in module %s]"),
15774 sect_offset_str (die->sect_off),
15775 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15778 /* Called when we find the DIE that starts a structure or union scope
15779 (definition) to create a type for the structure or union. Fill in
15780 the type's name and general properties; the members will not be
15781 processed until process_structure_scope. A symbol table entry for
15782 the type will also not be done until process_structure_scope (assuming
15783 the type has a name).
15785 NOTE: we need to call these functions regardless of whether or not the
15786 DIE has a DW_AT_name attribute, since it might be an anonymous
15787 structure or union. This gets the type entered into our set of
15788 user defined types. */
15790 static struct type *
15791 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
15793 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15795 struct attribute *attr;
15798 /* If the definition of this type lives in .debug_types, read that type.
15799 Don't follow DW_AT_specification though, that will take us back up
15800 the chain and we want to go down. */
15801 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
15804 type = get_DW_AT_signature_type (die, attr, cu);
15806 /* The type's CU may not be the same as CU.
15807 Ensure TYPE is recorded with CU in die_type_hash. */
15808 return set_die_type (die, type, cu);
15811 type = alloc_type (objfile);
15812 INIT_CPLUS_SPECIFIC (type);
15814 name = dwarf2_name (die, cu);
15817 if (cu->language == language_cplus
15818 || cu->language == language_d
15819 || cu->language == language_rust)
15821 const char *full_name = dwarf2_full_name (name, die, cu);
15823 /* dwarf2_full_name might have already finished building the DIE's
15824 type. If so, there is no need to continue. */
15825 if (get_die_type (die, cu) != NULL)
15826 return get_die_type (die, cu);
15828 TYPE_NAME (type) = full_name;
15832 /* The name is already allocated along with this objfile, so
15833 we don't need to duplicate it for the type. */
15834 TYPE_NAME (type) = name;
15838 if (die->tag == DW_TAG_structure_type)
15840 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15842 else if (die->tag == DW_TAG_union_type)
15844 TYPE_CODE (type) = TYPE_CODE_UNION;
15846 else if (die->tag == DW_TAG_variant_part)
15848 TYPE_CODE (type) = TYPE_CODE_UNION;
15849 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
15853 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15856 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
15857 TYPE_DECLARED_CLASS (type) = 1;
15859 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15862 if (attr_form_is_constant (attr))
15863 TYPE_LENGTH (type) = DW_UNSND (attr);
15866 /* For the moment, dynamic type sizes are not supported
15867 by GDB's struct type. The actual size is determined
15868 on-demand when resolving the type of a given object,
15869 so set the type's length to zero for now. Otherwise,
15870 we record an expression as the length, and that expression
15871 could lead to a very large value, which could eventually
15872 lead to us trying to allocate that much memory when creating
15873 a value of that type. */
15874 TYPE_LENGTH (type) = 0;
15879 TYPE_LENGTH (type) = 0;
15882 maybe_set_alignment (cu, die, type);
15884 if (producer_is_icc_lt_14 (cu) && (TYPE_LENGTH (type) == 0))
15886 /* ICC<14 does not output the required DW_AT_declaration on
15887 incomplete types, but gives them a size of zero. */
15888 TYPE_STUB (type) = 1;
15891 TYPE_STUB_SUPPORTED (type) = 1;
15893 if (die_is_declaration (die, cu))
15894 TYPE_STUB (type) = 1;
15895 else if (attr == NULL && die->child == NULL
15896 && producer_is_realview (cu->producer))
15897 /* RealView does not output the required DW_AT_declaration
15898 on incomplete types. */
15899 TYPE_STUB (type) = 1;
15901 /* We need to add the type field to the die immediately so we don't
15902 infinitely recurse when dealing with pointers to the structure
15903 type within the structure itself. */
15904 set_die_type (die, type, cu);
15906 /* set_die_type should be already done. */
15907 set_descriptive_type (type, die, cu);
15912 /* A helper for process_structure_scope that handles a single member
15916 handle_struct_member_die (struct die_info *child_die, struct type *type,
15917 struct field_info *fi,
15918 std::vector<struct symbol *> *template_args,
15919 struct dwarf2_cu *cu)
15921 if (child_die->tag == DW_TAG_member
15922 || child_die->tag == DW_TAG_variable
15923 || child_die->tag == DW_TAG_variant_part)
15925 /* NOTE: carlton/2002-11-05: A C++ static data member
15926 should be a DW_TAG_member that is a declaration, but
15927 all versions of G++ as of this writing (so through at
15928 least 3.2.1) incorrectly generate DW_TAG_variable
15929 tags for them instead. */
15930 dwarf2_add_field (fi, child_die, cu);
15932 else if (child_die->tag == DW_TAG_subprogram)
15934 /* Rust doesn't have member functions in the C++ sense.
15935 However, it does emit ordinary functions as children
15936 of a struct DIE. */
15937 if (cu->language == language_rust)
15938 read_func_scope (child_die, cu);
15941 /* C++ member function. */
15942 dwarf2_add_member_fn (fi, child_die, type, cu);
15945 else if (child_die->tag == DW_TAG_inheritance)
15947 /* C++ base class field. */
15948 dwarf2_add_field (fi, child_die, cu);
15950 else if (type_can_define_types (child_die))
15951 dwarf2_add_type_defn (fi, child_die, cu);
15952 else if (child_die->tag == DW_TAG_template_type_param
15953 || child_die->tag == DW_TAG_template_value_param)
15955 struct symbol *arg = new_symbol (child_die, NULL, cu);
15958 template_args->push_back (arg);
15960 else if (child_die->tag == DW_TAG_variant)
15962 /* In a variant we want to get the discriminant and also add a
15963 field for our sole member child. */
15964 struct attribute *discr = dwarf2_attr (child_die, DW_AT_discr_value, cu);
15966 for (struct die_info *variant_child = child_die->child;
15967 variant_child != NULL;
15968 variant_child = sibling_die (variant_child))
15970 if (variant_child->tag == DW_TAG_member)
15972 handle_struct_member_die (variant_child, type, fi,
15973 template_args, cu);
15974 /* Only handle the one. */
15979 /* We don't handle this but we might as well report it if we see
15981 if (dwarf2_attr (child_die, DW_AT_discr_list, cu) != nullptr)
15982 complaint (_("DW_AT_discr_list is not supported yet"
15983 " - DIE at %s [in module %s]"),
15984 sect_offset_str (child_die->sect_off),
15985 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15987 /* The first field was just added, so we can stash the
15988 discriminant there. */
15989 gdb_assert (!fi->fields.empty ());
15991 fi->fields.back ().variant.default_branch = true;
15993 fi->fields.back ().variant.discriminant_value = DW_UNSND (discr);
15997 /* Finish creating a structure or union type, including filling in
15998 its members and creating a symbol for it. */
16001 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
16003 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16004 struct die_info *child_die;
16007 type = get_die_type (die, cu);
16009 type = read_structure_type (die, cu);
16011 /* When reading a DW_TAG_variant_part, we need to notice when we
16012 read the discriminant member, so we can record it later in the
16013 discriminant_info. */
16014 bool is_variant_part = TYPE_FLAG_DISCRIMINATED_UNION (type);
16015 sect_offset discr_offset;
16016 bool has_template_parameters = false;
16018 if (is_variant_part)
16020 struct attribute *discr = dwarf2_attr (die, DW_AT_discr, cu);
16023 /* Maybe it's a univariant form, an extension we support.
16024 In this case arrange not to check the offset. */
16025 is_variant_part = false;
16027 else if (attr_form_is_ref (discr))
16029 struct dwarf2_cu *target_cu = cu;
16030 struct die_info *target_die = follow_die_ref (die, discr, &target_cu);
16032 discr_offset = target_die->sect_off;
16036 complaint (_("DW_AT_discr does not have DIE reference form"
16037 " - DIE at %s [in module %s]"),
16038 sect_offset_str (die->sect_off),
16039 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16040 is_variant_part = false;
16044 if (die->child != NULL && ! die_is_declaration (die, cu))
16046 struct field_info fi;
16047 std::vector<struct symbol *> template_args;
16049 child_die = die->child;
16051 while (child_die && child_die->tag)
16053 handle_struct_member_die (child_die, type, &fi, &template_args, cu);
16055 if (is_variant_part && discr_offset == child_die->sect_off)
16056 fi.fields.back ().variant.is_discriminant = true;
16058 child_die = sibling_die (child_die);
16061 /* Attach template arguments to type. */
16062 if (!template_args.empty ())
16064 has_template_parameters = true;
16065 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16066 TYPE_N_TEMPLATE_ARGUMENTS (type) = template_args.size ();
16067 TYPE_TEMPLATE_ARGUMENTS (type)
16068 = XOBNEWVEC (&objfile->objfile_obstack,
16070 TYPE_N_TEMPLATE_ARGUMENTS (type));
16071 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
16072 template_args.data (),
16073 (TYPE_N_TEMPLATE_ARGUMENTS (type)
16074 * sizeof (struct symbol *)));
16077 /* Attach fields and member functions to the type. */
16079 dwarf2_attach_fields_to_type (&fi, type, cu);
16080 if (!fi.fnfieldlists.empty ())
16082 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
16084 /* Get the type which refers to the base class (possibly this
16085 class itself) which contains the vtable pointer for the current
16086 class from the DW_AT_containing_type attribute. This use of
16087 DW_AT_containing_type is a GNU extension. */
16089 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
16091 struct type *t = die_containing_type (die, cu);
16093 set_type_vptr_basetype (type, t);
16098 /* Our own class provides vtbl ptr. */
16099 for (i = TYPE_NFIELDS (t) - 1;
16100 i >= TYPE_N_BASECLASSES (t);
16103 const char *fieldname = TYPE_FIELD_NAME (t, i);
16105 if (is_vtable_name (fieldname, cu))
16107 set_type_vptr_fieldno (type, i);
16112 /* Complain if virtual function table field not found. */
16113 if (i < TYPE_N_BASECLASSES (t))
16114 complaint (_("virtual function table pointer "
16115 "not found when defining class '%s'"),
16116 TYPE_NAME (type) ? TYPE_NAME (type) : "");
16120 set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
16123 else if (cu->producer
16124 && startswith (cu->producer, "IBM(R) XL C/C++ Advanced Edition"))
16126 /* The IBM XLC compiler does not provide direct indication
16127 of the containing type, but the vtable pointer is
16128 always named __vfp. */
16132 for (i = TYPE_NFIELDS (type) - 1;
16133 i >= TYPE_N_BASECLASSES (type);
16136 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
16138 set_type_vptr_fieldno (type, i);
16139 set_type_vptr_basetype (type, type);
16146 /* Copy fi.typedef_field_list linked list elements content into the
16147 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16148 if (!fi.typedef_field_list.empty ())
16150 int count = fi.typedef_field_list.size ();
16152 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16153 TYPE_TYPEDEF_FIELD_ARRAY (type)
16154 = ((struct decl_field *)
16156 sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * count));
16157 TYPE_TYPEDEF_FIELD_COUNT (type) = count;
16159 for (int i = 0; i < fi.typedef_field_list.size (); ++i)
16160 TYPE_TYPEDEF_FIELD (type, i) = fi.typedef_field_list[i];
16163 /* Copy fi.nested_types_list linked list elements content into the
16164 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16165 if (!fi.nested_types_list.empty () && cu->language != language_ada)
16167 int count = fi.nested_types_list.size ();
16169 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16170 TYPE_NESTED_TYPES_ARRAY (type)
16171 = ((struct decl_field *)
16172 TYPE_ALLOC (type, sizeof (struct decl_field) * count));
16173 TYPE_NESTED_TYPES_COUNT (type) = count;
16175 for (int i = 0; i < fi.nested_types_list.size (); ++i)
16176 TYPE_NESTED_TYPES_FIELD (type, i) = fi.nested_types_list[i];
16180 quirk_gcc_member_function_pointer (type, objfile);
16181 if (cu->language == language_rust && die->tag == DW_TAG_union_type)
16182 cu->rust_unions.push_back (type);
16184 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16185 snapshots) has been known to create a die giving a declaration
16186 for a class that has, as a child, a die giving a definition for a
16187 nested class. So we have to process our children even if the
16188 current die is a declaration. Normally, of course, a declaration
16189 won't have any children at all. */
16191 child_die = die->child;
16193 while (child_die != NULL && child_die->tag)
16195 if (child_die->tag == DW_TAG_member
16196 || child_die->tag == DW_TAG_variable
16197 || child_die->tag == DW_TAG_inheritance
16198 || child_die->tag == DW_TAG_template_value_param
16199 || child_die->tag == DW_TAG_template_type_param)
16204 process_die (child_die, cu);
16206 child_die = sibling_die (child_die);
16209 /* Do not consider external references. According to the DWARF standard,
16210 these DIEs are identified by the fact that they have no byte_size
16211 attribute, and a declaration attribute. */
16212 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
16213 || !die_is_declaration (die, cu))
16215 struct symbol *sym = new_symbol (die, type, cu);
16217 if (has_template_parameters)
16219 /* Make sure that the symtab is set on the new symbols.
16220 Even though they don't appear in this symtab directly,
16221 other parts of gdb assume that symbols do, and this is
16222 reasonably true. */
16223 for (int i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
16224 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type, i),
16225 symbol_symtab (sym));
16230 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16231 update TYPE using some information only available in DIE's children. */
16234 update_enumeration_type_from_children (struct die_info *die,
16236 struct dwarf2_cu *cu)
16238 struct die_info *child_die;
16239 int unsigned_enum = 1;
16243 auto_obstack obstack;
16245 for (child_die = die->child;
16246 child_die != NULL && child_die->tag;
16247 child_die = sibling_die (child_die))
16249 struct attribute *attr;
16251 const gdb_byte *bytes;
16252 struct dwarf2_locexpr_baton *baton;
16255 if (child_die->tag != DW_TAG_enumerator)
16258 attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
16262 name = dwarf2_name (child_die, cu);
16264 name = "<anonymous enumerator>";
16266 dwarf2_const_value_attr (attr, type, name, &obstack, cu,
16267 &value, &bytes, &baton);
16273 else if ((mask & value) != 0)
16278 /* If we already know that the enum type is neither unsigned, nor
16279 a flag type, no need to look at the rest of the enumerates. */
16280 if (!unsigned_enum && !flag_enum)
16285 TYPE_UNSIGNED (type) = 1;
16287 TYPE_FLAG_ENUM (type) = 1;
16290 /* Given a DW_AT_enumeration_type die, set its type. We do not
16291 complete the type's fields yet, or create any symbols. */
16293 static struct type *
16294 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
16296 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16298 struct attribute *attr;
16301 /* If the definition of this type lives in .debug_types, read that type.
16302 Don't follow DW_AT_specification though, that will take us back up
16303 the chain and we want to go down. */
16304 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
16307 type = get_DW_AT_signature_type (die, attr, cu);
16309 /* The type's CU may not be the same as CU.
16310 Ensure TYPE is recorded with CU in die_type_hash. */
16311 return set_die_type (die, type, cu);
16314 type = alloc_type (objfile);
16316 TYPE_CODE (type) = TYPE_CODE_ENUM;
16317 name = dwarf2_full_name (NULL, die, cu);
16319 TYPE_NAME (type) = name;
16321 attr = dwarf2_attr (die, DW_AT_type, cu);
16324 struct type *underlying_type = die_type (die, cu);
16326 TYPE_TARGET_TYPE (type) = underlying_type;
16329 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16332 TYPE_LENGTH (type) = DW_UNSND (attr);
16336 TYPE_LENGTH (type) = 0;
16339 maybe_set_alignment (cu, die, type);
16341 /* The enumeration DIE can be incomplete. In Ada, any type can be
16342 declared as private in the package spec, and then defined only
16343 inside the package body. Such types are known as Taft Amendment
16344 Types. When another package uses such a type, an incomplete DIE
16345 may be generated by the compiler. */
16346 if (die_is_declaration (die, cu))
16347 TYPE_STUB (type) = 1;
16349 /* Finish the creation of this type by using the enum's children.
16350 We must call this even when the underlying type has been provided
16351 so that we can determine if we're looking at a "flag" enum. */
16352 update_enumeration_type_from_children (die, type, cu);
16354 /* If this type has an underlying type that is not a stub, then we
16355 may use its attributes. We always use the "unsigned" attribute
16356 in this situation, because ordinarily we guess whether the type
16357 is unsigned -- but the guess can be wrong and the underlying type
16358 can tell us the reality. However, we defer to a local size
16359 attribute if one exists, because this lets the compiler override
16360 the underlying type if needed. */
16361 if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
16363 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
16364 if (TYPE_LENGTH (type) == 0)
16365 TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
16366 if (TYPE_RAW_ALIGN (type) == 0
16367 && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)) != 0)
16368 set_type_align (type, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)));
16371 TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
16373 return set_die_type (die, type, cu);
16376 /* Given a pointer to a die which begins an enumeration, process all
16377 the dies that define the members of the enumeration, and create the
16378 symbol for the enumeration type.
16380 NOTE: We reverse the order of the element list. */
16383 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
16385 struct type *this_type;
16387 this_type = get_die_type (die, cu);
16388 if (this_type == NULL)
16389 this_type = read_enumeration_type (die, cu);
16391 if (die->child != NULL)
16393 struct die_info *child_die;
16394 struct symbol *sym;
16395 struct field *fields = NULL;
16396 int num_fields = 0;
16399 child_die = die->child;
16400 while (child_die && child_die->tag)
16402 if (child_die->tag != DW_TAG_enumerator)
16404 process_die (child_die, cu);
16408 name = dwarf2_name (child_die, cu);
16411 sym = new_symbol (child_die, this_type, cu);
16413 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
16415 fields = (struct field *)
16417 (num_fields + DW_FIELD_ALLOC_CHUNK)
16418 * sizeof (struct field));
16421 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
16422 FIELD_TYPE (fields[num_fields]) = NULL;
16423 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
16424 FIELD_BITSIZE (fields[num_fields]) = 0;
16430 child_die = sibling_die (child_die);
16435 TYPE_NFIELDS (this_type) = num_fields;
16436 TYPE_FIELDS (this_type) = (struct field *)
16437 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
16438 memcpy (TYPE_FIELDS (this_type), fields,
16439 sizeof (struct field) * num_fields);
16444 /* If we are reading an enum from a .debug_types unit, and the enum
16445 is a declaration, and the enum is not the signatured type in the
16446 unit, then we do not want to add a symbol for it. Adding a
16447 symbol would in some cases obscure the true definition of the
16448 enum, giving users an incomplete type when the definition is
16449 actually available. Note that we do not want to do this for all
16450 enums which are just declarations, because C++0x allows forward
16451 enum declarations. */
16452 if (cu->per_cu->is_debug_types
16453 && die_is_declaration (die, cu))
16455 struct signatured_type *sig_type;
16457 sig_type = (struct signatured_type *) cu->per_cu;
16458 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
16459 if (sig_type->type_offset_in_section != die->sect_off)
16463 new_symbol (die, this_type, cu);
16466 /* Extract all information from a DW_TAG_array_type DIE and put it in
16467 the DIE's type field. For now, this only handles one dimensional
16470 static struct type *
16471 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
16473 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16474 struct die_info *child_die;
16476 struct type *element_type, *range_type, *index_type;
16477 struct attribute *attr;
16479 struct dynamic_prop *byte_stride_prop = NULL;
16480 unsigned int bit_stride = 0;
16482 element_type = die_type (die, cu);
16484 /* The die_type call above may have already set the type for this DIE. */
16485 type = get_die_type (die, cu);
16489 attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
16495 = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
16496 stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop);
16499 complaint (_("unable to read array DW_AT_byte_stride "
16500 " - DIE at %s [in module %s]"),
16501 sect_offset_str (die->sect_off),
16502 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16503 /* Ignore this attribute. We will likely not be able to print
16504 arrays of this type correctly, but there is little we can do
16505 to help if we cannot read the attribute's value. */
16506 byte_stride_prop = NULL;
16510 attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
16512 bit_stride = DW_UNSND (attr);
16514 /* Irix 6.2 native cc creates array types without children for
16515 arrays with unspecified length. */
16516 if (die->child == NULL)
16518 index_type = objfile_type (objfile)->builtin_int;
16519 range_type = create_static_range_type (NULL, index_type, 0, -1);
16520 type = create_array_type_with_stride (NULL, element_type, range_type,
16521 byte_stride_prop, bit_stride);
16522 return set_die_type (die, type, cu);
16525 std::vector<struct type *> range_types;
16526 child_die = die->child;
16527 while (child_die && child_die->tag)
16529 if (child_die->tag == DW_TAG_subrange_type)
16531 struct type *child_type = read_type_die (child_die, cu);
16533 if (child_type != NULL)
16535 /* The range type was succesfully read. Save it for the
16536 array type creation. */
16537 range_types.push_back (child_type);
16540 child_die = sibling_die (child_die);
16543 /* Dwarf2 dimensions are output from left to right, create the
16544 necessary array types in backwards order. */
16546 type = element_type;
16548 if (read_array_order (die, cu) == DW_ORD_col_major)
16552 while (i < range_types.size ())
16553 type = create_array_type_with_stride (NULL, type, range_types[i++],
16554 byte_stride_prop, bit_stride);
16558 size_t ndim = range_types.size ();
16560 type = create_array_type_with_stride (NULL, type, range_types[ndim],
16561 byte_stride_prop, bit_stride);
16564 /* Understand Dwarf2 support for vector types (like they occur on
16565 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16566 array type. This is not part of the Dwarf2/3 standard yet, but a
16567 custom vendor extension. The main difference between a regular
16568 array and the vector variant is that vectors are passed by value
16570 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
16572 make_vector_type (type);
16574 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16575 implementation may choose to implement triple vectors using this
16577 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16580 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
16581 TYPE_LENGTH (type) = DW_UNSND (attr);
16583 complaint (_("DW_AT_byte_size for array type smaller "
16584 "than the total size of elements"));
16587 name = dwarf2_name (die, cu);
16589 TYPE_NAME (type) = name;
16591 maybe_set_alignment (cu, die, type);
16593 /* Install the type in the die. */
16594 set_die_type (die, type, cu);
16596 /* set_die_type should be already done. */
16597 set_descriptive_type (type, die, cu);
16602 static enum dwarf_array_dim_ordering
16603 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
16605 struct attribute *attr;
16607 attr = dwarf2_attr (die, DW_AT_ordering, cu);
16610 return (enum dwarf_array_dim_ordering) DW_SND (attr);
16612 /* GNU F77 is a special case, as at 08/2004 array type info is the
16613 opposite order to the dwarf2 specification, but data is still
16614 laid out as per normal fortran.
16616 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16617 version checking. */
16619 if (cu->language == language_fortran
16620 && cu->producer && strstr (cu->producer, "GNU F77"))
16622 return DW_ORD_row_major;
16625 switch (cu->language_defn->la_array_ordering)
16627 case array_column_major:
16628 return DW_ORD_col_major;
16629 case array_row_major:
16631 return DW_ORD_row_major;
16635 /* Extract all information from a DW_TAG_set_type DIE and put it in
16636 the DIE's type field. */
16638 static struct type *
16639 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
16641 struct type *domain_type, *set_type;
16642 struct attribute *attr;
16644 domain_type = die_type (die, cu);
16646 /* The die_type call above may have already set the type for this DIE. */
16647 set_type = get_die_type (die, cu);
16651 set_type = create_set_type (NULL, domain_type);
16653 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16655 TYPE_LENGTH (set_type) = DW_UNSND (attr);
16657 maybe_set_alignment (cu, die, set_type);
16659 return set_die_type (die, set_type, cu);
16662 /* A helper for read_common_block that creates a locexpr baton.
16663 SYM is the symbol which we are marking as computed.
16664 COMMON_DIE is the DIE for the common block.
16665 COMMON_LOC is the location expression attribute for the common
16667 MEMBER_LOC is the location expression attribute for the particular
16668 member of the common block that we are processing.
16669 CU is the CU from which the above come. */
16672 mark_common_block_symbol_computed (struct symbol *sym,
16673 struct die_info *common_die,
16674 struct attribute *common_loc,
16675 struct attribute *member_loc,
16676 struct dwarf2_cu *cu)
16678 struct dwarf2_per_objfile *dwarf2_per_objfile
16679 = cu->per_cu->dwarf2_per_objfile;
16680 struct objfile *objfile = dwarf2_per_objfile->objfile;
16681 struct dwarf2_locexpr_baton *baton;
16683 unsigned int cu_off;
16684 enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
16685 LONGEST offset = 0;
16687 gdb_assert (common_loc && member_loc);
16688 gdb_assert (attr_form_is_block (common_loc));
16689 gdb_assert (attr_form_is_block (member_loc)
16690 || attr_form_is_constant (member_loc));
16692 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
16693 baton->per_cu = cu->per_cu;
16694 gdb_assert (baton->per_cu);
16696 baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16698 if (attr_form_is_constant (member_loc))
16700 offset = dwarf2_get_attr_constant_value (member_loc, 0);
16701 baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
16704 baton->size += DW_BLOCK (member_loc)->size;
16706 ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
16709 *ptr++ = DW_OP_call4;
16710 cu_off = common_die->sect_off - cu->per_cu->sect_off;
16711 store_unsigned_integer (ptr, 4, byte_order, cu_off);
16714 if (attr_form_is_constant (member_loc))
16716 *ptr++ = DW_OP_addr;
16717 store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
16718 ptr += cu->header.addr_size;
16722 /* We have to copy the data here, because DW_OP_call4 will only
16723 use a DW_AT_location attribute. */
16724 memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
16725 ptr += DW_BLOCK (member_loc)->size;
16728 *ptr++ = DW_OP_plus;
16729 gdb_assert (ptr - baton->data == baton->size);
16731 SYMBOL_LOCATION_BATON (sym) = baton;
16732 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
16735 /* Create appropriate locally-scoped variables for all the
16736 DW_TAG_common_block entries. Also create a struct common_block
16737 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16738 is used to sepate the common blocks name namespace from regular
16742 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
16744 struct attribute *attr;
16746 attr = dwarf2_attr (die, DW_AT_location, cu);
16749 /* Support the .debug_loc offsets. */
16750 if (attr_form_is_block (attr))
16754 else if (attr_form_is_section_offset (attr))
16756 dwarf2_complex_location_expr_complaint ();
16761 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16762 "common block member");
16767 if (die->child != NULL)
16769 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16770 struct die_info *child_die;
16771 size_t n_entries = 0, size;
16772 struct common_block *common_block;
16773 struct symbol *sym;
16775 for (child_die = die->child;
16776 child_die && child_die->tag;
16777 child_die = sibling_die (child_die))
16780 size = (sizeof (struct common_block)
16781 + (n_entries - 1) * sizeof (struct symbol *));
16783 = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
16785 memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
16786 common_block->n_entries = 0;
16788 for (child_die = die->child;
16789 child_die && child_die->tag;
16790 child_die = sibling_die (child_die))
16792 /* Create the symbol in the DW_TAG_common_block block in the current
16794 sym = new_symbol (child_die, NULL, cu);
16797 struct attribute *member_loc;
16799 common_block->contents[common_block->n_entries++] = sym;
16801 member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
16805 /* GDB has handled this for a long time, but it is
16806 not specified by DWARF. It seems to have been
16807 emitted by gfortran at least as recently as:
16808 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16809 complaint (_("Variable in common block has "
16810 "DW_AT_data_member_location "
16811 "- DIE at %s [in module %s]"),
16812 sect_offset_str (child_die->sect_off),
16813 objfile_name (objfile));
16815 if (attr_form_is_section_offset (member_loc))
16816 dwarf2_complex_location_expr_complaint ();
16817 else if (attr_form_is_constant (member_loc)
16818 || attr_form_is_block (member_loc))
16821 mark_common_block_symbol_computed (sym, die, attr,
16825 dwarf2_complex_location_expr_complaint ();
16830 sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
16831 SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
16835 /* Create a type for a C++ namespace. */
16837 static struct type *
16838 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
16840 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16841 const char *previous_prefix, *name;
16845 /* For extensions, reuse the type of the original namespace. */
16846 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
16848 struct die_info *ext_die;
16849 struct dwarf2_cu *ext_cu = cu;
16851 ext_die = dwarf2_extension (die, &ext_cu);
16852 type = read_type_die (ext_die, ext_cu);
16854 /* EXT_CU may not be the same as CU.
16855 Ensure TYPE is recorded with CU in die_type_hash. */
16856 return set_die_type (die, type, cu);
16859 name = namespace_name (die, &is_anonymous, cu);
16861 /* Now build the name of the current namespace. */
16863 previous_prefix = determine_prefix (die, cu);
16864 if (previous_prefix[0] != '\0')
16865 name = typename_concat (&objfile->objfile_obstack,
16866 previous_prefix, name, 0, cu);
16868 /* Create the type. */
16869 type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
16871 return set_die_type (die, type, cu);
16874 /* Read a namespace scope. */
16877 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
16879 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16882 /* Add a symbol associated to this if we haven't seen the namespace
16883 before. Also, add a using directive if it's an anonymous
16886 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
16890 type = read_type_die (die, cu);
16891 new_symbol (die, type, cu);
16893 namespace_name (die, &is_anonymous, cu);
16896 const char *previous_prefix = determine_prefix (die, cu);
16898 std::vector<const char *> excludes;
16899 add_using_directive (using_directives (cu),
16900 previous_prefix, TYPE_NAME (type), NULL,
16901 NULL, excludes, 0, &objfile->objfile_obstack);
16905 if (die->child != NULL)
16907 struct die_info *child_die = die->child;
16909 while (child_die && child_die->tag)
16911 process_die (child_die, cu);
16912 child_die = sibling_die (child_die);
16917 /* Read a Fortran module as type. This DIE can be only a declaration used for
16918 imported module. Still we need that type as local Fortran "use ... only"
16919 declaration imports depend on the created type in determine_prefix. */
16921 static struct type *
16922 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
16924 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16925 const char *module_name;
16928 module_name = dwarf2_name (die, cu);
16930 complaint (_("DW_TAG_module has no name, offset %s"),
16931 sect_offset_str (die->sect_off));
16932 type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
16934 return set_die_type (die, type, cu);
16937 /* Read a Fortran module. */
16940 read_module (struct die_info *die, struct dwarf2_cu *cu)
16942 struct die_info *child_die = die->child;
16945 type = read_type_die (die, cu);
16946 new_symbol (die, type, cu);
16948 while (child_die && child_die->tag)
16950 process_die (child_die, cu);
16951 child_die = sibling_die (child_die);
16955 /* Return the name of the namespace represented by DIE. Set
16956 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16959 static const char *
16960 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
16962 struct die_info *current_die;
16963 const char *name = NULL;
16965 /* Loop through the extensions until we find a name. */
16967 for (current_die = die;
16968 current_die != NULL;
16969 current_die = dwarf2_extension (die, &cu))
16971 /* We don't use dwarf2_name here so that we can detect the absence
16972 of a name -> anonymous namespace. */
16973 name = dwarf2_string_attr (die, DW_AT_name, cu);
16979 /* Is it an anonymous namespace? */
16981 *is_anonymous = (name == NULL);
16983 name = CP_ANONYMOUS_NAMESPACE_STR;
16988 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16989 the user defined type vector. */
16991 static struct type *
16992 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
16994 struct gdbarch *gdbarch
16995 = get_objfile_arch (cu->per_cu->dwarf2_per_objfile->objfile);
16996 struct comp_unit_head *cu_header = &cu->header;
16998 struct attribute *attr_byte_size;
16999 struct attribute *attr_address_class;
17000 int byte_size, addr_class;
17001 struct type *target_type;
17003 target_type = die_type (die, cu);
17005 /* The die_type call above may have already set the type for this DIE. */
17006 type = get_die_type (die, cu);
17010 type = lookup_pointer_type (target_type);
17012 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
17013 if (attr_byte_size)
17014 byte_size = DW_UNSND (attr_byte_size);
17016 byte_size = cu_header->addr_size;
17018 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
17019 if (attr_address_class)
17020 addr_class = DW_UNSND (attr_address_class);
17022 addr_class = DW_ADDR_none;
17024 ULONGEST alignment = get_alignment (cu, die);
17026 /* If the pointer size, alignment, or address class is different
17027 than the default, create a type variant marked as such and set
17028 the length accordingly. */
17029 if (TYPE_LENGTH (type) != byte_size
17030 || (alignment != 0 && TYPE_RAW_ALIGN (type) != 0
17031 && alignment != TYPE_RAW_ALIGN (type))
17032 || addr_class != DW_ADDR_none)
17034 if (gdbarch_address_class_type_flags_p (gdbarch))
17038 type_flags = gdbarch_address_class_type_flags
17039 (gdbarch, byte_size, addr_class);
17040 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
17042 type = make_type_with_address_space (type, type_flags);
17044 else if (TYPE_LENGTH (type) != byte_size)
17046 complaint (_("invalid pointer size %d"), byte_size);
17048 else if (TYPE_RAW_ALIGN (type) != alignment)
17050 complaint (_("Invalid DW_AT_alignment"
17051 " - DIE at %s [in module %s]"),
17052 sect_offset_str (die->sect_off),
17053 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17057 /* Should we also complain about unhandled address classes? */
17061 TYPE_LENGTH (type) = byte_size;
17062 set_type_align (type, alignment);
17063 return set_die_type (die, type, cu);
17066 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17067 the user defined type vector. */
17069 static struct type *
17070 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
17073 struct type *to_type;
17074 struct type *domain;
17076 to_type = die_type (die, cu);
17077 domain = die_containing_type (die, cu);
17079 /* The calls above may have already set the type for this DIE. */
17080 type = get_die_type (die, cu);
17084 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
17085 type = lookup_methodptr_type (to_type);
17086 else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
17088 struct type *new_type
17089 = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
17091 smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
17092 TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
17093 TYPE_VARARGS (to_type));
17094 type = lookup_methodptr_type (new_type);
17097 type = lookup_memberptr_type (to_type, domain);
17099 return set_die_type (die, type, cu);
17102 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17103 the user defined type vector. */
17105 static struct type *
17106 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
17107 enum type_code refcode)
17109 struct comp_unit_head *cu_header = &cu->header;
17110 struct type *type, *target_type;
17111 struct attribute *attr;
17113 gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
17115 target_type = die_type (die, cu);
17117 /* The die_type call above may have already set the type for this DIE. */
17118 type = get_die_type (die, cu);
17122 type = lookup_reference_type (target_type, refcode);
17123 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17126 TYPE_LENGTH (type) = DW_UNSND (attr);
17130 TYPE_LENGTH (type) = cu_header->addr_size;
17132 maybe_set_alignment (cu, die, type);
17133 return set_die_type (die, type, cu);
17136 /* Add the given cv-qualifiers to the element type of the array. GCC
17137 outputs DWARF type qualifiers that apply to an array, not the
17138 element type. But GDB relies on the array element type to carry
17139 the cv-qualifiers. This mimics section 6.7.3 of the C99
17142 static struct type *
17143 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
17144 struct type *base_type, int cnst, int voltl)
17146 struct type *el_type, *inner_array;
17148 base_type = copy_type (base_type);
17149 inner_array = base_type;
17151 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
17153 TYPE_TARGET_TYPE (inner_array) =
17154 copy_type (TYPE_TARGET_TYPE (inner_array));
17155 inner_array = TYPE_TARGET_TYPE (inner_array);
17158 el_type = TYPE_TARGET_TYPE (inner_array);
17159 cnst |= TYPE_CONST (el_type);
17160 voltl |= TYPE_VOLATILE (el_type);
17161 TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
17163 return set_die_type (die, base_type, cu);
17166 static struct type *
17167 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
17169 struct type *base_type, *cv_type;
17171 base_type = die_type (die, cu);
17173 /* The die_type call above may have already set the type for this DIE. */
17174 cv_type = get_die_type (die, cu);
17178 /* In case the const qualifier is applied to an array type, the element type
17179 is so qualified, not the array type (section 6.7.3 of C99). */
17180 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17181 return add_array_cv_type (die, cu, base_type, 1, 0);
17183 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
17184 return set_die_type (die, cv_type, cu);
17187 static struct type *
17188 read_tag_volatile_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 /* In case the volatile qualifier is applied to an array type, the
17200 element type is so qualified, not the array type (section 6.7.3
17202 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17203 return add_array_cv_type (die, cu, base_type, 0, 1);
17205 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
17206 return set_die_type (die, cv_type, cu);
17209 /* Handle DW_TAG_restrict_type. */
17211 static struct type *
17212 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
17214 struct type *base_type, *cv_type;
17216 base_type = die_type (die, cu);
17218 /* The die_type call above may have already set the type for this DIE. */
17219 cv_type = get_die_type (die, cu);
17223 cv_type = make_restrict_type (base_type);
17224 return set_die_type (die, cv_type, cu);
17227 /* Handle DW_TAG_atomic_type. */
17229 static struct type *
17230 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
17232 struct type *base_type, *cv_type;
17234 base_type = die_type (die, cu);
17236 /* The die_type call above may have already set the type for this DIE. */
17237 cv_type = get_die_type (die, cu);
17241 cv_type = make_atomic_type (base_type);
17242 return set_die_type (die, cv_type, cu);
17245 /* Extract all information from a DW_TAG_string_type DIE and add to
17246 the user defined type vector. It isn't really a user defined type,
17247 but it behaves like one, with other DIE's using an AT_user_def_type
17248 attribute to reference it. */
17250 static struct type *
17251 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
17253 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17254 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17255 struct type *type, *range_type, *index_type, *char_type;
17256 struct attribute *attr;
17257 unsigned int length;
17259 attr = dwarf2_attr (die, DW_AT_string_length, cu);
17262 length = DW_UNSND (attr);
17266 /* Check for the DW_AT_byte_size attribute. */
17267 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17270 length = DW_UNSND (attr);
17278 index_type = objfile_type (objfile)->builtin_int;
17279 range_type = create_static_range_type (NULL, index_type, 1, length);
17280 char_type = language_string_char_type (cu->language_defn, gdbarch);
17281 type = create_string_type (NULL, char_type, range_type);
17283 return set_die_type (die, type, cu);
17286 /* Assuming that DIE corresponds to a function, returns nonzero
17287 if the function is prototyped. */
17290 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
17292 struct attribute *attr;
17294 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
17295 if (attr && (DW_UNSND (attr) != 0))
17298 /* The DWARF standard implies that the DW_AT_prototyped attribute
17299 is only meaninful for C, but the concept also extends to other
17300 languages that allow unprototyped functions (Eg: Objective C).
17301 For all other languages, assume that functions are always
17303 if (cu->language != language_c
17304 && cu->language != language_objc
17305 && cu->language != language_opencl)
17308 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17309 prototyped and unprototyped functions; default to prototyped,
17310 since that is more common in modern code (and RealView warns
17311 about unprototyped functions). */
17312 if (producer_is_realview (cu->producer))
17318 /* Handle DIES due to C code like:
17322 int (*funcp)(int a, long l);
17326 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17328 static struct type *
17329 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
17331 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17332 struct type *type; /* Type that this function returns. */
17333 struct type *ftype; /* Function that returns above type. */
17334 struct attribute *attr;
17336 type = die_type (die, cu);
17338 /* The die_type call above may have already set the type for this DIE. */
17339 ftype = get_die_type (die, cu);
17343 ftype = lookup_function_type (type);
17345 if (prototyped_function_p (die, cu))
17346 TYPE_PROTOTYPED (ftype) = 1;
17348 /* Store the calling convention in the type if it's available in
17349 the subroutine die. Otherwise set the calling convention to
17350 the default value DW_CC_normal. */
17351 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
17353 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
17354 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
17355 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
17357 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
17359 /* Record whether the function returns normally to its caller or not
17360 if the DWARF producer set that information. */
17361 attr = dwarf2_attr (die, DW_AT_noreturn, cu);
17362 if (attr && (DW_UNSND (attr) != 0))
17363 TYPE_NO_RETURN (ftype) = 1;
17365 /* We need to add the subroutine type to the die immediately so
17366 we don't infinitely recurse when dealing with parameters
17367 declared as the same subroutine type. */
17368 set_die_type (die, ftype, cu);
17370 if (die->child != NULL)
17372 struct type *void_type = objfile_type (objfile)->builtin_void;
17373 struct die_info *child_die;
17374 int nparams, iparams;
17376 /* Count the number of parameters.
17377 FIXME: GDB currently ignores vararg functions, but knows about
17378 vararg member functions. */
17380 child_die = die->child;
17381 while (child_die && child_die->tag)
17383 if (child_die->tag == DW_TAG_formal_parameter)
17385 else if (child_die->tag == DW_TAG_unspecified_parameters)
17386 TYPE_VARARGS (ftype) = 1;
17387 child_die = sibling_die (child_die);
17390 /* Allocate storage for parameters and fill them in. */
17391 TYPE_NFIELDS (ftype) = nparams;
17392 TYPE_FIELDS (ftype) = (struct field *)
17393 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
17395 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17396 even if we error out during the parameters reading below. */
17397 for (iparams = 0; iparams < nparams; iparams++)
17398 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
17401 child_die = die->child;
17402 while (child_die && child_die->tag)
17404 if (child_die->tag == DW_TAG_formal_parameter)
17406 struct type *arg_type;
17408 /* DWARF version 2 has no clean way to discern C++
17409 static and non-static member functions. G++ helps
17410 GDB by marking the first parameter for non-static
17411 member functions (which is the this pointer) as
17412 artificial. We pass this information to
17413 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17415 DWARF version 3 added DW_AT_object_pointer, which GCC
17416 4.5 does not yet generate. */
17417 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
17419 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
17421 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
17422 arg_type = die_type (child_die, cu);
17424 /* RealView does not mark THIS as const, which the testsuite
17425 expects. GCC marks THIS as const in method definitions,
17426 but not in the class specifications (GCC PR 43053). */
17427 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
17428 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
17431 struct dwarf2_cu *arg_cu = cu;
17432 const char *name = dwarf2_name (child_die, cu);
17434 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
17437 /* If the compiler emits this, use it. */
17438 if (follow_die_ref (die, attr, &arg_cu) == child_die)
17441 else if (name && strcmp (name, "this") == 0)
17442 /* Function definitions will have the argument names. */
17444 else if (name == NULL && iparams == 0)
17445 /* Declarations may not have the names, so like
17446 elsewhere in GDB, assume an artificial first
17447 argument is "this". */
17451 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
17455 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
17458 child_die = sibling_die (child_die);
17465 static struct type *
17466 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
17468 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17469 const char *name = NULL;
17470 struct type *this_type, *target_type;
17472 name = dwarf2_full_name (NULL, die, cu);
17473 this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
17474 TYPE_TARGET_STUB (this_type) = 1;
17475 set_die_type (die, this_type, cu);
17476 target_type = die_type (die, cu);
17477 if (target_type != this_type)
17478 TYPE_TARGET_TYPE (this_type) = target_type;
17481 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17482 spec and cause infinite loops in GDB. */
17483 complaint (_("Self-referential DW_TAG_typedef "
17484 "- DIE at %s [in module %s]"),
17485 sect_offset_str (die->sect_off), objfile_name (objfile));
17486 TYPE_TARGET_TYPE (this_type) = NULL;
17491 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17492 (which may be different from NAME) to the architecture back-end to allow
17493 it to guess the correct format if necessary. */
17495 static struct type *
17496 dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
17497 const char *name_hint)
17499 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17500 const struct floatformat **format;
17503 format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
17505 type = init_float_type (objfile, bits, name, format);
17507 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17512 /* Allocate an integer type of size BITS and name NAME. */
17514 static struct type *
17515 dwarf2_init_integer_type (struct dwarf2_cu *cu, struct objfile *objfile,
17516 int bits, int unsigned_p, const char *name)
17520 /* Versions of Intel's C Compiler generate an integer type called "void"
17521 instead of using DW_TAG_unspecified_type. This has been seen on
17522 at least versions 14, 17, and 18. */
17523 if (bits == 0 && producer_is_icc (cu) && name != nullptr
17524 && strcmp (name, "void") == 0)
17525 type = objfile_type (objfile)->builtin_void;
17527 type = init_integer_type (objfile, bits, unsigned_p, name);
17532 /* Find a representation of a given base type and install
17533 it in the TYPE field of the die. */
17535 static struct type *
17536 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
17538 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17540 struct attribute *attr;
17541 int encoding = 0, bits = 0;
17544 attr = dwarf2_attr (die, DW_AT_encoding, cu);
17547 encoding = DW_UNSND (attr);
17549 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17552 bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
17554 name = dwarf2_name (die, cu);
17557 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17562 case DW_ATE_address:
17563 /* Turn DW_ATE_address into a void * pointer. */
17564 type = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
17565 type = init_pointer_type (objfile, bits, name, type);
17567 case DW_ATE_boolean:
17568 type = init_boolean_type (objfile, bits, 1, name);
17570 case DW_ATE_complex_float:
17571 type = dwarf2_init_float_type (objfile, bits / 2, NULL, name);
17572 type = init_complex_type (objfile, name, type);
17574 case DW_ATE_decimal_float:
17575 type = init_decfloat_type (objfile, bits, name);
17578 type = dwarf2_init_float_type (objfile, bits, name, name);
17580 case DW_ATE_signed:
17581 type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17583 case DW_ATE_unsigned:
17584 if (cu->language == language_fortran
17586 && startswith (name, "character("))
17587 type = init_character_type (objfile, bits, 1, name);
17589 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17591 case DW_ATE_signed_char:
17592 if (cu->language == language_ada || cu->language == language_m2
17593 || cu->language == language_pascal
17594 || cu->language == language_fortran)
17595 type = init_character_type (objfile, bits, 0, name);
17597 type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17599 case DW_ATE_unsigned_char:
17600 if (cu->language == language_ada || cu->language == language_m2
17601 || cu->language == language_pascal
17602 || cu->language == language_fortran
17603 || cu->language == language_rust)
17604 type = init_character_type (objfile, bits, 1, name);
17606 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17610 gdbarch *arch = get_objfile_arch (objfile);
17613 type = builtin_type (arch)->builtin_char16;
17614 else if (bits == 32)
17615 type = builtin_type (arch)->builtin_char32;
17618 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17620 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17622 return set_die_type (die, type, cu);
17627 complaint (_("unsupported DW_AT_encoding: '%s'"),
17628 dwarf_type_encoding_name (encoding));
17629 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17633 if (name && strcmp (name, "char") == 0)
17634 TYPE_NOSIGN (type) = 1;
17636 maybe_set_alignment (cu, die, type);
17638 return set_die_type (die, type, cu);
17641 /* Parse dwarf attribute if it's a block, reference or constant and put the
17642 resulting value of the attribute into struct bound_prop.
17643 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17646 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
17647 struct dwarf2_cu *cu, struct dynamic_prop *prop)
17649 struct dwarf2_property_baton *baton;
17650 struct obstack *obstack
17651 = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
17653 if (attr == NULL || prop == NULL)
17656 if (attr_form_is_block (attr))
17658 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17659 baton->referenced_type = NULL;
17660 baton->locexpr.per_cu = cu->per_cu;
17661 baton->locexpr.size = DW_BLOCK (attr)->size;
17662 baton->locexpr.data = DW_BLOCK (attr)->data;
17663 prop->data.baton = baton;
17664 prop->kind = PROP_LOCEXPR;
17665 gdb_assert (prop->data.baton != NULL);
17667 else if (attr_form_is_ref (attr))
17669 struct dwarf2_cu *target_cu = cu;
17670 struct die_info *target_die;
17671 struct attribute *target_attr;
17673 target_die = follow_die_ref (die, attr, &target_cu);
17674 target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
17675 if (target_attr == NULL)
17676 target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
17678 if (target_attr == NULL)
17681 switch (target_attr->name)
17683 case DW_AT_location:
17684 if (attr_form_is_section_offset (target_attr))
17686 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17687 baton->referenced_type = die_type (target_die, target_cu);
17688 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
17689 prop->data.baton = baton;
17690 prop->kind = PROP_LOCLIST;
17691 gdb_assert (prop->data.baton != NULL);
17693 else if (attr_form_is_block (target_attr))
17695 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17696 baton->referenced_type = die_type (target_die, target_cu);
17697 baton->locexpr.per_cu = cu->per_cu;
17698 baton->locexpr.size = DW_BLOCK (target_attr)->size;
17699 baton->locexpr.data = DW_BLOCK (target_attr)->data;
17700 prop->data.baton = baton;
17701 prop->kind = PROP_LOCEXPR;
17702 gdb_assert (prop->data.baton != NULL);
17706 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17707 "dynamic property");
17711 case DW_AT_data_member_location:
17715 if (!handle_data_member_location (target_die, target_cu,
17719 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17720 baton->referenced_type = read_type_die (target_die->parent,
17722 baton->offset_info.offset = offset;
17723 baton->offset_info.type = die_type (target_die, target_cu);
17724 prop->data.baton = baton;
17725 prop->kind = PROP_ADDR_OFFSET;
17730 else if (attr_form_is_constant (attr))
17732 prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
17733 prop->kind = PROP_CONST;
17737 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
17738 dwarf2_name (die, cu));
17745 /* Read the given DW_AT_subrange DIE. */
17747 static struct type *
17748 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
17750 struct type *base_type, *orig_base_type;
17751 struct type *range_type;
17752 struct attribute *attr;
17753 struct dynamic_prop low, high;
17754 int low_default_is_valid;
17755 int high_bound_is_count = 0;
17757 ULONGEST negative_mask;
17759 orig_base_type = die_type (die, cu);
17760 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17761 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17762 creating the range type, but we use the result of check_typedef
17763 when examining properties of the type. */
17764 base_type = check_typedef (orig_base_type);
17766 /* The die_type call above may have already set the type for this DIE. */
17767 range_type = get_die_type (die, cu);
17771 low.kind = PROP_CONST;
17772 high.kind = PROP_CONST;
17773 high.data.const_val = 0;
17775 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17776 omitting DW_AT_lower_bound. */
17777 switch (cu->language)
17780 case language_cplus:
17781 low.data.const_val = 0;
17782 low_default_is_valid = 1;
17784 case language_fortran:
17785 low.data.const_val = 1;
17786 low_default_is_valid = 1;
17789 case language_objc:
17790 case language_rust:
17791 low.data.const_val = 0;
17792 low_default_is_valid = (cu->header.version >= 4);
17796 case language_pascal:
17797 low.data.const_val = 1;
17798 low_default_is_valid = (cu->header.version >= 4);
17801 low.data.const_val = 0;
17802 low_default_is_valid = 0;
17806 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
17808 attr_to_dynamic_prop (attr, die, cu, &low);
17809 else if (!low_default_is_valid)
17810 complaint (_("Missing DW_AT_lower_bound "
17811 "- DIE at %s [in module %s]"),
17812 sect_offset_str (die->sect_off),
17813 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17815 struct attribute *attr_ub, *attr_count;
17816 attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);
17817 if (!attr_to_dynamic_prop (attr, die, cu, &high))
17819 attr = attr_count = dwarf2_attr (die, DW_AT_count, cu);
17820 if (attr_to_dynamic_prop (attr, die, cu, &high))
17822 /* If bounds are constant do the final calculation here. */
17823 if (low.kind == PROP_CONST && high.kind == PROP_CONST)
17824 high.data.const_val = low.data.const_val + high.data.const_val - 1;
17826 high_bound_is_count = 1;
17830 if (attr_ub != NULL)
17831 complaint (_("Unresolved DW_AT_upper_bound "
17832 "- DIE at %s [in module %s]"),
17833 sect_offset_str (die->sect_off),
17834 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17835 if (attr_count != NULL)
17836 complaint (_("Unresolved DW_AT_count "
17837 "- DIE at %s [in module %s]"),
17838 sect_offset_str (die->sect_off),
17839 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17844 /* Dwarf-2 specifications explicitly allows to create subrange types
17845 without specifying a base type.
17846 In that case, the base type must be set to the type of
17847 the lower bound, upper bound or count, in that order, if any of these
17848 three attributes references an object that has a type.
17849 If no base type is found, the Dwarf-2 specifications say that
17850 a signed integer type of size equal to the size of an address should
17852 For the following C code: `extern char gdb_int [];'
17853 GCC produces an empty range DIE.
17854 FIXME: muller/2010-05-28: Possible references to object for low bound,
17855 high bound or count are not yet handled by this code. */
17856 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
17858 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17859 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17860 int addr_size = gdbarch_addr_bit (gdbarch) /8;
17861 struct type *int_type = objfile_type (objfile)->builtin_int;
17863 /* Test "int", "long int", and "long long int" objfile types,
17864 and select the first one having a size above or equal to the
17865 architecture address size. */
17866 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17867 base_type = int_type;
17870 int_type = objfile_type (objfile)->builtin_long;
17871 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17872 base_type = int_type;
17875 int_type = objfile_type (objfile)->builtin_long_long;
17876 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17877 base_type = int_type;
17882 /* Normally, the DWARF producers are expected to use a signed
17883 constant form (Eg. DW_FORM_sdata) to express negative bounds.
17884 But this is unfortunately not always the case, as witnessed
17885 with GCC, for instance, where the ambiguous DW_FORM_dataN form
17886 is used instead. To work around that ambiguity, we treat
17887 the bounds as signed, and thus sign-extend their values, when
17888 the base type is signed. */
17890 -((ULONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
17891 if (low.kind == PROP_CONST
17892 && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
17893 low.data.const_val |= negative_mask;
17894 if (high.kind == PROP_CONST
17895 && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
17896 high.data.const_val |= negative_mask;
17898 range_type = create_range_type (NULL, orig_base_type, &low, &high);
17900 if (high_bound_is_count)
17901 TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
17903 /* Ada expects an empty array on no boundary attributes. */
17904 if (attr == NULL && cu->language != language_ada)
17905 TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
17907 name = dwarf2_name (die, cu);
17909 TYPE_NAME (range_type) = name;
17911 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17913 TYPE_LENGTH (range_type) = DW_UNSND (attr);
17915 maybe_set_alignment (cu, die, range_type);
17917 set_die_type (die, range_type, cu);
17919 /* set_die_type should be already done. */
17920 set_descriptive_type (range_type, die, cu);
17925 static struct type *
17926 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
17930 type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
17932 TYPE_NAME (type) = dwarf2_name (die, cu);
17934 /* In Ada, an unspecified type is typically used when the description
17935 of the type is defered to a different unit. When encountering
17936 such a type, we treat it as a stub, and try to resolve it later on,
17938 if (cu->language == language_ada)
17939 TYPE_STUB (type) = 1;
17941 return set_die_type (die, type, cu);
17944 /* Read a single die and all its descendents. Set the die's sibling
17945 field to NULL; set other fields in the die correctly, and set all
17946 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
17947 location of the info_ptr after reading all of those dies. PARENT
17948 is the parent of the die in question. */
17950 static struct die_info *
17951 read_die_and_children (const struct die_reader_specs *reader,
17952 const gdb_byte *info_ptr,
17953 const gdb_byte **new_info_ptr,
17954 struct die_info *parent)
17956 struct die_info *die;
17957 const gdb_byte *cur_ptr;
17960 cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
17963 *new_info_ptr = cur_ptr;
17966 store_in_ref_table (die, reader->cu);
17969 die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
17973 *new_info_ptr = cur_ptr;
17976 die->sibling = NULL;
17977 die->parent = parent;
17981 /* Read a die, all of its descendents, and all of its siblings; set
17982 all of the fields of all of the dies correctly. Arguments are as
17983 in read_die_and_children. */
17985 static struct die_info *
17986 read_die_and_siblings_1 (const struct die_reader_specs *reader,
17987 const gdb_byte *info_ptr,
17988 const gdb_byte **new_info_ptr,
17989 struct die_info *parent)
17991 struct die_info *first_die, *last_sibling;
17992 const gdb_byte *cur_ptr;
17994 cur_ptr = info_ptr;
17995 first_die = last_sibling = NULL;
17999 struct die_info *die
18000 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
18004 *new_info_ptr = cur_ptr;
18011 last_sibling->sibling = die;
18013 last_sibling = die;
18017 /* Read a die, all of its descendents, and all of its siblings; set
18018 all of the fields of all of the dies correctly. Arguments are as
18019 in read_die_and_children.
18020 This the main entry point for reading a DIE and all its children. */
18022 static struct die_info *
18023 read_die_and_siblings (const struct die_reader_specs *reader,
18024 const gdb_byte *info_ptr,
18025 const gdb_byte **new_info_ptr,
18026 struct die_info *parent)
18028 struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
18029 new_info_ptr, parent);
18031 if (dwarf_die_debug)
18033 fprintf_unfiltered (gdb_stdlog,
18034 "Read die from %s@0x%x of %s:\n",
18035 get_section_name (reader->die_section),
18036 (unsigned) (info_ptr - reader->die_section->buffer),
18037 bfd_get_filename (reader->abfd));
18038 dump_die (die, dwarf_die_debug);
18044 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18046 The caller is responsible for filling in the extra attributes
18047 and updating (*DIEP)->num_attrs.
18048 Set DIEP to point to a newly allocated die with its information,
18049 except for its child, sibling, and parent fields.
18050 Set HAS_CHILDREN to tell whether the die has children or not. */
18052 static const gdb_byte *
18053 read_full_die_1 (const struct die_reader_specs *reader,
18054 struct die_info **diep, const gdb_byte *info_ptr,
18055 int *has_children, int num_extra_attrs)
18057 unsigned int abbrev_number, bytes_read, i;
18058 struct abbrev_info *abbrev;
18059 struct die_info *die;
18060 struct dwarf2_cu *cu = reader->cu;
18061 bfd *abfd = reader->abfd;
18063 sect_offset sect_off = (sect_offset) (info_ptr - reader->buffer);
18064 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
18065 info_ptr += bytes_read;
18066 if (!abbrev_number)
18073 abbrev = reader->abbrev_table->lookup_abbrev (abbrev_number);
18075 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18077 bfd_get_filename (abfd));
18079 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
18080 die->sect_off = sect_off;
18081 die->tag = abbrev->tag;
18082 die->abbrev = abbrev_number;
18084 /* Make the result usable.
18085 The caller needs to update num_attrs after adding the extra
18087 die->num_attrs = abbrev->num_attrs;
18089 for (i = 0; i < abbrev->num_attrs; ++i)
18090 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
18094 *has_children = abbrev->has_children;
18098 /* Read a die and all its attributes.
18099 Set DIEP to point to a newly allocated die with its information,
18100 except for its child, sibling, and parent fields.
18101 Set HAS_CHILDREN to tell whether the die has children or not. */
18103 static const gdb_byte *
18104 read_full_die (const struct die_reader_specs *reader,
18105 struct die_info **diep, const gdb_byte *info_ptr,
18108 const gdb_byte *result;
18110 result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
18112 if (dwarf_die_debug)
18114 fprintf_unfiltered (gdb_stdlog,
18115 "Read die from %s@0x%x of %s:\n",
18116 get_section_name (reader->die_section),
18117 (unsigned) (info_ptr - reader->die_section->buffer),
18118 bfd_get_filename (reader->abfd));
18119 dump_die (*diep, dwarf_die_debug);
18125 /* Abbreviation tables.
18127 In DWARF version 2, the description of the debugging information is
18128 stored in a separate .debug_abbrev section. Before we read any
18129 dies from a section we read in all abbreviations and install them
18130 in a hash table. */
18132 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18134 struct abbrev_info *
18135 abbrev_table::alloc_abbrev ()
18137 struct abbrev_info *abbrev;
18139 abbrev = XOBNEW (&abbrev_obstack, struct abbrev_info);
18140 memset (abbrev, 0, sizeof (struct abbrev_info));
18145 /* Add an abbreviation to the table. */
18148 abbrev_table::add_abbrev (unsigned int abbrev_number,
18149 struct abbrev_info *abbrev)
18151 unsigned int hash_number;
18153 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18154 abbrev->next = m_abbrevs[hash_number];
18155 m_abbrevs[hash_number] = abbrev;
18158 /* Look up an abbrev in the table.
18159 Returns NULL if the abbrev is not found. */
18161 struct abbrev_info *
18162 abbrev_table::lookup_abbrev (unsigned int abbrev_number)
18164 unsigned int hash_number;
18165 struct abbrev_info *abbrev;
18167 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18168 abbrev = m_abbrevs[hash_number];
18172 if (abbrev->number == abbrev_number)
18174 abbrev = abbrev->next;
18179 /* Read in an abbrev table. */
18181 static abbrev_table_up
18182 abbrev_table_read_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
18183 struct dwarf2_section_info *section,
18184 sect_offset sect_off)
18186 struct objfile *objfile = dwarf2_per_objfile->objfile;
18187 bfd *abfd = get_section_bfd_owner (section);
18188 const gdb_byte *abbrev_ptr;
18189 struct abbrev_info *cur_abbrev;
18190 unsigned int abbrev_number, bytes_read, abbrev_name;
18191 unsigned int abbrev_form;
18192 struct attr_abbrev *cur_attrs;
18193 unsigned int allocated_attrs;
18195 abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
18197 dwarf2_read_section (objfile, section);
18198 abbrev_ptr = section->buffer + to_underlying (sect_off);
18199 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18200 abbrev_ptr += bytes_read;
18202 allocated_attrs = ATTR_ALLOC_CHUNK;
18203 cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
18205 /* Loop until we reach an abbrev number of 0. */
18206 while (abbrev_number)
18208 cur_abbrev = abbrev_table->alloc_abbrev ();
18210 /* read in abbrev header */
18211 cur_abbrev->number = abbrev_number;
18213 = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18214 abbrev_ptr += bytes_read;
18215 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
18218 /* now read in declarations */
18221 LONGEST implicit_const;
18223 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18224 abbrev_ptr += bytes_read;
18225 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18226 abbrev_ptr += bytes_read;
18227 if (abbrev_form == DW_FORM_implicit_const)
18229 implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
18231 abbrev_ptr += bytes_read;
18235 /* Initialize it due to a false compiler warning. */
18236 implicit_const = -1;
18239 if (abbrev_name == 0)
18242 if (cur_abbrev->num_attrs == allocated_attrs)
18244 allocated_attrs += ATTR_ALLOC_CHUNK;
18246 = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
18249 cur_attrs[cur_abbrev->num_attrs].name
18250 = (enum dwarf_attribute) abbrev_name;
18251 cur_attrs[cur_abbrev->num_attrs].form
18252 = (enum dwarf_form) abbrev_form;
18253 cur_attrs[cur_abbrev->num_attrs].implicit_const = implicit_const;
18254 ++cur_abbrev->num_attrs;
18257 cur_abbrev->attrs =
18258 XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
18259 cur_abbrev->num_attrs);
18260 memcpy (cur_abbrev->attrs, cur_attrs,
18261 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
18263 abbrev_table->add_abbrev (abbrev_number, cur_abbrev);
18265 /* Get next abbreviation.
18266 Under Irix6 the abbreviations for a compilation unit are not
18267 always properly terminated with an abbrev number of 0.
18268 Exit loop if we encounter an abbreviation which we have
18269 already read (which means we are about to read the abbreviations
18270 for the next compile unit) or if the end of the abbreviation
18271 table is reached. */
18272 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
18274 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18275 abbrev_ptr += bytes_read;
18276 if (abbrev_table->lookup_abbrev (abbrev_number) != NULL)
18281 return abbrev_table;
18284 /* Returns nonzero if TAG represents a type that we might generate a partial
18288 is_type_tag_for_partial (int tag)
18293 /* Some types that would be reasonable to generate partial symbols for,
18294 that we don't at present. */
18295 case DW_TAG_array_type:
18296 case DW_TAG_file_type:
18297 case DW_TAG_ptr_to_member_type:
18298 case DW_TAG_set_type:
18299 case DW_TAG_string_type:
18300 case DW_TAG_subroutine_type:
18302 case DW_TAG_base_type:
18303 case DW_TAG_class_type:
18304 case DW_TAG_interface_type:
18305 case DW_TAG_enumeration_type:
18306 case DW_TAG_structure_type:
18307 case DW_TAG_subrange_type:
18308 case DW_TAG_typedef:
18309 case DW_TAG_union_type:
18316 /* Load all DIEs that are interesting for partial symbols into memory. */
18318 static struct partial_die_info *
18319 load_partial_dies (const struct die_reader_specs *reader,
18320 const gdb_byte *info_ptr, int building_psymtab)
18322 struct dwarf2_cu *cu = reader->cu;
18323 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18324 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
18325 unsigned int bytes_read;
18326 unsigned int load_all = 0;
18327 int nesting_level = 1;
18332 gdb_assert (cu->per_cu != NULL);
18333 if (cu->per_cu->load_all_dies)
18337 = htab_create_alloc_ex (cu->header.length / 12,
18341 &cu->comp_unit_obstack,
18342 hashtab_obstack_allocate,
18343 dummy_obstack_deallocate);
18347 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
18349 /* A NULL abbrev means the end of a series of children. */
18350 if (abbrev == NULL)
18352 if (--nesting_level == 0)
18355 info_ptr += bytes_read;
18356 last_die = parent_die;
18357 parent_die = parent_die->die_parent;
18361 /* Check for template arguments. We never save these; if
18362 they're seen, we just mark the parent, and go on our way. */
18363 if (parent_die != NULL
18364 && cu->language == language_cplus
18365 && (abbrev->tag == DW_TAG_template_type_param
18366 || abbrev->tag == DW_TAG_template_value_param))
18368 parent_die->has_template_arguments = 1;
18372 /* We don't need a partial DIE for the template argument. */
18373 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18378 /* We only recurse into c++ subprograms looking for template arguments.
18379 Skip their other children. */
18381 && cu->language == language_cplus
18382 && parent_die != NULL
18383 && parent_die->tag == DW_TAG_subprogram)
18385 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18389 /* Check whether this DIE is interesting enough to save. Normally
18390 we would not be interested in members here, but there may be
18391 later variables referencing them via DW_AT_specification (for
18392 static members). */
18394 && !is_type_tag_for_partial (abbrev->tag)
18395 && abbrev->tag != DW_TAG_constant
18396 && abbrev->tag != DW_TAG_enumerator
18397 && abbrev->tag != DW_TAG_subprogram
18398 && abbrev->tag != DW_TAG_inlined_subroutine
18399 && abbrev->tag != DW_TAG_lexical_block
18400 && abbrev->tag != DW_TAG_variable
18401 && abbrev->tag != DW_TAG_namespace
18402 && abbrev->tag != DW_TAG_module
18403 && abbrev->tag != DW_TAG_member
18404 && abbrev->tag != DW_TAG_imported_unit
18405 && abbrev->tag != DW_TAG_imported_declaration)
18407 /* Otherwise we skip to the next sibling, if any. */
18408 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18412 struct partial_die_info pdi ((sect_offset) (info_ptr - reader->buffer),
18415 info_ptr = pdi.read (reader, *abbrev, info_ptr + bytes_read);
18417 /* This two-pass algorithm for processing partial symbols has a
18418 high cost in cache pressure. Thus, handle some simple cases
18419 here which cover the majority of C partial symbols. DIEs
18420 which neither have specification tags in them, nor could have
18421 specification tags elsewhere pointing at them, can simply be
18422 processed and discarded.
18424 This segment is also optional; scan_partial_symbols and
18425 add_partial_symbol will handle these DIEs if we chain
18426 them in normally. When compilers which do not emit large
18427 quantities of duplicate debug information are more common,
18428 this code can probably be removed. */
18430 /* Any complete simple types at the top level (pretty much all
18431 of them, for a language without namespaces), can be processed
18433 if (parent_die == NULL
18434 && pdi.has_specification == 0
18435 && pdi.is_declaration == 0
18436 && ((pdi.tag == DW_TAG_typedef && !pdi.has_children)
18437 || pdi.tag == DW_TAG_base_type
18438 || pdi.tag == DW_TAG_subrange_type))
18440 if (building_psymtab && pdi.name != NULL)
18441 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18442 VAR_DOMAIN, LOC_TYPEDEF, -1,
18443 &objfile->static_psymbols,
18444 0, cu->language, objfile);
18445 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18449 /* The exception for DW_TAG_typedef with has_children above is
18450 a workaround of GCC PR debug/47510. In the case of this complaint
18451 type_name_or_error will error on such types later.
18453 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18454 it could not find the child DIEs referenced later, this is checked
18455 above. In correct DWARF DW_TAG_typedef should have no children. */
18457 if (pdi.tag == DW_TAG_typedef && pdi.has_children)
18458 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18459 "- DIE at %s [in module %s]"),
18460 sect_offset_str (pdi.sect_off), objfile_name (objfile));
18462 /* If we're at the second level, and we're an enumerator, and
18463 our parent has no specification (meaning possibly lives in a
18464 namespace elsewhere), then we can add the partial symbol now
18465 instead of queueing it. */
18466 if (pdi.tag == DW_TAG_enumerator
18467 && parent_die != NULL
18468 && parent_die->die_parent == NULL
18469 && parent_die->tag == DW_TAG_enumeration_type
18470 && parent_die->has_specification == 0)
18472 if (pdi.name == NULL)
18473 complaint (_("malformed enumerator DIE ignored"));
18474 else if (building_psymtab)
18475 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18476 VAR_DOMAIN, LOC_CONST, -1,
18477 cu->language == language_cplus
18478 ? &objfile->global_psymbols
18479 : &objfile->static_psymbols,
18480 0, cu->language, objfile);
18482 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18486 struct partial_die_info *part_die
18487 = new (&cu->comp_unit_obstack) partial_die_info (pdi);
18489 /* We'll save this DIE so link it in. */
18490 part_die->die_parent = parent_die;
18491 part_die->die_sibling = NULL;
18492 part_die->die_child = NULL;
18494 if (last_die && last_die == parent_die)
18495 last_die->die_child = part_die;
18497 last_die->die_sibling = part_die;
18499 last_die = part_die;
18501 if (first_die == NULL)
18502 first_die = part_die;
18504 /* Maybe add the DIE to the hash table. Not all DIEs that we
18505 find interesting need to be in the hash table, because we
18506 also have the parent/sibling/child chains; only those that we
18507 might refer to by offset later during partial symbol reading.
18509 For now this means things that might have be the target of a
18510 DW_AT_specification, DW_AT_abstract_origin, or
18511 DW_AT_extension. DW_AT_extension will refer only to
18512 namespaces; DW_AT_abstract_origin refers to functions (and
18513 many things under the function DIE, but we do not recurse
18514 into function DIEs during partial symbol reading) and
18515 possibly variables as well; DW_AT_specification refers to
18516 declarations. Declarations ought to have the DW_AT_declaration
18517 flag. It happens that GCC forgets to put it in sometimes, but
18518 only for functions, not for types.
18520 Adding more things than necessary to the hash table is harmless
18521 except for the performance cost. Adding too few will result in
18522 wasted time in find_partial_die, when we reread the compilation
18523 unit with load_all_dies set. */
18526 || abbrev->tag == DW_TAG_constant
18527 || abbrev->tag == DW_TAG_subprogram
18528 || abbrev->tag == DW_TAG_variable
18529 || abbrev->tag == DW_TAG_namespace
18530 || part_die->is_declaration)
18534 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
18535 to_underlying (part_die->sect_off),
18540 /* For some DIEs we want to follow their children (if any). For C
18541 we have no reason to follow the children of structures; for other
18542 languages we have to, so that we can get at method physnames
18543 to infer fully qualified class names, for DW_AT_specification,
18544 and for C++ template arguments. For C++, we also look one level
18545 inside functions to find template arguments (if the name of the
18546 function does not already contain the template arguments).
18548 For Ada, we need to scan the children of subprograms and lexical
18549 blocks as well because Ada allows the definition of nested
18550 entities that could be interesting for the debugger, such as
18551 nested subprograms for instance. */
18552 if (last_die->has_children
18554 || last_die->tag == DW_TAG_namespace
18555 || last_die->tag == DW_TAG_module
18556 || last_die->tag == DW_TAG_enumeration_type
18557 || (cu->language == language_cplus
18558 && last_die->tag == DW_TAG_subprogram
18559 && (last_die->name == NULL
18560 || strchr (last_die->name, '<') == NULL))
18561 || (cu->language != language_c
18562 && (last_die->tag == DW_TAG_class_type
18563 || last_die->tag == DW_TAG_interface_type
18564 || last_die->tag == DW_TAG_structure_type
18565 || last_die->tag == DW_TAG_union_type))
18566 || (cu->language == language_ada
18567 && (last_die->tag == DW_TAG_subprogram
18568 || last_die->tag == DW_TAG_lexical_block))))
18571 parent_die = last_die;
18575 /* Otherwise we skip to the next sibling, if any. */
18576 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
18578 /* Back to the top, do it again. */
18582 partial_die_info::partial_die_info (sect_offset sect_off_,
18583 struct abbrev_info *abbrev)
18584 : partial_die_info (sect_off_, abbrev->tag, abbrev->has_children)
18588 /* Read a minimal amount of information into the minimal die structure.
18589 INFO_PTR should point just after the initial uleb128 of a DIE. */
18592 partial_die_info::read (const struct die_reader_specs *reader,
18593 const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
18595 struct dwarf2_cu *cu = reader->cu;
18596 struct dwarf2_per_objfile *dwarf2_per_objfile
18597 = cu->per_cu->dwarf2_per_objfile;
18599 int has_low_pc_attr = 0;
18600 int has_high_pc_attr = 0;
18601 int high_pc_relative = 0;
18603 for (i = 0; i < abbrev.num_attrs; ++i)
18605 struct attribute attr;
18607 info_ptr = read_attribute (reader, &attr, &abbrev.attrs[i], info_ptr);
18609 /* Store the data if it is of an attribute we want to keep in a
18610 partial symbol table. */
18616 case DW_TAG_compile_unit:
18617 case DW_TAG_partial_unit:
18618 case DW_TAG_type_unit:
18619 /* Compilation units have a DW_AT_name that is a filename, not
18620 a source language identifier. */
18621 case DW_TAG_enumeration_type:
18622 case DW_TAG_enumerator:
18623 /* These tags always have simple identifiers already; no need
18624 to canonicalize them. */
18625 name = DW_STRING (&attr);
18629 struct objfile *objfile = dwarf2_per_objfile->objfile;
18632 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
18633 &objfile->per_bfd->storage_obstack);
18638 case DW_AT_linkage_name:
18639 case DW_AT_MIPS_linkage_name:
18640 /* Note that both forms of linkage name might appear. We
18641 assume they will be the same, and we only store the last
18643 if (cu->language == language_ada)
18644 name = DW_STRING (&attr);
18645 linkage_name = DW_STRING (&attr);
18648 has_low_pc_attr = 1;
18649 lowpc = attr_value_as_address (&attr);
18651 case DW_AT_high_pc:
18652 has_high_pc_attr = 1;
18653 highpc = attr_value_as_address (&attr);
18654 if (cu->header.version >= 4 && attr_form_is_constant (&attr))
18655 high_pc_relative = 1;
18657 case DW_AT_location:
18658 /* Support the .debug_loc offsets. */
18659 if (attr_form_is_block (&attr))
18661 d.locdesc = DW_BLOCK (&attr);
18663 else if (attr_form_is_section_offset (&attr))
18665 dwarf2_complex_location_expr_complaint ();
18669 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18670 "partial symbol information");
18673 case DW_AT_external:
18674 is_external = DW_UNSND (&attr);
18676 case DW_AT_declaration:
18677 is_declaration = DW_UNSND (&attr);
18682 case DW_AT_abstract_origin:
18683 case DW_AT_specification:
18684 case DW_AT_extension:
18685 has_specification = 1;
18686 spec_offset = dwarf2_get_ref_die_offset (&attr);
18687 spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18688 || cu->per_cu->is_dwz);
18690 case DW_AT_sibling:
18691 /* Ignore absolute siblings, they might point outside of
18692 the current compile unit. */
18693 if (attr.form == DW_FORM_ref_addr)
18694 complaint (_("ignoring absolute DW_AT_sibling"));
18697 const gdb_byte *buffer = reader->buffer;
18698 sect_offset off = dwarf2_get_ref_die_offset (&attr);
18699 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
18701 if (sibling_ptr < info_ptr)
18702 complaint (_("DW_AT_sibling points backwards"));
18703 else if (sibling_ptr > reader->buffer_end)
18704 dwarf2_section_buffer_overflow_complaint (reader->die_section);
18706 sibling = sibling_ptr;
18709 case DW_AT_byte_size:
18712 case DW_AT_const_value:
18713 has_const_value = 1;
18715 case DW_AT_calling_convention:
18716 /* DWARF doesn't provide a way to identify a program's source-level
18717 entry point. DW_AT_calling_convention attributes are only meant
18718 to describe functions' calling conventions.
18720 However, because it's a necessary piece of information in
18721 Fortran, and before DWARF 4 DW_CC_program was the only
18722 piece of debugging information whose definition refers to
18723 a 'main program' at all, several compilers marked Fortran
18724 main programs with DW_CC_program --- even when those
18725 functions use the standard calling conventions.
18727 Although DWARF now specifies a way to provide this
18728 information, we support this practice for backward
18730 if (DW_UNSND (&attr) == DW_CC_program
18731 && cu->language == language_fortran)
18732 main_subprogram = 1;
18735 if (DW_UNSND (&attr) == DW_INL_inlined
18736 || DW_UNSND (&attr) == DW_INL_declared_inlined)
18737 may_be_inlined = 1;
18741 if (tag == DW_TAG_imported_unit)
18743 d.sect_off = dwarf2_get_ref_die_offset (&attr);
18744 is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18745 || cu->per_cu->is_dwz);
18749 case DW_AT_main_subprogram:
18750 main_subprogram = DW_UNSND (&attr);
18758 if (high_pc_relative)
18761 if (has_low_pc_attr && has_high_pc_attr)
18763 /* When using the GNU linker, .gnu.linkonce. sections are used to
18764 eliminate duplicate copies of functions and vtables and such.
18765 The linker will arbitrarily choose one and discard the others.
18766 The AT_*_pc values for such functions refer to local labels in
18767 these sections. If the section from that file was discarded, the
18768 labels are not in the output, so the relocs get a value of 0.
18769 If this is a discarded function, mark the pc bounds as invalid,
18770 so that GDB will ignore it. */
18771 if (lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
18773 struct objfile *objfile = dwarf2_per_objfile->objfile;
18774 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18776 complaint (_("DW_AT_low_pc %s is zero "
18777 "for DIE at %s [in module %s]"),
18778 paddress (gdbarch, lowpc),
18779 sect_offset_str (sect_off),
18780 objfile_name (objfile));
18782 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18783 else if (lowpc >= highpc)
18785 struct objfile *objfile = dwarf2_per_objfile->objfile;
18786 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18788 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18789 "for DIE at %s [in module %s]"),
18790 paddress (gdbarch, lowpc),
18791 paddress (gdbarch, highpc),
18792 sect_offset_str (sect_off),
18793 objfile_name (objfile));
18802 /* Find a cached partial DIE at OFFSET in CU. */
18804 struct partial_die_info *
18805 dwarf2_cu::find_partial_die (sect_offset sect_off)
18807 struct partial_die_info *lookup_die = NULL;
18808 struct partial_die_info part_die (sect_off);
18810 lookup_die = ((struct partial_die_info *)
18811 htab_find_with_hash (partial_dies, &part_die,
18812 to_underlying (sect_off)));
18817 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18818 except in the case of .debug_types DIEs which do not reference
18819 outside their CU (they do however referencing other types via
18820 DW_FORM_ref_sig8). */
18822 static struct partial_die_info *
18823 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
18825 struct dwarf2_per_objfile *dwarf2_per_objfile
18826 = cu->per_cu->dwarf2_per_objfile;
18827 struct objfile *objfile = dwarf2_per_objfile->objfile;
18828 struct dwarf2_per_cu_data *per_cu = NULL;
18829 struct partial_die_info *pd = NULL;
18831 if (offset_in_dwz == cu->per_cu->is_dwz
18832 && offset_in_cu_p (&cu->header, sect_off))
18834 pd = cu->find_partial_die (sect_off);
18837 /* We missed recording what we needed.
18838 Load all dies and try again. */
18839 per_cu = cu->per_cu;
18843 /* TUs don't reference other CUs/TUs (except via type signatures). */
18844 if (cu->per_cu->is_debug_types)
18846 error (_("Dwarf Error: Type Unit at offset %s contains"
18847 " external reference to offset %s [in module %s].\n"),
18848 sect_offset_str (cu->header.sect_off), sect_offset_str (sect_off),
18849 bfd_get_filename (objfile->obfd));
18851 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
18852 dwarf2_per_objfile);
18854 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
18855 load_partial_comp_unit (per_cu);
18857 per_cu->cu->last_used = 0;
18858 pd = per_cu->cu->find_partial_die (sect_off);
18861 /* If we didn't find it, and not all dies have been loaded,
18862 load them all and try again. */
18864 if (pd == NULL && per_cu->load_all_dies == 0)
18866 per_cu->load_all_dies = 1;
18868 /* This is nasty. When we reread the DIEs, somewhere up the call chain
18869 THIS_CU->cu may already be in use. So we can't just free it and
18870 replace its DIEs with the ones we read in. Instead, we leave those
18871 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18872 and clobber THIS_CU->cu->partial_dies with the hash table for the new
18874 load_partial_comp_unit (per_cu);
18876 pd = per_cu->cu->find_partial_die (sect_off);
18880 internal_error (__FILE__, __LINE__,
18881 _("could not find partial DIE %s "
18882 "in cache [from module %s]\n"),
18883 sect_offset_str (sect_off), bfd_get_filename (objfile->obfd));
18887 /* See if we can figure out if the class lives in a namespace. We do
18888 this by looking for a member function; its demangled name will
18889 contain namespace info, if there is any. */
18892 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
18893 struct dwarf2_cu *cu)
18895 /* NOTE: carlton/2003-10-07: Getting the info this way changes
18896 what template types look like, because the demangler
18897 frequently doesn't give the same name as the debug info. We
18898 could fix this by only using the demangled name to get the
18899 prefix (but see comment in read_structure_type). */
18901 struct partial_die_info *real_pdi;
18902 struct partial_die_info *child_pdi;
18904 /* If this DIE (this DIE's specification, if any) has a parent, then
18905 we should not do this. We'll prepend the parent's fully qualified
18906 name when we create the partial symbol. */
18908 real_pdi = struct_pdi;
18909 while (real_pdi->has_specification)
18910 real_pdi = find_partial_die (real_pdi->spec_offset,
18911 real_pdi->spec_is_dwz, cu);
18913 if (real_pdi->die_parent != NULL)
18916 for (child_pdi = struct_pdi->die_child;
18918 child_pdi = child_pdi->die_sibling)
18920 if (child_pdi->tag == DW_TAG_subprogram
18921 && child_pdi->linkage_name != NULL)
18923 char *actual_class_name
18924 = language_class_name_from_physname (cu->language_defn,
18925 child_pdi->linkage_name);
18926 if (actual_class_name != NULL)
18928 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18931 obstack_copy0 (&objfile->per_bfd->storage_obstack,
18933 strlen (actual_class_name)));
18934 xfree (actual_class_name);
18942 partial_die_info::fixup (struct dwarf2_cu *cu)
18944 /* Once we've fixed up a die, there's no point in doing so again.
18945 This also avoids a memory leak if we were to call
18946 guess_partial_die_structure_name multiple times. */
18950 /* If we found a reference attribute and the DIE has no name, try
18951 to find a name in the referred to DIE. */
18953 if (name == NULL && has_specification)
18955 struct partial_die_info *spec_die;
18957 spec_die = find_partial_die (spec_offset, spec_is_dwz, cu);
18959 spec_die->fixup (cu);
18961 if (spec_die->name)
18963 name = spec_die->name;
18965 /* Copy DW_AT_external attribute if it is set. */
18966 if (spec_die->is_external)
18967 is_external = spec_die->is_external;
18971 /* Set default names for some unnamed DIEs. */
18973 if (name == NULL && tag == DW_TAG_namespace)
18974 name = CP_ANONYMOUS_NAMESPACE_STR;
18976 /* If there is no parent die to provide a namespace, and there are
18977 children, see if we can determine the namespace from their linkage
18979 if (cu->language == language_cplus
18980 && !VEC_empty (dwarf2_section_info_def,
18981 cu->per_cu->dwarf2_per_objfile->types)
18982 && die_parent == NULL
18984 && (tag == DW_TAG_class_type
18985 || tag == DW_TAG_structure_type
18986 || tag == DW_TAG_union_type))
18987 guess_partial_die_structure_name (this, cu);
18989 /* GCC might emit a nameless struct or union that has a linkage
18990 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18992 && (tag == DW_TAG_class_type
18993 || tag == DW_TAG_interface_type
18994 || tag == DW_TAG_structure_type
18995 || tag == DW_TAG_union_type)
18996 && linkage_name != NULL)
19000 demangled = gdb_demangle (linkage_name, DMGL_TYPES);
19005 /* Strip any leading namespaces/classes, keep only the base name.
19006 DW_AT_name for named DIEs does not contain the prefixes. */
19007 base = strrchr (demangled, ':');
19008 if (base && base > demangled && base[-1] == ':')
19013 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
19016 obstack_copy0 (&objfile->per_bfd->storage_obstack,
19017 base, strlen (base)));
19025 /* Read an attribute value described by an attribute form. */
19027 static const gdb_byte *
19028 read_attribute_value (const struct die_reader_specs *reader,
19029 struct attribute *attr, unsigned form,
19030 LONGEST implicit_const, const gdb_byte *info_ptr)
19032 struct dwarf2_cu *cu = reader->cu;
19033 struct dwarf2_per_objfile *dwarf2_per_objfile
19034 = cu->per_cu->dwarf2_per_objfile;
19035 struct objfile *objfile = dwarf2_per_objfile->objfile;
19036 struct gdbarch *gdbarch = get_objfile_arch (objfile);
19037 bfd *abfd = reader->abfd;
19038 struct comp_unit_head *cu_header = &cu->header;
19039 unsigned int bytes_read;
19040 struct dwarf_block *blk;
19042 attr->form = (enum dwarf_form) form;
19045 case DW_FORM_ref_addr:
19046 if (cu->header.version == 2)
19047 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19049 DW_UNSND (attr) = read_offset (abfd, info_ptr,
19050 &cu->header, &bytes_read);
19051 info_ptr += bytes_read;
19053 case DW_FORM_GNU_ref_alt:
19054 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19055 info_ptr += bytes_read;
19058 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19059 DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
19060 info_ptr += bytes_read;
19062 case DW_FORM_block2:
19063 blk = dwarf_alloc_block (cu);
19064 blk->size = read_2_bytes (abfd, info_ptr);
19066 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19067 info_ptr += blk->size;
19068 DW_BLOCK (attr) = blk;
19070 case DW_FORM_block4:
19071 blk = dwarf_alloc_block (cu);
19072 blk->size = read_4_bytes (abfd, info_ptr);
19074 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19075 info_ptr += blk->size;
19076 DW_BLOCK (attr) = blk;
19078 case DW_FORM_data2:
19079 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
19082 case DW_FORM_data4:
19083 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
19086 case DW_FORM_data8:
19087 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
19090 case DW_FORM_data16:
19091 blk = dwarf_alloc_block (cu);
19093 blk->data = read_n_bytes (abfd, info_ptr, 16);
19095 DW_BLOCK (attr) = blk;
19097 case DW_FORM_sec_offset:
19098 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19099 info_ptr += bytes_read;
19101 case DW_FORM_string:
19102 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
19103 DW_STRING_IS_CANONICAL (attr) = 0;
19104 info_ptr += bytes_read;
19107 if (!cu->per_cu->is_dwz)
19109 DW_STRING (attr) = read_indirect_string (dwarf2_per_objfile,
19110 abfd, info_ptr, cu_header,
19112 DW_STRING_IS_CANONICAL (attr) = 0;
19113 info_ptr += bytes_read;
19117 case DW_FORM_line_strp:
19118 if (!cu->per_cu->is_dwz)
19120 DW_STRING (attr) = read_indirect_line_string (dwarf2_per_objfile,
19122 cu_header, &bytes_read);
19123 DW_STRING_IS_CANONICAL (attr) = 0;
19124 info_ptr += bytes_read;
19128 case DW_FORM_GNU_strp_alt:
19130 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19131 LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
19134 DW_STRING (attr) = read_indirect_string_from_dwz (objfile,
19136 DW_STRING_IS_CANONICAL (attr) = 0;
19137 info_ptr += bytes_read;
19140 case DW_FORM_exprloc:
19141 case DW_FORM_block:
19142 blk = dwarf_alloc_block (cu);
19143 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19144 info_ptr += bytes_read;
19145 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19146 info_ptr += blk->size;
19147 DW_BLOCK (attr) = blk;
19149 case DW_FORM_block1:
19150 blk = dwarf_alloc_block (cu);
19151 blk->size = read_1_byte (abfd, info_ptr);
19153 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19154 info_ptr += blk->size;
19155 DW_BLOCK (attr) = blk;
19157 case DW_FORM_data1:
19158 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19162 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19165 case DW_FORM_flag_present:
19166 DW_UNSND (attr) = 1;
19168 case DW_FORM_sdata:
19169 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19170 info_ptr += bytes_read;
19172 case DW_FORM_udata:
19173 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19174 info_ptr += bytes_read;
19177 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19178 + read_1_byte (abfd, info_ptr));
19182 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19183 + read_2_bytes (abfd, info_ptr));
19187 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19188 + read_4_bytes (abfd, info_ptr));
19192 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19193 + read_8_bytes (abfd, info_ptr));
19196 case DW_FORM_ref_sig8:
19197 DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
19200 case DW_FORM_ref_udata:
19201 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19202 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
19203 info_ptr += bytes_read;
19205 case DW_FORM_indirect:
19206 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19207 info_ptr += bytes_read;
19208 if (form == DW_FORM_implicit_const)
19210 implicit_const = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19211 info_ptr += bytes_read;
19213 info_ptr = read_attribute_value (reader, attr, form, implicit_const,
19216 case DW_FORM_implicit_const:
19217 DW_SND (attr) = implicit_const;
19219 case DW_FORM_GNU_addr_index:
19220 if (reader->dwo_file == NULL)
19222 /* For now flag a hard error.
19223 Later we can turn this into a complaint. */
19224 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19225 dwarf_form_name (form),
19226 bfd_get_filename (abfd));
19228 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
19229 info_ptr += bytes_read;
19231 case DW_FORM_GNU_str_index:
19232 if (reader->dwo_file == NULL)
19234 /* For now flag a hard error.
19235 Later we can turn this into a complaint if warranted. */
19236 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19237 dwarf_form_name (form),
19238 bfd_get_filename (abfd));
19241 ULONGEST str_index =
19242 read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19244 DW_STRING (attr) = read_str_index (reader, str_index);
19245 DW_STRING_IS_CANONICAL (attr) = 0;
19246 info_ptr += bytes_read;
19250 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19251 dwarf_form_name (form),
19252 bfd_get_filename (abfd));
19256 if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
19257 attr->form = DW_FORM_GNU_ref_alt;
19259 /* We have seen instances where the compiler tried to emit a byte
19260 size attribute of -1 which ended up being encoded as an unsigned
19261 0xffffffff. Although 0xffffffff is technically a valid size value,
19262 an object of this size seems pretty unlikely so we can relatively
19263 safely treat these cases as if the size attribute was invalid and
19264 treat them as zero by default. */
19265 if (attr->name == DW_AT_byte_size
19266 && form == DW_FORM_data4
19267 && DW_UNSND (attr) >= 0xffffffff)
19270 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19271 hex_string (DW_UNSND (attr)));
19272 DW_UNSND (attr) = 0;
19278 /* Read an attribute described by an abbreviated attribute. */
19280 static const gdb_byte *
19281 read_attribute (const struct die_reader_specs *reader,
19282 struct attribute *attr, struct attr_abbrev *abbrev,
19283 const gdb_byte *info_ptr)
19285 attr->name = abbrev->name;
19286 return read_attribute_value (reader, attr, abbrev->form,
19287 abbrev->implicit_const, info_ptr);
19290 /* Read dwarf information from a buffer. */
19292 static unsigned int
19293 read_1_byte (bfd *abfd, const gdb_byte *buf)
19295 return bfd_get_8 (abfd, buf);
19299 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
19301 return bfd_get_signed_8 (abfd, buf);
19304 static unsigned int
19305 read_2_bytes (bfd *abfd, const gdb_byte *buf)
19307 return bfd_get_16 (abfd, buf);
19311 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
19313 return bfd_get_signed_16 (abfd, buf);
19316 static unsigned int
19317 read_4_bytes (bfd *abfd, const gdb_byte *buf)
19319 return bfd_get_32 (abfd, buf);
19323 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
19325 return bfd_get_signed_32 (abfd, buf);
19329 read_8_bytes (bfd *abfd, const gdb_byte *buf)
19331 return bfd_get_64 (abfd, buf);
19335 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
19336 unsigned int *bytes_read)
19338 struct comp_unit_head *cu_header = &cu->header;
19339 CORE_ADDR retval = 0;
19341 if (cu_header->signed_addr_p)
19343 switch (cu_header->addr_size)
19346 retval = bfd_get_signed_16 (abfd, buf);
19349 retval = bfd_get_signed_32 (abfd, buf);
19352 retval = bfd_get_signed_64 (abfd, buf);
19355 internal_error (__FILE__, __LINE__,
19356 _("read_address: bad switch, signed [in module %s]"),
19357 bfd_get_filename (abfd));
19362 switch (cu_header->addr_size)
19365 retval = bfd_get_16 (abfd, buf);
19368 retval = bfd_get_32 (abfd, buf);
19371 retval = bfd_get_64 (abfd, buf);
19374 internal_error (__FILE__, __LINE__,
19375 _("read_address: bad switch, "
19376 "unsigned [in module %s]"),
19377 bfd_get_filename (abfd));
19381 *bytes_read = cu_header->addr_size;
19385 /* Read the initial length from a section. The (draft) DWARF 3
19386 specification allows the initial length to take up either 4 bytes
19387 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19388 bytes describe the length and all offsets will be 8 bytes in length
19391 An older, non-standard 64-bit format is also handled by this
19392 function. The older format in question stores the initial length
19393 as an 8-byte quantity without an escape value. Lengths greater
19394 than 2^32 aren't very common which means that the initial 4 bytes
19395 is almost always zero. Since a length value of zero doesn't make
19396 sense for the 32-bit format, this initial zero can be considered to
19397 be an escape value which indicates the presence of the older 64-bit
19398 format. As written, the code can't detect (old format) lengths
19399 greater than 4GB. If it becomes necessary to handle lengths
19400 somewhat larger than 4GB, we could allow other small values (such
19401 as the non-sensical values of 1, 2, and 3) to also be used as
19402 escape values indicating the presence of the old format.
19404 The value returned via bytes_read should be used to increment the
19405 relevant pointer after calling read_initial_length().
19407 [ Note: read_initial_length() and read_offset() are based on the
19408 document entitled "DWARF Debugging Information Format", revision
19409 3, draft 8, dated November 19, 2001. This document was obtained
19412 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19414 This document is only a draft and is subject to change. (So beware.)
19416 Details regarding the older, non-standard 64-bit format were
19417 determined empirically by examining 64-bit ELF files produced by
19418 the SGI toolchain on an IRIX 6.5 machine.
19420 - Kevin, July 16, 2002
19424 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
19426 LONGEST length = bfd_get_32 (abfd, buf);
19428 if (length == 0xffffffff)
19430 length = bfd_get_64 (abfd, buf + 4);
19433 else if (length == 0)
19435 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19436 length = bfd_get_64 (abfd, buf);
19447 /* Cover function for read_initial_length.
19448 Returns the length of the object at BUF, and stores the size of the
19449 initial length in *BYTES_READ and stores the size that offsets will be in
19451 If the initial length size is not equivalent to that specified in
19452 CU_HEADER then issue a complaint.
19453 This is useful when reading non-comp-unit headers. */
19456 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
19457 const struct comp_unit_head *cu_header,
19458 unsigned int *bytes_read,
19459 unsigned int *offset_size)
19461 LONGEST length = read_initial_length (abfd, buf, bytes_read);
19463 gdb_assert (cu_header->initial_length_size == 4
19464 || cu_header->initial_length_size == 8
19465 || cu_header->initial_length_size == 12);
19467 if (cu_header->initial_length_size != *bytes_read)
19468 complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19470 *offset_size = (*bytes_read == 4) ? 4 : 8;
19474 /* Read an offset from the data stream. The size of the offset is
19475 given by cu_header->offset_size. */
19478 read_offset (bfd *abfd, const gdb_byte *buf,
19479 const struct comp_unit_head *cu_header,
19480 unsigned int *bytes_read)
19482 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
19484 *bytes_read = cu_header->offset_size;
19488 /* Read an offset from the data stream. */
19491 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
19493 LONGEST retval = 0;
19495 switch (offset_size)
19498 retval = bfd_get_32 (abfd, buf);
19501 retval = bfd_get_64 (abfd, buf);
19504 internal_error (__FILE__, __LINE__,
19505 _("read_offset_1: bad switch [in module %s]"),
19506 bfd_get_filename (abfd));
19512 static const gdb_byte *
19513 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
19515 /* If the size of a host char is 8 bits, we can return a pointer
19516 to the buffer, otherwise we have to copy the data to a buffer
19517 allocated on the temporary obstack. */
19518 gdb_assert (HOST_CHAR_BIT == 8);
19522 static const char *
19523 read_direct_string (bfd *abfd, const gdb_byte *buf,
19524 unsigned int *bytes_read_ptr)
19526 /* If the size of a host char is 8 bits, we can return a pointer
19527 to the string, otherwise we have to copy the string to a buffer
19528 allocated on the temporary obstack. */
19529 gdb_assert (HOST_CHAR_BIT == 8);
19532 *bytes_read_ptr = 1;
19535 *bytes_read_ptr = strlen ((const char *) buf) + 1;
19536 return (const char *) buf;
19539 /* Return pointer to string at section SECT offset STR_OFFSET with error
19540 reporting strings FORM_NAME and SECT_NAME. */
19542 static const char *
19543 read_indirect_string_at_offset_from (struct objfile *objfile,
19544 bfd *abfd, LONGEST str_offset,
19545 struct dwarf2_section_info *sect,
19546 const char *form_name,
19547 const char *sect_name)
19549 dwarf2_read_section (objfile, sect);
19550 if (sect->buffer == NULL)
19551 error (_("%s used without %s section [in module %s]"),
19552 form_name, sect_name, bfd_get_filename (abfd));
19553 if (str_offset >= sect->size)
19554 error (_("%s pointing outside of %s section [in module %s]"),
19555 form_name, sect_name, bfd_get_filename (abfd));
19556 gdb_assert (HOST_CHAR_BIT == 8);
19557 if (sect->buffer[str_offset] == '\0')
19559 return (const char *) (sect->buffer + str_offset);
19562 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19564 static const char *
19565 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19566 bfd *abfd, LONGEST str_offset)
19568 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19570 &dwarf2_per_objfile->str,
19571 "DW_FORM_strp", ".debug_str");
19574 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
19576 static const char *
19577 read_indirect_line_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19578 bfd *abfd, LONGEST str_offset)
19580 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19582 &dwarf2_per_objfile->line_str,
19583 "DW_FORM_line_strp",
19584 ".debug_line_str");
19587 /* Read a string at offset STR_OFFSET in the .debug_str section from
19588 the .dwz file DWZ. Throw an error if the offset is too large. If
19589 the string consists of a single NUL byte, return NULL; otherwise
19590 return a pointer to the string. */
19592 static const char *
19593 read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz,
19594 LONGEST str_offset)
19596 dwarf2_read_section (objfile, &dwz->str);
19598 if (dwz->str.buffer == NULL)
19599 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19600 "section [in module %s]"),
19601 bfd_get_filename (dwz->dwz_bfd));
19602 if (str_offset >= dwz->str.size)
19603 error (_("DW_FORM_GNU_strp_alt pointing outside of "
19604 ".debug_str section [in module %s]"),
19605 bfd_get_filename (dwz->dwz_bfd));
19606 gdb_assert (HOST_CHAR_BIT == 8);
19607 if (dwz->str.buffer[str_offset] == '\0')
19609 return (const char *) (dwz->str.buffer + str_offset);
19612 /* Return pointer to string at .debug_str offset as read from BUF.
19613 BUF is assumed to be in a compilation unit described by CU_HEADER.
19614 Return *BYTES_READ_PTR count of bytes read from BUF. */
19616 static const char *
19617 read_indirect_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
19618 const gdb_byte *buf,
19619 const struct comp_unit_head *cu_header,
19620 unsigned int *bytes_read_ptr)
19622 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19624 return read_indirect_string_at_offset (dwarf2_per_objfile, abfd, str_offset);
19627 /* Return pointer to string at .debug_line_str offset as read from BUF.
19628 BUF is assumed to be in a compilation unit described by CU_HEADER.
19629 Return *BYTES_READ_PTR count of bytes read from BUF. */
19631 static const char *
19632 read_indirect_line_string (struct dwarf2_per_objfile *dwarf2_per_objfile,
19633 bfd *abfd, const gdb_byte *buf,
19634 const struct comp_unit_head *cu_header,
19635 unsigned int *bytes_read_ptr)
19637 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19639 return read_indirect_line_string_at_offset (dwarf2_per_objfile, abfd,
19644 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
19645 unsigned int *bytes_read_ptr)
19648 unsigned int num_read;
19650 unsigned char byte;
19657 byte = bfd_get_8 (abfd, buf);
19660 result |= ((ULONGEST) (byte & 127) << shift);
19661 if ((byte & 128) == 0)
19667 *bytes_read_ptr = num_read;
19672 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
19673 unsigned int *bytes_read_ptr)
19676 int shift, num_read;
19677 unsigned char byte;
19684 byte = bfd_get_8 (abfd, buf);
19687 result |= ((ULONGEST) (byte & 127) << shift);
19689 if ((byte & 128) == 0)
19694 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
19695 result |= -(((ULONGEST) 1) << shift);
19696 *bytes_read_ptr = num_read;
19700 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19701 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19702 ADDR_SIZE is the size of addresses from the CU header. */
19705 read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
19706 unsigned int addr_index, ULONGEST addr_base, int addr_size)
19708 struct objfile *objfile = dwarf2_per_objfile->objfile;
19709 bfd *abfd = objfile->obfd;
19710 const gdb_byte *info_ptr;
19712 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
19713 if (dwarf2_per_objfile->addr.buffer == NULL)
19714 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19715 objfile_name (objfile));
19716 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
19717 error (_("DW_FORM_addr_index pointing outside of "
19718 ".debug_addr section [in module %s]"),
19719 objfile_name (objfile));
19720 info_ptr = (dwarf2_per_objfile->addr.buffer
19721 + addr_base + addr_index * addr_size);
19722 if (addr_size == 4)
19723 return bfd_get_32 (abfd, info_ptr);
19725 return bfd_get_64 (abfd, info_ptr);
19728 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
19731 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
19733 return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
19734 cu->addr_base, cu->header.addr_size);
19737 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
19740 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
19741 unsigned int *bytes_read)
19743 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
19744 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
19746 return read_addr_index (cu, addr_index);
19749 /* Data structure to pass results from dwarf2_read_addr_index_reader
19750 back to dwarf2_read_addr_index. */
19752 struct dwarf2_read_addr_index_data
19754 ULONGEST addr_base;
19758 /* die_reader_func for dwarf2_read_addr_index. */
19761 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
19762 const gdb_byte *info_ptr,
19763 struct die_info *comp_unit_die,
19767 struct dwarf2_cu *cu = reader->cu;
19768 struct dwarf2_read_addr_index_data *aidata =
19769 (struct dwarf2_read_addr_index_data *) data;
19771 aidata->addr_base = cu->addr_base;
19772 aidata->addr_size = cu->header.addr_size;
19775 /* Given an index in .debug_addr, fetch the value.
19776 NOTE: This can be called during dwarf expression evaluation,
19777 long after the debug information has been read, and thus per_cu->cu
19778 may no longer exist. */
19781 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
19782 unsigned int addr_index)
19784 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
19785 struct dwarf2_cu *cu = per_cu->cu;
19786 ULONGEST addr_base;
19789 /* We need addr_base and addr_size.
19790 If we don't have PER_CU->cu, we have to get it.
19791 Nasty, but the alternative is storing the needed info in PER_CU,
19792 which at this point doesn't seem justified: it's not clear how frequently
19793 it would get used and it would increase the size of every PER_CU.
19794 Entry points like dwarf2_per_cu_addr_size do a similar thing
19795 so we're not in uncharted territory here.
19796 Alas we need to be a bit more complicated as addr_base is contained
19799 We don't need to read the entire CU(/TU).
19800 We just need the header and top level die.
19802 IWBN to use the aging mechanism to let us lazily later discard the CU.
19803 For now we skip this optimization. */
19807 addr_base = cu->addr_base;
19808 addr_size = cu->header.addr_size;
19812 struct dwarf2_read_addr_index_data aidata;
19814 /* Note: We can't use init_cutu_and_read_dies_simple here,
19815 we need addr_base. */
19816 init_cutu_and_read_dies (per_cu, NULL, 0, 0, false,
19817 dwarf2_read_addr_index_reader, &aidata);
19818 addr_base = aidata.addr_base;
19819 addr_size = aidata.addr_size;
19822 return read_addr_index_1 (dwarf2_per_objfile, addr_index, addr_base,
19826 /* Given a DW_FORM_GNU_str_index, fetch the string.
19827 This is only used by the Fission support. */
19829 static const char *
19830 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
19832 struct dwarf2_cu *cu = reader->cu;
19833 struct dwarf2_per_objfile *dwarf2_per_objfile
19834 = cu->per_cu->dwarf2_per_objfile;
19835 struct objfile *objfile = dwarf2_per_objfile->objfile;
19836 const char *objf_name = objfile_name (objfile);
19837 bfd *abfd = objfile->obfd;
19838 struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
19839 struct dwarf2_section_info *str_offsets_section =
19840 &reader->dwo_file->sections.str_offsets;
19841 const gdb_byte *info_ptr;
19842 ULONGEST str_offset;
19843 static const char form_name[] = "DW_FORM_GNU_str_index";
19845 dwarf2_read_section (objfile, str_section);
19846 dwarf2_read_section (objfile, str_offsets_section);
19847 if (str_section->buffer == NULL)
19848 error (_("%s used without .debug_str.dwo section"
19849 " in CU at offset %s [in module %s]"),
19850 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19851 if (str_offsets_section->buffer == NULL)
19852 error (_("%s used without .debug_str_offsets.dwo section"
19853 " in CU at offset %s [in module %s]"),
19854 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19855 if (str_index * cu->header.offset_size >= str_offsets_section->size)
19856 error (_("%s pointing outside of .debug_str_offsets.dwo"
19857 " section in CU at offset %s [in module %s]"),
19858 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19859 info_ptr = (str_offsets_section->buffer
19860 + str_index * cu->header.offset_size);
19861 if (cu->header.offset_size == 4)
19862 str_offset = bfd_get_32 (abfd, info_ptr);
19864 str_offset = bfd_get_64 (abfd, info_ptr);
19865 if (str_offset >= str_section->size)
19866 error (_("Offset from %s pointing outside of"
19867 " .debug_str.dwo section in CU at offset %s [in module %s]"),
19868 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19869 return (const char *) (str_section->buffer + str_offset);
19872 /* Return the length of an LEB128 number in BUF. */
19875 leb128_size (const gdb_byte *buf)
19877 const gdb_byte *begin = buf;
19883 if ((byte & 128) == 0)
19884 return buf - begin;
19889 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
19898 cu->language = language_c;
19901 case DW_LANG_C_plus_plus:
19902 case DW_LANG_C_plus_plus_11:
19903 case DW_LANG_C_plus_plus_14:
19904 cu->language = language_cplus;
19907 cu->language = language_d;
19909 case DW_LANG_Fortran77:
19910 case DW_LANG_Fortran90:
19911 case DW_LANG_Fortran95:
19912 case DW_LANG_Fortran03:
19913 case DW_LANG_Fortran08:
19914 cu->language = language_fortran;
19917 cu->language = language_go;
19919 case DW_LANG_Mips_Assembler:
19920 cu->language = language_asm;
19922 case DW_LANG_Ada83:
19923 case DW_LANG_Ada95:
19924 cu->language = language_ada;
19926 case DW_LANG_Modula2:
19927 cu->language = language_m2;
19929 case DW_LANG_Pascal83:
19930 cu->language = language_pascal;
19933 cu->language = language_objc;
19936 case DW_LANG_Rust_old:
19937 cu->language = language_rust;
19939 case DW_LANG_Cobol74:
19940 case DW_LANG_Cobol85:
19942 cu->language = language_minimal;
19945 cu->language_defn = language_def (cu->language);
19948 /* Return the named attribute or NULL if not there. */
19950 static struct attribute *
19951 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
19956 struct attribute *spec = NULL;
19958 for (i = 0; i < die->num_attrs; ++i)
19960 if (die->attrs[i].name == name)
19961 return &die->attrs[i];
19962 if (die->attrs[i].name == DW_AT_specification
19963 || die->attrs[i].name == DW_AT_abstract_origin)
19964 spec = &die->attrs[i];
19970 die = follow_die_ref (die, spec, &cu);
19976 /* Return the named attribute or NULL if not there,
19977 but do not follow DW_AT_specification, etc.
19978 This is for use in contexts where we're reading .debug_types dies.
19979 Following DW_AT_specification, DW_AT_abstract_origin will take us
19980 back up the chain, and we want to go down. */
19982 static struct attribute *
19983 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
19987 for (i = 0; i < die->num_attrs; ++i)
19988 if (die->attrs[i].name == name)
19989 return &die->attrs[i];
19994 /* Return the string associated with a string-typed attribute, or NULL if it
19995 is either not found or is of an incorrect type. */
19997 static const char *
19998 dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
20000 struct attribute *attr;
20001 const char *str = NULL;
20003 attr = dwarf2_attr (die, name, cu);
20007 if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp
20008 || attr->form == DW_FORM_string
20009 || attr->form == DW_FORM_GNU_str_index
20010 || attr->form == DW_FORM_GNU_strp_alt)
20011 str = DW_STRING (attr);
20013 complaint (_("string type expected for attribute %s for "
20014 "DIE at %s in module %s"),
20015 dwarf_attr_name (name), sect_offset_str (die->sect_off),
20016 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
20022 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20023 and holds a non-zero value. This function should only be used for
20024 DW_FORM_flag or DW_FORM_flag_present attributes. */
20027 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
20029 struct attribute *attr = dwarf2_attr (die, name, cu);
20031 return (attr && DW_UNSND (attr));
20035 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
20037 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20038 which value is non-zero. However, we have to be careful with
20039 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20040 (via dwarf2_flag_true_p) follows this attribute. So we may
20041 end up accidently finding a declaration attribute that belongs
20042 to a different DIE referenced by the specification attribute,
20043 even though the given DIE does not have a declaration attribute. */
20044 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
20045 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
20048 /* Return the die giving the specification for DIE, if there is
20049 one. *SPEC_CU is the CU containing DIE on input, and the CU
20050 containing the return value on output. If there is no
20051 specification, but there is an abstract origin, that is
20054 static struct die_info *
20055 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
20057 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
20060 if (spec_attr == NULL)
20061 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
20063 if (spec_attr == NULL)
20066 return follow_die_ref (die, spec_attr, spec_cu);
20069 /* Stub for free_line_header to match void * callback types. */
20072 free_line_header_voidp (void *arg)
20074 struct line_header *lh = (struct line_header *) arg;
20080 line_header::add_include_dir (const char *include_dir)
20082 if (dwarf_line_debug >= 2)
20083 fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
20084 include_dirs.size () + 1, include_dir);
20086 include_dirs.push_back (include_dir);
20090 line_header::add_file_name (const char *name,
20092 unsigned int mod_time,
20093 unsigned int length)
20095 if (dwarf_line_debug >= 2)
20096 fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
20097 (unsigned) file_names.size () + 1, name);
20099 file_names.emplace_back (name, d_index, mod_time, length);
20102 /* A convenience function to find the proper .debug_line section for a CU. */
20104 static struct dwarf2_section_info *
20105 get_debug_line_section (struct dwarf2_cu *cu)
20107 struct dwarf2_section_info *section;
20108 struct dwarf2_per_objfile *dwarf2_per_objfile
20109 = cu->per_cu->dwarf2_per_objfile;
20111 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20113 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20114 section = &cu->dwo_unit->dwo_file->sections.line;
20115 else if (cu->per_cu->is_dwz)
20117 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
20119 section = &dwz->line;
20122 section = &dwarf2_per_objfile->line;
20127 /* Read directory or file name entry format, starting with byte of
20128 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20129 entries count and the entries themselves in the described entry
20133 read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
20134 bfd *abfd, const gdb_byte **bufp,
20135 struct line_header *lh,
20136 const struct comp_unit_head *cu_header,
20137 void (*callback) (struct line_header *lh,
20140 unsigned int mod_time,
20141 unsigned int length))
20143 gdb_byte format_count, formati;
20144 ULONGEST data_count, datai;
20145 const gdb_byte *buf = *bufp;
20146 const gdb_byte *format_header_data;
20147 unsigned int bytes_read;
20149 format_count = read_1_byte (abfd, buf);
20151 format_header_data = buf;
20152 for (formati = 0; formati < format_count; formati++)
20154 read_unsigned_leb128 (abfd, buf, &bytes_read);
20156 read_unsigned_leb128 (abfd, buf, &bytes_read);
20160 data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
20162 for (datai = 0; datai < data_count; datai++)
20164 const gdb_byte *format = format_header_data;
20165 struct file_entry fe;
20167 for (formati = 0; formati < format_count; formati++)
20169 ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
20170 format += bytes_read;
20172 ULONGEST form = read_unsigned_leb128 (abfd, format, &bytes_read);
20173 format += bytes_read;
20175 gdb::optional<const char *> string;
20176 gdb::optional<unsigned int> uint;
20180 case DW_FORM_string:
20181 string.emplace (read_direct_string (abfd, buf, &bytes_read));
20185 case DW_FORM_line_strp:
20186 string.emplace (read_indirect_line_string (dwarf2_per_objfile,
20193 case DW_FORM_data1:
20194 uint.emplace (read_1_byte (abfd, buf));
20198 case DW_FORM_data2:
20199 uint.emplace (read_2_bytes (abfd, buf));
20203 case DW_FORM_data4:
20204 uint.emplace (read_4_bytes (abfd, buf));
20208 case DW_FORM_data8:
20209 uint.emplace (read_8_bytes (abfd, buf));
20213 case DW_FORM_udata:
20214 uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
20218 case DW_FORM_block:
20219 /* It is valid only for DW_LNCT_timestamp which is ignored by
20224 switch (content_type)
20227 if (string.has_value ())
20230 case DW_LNCT_directory_index:
20231 if (uint.has_value ())
20232 fe.d_index = (dir_index) *uint;
20234 case DW_LNCT_timestamp:
20235 if (uint.has_value ())
20236 fe.mod_time = *uint;
20239 if (uint.has_value ())
20245 complaint (_("Unknown format content type %s"),
20246 pulongest (content_type));
20250 callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
20256 /* Read the statement program header starting at OFFSET in
20257 .debug_line, or .debug_line.dwo. Return a pointer
20258 to a struct line_header, allocated using xmalloc.
20259 Returns NULL if there is a problem reading the header, e.g., if it
20260 has a version we don't understand.
20262 NOTE: the strings in the include directory and file name tables of
20263 the returned object point into the dwarf line section buffer,
20264 and must not be freed. */
20266 static line_header_up
20267 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
20269 const gdb_byte *line_ptr;
20270 unsigned int bytes_read, offset_size;
20272 const char *cur_dir, *cur_file;
20273 struct dwarf2_section_info *section;
20275 struct dwarf2_per_objfile *dwarf2_per_objfile
20276 = cu->per_cu->dwarf2_per_objfile;
20278 section = get_debug_line_section (cu);
20279 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20280 if (section->buffer == NULL)
20282 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20283 complaint (_("missing .debug_line.dwo section"));
20285 complaint (_("missing .debug_line section"));
20289 /* We can't do this until we know the section is non-empty.
20290 Only then do we know we have such a section. */
20291 abfd = get_section_bfd_owner (section);
20293 /* Make sure that at least there's room for the total_length field.
20294 That could be 12 bytes long, but we're just going to fudge that. */
20295 if (to_underlying (sect_off) + 4 >= section->size)
20297 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20301 line_header_up lh (new line_header ());
20303 lh->sect_off = sect_off;
20304 lh->offset_in_dwz = cu->per_cu->is_dwz;
20306 line_ptr = section->buffer + to_underlying (sect_off);
20308 /* Read in the header. */
20310 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
20311 &bytes_read, &offset_size);
20312 line_ptr += bytes_read;
20313 if (line_ptr + lh->total_length > (section->buffer + section->size))
20315 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20318 lh->statement_program_end = line_ptr + lh->total_length;
20319 lh->version = read_2_bytes (abfd, line_ptr);
20321 if (lh->version > 5)
20323 /* This is a version we don't understand. The format could have
20324 changed in ways we don't handle properly so just punt. */
20325 complaint (_("unsupported version in .debug_line section"));
20328 if (lh->version >= 5)
20330 gdb_byte segment_selector_size;
20332 /* Skip address size. */
20333 read_1_byte (abfd, line_ptr);
20336 segment_selector_size = read_1_byte (abfd, line_ptr);
20338 if (segment_selector_size != 0)
20340 complaint (_("unsupported segment selector size %u "
20341 "in .debug_line section"),
20342 segment_selector_size);
20346 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
20347 line_ptr += offset_size;
20348 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
20350 if (lh->version >= 4)
20352 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
20356 lh->maximum_ops_per_instruction = 1;
20358 if (lh->maximum_ops_per_instruction == 0)
20360 lh->maximum_ops_per_instruction = 1;
20361 complaint (_("invalid maximum_ops_per_instruction "
20362 "in `.debug_line' section"));
20365 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
20367 lh->line_base = read_1_signed_byte (abfd, line_ptr);
20369 lh->line_range = read_1_byte (abfd, line_ptr);
20371 lh->opcode_base = read_1_byte (abfd, line_ptr);
20373 lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
20375 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
20376 for (i = 1; i < lh->opcode_base; ++i)
20378 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
20382 if (lh->version >= 5)
20384 /* Read directory table. */
20385 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20387 [] (struct line_header *header, const char *name,
20388 dir_index d_index, unsigned int mod_time,
20389 unsigned int length)
20391 header->add_include_dir (name);
20394 /* Read file name table. */
20395 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20397 [] (struct line_header *header, const char *name,
20398 dir_index d_index, unsigned int mod_time,
20399 unsigned int length)
20401 header->add_file_name (name, d_index, mod_time, length);
20406 /* Read directory table. */
20407 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20409 line_ptr += bytes_read;
20410 lh->add_include_dir (cur_dir);
20412 line_ptr += bytes_read;
20414 /* Read file name table. */
20415 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20417 unsigned int mod_time, length;
20420 line_ptr += bytes_read;
20421 d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20422 line_ptr += bytes_read;
20423 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20424 line_ptr += bytes_read;
20425 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20426 line_ptr += bytes_read;
20428 lh->add_file_name (cur_file, d_index, mod_time, length);
20430 line_ptr += bytes_read;
20432 lh->statement_program_start = line_ptr;
20434 if (line_ptr > (section->buffer + section->size))
20435 complaint (_("line number info header doesn't "
20436 "fit in `.debug_line' section"));
20441 /* Subroutine of dwarf_decode_lines to simplify it.
20442 Return the file name of the psymtab for included file FILE_INDEX
20443 in line header LH of PST.
20444 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20445 If space for the result is malloc'd, *NAME_HOLDER will be set.
20446 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20448 static const char *
20449 psymtab_include_file_name (const struct line_header *lh, int file_index,
20450 const struct partial_symtab *pst,
20451 const char *comp_dir,
20452 gdb::unique_xmalloc_ptr<char> *name_holder)
20454 const file_entry &fe = lh->file_names[file_index];
20455 const char *include_name = fe.name;
20456 const char *include_name_to_compare = include_name;
20457 const char *pst_filename;
20460 const char *dir_name = fe.include_dir (lh);
20462 gdb::unique_xmalloc_ptr<char> hold_compare;
20463 if (!IS_ABSOLUTE_PATH (include_name)
20464 && (dir_name != NULL || comp_dir != NULL))
20466 /* Avoid creating a duplicate psymtab for PST.
20467 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20468 Before we do the comparison, however, we need to account
20469 for DIR_NAME and COMP_DIR.
20470 First prepend dir_name (if non-NULL). If we still don't
20471 have an absolute path prepend comp_dir (if non-NULL).
20472 However, the directory we record in the include-file's
20473 psymtab does not contain COMP_DIR (to match the
20474 corresponding symtab(s)).
20479 bash$ gcc -g ./hello.c
20480 include_name = "hello.c"
20482 DW_AT_comp_dir = comp_dir = "/tmp"
20483 DW_AT_name = "./hello.c"
20487 if (dir_name != NULL)
20489 name_holder->reset (concat (dir_name, SLASH_STRING,
20490 include_name, (char *) NULL));
20491 include_name = name_holder->get ();
20492 include_name_to_compare = include_name;
20494 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
20496 hold_compare.reset (concat (comp_dir, SLASH_STRING,
20497 include_name, (char *) NULL));
20498 include_name_to_compare = hold_compare.get ();
20502 pst_filename = pst->filename;
20503 gdb::unique_xmalloc_ptr<char> copied_name;
20504 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
20506 copied_name.reset (concat (pst->dirname, SLASH_STRING,
20507 pst_filename, (char *) NULL));
20508 pst_filename = copied_name.get ();
20511 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
20515 return include_name;
20518 /* State machine to track the state of the line number program. */
20520 class lnp_state_machine
20523 /* Initialize a machine state for the start of a line number
20525 lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch, line_header *lh,
20526 bool record_lines_p);
20528 file_entry *current_file ()
20530 /* lh->file_names is 0-based, but the file name numbers in the
20531 statement program are 1-based. */
20532 return m_line_header->file_name_at (m_file);
20535 /* Record the line in the state machine. END_SEQUENCE is true if
20536 we're processing the end of a sequence. */
20537 void record_line (bool end_sequence);
20539 /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20540 nop-out rest of the lines in this sequence. */
20541 void check_line_address (struct dwarf2_cu *cu,
20542 const gdb_byte *line_ptr,
20543 CORE_ADDR unrelocated_lowpc, CORE_ADDR address);
20545 void handle_set_discriminator (unsigned int discriminator)
20547 m_discriminator = discriminator;
20548 m_line_has_non_zero_discriminator |= discriminator != 0;
20551 /* Handle DW_LNE_set_address. */
20552 void handle_set_address (CORE_ADDR baseaddr, CORE_ADDR address)
20555 address += baseaddr;
20556 m_address = gdbarch_adjust_dwarf2_line (m_gdbarch, address, false);
20559 /* Handle DW_LNS_advance_pc. */
20560 void handle_advance_pc (CORE_ADDR adjust);
20562 /* Handle a special opcode. */
20563 void handle_special_opcode (unsigned char op_code);
20565 /* Handle DW_LNS_advance_line. */
20566 void handle_advance_line (int line_delta)
20568 advance_line (line_delta);
20571 /* Handle DW_LNS_set_file. */
20572 void handle_set_file (file_name_index file);
20574 /* Handle DW_LNS_negate_stmt. */
20575 void handle_negate_stmt ()
20577 m_is_stmt = !m_is_stmt;
20580 /* Handle DW_LNS_const_add_pc. */
20581 void handle_const_add_pc ();
20583 /* Handle DW_LNS_fixed_advance_pc. */
20584 void handle_fixed_advance_pc (CORE_ADDR addr_adj)
20586 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20590 /* Handle DW_LNS_copy. */
20591 void handle_copy ()
20593 record_line (false);
20594 m_discriminator = 0;
20597 /* Handle DW_LNE_end_sequence. */
20598 void handle_end_sequence ()
20600 m_currently_recording_lines = true;
20604 /* Advance the line by LINE_DELTA. */
20605 void advance_line (int line_delta)
20607 m_line += line_delta;
20609 if (line_delta != 0)
20610 m_line_has_non_zero_discriminator = m_discriminator != 0;
20613 struct dwarf2_cu *m_cu;
20615 gdbarch *m_gdbarch;
20617 /* True if we're recording lines.
20618 Otherwise we're building partial symtabs and are just interested in
20619 finding include files mentioned by the line number program. */
20620 bool m_record_lines_p;
20622 /* The line number header. */
20623 line_header *m_line_header;
20625 /* These are part of the standard DWARF line number state machine,
20626 and initialized according to the DWARF spec. */
20628 unsigned char m_op_index = 0;
20629 /* The line table index (1-based) of the current file. */
20630 file_name_index m_file = (file_name_index) 1;
20631 unsigned int m_line = 1;
20633 /* These are initialized in the constructor. */
20635 CORE_ADDR m_address;
20637 unsigned int m_discriminator;
20639 /* Additional bits of state we need to track. */
20641 /* The last file that we called dwarf2_start_subfile for.
20642 This is only used for TLLs. */
20643 unsigned int m_last_file = 0;
20644 /* The last file a line number was recorded for. */
20645 struct subfile *m_last_subfile = NULL;
20647 /* When true, record the lines we decode. */
20648 bool m_currently_recording_lines = false;
20650 /* The last line number that was recorded, used to coalesce
20651 consecutive entries for the same line. This can happen, for
20652 example, when discriminators are present. PR 17276. */
20653 unsigned int m_last_line = 0;
20654 bool m_line_has_non_zero_discriminator = false;
20658 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust)
20660 CORE_ADDR addr_adj = (((m_op_index + adjust)
20661 / m_line_header->maximum_ops_per_instruction)
20662 * m_line_header->minimum_instruction_length);
20663 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20664 m_op_index = ((m_op_index + adjust)
20665 % m_line_header->maximum_ops_per_instruction);
20669 lnp_state_machine::handle_special_opcode (unsigned char op_code)
20671 unsigned char adj_opcode = op_code - m_line_header->opcode_base;
20672 CORE_ADDR addr_adj = (((m_op_index
20673 + (adj_opcode / m_line_header->line_range))
20674 / m_line_header->maximum_ops_per_instruction)
20675 * m_line_header->minimum_instruction_length);
20676 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20677 m_op_index = ((m_op_index + (adj_opcode / m_line_header->line_range))
20678 % m_line_header->maximum_ops_per_instruction);
20680 int line_delta = (m_line_header->line_base
20681 + (adj_opcode % m_line_header->line_range));
20682 advance_line (line_delta);
20683 record_line (false);
20684 m_discriminator = 0;
20688 lnp_state_machine::handle_set_file (file_name_index file)
20692 const file_entry *fe = current_file ();
20694 dwarf2_debug_line_missing_file_complaint ();
20695 else if (m_record_lines_p)
20697 const char *dir = fe->include_dir (m_line_header);
20699 m_last_subfile = m_cu->builder->get_current_subfile ();
20700 m_line_has_non_zero_discriminator = m_discriminator != 0;
20701 dwarf2_start_subfile (m_cu, fe->name, dir);
20706 lnp_state_machine::handle_const_add_pc ()
20709 = (255 - m_line_header->opcode_base) / m_line_header->line_range;
20712 = (((m_op_index + adjust)
20713 / m_line_header->maximum_ops_per_instruction)
20714 * m_line_header->minimum_instruction_length);
20716 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20717 m_op_index = ((m_op_index + adjust)
20718 % m_line_header->maximum_ops_per_instruction);
20721 /* Return non-zero if we should add LINE to the line number table.
20722 LINE is the line to add, LAST_LINE is the last line that was added,
20723 LAST_SUBFILE is the subfile for LAST_LINE.
20724 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20725 had a non-zero discriminator.
20727 We have to be careful in the presence of discriminators.
20728 E.g., for this line:
20730 for (i = 0; i < 100000; i++);
20732 clang can emit four line number entries for that one line,
20733 each with a different discriminator.
20734 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20736 However, we want gdb to coalesce all four entries into one.
20737 Otherwise the user could stepi into the middle of the line and
20738 gdb would get confused about whether the pc really was in the
20739 middle of the line.
20741 Things are further complicated by the fact that two consecutive
20742 line number entries for the same line is a heuristic used by gcc
20743 to denote the end of the prologue. So we can't just discard duplicate
20744 entries, we have to be selective about it. The heuristic we use is
20745 that we only collapse consecutive entries for the same line if at least
20746 one of those entries has a non-zero discriminator. PR 17276.
20748 Note: Addresses in the line number state machine can never go backwards
20749 within one sequence, thus this coalescing is ok. */
20752 dwarf_record_line_p (struct dwarf2_cu *cu,
20753 unsigned int line, unsigned int last_line,
20754 int line_has_non_zero_discriminator,
20755 struct subfile *last_subfile)
20757 if (cu->builder->get_current_subfile () != last_subfile)
20759 if (line != last_line)
20761 /* Same line for the same file that we've seen already.
20762 As a last check, for pr 17276, only record the line if the line
20763 has never had a non-zero discriminator. */
20764 if (!line_has_non_zero_discriminator)
20769 /* Use the CU's builder to record line number LINE beginning at
20770 address ADDRESS in the line table of subfile SUBFILE. */
20773 dwarf_record_line_1 (struct gdbarch *gdbarch, struct subfile *subfile,
20774 unsigned int line, CORE_ADDR address,
20775 struct dwarf2_cu *cu)
20777 CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
20779 if (dwarf_line_debug)
20781 fprintf_unfiltered (gdb_stdlog,
20782 "Recording line %u, file %s, address %s\n",
20783 line, lbasename (subfile->name),
20784 paddress (gdbarch, address));
20788 cu->builder->record_line (subfile, line, addr);
20791 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20792 Mark the end of a set of line number records.
20793 The arguments are the same as for dwarf_record_line_1.
20794 If SUBFILE is NULL the request is ignored. */
20797 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
20798 CORE_ADDR address, struct dwarf2_cu *cu)
20800 if (subfile == NULL)
20803 if (dwarf_line_debug)
20805 fprintf_unfiltered (gdb_stdlog,
20806 "Finishing current line, file %s, address %s\n",
20807 lbasename (subfile->name),
20808 paddress (gdbarch, address));
20811 dwarf_record_line_1 (gdbarch, subfile, 0, address, cu);
20815 lnp_state_machine::record_line (bool end_sequence)
20817 if (dwarf_line_debug)
20819 fprintf_unfiltered (gdb_stdlog,
20820 "Processing actual line %u: file %u,"
20821 " address %s, is_stmt %u, discrim %u\n",
20822 m_line, to_underlying (m_file),
20823 paddress (m_gdbarch, m_address),
20824 m_is_stmt, m_discriminator);
20827 file_entry *fe = current_file ();
20830 dwarf2_debug_line_missing_file_complaint ();
20831 /* For now we ignore lines not starting on an instruction boundary.
20832 But not when processing end_sequence for compatibility with the
20833 previous version of the code. */
20834 else if (m_op_index == 0 || end_sequence)
20836 fe->included_p = 1;
20837 if (m_record_lines_p && (producer_is_codewarrior (m_cu) || m_is_stmt))
20839 if (m_last_subfile != m_cu->builder->get_current_subfile ()
20842 dwarf_finish_line (m_gdbarch, m_last_subfile, m_address,
20843 m_currently_recording_lines ? m_cu : nullptr);
20848 if (dwarf_record_line_p (m_cu, m_line, m_last_line,
20849 m_line_has_non_zero_discriminator,
20852 dwarf_record_line_1 (m_gdbarch,
20853 m_cu->builder->get_current_subfile (),
20855 m_currently_recording_lines ? m_cu : nullptr);
20857 m_last_subfile = m_cu->builder->get_current_subfile ();
20858 m_last_line = m_line;
20864 lnp_state_machine::lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch,
20865 line_header *lh, bool record_lines_p)
20869 m_record_lines_p = record_lines_p;
20870 m_line_header = lh;
20872 m_currently_recording_lines = true;
20874 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20875 was a line entry for it so that the backend has a chance to adjust it
20876 and also record it in case it needs it. This is currently used by MIPS
20877 code, cf. `mips_adjust_dwarf2_line'. */
20878 m_address = gdbarch_adjust_dwarf2_line (arch, 0, 0);
20879 m_is_stmt = lh->default_is_stmt;
20880 m_discriminator = 0;
20884 lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
20885 const gdb_byte *line_ptr,
20886 CORE_ADDR unrelocated_lowpc, CORE_ADDR address)
20888 /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
20889 the pc range of the CU. However, we restrict the test to only ADDRESS
20890 values of zero to preserve GDB's previous behaviour which is to handle
20891 the specific case of a function being GC'd by the linker. */
20893 if (address == 0 && address < unrelocated_lowpc)
20895 /* This line table is for a function which has been
20896 GCd by the linker. Ignore it. PR gdb/12528 */
20898 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20899 long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
20901 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20902 line_offset, objfile_name (objfile));
20903 m_currently_recording_lines = false;
20904 /* Note: m_currently_recording_lines is left as false until we see
20905 DW_LNE_end_sequence. */
20909 /* Subroutine of dwarf_decode_lines to simplify it.
20910 Process the line number information in LH.
20911 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20912 program in order to set included_p for every referenced header. */
20915 dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
20916 const int decode_for_pst_p, CORE_ADDR lowpc)
20918 const gdb_byte *line_ptr, *extended_end;
20919 const gdb_byte *line_end;
20920 unsigned int bytes_read, extended_len;
20921 unsigned char op_code, extended_op;
20922 CORE_ADDR baseaddr;
20923 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20924 bfd *abfd = objfile->obfd;
20925 struct gdbarch *gdbarch = get_objfile_arch (objfile);
20926 /* True if we're recording line info (as opposed to building partial
20927 symtabs and just interested in finding include files mentioned by
20928 the line number program). */
20929 bool record_lines_p = !decode_for_pst_p;
20931 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
20933 line_ptr = lh->statement_program_start;
20934 line_end = lh->statement_program_end;
20936 /* Read the statement sequences until there's nothing left. */
20937 while (line_ptr < line_end)
20939 /* The DWARF line number program state machine. Reset the state
20940 machine at the start of each sequence. */
20941 lnp_state_machine state_machine (cu, gdbarch, lh, record_lines_p);
20942 bool end_sequence = false;
20944 if (record_lines_p)
20946 /* Start a subfile for the current file of the state
20948 const file_entry *fe = state_machine.current_file ();
20951 dwarf2_start_subfile (cu, fe->name, fe->include_dir (lh));
20954 /* Decode the table. */
20955 while (line_ptr < line_end && !end_sequence)
20957 op_code = read_1_byte (abfd, line_ptr);
20960 if (op_code >= lh->opcode_base)
20962 /* Special opcode. */
20963 state_machine.handle_special_opcode (op_code);
20965 else switch (op_code)
20967 case DW_LNS_extended_op:
20968 extended_len = read_unsigned_leb128 (abfd, line_ptr,
20970 line_ptr += bytes_read;
20971 extended_end = line_ptr + extended_len;
20972 extended_op = read_1_byte (abfd, line_ptr);
20974 switch (extended_op)
20976 case DW_LNE_end_sequence:
20977 state_machine.handle_end_sequence ();
20978 end_sequence = true;
20980 case DW_LNE_set_address:
20983 = read_address (abfd, line_ptr, cu, &bytes_read);
20984 line_ptr += bytes_read;
20986 state_machine.check_line_address (cu, line_ptr,
20987 lowpc - baseaddr, address);
20988 state_machine.handle_set_address (baseaddr, address);
20991 case DW_LNE_define_file:
20993 const char *cur_file;
20994 unsigned int mod_time, length;
20997 cur_file = read_direct_string (abfd, line_ptr,
20999 line_ptr += bytes_read;
21000 dindex = (dir_index)
21001 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21002 line_ptr += bytes_read;
21004 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21005 line_ptr += bytes_read;
21007 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21008 line_ptr += bytes_read;
21009 lh->add_file_name (cur_file, dindex, mod_time, length);
21012 case DW_LNE_set_discriminator:
21014 /* The discriminator is not interesting to the
21015 debugger; just ignore it. We still need to
21016 check its value though:
21017 if there are consecutive entries for the same
21018 (non-prologue) line we want to coalesce them.
21021 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21022 line_ptr += bytes_read;
21024 state_machine.handle_set_discriminator (discr);
21028 complaint (_("mangled .debug_line section"));
21031 /* Make sure that we parsed the extended op correctly. If e.g.
21032 we expected a different address size than the producer used,
21033 we may have read the wrong number of bytes. */
21034 if (line_ptr != extended_end)
21036 complaint (_("mangled .debug_line section"));
21041 state_machine.handle_copy ();
21043 case DW_LNS_advance_pc:
21046 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21047 line_ptr += bytes_read;
21049 state_machine.handle_advance_pc (adjust);
21052 case DW_LNS_advance_line:
21055 = read_signed_leb128 (abfd, line_ptr, &bytes_read);
21056 line_ptr += bytes_read;
21058 state_machine.handle_advance_line (line_delta);
21061 case DW_LNS_set_file:
21063 file_name_index file
21064 = (file_name_index) read_unsigned_leb128 (abfd, line_ptr,
21066 line_ptr += bytes_read;
21068 state_machine.handle_set_file (file);
21071 case DW_LNS_set_column:
21072 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21073 line_ptr += bytes_read;
21075 case DW_LNS_negate_stmt:
21076 state_machine.handle_negate_stmt ();
21078 case DW_LNS_set_basic_block:
21080 /* Add to the address register of the state machine the
21081 address increment value corresponding to special opcode
21082 255. I.e., this value is scaled by the minimum
21083 instruction length since special opcode 255 would have
21084 scaled the increment. */
21085 case DW_LNS_const_add_pc:
21086 state_machine.handle_const_add_pc ();
21088 case DW_LNS_fixed_advance_pc:
21090 CORE_ADDR addr_adj = read_2_bytes (abfd, line_ptr);
21093 state_machine.handle_fixed_advance_pc (addr_adj);
21098 /* Unknown standard opcode, ignore it. */
21101 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
21103 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21104 line_ptr += bytes_read;
21111 dwarf2_debug_line_missing_end_sequence_complaint ();
21113 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21114 in which case we still finish recording the last line). */
21115 state_machine.record_line (true);
21119 /* Decode the Line Number Program (LNP) for the given line_header
21120 structure and CU. The actual information extracted and the type
21121 of structures created from the LNP depends on the value of PST.
21123 1. If PST is NULL, then this procedure uses the data from the program
21124 to create all necessary symbol tables, and their linetables.
21126 2. If PST is not NULL, this procedure reads the program to determine
21127 the list of files included by the unit represented by PST, and
21128 builds all the associated partial symbol tables.
21130 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21131 It is used for relative paths in the line table.
21132 NOTE: When processing partial symtabs (pst != NULL),
21133 comp_dir == pst->dirname.
21135 NOTE: It is important that psymtabs have the same file name (via strcmp)
21136 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21137 symtab we don't use it in the name of the psymtabs we create.
21138 E.g. expand_line_sal requires this when finding psymtabs to expand.
21139 A good testcase for this is mb-inline.exp.
21141 LOWPC is the lowest address in CU (or 0 if not known).
21143 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21144 for its PC<->lines mapping information. Otherwise only the filename
21145 table is read in. */
21148 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
21149 struct dwarf2_cu *cu, struct partial_symtab *pst,
21150 CORE_ADDR lowpc, int decode_mapping)
21152 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21153 const int decode_for_pst_p = (pst != NULL);
21155 if (decode_mapping)
21156 dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
21158 if (decode_for_pst_p)
21162 /* Now that we're done scanning the Line Header Program, we can
21163 create the psymtab of each included file. */
21164 for (file_index = 0; file_index < lh->file_names.size (); file_index++)
21165 if (lh->file_names[file_index].included_p == 1)
21167 gdb::unique_xmalloc_ptr<char> name_holder;
21168 const char *include_name =
21169 psymtab_include_file_name (lh, file_index, pst, comp_dir,
21171 if (include_name != NULL)
21172 dwarf2_create_include_psymtab (include_name, pst, objfile);
21177 /* Make sure a symtab is created for every file, even files
21178 which contain only variables (i.e. no code with associated
21180 struct compunit_symtab *cust = cu->builder->get_compunit_symtab ();
21183 for (i = 0; i < lh->file_names.size (); i++)
21185 file_entry &fe = lh->file_names[i];
21187 dwarf2_start_subfile (cu, fe.name, fe.include_dir (lh));
21189 if (cu->builder->get_current_subfile ()->symtab == NULL)
21191 cu->builder->get_current_subfile ()->symtab
21192 = allocate_symtab (cust,
21193 cu->builder->get_current_subfile ()->name);
21195 fe.symtab = cu->builder->get_current_subfile ()->symtab;
21200 /* Start a subfile for DWARF. FILENAME is the name of the file and
21201 DIRNAME the name of the source directory which contains FILENAME
21202 or NULL if not known.
21203 This routine tries to keep line numbers from identical absolute and
21204 relative file names in a common subfile.
21206 Using the `list' example from the GDB testsuite, which resides in
21207 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21208 of /srcdir/list0.c yields the following debugging information for list0.c:
21210 DW_AT_name: /srcdir/list0.c
21211 DW_AT_comp_dir: /compdir
21212 files.files[0].name: list0.h
21213 files.files[0].dir: /srcdir
21214 files.files[1].name: list0.c
21215 files.files[1].dir: /srcdir
21217 The line number information for list0.c has to end up in a single
21218 subfile, so that `break /srcdir/list0.c:1' works as expected.
21219 start_subfile will ensure that this happens provided that we pass the
21220 concatenation of files.files[1].dir and files.files[1].name as the
21224 dwarf2_start_subfile (struct dwarf2_cu *cu, const char *filename,
21225 const char *dirname)
21229 /* In order not to lose the line information directory,
21230 we concatenate it to the filename when it makes sense.
21231 Note that the Dwarf3 standard says (speaking of filenames in line
21232 information): ``The directory index is ignored for file names
21233 that represent full path names''. Thus ignoring dirname in the
21234 `else' branch below isn't an issue. */
21236 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
21238 copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
21242 cu->builder->start_subfile (filename);
21248 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21249 buildsym_compunit constructor. */
21251 static struct compunit_symtab *
21252 dwarf2_start_symtab (struct dwarf2_cu *cu,
21253 const char *name, const char *comp_dir, CORE_ADDR low_pc)
21255 gdb_assert (cu->builder == nullptr);
21257 cu->builder.reset (new struct buildsym_compunit
21258 (cu->per_cu->dwarf2_per_objfile->objfile,
21259 name, comp_dir, cu->language, low_pc));
21261 cu->list_in_scope = cu->builder->get_file_symbols ();
21263 cu->builder->record_debugformat ("DWARF 2");
21264 cu->builder->record_producer (cu->producer);
21266 cu->processing_has_namespace_info = false;
21268 return cu->builder->get_compunit_symtab ();
21272 var_decode_location (struct attribute *attr, struct symbol *sym,
21273 struct dwarf2_cu *cu)
21275 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21276 struct comp_unit_head *cu_header = &cu->header;
21278 /* NOTE drow/2003-01-30: There used to be a comment and some special
21279 code here to turn a symbol with DW_AT_external and a
21280 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21281 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21282 with some versions of binutils) where shared libraries could have
21283 relocations against symbols in their debug information - the
21284 minimal symbol would have the right address, but the debug info
21285 would not. It's no longer necessary, because we will explicitly
21286 apply relocations when we read in the debug information now. */
21288 /* A DW_AT_location attribute with no contents indicates that a
21289 variable has been optimized away. */
21290 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
21292 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21296 /* Handle one degenerate form of location expression specially, to
21297 preserve GDB's previous behavior when section offsets are
21298 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
21299 then mark this symbol as LOC_STATIC. */
21301 if (attr_form_is_block (attr)
21302 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
21303 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
21304 || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
21305 && (DW_BLOCK (attr)->size
21306 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
21308 unsigned int dummy;
21310 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
21311 SYMBOL_VALUE_ADDRESS (sym) =
21312 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
21314 SYMBOL_VALUE_ADDRESS (sym) =
21315 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
21316 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
21317 fixup_symbol_section (sym, objfile);
21318 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
21319 SYMBOL_SECTION (sym));
21323 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21324 expression evaluator, and use LOC_COMPUTED only when necessary
21325 (i.e. when the value of a register or memory location is
21326 referenced, or a thread-local block, etc.). Then again, it might
21327 not be worthwhile. I'm assuming that it isn't unless performance
21328 or memory numbers show me otherwise. */
21330 dwarf2_symbol_mark_computed (attr, sym, cu, 0);
21332 if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
21333 cu->has_loclist = true;
21336 /* Given a pointer to a DWARF information entry, figure out if we need
21337 to make a symbol table entry for it, and if so, create a new entry
21338 and return a pointer to it.
21339 If TYPE is NULL, determine symbol type from the die, otherwise
21340 used the passed type.
21341 If SPACE is not NULL, use it to hold the new symbol. If it is
21342 NULL, allocate a new symbol on the objfile's obstack. */
21344 static struct symbol *
21345 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
21346 struct symbol *space)
21348 struct dwarf2_per_objfile *dwarf2_per_objfile
21349 = cu->per_cu->dwarf2_per_objfile;
21350 struct objfile *objfile = dwarf2_per_objfile->objfile;
21351 struct gdbarch *gdbarch = get_objfile_arch (objfile);
21352 struct symbol *sym = NULL;
21354 struct attribute *attr = NULL;
21355 struct attribute *attr2 = NULL;
21356 CORE_ADDR baseaddr;
21357 struct pending **list_to_add = NULL;
21359 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
21361 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21363 name = dwarf2_name (die, cu);
21366 const char *linkagename;
21367 int suppress_add = 0;
21372 sym = allocate_symbol (objfile);
21373 OBJSTAT (objfile, n_syms++);
21375 /* Cache this symbol's name and the name's demangled form (if any). */
21376 SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
21377 linkagename = dwarf2_physname (name, die, cu);
21378 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
21380 /* Fortran does not have mangling standard and the mangling does differ
21381 between gfortran, iFort etc. */
21382 if (cu->language == language_fortran
21383 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
21384 symbol_set_demangled_name (&(sym->ginfo),
21385 dwarf2_full_name (name, die, cu),
21388 /* Default assumptions.
21389 Use the passed type or decode it from the die. */
21390 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21391 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21393 SYMBOL_TYPE (sym) = type;
21395 SYMBOL_TYPE (sym) = die_type (die, cu);
21396 attr = dwarf2_attr (die,
21397 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
21401 SYMBOL_LINE (sym) = DW_UNSND (attr);
21404 attr = dwarf2_attr (die,
21405 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
21409 file_name_index file_index = (file_name_index) DW_UNSND (attr);
21410 struct file_entry *fe;
21412 if (cu->line_header != NULL)
21413 fe = cu->line_header->file_name_at (file_index);
21418 complaint (_("file index out of range"));
21420 symbol_set_symtab (sym, fe->symtab);
21426 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
21431 addr = attr_value_as_address (attr);
21432 addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
21433 SYMBOL_VALUE_ADDRESS (sym) = addr;
21435 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
21436 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
21437 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
21438 dw2_add_symbol_to_list (sym, cu->list_in_scope);
21440 case DW_TAG_subprogram:
21441 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21443 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21444 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21445 if ((attr2 && (DW_UNSND (attr2) != 0))
21446 || cu->language == language_ada)
21448 /* Subprograms marked external are stored as a global symbol.
21449 Ada subprograms, whether marked external or not, are always
21450 stored as a global symbol, because we want to be able to
21451 access them globally. For instance, we want to be able
21452 to break on a nested subprogram without having to
21453 specify the context. */
21454 list_to_add = cu->builder->get_global_symbols ();
21458 list_to_add = cu->list_in_scope;
21461 case DW_TAG_inlined_subroutine:
21462 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21464 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21465 SYMBOL_INLINED (sym) = 1;
21466 list_to_add = cu->list_in_scope;
21468 case DW_TAG_template_value_param:
21470 /* Fall through. */
21471 case DW_TAG_constant:
21472 case DW_TAG_variable:
21473 case DW_TAG_member:
21474 /* Compilation with minimal debug info may result in
21475 variables with missing type entries. Change the
21476 misleading `void' type to something sensible. */
21477 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
21478 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
21480 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21481 /* In the case of DW_TAG_member, we should only be called for
21482 static const members. */
21483 if (die->tag == DW_TAG_member)
21485 /* dwarf2_add_field uses die_is_declaration,
21486 so we do the same. */
21487 gdb_assert (die_is_declaration (die, cu));
21492 dwarf2_const_value (attr, sym, cu);
21493 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21496 if (attr2 && (DW_UNSND (attr2) != 0))
21497 list_to_add = cu->builder->get_global_symbols ();
21499 list_to_add = cu->list_in_scope;
21503 attr = dwarf2_attr (die, DW_AT_location, cu);
21506 var_decode_location (attr, sym, cu);
21507 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21509 /* Fortran explicitly imports any global symbols to the local
21510 scope by DW_TAG_common_block. */
21511 if (cu->language == language_fortran && die->parent
21512 && die->parent->tag == DW_TAG_common_block)
21515 if (SYMBOL_CLASS (sym) == LOC_STATIC
21516 && SYMBOL_VALUE_ADDRESS (sym) == 0
21517 && !dwarf2_per_objfile->has_section_at_zero)
21519 /* When a static variable is eliminated by the linker,
21520 the corresponding debug information is not stripped
21521 out, but the variable address is set to null;
21522 do not add such variables into symbol table. */
21524 else if (attr2 && (DW_UNSND (attr2) != 0))
21526 /* Workaround gfortran PR debug/40040 - it uses
21527 DW_AT_location for variables in -fPIC libraries which may
21528 get overriden by other libraries/executable and get
21529 a different address. Resolve it by the minimal symbol
21530 which may come from inferior's executable using copy
21531 relocation. Make this workaround only for gfortran as for
21532 other compilers GDB cannot guess the minimal symbol
21533 Fortran mangling kind. */
21534 if (cu->language == language_fortran && die->parent
21535 && die->parent->tag == DW_TAG_module
21537 && startswith (cu->producer, "GNU Fortran"))
21538 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21540 /* A variable with DW_AT_external is never static,
21541 but it may be block-scoped. */
21543 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21544 ? cu->builder->get_global_symbols ()
21545 : cu->list_in_scope);
21548 list_to_add = cu->list_in_scope;
21552 /* We do not know the address of this symbol.
21553 If it is an external symbol and we have type information
21554 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21555 The address of the variable will then be determined from
21556 the minimal symbol table whenever the variable is
21558 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21560 /* Fortran explicitly imports any global symbols to the local
21561 scope by DW_TAG_common_block. */
21562 if (cu->language == language_fortran && die->parent
21563 && die->parent->tag == DW_TAG_common_block)
21565 /* SYMBOL_CLASS doesn't matter here because
21566 read_common_block is going to reset it. */
21568 list_to_add = cu->list_in_scope;
21570 else if (attr2 && (DW_UNSND (attr2) != 0)
21571 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
21573 /* A variable with DW_AT_external is never static, but it
21574 may be block-scoped. */
21576 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21577 ? cu->builder->get_global_symbols ()
21578 : cu->list_in_scope);
21580 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21582 else if (!die_is_declaration (die, cu))
21584 /* Use the default LOC_OPTIMIZED_OUT class. */
21585 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
21587 list_to_add = cu->list_in_scope;
21591 case DW_TAG_formal_parameter:
21593 /* If we are inside a function, mark this as an argument. If
21594 not, we might be looking at an argument to an inlined function
21595 when we do not have enough information to show inlined frames;
21596 pretend it's a local variable in that case so that the user can
21598 struct context_stack *curr
21599 = cu->builder->get_current_context_stack ();
21600 if (curr != nullptr && curr->name != nullptr)
21601 SYMBOL_IS_ARGUMENT (sym) = 1;
21602 attr = dwarf2_attr (die, DW_AT_location, cu);
21605 var_decode_location (attr, sym, cu);
21607 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21610 dwarf2_const_value (attr, sym, cu);
21613 list_to_add = cu->list_in_scope;
21616 case DW_TAG_unspecified_parameters:
21617 /* From varargs functions; gdb doesn't seem to have any
21618 interest in this information, so just ignore it for now.
21621 case DW_TAG_template_type_param:
21623 /* Fall through. */
21624 case DW_TAG_class_type:
21625 case DW_TAG_interface_type:
21626 case DW_TAG_structure_type:
21627 case DW_TAG_union_type:
21628 case DW_TAG_set_type:
21629 case DW_TAG_enumeration_type:
21630 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21631 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
21634 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21635 really ever be static objects: otherwise, if you try
21636 to, say, break of a class's method and you're in a file
21637 which doesn't mention that class, it won't work unless
21638 the check for all static symbols in lookup_symbol_aux
21639 saves you. See the OtherFileClass tests in
21640 gdb.c++/namespace.exp. */
21645 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21646 && cu->language == language_cplus
21647 ? cu->builder->get_global_symbols ()
21648 : cu->list_in_scope);
21650 /* The semantics of C++ state that "struct foo {
21651 ... }" also defines a typedef for "foo". */
21652 if (cu->language == language_cplus
21653 || cu->language == language_ada
21654 || cu->language == language_d
21655 || cu->language == language_rust)
21657 /* The symbol's name is already allocated along
21658 with this objfile, so we don't need to
21659 duplicate it for the type. */
21660 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
21661 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
21666 case DW_TAG_typedef:
21667 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21668 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21669 list_to_add = cu->list_in_scope;
21671 case DW_TAG_base_type:
21672 case DW_TAG_subrange_type:
21673 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21674 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21675 list_to_add = cu->list_in_scope;
21677 case DW_TAG_enumerator:
21678 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21681 dwarf2_const_value (attr, sym, cu);
21684 /* NOTE: carlton/2003-11-10: See comment above in the
21685 DW_TAG_class_type, etc. block. */
21688 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21689 && cu->language == language_cplus
21690 ? cu->builder->get_global_symbols ()
21691 : cu->list_in_scope);
21694 case DW_TAG_imported_declaration:
21695 case DW_TAG_namespace:
21696 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21697 list_to_add = cu->builder->get_global_symbols ();
21699 case DW_TAG_module:
21700 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21701 SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
21702 list_to_add = cu->builder->get_global_symbols ();
21704 case DW_TAG_common_block:
21705 SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
21706 SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
21707 dw2_add_symbol_to_list (sym, cu->list_in_scope);
21710 /* Not a tag we recognize. Hopefully we aren't processing
21711 trash data, but since we must specifically ignore things
21712 we don't recognize, there is nothing else we should do at
21714 complaint (_("unsupported tag: '%s'"),
21715 dwarf_tag_name (die->tag));
21721 sym->hash_next = objfile->template_symbols;
21722 objfile->template_symbols = sym;
21723 list_to_add = NULL;
21726 if (list_to_add != NULL)
21727 dw2_add_symbol_to_list (sym, list_to_add);
21729 /* For the benefit of old versions of GCC, check for anonymous
21730 namespaces based on the demangled name. */
21731 if (!cu->processing_has_namespace_info
21732 && cu->language == language_cplus)
21733 cp_scan_for_anonymous_namespaces (cu->builder.get (), sym, objfile);
21738 /* Given an attr with a DW_FORM_dataN value in host byte order,
21739 zero-extend it as appropriate for the symbol's type. The DWARF
21740 standard (v4) is not entirely clear about the meaning of using
21741 DW_FORM_dataN for a constant with a signed type, where the type is
21742 wider than the data. The conclusion of a discussion on the DWARF
21743 list was that this is unspecified. We choose to always zero-extend
21744 because that is the interpretation long in use by GCC. */
21747 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
21748 struct dwarf2_cu *cu, LONGEST *value, int bits)
21750 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21751 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
21752 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
21753 LONGEST l = DW_UNSND (attr);
21755 if (bits < sizeof (*value) * 8)
21757 l &= ((LONGEST) 1 << bits) - 1;
21760 else if (bits == sizeof (*value) * 8)
21764 gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
21765 store_unsigned_integer (bytes, bits / 8, byte_order, l);
21772 /* Read a constant value from an attribute. Either set *VALUE, or if
21773 the value does not fit in *VALUE, set *BYTES - either already
21774 allocated on the objfile obstack, or newly allocated on OBSTACK,
21775 or, set *BATON, if we translated the constant to a location
21779 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
21780 const char *name, struct obstack *obstack,
21781 struct dwarf2_cu *cu,
21782 LONGEST *value, const gdb_byte **bytes,
21783 struct dwarf2_locexpr_baton **baton)
21785 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21786 struct comp_unit_head *cu_header = &cu->header;
21787 struct dwarf_block *blk;
21788 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
21789 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
21795 switch (attr->form)
21798 case DW_FORM_GNU_addr_index:
21802 if (TYPE_LENGTH (type) != cu_header->addr_size)
21803 dwarf2_const_value_length_mismatch_complaint (name,
21804 cu_header->addr_size,
21805 TYPE_LENGTH (type));
21806 /* Symbols of this form are reasonably rare, so we just
21807 piggyback on the existing location code rather than writing
21808 a new implementation of symbol_computed_ops. */
21809 *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
21810 (*baton)->per_cu = cu->per_cu;
21811 gdb_assert ((*baton)->per_cu);
21813 (*baton)->size = 2 + cu_header->addr_size;
21814 data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
21815 (*baton)->data = data;
21817 data[0] = DW_OP_addr;
21818 store_unsigned_integer (&data[1], cu_header->addr_size,
21819 byte_order, DW_ADDR (attr));
21820 data[cu_header->addr_size + 1] = DW_OP_stack_value;
21823 case DW_FORM_string:
21825 case DW_FORM_GNU_str_index:
21826 case DW_FORM_GNU_strp_alt:
21827 /* DW_STRING is already allocated on the objfile obstack, point
21829 *bytes = (const gdb_byte *) DW_STRING (attr);
21831 case DW_FORM_block1:
21832 case DW_FORM_block2:
21833 case DW_FORM_block4:
21834 case DW_FORM_block:
21835 case DW_FORM_exprloc:
21836 case DW_FORM_data16:
21837 blk = DW_BLOCK (attr);
21838 if (TYPE_LENGTH (type) != blk->size)
21839 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
21840 TYPE_LENGTH (type));
21841 *bytes = blk->data;
21844 /* The DW_AT_const_value attributes are supposed to carry the
21845 symbol's value "represented as it would be on the target
21846 architecture." By the time we get here, it's already been
21847 converted to host endianness, so we just need to sign- or
21848 zero-extend it as appropriate. */
21849 case DW_FORM_data1:
21850 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
21852 case DW_FORM_data2:
21853 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
21855 case DW_FORM_data4:
21856 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
21858 case DW_FORM_data8:
21859 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
21862 case DW_FORM_sdata:
21863 case DW_FORM_implicit_const:
21864 *value = DW_SND (attr);
21867 case DW_FORM_udata:
21868 *value = DW_UNSND (attr);
21872 complaint (_("unsupported const value attribute form: '%s'"),
21873 dwarf_form_name (attr->form));
21880 /* Copy constant value from an attribute to a symbol. */
21883 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
21884 struct dwarf2_cu *cu)
21886 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21888 const gdb_byte *bytes;
21889 struct dwarf2_locexpr_baton *baton;
21891 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
21892 SYMBOL_PRINT_NAME (sym),
21893 &objfile->objfile_obstack, cu,
21894 &value, &bytes, &baton);
21898 SYMBOL_LOCATION_BATON (sym) = baton;
21899 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
21901 else if (bytes != NULL)
21903 SYMBOL_VALUE_BYTES (sym) = bytes;
21904 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
21908 SYMBOL_VALUE (sym) = value;
21909 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
21913 /* Return the type of the die in question using its DW_AT_type attribute. */
21915 static struct type *
21916 die_type (struct die_info *die, struct dwarf2_cu *cu)
21918 struct attribute *type_attr;
21920 type_attr = dwarf2_attr (die, DW_AT_type, cu);
21923 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21924 /* A missing DW_AT_type represents a void type. */
21925 return objfile_type (objfile)->builtin_void;
21928 return lookup_die_type (die, type_attr, cu);
21931 /* True iff CU's producer generates GNAT Ada auxiliary information
21932 that allows to find parallel types through that information instead
21933 of having to do expensive parallel lookups by type name. */
21936 need_gnat_info (struct dwarf2_cu *cu)
21938 /* Assume that the Ada compiler was GNAT, which always produces
21939 the auxiliary information. */
21940 return (cu->language == language_ada);
21943 /* Return the auxiliary type of the die in question using its
21944 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
21945 attribute is not present. */
21947 static struct type *
21948 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
21950 struct attribute *type_attr;
21952 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
21956 return lookup_die_type (die, type_attr, cu);
21959 /* If DIE has a descriptive_type attribute, then set the TYPE's
21960 descriptive type accordingly. */
21963 set_descriptive_type (struct type *type, struct die_info *die,
21964 struct dwarf2_cu *cu)
21966 struct type *descriptive_type = die_descriptive_type (die, cu);
21968 if (descriptive_type)
21970 ALLOCATE_GNAT_AUX_TYPE (type);
21971 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
21975 /* Return the containing type of the die in question using its
21976 DW_AT_containing_type attribute. */
21978 static struct type *
21979 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
21981 struct attribute *type_attr;
21982 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21984 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
21986 error (_("Dwarf Error: Problem turning containing type into gdb type "
21987 "[in module %s]"), objfile_name (objfile));
21989 return lookup_die_type (die, type_attr, cu);
21992 /* Return an error marker type to use for the ill formed type in DIE/CU. */
21994 static struct type *
21995 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
21997 struct dwarf2_per_objfile *dwarf2_per_objfile
21998 = cu->per_cu->dwarf2_per_objfile;
21999 struct objfile *objfile = dwarf2_per_objfile->objfile;
22002 std::string message
22003 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22004 objfile_name (objfile),
22005 sect_offset_str (cu->header.sect_off),
22006 sect_offset_str (die->sect_off));
22007 saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
22008 message.c_str (), message.length ());
22010 return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
22013 /* Look up the type of DIE in CU using its type attribute ATTR.
22014 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22015 DW_AT_containing_type.
22016 If there is no type substitute an error marker. */
22018 static struct type *
22019 lookup_die_type (struct die_info *die, const struct attribute *attr,
22020 struct dwarf2_cu *cu)
22022 struct dwarf2_per_objfile *dwarf2_per_objfile
22023 = cu->per_cu->dwarf2_per_objfile;
22024 struct objfile *objfile = dwarf2_per_objfile->objfile;
22025 struct type *this_type;
22027 gdb_assert (attr->name == DW_AT_type
22028 || attr->name == DW_AT_GNAT_descriptive_type
22029 || attr->name == DW_AT_containing_type);
22031 /* First see if we have it cached. */
22033 if (attr->form == DW_FORM_GNU_ref_alt)
22035 struct dwarf2_per_cu_data *per_cu;
22036 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22038 per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
22039 dwarf2_per_objfile);
22040 this_type = get_die_type_at_offset (sect_off, per_cu);
22042 else if (attr_form_is_ref (attr))
22044 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22046 this_type = get_die_type_at_offset (sect_off, cu->per_cu);
22048 else if (attr->form == DW_FORM_ref_sig8)
22050 ULONGEST signature = DW_SIGNATURE (attr);
22052 return get_signatured_type (die, signature, cu);
22056 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22057 " at %s [in module %s]"),
22058 dwarf_attr_name (attr->name), sect_offset_str (die->sect_off),
22059 objfile_name (objfile));
22060 return build_error_marker_type (cu, die);
22063 /* If not cached we need to read it in. */
22065 if (this_type == NULL)
22067 struct die_info *type_die = NULL;
22068 struct dwarf2_cu *type_cu = cu;
22070 if (attr_form_is_ref (attr))
22071 type_die = follow_die_ref (die, attr, &type_cu);
22072 if (type_die == NULL)
22073 return build_error_marker_type (cu, die);
22074 /* If we find the type now, it's probably because the type came
22075 from an inter-CU reference and the type's CU got expanded before
22077 this_type = read_type_die (type_die, type_cu);
22080 /* If we still don't have a type use an error marker. */
22082 if (this_type == NULL)
22083 return build_error_marker_type (cu, die);
22088 /* Return the type in DIE, CU.
22089 Returns NULL for invalid types.
22091 This first does a lookup in die_type_hash,
22092 and only reads the die in if necessary.
22094 NOTE: This can be called when reading in partial or full symbols. */
22096 static struct type *
22097 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
22099 struct type *this_type;
22101 this_type = get_die_type (die, cu);
22105 return read_type_die_1 (die, cu);
22108 /* Read the type in DIE, CU.
22109 Returns NULL for invalid types. */
22111 static struct type *
22112 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
22114 struct type *this_type = NULL;
22118 case DW_TAG_class_type:
22119 case DW_TAG_interface_type:
22120 case DW_TAG_structure_type:
22121 case DW_TAG_union_type:
22122 this_type = read_structure_type (die, cu);
22124 case DW_TAG_enumeration_type:
22125 this_type = read_enumeration_type (die, cu);
22127 case DW_TAG_subprogram:
22128 case DW_TAG_subroutine_type:
22129 case DW_TAG_inlined_subroutine:
22130 this_type = read_subroutine_type (die, cu);
22132 case DW_TAG_array_type:
22133 this_type = read_array_type (die, cu);
22135 case DW_TAG_set_type:
22136 this_type = read_set_type (die, cu);
22138 case DW_TAG_pointer_type:
22139 this_type = read_tag_pointer_type (die, cu);
22141 case DW_TAG_ptr_to_member_type:
22142 this_type = read_tag_ptr_to_member_type (die, cu);
22144 case DW_TAG_reference_type:
22145 this_type = read_tag_reference_type (die, cu, TYPE_CODE_REF);
22147 case DW_TAG_rvalue_reference_type:
22148 this_type = read_tag_reference_type (die, cu, TYPE_CODE_RVALUE_REF);
22150 case DW_TAG_const_type:
22151 this_type = read_tag_const_type (die, cu);
22153 case DW_TAG_volatile_type:
22154 this_type = read_tag_volatile_type (die, cu);
22156 case DW_TAG_restrict_type:
22157 this_type = read_tag_restrict_type (die, cu);
22159 case DW_TAG_string_type:
22160 this_type = read_tag_string_type (die, cu);
22162 case DW_TAG_typedef:
22163 this_type = read_typedef (die, cu);
22165 case DW_TAG_subrange_type:
22166 this_type = read_subrange_type (die, cu);
22168 case DW_TAG_base_type:
22169 this_type = read_base_type (die, cu);
22171 case DW_TAG_unspecified_type:
22172 this_type = read_unspecified_type (die, cu);
22174 case DW_TAG_namespace:
22175 this_type = read_namespace_type (die, cu);
22177 case DW_TAG_module:
22178 this_type = read_module_type (die, cu);
22180 case DW_TAG_atomic_type:
22181 this_type = read_tag_atomic_type (die, cu);
22184 complaint (_("unexpected tag in read_type_die: '%s'"),
22185 dwarf_tag_name (die->tag));
22192 /* See if we can figure out if the class lives in a namespace. We do
22193 this by looking for a member function; its demangled name will
22194 contain namespace info, if there is any.
22195 Return the computed name or NULL.
22196 Space for the result is allocated on the objfile's obstack.
22197 This is the full-die version of guess_partial_die_structure_name.
22198 In this case we know DIE has no useful parent. */
22201 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
22203 struct die_info *spec_die;
22204 struct dwarf2_cu *spec_cu;
22205 struct die_info *child;
22206 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22209 spec_die = die_specification (die, &spec_cu);
22210 if (spec_die != NULL)
22216 for (child = die->child;
22218 child = child->sibling)
22220 if (child->tag == DW_TAG_subprogram)
22222 const char *linkage_name = dw2_linkage_name (child, cu);
22224 if (linkage_name != NULL)
22227 = language_class_name_from_physname (cu->language_defn,
22231 if (actual_name != NULL)
22233 const char *die_name = dwarf2_name (die, cu);
22235 if (die_name != NULL
22236 && strcmp (die_name, actual_name) != 0)
22238 /* Strip off the class name from the full name.
22239 We want the prefix. */
22240 int die_name_len = strlen (die_name);
22241 int actual_name_len = strlen (actual_name);
22243 /* Test for '::' as a sanity check. */
22244 if (actual_name_len > die_name_len + 2
22245 && actual_name[actual_name_len
22246 - die_name_len - 1] == ':')
22247 name = (char *) obstack_copy0 (
22248 &objfile->per_bfd->storage_obstack,
22249 actual_name, actual_name_len - die_name_len - 2);
22252 xfree (actual_name);
22261 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22262 prefix part in such case. See
22263 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22265 static const char *
22266 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
22268 struct attribute *attr;
22271 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
22272 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
22275 if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
22278 attr = dw2_linkage_name_attr (die, cu);
22279 if (attr == NULL || DW_STRING (attr) == NULL)
22282 /* dwarf2_name had to be already called. */
22283 gdb_assert (DW_STRING_IS_CANONICAL (attr));
22285 /* Strip the base name, keep any leading namespaces/classes. */
22286 base = strrchr (DW_STRING (attr), ':');
22287 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
22290 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22291 return (char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
22293 &base[-1] - DW_STRING (attr));
22296 /* Return the name of the namespace/class that DIE is defined within,
22297 or "" if we can't tell. The caller should not xfree the result.
22299 For example, if we're within the method foo() in the following
22309 then determine_prefix on foo's die will return "N::C". */
22311 static const char *
22312 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
22314 struct dwarf2_per_objfile *dwarf2_per_objfile
22315 = cu->per_cu->dwarf2_per_objfile;
22316 struct die_info *parent, *spec_die;
22317 struct dwarf2_cu *spec_cu;
22318 struct type *parent_type;
22319 const char *retval;
22321 if (cu->language != language_cplus
22322 && cu->language != language_fortran && cu->language != language_d
22323 && cu->language != language_rust)
22326 retval = anonymous_struct_prefix (die, cu);
22330 /* We have to be careful in the presence of DW_AT_specification.
22331 For example, with GCC 3.4, given the code
22335 // Definition of N::foo.
22339 then we'll have a tree of DIEs like this:
22341 1: DW_TAG_compile_unit
22342 2: DW_TAG_namespace // N
22343 3: DW_TAG_subprogram // declaration of N::foo
22344 4: DW_TAG_subprogram // definition of N::foo
22345 DW_AT_specification // refers to die #3
22347 Thus, when processing die #4, we have to pretend that we're in
22348 the context of its DW_AT_specification, namely the contex of die
22351 spec_die = die_specification (die, &spec_cu);
22352 if (spec_die == NULL)
22353 parent = die->parent;
22356 parent = spec_die->parent;
22360 if (parent == NULL)
22362 else if (parent->building_fullname)
22365 const char *parent_name;
22367 /* It has been seen on RealView 2.2 built binaries,
22368 DW_TAG_template_type_param types actually _defined_ as
22369 children of the parent class:
22372 template class <class Enum> Class{};
22373 Class<enum E> class_e;
22375 1: DW_TAG_class_type (Class)
22376 2: DW_TAG_enumeration_type (E)
22377 3: DW_TAG_enumerator (enum1:0)
22378 3: DW_TAG_enumerator (enum2:1)
22380 2: DW_TAG_template_type_param
22381 DW_AT_type DW_FORM_ref_udata (E)
22383 Besides being broken debug info, it can put GDB into an
22384 infinite loop. Consider:
22386 When we're building the full name for Class<E>, we'll start
22387 at Class, and go look over its template type parameters,
22388 finding E. We'll then try to build the full name of E, and
22389 reach here. We're now trying to build the full name of E,
22390 and look over the parent DIE for containing scope. In the
22391 broken case, if we followed the parent DIE of E, we'd again
22392 find Class, and once again go look at its template type
22393 arguments, etc., etc. Simply don't consider such parent die
22394 as source-level parent of this die (it can't be, the language
22395 doesn't allow it), and break the loop here. */
22396 name = dwarf2_name (die, cu);
22397 parent_name = dwarf2_name (parent, cu);
22398 complaint (_("template param type '%s' defined within parent '%s'"),
22399 name ? name : "<unknown>",
22400 parent_name ? parent_name : "<unknown>");
22404 switch (parent->tag)
22406 case DW_TAG_namespace:
22407 parent_type = read_type_die (parent, cu);
22408 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22409 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22410 Work around this problem here. */
22411 if (cu->language == language_cplus
22412 && strcmp (TYPE_NAME (parent_type), "::") == 0)
22414 /* We give a name to even anonymous namespaces. */
22415 return TYPE_NAME (parent_type);
22416 case DW_TAG_class_type:
22417 case DW_TAG_interface_type:
22418 case DW_TAG_structure_type:
22419 case DW_TAG_union_type:
22420 case DW_TAG_module:
22421 parent_type = read_type_die (parent, cu);
22422 if (TYPE_NAME (parent_type) != NULL)
22423 return TYPE_NAME (parent_type);
22425 /* An anonymous structure is only allowed non-static data
22426 members; no typedefs, no member functions, et cetera.
22427 So it does not need a prefix. */
22429 case DW_TAG_compile_unit:
22430 case DW_TAG_partial_unit:
22431 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22432 if (cu->language == language_cplus
22433 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
22434 && die->child != NULL
22435 && (die->tag == DW_TAG_class_type
22436 || die->tag == DW_TAG_structure_type
22437 || die->tag == DW_TAG_union_type))
22439 char *name = guess_full_die_structure_name (die, cu);
22444 case DW_TAG_enumeration_type:
22445 parent_type = read_type_die (parent, cu);
22446 if (TYPE_DECLARED_CLASS (parent_type))
22448 if (TYPE_NAME (parent_type) != NULL)
22449 return TYPE_NAME (parent_type);
22452 /* Fall through. */
22454 return determine_prefix (parent, cu);
22458 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22459 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22460 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22461 an obconcat, otherwise allocate storage for the result. The CU argument is
22462 used to determine the language and hence, the appropriate separator. */
22464 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22467 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
22468 int physname, struct dwarf2_cu *cu)
22470 const char *lead = "";
22473 if (suffix == NULL || suffix[0] == '\0'
22474 || prefix == NULL || prefix[0] == '\0')
22476 else if (cu->language == language_d)
22478 /* For D, the 'main' function could be defined in any module, but it
22479 should never be prefixed. */
22480 if (strcmp (suffix, "D main") == 0)
22488 else if (cu->language == language_fortran && physname)
22490 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22491 DW_AT_MIPS_linkage_name is preferred and used instead. */
22499 if (prefix == NULL)
22501 if (suffix == NULL)
22508 xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
22510 strcpy (retval, lead);
22511 strcat (retval, prefix);
22512 strcat (retval, sep);
22513 strcat (retval, suffix);
22518 /* We have an obstack. */
22519 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
22523 /* Return sibling of die, NULL if no sibling. */
22525 static struct die_info *
22526 sibling_die (struct die_info *die)
22528 return die->sibling;
22531 /* Get name of a die, return NULL if not found. */
22533 static const char *
22534 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
22535 struct obstack *obstack)
22537 if (name && cu->language == language_cplus)
22539 std::string canon_name = cp_canonicalize_string (name);
22541 if (!canon_name.empty ())
22543 if (canon_name != name)
22544 name = (const char *) obstack_copy0 (obstack,
22545 canon_name.c_str (),
22546 canon_name.length ());
22553 /* Get name of a die, return NULL if not found.
22554 Anonymous namespaces are converted to their magic string. */
22556 static const char *
22557 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
22559 struct attribute *attr;
22560 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22562 attr = dwarf2_attr (die, DW_AT_name, cu);
22563 if ((!attr || !DW_STRING (attr))
22564 && die->tag != DW_TAG_namespace
22565 && die->tag != DW_TAG_class_type
22566 && die->tag != DW_TAG_interface_type
22567 && die->tag != DW_TAG_structure_type
22568 && die->tag != DW_TAG_union_type)
22573 case DW_TAG_compile_unit:
22574 case DW_TAG_partial_unit:
22575 /* Compilation units have a DW_AT_name that is a filename, not
22576 a source language identifier. */
22577 case DW_TAG_enumeration_type:
22578 case DW_TAG_enumerator:
22579 /* These tags always have simple identifiers already; no need
22580 to canonicalize them. */
22581 return DW_STRING (attr);
22583 case DW_TAG_namespace:
22584 if (attr != NULL && DW_STRING (attr) != NULL)
22585 return DW_STRING (attr);
22586 return CP_ANONYMOUS_NAMESPACE_STR;
22588 case DW_TAG_class_type:
22589 case DW_TAG_interface_type:
22590 case DW_TAG_structure_type:
22591 case DW_TAG_union_type:
22592 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22593 structures or unions. These were of the form "._%d" in GCC 4.1,
22594 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22595 and GCC 4.4. We work around this problem by ignoring these. */
22596 if (attr && DW_STRING (attr)
22597 && (startswith (DW_STRING (attr), "._")
22598 || startswith (DW_STRING (attr), "<anonymous")))
22601 /* GCC might emit a nameless typedef that has a linkage name. See
22602 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22603 if (!attr || DW_STRING (attr) == NULL)
22605 char *demangled = NULL;
22607 attr = dw2_linkage_name_attr (die, cu);
22608 if (attr == NULL || DW_STRING (attr) == NULL)
22611 /* Avoid demangling DW_STRING (attr) the second time on a second
22612 call for the same DIE. */
22613 if (!DW_STRING_IS_CANONICAL (attr))
22614 demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
22620 /* FIXME: we already did this for the partial symbol... */
22623 obstack_copy0 (&objfile->per_bfd->storage_obstack,
22624 demangled, strlen (demangled)));
22625 DW_STRING_IS_CANONICAL (attr) = 1;
22628 /* Strip any leading namespaces/classes, keep only the base name.
22629 DW_AT_name for named DIEs does not contain the prefixes. */
22630 base = strrchr (DW_STRING (attr), ':');
22631 if (base && base > DW_STRING (attr) && base[-1] == ':')
22634 return DW_STRING (attr);
22643 if (!DW_STRING_IS_CANONICAL (attr))
22646 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
22647 &objfile->per_bfd->storage_obstack);
22648 DW_STRING_IS_CANONICAL (attr) = 1;
22650 return DW_STRING (attr);
22653 /* Return the die that this die in an extension of, or NULL if there
22654 is none. *EXT_CU is the CU containing DIE on input, and the CU
22655 containing the return value on output. */
22657 static struct die_info *
22658 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
22660 struct attribute *attr;
22662 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
22666 return follow_die_ref (die, attr, ext_cu);
22669 /* Convert a DIE tag into its string name. */
22671 static const char *
22672 dwarf_tag_name (unsigned tag)
22674 const char *name = get_DW_TAG_name (tag);
22677 return "DW_TAG_<unknown>";
22682 /* Convert a DWARF attribute code into its string name. */
22684 static const char *
22685 dwarf_attr_name (unsigned attr)
22689 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22690 if (attr == DW_AT_MIPS_fde)
22691 return "DW_AT_MIPS_fde";
22693 if (attr == DW_AT_HP_block_index)
22694 return "DW_AT_HP_block_index";
22697 name = get_DW_AT_name (attr);
22700 return "DW_AT_<unknown>";
22705 /* Convert a DWARF value form code into its string name. */
22707 static const char *
22708 dwarf_form_name (unsigned form)
22710 const char *name = get_DW_FORM_name (form);
22713 return "DW_FORM_<unknown>";
22718 static const char *
22719 dwarf_bool_name (unsigned mybool)
22727 /* Convert a DWARF type code into its string name. */
22729 static const char *
22730 dwarf_type_encoding_name (unsigned enc)
22732 const char *name = get_DW_ATE_name (enc);
22735 return "DW_ATE_<unknown>";
22741 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
22745 print_spaces (indent, f);
22746 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset %s)\n",
22747 dwarf_tag_name (die->tag), die->abbrev,
22748 sect_offset_str (die->sect_off));
22750 if (die->parent != NULL)
22752 print_spaces (indent, f);
22753 fprintf_unfiltered (f, " parent at offset: %s\n",
22754 sect_offset_str (die->parent->sect_off));
22757 print_spaces (indent, f);
22758 fprintf_unfiltered (f, " has children: %s\n",
22759 dwarf_bool_name (die->child != NULL));
22761 print_spaces (indent, f);
22762 fprintf_unfiltered (f, " attributes:\n");
22764 for (i = 0; i < die->num_attrs; ++i)
22766 print_spaces (indent, f);
22767 fprintf_unfiltered (f, " %s (%s) ",
22768 dwarf_attr_name (die->attrs[i].name),
22769 dwarf_form_name (die->attrs[i].form));
22771 switch (die->attrs[i].form)
22774 case DW_FORM_GNU_addr_index:
22775 fprintf_unfiltered (f, "address: ");
22776 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
22778 case DW_FORM_block2:
22779 case DW_FORM_block4:
22780 case DW_FORM_block:
22781 case DW_FORM_block1:
22782 fprintf_unfiltered (f, "block: size %s",
22783 pulongest (DW_BLOCK (&die->attrs[i])->size));
22785 case DW_FORM_exprloc:
22786 fprintf_unfiltered (f, "expression: size %s",
22787 pulongest (DW_BLOCK (&die->attrs[i])->size));
22789 case DW_FORM_data16:
22790 fprintf_unfiltered (f, "constant of 16 bytes");
22792 case DW_FORM_ref_addr:
22793 fprintf_unfiltered (f, "ref address: ");
22794 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22796 case DW_FORM_GNU_ref_alt:
22797 fprintf_unfiltered (f, "alt ref address: ");
22798 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22804 case DW_FORM_ref_udata:
22805 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
22806 (long) (DW_UNSND (&die->attrs[i])));
22808 case DW_FORM_data1:
22809 case DW_FORM_data2:
22810 case DW_FORM_data4:
22811 case DW_FORM_data8:
22812 case DW_FORM_udata:
22813 case DW_FORM_sdata:
22814 fprintf_unfiltered (f, "constant: %s",
22815 pulongest (DW_UNSND (&die->attrs[i])));
22817 case DW_FORM_sec_offset:
22818 fprintf_unfiltered (f, "section offset: %s",
22819 pulongest (DW_UNSND (&die->attrs[i])));
22821 case DW_FORM_ref_sig8:
22822 fprintf_unfiltered (f, "signature: %s",
22823 hex_string (DW_SIGNATURE (&die->attrs[i])));
22825 case DW_FORM_string:
22827 case DW_FORM_line_strp:
22828 case DW_FORM_GNU_str_index:
22829 case DW_FORM_GNU_strp_alt:
22830 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
22831 DW_STRING (&die->attrs[i])
22832 ? DW_STRING (&die->attrs[i]) : "",
22833 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
22836 if (DW_UNSND (&die->attrs[i]))
22837 fprintf_unfiltered (f, "flag: TRUE");
22839 fprintf_unfiltered (f, "flag: FALSE");
22841 case DW_FORM_flag_present:
22842 fprintf_unfiltered (f, "flag: TRUE");
22844 case DW_FORM_indirect:
22845 /* The reader will have reduced the indirect form to
22846 the "base form" so this form should not occur. */
22847 fprintf_unfiltered (f,
22848 "unexpected attribute form: DW_FORM_indirect");
22850 case DW_FORM_implicit_const:
22851 fprintf_unfiltered (f, "constant: %s",
22852 plongest (DW_SND (&die->attrs[i])));
22855 fprintf_unfiltered (f, "unsupported attribute form: %d.",
22856 die->attrs[i].form);
22859 fprintf_unfiltered (f, "\n");
22864 dump_die_for_error (struct die_info *die)
22866 dump_die_shallow (gdb_stderr, 0, die);
22870 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
22872 int indent = level * 4;
22874 gdb_assert (die != NULL);
22876 if (level >= max_level)
22879 dump_die_shallow (f, indent, die);
22881 if (die->child != NULL)
22883 print_spaces (indent, f);
22884 fprintf_unfiltered (f, " Children:");
22885 if (level + 1 < max_level)
22887 fprintf_unfiltered (f, "\n");
22888 dump_die_1 (f, level + 1, max_level, die->child);
22892 fprintf_unfiltered (f,
22893 " [not printed, max nesting level reached]\n");
22897 if (die->sibling != NULL && level > 0)
22899 dump_die_1 (f, level, max_level, die->sibling);
22903 /* This is called from the pdie macro in gdbinit.in.
22904 It's not static so gcc will keep a copy callable from gdb. */
22907 dump_die (struct die_info *die, int max_level)
22909 dump_die_1 (gdb_stdlog, 0, max_level, die);
22913 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
22917 slot = htab_find_slot_with_hash (cu->die_hash, die,
22918 to_underlying (die->sect_off),
22924 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
22928 dwarf2_get_ref_die_offset (const struct attribute *attr)
22930 if (attr_form_is_ref (attr))
22931 return (sect_offset) DW_UNSND (attr);
22933 complaint (_("unsupported die ref attribute form: '%s'"),
22934 dwarf_form_name (attr->form));
22938 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
22939 * the value held by the attribute is not constant. */
22942 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
22944 if (attr->form == DW_FORM_sdata || attr->form == DW_FORM_implicit_const)
22945 return DW_SND (attr);
22946 else if (attr->form == DW_FORM_udata
22947 || attr->form == DW_FORM_data1
22948 || attr->form == DW_FORM_data2
22949 || attr->form == DW_FORM_data4
22950 || attr->form == DW_FORM_data8)
22951 return DW_UNSND (attr);
22954 /* For DW_FORM_data16 see attr_form_is_constant. */
22955 complaint (_("Attribute value is not a constant (%s)"),
22956 dwarf_form_name (attr->form));
22957 return default_value;
22961 /* Follow reference or signature attribute ATTR of SRC_DIE.
22962 On entry *REF_CU is the CU of SRC_DIE.
22963 On exit *REF_CU is the CU of the result. */
22965 static struct die_info *
22966 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
22967 struct dwarf2_cu **ref_cu)
22969 struct die_info *die;
22971 if (attr_form_is_ref (attr))
22972 die = follow_die_ref (src_die, attr, ref_cu);
22973 else if (attr->form == DW_FORM_ref_sig8)
22974 die = follow_die_sig (src_die, attr, ref_cu);
22977 dump_die_for_error (src_die);
22978 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
22979 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
22985 /* Follow reference OFFSET.
22986 On entry *REF_CU is the CU of the source die referencing OFFSET.
22987 On exit *REF_CU is the CU of the result.
22988 Returns NULL if OFFSET is invalid. */
22990 static struct die_info *
22991 follow_die_offset (sect_offset sect_off, int offset_in_dwz,
22992 struct dwarf2_cu **ref_cu)
22994 struct die_info temp_die;
22995 struct dwarf2_cu *target_cu, *cu = *ref_cu;
22996 struct dwarf2_per_objfile *dwarf2_per_objfile
22997 = cu->per_cu->dwarf2_per_objfile;
22999 gdb_assert (cu->per_cu != NULL);
23003 if (cu->per_cu->is_debug_types)
23005 /* .debug_types CUs cannot reference anything outside their CU.
23006 If they need to, they have to reference a signatured type via
23007 DW_FORM_ref_sig8. */
23008 if (!offset_in_cu_p (&cu->header, sect_off))
23011 else if (offset_in_dwz != cu->per_cu->is_dwz
23012 || !offset_in_cu_p (&cu->header, sect_off))
23014 struct dwarf2_per_cu_data *per_cu;
23016 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
23017 dwarf2_per_objfile);
23019 /* If necessary, add it to the queue and load its DIEs. */
23020 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
23021 load_full_comp_unit (per_cu, false, cu->language);
23023 target_cu = per_cu->cu;
23025 else if (cu->dies == NULL)
23027 /* We're loading full DIEs during partial symbol reading. */
23028 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
23029 load_full_comp_unit (cu->per_cu, false, language_minimal);
23032 *ref_cu = target_cu;
23033 temp_die.sect_off = sect_off;
23034 return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
23036 to_underlying (sect_off));
23039 /* Follow reference attribute ATTR of SRC_DIE.
23040 On entry *REF_CU is the CU of SRC_DIE.
23041 On exit *REF_CU is the CU of the result. */
23043 static struct die_info *
23044 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
23045 struct dwarf2_cu **ref_cu)
23047 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
23048 struct dwarf2_cu *cu = *ref_cu;
23049 struct die_info *die;
23051 die = follow_die_offset (sect_off,
23052 (attr->form == DW_FORM_GNU_ref_alt
23053 || cu->per_cu->is_dwz),
23056 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23057 "at %s [in module %s]"),
23058 sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
23059 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
23064 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23065 Returned value is intended for DW_OP_call*. Returned
23066 dwarf2_locexpr_baton->data has lifetime of
23067 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
23069 struct dwarf2_locexpr_baton
23070 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
23071 struct dwarf2_per_cu_data *per_cu,
23072 CORE_ADDR (*get_frame_pc) (void *baton),
23073 void *baton, bool resolve_abstract_p)
23075 struct dwarf2_cu *cu;
23076 struct die_info *die;
23077 struct attribute *attr;
23078 struct dwarf2_locexpr_baton retval;
23079 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
23080 struct objfile *objfile = dwarf2_per_objfile->objfile;
23082 if (per_cu->cu == NULL)
23083 load_cu (per_cu, false);
23087 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23088 Instead just throw an error, not much else we can do. */
23089 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23090 sect_offset_str (sect_off), objfile_name (objfile));
23093 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23095 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23096 sect_offset_str (sect_off), objfile_name (objfile));
23098 attr = dwarf2_attr (die, DW_AT_location, cu);
23099 if (!attr && resolve_abstract_p
23100 && (dwarf2_per_objfile->abstract_to_concrete.find (die)
23101 != dwarf2_per_objfile->abstract_to_concrete.end ()))
23103 CORE_ADDR pc = (*get_frame_pc) (baton);
23105 for (const auto &cand : dwarf2_per_objfile->abstract_to_concrete[die])
23108 || cand->parent->tag != DW_TAG_subprogram)
23111 CORE_ADDR pc_low, pc_high;
23112 get_scope_pc_bounds (cand->parent, &pc_low, &pc_high, cu);
23113 if (pc_low == ((CORE_ADDR) -1)
23114 || !(pc_low <= pc && pc < pc_high))
23118 attr = dwarf2_attr (die, DW_AT_location, cu);
23125 /* DWARF: "If there is no such attribute, then there is no effect.".
23126 DATA is ignored if SIZE is 0. */
23128 retval.data = NULL;
23131 else if (attr_form_is_section_offset (attr))
23133 struct dwarf2_loclist_baton loclist_baton;
23134 CORE_ADDR pc = (*get_frame_pc) (baton);
23137 fill_in_loclist_baton (cu, &loclist_baton, attr);
23139 retval.data = dwarf2_find_location_expression (&loclist_baton,
23141 retval.size = size;
23145 if (!attr_form_is_block (attr))
23146 error (_("Dwarf Error: DIE at %s referenced in module %s "
23147 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23148 sect_offset_str (sect_off), objfile_name (objfile));
23150 retval.data = DW_BLOCK (attr)->data;
23151 retval.size = DW_BLOCK (attr)->size;
23153 retval.per_cu = cu->per_cu;
23155 age_cached_comp_units (dwarf2_per_objfile);
23160 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23163 struct dwarf2_locexpr_baton
23164 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
23165 struct dwarf2_per_cu_data *per_cu,
23166 CORE_ADDR (*get_frame_pc) (void *baton),
23169 sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
23171 return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
23174 /* Write a constant of a given type as target-ordered bytes into
23177 static const gdb_byte *
23178 write_constant_as_bytes (struct obstack *obstack,
23179 enum bfd_endian byte_order,
23186 *len = TYPE_LENGTH (type);
23187 result = (gdb_byte *) obstack_alloc (obstack, *len);
23188 store_unsigned_integer (result, *len, byte_order, value);
23193 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23194 pointer to the constant bytes and set LEN to the length of the
23195 data. If memory is needed, allocate it on OBSTACK. If the DIE
23196 does not have a DW_AT_const_value, return NULL. */
23199 dwarf2_fetch_constant_bytes (sect_offset sect_off,
23200 struct dwarf2_per_cu_data *per_cu,
23201 struct obstack *obstack,
23204 struct dwarf2_cu *cu;
23205 struct die_info *die;
23206 struct attribute *attr;
23207 const gdb_byte *result = NULL;
23210 enum bfd_endian byte_order;
23211 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23213 if (per_cu->cu == NULL)
23214 load_cu (per_cu, false);
23218 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23219 Instead just throw an error, not much else we can do. */
23220 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23221 sect_offset_str (sect_off), objfile_name (objfile));
23224 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23226 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23227 sect_offset_str (sect_off), objfile_name (objfile));
23229 attr = dwarf2_attr (die, DW_AT_const_value, cu);
23233 byte_order = (bfd_big_endian (objfile->obfd)
23234 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
23236 switch (attr->form)
23239 case DW_FORM_GNU_addr_index:
23243 *len = cu->header.addr_size;
23244 tem = (gdb_byte *) obstack_alloc (obstack, *len);
23245 store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
23249 case DW_FORM_string:
23251 case DW_FORM_GNU_str_index:
23252 case DW_FORM_GNU_strp_alt:
23253 /* DW_STRING is already allocated on the objfile obstack, point
23255 result = (const gdb_byte *) DW_STRING (attr);
23256 *len = strlen (DW_STRING (attr));
23258 case DW_FORM_block1:
23259 case DW_FORM_block2:
23260 case DW_FORM_block4:
23261 case DW_FORM_block:
23262 case DW_FORM_exprloc:
23263 case DW_FORM_data16:
23264 result = DW_BLOCK (attr)->data;
23265 *len = DW_BLOCK (attr)->size;
23268 /* The DW_AT_const_value attributes are supposed to carry the
23269 symbol's value "represented as it would be on the target
23270 architecture." By the time we get here, it's already been
23271 converted to host endianness, so we just need to sign- or
23272 zero-extend it as appropriate. */
23273 case DW_FORM_data1:
23274 type = die_type (die, cu);
23275 result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
23276 if (result == NULL)
23277 result = write_constant_as_bytes (obstack, byte_order,
23280 case DW_FORM_data2:
23281 type = die_type (die, cu);
23282 result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
23283 if (result == NULL)
23284 result = write_constant_as_bytes (obstack, byte_order,
23287 case DW_FORM_data4:
23288 type = die_type (die, cu);
23289 result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
23290 if (result == NULL)
23291 result = write_constant_as_bytes (obstack, byte_order,
23294 case DW_FORM_data8:
23295 type = die_type (die, cu);
23296 result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
23297 if (result == NULL)
23298 result = write_constant_as_bytes (obstack, byte_order,
23302 case DW_FORM_sdata:
23303 case DW_FORM_implicit_const:
23304 type = die_type (die, cu);
23305 result = write_constant_as_bytes (obstack, byte_order,
23306 type, DW_SND (attr), len);
23309 case DW_FORM_udata:
23310 type = die_type (die, cu);
23311 result = write_constant_as_bytes (obstack, byte_order,
23312 type, DW_UNSND (attr), len);
23316 complaint (_("unsupported const value attribute form: '%s'"),
23317 dwarf_form_name (attr->form));
23324 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23325 valid type for this die is found. */
23328 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
23329 struct dwarf2_per_cu_data *per_cu)
23331 struct dwarf2_cu *cu;
23332 struct die_info *die;
23334 if (per_cu->cu == NULL)
23335 load_cu (per_cu, false);
23340 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23344 return die_type (die, cu);
23347 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23351 dwarf2_get_die_type (cu_offset die_offset,
23352 struct dwarf2_per_cu_data *per_cu)
23354 sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
23355 return get_die_type_at_offset (die_offset_sect, per_cu);
23358 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23359 On entry *REF_CU is the CU of SRC_DIE.
23360 On exit *REF_CU is the CU of the result.
23361 Returns NULL if the referenced DIE isn't found. */
23363 static struct die_info *
23364 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
23365 struct dwarf2_cu **ref_cu)
23367 struct die_info temp_die;
23368 struct dwarf2_cu *sig_cu;
23369 struct die_info *die;
23371 /* While it might be nice to assert sig_type->type == NULL here,
23372 we can get here for DW_AT_imported_declaration where we need
23373 the DIE not the type. */
23375 /* If necessary, add it to the queue and load its DIEs. */
23377 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
23378 read_signatured_type (sig_type);
23380 sig_cu = sig_type->per_cu.cu;
23381 gdb_assert (sig_cu != NULL);
23382 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
23383 temp_die.sect_off = sig_type->type_offset_in_section;
23384 die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
23385 to_underlying (temp_die.sect_off));
23388 struct dwarf2_per_objfile *dwarf2_per_objfile
23389 = (*ref_cu)->per_cu->dwarf2_per_objfile;
23391 /* For .gdb_index version 7 keep track of included TUs.
23392 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23393 if (dwarf2_per_objfile->index_table != NULL
23394 && dwarf2_per_objfile->index_table->version <= 7)
23396 VEC_safe_push (dwarf2_per_cu_ptr,
23397 (*ref_cu)->per_cu->imported_symtabs,
23408 /* Follow signatured type referenced by ATTR in SRC_DIE.
23409 On entry *REF_CU is the CU of SRC_DIE.
23410 On exit *REF_CU is the CU of the result.
23411 The result is the DIE of the type.
23412 If the referenced type cannot be found an error is thrown. */
23414 static struct die_info *
23415 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
23416 struct dwarf2_cu **ref_cu)
23418 ULONGEST signature = DW_SIGNATURE (attr);
23419 struct signatured_type *sig_type;
23420 struct die_info *die;
23422 gdb_assert (attr->form == DW_FORM_ref_sig8);
23424 sig_type = lookup_signatured_type (*ref_cu, signature);
23425 /* sig_type will be NULL if the signatured type is missing from
23427 if (sig_type == NULL)
23429 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23430 " from DIE at %s [in module %s]"),
23431 hex_string (signature), sect_offset_str (src_die->sect_off),
23432 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23435 die = follow_die_sig_1 (src_die, sig_type, ref_cu);
23438 dump_die_for_error (src_die);
23439 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23440 " from DIE at %s [in module %s]"),
23441 hex_string (signature), sect_offset_str (src_die->sect_off),
23442 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23448 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23449 reading in and processing the type unit if necessary. */
23451 static struct type *
23452 get_signatured_type (struct die_info *die, ULONGEST signature,
23453 struct dwarf2_cu *cu)
23455 struct dwarf2_per_objfile *dwarf2_per_objfile
23456 = cu->per_cu->dwarf2_per_objfile;
23457 struct signatured_type *sig_type;
23458 struct dwarf2_cu *type_cu;
23459 struct die_info *type_die;
23462 sig_type = lookup_signatured_type (cu, signature);
23463 /* sig_type will be NULL if the signatured type is missing from
23465 if (sig_type == NULL)
23467 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23468 " from DIE at %s [in module %s]"),
23469 hex_string (signature), sect_offset_str (die->sect_off),
23470 objfile_name (dwarf2_per_objfile->objfile));
23471 return build_error_marker_type (cu, die);
23474 /* If we already know the type we're done. */
23475 if (sig_type->type != NULL)
23476 return sig_type->type;
23479 type_die = follow_die_sig_1 (die, sig_type, &type_cu);
23480 if (type_die != NULL)
23482 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23483 is created. This is important, for example, because for c++ classes
23484 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23485 type = read_type_die (type_die, type_cu);
23488 complaint (_("Dwarf Error: Cannot build signatured type %s"
23489 " referenced from DIE at %s [in module %s]"),
23490 hex_string (signature), sect_offset_str (die->sect_off),
23491 objfile_name (dwarf2_per_objfile->objfile));
23492 type = build_error_marker_type (cu, die);
23497 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23498 " from DIE at %s [in module %s]"),
23499 hex_string (signature), sect_offset_str (die->sect_off),
23500 objfile_name (dwarf2_per_objfile->objfile));
23501 type = build_error_marker_type (cu, die);
23503 sig_type->type = type;
23508 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23509 reading in and processing the type unit if necessary. */
23511 static struct type *
23512 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
23513 struct dwarf2_cu *cu) /* ARI: editCase function */
23515 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23516 if (attr_form_is_ref (attr))
23518 struct dwarf2_cu *type_cu = cu;
23519 struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
23521 return read_type_die (type_die, type_cu);
23523 else if (attr->form == DW_FORM_ref_sig8)
23525 return get_signatured_type (die, DW_SIGNATURE (attr), cu);
23529 struct dwarf2_per_objfile *dwarf2_per_objfile
23530 = cu->per_cu->dwarf2_per_objfile;
23532 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23533 " at %s [in module %s]"),
23534 dwarf_form_name (attr->form), sect_offset_str (die->sect_off),
23535 objfile_name (dwarf2_per_objfile->objfile));
23536 return build_error_marker_type (cu, die);
23540 /* Load the DIEs associated with type unit PER_CU into memory. */
23543 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
23545 struct signatured_type *sig_type;
23547 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23548 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
23550 /* We have the per_cu, but we need the signatured_type.
23551 Fortunately this is an easy translation. */
23552 gdb_assert (per_cu->is_debug_types);
23553 sig_type = (struct signatured_type *) per_cu;
23555 gdb_assert (per_cu->cu == NULL);
23557 read_signatured_type (sig_type);
23559 gdb_assert (per_cu->cu != NULL);
23562 /* die_reader_func for read_signatured_type.
23563 This is identical to load_full_comp_unit_reader,
23564 but is kept separate for now. */
23567 read_signatured_type_reader (const struct die_reader_specs *reader,
23568 const gdb_byte *info_ptr,
23569 struct die_info *comp_unit_die,
23573 struct dwarf2_cu *cu = reader->cu;
23575 gdb_assert (cu->die_hash == NULL);
23577 htab_create_alloc_ex (cu->header.length / 12,
23581 &cu->comp_unit_obstack,
23582 hashtab_obstack_allocate,
23583 dummy_obstack_deallocate);
23586 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
23587 &info_ptr, comp_unit_die);
23588 cu->dies = comp_unit_die;
23589 /* comp_unit_die is not stored in die_hash, no need. */
23591 /* We try not to read any attributes in this function, because not
23592 all CUs needed for references have been loaded yet, and symbol
23593 table processing isn't initialized. But we have to set the CU language,
23594 or we won't be able to build types correctly.
23595 Similarly, if we do not read the producer, we can not apply
23596 producer-specific interpretation. */
23597 prepare_one_comp_unit (cu, cu->dies, language_minimal);
23600 /* Read in a signatured type and build its CU and DIEs.
23601 If the type is a stub for the real type in a DWO file,
23602 read in the real type from the DWO file as well. */
23605 read_signatured_type (struct signatured_type *sig_type)
23607 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
23609 gdb_assert (per_cu->is_debug_types);
23610 gdb_assert (per_cu->cu == NULL);
23612 init_cutu_and_read_dies (per_cu, NULL, 0, 1, false,
23613 read_signatured_type_reader, NULL);
23614 sig_type->per_cu.tu_read = 1;
23617 /* Decode simple location descriptions.
23618 Given a pointer to a dwarf block that defines a location, compute
23619 the location and return the value.
23621 NOTE drow/2003-11-18: This function is called in two situations
23622 now: for the address of static or global variables (partial symbols
23623 only) and for offsets into structures which are expected to be
23624 (more or less) constant. The partial symbol case should go away,
23625 and only the constant case should remain. That will let this
23626 function complain more accurately. A few special modes are allowed
23627 without complaint for global variables (for instance, global
23628 register values and thread-local values).
23630 A location description containing no operations indicates that the
23631 object is optimized out. The return value is 0 for that case.
23632 FIXME drow/2003-11-16: No callers check for this case any more; soon all
23633 callers will only want a very basic result and this can become a
23636 Note that stack[0] is unused except as a default error return. */
23639 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
23641 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
23643 size_t size = blk->size;
23644 const gdb_byte *data = blk->data;
23645 CORE_ADDR stack[64];
23647 unsigned int bytes_read, unsnd;
23653 stack[++stacki] = 0;
23692 stack[++stacki] = op - DW_OP_lit0;
23727 stack[++stacki] = op - DW_OP_reg0;
23729 dwarf2_complex_location_expr_complaint ();
23733 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
23735 stack[++stacki] = unsnd;
23737 dwarf2_complex_location_expr_complaint ();
23741 stack[++stacki] = read_address (objfile->obfd, &data[i],
23746 case DW_OP_const1u:
23747 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
23751 case DW_OP_const1s:
23752 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
23756 case DW_OP_const2u:
23757 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
23761 case DW_OP_const2s:
23762 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
23766 case DW_OP_const4u:
23767 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
23771 case DW_OP_const4s:
23772 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
23776 case DW_OP_const8u:
23777 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
23782 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
23788 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
23793 stack[stacki + 1] = stack[stacki];
23798 stack[stacki - 1] += stack[stacki];
23802 case DW_OP_plus_uconst:
23803 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
23809 stack[stacki - 1] -= stack[stacki];
23814 /* If we're not the last op, then we definitely can't encode
23815 this using GDB's address_class enum. This is valid for partial
23816 global symbols, although the variable's address will be bogus
23819 dwarf2_complex_location_expr_complaint ();
23822 case DW_OP_GNU_push_tls_address:
23823 case DW_OP_form_tls_address:
23824 /* The top of the stack has the offset from the beginning
23825 of the thread control block at which the variable is located. */
23826 /* Nothing should follow this operator, so the top of stack would
23828 /* This is valid for partial global symbols, but the variable's
23829 address will be bogus in the psymtab. Make it always at least
23830 non-zero to not look as a variable garbage collected by linker
23831 which have DW_OP_addr 0. */
23833 dwarf2_complex_location_expr_complaint ();
23837 case DW_OP_GNU_uninit:
23840 case DW_OP_GNU_addr_index:
23841 case DW_OP_GNU_const_index:
23842 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
23849 const char *name = get_DW_OP_name (op);
23852 complaint (_("unsupported stack op: '%s'"),
23855 complaint (_("unsupported stack op: '%02x'"),
23859 return (stack[stacki]);
23862 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23863 outside of the allocated space. Also enforce minimum>0. */
23864 if (stacki >= ARRAY_SIZE (stack) - 1)
23866 complaint (_("location description stack overflow"));
23872 complaint (_("location description stack underflow"));
23876 return (stack[stacki]);
23879 /* memory allocation interface */
23881 static struct dwarf_block *
23882 dwarf_alloc_block (struct dwarf2_cu *cu)
23884 return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
23887 static struct die_info *
23888 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
23890 struct die_info *die;
23891 size_t size = sizeof (struct die_info);
23894 size += (num_attrs - 1) * sizeof (struct attribute);
23896 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
23897 memset (die, 0, sizeof (struct die_info));
23902 /* Macro support. */
23904 /* Return file name relative to the compilation directory of file number I in
23905 *LH's file name table. The result is allocated using xmalloc; the caller is
23906 responsible for freeing it. */
23909 file_file_name (int file, struct line_header *lh)
23911 /* Is the file number a valid index into the line header's file name
23912 table? Remember that file numbers start with one, not zero. */
23913 if (1 <= file && file <= lh->file_names.size ())
23915 const file_entry &fe = lh->file_names[file - 1];
23917 if (!IS_ABSOLUTE_PATH (fe.name))
23919 const char *dir = fe.include_dir (lh);
23921 return concat (dir, SLASH_STRING, fe.name, (char *) NULL);
23923 return xstrdup (fe.name);
23927 /* The compiler produced a bogus file number. We can at least
23928 record the macro definitions made in the file, even if we
23929 won't be able to find the file by name. */
23930 char fake_name[80];
23932 xsnprintf (fake_name, sizeof (fake_name),
23933 "<bad macro file number %d>", file);
23935 complaint (_("bad file number in macro information (%d)"),
23938 return xstrdup (fake_name);
23942 /* Return the full name of file number I in *LH's file name table.
23943 Use COMP_DIR as the name of the current directory of the
23944 compilation. The result is allocated using xmalloc; the caller is
23945 responsible for freeing it. */
23947 file_full_name (int file, struct line_header *lh, const char *comp_dir)
23949 /* Is the file number a valid index into the line header's file name
23950 table? Remember that file numbers start with one, not zero. */
23951 if (1 <= file && file <= lh->file_names.size ())
23953 char *relative = file_file_name (file, lh);
23955 if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
23957 return reconcat (relative, comp_dir, SLASH_STRING,
23958 relative, (char *) NULL);
23961 return file_file_name (file, lh);
23965 static struct macro_source_file *
23966 macro_start_file (struct dwarf2_cu *cu,
23967 int file, int line,
23968 struct macro_source_file *current_file,
23969 struct line_header *lh)
23971 /* File name relative to the compilation directory of this source file. */
23972 char *file_name = file_file_name (file, lh);
23974 if (! current_file)
23976 /* Note: We don't create a macro table for this compilation unit
23977 at all until we actually get a filename. */
23978 struct macro_table *macro_table = cu->builder->get_macro_table ();
23980 /* If we have no current file, then this must be the start_file
23981 directive for the compilation unit's main source file. */
23982 current_file = macro_set_main (macro_table, file_name);
23983 macro_define_special (macro_table);
23986 current_file = macro_include (current_file, line, file_name);
23990 return current_file;
23993 static const char *
23994 consume_improper_spaces (const char *p, const char *body)
23998 complaint (_("macro definition contains spaces "
23999 "in formal argument list:\n`%s'"),
24011 parse_macro_definition (struct macro_source_file *file, int line,
24016 /* The body string takes one of two forms. For object-like macro
24017 definitions, it should be:
24019 <macro name> " " <definition>
24021 For function-like macro definitions, it should be:
24023 <macro name> "() " <definition>
24025 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24027 Spaces may appear only where explicitly indicated, and in the
24030 The Dwarf 2 spec says that an object-like macro's name is always
24031 followed by a space, but versions of GCC around March 2002 omit
24032 the space when the macro's definition is the empty string.
24034 The Dwarf 2 spec says that there should be no spaces between the
24035 formal arguments in a function-like macro's formal argument list,
24036 but versions of GCC around March 2002 include spaces after the
24040 /* Find the extent of the macro name. The macro name is terminated
24041 by either a space or null character (for an object-like macro) or
24042 an opening paren (for a function-like macro). */
24043 for (p = body; *p; p++)
24044 if (*p == ' ' || *p == '(')
24047 if (*p == ' ' || *p == '\0')
24049 /* It's an object-like macro. */
24050 int name_len = p - body;
24051 char *name = savestring (body, name_len);
24052 const char *replacement;
24055 replacement = body + name_len + 1;
24058 dwarf2_macro_malformed_definition_complaint (body);
24059 replacement = body + name_len;
24062 macro_define_object (file, line, name, replacement);
24066 else if (*p == '(')
24068 /* It's a function-like macro. */
24069 char *name = savestring (body, p - body);
24072 char **argv = XNEWVEC (char *, argv_size);
24076 p = consume_improper_spaces (p, body);
24078 /* Parse the formal argument list. */
24079 while (*p && *p != ')')
24081 /* Find the extent of the current argument name. */
24082 const char *arg_start = p;
24084 while (*p && *p != ',' && *p != ')' && *p != ' ')
24087 if (! *p || p == arg_start)
24088 dwarf2_macro_malformed_definition_complaint (body);
24091 /* Make sure argv has room for the new argument. */
24092 if (argc >= argv_size)
24095 argv = XRESIZEVEC (char *, argv, argv_size);
24098 argv[argc++] = savestring (arg_start, p - arg_start);
24101 p = consume_improper_spaces (p, body);
24103 /* Consume the comma, if present. */
24108 p = consume_improper_spaces (p, body);
24117 /* Perfectly formed definition, no complaints. */
24118 macro_define_function (file, line, name,
24119 argc, (const char **) argv,
24121 else if (*p == '\0')
24123 /* Complain, but do define it. */
24124 dwarf2_macro_malformed_definition_complaint (body);
24125 macro_define_function (file, line, name,
24126 argc, (const char **) argv,
24130 /* Just complain. */
24131 dwarf2_macro_malformed_definition_complaint (body);
24134 /* Just complain. */
24135 dwarf2_macro_malformed_definition_complaint (body);
24141 for (i = 0; i < argc; i++)
24147 dwarf2_macro_malformed_definition_complaint (body);
24150 /* Skip some bytes from BYTES according to the form given in FORM.
24151 Returns the new pointer. */
24153 static const gdb_byte *
24154 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
24155 enum dwarf_form form,
24156 unsigned int offset_size,
24157 struct dwarf2_section_info *section)
24159 unsigned int bytes_read;
24163 case DW_FORM_data1:
24168 case DW_FORM_data2:
24172 case DW_FORM_data4:
24176 case DW_FORM_data8:
24180 case DW_FORM_data16:
24184 case DW_FORM_string:
24185 read_direct_string (abfd, bytes, &bytes_read);
24186 bytes += bytes_read;
24189 case DW_FORM_sec_offset:
24191 case DW_FORM_GNU_strp_alt:
24192 bytes += offset_size;
24195 case DW_FORM_block:
24196 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
24197 bytes += bytes_read;
24200 case DW_FORM_block1:
24201 bytes += 1 + read_1_byte (abfd, bytes);
24203 case DW_FORM_block2:
24204 bytes += 2 + read_2_bytes (abfd, bytes);
24206 case DW_FORM_block4:
24207 bytes += 4 + read_4_bytes (abfd, bytes);
24210 case DW_FORM_sdata:
24211 case DW_FORM_udata:
24212 case DW_FORM_GNU_addr_index:
24213 case DW_FORM_GNU_str_index:
24214 bytes = gdb_skip_leb128 (bytes, buffer_end);
24217 dwarf2_section_buffer_overflow_complaint (section);
24222 case DW_FORM_implicit_const:
24227 complaint (_("invalid form 0x%x in `%s'"),
24228 form, get_section_name (section));
24236 /* A helper for dwarf_decode_macros that handles skipping an unknown
24237 opcode. Returns an updated pointer to the macro data buffer; or,
24238 on error, issues a complaint and returns NULL. */
24240 static const gdb_byte *
24241 skip_unknown_opcode (unsigned int opcode,
24242 const gdb_byte **opcode_definitions,
24243 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24245 unsigned int offset_size,
24246 struct dwarf2_section_info *section)
24248 unsigned int bytes_read, i;
24250 const gdb_byte *defn;
24252 if (opcode_definitions[opcode] == NULL)
24254 complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24259 defn = opcode_definitions[opcode];
24260 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
24261 defn += bytes_read;
24263 for (i = 0; i < arg; ++i)
24265 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end,
24266 (enum dwarf_form) defn[i], offset_size,
24268 if (mac_ptr == NULL)
24270 /* skip_form_bytes already issued the complaint. */
24278 /* A helper function which parses the header of a macro section.
24279 If the macro section is the extended (for now called "GNU") type,
24280 then this updates *OFFSET_SIZE. Returns a pointer to just after
24281 the header, or issues a complaint and returns NULL on error. */
24283 static const gdb_byte *
24284 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
24286 const gdb_byte *mac_ptr,
24287 unsigned int *offset_size,
24288 int section_is_gnu)
24290 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
24292 if (section_is_gnu)
24294 unsigned int version, flags;
24296 version = read_2_bytes (abfd, mac_ptr);
24297 if (version != 4 && version != 5)
24299 complaint (_("unrecognized version `%d' in .debug_macro section"),
24305 flags = read_1_byte (abfd, mac_ptr);
24307 *offset_size = (flags & 1) ? 8 : 4;
24309 if ((flags & 2) != 0)
24310 /* We don't need the line table offset. */
24311 mac_ptr += *offset_size;
24313 /* Vendor opcode descriptions. */
24314 if ((flags & 4) != 0)
24316 unsigned int i, count;
24318 count = read_1_byte (abfd, mac_ptr);
24320 for (i = 0; i < count; ++i)
24322 unsigned int opcode, bytes_read;
24325 opcode = read_1_byte (abfd, mac_ptr);
24327 opcode_definitions[opcode] = mac_ptr;
24328 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24329 mac_ptr += bytes_read;
24338 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24339 including DW_MACRO_import. */
24342 dwarf_decode_macro_bytes (struct dwarf2_cu *cu,
24344 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24345 struct macro_source_file *current_file,
24346 struct line_header *lh,
24347 struct dwarf2_section_info *section,
24348 int section_is_gnu, int section_is_dwz,
24349 unsigned int offset_size,
24350 htab_t include_hash)
24352 struct dwarf2_per_objfile *dwarf2_per_objfile
24353 = cu->per_cu->dwarf2_per_objfile;
24354 struct objfile *objfile = dwarf2_per_objfile->objfile;
24355 enum dwarf_macro_record_type macinfo_type;
24356 int at_commandline;
24357 const gdb_byte *opcode_definitions[256];
24359 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24360 &offset_size, section_is_gnu);
24361 if (mac_ptr == NULL)
24363 /* We already issued a complaint. */
24367 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24368 GDB is still reading the definitions from command line. First
24369 DW_MACINFO_start_file will need to be ignored as it was already executed
24370 to create CURRENT_FILE for the main source holding also the command line
24371 definitions. On first met DW_MACINFO_start_file this flag is reset to
24372 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24374 at_commandline = 1;
24378 /* Do we at least have room for a macinfo type byte? */
24379 if (mac_ptr >= mac_end)
24381 dwarf2_section_buffer_overflow_complaint (section);
24385 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24388 /* Note that we rely on the fact that the corresponding GNU and
24389 DWARF constants are the same. */
24391 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24392 switch (macinfo_type)
24394 /* A zero macinfo type indicates the end of the macro
24399 case DW_MACRO_define:
24400 case DW_MACRO_undef:
24401 case DW_MACRO_define_strp:
24402 case DW_MACRO_undef_strp:
24403 case DW_MACRO_define_sup:
24404 case DW_MACRO_undef_sup:
24406 unsigned int bytes_read;
24411 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24412 mac_ptr += bytes_read;
24414 if (macinfo_type == DW_MACRO_define
24415 || macinfo_type == DW_MACRO_undef)
24417 body = read_direct_string (abfd, mac_ptr, &bytes_read);
24418 mac_ptr += bytes_read;
24422 LONGEST str_offset;
24424 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
24425 mac_ptr += offset_size;
24427 if (macinfo_type == DW_MACRO_define_sup
24428 || macinfo_type == DW_MACRO_undef_sup
24431 struct dwz_file *dwz
24432 = dwarf2_get_dwz_file (dwarf2_per_objfile);
24434 body = read_indirect_string_from_dwz (objfile,
24438 body = read_indirect_string_at_offset (dwarf2_per_objfile,
24442 is_define = (macinfo_type == DW_MACRO_define
24443 || macinfo_type == DW_MACRO_define_strp
24444 || macinfo_type == DW_MACRO_define_sup);
24445 if (! current_file)
24447 /* DWARF violation as no main source is present. */
24448 complaint (_("debug info with no main source gives macro %s "
24450 is_define ? _("definition") : _("undefinition"),
24454 if ((line == 0 && !at_commandline)
24455 || (line != 0 && at_commandline))
24456 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24457 at_commandline ? _("command-line") : _("in-file"),
24458 is_define ? _("definition") : _("undefinition"),
24459 line == 0 ? _("zero") : _("non-zero"), line, body);
24462 parse_macro_definition (current_file, line, body);
24465 gdb_assert (macinfo_type == DW_MACRO_undef
24466 || macinfo_type == DW_MACRO_undef_strp
24467 || macinfo_type == DW_MACRO_undef_sup);
24468 macro_undef (current_file, line, body);
24473 case DW_MACRO_start_file:
24475 unsigned int bytes_read;
24478 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24479 mac_ptr += bytes_read;
24480 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24481 mac_ptr += bytes_read;
24483 if ((line == 0 && !at_commandline)
24484 || (line != 0 && at_commandline))
24485 complaint (_("debug info gives source %d included "
24486 "from %s at %s line %d"),
24487 file, at_commandline ? _("command-line") : _("file"),
24488 line == 0 ? _("zero") : _("non-zero"), line);
24490 if (at_commandline)
24492 /* This DW_MACRO_start_file was executed in the
24494 at_commandline = 0;
24497 current_file = macro_start_file (cu, file, line, current_file,
24502 case DW_MACRO_end_file:
24503 if (! current_file)
24504 complaint (_("macro debug info has an unmatched "
24505 "`close_file' directive"));
24508 current_file = current_file->included_by;
24509 if (! current_file)
24511 enum dwarf_macro_record_type next_type;
24513 /* GCC circa March 2002 doesn't produce the zero
24514 type byte marking the end of the compilation
24515 unit. Complain if it's not there, but exit no
24518 /* Do we at least have room for a macinfo type byte? */
24519 if (mac_ptr >= mac_end)
24521 dwarf2_section_buffer_overflow_complaint (section);
24525 /* We don't increment mac_ptr here, so this is just
24528 = (enum dwarf_macro_record_type) read_1_byte (abfd,
24530 if (next_type != 0)
24531 complaint (_("no terminating 0-type entry for "
24532 "macros in `.debug_macinfo' section"));
24539 case DW_MACRO_import:
24540 case DW_MACRO_import_sup:
24544 bfd *include_bfd = abfd;
24545 struct dwarf2_section_info *include_section = section;
24546 const gdb_byte *include_mac_end = mac_end;
24547 int is_dwz = section_is_dwz;
24548 const gdb_byte *new_mac_ptr;
24550 offset = read_offset_1 (abfd, mac_ptr, offset_size);
24551 mac_ptr += offset_size;
24553 if (macinfo_type == DW_MACRO_import_sup)
24555 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
24557 dwarf2_read_section (objfile, &dwz->macro);
24559 include_section = &dwz->macro;
24560 include_bfd = get_section_bfd_owner (include_section);
24561 include_mac_end = dwz->macro.buffer + dwz->macro.size;
24565 new_mac_ptr = include_section->buffer + offset;
24566 slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
24570 /* This has actually happened; see
24571 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
24572 complaint (_("recursive DW_MACRO_import in "
24573 ".debug_macro section"));
24577 *slot = (void *) new_mac_ptr;
24579 dwarf_decode_macro_bytes (cu, include_bfd, new_mac_ptr,
24580 include_mac_end, current_file, lh,
24581 section, section_is_gnu, is_dwz,
24582 offset_size, include_hash);
24584 htab_remove_elt (include_hash, (void *) new_mac_ptr);
24589 case DW_MACINFO_vendor_ext:
24590 if (!section_is_gnu)
24592 unsigned int bytes_read;
24594 /* This reads the constant, but since we don't recognize
24595 any vendor extensions, we ignore it. */
24596 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24597 mac_ptr += bytes_read;
24598 read_direct_string (abfd, mac_ptr, &bytes_read);
24599 mac_ptr += bytes_read;
24601 /* We don't recognize any vendor extensions. */
24607 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24608 mac_ptr, mac_end, abfd, offset_size,
24610 if (mac_ptr == NULL)
24615 } while (macinfo_type != 0);
24619 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
24620 int section_is_gnu)
24622 struct dwarf2_per_objfile *dwarf2_per_objfile
24623 = cu->per_cu->dwarf2_per_objfile;
24624 struct objfile *objfile = dwarf2_per_objfile->objfile;
24625 struct line_header *lh = cu->line_header;
24627 const gdb_byte *mac_ptr, *mac_end;
24628 struct macro_source_file *current_file = 0;
24629 enum dwarf_macro_record_type macinfo_type;
24630 unsigned int offset_size = cu->header.offset_size;
24631 const gdb_byte *opcode_definitions[256];
24633 struct dwarf2_section_info *section;
24634 const char *section_name;
24636 if (cu->dwo_unit != NULL)
24638 if (section_is_gnu)
24640 section = &cu->dwo_unit->dwo_file->sections.macro;
24641 section_name = ".debug_macro.dwo";
24645 section = &cu->dwo_unit->dwo_file->sections.macinfo;
24646 section_name = ".debug_macinfo.dwo";
24651 if (section_is_gnu)
24653 section = &dwarf2_per_objfile->macro;
24654 section_name = ".debug_macro";
24658 section = &dwarf2_per_objfile->macinfo;
24659 section_name = ".debug_macinfo";
24663 dwarf2_read_section (objfile, section);
24664 if (section->buffer == NULL)
24666 complaint (_("missing %s section"), section_name);
24669 abfd = get_section_bfd_owner (section);
24671 /* First pass: Find the name of the base filename.
24672 This filename is needed in order to process all macros whose definition
24673 (or undefinition) comes from the command line. These macros are defined
24674 before the first DW_MACINFO_start_file entry, and yet still need to be
24675 associated to the base file.
24677 To determine the base file name, we scan the macro definitions until we
24678 reach the first DW_MACINFO_start_file entry. We then initialize
24679 CURRENT_FILE accordingly so that any macro definition found before the
24680 first DW_MACINFO_start_file can still be associated to the base file. */
24682 mac_ptr = section->buffer + offset;
24683 mac_end = section->buffer + section->size;
24685 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24686 &offset_size, section_is_gnu);
24687 if (mac_ptr == NULL)
24689 /* We already issued a complaint. */
24695 /* Do we at least have room for a macinfo type byte? */
24696 if (mac_ptr >= mac_end)
24698 /* Complaint is printed during the second pass as GDB will probably
24699 stop the first pass earlier upon finding
24700 DW_MACINFO_start_file. */
24704 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24707 /* Note that we rely on the fact that the corresponding GNU and
24708 DWARF constants are the same. */
24710 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24711 switch (macinfo_type)
24713 /* A zero macinfo type indicates the end of the macro
24718 case DW_MACRO_define:
24719 case DW_MACRO_undef:
24720 /* Only skip the data by MAC_PTR. */
24722 unsigned int bytes_read;
24724 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24725 mac_ptr += bytes_read;
24726 read_direct_string (abfd, mac_ptr, &bytes_read);
24727 mac_ptr += bytes_read;
24731 case DW_MACRO_start_file:
24733 unsigned int bytes_read;
24736 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24737 mac_ptr += bytes_read;
24738 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24739 mac_ptr += bytes_read;
24741 current_file = macro_start_file (cu, file, line, current_file, lh);
24745 case DW_MACRO_end_file:
24746 /* No data to skip by MAC_PTR. */
24749 case DW_MACRO_define_strp:
24750 case DW_MACRO_undef_strp:
24751 case DW_MACRO_define_sup:
24752 case DW_MACRO_undef_sup:
24754 unsigned int bytes_read;
24756 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24757 mac_ptr += bytes_read;
24758 mac_ptr += offset_size;
24762 case DW_MACRO_import:
24763 case DW_MACRO_import_sup:
24764 /* Note that, according to the spec, a transparent include
24765 chain cannot call DW_MACRO_start_file. So, we can just
24766 skip this opcode. */
24767 mac_ptr += offset_size;
24770 case DW_MACINFO_vendor_ext:
24771 /* Only skip the data by MAC_PTR. */
24772 if (!section_is_gnu)
24774 unsigned int bytes_read;
24776 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24777 mac_ptr += bytes_read;
24778 read_direct_string (abfd, mac_ptr, &bytes_read);
24779 mac_ptr += bytes_read;
24784 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24785 mac_ptr, mac_end, abfd, offset_size,
24787 if (mac_ptr == NULL)
24792 } while (macinfo_type != 0 && current_file == NULL);
24794 /* Second pass: Process all entries.
24796 Use the AT_COMMAND_LINE flag to determine whether we are still processing
24797 command-line macro definitions/undefinitions. This flag is unset when we
24798 reach the first DW_MACINFO_start_file entry. */
24800 htab_up include_hash (htab_create_alloc (1, htab_hash_pointer,
24802 NULL, xcalloc, xfree));
24803 mac_ptr = section->buffer + offset;
24804 slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT);
24805 *slot = (void *) mac_ptr;
24806 dwarf_decode_macro_bytes (cu, abfd, mac_ptr, mac_end,
24807 current_file, lh, section,
24808 section_is_gnu, 0, offset_size,
24809 include_hash.get ());
24812 /* Check if the attribute's form is a DW_FORM_block*
24813 if so return true else false. */
24816 attr_form_is_block (const struct attribute *attr)
24818 return (attr == NULL ? 0 :
24819 attr->form == DW_FORM_block1
24820 || attr->form == DW_FORM_block2
24821 || attr->form == DW_FORM_block4
24822 || attr->form == DW_FORM_block
24823 || attr->form == DW_FORM_exprloc);
24826 /* Return non-zero if ATTR's value is a section offset --- classes
24827 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24828 You may use DW_UNSND (attr) to retrieve such offsets.
24830 Section 7.5.4, "Attribute Encodings", explains that no attribute
24831 may have a value that belongs to more than one of these classes; it
24832 would be ambiguous if we did, because we use the same forms for all
24836 attr_form_is_section_offset (const struct attribute *attr)
24838 return (attr->form == DW_FORM_data4
24839 || attr->form == DW_FORM_data8
24840 || attr->form == DW_FORM_sec_offset);
24843 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24844 zero otherwise. When this function returns true, you can apply
24845 dwarf2_get_attr_constant_value to it.
24847 However, note that for some attributes you must check
24848 attr_form_is_section_offset before using this test. DW_FORM_data4
24849 and DW_FORM_data8 are members of both the constant class, and of
24850 the classes that contain offsets into other debug sections
24851 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
24852 that, if an attribute's can be either a constant or one of the
24853 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
24854 taken as section offsets, not constants.
24856 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
24857 cannot handle that. */
24860 attr_form_is_constant (const struct attribute *attr)
24862 switch (attr->form)
24864 case DW_FORM_sdata:
24865 case DW_FORM_udata:
24866 case DW_FORM_data1:
24867 case DW_FORM_data2:
24868 case DW_FORM_data4:
24869 case DW_FORM_data8:
24870 case DW_FORM_implicit_const:
24878 /* DW_ADDR is always stored already as sect_offset; despite for the forms
24879 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
24882 attr_form_is_ref (const struct attribute *attr)
24884 switch (attr->form)
24886 case DW_FORM_ref_addr:
24891 case DW_FORM_ref_udata:
24892 case DW_FORM_GNU_ref_alt:
24899 /* Return the .debug_loc section to use for CU.
24900 For DWO files use .debug_loc.dwo. */
24902 static struct dwarf2_section_info *
24903 cu_debug_loc_section (struct dwarf2_cu *cu)
24905 struct dwarf2_per_objfile *dwarf2_per_objfile
24906 = cu->per_cu->dwarf2_per_objfile;
24910 struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections;
24912 return cu->header.version >= 5 ? §ions->loclists : §ions->loc;
24914 return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
24915 : &dwarf2_per_objfile->loc);
24918 /* A helper function that fills in a dwarf2_loclist_baton. */
24921 fill_in_loclist_baton (struct dwarf2_cu *cu,
24922 struct dwarf2_loclist_baton *baton,
24923 const struct attribute *attr)
24925 struct dwarf2_per_objfile *dwarf2_per_objfile
24926 = cu->per_cu->dwarf2_per_objfile;
24927 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24929 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
24931 baton->per_cu = cu->per_cu;
24932 gdb_assert (baton->per_cu);
24933 /* We don't know how long the location list is, but make sure we
24934 don't run off the edge of the section. */
24935 baton->size = section->size - DW_UNSND (attr);
24936 baton->data = section->buffer + DW_UNSND (attr);
24937 baton->base_address = cu->base_address;
24938 baton->from_dwo = cu->dwo_unit != NULL;
24942 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
24943 struct dwarf2_cu *cu, int is_block)
24945 struct dwarf2_per_objfile *dwarf2_per_objfile
24946 = cu->per_cu->dwarf2_per_objfile;
24947 struct objfile *objfile = dwarf2_per_objfile->objfile;
24948 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24950 if (attr_form_is_section_offset (attr)
24951 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24952 the section. If so, fall through to the complaint in the
24954 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
24956 struct dwarf2_loclist_baton *baton;
24958 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
24960 fill_in_loclist_baton (cu, baton, attr);
24962 if (cu->base_known == 0)
24963 complaint (_("Location list used without "
24964 "specifying the CU base address."));
24966 SYMBOL_ACLASS_INDEX (sym) = (is_block
24967 ? dwarf2_loclist_block_index
24968 : dwarf2_loclist_index);
24969 SYMBOL_LOCATION_BATON (sym) = baton;
24973 struct dwarf2_locexpr_baton *baton;
24975 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
24976 baton->per_cu = cu->per_cu;
24977 gdb_assert (baton->per_cu);
24979 if (attr_form_is_block (attr))
24981 /* Note that we're just copying the block's data pointer
24982 here, not the actual data. We're still pointing into the
24983 info_buffer for SYM's objfile; right now we never release
24984 that buffer, but when we do clean up properly this may
24986 baton->size = DW_BLOCK (attr)->size;
24987 baton->data = DW_BLOCK (attr)->data;
24991 dwarf2_invalid_attrib_class_complaint ("location description",
24992 SYMBOL_NATURAL_NAME (sym));
24996 SYMBOL_ACLASS_INDEX (sym) = (is_block
24997 ? dwarf2_locexpr_block_index
24998 : dwarf2_locexpr_index);
24999 SYMBOL_LOCATION_BATON (sym) = baton;
25003 /* Return the OBJFILE associated with the compilation unit CU. If CU
25004 came from a separate debuginfo file, then the master objfile is
25008 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
25010 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25012 /* Return the master objfile, so that we can report and look up the
25013 correct file containing this variable. */
25014 if (objfile->separate_debug_objfile_backlink)
25015 objfile = objfile->separate_debug_objfile_backlink;
25020 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25021 (CU_HEADERP is unused in such case) or prepare a temporary copy at
25022 CU_HEADERP first. */
25024 static const struct comp_unit_head *
25025 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
25026 struct dwarf2_per_cu_data *per_cu)
25028 const gdb_byte *info_ptr;
25031 return &per_cu->cu->header;
25033 info_ptr = per_cu->section->buffer + to_underlying (per_cu->sect_off);
25035 memset (cu_headerp, 0, sizeof (*cu_headerp));
25036 read_comp_unit_head (cu_headerp, info_ptr, per_cu->section,
25037 rcuh_kind::COMPILE);
25042 /* Return the address size given in the compilation unit header for CU. */
25045 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
25047 struct comp_unit_head cu_header_local;
25048 const struct comp_unit_head *cu_headerp;
25050 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25052 return cu_headerp->addr_size;
25055 /* Return the offset size given in the compilation unit header for CU. */
25058 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
25060 struct comp_unit_head cu_header_local;
25061 const struct comp_unit_head *cu_headerp;
25063 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25065 return cu_headerp->offset_size;
25068 /* See its dwarf2loc.h declaration. */
25071 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
25073 struct comp_unit_head cu_header_local;
25074 const struct comp_unit_head *cu_headerp;
25076 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25078 if (cu_headerp->version == 2)
25079 return cu_headerp->addr_size;
25081 return cu_headerp->offset_size;
25084 /* Return the text offset of the CU. The returned offset comes from
25085 this CU's objfile. If this objfile came from a separate debuginfo
25086 file, then the offset may be different from the corresponding
25087 offset in the parent objfile. */
25090 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
25092 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25094 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
25097 /* Return DWARF version number of PER_CU. */
25100 dwarf2_version (struct dwarf2_per_cu_data *per_cu)
25102 return per_cu->dwarf_version;
25105 /* Locate the .debug_info compilation unit from CU's objfile which contains
25106 the DIE at OFFSET. Raises an error on failure. */
25108 static struct dwarf2_per_cu_data *
25109 dwarf2_find_containing_comp_unit (sect_offset sect_off,
25110 unsigned int offset_in_dwz,
25111 struct dwarf2_per_objfile *dwarf2_per_objfile)
25113 struct dwarf2_per_cu_data *this_cu;
25117 high = dwarf2_per_objfile->all_comp_units.size () - 1;
25120 struct dwarf2_per_cu_data *mid_cu;
25121 int mid = low + (high - low) / 2;
25123 mid_cu = dwarf2_per_objfile->all_comp_units[mid];
25124 if (mid_cu->is_dwz > offset_in_dwz
25125 || (mid_cu->is_dwz == offset_in_dwz
25126 && mid_cu->sect_off + mid_cu->length >= sect_off))
25131 gdb_assert (low == high);
25132 this_cu = dwarf2_per_objfile->all_comp_units[low];
25133 if (this_cu->is_dwz != offset_in_dwz || this_cu->sect_off > sect_off)
25135 if (low == 0 || this_cu->is_dwz != offset_in_dwz)
25136 error (_("Dwarf Error: could not find partial DIE containing "
25137 "offset %s [in module %s]"),
25138 sect_offset_str (sect_off),
25139 bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
25141 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
25143 return dwarf2_per_objfile->all_comp_units[low-1];
25147 this_cu = dwarf2_per_objfile->all_comp_units[low];
25148 if (low == dwarf2_per_objfile->all_comp_units.size () - 1
25149 && sect_off >= this_cu->sect_off + this_cu->length)
25150 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
25151 gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
25156 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25158 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data *per_cu_)
25159 : per_cu (per_cu_),
25161 has_loclist (false),
25162 checked_producer (false),
25163 producer_is_gxx_lt_4_6 (false),
25164 producer_is_gcc_lt_4_3 (false),
25165 producer_is_icc (false),
25166 producer_is_icc_lt_14 (false),
25167 producer_is_codewarrior (false),
25168 processing_has_namespace_info (false)
25173 /* Destroy a dwarf2_cu. */
25175 dwarf2_cu::~dwarf2_cu ()
25180 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25183 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
25184 enum language pretend_language)
25186 struct attribute *attr;
25188 /* Set the language we're debugging. */
25189 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
25191 set_cu_language (DW_UNSND (attr), cu);
25194 cu->language = pretend_language;
25195 cu->language_defn = language_def (cu->language);
25198 cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
25201 /* Increase the age counter on each cached compilation unit, and free
25202 any that are too old. */
25205 age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
25207 struct dwarf2_per_cu_data *per_cu, **last_chain;
25209 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
25210 per_cu = dwarf2_per_objfile->read_in_chain;
25211 while (per_cu != NULL)
25213 per_cu->cu->last_used ++;
25214 if (per_cu->cu->last_used <= dwarf_max_cache_age)
25215 dwarf2_mark (per_cu->cu);
25216 per_cu = per_cu->cu->read_in_chain;
25219 per_cu = dwarf2_per_objfile->read_in_chain;
25220 last_chain = &dwarf2_per_objfile->read_in_chain;
25221 while (per_cu != NULL)
25223 struct dwarf2_per_cu_data *next_cu;
25225 next_cu = per_cu->cu->read_in_chain;
25227 if (!per_cu->cu->mark)
25230 *last_chain = next_cu;
25233 last_chain = &per_cu->cu->read_in_chain;
25239 /* Remove a single compilation unit from the cache. */
25242 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
25244 struct dwarf2_per_cu_data *per_cu, **last_chain;
25245 struct dwarf2_per_objfile *dwarf2_per_objfile
25246 = target_per_cu->dwarf2_per_objfile;
25248 per_cu = dwarf2_per_objfile->read_in_chain;
25249 last_chain = &dwarf2_per_objfile->read_in_chain;
25250 while (per_cu != NULL)
25252 struct dwarf2_per_cu_data *next_cu;
25254 next_cu = per_cu->cu->read_in_chain;
25256 if (per_cu == target_per_cu)
25260 *last_chain = next_cu;
25264 last_chain = &per_cu->cu->read_in_chain;
25270 /* Cleanup function for the dwarf2_per_objfile data. */
25273 dwarf2_free_objfile (struct objfile *objfile, void *datum)
25275 struct dwarf2_per_objfile *dwarf2_per_objfile
25276 = static_cast<struct dwarf2_per_objfile *> (datum);
25278 delete dwarf2_per_objfile;
25281 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25282 We store these in a hash table separate from the DIEs, and preserve them
25283 when the DIEs are flushed out of cache.
25285 The CU "per_cu" pointer is needed because offset alone is not enough to
25286 uniquely identify the type. A file may have multiple .debug_types sections,
25287 or the type may come from a DWO file. Furthermore, while it's more logical
25288 to use per_cu->section+offset, with Fission the section with the data is in
25289 the DWO file but we don't know that section at the point we need it.
25290 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25291 because we can enter the lookup routine, get_die_type_at_offset, from
25292 outside this file, and thus won't necessarily have PER_CU->cu.
25293 Fortunately, PER_CU is stable for the life of the objfile. */
25295 struct dwarf2_per_cu_offset_and_type
25297 const struct dwarf2_per_cu_data *per_cu;
25298 sect_offset sect_off;
25302 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25305 per_cu_offset_and_type_hash (const void *item)
25307 const struct dwarf2_per_cu_offset_and_type *ofs
25308 = (const struct dwarf2_per_cu_offset_and_type *) item;
25310 return (uintptr_t) ofs->per_cu + to_underlying (ofs->sect_off);
25313 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25316 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
25318 const struct dwarf2_per_cu_offset_and_type *ofs_lhs
25319 = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
25320 const struct dwarf2_per_cu_offset_and_type *ofs_rhs
25321 = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
25323 return (ofs_lhs->per_cu == ofs_rhs->per_cu
25324 && ofs_lhs->sect_off == ofs_rhs->sect_off);
25327 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25328 table if necessary. For convenience, return TYPE.
25330 The DIEs reading must have careful ordering to:
25331 * Not cause infite loops trying to read in DIEs as a prerequisite for
25332 reading current DIE.
25333 * Not trying to dereference contents of still incompletely read in types
25334 while reading in other DIEs.
25335 * Enable referencing still incompletely read in types just by a pointer to
25336 the type without accessing its fields.
25338 Therefore caller should follow these rules:
25339 * Try to fetch any prerequisite types we may need to build this DIE type
25340 before building the type and calling set_die_type.
25341 * After building type call set_die_type for current DIE as soon as
25342 possible before fetching more types to complete the current type.
25343 * Make the type as complete as possible before fetching more types. */
25345 static struct type *
25346 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
25348 struct dwarf2_per_objfile *dwarf2_per_objfile
25349 = cu->per_cu->dwarf2_per_objfile;
25350 struct dwarf2_per_cu_offset_and_type **slot, ofs;
25351 struct objfile *objfile = dwarf2_per_objfile->objfile;
25352 struct attribute *attr;
25353 struct dynamic_prop prop;
25355 /* For Ada types, make sure that the gnat-specific data is always
25356 initialized (if not already set). There are a few types where
25357 we should not be doing so, because the type-specific area is
25358 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25359 where the type-specific area is used to store the floatformat).
25360 But this is not a problem, because the gnat-specific information
25361 is actually not needed for these types. */
25362 if (need_gnat_info (cu)
25363 && TYPE_CODE (type) != TYPE_CODE_FUNC
25364 && TYPE_CODE (type) != TYPE_CODE_FLT
25365 && TYPE_CODE (type) != TYPE_CODE_METHODPTR
25366 && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
25367 && TYPE_CODE (type) != TYPE_CODE_METHOD
25368 && !HAVE_GNAT_AUX_INFO (type))
25369 INIT_GNAT_SPECIFIC (type);
25371 /* Read DW_AT_allocated and set in type. */
25372 attr = dwarf2_attr (die, DW_AT_allocated, cu);
25373 if (attr_form_is_block (attr))
25375 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25376 add_dyn_prop (DYN_PROP_ALLOCATED, prop, type);
25378 else if (attr != NULL)
25380 complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25381 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25382 sect_offset_str (die->sect_off));
25385 /* Read DW_AT_associated and set in type. */
25386 attr = dwarf2_attr (die, DW_AT_associated, cu);
25387 if (attr_form_is_block (attr))
25389 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25390 add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type);
25392 else if (attr != NULL)
25394 complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25395 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25396 sect_offset_str (die->sect_off));
25399 /* Read DW_AT_data_location and set in type. */
25400 attr = dwarf2_attr (die, DW_AT_data_location, cu);
25401 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25402 add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type);
25404 if (dwarf2_per_objfile->die_type_hash == NULL)
25406 dwarf2_per_objfile->die_type_hash =
25407 htab_create_alloc_ex (127,
25408 per_cu_offset_and_type_hash,
25409 per_cu_offset_and_type_eq,
25411 &objfile->objfile_obstack,
25412 hashtab_obstack_allocate,
25413 dummy_obstack_deallocate);
25416 ofs.per_cu = cu->per_cu;
25417 ofs.sect_off = die->sect_off;
25419 slot = (struct dwarf2_per_cu_offset_and_type **)
25420 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
25422 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25423 sect_offset_str (die->sect_off));
25424 *slot = XOBNEW (&objfile->objfile_obstack,
25425 struct dwarf2_per_cu_offset_and_type);
25430 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25431 or return NULL if the die does not have a saved type. */
25433 static struct type *
25434 get_die_type_at_offset (sect_offset sect_off,
25435 struct dwarf2_per_cu_data *per_cu)
25437 struct dwarf2_per_cu_offset_and_type *slot, ofs;
25438 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
25440 if (dwarf2_per_objfile->die_type_hash == NULL)
25443 ofs.per_cu = per_cu;
25444 ofs.sect_off = sect_off;
25445 slot = ((struct dwarf2_per_cu_offset_and_type *)
25446 htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
25453 /* Look up the type for DIE in CU in die_type_hash,
25454 or return NULL if DIE does not have a saved type. */
25456 static struct type *
25457 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
25459 return get_die_type_at_offset (die->sect_off, cu->per_cu);
25462 /* Add a dependence relationship from CU to REF_PER_CU. */
25465 dwarf2_add_dependence (struct dwarf2_cu *cu,
25466 struct dwarf2_per_cu_data *ref_per_cu)
25470 if (cu->dependencies == NULL)
25472 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
25473 NULL, &cu->comp_unit_obstack,
25474 hashtab_obstack_allocate,
25475 dummy_obstack_deallocate);
25477 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
25479 *slot = ref_per_cu;
25482 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25483 Set the mark field in every compilation unit in the
25484 cache that we must keep because we are keeping CU. */
25487 dwarf2_mark_helper (void **slot, void *data)
25489 struct dwarf2_per_cu_data *per_cu;
25491 per_cu = (struct dwarf2_per_cu_data *) *slot;
25493 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25494 reading of the chain. As such dependencies remain valid it is not much
25495 useful to track and undo them during QUIT cleanups. */
25496 if (per_cu->cu == NULL)
25499 if (per_cu->cu->mark)
25501 per_cu->cu->mark = true;
25503 if (per_cu->cu->dependencies != NULL)
25504 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
25509 /* Set the mark field in CU and in every other compilation unit in the
25510 cache that we must keep because we are keeping CU. */
25513 dwarf2_mark (struct dwarf2_cu *cu)
25518 if (cu->dependencies != NULL)
25519 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
25523 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
25527 per_cu->cu->mark = false;
25528 per_cu = per_cu->cu->read_in_chain;
25532 /* Trivial hash function for partial_die_info: the hash value of a DIE
25533 is its offset in .debug_info for this objfile. */
25536 partial_die_hash (const void *item)
25538 const struct partial_die_info *part_die
25539 = (const struct partial_die_info *) item;
25541 return to_underlying (part_die->sect_off);
25544 /* Trivial comparison function for partial_die_info structures: two DIEs
25545 are equal if they have the same offset. */
25548 partial_die_eq (const void *item_lhs, const void *item_rhs)
25550 const struct partial_die_info *part_die_lhs
25551 = (const struct partial_die_info *) item_lhs;
25552 const struct partial_die_info *part_die_rhs
25553 = (const struct partial_die_info *) item_rhs;
25555 return part_die_lhs->sect_off == part_die_rhs->sect_off;
25558 struct cmd_list_element *set_dwarf_cmdlist;
25559 struct cmd_list_element *show_dwarf_cmdlist;
25562 set_dwarf_cmd (const char *args, int from_tty)
25564 help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
25569 show_dwarf_cmd (const char *args, int from_tty)
25571 cmd_show_list (show_dwarf_cmdlist, from_tty, "");
25574 int dwarf_always_disassemble;
25577 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
25578 struct cmd_list_element *c, const char *value)
25580 fprintf_filtered (file,
25581 _("Whether to always disassemble "
25582 "DWARF expressions is %s.\n"),
25587 show_check_physname (struct ui_file *file, int from_tty,
25588 struct cmd_list_element *c, const char *value)
25590 fprintf_filtered (file,
25591 _("Whether to check \"physname\" is %s.\n"),
25596 _initialize_dwarf2_read (void)
25598 dwarf2_objfile_data_key
25599 = register_objfile_data_with_cleanup (nullptr, dwarf2_free_objfile);
25601 add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
25602 Set DWARF specific variables.\n\
25603 Configure DWARF variables such as the cache size"),
25604 &set_dwarf_cmdlist, "maintenance set dwarf ",
25605 0/*allow-unknown*/, &maintenance_set_cmdlist);
25607 add_prefix_cmd ("dwarf", class_maintenance, show_dwarf_cmd, _("\
25608 Show DWARF specific variables\n\
25609 Show DWARF variables such as the cache size"),
25610 &show_dwarf_cmdlist, "maintenance show dwarf ",
25611 0/*allow-unknown*/, &maintenance_show_cmdlist);
25613 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
25614 &dwarf_max_cache_age, _("\
25615 Set the upper bound on the age of cached DWARF compilation units."), _("\
25616 Show the upper bound on the age of cached DWARF compilation units."), _("\
25617 A higher limit means that cached compilation units will be stored\n\
25618 in memory longer, and more total memory will be used. Zero disables\n\
25619 caching, which can slow down startup."),
25621 show_dwarf_max_cache_age,
25622 &set_dwarf_cmdlist,
25623 &show_dwarf_cmdlist);
25625 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
25626 &dwarf_always_disassemble, _("\
25627 Set whether `info address' always disassembles DWARF expressions."), _("\
25628 Show whether `info address' always disassembles DWARF expressions."), _("\
25629 When enabled, DWARF expressions are always printed in an assembly-like\n\
25630 syntax. When disabled, expressions will be printed in a more\n\
25631 conversational style, when possible."),
25633 show_dwarf_always_disassemble,
25634 &set_dwarf_cmdlist,
25635 &show_dwarf_cmdlist);
25637 add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
25638 Set debugging of the DWARF reader."), _("\
25639 Show debugging of the DWARF reader."), _("\
25640 When enabled (non-zero), debugging messages are printed during DWARF\n\
25641 reading and symtab expansion. A value of 1 (one) provides basic\n\
25642 information. A value greater than 1 provides more verbose information."),
25645 &setdebuglist, &showdebuglist);
25647 add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
25648 Set debugging of the DWARF DIE reader."), _("\
25649 Show debugging of the DWARF DIE reader."), _("\
25650 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25651 The value is the maximum depth to print."),
25654 &setdebuglist, &showdebuglist);
25656 add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
25657 Set debugging of the dwarf line reader."), _("\
25658 Show debugging of the dwarf line reader."), _("\
25659 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25660 A value of 1 (one) provides basic information.\n\
25661 A value greater than 1 provides more verbose information."),
25664 &setdebuglist, &showdebuglist);
25666 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
25667 Set cross-checking of \"physname\" code against demangler."), _("\
25668 Show cross-checking of \"physname\" code against demangler."), _("\
25669 When enabled, GDB's internal \"physname\" code is checked against\n\
25671 NULL, show_check_physname,
25672 &setdebuglist, &showdebuglist);
25674 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25675 no_class, &use_deprecated_index_sections, _("\
25676 Set whether to use deprecated gdb_index sections."), _("\
25677 Show whether to use deprecated gdb_index sections."), _("\
25678 When enabled, deprecated .gdb_index sections are used anyway.\n\
25679 Normally they are ignored either because of a missing feature or\n\
25680 performance issue.\n\
25681 Warning: This option must be enabled before gdb reads the file."),
25684 &setlist, &showlist);
25686 dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
25687 &dwarf2_locexpr_funcs);
25688 dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
25689 &dwarf2_loclist_funcs);
25691 dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
25692 &dwarf2_block_frame_base_locexpr_funcs);
25693 dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
25694 &dwarf2_block_frame_base_loclist_funcs);
25697 selftests::register_test ("dw2_expand_symtabs_matching",
25698 selftests::dw2_expand_symtabs_matching::run_test);