1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2019 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* FIXME: Various die-reading functions need to be more careful with
28 reading off the end of the section.
29 E.g., load_partial_dies, read_partial_die. */
32 #include "dwarf2read.h"
33 #include "dwarf-index-cache.h"
34 #include "dwarf-index-common.h"
43 #include "gdb-demangle.h"
44 #include "expression.h"
45 #include "filenames.h" /* for DOSish file names */
48 #include "complaints.h"
50 #include "dwarf2expr.h"
51 #include "dwarf2loc.h"
52 #include "cp-support.h"
58 #include "typeprint.h"
61 #include "completer.h"
66 #include "gdbcore.h" /* for gnutarget */
67 #include "gdb/gdb-index.h"
72 #include "filestuff.h"
74 #include "namespace.h"
75 #include "common/gdb_unlinker.h"
76 #include "common/function-view.h"
77 #include "common/gdb_optional.h"
78 #include "common/underlying.h"
79 #include "common/byte-vector.h"
80 #include "common/hash_enum.h"
81 #include "filename-seen-cache.h"
84 #include <sys/types.h>
86 #include <unordered_set>
87 #include <unordered_map>
91 #include <forward_list>
92 #include "rust-lang.h"
93 #include "common/pathstuff.h"
95 /* When == 1, print basic high level tracing messages.
96 When > 1, be more verbose.
97 This is in contrast to the low level DIE reading of dwarf_die_debug. */
98 static unsigned int dwarf_read_debug = 0;
100 /* When non-zero, dump DIEs after they are read in. */
101 static unsigned int dwarf_die_debug = 0;
103 /* When non-zero, dump line number entries as they are read in. */
104 static unsigned int dwarf_line_debug = 0;
106 /* When non-zero, cross-check physname against demangler. */
107 static int check_physname = 0;
109 /* When non-zero, do not reject deprecated .gdb_index sections. */
110 static int use_deprecated_index_sections = 0;
112 static const struct objfile_data *dwarf2_objfile_data_key;
114 /* The "aclass" indices for various kinds of computed DWARF symbols. */
116 static int dwarf2_locexpr_index;
117 static int dwarf2_loclist_index;
118 static int dwarf2_locexpr_block_index;
119 static int dwarf2_loclist_block_index;
121 /* An index into a (C++) symbol name component in a symbol name as
122 recorded in the mapped_index's symbol table. For each C++ symbol
123 in the symbol table, we record one entry for the start of each
124 component in the symbol in a table of name components, and then
125 sort the table, in order to be able to binary search symbol names,
126 ignoring leading namespaces, both completion and regular look up.
127 For example, for symbol "A::B::C", we'll have an entry that points
128 to "A::B::C", another that points to "B::C", and another for "C".
129 Note that function symbols in GDB index have no parameter
130 information, just the function/method names. You can convert a
131 name_component to a "const char *" using the
132 'mapped_index::symbol_name_at(offset_type)' method. */
134 struct name_component
136 /* Offset in the symbol name where the component starts. Stored as
137 a (32-bit) offset instead of a pointer to save memory and improve
138 locality on 64-bit architectures. */
139 offset_type name_offset;
141 /* The symbol's index in the symbol and constant pool tables of a
146 /* Base class containing bits shared by both .gdb_index and
147 .debug_name indexes. */
149 struct mapped_index_base
151 mapped_index_base () = default;
152 DISABLE_COPY_AND_ASSIGN (mapped_index_base);
154 /* The name_component table (a sorted vector). See name_component's
155 description above. */
156 std::vector<name_component> name_components;
158 /* How NAME_COMPONENTS is sorted. */
159 enum case_sensitivity name_components_casing;
161 /* Return the number of names in the symbol table. */
162 virtual size_t symbol_name_count () const = 0;
164 /* Get the name of the symbol at IDX in the symbol table. */
165 virtual const char *symbol_name_at (offset_type idx) const = 0;
167 /* Return whether the name at IDX in the symbol table should be
169 virtual bool symbol_name_slot_invalid (offset_type idx) const
174 /* Build the symbol name component sorted vector, if we haven't
176 void build_name_components ();
178 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
179 possible matches for LN_NO_PARAMS in the name component
181 std::pair<std::vector<name_component>::const_iterator,
182 std::vector<name_component>::const_iterator>
183 find_name_components_bounds (const lookup_name_info &ln_no_params) const;
185 /* Prevent deleting/destroying via a base class pointer. */
187 ~mapped_index_base() = default;
190 /* A description of the mapped index. The file format is described in
191 a comment by the code that writes the index. */
192 struct mapped_index final : public mapped_index_base
194 /* A slot/bucket in the symbol table hash. */
195 struct symbol_table_slot
197 const offset_type name;
198 const offset_type vec;
201 /* Index data format version. */
204 /* The address table data. */
205 gdb::array_view<const gdb_byte> address_table;
207 /* The symbol table, implemented as a hash table. */
208 gdb::array_view<symbol_table_slot> symbol_table;
210 /* A pointer to the constant pool. */
211 const char *constant_pool = nullptr;
213 bool symbol_name_slot_invalid (offset_type idx) const override
215 const auto &bucket = this->symbol_table[idx];
216 return bucket.name == 0 && bucket.vec;
219 /* Convenience method to get at the name of the symbol at IDX in the
221 const char *symbol_name_at (offset_type idx) const override
222 { return this->constant_pool + MAYBE_SWAP (this->symbol_table[idx].name); }
224 size_t symbol_name_count () const override
225 { return this->symbol_table.size (); }
228 /* A description of the mapped .debug_names.
229 Uninitialized map has CU_COUNT 0. */
230 struct mapped_debug_names final : public mapped_index_base
232 mapped_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile_)
233 : dwarf2_per_objfile (dwarf2_per_objfile_)
236 struct dwarf2_per_objfile *dwarf2_per_objfile;
237 bfd_endian dwarf5_byte_order;
238 bool dwarf5_is_dwarf64;
239 bool augmentation_is_gdb;
241 uint32_t cu_count = 0;
242 uint32_t tu_count, bucket_count, name_count;
243 const gdb_byte *cu_table_reordered, *tu_table_reordered;
244 const uint32_t *bucket_table_reordered, *hash_table_reordered;
245 const gdb_byte *name_table_string_offs_reordered;
246 const gdb_byte *name_table_entry_offs_reordered;
247 const gdb_byte *entry_pool;
254 /* Attribute name DW_IDX_*. */
257 /* Attribute form DW_FORM_*. */
260 /* Value if FORM is DW_FORM_implicit_const. */
261 LONGEST implicit_const;
263 std::vector<attr> attr_vec;
266 std::unordered_map<ULONGEST, index_val> abbrev_map;
268 const char *namei_to_name (uint32_t namei) const;
270 /* Implementation of the mapped_index_base virtual interface, for
271 the name_components cache. */
273 const char *symbol_name_at (offset_type idx) const override
274 { return namei_to_name (idx); }
276 size_t symbol_name_count () const override
277 { return this->name_count; }
280 /* See dwarf2read.h. */
283 get_dwarf2_per_objfile (struct objfile *objfile)
285 return ((struct dwarf2_per_objfile *)
286 objfile_data (objfile, dwarf2_objfile_data_key));
289 /* Set the dwarf2_per_objfile associated to OBJFILE. */
292 set_dwarf2_per_objfile (struct objfile *objfile,
293 struct dwarf2_per_objfile *dwarf2_per_objfile)
295 gdb_assert (get_dwarf2_per_objfile (objfile) == NULL);
296 set_objfile_data (objfile, dwarf2_objfile_data_key, dwarf2_per_objfile);
299 /* Default names of the debugging sections. */
301 /* Note that if the debugging section has been compressed, it might
302 have a name like .zdebug_info. */
304 static const struct dwarf2_debug_sections dwarf2_elf_names =
306 { ".debug_info", ".zdebug_info" },
307 { ".debug_abbrev", ".zdebug_abbrev" },
308 { ".debug_line", ".zdebug_line" },
309 { ".debug_loc", ".zdebug_loc" },
310 { ".debug_loclists", ".zdebug_loclists" },
311 { ".debug_macinfo", ".zdebug_macinfo" },
312 { ".debug_macro", ".zdebug_macro" },
313 { ".debug_str", ".zdebug_str" },
314 { ".debug_line_str", ".zdebug_line_str" },
315 { ".debug_ranges", ".zdebug_ranges" },
316 { ".debug_rnglists", ".zdebug_rnglists" },
317 { ".debug_types", ".zdebug_types" },
318 { ".debug_addr", ".zdebug_addr" },
319 { ".debug_frame", ".zdebug_frame" },
320 { ".eh_frame", NULL },
321 { ".gdb_index", ".zgdb_index" },
322 { ".debug_names", ".zdebug_names" },
323 { ".debug_aranges", ".zdebug_aranges" },
327 /* List of DWO/DWP sections. */
329 static const struct dwop_section_names
331 struct dwarf2_section_names abbrev_dwo;
332 struct dwarf2_section_names info_dwo;
333 struct dwarf2_section_names line_dwo;
334 struct dwarf2_section_names loc_dwo;
335 struct dwarf2_section_names loclists_dwo;
336 struct dwarf2_section_names macinfo_dwo;
337 struct dwarf2_section_names macro_dwo;
338 struct dwarf2_section_names str_dwo;
339 struct dwarf2_section_names str_offsets_dwo;
340 struct dwarf2_section_names types_dwo;
341 struct dwarf2_section_names cu_index;
342 struct dwarf2_section_names tu_index;
346 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
347 { ".debug_info.dwo", ".zdebug_info.dwo" },
348 { ".debug_line.dwo", ".zdebug_line.dwo" },
349 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
350 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
351 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
352 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
353 { ".debug_str.dwo", ".zdebug_str.dwo" },
354 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
355 { ".debug_types.dwo", ".zdebug_types.dwo" },
356 { ".debug_cu_index", ".zdebug_cu_index" },
357 { ".debug_tu_index", ".zdebug_tu_index" },
360 /* local data types */
362 /* The data in a compilation unit header, after target2host
363 translation, looks like this. */
364 struct comp_unit_head
368 unsigned char addr_size;
369 unsigned char signed_addr_p;
370 sect_offset abbrev_sect_off;
372 /* Size of file offsets; either 4 or 8. */
373 unsigned int offset_size;
375 /* Size of the length field; either 4 or 12. */
376 unsigned int initial_length_size;
378 enum dwarf_unit_type unit_type;
380 /* Offset to the first byte of this compilation unit header in the
381 .debug_info section, for resolving relative reference dies. */
382 sect_offset sect_off;
384 /* Offset to first die in this cu from the start of the cu.
385 This will be the first byte following the compilation unit header. */
386 cu_offset first_die_cu_offset;
388 /* 64-bit signature of this type unit - it is valid only for
389 UNIT_TYPE DW_UT_type. */
392 /* For types, offset in the type's DIE of the type defined by this TU. */
393 cu_offset type_cu_offset_in_tu;
396 /* Type used for delaying computation of method physnames.
397 See comments for compute_delayed_physnames. */
398 struct delayed_method_info
400 /* The type to which the method is attached, i.e., its parent class. */
403 /* The index of the method in the type's function fieldlists. */
406 /* The index of the method in the fieldlist. */
409 /* The name of the DIE. */
412 /* The DIE associated with this method. */
413 struct die_info *die;
416 /* Internal state when decoding a particular compilation unit. */
419 explicit dwarf2_cu (struct dwarf2_per_cu_data *per_cu);
422 DISABLE_COPY_AND_ASSIGN (dwarf2_cu);
424 /* The header of the compilation unit. */
425 struct comp_unit_head header {};
427 /* Base address of this compilation unit. */
428 CORE_ADDR base_address = 0;
430 /* Non-zero if base_address has been set. */
433 /* The language we are debugging. */
434 enum language language = language_unknown;
435 const struct language_defn *language_defn = nullptr;
437 const char *producer = nullptr;
439 /* The symtab builder for this CU. This is only non-NULL when full
440 symbols are being read. */
441 std::unique_ptr<buildsym_compunit> builder;
443 /* The generic symbol table building routines have separate lists for
444 file scope symbols and all all other scopes (local scopes). So
445 we need to select the right one to pass to add_symbol_to_list().
446 We do it by keeping a pointer to the correct list in list_in_scope.
448 FIXME: The original dwarf code just treated the file scope as the
449 first local scope, and all other local scopes as nested local
450 scopes, and worked fine. Check to see if we really need to
451 distinguish these in buildsym.c. */
452 struct pending **list_in_scope = nullptr;
454 /* Hash table holding all the loaded partial DIEs
455 with partial_die->offset.SECT_OFF as hash. */
456 htab_t partial_dies = nullptr;
458 /* Storage for things with the same lifetime as this read-in compilation
459 unit, including partial DIEs. */
460 auto_obstack comp_unit_obstack;
462 /* When multiple dwarf2_cu structures are living in memory, this field
463 chains them all together, so that they can be released efficiently.
464 We will probably also want a generation counter so that most-recently-used
465 compilation units are cached... */
466 struct dwarf2_per_cu_data *read_in_chain = nullptr;
468 /* Backlink to our per_cu entry. */
469 struct dwarf2_per_cu_data *per_cu;
471 /* How many compilation units ago was this CU last referenced? */
474 /* A hash table of DIE cu_offset for following references with
475 die_info->offset.sect_off as hash. */
476 htab_t die_hash = nullptr;
478 /* Full DIEs if read in. */
479 struct die_info *dies = nullptr;
481 /* A set of pointers to dwarf2_per_cu_data objects for compilation
482 units referenced by this one. Only set during full symbol processing;
483 partial symbol tables do not have dependencies. */
484 htab_t dependencies = nullptr;
486 /* Header data from the line table, during full symbol processing. */
487 struct line_header *line_header = nullptr;
488 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
489 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
490 this is the DW_TAG_compile_unit die for this CU. We'll hold on
491 to the line header as long as this DIE is being processed. See
492 process_die_scope. */
493 die_info *line_header_die_owner = nullptr;
495 /* A list of methods which need to have physnames computed
496 after all type information has been read. */
497 std::vector<delayed_method_info> method_list;
499 /* To be copied to symtab->call_site_htab. */
500 htab_t call_site_htab = nullptr;
502 /* Non-NULL if this CU came from a DWO file.
503 There is an invariant here that is important to remember:
504 Except for attributes copied from the top level DIE in the "main"
505 (or "stub") file in preparation for reading the DWO file
506 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
507 Either there isn't a DWO file (in which case this is NULL and the point
508 is moot), or there is and either we're not going to read it (in which
509 case this is NULL) or there is and we are reading it (in which case this
511 struct dwo_unit *dwo_unit = nullptr;
513 /* The DW_AT_addr_base attribute if present, zero otherwise
514 (zero is a valid value though).
515 Note this value comes from the Fission stub CU/TU's DIE. */
516 ULONGEST addr_base = 0;
518 /* The DW_AT_ranges_base attribute if present, zero otherwise
519 (zero is a valid value though).
520 Note this value comes from the Fission stub CU/TU's DIE.
521 Also note that the value is zero in the non-DWO case so this value can
522 be used without needing to know whether DWO files are in use or not.
523 N.B. This does not apply to DW_AT_ranges appearing in
524 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
525 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
526 DW_AT_ranges_base *would* have to be applied, and we'd have to care
527 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
528 ULONGEST ranges_base = 0;
530 /* When reading debug info generated by older versions of rustc, we
531 have to rewrite some union types to be struct types with a
532 variant part. This rewriting must be done after the CU is fully
533 read in, because otherwise at the point of rewriting some struct
534 type might not have been fully processed. So, we keep a list of
535 all such types here and process them after expansion. */
536 std::vector<struct type *> rust_unions;
538 /* Mark used when releasing cached dies. */
541 /* This CU references .debug_loc. See the symtab->locations_valid field.
542 This test is imperfect as there may exist optimized debug code not using
543 any location list and still facing inlining issues if handled as
544 unoptimized code. For a future better test see GCC PR other/32998. */
545 bool has_loclist : 1;
547 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is true
548 if all the producer_is_* fields are valid. This information is cached
549 because profiling CU expansion showed excessive time spent in
550 producer_is_gxx_lt_4_6. */
551 bool checked_producer : 1;
552 bool producer_is_gxx_lt_4_6 : 1;
553 bool producer_is_gcc_lt_4_3 : 1;
554 bool producer_is_icc : 1;
555 bool producer_is_icc_lt_14 : 1;
556 bool producer_is_codewarrior : 1;
558 /* When true, the file that we're processing is known to have
559 debugging info for C++ namespaces. GCC 3.3.x did not produce
560 this information, but later versions do. */
562 bool processing_has_namespace_info : 1;
564 struct partial_die_info *find_partial_die (sect_offset sect_off);
567 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
568 This includes type_unit_group and quick_file_names. */
570 struct stmt_list_hash
572 /* The DWO unit this table is from or NULL if there is none. */
573 struct dwo_unit *dwo_unit;
575 /* Offset in .debug_line or .debug_line.dwo. */
576 sect_offset line_sect_off;
579 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
580 an object of this type. */
582 struct type_unit_group
584 /* dwarf2read.c's main "handle" on a TU symtab.
585 To simplify things we create an artificial CU that "includes" all the
586 type units using this stmt_list so that the rest of the code still has
587 a "per_cu" handle on the symtab.
588 This PER_CU is recognized by having no section. */
589 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
590 struct dwarf2_per_cu_data per_cu;
592 /* The TUs that share this DW_AT_stmt_list entry.
593 This is added to while parsing type units to build partial symtabs,
594 and is deleted afterwards and not used again. */
595 VEC (sig_type_ptr) *tus;
597 /* The compunit symtab.
598 Type units in a group needn't all be defined in the same source file,
599 so we create an essentially anonymous symtab as the compunit symtab. */
600 struct compunit_symtab *compunit_symtab;
602 /* The data used to construct the hash key. */
603 struct stmt_list_hash hash;
605 /* The number of symtabs from the line header.
606 The value here must match line_header.num_file_names. */
607 unsigned int num_symtabs;
609 /* The symbol tables for this TU (obtained from the files listed in
611 WARNING: The order of entries here must match the order of entries
612 in the line header. After the first TU using this type_unit_group, the
613 line header for the subsequent TUs is recreated from this. This is done
614 because we need to use the same symtabs for each TU using the same
615 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
616 there's no guarantee the line header doesn't have duplicate entries. */
617 struct symtab **symtabs;
620 /* These sections are what may appear in a (real or virtual) DWO file. */
624 struct dwarf2_section_info abbrev;
625 struct dwarf2_section_info line;
626 struct dwarf2_section_info loc;
627 struct dwarf2_section_info loclists;
628 struct dwarf2_section_info macinfo;
629 struct dwarf2_section_info macro;
630 struct dwarf2_section_info str;
631 struct dwarf2_section_info str_offsets;
632 /* In the case of a virtual DWO file, these two are unused. */
633 struct dwarf2_section_info info;
634 VEC (dwarf2_section_info_def) *types;
637 /* CUs/TUs in DWP/DWO files. */
641 /* Backlink to the containing struct dwo_file. */
642 struct dwo_file *dwo_file;
644 /* The "id" that distinguishes this CU/TU.
645 .debug_info calls this "dwo_id", .debug_types calls this "signature".
646 Since signatures came first, we stick with it for consistency. */
649 /* The section this CU/TU lives in, in the DWO file. */
650 struct dwarf2_section_info *section;
652 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
653 sect_offset sect_off;
656 /* For types, offset in the type's DIE of the type defined by this TU. */
657 cu_offset type_offset_in_tu;
660 /* include/dwarf2.h defines the DWP section codes.
661 It defines a max value but it doesn't define a min value, which we
662 use for error checking, so provide one. */
664 enum dwp_v2_section_ids
669 /* Data for one DWO file.
671 This includes virtual DWO files (a virtual DWO file is a DWO file as it
672 appears in a DWP file). DWP files don't really have DWO files per se -
673 comdat folding of types "loses" the DWO file they came from, and from
674 a high level view DWP files appear to contain a mass of random types.
675 However, to maintain consistency with the non-DWP case we pretend DWP
676 files contain virtual DWO files, and we assign each TU with one virtual
677 DWO file (generally based on the line and abbrev section offsets -
678 a heuristic that seems to work in practice). */
682 /* The DW_AT_GNU_dwo_name attribute.
683 For virtual DWO files the name is constructed from the section offsets
684 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
685 from related CU+TUs. */
686 const char *dwo_name;
688 /* The DW_AT_comp_dir attribute. */
689 const char *comp_dir;
691 /* The bfd, when the file is open. Otherwise this is NULL.
692 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
695 /* The sections that make up this DWO file.
696 Remember that for virtual DWO files in DWP V2, these are virtual
697 sections (for lack of a better name). */
698 struct dwo_sections sections;
700 /* The CUs in the file.
701 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
702 an extension to handle LLVM's Link Time Optimization output (where
703 multiple source files may be compiled into a single object/dwo pair). */
706 /* Table of TUs in the file.
707 Each element is a struct dwo_unit. */
711 /* These sections are what may appear in a DWP file. */
715 /* These are used by both DWP version 1 and 2. */
716 struct dwarf2_section_info str;
717 struct dwarf2_section_info cu_index;
718 struct dwarf2_section_info tu_index;
720 /* These are only used by DWP version 2 files.
721 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
722 sections are referenced by section number, and are not recorded here.
723 In DWP version 2 there is at most one copy of all these sections, each
724 section being (effectively) comprised of the concatenation of all of the
725 individual sections that exist in the version 1 format.
726 To keep the code simple we treat each of these concatenated pieces as a
727 section itself (a virtual section?). */
728 struct dwarf2_section_info abbrev;
729 struct dwarf2_section_info info;
730 struct dwarf2_section_info line;
731 struct dwarf2_section_info loc;
732 struct dwarf2_section_info macinfo;
733 struct dwarf2_section_info macro;
734 struct dwarf2_section_info str_offsets;
735 struct dwarf2_section_info types;
738 /* These sections are what may appear in a virtual DWO file in DWP version 1.
739 A virtual DWO file is a DWO file as it appears in a DWP file. */
741 struct virtual_v1_dwo_sections
743 struct dwarf2_section_info abbrev;
744 struct dwarf2_section_info line;
745 struct dwarf2_section_info loc;
746 struct dwarf2_section_info macinfo;
747 struct dwarf2_section_info macro;
748 struct dwarf2_section_info str_offsets;
749 /* Each DWP hash table entry records one CU or one TU.
750 That is recorded here, and copied to dwo_unit.section. */
751 struct dwarf2_section_info info_or_types;
754 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
755 In version 2, the sections of the DWO files are concatenated together
756 and stored in one section of that name. Thus each ELF section contains
757 several "virtual" sections. */
759 struct virtual_v2_dwo_sections
761 bfd_size_type abbrev_offset;
762 bfd_size_type abbrev_size;
764 bfd_size_type line_offset;
765 bfd_size_type line_size;
767 bfd_size_type loc_offset;
768 bfd_size_type loc_size;
770 bfd_size_type macinfo_offset;
771 bfd_size_type macinfo_size;
773 bfd_size_type macro_offset;
774 bfd_size_type macro_size;
776 bfd_size_type str_offsets_offset;
777 bfd_size_type str_offsets_size;
779 /* Each DWP hash table entry records one CU or one TU.
780 That is recorded here, and copied to dwo_unit.section. */
781 bfd_size_type info_or_types_offset;
782 bfd_size_type info_or_types_size;
785 /* Contents of DWP hash tables. */
787 struct dwp_hash_table
789 uint32_t version, nr_columns;
790 uint32_t nr_units, nr_slots;
791 const gdb_byte *hash_table, *unit_table;
796 const gdb_byte *indices;
800 /* This is indexed by column number and gives the id of the section
802 #define MAX_NR_V2_DWO_SECTIONS \
803 (1 /* .debug_info or .debug_types */ \
804 + 1 /* .debug_abbrev */ \
805 + 1 /* .debug_line */ \
806 + 1 /* .debug_loc */ \
807 + 1 /* .debug_str_offsets */ \
808 + 1 /* .debug_macro or .debug_macinfo */)
809 int section_ids[MAX_NR_V2_DWO_SECTIONS];
810 const gdb_byte *offsets;
811 const gdb_byte *sizes;
816 /* Data for one DWP file. */
820 dwp_file (const char *name_, gdb_bfd_ref_ptr &&abfd)
822 dbfd (std::move (abfd))
826 /* Name of the file. */
829 /* File format version. */
833 gdb_bfd_ref_ptr dbfd;
835 /* Section info for this file. */
836 struct dwp_sections sections {};
838 /* Table of CUs in the file. */
839 const struct dwp_hash_table *cus = nullptr;
841 /* Table of TUs in the file. */
842 const struct dwp_hash_table *tus = nullptr;
844 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
845 htab_t loaded_cus {};
846 htab_t loaded_tus {};
848 /* Table to map ELF section numbers to their sections.
849 This is only needed for the DWP V1 file format. */
850 unsigned int num_sections = 0;
851 asection **elf_sections = nullptr;
854 /* This represents a '.dwz' file. */
858 dwz_file (gdb_bfd_ref_ptr &&bfd)
859 : dwz_bfd (std::move (bfd))
863 /* A dwz file can only contain a few sections. */
864 struct dwarf2_section_info abbrev {};
865 struct dwarf2_section_info info {};
866 struct dwarf2_section_info str {};
867 struct dwarf2_section_info line {};
868 struct dwarf2_section_info macro {};
869 struct dwarf2_section_info gdb_index {};
870 struct dwarf2_section_info debug_names {};
873 gdb_bfd_ref_ptr dwz_bfd;
875 /* If we loaded the index from an external file, this contains the
876 resources associated to the open file, memory mapping, etc. */
877 std::unique_ptr<index_cache_resource> index_cache_res;
880 /* Struct used to pass misc. parameters to read_die_and_children, et
881 al. which are used for both .debug_info and .debug_types dies.
882 All parameters here are unchanging for the life of the call. This
883 struct exists to abstract away the constant parameters of die reading. */
885 struct die_reader_specs
887 /* The bfd of die_section. */
890 /* The CU of the DIE we are parsing. */
891 struct dwarf2_cu *cu;
893 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
894 struct dwo_file *dwo_file;
896 /* The section the die comes from.
897 This is either .debug_info or .debug_types, or the .dwo variants. */
898 struct dwarf2_section_info *die_section;
900 /* die_section->buffer. */
901 const gdb_byte *buffer;
903 /* The end of the buffer. */
904 const gdb_byte *buffer_end;
906 /* The value of the DW_AT_comp_dir attribute. */
907 const char *comp_dir;
909 /* The abbreviation table to use when reading the DIEs. */
910 struct abbrev_table *abbrev_table;
913 /* Type of function passed to init_cutu_and_read_dies, et.al. */
914 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
915 const gdb_byte *info_ptr,
916 struct die_info *comp_unit_die,
920 /* A 1-based directory index. This is a strong typedef to prevent
921 accidentally using a directory index as a 0-based index into an
923 enum class dir_index : unsigned int {};
925 /* Likewise, a 1-based file name index. */
926 enum class file_name_index : unsigned int {};
930 file_entry () = default;
932 file_entry (const char *name_, dir_index d_index_,
933 unsigned int mod_time_, unsigned int length_)
936 mod_time (mod_time_),
940 /* Return the include directory at D_INDEX stored in LH. Returns
941 NULL if D_INDEX is out of bounds. */
942 const char *include_dir (const line_header *lh) const;
944 /* The file name. Note this is an observing pointer. The memory is
945 owned by debug_line_buffer. */
948 /* The directory index (1-based). */
949 dir_index d_index {};
951 unsigned int mod_time {};
953 unsigned int length {};
955 /* True if referenced by the Line Number Program. */
958 /* The associated symbol table, if any. */
959 struct symtab *symtab {};
962 /* The line number information for a compilation unit (found in the
963 .debug_line section) begins with a "statement program header",
964 which contains the following information. */
971 /* Add an entry to the include directory table. */
972 void add_include_dir (const char *include_dir);
974 /* Add an entry to the file name table. */
975 void add_file_name (const char *name, dir_index d_index,
976 unsigned int mod_time, unsigned int length);
978 /* Return the include dir at INDEX (1-based). Returns NULL if INDEX
980 const char *include_dir_at (dir_index index) const
982 /* Convert directory index number (1-based) to vector index
984 size_t vec_index = to_underlying (index) - 1;
986 if (vec_index >= include_dirs.size ())
988 return include_dirs[vec_index];
991 /* Return the file name at INDEX (1-based). Returns NULL if INDEX
993 file_entry *file_name_at (file_name_index index)
995 /* Convert file name index number (1-based) to vector index
997 size_t vec_index = to_underlying (index) - 1;
999 if (vec_index >= file_names.size ())
1001 return &file_names[vec_index];
1004 /* Const version of the above. */
1005 const file_entry *file_name_at (unsigned int index) const
1007 if (index >= file_names.size ())
1009 return &file_names[index];
1012 /* Offset of line number information in .debug_line section. */
1013 sect_offset sect_off {};
1015 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1016 unsigned offset_in_dwz : 1; /* Can't initialize bitfields in-class. */
1018 unsigned int total_length {};
1019 unsigned short version {};
1020 unsigned int header_length {};
1021 unsigned char minimum_instruction_length {};
1022 unsigned char maximum_ops_per_instruction {};
1023 unsigned char default_is_stmt {};
1025 unsigned char line_range {};
1026 unsigned char opcode_base {};
1028 /* standard_opcode_lengths[i] is the number of operands for the
1029 standard opcode whose value is i. This means that
1030 standard_opcode_lengths[0] is unused, and the last meaningful
1031 element is standard_opcode_lengths[opcode_base - 1]. */
1032 std::unique_ptr<unsigned char[]> standard_opcode_lengths;
1034 /* The include_directories table. Note these are observing
1035 pointers. The memory is owned by debug_line_buffer. */
1036 std::vector<const char *> include_dirs;
1038 /* The file_names table. */
1039 std::vector<file_entry> file_names;
1041 /* The start and end of the statement program following this
1042 header. These point into dwarf2_per_objfile->line_buffer. */
1043 const gdb_byte *statement_program_start {}, *statement_program_end {};
1046 typedef std::unique_ptr<line_header> line_header_up;
1049 file_entry::include_dir (const line_header *lh) const
1051 return lh->include_dir_at (d_index);
1054 /* When we construct a partial symbol table entry we only
1055 need this much information. */
1056 struct partial_die_info : public allocate_on_obstack
1058 partial_die_info (sect_offset sect_off, struct abbrev_info *abbrev);
1060 /* Disable assign but still keep copy ctor, which is needed
1061 load_partial_dies. */
1062 partial_die_info& operator=(const partial_die_info& rhs) = delete;
1064 /* Adjust the partial die before generating a symbol for it. This
1065 function may set the is_external flag or change the DIE's
1067 void fixup (struct dwarf2_cu *cu);
1069 /* Read a minimal amount of information into the minimal die
1071 const gdb_byte *read (const struct die_reader_specs *reader,
1072 const struct abbrev_info &abbrev,
1073 const gdb_byte *info_ptr);
1075 /* Offset of this DIE. */
1076 const sect_offset sect_off;
1078 /* DWARF-2 tag for this DIE. */
1079 const ENUM_BITFIELD(dwarf_tag) tag : 16;
1081 /* Assorted flags describing the data found in this DIE. */
1082 const unsigned int has_children : 1;
1084 unsigned int is_external : 1;
1085 unsigned int is_declaration : 1;
1086 unsigned int has_type : 1;
1087 unsigned int has_specification : 1;
1088 unsigned int has_pc_info : 1;
1089 unsigned int may_be_inlined : 1;
1091 /* This DIE has been marked DW_AT_main_subprogram. */
1092 unsigned int main_subprogram : 1;
1094 /* Flag set if the SCOPE field of this structure has been
1096 unsigned int scope_set : 1;
1098 /* Flag set if the DIE has a byte_size attribute. */
1099 unsigned int has_byte_size : 1;
1101 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1102 unsigned int has_const_value : 1;
1104 /* Flag set if any of the DIE's children are template arguments. */
1105 unsigned int has_template_arguments : 1;
1107 /* Flag set if fixup has been called on this die. */
1108 unsigned int fixup_called : 1;
1110 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1111 unsigned int is_dwz : 1;
1113 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1114 unsigned int spec_is_dwz : 1;
1116 /* The name of this DIE. Normally the value of DW_AT_name, but
1117 sometimes a default name for unnamed DIEs. */
1118 const char *name = nullptr;
1120 /* The linkage name, if present. */
1121 const char *linkage_name = nullptr;
1123 /* The scope to prepend to our children. This is generally
1124 allocated on the comp_unit_obstack, so will disappear
1125 when this compilation unit leaves the cache. */
1126 const char *scope = nullptr;
1128 /* Some data associated with the partial DIE. The tag determines
1129 which field is live. */
1132 /* The location description associated with this DIE, if any. */
1133 struct dwarf_block *locdesc;
1134 /* The offset of an import, for DW_TAG_imported_unit. */
1135 sect_offset sect_off;
1138 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1139 CORE_ADDR lowpc = 0;
1140 CORE_ADDR highpc = 0;
1142 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1143 DW_AT_sibling, if any. */
1144 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1145 could return DW_AT_sibling values to its caller load_partial_dies. */
1146 const gdb_byte *sibling = nullptr;
1148 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1149 DW_AT_specification (or DW_AT_abstract_origin or
1150 DW_AT_extension). */
1151 sect_offset spec_offset {};
1153 /* Pointers to this DIE's parent, first child, and next sibling,
1155 struct partial_die_info *die_parent = nullptr;
1156 struct partial_die_info *die_child = nullptr;
1157 struct partial_die_info *die_sibling = nullptr;
1159 friend struct partial_die_info *
1160 dwarf2_cu::find_partial_die (sect_offset sect_off);
1163 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1164 partial_die_info (sect_offset sect_off)
1165 : partial_die_info (sect_off, DW_TAG_padding, 0)
1169 partial_die_info (sect_offset sect_off_, enum dwarf_tag tag_,
1171 : sect_off (sect_off_), tag (tag_), has_children (has_children_)
1176 has_specification = 0;
1179 main_subprogram = 0;
1182 has_const_value = 0;
1183 has_template_arguments = 0;
1190 /* This data structure holds the information of an abbrev. */
1193 unsigned int number; /* number identifying abbrev */
1194 enum dwarf_tag tag; /* dwarf tag */
1195 unsigned short has_children; /* boolean */
1196 unsigned short num_attrs; /* number of attributes */
1197 struct attr_abbrev *attrs; /* an array of attribute descriptions */
1198 struct abbrev_info *next; /* next in chain */
1203 ENUM_BITFIELD(dwarf_attribute) name : 16;
1204 ENUM_BITFIELD(dwarf_form) form : 16;
1206 /* It is valid only if FORM is DW_FORM_implicit_const. */
1207 LONGEST implicit_const;
1210 /* Size of abbrev_table.abbrev_hash_table. */
1211 #define ABBREV_HASH_SIZE 121
1213 /* Top level data structure to contain an abbreviation table. */
1217 explicit abbrev_table (sect_offset off)
1221 XOBNEWVEC (&abbrev_obstack, struct abbrev_info *, ABBREV_HASH_SIZE);
1222 memset (m_abbrevs, 0, ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
1225 DISABLE_COPY_AND_ASSIGN (abbrev_table);
1227 /* Allocate space for a struct abbrev_info object in
1229 struct abbrev_info *alloc_abbrev ();
1231 /* Add an abbreviation to the table. */
1232 void add_abbrev (unsigned int abbrev_number, struct abbrev_info *abbrev);
1234 /* Look up an abbrev in the table.
1235 Returns NULL if the abbrev is not found. */
1237 struct abbrev_info *lookup_abbrev (unsigned int abbrev_number);
1240 /* Where the abbrev table came from.
1241 This is used as a sanity check when the table is used. */
1242 const sect_offset sect_off;
1244 /* Storage for the abbrev table. */
1245 auto_obstack abbrev_obstack;
1249 /* Hash table of abbrevs.
1250 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1251 It could be statically allocated, but the previous code didn't so we
1253 struct abbrev_info **m_abbrevs;
1256 typedef std::unique_ptr<struct abbrev_table> abbrev_table_up;
1258 /* Attributes have a name and a value. */
1261 ENUM_BITFIELD(dwarf_attribute) name : 16;
1262 ENUM_BITFIELD(dwarf_form) form : 15;
1264 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1265 field should be in u.str (existing only for DW_STRING) but it is kept
1266 here for better struct attribute alignment. */
1267 unsigned int string_is_canonical : 1;
1272 struct dwarf_block *blk;
1281 /* This data structure holds a complete die structure. */
1284 /* DWARF-2 tag for this DIE. */
1285 ENUM_BITFIELD(dwarf_tag) tag : 16;
1287 /* Number of attributes */
1288 unsigned char num_attrs;
1290 /* True if we're presently building the full type name for the
1291 type derived from this DIE. */
1292 unsigned char building_fullname : 1;
1294 /* True if this die is in process. PR 16581. */
1295 unsigned char in_process : 1;
1298 unsigned int abbrev;
1300 /* Offset in .debug_info or .debug_types section. */
1301 sect_offset sect_off;
1303 /* The dies in a compilation unit form an n-ary tree. PARENT
1304 points to this die's parent; CHILD points to the first child of
1305 this node; and all the children of a given node are chained
1306 together via their SIBLING fields. */
1307 struct die_info *child; /* Its first child, if any. */
1308 struct die_info *sibling; /* Its next sibling, if any. */
1309 struct die_info *parent; /* Its parent, if any. */
1311 /* An array of attributes, with NUM_ATTRS elements. There may be
1312 zero, but it's not common and zero-sized arrays are not
1313 sufficiently portable C. */
1314 struct attribute attrs[1];
1317 /* Get at parts of an attribute structure. */
1319 #define DW_STRING(attr) ((attr)->u.str)
1320 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1321 #define DW_UNSND(attr) ((attr)->u.unsnd)
1322 #define DW_BLOCK(attr) ((attr)->u.blk)
1323 #define DW_SND(attr) ((attr)->u.snd)
1324 #define DW_ADDR(attr) ((attr)->u.addr)
1325 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1327 /* Blocks are a bunch of untyped bytes. */
1332 /* Valid only if SIZE is not zero. */
1333 const gdb_byte *data;
1336 #ifndef ATTR_ALLOC_CHUNK
1337 #define ATTR_ALLOC_CHUNK 4
1340 /* Allocate fields for structs, unions and enums in this size. */
1341 #ifndef DW_FIELD_ALLOC_CHUNK
1342 #define DW_FIELD_ALLOC_CHUNK 4
1345 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1346 but this would require a corresponding change in unpack_field_as_long
1348 static int bits_per_byte = 8;
1350 /* When reading a variant or variant part, we track a bit more
1351 information about the field, and store it in an object of this
1354 struct variant_field
1356 /* If we see a DW_TAG_variant, then this will be the discriminant
1358 ULONGEST discriminant_value;
1359 /* If we see a DW_TAG_variant, then this will be set if this is the
1361 bool default_branch;
1362 /* While reading a DW_TAG_variant_part, this will be set if this
1363 field is the discriminant. */
1364 bool is_discriminant;
1369 int accessibility = 0;
1371 /* Extra information to describe a variant or variant part. */
1372 struct variant_field variant {};
1373 struct field field {};
1378 const char *name = nullptr;
1379 std::vector<struct fn_field> fnfields;
1382 /* The routines that read and process dies for a C struct or C++ class
1383 pass lists of data member fields and lists of member function fields
1384 in an instance of a field_info structure, as defined below. */
1387 /* List of data member and baseclasses fields. */
1388 std::vector<struct nextfield> fields;
1389 std::vector<struct nextfield> baseclasses;
1391 /* Number of fields (including baseclasses). */
1394 /* Set if the accesibility of one of the fields is not public. */
1395 int non_public_fields = 0;
1397 /* Member function fieldlist array, contains name of possibly overloaded
1398 member function, number of overloaded member functions and a pointer
1399 to the head of the member function field chain. */
1400 std::vector<struct fnfieldlist> fnfieldlists;
1402 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1403 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1404 std::vector<struct decl_field> typedef_field_list;
1406 /* Nested types defined by this class and the number of elements in this
1408 std::vector<struct decl_field> nested_types_list;
1411 /* One item on the queue of compilation units to read in full symbols
1413 struct dwarf2_queue_item
1415 struct dwarf2_per_cu_data *per_cu;
1416 enum language pretend_language;
1417 struct dwarf2_queue_item *next;
1420 /* The current queue. */
1421 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1423 /* Loaded secondary compilation units are kept in memory until they
1424 have not been referenced for the processing of this many
1425 compilation units. Set this to zero to disable caching. Cache
1426 sizes of up to at least twenty will improve startup time for
1427 typical inter-CU-reference binaries, at an obvious memory cost. */
1428 static int dwarf_max_cache_age = 5;
1430 show_dwarf_max_cache_age (struct ui_file *file, int from_tty,
1431 struct cmd_list_element *c, const char *value)
1433 fprintf_filtered (file, _("The upper bound on the age of cached "
1434 "DWARF compilation units is %s.\n"),
1438 /* local function prototypes */
1440 static const char *get_section_name (const struct dwarf2_section_info *);
1442 static const char *get_section_file_name (const struct dwarf2_section_info *);
1444 static void dwarf2_find_base_address (struct die_info *die,
1445 struct dwarf2_cu *cu);
1447 static struct partial_symtab *create_partial_symtab
1448 (struct dwarf2_per_cu_data *per_cu, const char *name);
1450 static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
1451 const gdb_byte *info_ptr,
1452 struct die_info *type_unit_die,
1453 int has_children, void *data);
1455 static void dwarf2_build_psymtabs_hard
1456 (struct dwarf2_per_objfile *dwarf2_per_objfile);
1458 static void scan_partial_symbols (struct partial_die_info *,
1459 CORE_ADDR *, CORE_ADDR *,
1460 int, struct dwarf2_cu *);
1462 static void add_partial_symbol (struct partial_die_info *,
1463 struct dwarf2_cu *);
1465 static void add_partial_namespace (struct partial_die_info *pdi,
1466 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1467 int set_addrmap, struct dwarf2_cu *cu);
1469 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1470 CORE_ADDR *highpc, int set_addrmap,
1471 struct dwarf2_cu *cu);
1473 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1474 struct dwarf2_cu *cu);
1476 static void add_partial_subprogram (struct partial_die_info *pdi,
1477 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1478 int need_pc, struct dwarf2_cu *cu);
1480 static void dwarf2_read_symtab (struct partial_symtab *,
1483 static void psymtab_to_symtab_1 (struct partial_symtab *);
1485 static abbrev_table_up abbrev_table_read_table
1486 (struct dwarf2_per_objfile *dwarf2_per_objfile, struct dwarf2_section_info *,
1489 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1491 static struct partial_die_info *load_partial_dies
1492 (const struct die_reader_specs *, const gdb_byte *, int);
1494 static struct partial_die_info *find_partial_die (sect_offset, int,
1495 struct dwarf2_cu *);
1497 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1498 struct attribute *, struct attr_abbrev *,
1501 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1503 static int read_1_signed_byte (bfd *, const gdb_byte *);
1505 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1507 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1509 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1511 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1514 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1516 static LONGEST read_checked_initial_length_and_offset
1517 (bfd *, const gdb_byte *, const struct comp_unit_head *,
1518 unsigned int *, unsigned int *);
1520 static LONGEST read_offset (bfd *, const gdb_byte *,
1521 const struct comp_unit_head *,
1524 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1526 static sect_offset read_abbrev_offset
1527 (struct dwarf2_per_objfile *dwarf2_per_objfile,
1528 struct dwarf2_section_info *, sect_offset);
1530 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1532 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1534 static const char *read_indirect_string
1535 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1536 const struct comp_unit_head *, unsigned int *);
1538 static const char *read_indirect_line_string
1539 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1540 const struct comp_unit_head *, unsigned int *);
1542 static const char *read_indirect_string_at_offset
1543 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
1544 LONGEST str_offset);
1546 static const char *read_indirect_string_from_dwz
1547 (struct objfile *objfile, struct dwz_file *, LONGEST);
1549 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1551 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1555 static const char *read_str_index (const struct die_reader_specs *reader,
1556 ULONGEST str_index);
1558 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1560 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1561 struct dwarf2_cu *);
1563 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1566 static const char *dwarf2_string_attr (struct die_info *die, unsigned int name,
1567 struct dwarf2_cu *cu);
1569 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1570 struct dwarf2_cu *cu);
1572 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1574 static struct die_info *die_specification (struct die_info *die,
1575 struct dwarf2_cu **);
1577 static line_header_up dwarf_decode_line_header (sect_offset sect_off,
1578 struct dwarf2_cu *cu);
1580 static void dwarf_decode_lines (struct line_header *, const char *,
1581 struct dwarf2_cu *, struct partial_symtab *,
1582 CORE_ADDR, int decode_mapping);
1584 static void dwarf2_start_subfile (struct dwarf2_cu *, const char *,
1587 static struct compunit_symtab *dwarf2_start_symtab (struct dwarf2_cu *,
1588 const char *, const char *,
1591 static struct symbol *new_symbol (struct die_info *, struct type *,
1592 struct dwarf2_cu *, struct symbol * = NULL);
1594 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1595 struct dwarf2_cu *);
1597 static void dwarf2_const_value_attr (const struct attribute *attr,
1600 struct obstack *obstack,
1601 struct dwarf2_cu *cu, LONGEST *value,
1602 const gdb_byte **bytes,
1603 struct dwarf2_locexpr_baton **baton);
1605 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1607 static int need_gnat_info (struct dwarf2_cu *);
1609 static struct type *die_descriptive_type (struct die_info *,
1610 struct dwarf2_cu *);
1612 static void set_descriptive_type (struct type *, struct die_info *,
1613 struct dwarf2_cu *);
1615 static struct type *die_containing_type (struct die_info *,
1616 struct dwarf2_cu *);
1618 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1619 struct dwarf2_cu *);
1621 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1623 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1625 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1627 static char *typename_concat (struct obstack *obs, const char *prefix,
1628 const char *suffix, int physname,
1629 struct dwarf2_cu *cu);
1631 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1633 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1635 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1637 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1639 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1641 static void read_variable (struct die_info *die, struct dwarf2_cu *cu);
1643 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1644 struct dwarf2_cu *, struct partial_symtab *);
1646 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1647 values. Keep the items ordered with increasing constraints compliance. */
1650 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1651 PC_BOUNDS_NOT_PRESENT,
1653 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1654 were present but they do not form a valid range of PC addresses. */
1657 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1660 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1664 static enum pc_bounds_kind dwarf2_get_pc_bounds (struct die_info *,
1665 CORE_ADDR *, CORE_ADDR *,
1667 struct partial_symtab *);
1669 static void get_scope_pc_bounds (struct die_info *,
1670 CORE_ADDR *, CORE_ADDR *,
1671 struct dwarf2_cu *);
1673 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1674 CORE_ADDR, struct dwarf2_cu *);
1676 static void dwarf2_add_field (struct field_info *, struct die_info *,
1677 struct dwarf2_cu *);
1679 static void dwarf2_attach_fields_to_type (struct field_info *,
1680 struct type *, struct dwarf2_cu *);
1682 static void dwarf2_add_member_fn (struct field_info *,
1683 struct die_info *, struct type *,
1684 struct dwarf2_cu *);
1686 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1688 struct dwarf2_cu *);
1690 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1692 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1694 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1696 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1698 static struct using_direct **using_directives (struct dwarf2_cu *cu);
1700 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1702 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1704 static struct type *read_module_type (struct die_info *die,
1705 struct dwarf2_cu *cu);
1707 static const char *namespace_name (struct die_info *die,
1708 int *is_anonymous, struct dwarf2_cu *);
1710 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1712 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1714 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1715 struct dwarf2_cu *);
1717 static struct die_info *read_die_and_siblings_1
1718 (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1721 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1722 const gdb_byte *info_ptr,
1723 const gdb_byte **new_info_ptr,
1724 struct die_info *parent);
1726 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1727 struct die_info **, const gdb_byte *,
1730 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1731 struct die_info **, const gdb_byte *,
1734 static void process_die (struct die_info *, struct dwarf2_cu *);
1736 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1739 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1741 static const char *dwarf2_full_name (const char *name,
1742 struct die_info *die,
1743 struct dwarf2_cu *cu);
1745 static const char *dwarf2_physname (const char *name, struct die_info *die,
1746 struct dwarf2_cu *cu);
1748 static struct die_info *dwarf2_extension (struct die_info *die,
1749 struct dwarf2_cu **);
1751 static const char *dwarf_tag_name (unsigned int);
1753 static const char *dwarf_attr_name (unsigned int);
1755 static const char *dwarf_form_name (unsigned int);
1757 static const char *dwarf_bool_name (unsigned int);
1759 static const char *dwarf_type_encoding_name (unsigned int);
1761 static struct die_info *sibling_die (struct die_info *);
1763 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1765 static void dump_die_for_error (struct die_info *);
1767 static void dump_die_1 (struct ui_file *, int level, int max_level,
1770 /*static*/ void dump_die (struct die_info *, int max_level);
1772 static void store_in_ref_table (struct die_info *,
1773 struct dwarf2_cu *);
1775 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1777 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1779 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1780 const struct attribute *,
1781 struct dwarf2_cu **);
1783 static struct die_info *follow_die_ref (struct die_info *,
1784 const struct attribute *,
1785 struct dwarf2_cu **);
1787 static struct die_info *follow_die_sig (struct die_info *,
1788 const struct attribute *,
1789 struct dwarf2_cu **);
1791 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1792 struct dwarf2_cu *);
1794 static struct type *get_DW_AT_signature_type (struct die_info *,
1795 const struct attribute *,
1796 struct dwarf2_cu *);
1798 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1800 static void read_signatured_type (struct signatured_type *);
1802 static int attr_to_dynamic_prop (const struct attribute *attr,
1803 struct die_info *die, struct dwarf2_cu *cu,
1804 struct dynamic_prop *prop);
1806 /* memory allocation interface */
1808 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1810 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1812 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int, int);
1814 static int attr_form_is_block (const struct attribute *);
1816 static int attr_form_is_section_offset (const struct attribute *);
1818 static int attr_form_is_constant (const struct attribute *);
1820 static int attr_form_is_ref (const struct attribute *);
1822 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1823 struct dwarf2_loclist_baton *baton,
1824 const struct attribute *attr);
1826 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1828 struct dwarf2_cu *cu,
1831 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1832 const gdb_byte *info_ptr,
1833 struct abbrev_info *abbrev);
1835 static hashval_t partial_die_hash (const void *item);
1837 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1839 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1840 (sect_offset sect_off, unsigned int offset_in_dwz,
1841 struct dwarf2_per_objfile *dwarf2_per_objfile);
1843 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1844 struct die_info *comp_unit_die,
1845 enum language pretend_language);
1847 static void age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1849 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1851 static struct type *set_die_type (struct die_info *, struct type *,
1852 struct dwarf2_cu *);
1854 static void create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1856 static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1858 static void load_full_comp_unit (struct dwarf2_per_cu_data *, bool,
1861 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1864 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1867 static void dwarf2_add_dependence (struct dwarf2_cu *,
1868 struct dwarf2_per_cu_data *);
1870 static void dwarf2_mark (struct dwarf2_cu *);
1872 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1874 static struct type *get_die_type_at_offset (sect_offset,
1875 struct dwarf2_per_cu_data *);
1877 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1879 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1880 enum language pretend_language);
1882 static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile);
1884 /* Class, the destructor of which frees all allocated queue entries. This
1885 will only have work to do if an error was thrown while processing the
1886 dwarf. If no error was thrown then the queue entries should have all
1887 been processed, and freed, as we went along. */
1889 class dwarf2_queue_guard
1892 dwarf2_queue_guard () = default;
1894 /* Free any entries remaining on the queue. There should only be
1895 entries left if we hit an error while processing the dwarf. */
1896 ~dwarf2_queue_guard ()
1898 struct dwarf2_queue_item *item, *last;
1900 item = dwarf2_queue;
1903 /* Anything still marked queued is likely to be in an
1904 inconsistent state, so discard it. */
1905 if (item->per_cu->queued)
1907 if (item->per_cu->cu != NULL)
1908 free_one_cached_comp_unit (item->per_cu);
1909 item->per_cu->queued = 0;
1917 dwarf2_queue = dwarf2_queue_tail = NULL;
1921 /* The return type of find_file_and_directory. Note, the enclosed
1922 string pointers are only valid while this object is valid. */
1924 struct file_and_directory
1926 /* The filename. This is never NULL. */
1929 /* The compilation directory. NULL if not known. If we needed to
1930 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1931 points directly to the DW_AT_comp_dir string attribute owned by
1932 the obstack that owns the DIE. */
1933 const char *comp_dir;
1935 /* If we needed to build a new string for comp_dir, this is what
1936 owns the storage. */
1937 std::string comp_dir_storage;
1940 static file_and_directory find_file_and_directory (struct die_info *die,
1941 struct dwarf2_cu *cu);
1943 static char *file_full_name (int file, struct line_header *lh,
1944 const char *comp_dir);
1946 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
1947 enum class rcuh_kind { COMPILE, TYPE };
1949 static const gdb_byte *read_and_check_comp_unit_head
1950 (struct dwarf2_per_objfile* dwarf2_per_objfile,
1951 struct comp_unit_head *header,
1952 struct dwarf2_section_info *section,
1953 struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1954 rcuh_kind section_kind);
1956 static void init_cutu_and_read_dies
1957 (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1958 int use_existing_cu, int keep, bool skip_partial,
1959 die_reader_func_ftype *die_reader_func, void *data);
1961 static void init_cutu_and_read_dies_simple
1962 (struct dwarf2_per_cu_data *this_cu,
1963 die_reader_func_ftype *die_reader_func, void *data);
1965 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1967 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1969 static struct dwo_unit *lookup_dwo_unit_in_dwp
1970 (struct dwarf2_per_objfile *dwarf2_per_objfile,
1971 struct dwp_file *dwp_file, const char *comp_dir,
1972 ULONGEST signature, int is_debug_types);
1974 static struct dwp_file *get_dwp_file
1975 (struct dwarf2_per_objfile *dwarf2_per_objfile);
1977 static struct dwo_unit *lookup_dwo_comp_unit
1978 (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
1980 static struct dwo_unit *lookup_dwo_type_unit
1981 (struct signatured_type *, const char *, const char *);
1983 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
1985 static void free_dwo_file (struct dwo_file *);
1987 /* A unique_ptr helper to free a dwo_file. */
1989 struct dwo_file_deleter
1991 void operator() (struct dwo_file *df) const
1997 /* A unique pointer to a dwo_file. */
1999 typedef std::unique_ptr<struct dwo_file, dwo_file_deleter> dwo_file_up;
2001 static void process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile);
2003 static void check_producer (struct dwarf2_cu *cu);
2005 static void free_line_header_voidp (void *arg);
2007 /* Various complaints about symbol reading that don't abort the process. */
2010 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2012 complaint (_("statement list doesn't fit in .debug_line section"));
2016 dwarf2_debug_line_missing_file_complaint (void)
2018 complaint (_(".debug_line section has line data without a file"));
2022 dwarf2_debug_line_missing_end_sequence_complaint (void)
2024 complaint (_(".debug_line section has line "
2025 "program sequence without an end"));
2029 dwarf2_complex_location_expr_complaint (void)
2031 complaint (_("location expression too complex"));
2035 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
2038 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
2043 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
2045 complaint (_("debug info runs off end of %s section"
2047 get_section_name (section),
2048 get_section_file_name (section));
2052 dwarf2_macro_malformed_definition_complaint (const char *arg1)
2054 complaint (_("macro debug info contains a "
2055 "malformed macro definition:\n`%s'"),
2060 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
2062 complaint (_("invalid attribute class or form for '%s' in '%s'"),
2066 /* Hash function for line_header_hash. */
2069 line_header_hash (const struct line_header *ofs)
2071 return to_underlying (ofs->sect_off) ^ ofs->offset_in_dwz;
2074 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2077 line_header_hash_voidp (const void *item)
2079 const struct line_header *ofs = (const struct line_header *) item;
2081 return line_header_hash (ofs);
2084 /* Equality function for line_header_hash. */
2087 line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
2089 const struct line_header *ofs_lhs = (const struct line_header *) item_lhs;
2090 const struct line_header *ofs_rhs = (const struct line_header *) item_rhs;
2092 return (ofs_lhs->sect_off == ofs_rhs->sect_off
2093 && ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
2098 /* Read the given attribute value as an address, taking the attribute's
2099 form into account. */
2102 attr_value_as_address (struct attribute *attr)
2106 if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index)
2108 /* Aside from a few clearly defined exceptions, attributes that
2109 contain an address must always be in DW_FORM_addr form.
2110 Unfortunately, some compilers happen to be violating this
2111 requirement by encoding addresses using other forms, such
2112 as DW_FORM_data4 for example. For those broken compilers,
2113 we try to do our best, without any guarantee of success,
2114 to interpret the address correctly. It would also be nice
2115 to generate a complaint, but that would require us to maintain
2116 a list of legitimate cases where a non-address form is allowed,
2117 as well as update callers to pass in at least the CU's DWARF
2118 version. This is more overhead than what we're willing to
2119 expand for a pretty rare case. */
2120 addr = DW_UNSND (attr);
2123 addr = DW_ADDR (attr);
2128 /* See declaration. */
2130 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_,
2131 const dwarf2_debug_sections *names)
2132 : objfile (objfile_)
2135 names = &dwarf2_elf_names;
2137 bfd *obfd = objfile->obfd;
2139 for (asection *sec = obfd->sections; sec != NULL; sec = sec->next)
2140 locate_sections (obfd, sec, *names);
2143 static void free_dwo_files (htab_t dwo_files, struct objfile *objfile);
2145 dwarf2_per_objfile::~dwarf2_per_objfile ()
2147 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
2148 free_cached_comp_units ();
2150 if (quick_file_names_table)
2151 htab_delete (quick_file_names_table);
2153 if (line_header_hash)
2154 htab_delete (line_header_hash);
2156 for (dwarf2_per_cu_data *per_cu : all_comp_units)
2157 VEC_free (dwarf2_per_cu_ptr, per_cu->imported_symtabs);
2159 for (signatured_type *sig_type : all_type_units)
2160 VEC_free (dwarf2_per_cu_ptr, sig_type->per_cu.imported_symtabs);
2162 VEC_free (dwarf2_section_info_def, types);
2164 if (dwo_files != NULL)
2165 free_dwo_files (dwo_files, objfile);
2167 /* Everything else should be on the objfile obstack. */
2170 /* See declaration. */
2173 dwarf2_per_objfile::free_cached_comp_units ()
2175 dwarf2_per_cu_data *per_cu = read_in_chain;
2176 dwarf2_per_cu_data **last_chain = &read_in_chain;
2177 while (per_cu != NULL)
2179 dwarf2_per_cu_data *next_cu = per_cu->cu->read_in_chain;
2182 *last_chain = next_cu;
2187 /* A helper class that calls free_cached_comp_units on
2190 class free_cached_comp_units
2194 explicit free_cached_comp_units (dwarf2_per_objfile *per_objfile)
2195 : m_per_objfile (per_objfile)
2199 ~free_cached_comp_units ()
2201 m_per_objfile->free_cached_comp_units ();
2204 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units);
2208 dwarf2_per_objfile *m_per_objfile;
2211 /* Try to locate the sections we need for DWARF 2 debugging
2212 information and return true if we have enough to do something.
2213 NAMES points to the dwarf2 section names, or is NULL if the standard
2214 ELF names are used. */
2217 dwarf2_has_info (struct objfile *objfile,
2218 const struct dwarf2_debug_sections *names)
2220 if (objfile->flags & OBJF_READNEVER)
2223 struct dwarf2_per_objfile *dwarf2_per_objfile
2224 = get_dwarf2_per_objfile (objfile);
2226 if (dwarf2_per_objfile == NULL)
2228 /* Initialize per-objfile state. */
2230 = new (&objfile->objfile_obstack) struct dwarf2_per_objfile (objfile,
2232 set_dwarf2_per_objfile (objfile, dwarf2_per_objfile);
2234 return (!dwarf2_per_objfile->info.is_virtual
2235 && dwarf2_per_objfile->info.s.section != NULL
2236 && !dwarf2_per_objfile->abbrev.is_virtual
2237 && dwarf2_per_objfile->abbrev.s.section != NULL);
2240 /* Return the containing section of virtual section SECTION. */
2242 static struct dwarf2_section_info *
2243 get_containing_section (const struct dwarf2_section_info *section)
2245 gdb_assert (section->is_virtual);
2246 return section->s.containing_section;
2249 /* Return the bfd owner of SECTION. */
2252 get_section_bfd_owner (const struct dwarf2_section_info *section)
2254 if (section->is_virtual)
2256 section = get_containing_section (section);
2257 gdb_assert (!section->is_virtual);
2259 return section->s.section->owner;
2262 /* Return the bfd section of SECTION.
2263 Returns NULL if the section is not present. */
2266 get_section_bfd_section (const struct dwarf2_section_info *section)
2268 if (section->is_virtual)
2270 section = get_containing_section (section);
2271 gdb_assert (!section->is_virtual);
2273 return section->s.section;
2276 /* Return the name of SECTION. */
2279 get_section_name (const struct dwarf2_section_info *section)
2281 asection *sectp = get_section_bfd_section (section);
2283 gdb_assert (sectp != NULL);
2284 return bfd_section_name (get_section_bfd_owner (section), sectp);
2287 /* Return the name of the file SECTION is in. */
2290 get_section_file_name (const struct dwarf2_section_info *section)
2292 bfd *abfd = get_section_bfd_owner (section);
2294 return bfd_get_filename (abfd);
2297 /* Return the id of SECTION.
2298 Returns 0 if SECTION doesn't exist. */
2301 get_section_id (const struct dwarf2_section_info *section)
2303 asection *sectp = get_section_bfd_section (section);
2310 /* Return the flags of SECTION.
2311 SECTION (or containing section if this is a virtual section) must exist. */
2314 get_section_flags (const struct dwarf2_section_info *section)
2316 asection *sectp = get_section_bfd_section (section);
2318 gdb_assert (sectp != NULL);
2319 return bfd_get_section_flags (sectp->owner, sectp);
2322 /* When loading sections, we look either for uncompressed section or for
2323 compressed section names. */
2326 section_is_p (const char *section_name,
2327 const struct dwarf2_section_names *names)
2329 if (names->normal != NULL
2330 && strcmp (section_name, names->normal) == 0)
2332 if (names->compressed != NULL
2333 && strcmp (section_name, names->compressed) == 0)
2338 /* See declaration. */
2341 dwarf2_per_objfile::locate_sections (bfd *abfd, asection *sectp,
2342 const dwarf2_debug_sections &names)
2344 flagword aflag = bfd_get_section_flags (abfd, sectp);
2346 if ((aflag & SEC_HAS_CONTENTS) == 0)
2349 else if (section_is_p (sectp->name, &names.info))
2351 this->info.s.section = sectp;
2352 this->info.size = bfd_get_section_size (sectp);
2354 else if (section_is_p (sectp->name, &names.abbrev))
2356 this->abbrev.s.section = sectp;
2357 this->abbrev.size = bfd_get_section_size (sectp);
2359 else if (section_is_p (sectp->name, &names.line))
2361 this->line.s.section = sectp;
2362 this->line.size = bfd_get_section_size (sectp);
2364 else if (section_is_p (sectp->name, &names.loc))
2366 this->loc.s.section = sectp;
2367 this->loc.size = bfd_get_section_size (sectp);
2369 else if (section_is_p (sectp->name, &names.loclists))
2371 this->loclists.s.section = sectp;
2372 this->loclists.size = bfd_get_section_size (sectp);
2374 else if (section_is_p (sectp->name, &names.macinfo))
2376 this->macinfo.s.section = sectp;
2377 this->macinfo.size = bfd_get_section_size (sectp);
2379 else if (section_is_p (sectp->name, &names.macro))
2381 this->macro.s.section = sectp;
2382 this->macro.size = bfd_get_section_size (sectp);
2384 else if (section_is_p (sectp->name, &names.str))
2386 this->str.s.section = sectp;
2387 this->str.size = bfd_get_section_size (sectp);
2389 else if (section_is_p (sectp->name, &names.line_str))
2391 this->line_str.s.section = sectp;
2392 this->line_str.size = bfd_get_section_size (sectp);
2394 else if (section_is_p (sectp->name, &names.addr))
2396 this->addr.s.section = sectp;
2397 this->addr.size = bfd_get_section_size (sectp);
2399 else if (section_is_p (sectp->name, &names.frame))
2401 this->frame.s.section = sectp;
2402 this->frame.size = bfd_get_section_size (sectp);
2404 else if (section_is_p (sectp->name, &names.eh_frame))
2406 this->eh_frame.s.section = sectp;
2407 this->eh_frame.size = bfd_get_section_size (sectp);
2409 else if (section_is_p (sectp->name, &names.ranges))
2411 this->ranges.s.section = sectp;
2412 this->ranges.size = bfd_get_section_size (sectp);
2414 else if (section_is_p (sectp->name, &names.rnglists))
2416 this->rnglists.s.section = sectp;
2417 this->rnglists.size = bfd_get_section_size (sectp);
2419 else if (section_is_p (sectp->name, &names.types))
2421 struct dwarf2_section_info type_section;
2423 memset (&type_section, 0, sizeof (type_section));
2424 type_section.s.section = sectp;
2425 type_section.size = bfd_get_section_size (sectp);
2427 VEC_safe_push (dwarf2_section_info_def, this->types,
2430 else if (section_is_p (sectp->name, &names.gdb_index))
2432 this->gdb_index.s.section = sectp;
2433 this->gdb_index.size = bfd_get_section_size (sectp);
2435 else if (section_is_p (sectp->name, &names.debug_names))
2437 this->debug_names.s.section = sectp;
2438 this->debug_names.size = bfd_get_section_size (sectp);
2440 else if (section_is_p (sectp->name, &names.debug_aranges))
2442 this->debug_aranges.s.section = sectp;
2443 this->debug_aranges.size = bfd_get_section_size (sectp);
2446 if ((bfd_get_section_flags (abfd, sectp) & (SEC_LOAD | SEC_ALLOC))
2447 && bfd_section_vma (abfd, sectp) == 0)
2448 this->has_section_at_zero = true;
2451 /* A helper function that decides whether a section is empty,
2455 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2457 if (section->is_virtual)
2458 return section->size == 0;
2459 return section->s.section == NULL || section->size == 0;
2462 /* See dwarf2read.h. */
2465 dwarf2_read_section (struct objfile *objfile, dwarf2_section_info *info)
2469 gdb_byte *buf, *retbuf;
2473 info->buffer = NULL;
2476 if (dwarf2_section_empty_p (info))
2479 sectp = get_section_bfd_section (info);
2481 /* If this is a virtual section we need to read in the real one first. */
2482 if (info->is_virtual)
2484 struct dwarf2_section_info *containing_section =
2485 get_containing_section (info);
2487 gdb_assert (sectp != NULL);
2488 if ((sectp->flags & SEC_RELOC) != 0)
2490 error (_("Dwarf Error: DWP format V2 with relocations is not"
2491 " supported in section %s [in module %s]"),
2492 get_section_name (info), get_section_file_name (info));
2494 dwarf2_read_section (objfile, containing_section);
2495 /* Other code should have already caught virtual sections that don't
2497 gdb_assert (info->virtual_offset + info->size
2498 <= containing_section->size);
2499 /* If the real section is empty or there was a problem reading the
2500 section we shouldn't get here. */
2501 gdb_assert (containing_section->buffer != NULL);
2502 info->buffer = containing_section->buffer + info->virtual_offset;
2506 /* If the section has relocations, we must read it ourselves.
2507 Otherwise we attach it to the BFD. */
2508 if ((sectp->flags & SEC_RELOC) == 0)
2510 info->buffer = gdb_bfd_map_section (sectp, &info->size);
2514 buf = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, info->size);
2517 /* When debugging .o files, we may need to apply relocations; see
2518 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2519 We never compress sections in .o files, so we only need to
2520 try this when the section is not compressed. */
2521 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2524 info->buffer = retbuf;
2528 abfd = get_section_bfd_owner (info);
2529 gdb_assert (abfd != NULL);
2531 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2532 || bfd_bread (buf, info->size, abfd) != info->size)
2534 error (_("Dwarf Error: Can't read DWARF data"
2535 " in section %s [in module %s]"),
2536 bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2540 /* A helper function that returns the size of a section in a safe way.
2541 If you are positive that the section has been read before using the
2542 size, then it is safe to refer to the dwarf2_section_info object's
2543 "size" field directly. In other cases, you must call this
2544 function, because for compressed sections the size field is not set
2545 correctly until the section has been read. */
2547 static bfd_size_type
2548 dwarf2_section_size (struct objfile *objfile,
2549 struct dwarf2_section_info *info)
2552 dwarf2_read_section (objfile, info);
2556 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2560 dwarf2_get_section_info (struct objfile *objfile,
2561 enum dwarf2_section_enum sect,
2562 asection **sectp, const gdb_byte **bufp,
2563 bfd_size_type *sizep)
2565 struct dwarf2_per_objfile *data
2566 = (struct dwarf2_per_objfile *) objfile_data (objfile,
2567 dwarf2_objfile_data_key);
2568 struct dwarf2_section_info *info;
2570 /* We may see an objfile without any DWARF, in which case we just
2581 case DWARF2_DEBUG_FRAME:
2582 info = &data->frame;
2584 case DWARF2_EH_FRAME:
2585 info = &data->eh_frame;
2588 gdb_assert_not_reached ("unexpected section");
2591 dwarf2_read_section (objfile, info);
2593 *sectp = get_section_bfd_section (info);
2594 *bufp = info->buffer;
2595 *sizep = info->size;
2598 /* A helper function to find the sections for a .dwz file. */
2601 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2603 struct dwz_file *dwz_file = (struct dwz_file *) arg;
2605 /* Note that we only support the standard ELF names, because .dwz
2606 is ELF-only (at the time of writing). */
2607 if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2609 dwz_file->abbrev.s.section = sectp;
2610 dwz_file->abbrev.size = bfd_get_section_size (sectp);
2612 else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2614 dwz_file->info.s.section = sectp;
2615 dwz_file->info.size = bfd_get_section_size (sectp);
2617 else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2619 dwz_file->str.s.section = sectp;
2620 dwz_file->str.size = bfd_get_section_size (sectp);
2622 else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2624 dwz_file->line.s.section = sectp;
2625 dwz_file->line.size = bfd_get_section_size (sectp);
2627 else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2629 dwz_file->macro.s.section = sectp;
2630 dwz_file->macro.size = bfd_get_section_size (sectp);
2632 else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2634 dwz_file->gdb_index.s.section = sectp;
2635 dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2637 else if (section_is_p (sectp->name, &dwarf2_elf_names.debug_names))
2639 dwz_file->debug_names.s.section = sectp;
2640 dwz_file->debug_names.size = bfd_get_section_size (sectp);
2644 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2645 there is no .gnu_debugaltlink section in the file. Error if there
2646 is such a section but the file cannot be found. */
2648 static struct dwz_file *
2649 dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
2651 const char *filename;
2652 bfd_size_type buildid_len_arg;
2656 if (dwarf2_per_objfile->dwz_file != NULL)
2657 return dwarf2_per_objfile->dwz_file.get ();
2659 bfd_set_error (bfd_error_no_error);
2660 gdb::unique_xmalloc_ptr<char> data
2661 (bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2662 &buildid_len_arg, &buildid));
2665 if (bfd_get_error () == bfd_error_no_error)
2667 error (_("could not read '.gnu_debugaltlink' section: %s"),
2668 bfd_errmsg (bfd_get_error ()));
2671 gdb::unique_xmalloc_ptr<bfd_byte> buildid_holder (buildid);
2673 buildid_len = (size_t) buildid_len_arg;
2675 filename = data.get ();
2677 std::string abs_storage;
2678 if (!IS_ABSOLUTE_PATH (filename))
2680 gdb::unique_xmalloc_ptr<char> abs
2681 = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2683 abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
2684 filename = abs_storage.c_str ();
2687 /* First try the file name given in the section. If that doesn't
2688 work, try to use the build-id instead. */
2689 gdb_bfd_ref_ptr dwz_bfd (gdb_bfd_open (filename, gnutarget, -1));
2690 if (dwz_bfd != NULL)
2692 if (!build_id_verify (dwz_bfd.get (), buildid_len, buildid))
2696 if (dwz_bfd == NULL)
2697 dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2699 if (dwz_bfd == NULL)
2700 error (_("could not find '.gnu_debugaltlink' file for %s"),
2701 objfile_name (dwarf2_per_objfile->objfile));
2703 std::unique_ptr<struct dwz_file> result
2704 (new struct dwz_file (std::move (dwz_bfd)));
2706 bfd_map_over_sections (result->dwz_bfd.get (), locate_dwz_sections,
2709 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd,
2710 result->dwz_bfd.get ());
2711 dwarf2_per_objfile->dwz_file = std::move (result);
2712 return dwarf2_per_objfile->dwz_file.get ();
2715 /* DWARF quick_symbols_functions support. */
2717 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2718 unique line tables, so we maintain a separate table of all .debug_line
2719 derived entries to support the sharing.
2720 All the quick functions need is the list of file names. We discard the
2721 line_header when we're done and don't need to record it here. */
2722 struct quick_file_names
2724 /* The data used to construct the hash key. */
2725 struct stmt_list_hash hash;
2727 /* The number of entries in file_names, real_names. */
2728 unsigned int num_file_names;
2730 /* The file names from the line table, after being run through
2732 const char **file_names;
2734 /* The file names from the line table after being run through
2735 gdb_realpath. These are computed lazily. */
2736 const char **real_names;
2739 /* When using the index (and thus not using psymtabs), each CU has an
2740 object of this type. This is used to hold information needed by
2741 the various "quick" methods. */
2742 struct dwarf2_per_cu_quick_data
2744 /* The file table. This can be NULL if there was no file table
2745 or it's currently not read in.
2746 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2747 struct quick_file_names *file_names;
2749 /* The corresponding symbol table. This is NULL if symbols for this
2750 CU have not yet been read. */
2751 struct compunit_symtab *compunit_symtab;
2753 /* A temporary mark bit used when iterating over all CUs in
2754 expand_symtabs_matching. */
2755 unsigned int mark : 1;
2757 /* True if we've tried to read the file table and found there isn't one.
2758 There will be no point in trying to read it again next time. */
2759 unsigned int no_file_data : 1;
2762 /* Utility hash function for a stmt_list_hash. */
2765 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2769 if (stmt_list_hash->dwo_unit != NULL)
2770 v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2771 v += to_underlying (stmt_list_hash->line_sect_off);
2775 /* Utility equality function for a stmt_list_hash. */
2778 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2779 const struct stmt_list_hash *rhs)
2781 if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2783 if (lhs->dwo_unit != NULL
2784 && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2787 return lhs->line_sect_off == rhs->line_sect_off;
2790 /* Hash function for a quick_file_names. */
2793 hash_file_name_entry (const void *e)
2795 const struct quick_file_names *file_data
2796 = (const struct quick_file_names *) e;
2798 return hash_stmt_list_entry (&file_data->hash);
2801 /* Equality function for a quick_file_names. */
2804 eq_file_name_entry (const void *a, const void *b)
2806 const struct quick_file_names *ea = (const struct quick_file_names *) a;
2807 const struct quick_file_names *eb = (const struct quick_file_names *) b;
2809 return eq_stmt_list_entry (&ea->hash, &eb->hash);
2812 /* Delete function for a quick_file_names. */
2815 delete_file_name_entry (void *e)
2817 struct quick_file_names *file_data = (struct quick_file_names *) e;
2820 for (i = 0; i < file_data->num_file_names; ++i)
2822 xfree ((void*) file_data->file_names[i]);
2823 if (file_data->real_names)
2824 xfree ((void*) file_data->real_names[i]);
2827 /* The space for the struct itself lives on objfile_obstack,
2828 so we don't free it here. */
2831 /* Create a quick_file_names hash table. */
2834 create_quick_file_names_table (unsigned int nr_initial_entries)
2836 return htab_create_alloc (nr_initial_entries,
2837 hash_file_name_entry, eq_file_name_entry,
2838 delete_file_name_entry, xcalloc, xfree);
2841 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2842 have to be created afterwards. You should call age_cached_comp_units after
2843 processing PER_CU->CU. dw2_setup must have been already called. */
2846 load_cu (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2848 if (per_cu->is_debug_types)
2849 load_full_type_unit (per_cu);
2851 load_full_comp_unit (per_cu, skip_partial, language_minimal);
2853 if (per_cu->cu == NULL)
2854 return; /* Dummy CU. */
2856 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2859 /* Read in the symbols for PER_CU. */
2862 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2864 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2866 /* Skip type_unit_groups, reading the type units they contain
2867 is handled elsewhere. */
2868 if (IS_TYPE_UNIT_GROUP (per_cu))
2871 /* The destructor of dwarf2_queue_guard frees any entries left on
2872 the queue. After this point we're guaranteed to leave this function
2873 with the dwarf queue empty. */
2874 dwarf2_queue_guard q_guard;
2876 if (dwarf2_per_objfile->using_index
2877 ? per_cu->v.quick->compunit_symtab == NULL
2878 : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2880 queue_comp_unit (per_cu, language_minimal);
2881 load_cu (per_cu, skip_partial);
2883 /* If we just loaded a CU from a DWO, and we're working with an index
2884 that may badly handle TUs, load all the TUs in that DWO as well.
2885 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2886 if (!per_cu->is_debug_types
2887 && per_cu->cu != NULL
2888 && per_cu->cu->dwo_unit != NULL
2889 && dwarf2_per_objfile->index_table != NULL
2890 && dwarf2_per_objfile->index_table->version <= 7
2891 /* DWP files aren't supported yet. */
2892 && get_dwp_file (dwarf2_per_objfile) == NULL)
2893 queue_and_load_all_dwo_tus (per_cu);
2896 process_queue (dwarf2_per_objfile);
2898 /* Age the cache, releasing compilation units that have not
2899 been used recently. */
2900 age_cached_comp_units (dwarf2_per_objfile);
2903 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2904 the objfile from which this CU came. Returns the resulting symbol
2907 static struct compunit_symtab *
2908 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2910 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2912 gdb_assert (dwarf2_per_objfile->using_index);
2913 if (!per_cu->v.quick->compunit_symtab)
2915 free_cached_comp_units freer (dwarf2_per_objfile);
2916 scoped_restore decrementer = increment_reading_symtab ();
2917 dw2_do_instantiate_symtab (per_cu, skip_partial);
2918 process_cu_includes (dwarf2_per_objfile);
2921 return per_cu->v.quick->compunit_symtab;
2924 /* See declaration. */
2926 dwarf2_per_cu_data *
2927 dwarf2_per_objfile::get_cutu (int index)
2929 if (index >= this->all_comp_units.size ())
2931 index -= this->all_comp_units.size ();
2932 gdb_assert (index < this->all_type_units.size ());
2933 return &this->all_type_units[index]->per_cu;
2936 return this->all_comp_units[index];
2939 /* See declaration. */
2941 dwarf2_per_cu_data *
2942 dwarf2_per_objfile::get_cu (int index)
2944 gdb_assert (index >= 0 && index < this->all_comp_units.size ());
2946 return this->all_comp_units[index];
2949 /* See declaration. */
2952 dwarf2_per_objfile::get_tu (int index)
2954 gdb_assert (index >= 0 && index < this->all_type_units.size ());
2956 return this->all_type_units[index];
2959 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2960 objfile_obstack, and constructed with the specified field
2963 static dwarf2_per_cu_data *
2964 create_cu_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2965 struct dwarf2_section_info *section,
2967 sect_offset sect_off, ULONGEST length)
2969 struct objfile *objfile = dwarf2_per_objfile->objfile;
2970 dwarf2_per_cu_data *the_cu
2971 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2972 struct dwarf2_per_cu_data);
2973 the_cu->sect_off = sect_off;
2974 the_cu->length = length;
2975 the_cu->dwarf2_per_objfile = dwarf2_per_objfile;
2976 the_cu->section = section;
2977 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2978 struct dwarf2_per_cu_quick_data);
2979 the_cu->is_dwz = is_dwz;
2983 /* A helper for create_cus_from_index that handles a given list of
2987 create_cus_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2988 const gdb_byte *cu_list, offset_type n_elements,
2989 struct dwarf2_section_info *section,
2992 for (offset_type i = 0; i < n_elements; i += 2)
2994 gdb_static_assert (sizeof (ULONGEST) >= 8);
2996 sect_offset sect_off
2997 = (sect_offset) extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
2998 ULONGEST length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
3001 dwarf2_per_cu_data *per_cu
3002 = create_cu_from_index_list (dwarf2_per_objfile, section, is_dwz,
3004 dwarf2_per_objfile->all_comp_units.push_back (per_cu);
3008 /* Read the CU list from the mapped index, and use it to create all
3009 the CU objects for this objfile. */
3012 create_cus_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3013 const gdb_byte *cu_list, offset_type cu_list_elements,
3014 const gdb_byte *dwz_list, offset_type dwz_elements)
3016 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
3017 dwarf2_per_objfile->all_comp_units.reserve
3018 ((cu_list_elements + dwz_elements) / 2);
3020 create_cus_from_index_list (dwarf2_per_objfile, cu_list, cu_list_elements,
3021 &dwarf2_per_objfile->info, 0);
3023 if (dwz_elements == 0)
3026 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3027 create_cus_from_index_list (dwarf2_per_objfile, dwz_list, dwz_elements,
3031 /* Create the signatured type hash table from the index. */
3034 create_signatured_type_table_from_index
3035 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3036 struct dwarf2_section_info *section,
3037 const gdb_byte *bytes,
3038 offset_type elements)
3040 struct objfile *objfile = dwarf2_per_objfile->objfile;
3042 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3043 dwarf2_per_objfile->all_type_units.reserve (elements / 3);
3045 htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3047 for (offset_type i = 0; i < elements; i += 3)
3049 struct signatured_type *sig_type;
3052 cu_offset type_offset_in_tu;
3054 gdb_static_assert (sizeof (ULONGEST) >= 8);
3055 sect_offset sect_off
3056 = (sect_offset) extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
3058 = (cu_offset) extract_unsigned_integer (bytes + 8, 8,
3060 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
3063 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3064 struct signatured_type);
3065 sig_type->signature = signature;
3066 sig_type->type_offset_in_tu = type_offset_in_tu;
3067 sig_type->per_cu.is_debug_types = 1;
3068 sig_type->per_cu.section = section;
3069 sig_type->per_cu.sect_off = sect_off;
3070 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3071 sig_type->per_cu.v.quick
3072 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3073 struct dwarf2_per_cu_quick_data);
3075 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3078 dwarf2_per_objfile->all_type_units.push_back (sig_type);
3081 dwarf2_per_objfile->signatured_types = sig_types_hash;
3084 /* Create the signatured type hash table from .debug_names. */
3087 create_signatured_type_table_from_debug_names
3088 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3089 const mapped_debug_names &map,
3090 struct dwarf2_section_info *section,
3091 struct dwarf2_section_info *abbrev_section)
3093 struct objfile *objfile = dwarf2_per_objfile->objfile;
3095 dwarf2_read_section (objfile, section);
3096 dwarf2_read_section (objfile, abbrev_section);
3098 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3099 dwarf2_per_objfile->all_type_units.reserve (map.tu_count);
3101 htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3103 for (uint32_t i = 0; i < map.tu_count; ++i)
3105 struct signatured_type *sig_type;
3108 sect_offset sect_off
3109 = (sect_offset) (extract_unsigned_integer
3110 (map.tu_table_reordered + i * map.offset_size,
3112 map.dwarf5_byte_order));
3114 comp_unit_head cu_header;
3115 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
3117 section->buffer + to_underlying (sect_off),
3120 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3121 struct signatured_type);
3122 sig_type->signature = cu_header.signature;
3123 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
3124 sig_type->per_cu.is_debug_types = 1;
3125 sig_type->per_cu.section = section;
3126 sig_type->per_cu.sect_off = sect_off;
3127 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3128 sig_type->per_cu.v.quick
3129 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3130 struct dwarf2_per_cu_quick_data);
3132 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3135 dwarf2_per_objfile->all_type_units.push_back (sig_type);
3138 dwarf2_per_objfile->signatured_types = sig_types_hash;
3141 /* Read the address map data from the mapped index, and use it to
3142 populate the objfile's psymtabs_addrmap. */
3145 create_addrmap_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3146 struct mapped_index *index)
3148 struct objfile *objfile = dwarf2_per_objfile->objfile;
3149 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3150 const gdb_byte *iter, *end;
3151 struct addrmap *mutable_map;
3154 auto_obstack temp_obstack;
3156 mutable_map = addrmap_create_mutable (&temp_obstack);
3158 iter = index->address_table.data ();
3159 end = iter + index->address_table.size ();
3161 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3165 ULONGEST hi, lo, cu_index;
3166 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3168 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3170 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
3175 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
3176 hex_string (lo), hex_string (hi));
3180 if (cu_index >= dwarf2_per_objfile->all_comp_units.size ())
3182 complaint (_(".gdb_index address table has invalid CU number %u"),
3183 (unsigned) cu_index);
3187 lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr) - baseaddr;
3188 hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr) - baseaddr;
3189 addrmap_set_empty (mutable_map, lo, hi - 1,
3190 dwarf2_per_objfile->get_cu (cu_index));
3193 objfile->partial_symtabs->psymtabs_addrmap
3194 = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3197 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3198 populate the objfile's psymtabs_addrmap. */
3201 create_addrmap_from_aranges (struct dwarf2_per_objfile *dwarf2_per_objfile,
3202 struct dwarf2_section_info *section)
3204 struct objfile *objfile = dwarf2_per_objfile->objfile;
3205 bfd *abfd = objfile->obfd;
3206 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3207 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
3208 SECT_OFF_TEXT (objfile));
3210 auto_obstack temp_obstack;
3211 addrmap *mutable_map = addrmap_create_mutable (&temp_obstack);
3213 std::unordered_map<sect_offset,
3214 dwarf2_per_cu_data *,
3215 gdb::hash_enum<sect_offset>>
3216 debug_info_offset_to_per_cu;
3217 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3219 const auto insertpair
3220 = debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);
3221 if (!insertpair.second)
3223 warning (_("Section .debug_aranges in %s has duplicate "
3224 "debug_info_offset %s, ignoring .debug_aranges."),
3225 objfile_name (objfile), sect_offset_str (per_cu->sect_off));
3230 dwarf2_read_section (objfile, section);
3232 const bfd_endian dwarf5_byte_order = gdbarch_byte_order (gdbarch);
3234 const gdb_byte *addr = section->buffer;
3236 while (addr < section->buffer + section->size)
3238 const gdb_byte *const entry_addr = addr;
3239 unsigned int bytes_read;
3241 const LONGEST entry_length = read_initial_length (abfd, addr,
3245 const gdb_byte *const entry_end = addr + entry_length;
3246 const bool dwarf5_is_dwarf64 = bytes_read != 4;
3247 const uint8_t offset_size = dwarf5_is_dwarf64 ? 8 : 4;
3248 if (addr + entry_length > section->buffer + section->size)
3250 warning (_("Section .debug_aranges in %s entry at offset %zu "
3251 "length %s exceeds section length %s, "
3252 "ignoring .debug_aranges."),
3253 objfile_name (objfile), entry_addr - section->buffer,
3254 plongest (bytes_read + entry_length),
3255 pulongest (section->size));
3259 /* The version number. */
3260 const uint16_t version = read_2_bytes (abfd, addr);
3264 warning (_("Section .debug_aranges in %s entry at offset %zu "
3265 "has unsupported version %d, ignoring .debug_aranges."),
3266 objfile_name (objfile), entry_addr - section->buffer,
3271 const uint64_t debug_info_offset
3272 = extract_unsigned_integer (addr, offset_size, dwarf5_byte_order);
3273 addr += offset_size;
3274 const auto per_cu_it
3275 = debug_info_offset_to_per_cu.find (sect_offset (debug_info_offset));
3276 if (per_cu_it == debug_info_offset_to_per_cu.cend ())
3278 warning (_("Section .debug_aranges in %s entry at offset %zu "
3279 "debug_info_offset %s does not exists, "
3280 "ignoring .debug_aranges."),
3281 objfile_name (objfile), entry_addr - section->buffer,
3282 pulongest (debug_info_offset));
3285 dwarf2_per_cu_data *const per_cu = per_cu_it->second;
3287 const uint8_t address_size = *addr++;
3288 if (address_size < 1 || address_size > 8)
3290 warning (_("Section .debug_aranges in %s entry at offset %zu "
3291 "address_size %u is invalid, ignoring .debug_aranges."),
3292 objfile_name (objfile), entry_addr - section->buffer,
3297 const uint8_t segment_selector_size = *addr++;
3298 if (segment_selector_size != 0)
3300 warning (_("Section .debug_aranges in %s entry at offset %zu "
3301 "segment_selector_size %u is not supported, "
3302 "ignoring .debug_aranges."),
3303 objfile_name (objfile), entry_addr - section->buffer,
3304 segment_selector_size);
3308 /* Must pad to an alignment boundary that is twice the address
3309 size. It is undocumented by the DWARF standard but GCC does
3311 for (size_t padding = ((-(addr - section->buffer))
3312 & (2 * address_size - 1));
3313 padding > 0; padding--)
3316 warning (_("Section .debug_aranges in %s entry at offset %zu "
3317 "padding is not zero, ignoring .debug_aranges."),
3318 objfile_name (objfile), entry_addr - section->buffer);
3324 if (addr + 2 * address_size > entry_end)
3326 warning (_("Section .debug_aranges in %s entry at offset %zu "
3327 "address list is not properly terminated, "
3328 "ignoring .debug_aranges."),
3329 objfile_name (objfile), entry_addr - section->buffer);
3332 ULONGEST start = extract_unsigned_integer (addr, address_size,
3334 addr += address_size;
3335 ULONGEST length = extract_unsigned_integer (addr, address_size,
3337 addr += address_size;
3338 if (start == 0 && length == 0)
3340 if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
3342 /* Symbol was eliminated due to a COMDAT group. */
3345 ULONGEST end = start + length;
3346 start = (gdbarch_adjust_dwarf2_addr (gdbarch, start + baseaddr)
3348 end = (gdbarch_adjust_dwarf2_addr (gdbarch, end + baseaddr)
3350 addrmap_set_empty (mutable_map, start, end - 1, per_cu);
3354 objfile->partial_symtabs->psymtabs_addrmap
3355 = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3358 /* Find a slot in the mapped index INDEX for the object named NAME.
3359 If NAME is found, set *VEC_OUT to point to the CU vector in the
3360 constant pool and return true. If NAME cannot be found, return
3364 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
3365 offset_type **vec_out)
3368 offset_type slot, step;
3369 int (*cmp) (const char *, const char *);
3371 gdb::unique_xmalloc_ptr<char> without_params;
3372 if (current_language->la_language == language_cplus
3373 || current_language->la_language == language_fortran
3374 || current_language->la_language == language_d)
3376 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3379 if (strchr (name, '(') != NULL)
3381 without_params = cp_remove_params (name);
3383 if (without_params != NULL)
3384 name = without_params.get ();
3388 /* Index version 4 did not support case insensitive searches. But the
3389 indices for case insensitive languages are built in lowercase, therefore
3390 simulate our NAME being searched is also lowercased. */
3391 hash = mapped_index_string_hash ((index->version == 4
3392 && case_sensitivity == case_sensitive_off
3393 ? 5 : index->version),
3396 slot = hash & (index->symbol_table.size () - 1);
3397 step = ((hash * 17) & (index->symbol_table.size () - 1)) | 1;
3398 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
3404 const auto &bucket = index->symbol_table[slot];
3405 if (bucket.name == 0 && bucket.vec == 0)
3408 str = index->constant_pool + MAYBE_SWAP (bucket.name);
3409 if (!cmp (name, str))
3411 *vec_out = (offset_type *) (index->constant_pool
3412 + MAYBE_SWAP (bucket.vec));
3416 slot = (slot + step) & (index->symbol_table.size () - 1);
3420 /* A helper function that reads the .gdb_index from BUFFER and fills
3421 in MAP. FILENAME is the name of the file containing the data;
3422 it is used for error reporting. DEPRECATED_OK is true if it is
3423 ok to use deprecated sections.
3425 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3426 out parameters that are filled in with information about the CU and
3427 TU lists in the section.
3429 Returns true if all went well, false otherwise. */
3432 read_gdb_index_from_buffer (struct objfile *objfile,
3433 const char *filename,
3435 gdb::array_view<const gdb_byte> buffer,
3436 struct mapped_index *map,
3437 const gdb_byte **cu_list,
3438 offset_type *cu_list_elements,
3439 const gdb_byte **types_list,
3440 offset_type *types_list_elements)
3442 const gdb_byte *addr = &buffer[0];
3444 /* Version check. */
3445 offset_type version = MAYBE_SWAP (*(offset_type *) addr);
3446 /* Versions earlier than 3 emitted every copy of a psymbol. This
3447 causes the index to behave very poorly for certain requests. Version 3
3448 contained incomplete addrmap. So, it seems better to just ignore such
3452 static int warning_printed = 0;
3453 if (!warning_printed)
3455 warning (_("Skipping obsolete .gdb_index section in %s."),
3457 warning_printed = 1;
3461 /* Index version 4 uses a different hash function than index version
3464 Versions earlier than 6 did not emit psymbols for inlined
3465 functions. Using these files will cause GDB not to be able to
3466 set breakpoints on inlined functions by name, so we ignore these
3467 indices unless the user has done
3468 "set use-deprecated-index-sections on". */
3469 if (version < 6 && !deprecated_ok)
3471 static int warning_printed = 0;
3472 if (!warning_printed)
3475 Skipping deprecated .gdb_index section in %s.\n\
3476 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3477 to use the section anyway."),
3479 warning_printed = 1;
3483 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3484 of the TU (for symbols coming from TUs),
3485 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3486 Plus gold-generated indices can have duplicate entries for global symbols,
3487 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3488 These are just performance bugs, and we can't distinguish gdb-generated
3489 indices from gold-generated ones, so issue no warning here. */
3491 /* Indexes with higher version than the one supported by GDB may be no
3492 longer backward compatible. */
3496 map->version = version;
3498 offset_type *metadata = (offset_type *) (addr + sizeof (offset_type));
3501 *cu_list = addr + MAYBE_SWAP (metadata[i]);
3502 *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3506 *types_list = addr + MAYBE_SWAP (metadata[i]);
3507 *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3508 - MAYBE_SWAP (metadata[i]))
3512 const gdb_byte *address_table = addr + MAYBE_SWAP (metadata[i]);
3513 const gdb_byte *address_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3515 = gdb::array_view<const gdb_byte> (address_table, address_table_end);
3518 const gdb_byte *symbol_table = addr + MAYBE_SWAP (metadata[i]);
3519 const gdb_byte *symbol_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3521 = gdb::array_view<mapped_index::symbol_table_slot>
3522 ((mapped_index::symbol_table_slot *) symbol_table,
3523 (mapped_index::symbol_table_slot *) symbol_table_end);
3526 map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3531 /* Callback types for dwarf2_read_gdb_index. */
3533 typedef gdb::function_view
3534 <gdb::array_view<const gdb_byte>(objfile *, dwarf2_per_objfile *)>
3535 get_gdb_index_contents_ftype;
3536 typedef gdb::function_view
3537 <gdb::array_view<const gdb_byte>(objfile *, dwz_file *)>
3538 get_gdb_index_contents_dwz_ftype;
3540 /* Read .gdb_index. If everything went ok, initialize the "quick"
3541 elements of all the CUs and return 1. Otherwise, return 0. */
3544 dwarf2_read_gdb_index
3545 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3546 get_gdb_index_contents_ftype get_gdb_index_contents,
3547 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz)
3549 const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3550 offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3551 struct dwz_file *dwz;
3552 struct objfile *objfile = dwarf2_per_objfile->objfile;
3554 gdb::array_view<const gdb_byte> main_index_contents
3555 = get_gdb_index_contents (objfile, dwarf2_per_objfile);
3557 if (main_index_contents.empty ())
3560 std::unique_ptr<struct mapped_index> map (new struct mapped_index);
3561 if (!read_gdb_index_from_buffer (objfile, objfile_name (objfile),
3562 use_deprecated_index_sections,
3563 main_index_contents, map.get (), &cu_list,
3564 &cu_list_elements, &types_list,
3565 &types_list_elements))
3568 /* Don't use the index if it's empty. */
3569 if (map->symbol_table.empty ())
3572 /* If there is a .dwz file, read it so we can get its CU list as
3574 dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3577 struct mapped_index dwz_map;
3578 const gdb_byte *dwz_types_ignore;
3579 offset_type dwz_types_elements_ignore;
3581 gdb::array_view<const gdb_byte> dwz_index_content
3582 = get_gdb_index_contents_dwz (objfile, dwz);
3584 if (dwz_index_content.empty ())
3587 if (!read_gdb_index_from_buffer (objfile,
3588 bfd_get_filename (dwz->dwz_bfd), 1,
3589 dwz_index_content, &dwz_map,
3590 &dwz_list, &dwz_list_elements,
3592 &dwz_types_elements_ignore))
3594 warning (_("could not read '.gdb_index' section from %s; skipping"),
3595 bfd_get_filename (dwz->dwz_bfd));
3600 create_cus_from_index (dwarf2_per_objfile, cu_list, cu_list_elements,
3601 dwz_list, dwz_list_elements);
3603 if (types_list_elements)
3605 struct dwarf2_section_info *section;
3607 /* We can only handle a single .debug_types when we have an
3609 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3612 section = VEC_index (dwarf2_section_info_def,
3613 dwarf2_per_objfile->types, 0);
3615 create_signatured_type_table_from_index (dwarf2_per_objfile, section,
3616 types_list, types_list_elements);
3619 create_addrmap_from_index (dwarf2_per_objfile, map.get ());
3621 dwarf2_per_objfile->index_table = std::move (map);
3622 dwarf2_per_objfile->using_index = 1;
3623 dwarf2_per_objfile->quick_file_names_table =
3624 create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
3629 /* die_reader_func for dw2_get_file_names. */
3632 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3633 const gdb_byte *info_ptr,
3634 struct die_info *comp_unit_die,
3638 struct dwarf2_cu *cu = reader->cu;
3639 struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3640 struct dwarf2_per_objfile *dwarf2_per_objfile
3641 = cu->per_cu->dwarf2_per_objfile;
3642 struct objfile *objfile = dwarf2_per_objfile->objfile;
3643 struct dwarf2_per_cu_data *lh_cu;
3644 struct attribute *attr;
3647 struct quick_file_names *qfn;
3649 gdb_assert (! this_cu->is_debug_types);
3651 /* Our callers never want to match partial units -- instead they
3652 will match the enclosing full CU. */
3653 if (comp_unit_die->tag == DW_TAG_partial_unit)
3655 this_cu->v.quick->no_file_data = 1;
3663 sect_offset line_offset {};
3665 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3668 struct quick_file_names find_entry;
3670 line_offset = (sect_offset) DW_UNSND (attr);
3672 /* We may have already read in this line header (TU line header sharing).
3673 If we have we're done. */
3674 find_entry.hash.dwo_unit = cu->dwo_unit;
3675 find_entry.hash.line_sect_off = line_offset;
3676 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3677 &find_entry, INSERT);
3680 lh_cu->v.quick->file_names = (struct quick_file_names *) *slot;
3684 lh = dwarf_decode_line_header (line_offset, cu);
3688 lh_cu->v.quick->no_file_data = 1;
3692 qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
3693 qfn->hash.dwo_unit = cu->dwo_unit;
3694 qfn->hash.line_sect_off = line_offset;
3695 gdb_assert (slot != NULL);
3698 file_and_directory fnd = find_file_and_directory (comp_unit_die, cu);
3700 qfn->num_file_names = lh->file_names.size ();
3702 XOBNEWVEC (&objfile->objfile_obstack, const char *, lh->file_names.size ());
3703 for (i = 0; i < lh->file_names.size (); ++i)
3704 qfn->file_names[i] = file_full_name (i + 1, lh.get (), fnd.comp_dir);
3705 qfn->real_names = NULL;
3707 lh_cu->v.quick->file_names = qfn;
3710 /* A helper for the "quick" functions which attempts to read the line
3711 table for THIS_CU. */
3713 static struct quick_file_names *
3714 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3716 /* This should never be called for TUs. */
3717 gdb_assert (! this_cu->is_debug_types);
3718 /* Nor type unit groups. */
3719 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3721 if (this_cu->v.quick->file_names != NULL)
3722 return this_cu->v.quick->file_names;
3723 /* If we know there is no line data, no point in looking again. */
3724 if (this_cu->v.quick->no_file_data)
3727 init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3729 if (this_cu->v.quick->no_file_data)
3731 return this_cu->v.quick->file_names;
3734 /* A helper for the "quick" functions which computes and caches the
3735 real path for a given file name from the line table. */
3738 dw2_get_real_path (struct objfile *objfile,
3739 struct quick_file_names *qfn, int index)
3741 if (qfn->real_names == NULL)
3742 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3743 qfn->num_file_names, const char *);
3745 if (qfn->real_names[index] == NULL)
3746 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]).release ();
3748 return qfn->real_names[index];
3751 static struct symtab *
3752 dw2_find_last_source_symtab (struct objfile *objfile)
3754 struct dwarf2_per_objfile *dwarf2_per_objfile
3755 = get_dwarf2_per_objfile (objfile);
3756 dwarf2_per_cu_data *dwarf_cu = dwarf2_per_objfile->all_comp_units.back ();
3757 compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu, false);
3762 return compunit_primary_filetab (cust);
3765 /* Traversal function for dw2_forget_cached_source_info. */
3768 dw2_free_cached_file_names (void **slot, void *info)
3770 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3772 if (file_data->real_names)
3776 for (i = 0; i < file_data->num_file_names; ++i)
3778 xfree ((void*) file_data->real_names[i]);
3779 file_data->real_names[i] = NULL;
3787 dw2_forget_cached_source_info (struct objfile *objfile)
3789 struct dwarf2_per_objfile *dwarf2_per_objfile
3790 = get_dwarf2_per_objfile (objfile);
3792 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3793 dw2_free_cached_file_names, NULL);
3796 /* Helper function for dw2_map_symtabs_matching_filename that expands
3797 the symtabs and calls the iterator. */
3800 dw2_map_expand_apply (struct objfile *objfile,
3801 struct dwarf2_per_cu_data *per_cu,
3802 const char *name, const char *real_path,
3803 gdb::function_view<bool (symtab *)> callback)
3805 struct compunit_symtab *last_made = objfile->compunit_symtabs;
3807 /* Don't visit already-expanded CUs. */
3808 if (per_cu->v.quick->compunit_symtab)
3811 /* This may expand more than one symtab, and we want to iterate over
3813 dw2_instantiate_symtab (per_cu, false);
3815 return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
3816 last_made, callback);
3819 /* Implementation of the map_symtabs_matching_filename method. */
3822 dw2_map_symtabs_matching_filename
3823 (struct objfile *objfile, const char *name, const char *real_path,
3824 gdb::function_view<bool (symtab *)> callback)
3826 const char *name_basename = lbasename (name);
3827 struct dwarf2_per_objfile *dwarf2_per_objfile
3828 = get_dwarf2_per_objfile (objfile);
3830 /* The rule is CUs specify all the files, including those used by
3831 any TU, so there's no need to scan TUs here. */
3833 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3835 /* We only need to look at symtabs not already expanded. */
3836 if (per_cu->v.quick->compunit_symtab)
3839 quick_file_names *file_data = dw2_get_file_names (per_cu);
3840 if (file_data == NULL)
3843 for (int j = 0; j < file_data->num_file_names; ++j)
3845 const char *this_name = file_data->file_names[j];
3846 const char *this_real_name;
3848 if (compare_filenames_for_search (this_name, name))
3850 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3856 /* Before we invoke realpath, which can get expensive when many
3857 files are involved, do a quick comparison of the basenames. */
3858 if (! basenames_may_differ
3859 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3862 this_real_name = dw2_get_real_path (objfile, file_data, j);
3863 if (compare_filenames_for_search (this_real_name, name))
3865 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3871 if (real_path != NULL)
3873 gdb_assert (IS_ABSOLUTE_PATH (real_path));
3874 gdb_assert (IS_ABSOLUTE_PATH (name));
3875 if (this_real_name != NULL
3876 && FILENAME_CMP (real_path, this_real_name) == 0)
3878 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3890 /* Struct used to manage iterating over all CUs looking for a symbol. */
3892 struct dw2_symtab_iterator
3894 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3895 struct dwarf2_per_objfile *dwarf2_per_objfile;
3896 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3897 int want_specific_block;
3898 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3899 Unused if !WANT_SPECIFIC_BLOCK. */
3901 /* The kind of symbol we're looking for. */
3903 /* The list of CUs from the index entry of the symbol,
3904 or NULL if not found. */
3906 /* The next element in VEC to look at. */
3908 /* The number of elements in VEC, or zero if there is no match. */
3910 /* Have we seen a global version of the symbol?
3911 If so we can ignore all further global instances.
3912 This is to work around gold/15646, inefficient gold-generated
3917 /* Initialize the index symtab iterator ITER.
3918 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3919 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3922 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3923 struct dwarf2_per_objfile *dwarf2_per_objfile,
3924 int want_specific_block,
3929 iter->dwarf2_per_objfile = dwarf2_per_objfile;
3930 iter->want_specific_block = want_specific_block;
3931 iter->block_index = block_index;
3932 iter->domain = domain;
3934 iter->global_seen = 0;
3936 mapped_index *index = dwarf2_per_objfile->index_table.get ();
3938 /* index is NULL if OBJF_READNOW. */
3939 if (index != NULL && find_slot_in_mapped_hash (index, name, &iter->vec))
3940 iter->length = MAYBE_SWAP (*iter->vec);
3948 /* Return the next matching CU or NULL if there are no more. */
3950 static struct dwarf2_per_cu_data *
3951 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
3953 struct dwarf2_per_objfile *dwarf2_per_objfile = iter->dwarf2_per_objfile;
3955 for ( ; iter->next < iter->length; ++iter->next)
3957 offset_type cu_index_and_attrs =
3958 MAYBE_SWAP (iter->vec[iter->next + 1]);
3959 offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3960 int want_static = iter->block_index != GLOBAL_BLOCK;
3961 /* This value is only valid for index versions >= 7. */
3962 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3963 gdb_index_symbol_kind symbol_kind =
3964 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3965 /* Only check the symbol attributes if they're present.
3966 Indices prior to version 7 don't record them,
3967 and indices >= 7 may elide them for certain symbols
3968 (gold does this). */
3970 (dwarf2_per_objfile->index_table->version >= 7
3971 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3973 /* Don't crash on bad data. */
3974 if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
3975 + dwarf2_per_objfile->all_type_units.size ()))
3977 complaint (_(".gdb_index entry has bad CU index"
3979 objfile_name (dwarf2_per_objfile->objfile));
3983 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
3985 /* Skip if already read in. */
3986 if (per_cu->v.quick->compunit_symtab)
3989 /* Check static vs global. */
3992 if (iter->want_specific_block
3993 && want_static != is_static)
3995 /* Work around gold/15646. */
3996 if (!is_static && iter->global_seen)
3999 iter->global_seen = 1;
4002 /* Only check the symbol's kind if it has one. */
4005 switch (iter->domain)
4008 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
4009 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
4010 /* Some types are also in VAR_DOMAIN. */
4011 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4015 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4019 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
4034 static struct compunit_symtab *
4035 dw2_lookup_symbol (struct objfile *objfile, int block_index,
4036 const char *name, domain_enum domain)
4038 struct compunit_symtab *stab_best = NULL;
4039 struct dwarf2_per_objfile *dwarf2_per_objfile
4040 = get_dwarf2_per_objfile (objfile);
4042 lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
4044 struct dw2_symtab_iterator iter;
4045 struct dwarf2_per_cu_data *per_cu;
4047 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 1, block_index, domain, name);
4049 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4051 struct symbol *sym, *with_opaque = NULL;
4052 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
4053 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
4054 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
4056 sym = block_find_symbol (block, name, domain,
4057 block_find_non_opaque_type_preferred,
4060 /* Some caution must be observed with overloaded functions
4061 and methods, since the index will not contain any overload
4062 information (but NAME might contain it). */
4065 && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
4067 if (with_opaque != NULL
4068 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
4071 /* Keep looking through other CUs. */
4078 dw2_print_stats (struct objfile *objfile)
4080 struct dwarf2_per_objfile *dwarf2_per_objfile
4081 = get_dwarf2_per_objfile (objfile);
4082 int total = (dwarf2_per_objfile->all_comp_units.size ()
4083 + dwarf2_per_objfile->all_type_units.size ());
4086 for (int i = 0; i < total; ++i)
4088 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4090 if (!per_cu->v.quick->compunit_symtab)
4093 printf_filtered (_(" Number of read CUs: %d\n"), total - count);
4094 printf_filtered (_(" Number of unread CUs: %d\n"), count);
4097 /* This dumps minimal information about the index.
4098 It is called via "mt print objfiles".
4099 One use is to verify .gdb_index has been loaded by the
4100 gdb.dwarf2/gdb-index.exp testcase. */
4103 dw2_dump (struct objfile *objfile)
4105 struct dwarf2_per_objfile *dwarf2_per_objfile
4106 = get_dwarf2_per_objfile (objfile);
4108 gdb_assert (dwarf2_per_objfile->using_index);
4109 printf_filtered (".gdb_index:");
4110 if (dwarf2_per_objfile->index_table != NULL)
4112 printf_filtered (" version %d\n",
4113 dwarf2_per_objfile->index_table->version);
4116 printf_filtered (" faked for \"readnow\"\n");
4117 printf_filtered ("\n");
4121 dw2_expand_symtabs_for_function (struct objfile *objfile,
4122 const char *func_name)
4124 struct dwarf2_per_objfile *dwarf2_per_objfile
4125 = get_dwarf2_per_objfile (objfile);
4127 struct dw2_symtab_iterator iter;
4128 struct dwarf2_per_cu_data *per_cu;
4130 /* Note: It doesn't matter what we pass for block_index here. */
4131 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 0, GLOBAL_BLOCK, VAR_DOMAIN,
4134 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4135 dw2_instantiate_symtab (per_cu, false);
4140 dw2_expand_all_symtabs (struct objfile *objfile)
4142 struct dwarf2_per_objfile *dwarf2_per_objfile
4143 = get_dwarf2_per_objfile (objfile);
4144 int total_units = (dwarf2_per_objfile->all_comp_units.size ()
4145 + dwarf2_per_objfile->all_type_units.size ());
4147 for (int i = 0; i < total_units; ++i)
4149 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4151 /* We don't want to directly expand a partial CU, because if we
4152 read it with the wrong language, then assertion failures can
4153 be triggered later on. See PR symtab/23010. So, tell
4154 dw2_instantiate_symtab to skip partial CUs -- any important
4155 partial CU will be read via DW_TAG_imported_unit anyway. */
4156 dw2_instantiate_symtab (per_cu, true);
4161 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
4162 const char *fullname)
4164 struct dwarf2_per_objfile *dwarf2_per_objfile
4165 = get_dwarf2_per_objfile (objfile);
4167 /* We don't need to consider type units here.
4168 This is only called for examining code, e.g. expand_line_sal.
4169 There can be an order of magnitude (or more) more type units
4170 than comp units, and we avoid them if we can. */
4172 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
4174 /* We only need to look at symtabs not already expanded. */
4175 if (per_cu->v.quick->compunit_symtab)
4178 quick_file_names *file_data = dw2_get_file_names (per_cu);
4179 if (file_data == NULL)
4182 for (int j = 0; j < file_data->num_file_names; ++j)
4184 const char *this_fullname = file_data->file_names[j];
4186 if (filename_cmp (this_fullname, fullname) == 0)
4188 dw2_instantiate_symtab (per_cu, false);
4196 dw2_map_matching_symbols (struct objfile *objfile,
4197 const char * name, domain_enum domain,
4199 int (*callback) (struct block *,
4200 struct symbol *, void *),
4201 void *data, symbol_name_match_type match,
4202 symbol_compare_ftype *ordered_compare)
4204 /* Currently unimplemented; used for Ada. The function can be called if the
4205 current language is Ada for a non-Ada objfile using GNU index. As Ada
4206 does not look for non-Ada symbols this function should just return. */
4209 /* Symbol name matcher for .gdb_index names.
4211 Symbol names in .gdb_index have a few particularities:
4213 - There's no indication of which is the language of each symbol.
4215 Since each language has its own symbol name matching algorithm,
4216 and we don't know which language is the right one, we must match
4217 each symbol against all languages. This would be a potential
4218 performance problem if it were not mitigated by the
4219 mapped_index::name_components lookup table, which significantly
4220 reduces the number of times we need to call into this matcher,
4221 making it a non-issue.
4223 - Symbol names in the index have no overload (parameter)
4224 information. I.e., in C++, "foo(int)" and "foo(long)" both
4225 appear as "foo" in the index, for example.
4227 This means that the lookup names passed to the symbol name
4228 matcher functions must have no parameter information either
4229 because (e.g.) symbol search name "foo" does not match
4230 lookup-name "foo(int)" [while swapping search name for lookup
4233 class gdb_index_symbol_name_matcher
4236 /* Prepares the vector of comparison functions for LOOKUP_NAME. */
4237 gdb_index_symbol_name_matcher (const lookup_name_info &lookup_name);
4239 /* Walk all the matcher routines and match SYMBOL_NAME against them.
4240 Returns true if any matcher matches. */
4241 bool matches (const char *symbol_name);
4244 /* A reference to the lookup name we're matching against. */
4245 const lookup_name_info &m_lookup_name;
4247 /* A vector holding all the different symbol name matchers, for all
4249 std::vector<symbol_name_matcher_ftype *> m_symbol_name_matcher_funcs;
4252 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4253 (const lookup_name_info &lookup_name)
4254 : m_lookup_name (lookup_name)
4256 /* Prepare the vector of comparison functions upfront, to avoid
4257 doing the same work for each symbol. Care is taken to avoid
4258 matching with the same matcher more than once if/when multiple
4259 languages use the same matcher function. */
4260 auto &matchers = m_symbol_name_matcher_funcs;
4261 matchers.reserve (nr_languages);
4263 matchers.push_back (default_symbol_name_matcher);
4265 for (int i = 0; i < nr_languages; i++)
4267 const language_defn *lang = language_def ((enum language) i);
4268 symbol_name_matcher_ftype *name_matcher
4269 = get_symbol_name_matcher (lang, m_lookup_name);
4271 /* Don't insert the same comparison routine more than once.
4272 Note that we do this linear walk instead of a seemingly
4273 cheaper sorted insert, or use a std::set or something like
4274 that, because relative order of function addresses is not
4275 stable. This is not a problem in practice because the number
4276 of supported languages is low, and the cost here is tiny
4277 compared to the number of searches we'll do afterwards using
4279 if (name_matcher != default_symbol_name_matcher
4280 && (std::find (matchers.begin (), matchers.end (), name_matcher)
4281 == matchers.end ()))
4282 matchers.push_back (name_matcher);
4287 gdb_index_symbol_name_matcher::matches (const char *symbol_name)
4289 for (auto matches_name : m_symbol_name_matcher_funcs)
4290 if (matches_name (symbol_name, m_lookup_name, NULL))
4296 /* Starting from a search name, return the string that finds the upper
4297 bound of all strings that start with SEARCH_NAME in a sorted name
4298 list. Returns the empty string to indicate that the upper bound is
4299 the end of the list. */
4302 make_sort_after_prefix_name (const char *search_name)
4304 /* When looking to complete "func", we find the upper bound of all
4305 symbols that start with "func" by looking for where we'd insert
4306 the closest string that would follow "func" in lexicographical
4307 order. Usually, that's "func"-with-last-character-incremented,
4308 i.e. "fund". Mind non-ASCII characters, though. Usually those
4309 will be UTF-8 multi-byte sequences, but we can't be certain.
4310 Especially mind the 0xff character, which is a valid character in
4311 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4312 rule out compilers allowing it in identifiers. Note that
4313 conveniently, strcmp/strcasecmp are specified to compare
4314 characters interpreted as unsigned char. So what we do is treat
4315 the whole string as a base 256 number composed of a sequence of
4316 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4317 to 0, and carries 1 to the following more-significant position.
4318 If the very first character in SEARCH_NAME ends up incremented
4319 and carries/overflows, then the upper bound is the end of the
4320 list. The string after the empty string is also the empty
4323 Some examples of this operation:
4325 SEARCH_NAME => "+1" RESULT
4329 "\xff" "a" "\xff" => "\xff" "b"
4334 Then, with these symbols for example:
4340 completing "func" looks for symbols between "func" and
4341 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4342 which finds "func" and "func1", but not "fund".
4346 funcÿ (Latin1 'ÿ' [0xff])
4350 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4351 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4355 ÿÿ (Latin1 'ÿ' [0xff])
4358 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4359 the end of the list.
4361 std::string after = search_name;
4362 while (!after.empty () && (unsigned char) after.back () == 0xff)
4364 if (!after.empty ())
4365 after.back () = (unsigned char) after.back () + 1;
4369 /* See declaration. */
4371 std::pair<std::vector<name_component>::const_iterator,
4372 std::vector<name_component>::const_iterator>
4373 mapped_index_base::find_name_components_bounds
4374 (const lookup_name_info &lookup_name_without_params) const
4377 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4380 = lookup_name_without_params.cplus ().lookup_name ().c_str ();
4382 /* Comparison function object for lower_bound that matches against a
4383 given symbol name. */
4384 auto lookup_compare_lower = [&] (const name_component &elem,
4387 const char *elem_qualified = this->symbol_name_at (elem.idx);
4388 const char *elem_name = elem_qualified + elem.name_offset;
4389 return name_cmp (elem_name, name) < 0;
4392 /* Comparison function object for upper_bound that matches against a
4393 given symbol name. */
4394 auto lookup_compare_upper = [&] (const char *name,
4395 const name_component &elem)
4397 const char *elem_qualified = this->symbol_name_at (elem.idx);
4398 const char *elem_name = elem_qualified + elem.name_offset;
4399 return name_cmp (name, elem_name) < 0;
4402 auto begin = this->name_components.begin ();
4403 auto end = this->name_components.end ();
4405 /* Find the lower bound. */
4408 if (lookup_name_without_params.completion_mode () && cplus[0] == '\0')
4411 return std::lower_bound (begin, end, cplus, lookup_compare_lower);
4414 /* Find the upper bound. */
4417 if (lookup_name_without_params.completion_mode ())
4419 /* In completion mode, we want UPPER to point past all
4420 symbols names that have the same prefix. I.e., with
4421 these symbols, and completing "func":
4423 function << lower bound
4425 other_function << upper bound
4427 We find the upper bound by looking for the insertion
4428 point of "func"-with-last-character-incremented,
4430 std::string after = make_sort_after_prefix_name (cplus);
4433 return std::lower_bound (lower, end, after.c_str (),
4434 lookup_compare_lower);
4437 return std::upper_bound (lower, end, cplus, lookup_compare_upper);
4440 return {lower, upper};
4443 /* See declaration. */
4446 mapped_index_base::build_name_components ()
4448 if (!this->name_components.empty ())
4451 this->name_components_casing = case_sensitivity;
4453 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4455 /* The code below only knows how to break apart components of C++
4456 symbol names (and other languages that use '::' as
4457 namespace/module separator). If we add support for wild matching
4458 to some language that uses some other operator (E.g., Ada, Go and
4459 D use '.'), then we'll need to try splitting the symbol name
4460 according to that language too. Note that Ada does support wild
4461 matching, but doesn't currently support .gdb_index. */
4462 auto count = this->symbol_name_count ();
4463 for (offset_type idx = 0; idx < count; idx++)
4465 if (this->symbol_name_slot_invalid (idx))
4468 const char *name = this->symbol_name_at (idx);
4470 /* Add each name component to the name component table. */
4471 unsigned int previous_len = 0;
4472 for (unsigned int current_len = cp_find_first_component (name);
4473 name[current_len] != '\0';
4474 current_len += cp_find_first_component (name + current_len))
4476 gdb_assert (name[current_len] == ':');
4477 this->name_components.push_back ({previous_len, idx});
4478 /* Skip the '::'. */
4480 previous_len = current_len;
4482 this->name_components.push_back ({previous_len, idx});
4485 /* Sort name_components elements by name. */
4486 auto name_comp_compare = [&] (const name_component &left,
4487 const name_component &right)
4489 const char *left_qualified = this->symbol_name_at (left.idx);
4490 const char *right_qualified = this->symbol_name_at (right.idx);
4492 const char *left_name = left_qualified + left.name_offset;
4493 const char *right_name = right_qualified + right.name_offset;
4495 return name_cmp (left_name, right_name) < 0;
4498 std::sort (this->name_components.begin (),
4499 this->name_components.end (),
4503 /* Helper for dw2_expand_symtabs_matching that works with a
4504 mapped_index_base instead of the containing objfile. This is split
4505 to a separate function in order to be able to unit test the
4506 name_components matching using a mock mapped_index_base. For each
4507 symbol name that matches, calls MATCH_CALLBACK, passing it the
4508 symbol's index in the mapped_index_base symbol table. */
4511 dw2_expand_symtabs_matching_symbol
4512 (mapped_index_base &index,
4513 const lookup_name_info &lookup_name_in,
4514 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
4515 enum search_domain kind,
4516 gdb::function_view<void (offset_type)> match_callback)
4518 lookup_name_info lookup_name_without_params
4519 = lookup_name_in.make_ignore_params ();
4520 gdb_index_symbol_name_matcher lookup_name_matcher
4521 (lookup_name_without_params);
4523 /* Build the symbol name component sorted vector, if we haven't
4525 index.build_name_components ();
4527 auto bounds = index.find_name_components_bounds (lookup_name_without_params);
4529 /* Now for each symbol name in range, check to see if we have a name
4530 match, and if so, call the MATCH_CALLBACK callback. */
4532 /* The same symbol may appear more than once in the range though.
4533 E.g., if we're looking for symbols that complete "w", and we have
4534 a symbol named "w1::w2", we'll find the two name components for
4535 that same symbol in the range. To be sure we only call the
4536 callback once per symbol, we first collect the symbol name
4537 indexes that matched in a temporary vector and ignore
4539 std::vector<offset_type> matches;
4540 matches.reserve (std::distance (bounds.first, bounds.second));
4542 for (; bounds.first != bounds.second; ++bounds.first)
4544 const char *qualified = index.symbol_name_at (bounds.first->idx);
4546 if (!lookup_name_matcher.matches (qualified)
4547 || (symbol_matcher != NULL && !symbol_matcher (qualified)))
4550 matches.push_back (bounds.first->idx);
4553 std::sort (matches.begin (), matches.end ());
4555 /* Finally call the callback, once per match. */
4557 for (offset_type idx : matches)
4561 match_callback (idx);
4566 /* Above we use a type wider than idx's for 'prev', since 0 and
4567 (offset_type)-1 are both possible values. */
4568 static_assert (sizeof (prev) > sizeof (offset_type), "");
4573 namespace selftests { namespace dw2_expand_symtabs_matching {
4575 /* A mock .gdb_index/.debug_names-like name index table, enough to
4576 exercise dw2_expand_symtabs_matching_symbol, which works with the
4577 mapped_index_base interface. Builds an index from the symbol list
4578 passed as parameter to the constructor. */
4579 class mock_mapped_index : public mapped_index_base
4582 mock_mapped_index (gdb::array_view<const char *> symbols)
4583 : m_symbol_table (symbols)
4586 DISABLE_COPY_AND_ASSIGN (mock_mapped_index);
4588 /* Return the number of names in the symbol table. */
4589 size_t symbol_name_count () const override
4591 return m_symbol_table.size ();
4594 /* Get the name of the symbol at IDX in the symbol table. */
4595 const char *symbol_name_at (offset_type idx) const override
4597 return m_symbol_table[idx];
4601 gdb::array_view<const char *> m_symbol_table;
4604 /* Convenience function that converts a NULL pointer to a "<null>"
4605 string, to pass to print routines. */
4608 string_or_null (const char *str)
4610 return str != NULL ? str : "<null>";
4613 /* Check if a lookup_name_info built from
4614 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4615 index. EXPECTED_LIST is the list of expected matches, in expected
4616 matching order. If no match expected, then an empty list is
4617 specified. Returns true on success. On failure prints a warning
4618 indicating the file:line that failed, and returns false. */
4621 check_match (const char *file, int line,
4622 mock_mapped_index &mock_index,
4623 const char *name, symbol_name_match_type match_type,
4624 bool completion_mode,
4625 std::initializer_list<const char *> expected_list)
4627 lookup_name_info lookup_name (name, match_type, completion_mode);
4629 bool matched = true;
4631 auto mismatch = [&] (const char *expected_str,
4634 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4635 "expected=\"%s\", got=\"%s\"\n"),
4637 (match_type == symbol_name_match_type::FULL
4639 name, string_or_null (expected_str), string_or_null (got));
4643 auto expected_it = expected_list.begin ();
4644 auto expected_end = expected_list.end ();
4646 dw2_expand_symtabs_matching_symbol (mock_index, lookup_name,
4648 [&] (offset_type idx)
4650 const char *matched_name = mock_index.symbol_name_at (idx);
4651 const char *expected_str
4652 = expected_it == expected_end ? NULL : *expected_it++;
4654 if (expected_str == NULL || strcmp (expected_str, matched_name) != 0)
4655 mismatch (expected_str, matched_name);
4658 const char *expected_str
4659 = expected_it == expected_end ? NULL : *expected_it++;
4660 if (expected_str != NULL)
4661 mismatch (expected_str, NULL);
4666 /* The symbols added to the mock mapped_index for testing (in
4668 static const char *test_symbols[] = {
4677 "ns2::tmpl<int>::foo2",
4678 "(anonymous namespace)::A::B::C",
4680 /* These are used to check that the increment-last-char in the
4681 matching algorithm for completion doesn't match "t1_fund" when
4682 completing "t1_func". */
4688 /* A UTF-8 name with multi-byte sequences to make sure that
4689 cp-name-parser understands this as a single identifier ("função"
4690 is "function" in PT). */
4693 /* \377 (0xff) is Latin1 'ÿ'. */
4696 /* \377 (0xff) is Latin1 'ÿ'. */
4700 /* A name with all sorts of complications. Starts with "z" to make
4701 it easier for the completion tests below. */
4702 #define Z_SYM_NAME \
4703 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4704 "::tuple<(anonymous namespace)::ui*, " \
4705 "std::default_delete<(anonymous namespace)::ui>, void>"
4710 /* Returns true if the mapped_index_base::find_name_component_bounds
4711 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4712 in completion mode. */
4715 check_find_bounds_finds (mapped_index_base &index,
4716 const char *search_name,
4717 gdb::array_view<const char *> expected_syms)
4719 lookup_name_info lookup_name (search_name,
4720 symbol_name_match_type::FULL, true);
4722 auto bounds = index.find_name_components_bounds (lookup_name);
4724 size_t distance = std::distance (bounds.first, bounds.second);
4725 if (distance != expected_syms.size ())
4728 for (size_t exp_elem = 0; exp_elem < distance; exp_elem++)
4730 auto nc_elem = bounds.first + exp_elem;
4731 const char *qualified = index.symbol_name_at (nc_elem->idx);
4732 if (strcmp (qualified, expected_syms[exp_elem]) != 0)
4739 /* Test the lower-level mapped_index::find_name_component_bounds
4743 test_mapped_index_find_name_component_bounds ()
4745 mock_mapped_index mock_index (test_symbols);
4747 mock_index.build_name_components ();
4749 /* Test the lower-level mapped_index::find_name_component_bounds
4750 method in completion mode. */
4752 static const char *expected_syms[] = {
4757 SELF_CHECK (check_find_bounds_finds (mock_index,
4758 "t1_func", expected_syms));
4761 /* Check that the increment-last-char in the name matching algorithm
4762 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4764 static const char *expected_syms1[] = {
4768 SELF_CHECK (check_find_bounds_finds (mock_index,
4769 "\377", expected_syms1));
4771 static const char *expected_syms2[] = {
4774 SELF_CHECK (check_find_bounds_finds (mock_index,
4775 "\377\377", expected_syms2));
4779 /* Test dw2_expand_symtabs_matching_symbol. */
4782 test_dw2_expand_symtabs_matching_symbol ()
4784 mock_mapped_index mock_index (test_symbols);
4786 /* We let all tests run until the end even if some fails, for debug
4788 bool any_mismatch = false;
4790 /* Create the expected symbols list (an initializer_list). Needed
4791 because lists have commas, and we need to pass them to CHECK,
4792 which is a macro. */
4793 #define EXPECT(...) { __VA_ARGS__ }
4795 /* Wrapper for check_match that passes down the current
4796 __FILE__/__LINE__. */
4797 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4798 any_mismatch |= !check_match (__FILE__, __LINE__, \
4800 NAME, MATCH_TYPE, COMPLETION_MODE, \
4803 /* Identity checks. */
4804 for (const char *sym : test_symbols)
4806 /* Should be able to match all existing symbols. */
4807 CHECK_MATCH (sym, symbol_name_match_type::FULL, false,
4810 /* Should be able to match all existing symbols with
4812 std::string with_params = std::string (sym) + "(int)";
4813 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4816 /* Should be able to match all existing symbols with
4817 parameters and qualifiers. */
4818 with_params = std::string (sym) + " ( int ) const";
4819 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4822 /* This should really find sym, but cp-name-parser.y doesn't
4823 know about lvalue/rvalue qualifiers yet. */
4824 with_params = std::string (sym) + " ( int ) &&";
4825 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4829 /* Check that the name matching algorithm for completion doesn't get
4830 confused with Latin1 'ÿ' / 0xff. */
4832 static const char str[] = "\377";
4833 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4834 EXPECT ("\377", "\377\377123"));
4837 /* Check that the increment-last-char in the matching algorithm for
4838 completion doesn't match "t1_fund" when completing "t1_func". */
4840 static const char str[] = "t1_func";
4841 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4842 EXPECT ("t1_func", "t1_func1"));
4845 /* Check that completion mode works at each prefix of the expected
4848 static const char str[] = "function(int)";
4849 size_t len = strlen (str);
4852 for (size_t i = 1; i < len; i++)
4854 lookup.assign (str, i);
4855 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4856 EXPECT ("function"));
4860 /* While "w" is a prefix of both components, the match function
4861 should still only be called once. */
4863 CHECK_MATCH ("w", symbol_name_match_type::FULL, true,
4865 CHECK_MATCH ("w", symbol_name_match_type::WILD, true,
4869 /* Same, with a "complicated" symbol. */
4871 static const char str[] = Z_SYM_NAME;
4872 size_t len = strlen (str);
4875 for (size_t i = 1; i < len; i++)
4877 lookup.assign (str, i);
4878 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4879 EXPECT (Z_SYM_NAME));
4883 /* In FULL mode, an incomplete symbol doesn't match. */
4885 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL, false,
4889 /* A complete symbol with parameters matches any overload, since the
4890 index has no overload info. */
4892 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL, true,
4893 EXPECT ("std::zfunction", "std::zfunction2"));
4894 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD, true,
4895 EXPECT ("std::zfunction", "std::zfunction2"));
4896 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD, true,
4897 EXPECT ("std::zfunction", "std::zfunction2"));
4900 /* Check that whitespace is ignored appropriately. A symbol with a
4901 template argument list. */
4903 static const char expected[] = "ns::foo<int>";
4904 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL, false,
4906 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD, false,
4910 /* Check that whitespace is ignored appropriately. A symbol with a
4911 template argument list that includes a pointer. */
4913 static const char expected[] = "ns::foo<char*>";
4914 /* Try both completion and non-completion modes. */
4915 static const bool completion_mode[2] = {false, true};
4916 for (size_t i = 0; i < 2; i++)
4918 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL,
4919 completion_mode[i], EXPECT (expected));
4920 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD,
4921 completion_mode[i], EXPECT (expected));
4923 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL,
4924 completion_mode[i], EXPECT (expected));
4925 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD,
4926 completion_mode[i], EXPECT (expected));
4931 /* Check method qualifiers are ignored. */
4932 static const char expected[] = "ns::foo<char*>";
4933 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4934 symbol_name_match_type::FULL, true, EXPECT (expected));
4935 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4936 symbol_name_match_type::FULL, true, EXPECT (expected));
4937 CHECK_MATCH ("foo < char * > ( int ) const",
4938 symbol_name_match_type::WILD, true, EXPECT (expected));
4939 CHECK_MATCH ("foo < char * > ( int ) &&",
4940 symbol_name_match_type::WILD, true, EXPECT (expected));
4943 /* Test lookup names that don't match anything. */
4945 CHECK_MATCH ("bar2", symbol_name_match_type::WILD, false,
4948 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL, false,
4952 /* Some wild matching tests, exercising "(anonymous namespace)",
4953 which should not be confused with a parameter list. */
4955 static const char *syms[] = {
4959 "A :: B :: C ( int )",
4964 for (const char *s : syms)
4966 CHECK_MATCH (s, symbol_name_match_type::WILD, false,
4967 EXPECT ("(anonymous namespace)::A::B::C"));
4972 static const char expected[] = "ns2::tmpl<int>::foo2";
4973 CHECK_MATCH ("tmp", symbol_name_match_type::WILD, true,
4975 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD, true,
4979 SELF_CHECK (!any_mismatch);
4988 test_mapped_index_find_name_component_bounds ();
4989 test_dw2_expand_symtabs_matching_symbol ();
4992 }} // namespace selftests::dw2_expand_symtabs_matching
4994 #endif /* GDB_SELF_TEST */
4996 /* If FILE_MATCHER is NULL or if PER_CU has
4997 dwarf2_per_cu_quick_data::MARK set (see
4998 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4999 EXPANSION_NOTIFY on it. */
5002 dw2_expand_symtabs_matching_one
5003 (struct dwarf2_per_cu_data *per_cu,
5004 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5005 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify)
5007 if (file_matcher == NULL || per_cu->v.quick->mark)
5009 bool symtab_was_null
5010 = (per_cu->v.quick->compunit_symtab == NULL);
5012 dw2_instantiate_symtab (per_cu, false);
5014 if (expansion_notify != NULL
5016 && per_cu->v.quick->compunit_symtab != NULL)
5017 expansion_notify (per_cu->v.quick->compunit_symtab);
5021 /* Helper for dw2_expand_matching symtabs. Called on each symbol
5022 matched, to expand corresponding CUs that were marked. IDX is the
5023 index of the symbol name that matched. */
5026 dw2_expand_marked_cus
5027 (struct dwarf2_per_objfile *dwarf2_per_objfile, offset_type idx,
5028 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5029 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5032 offset_type *vec, vec_len, vec_idx;
5033 bool global_seen = false;
5034 mapped_index &index = *dwarf2_per_objfile->index_table;
5036 vec = (offset_type *) (index.constant_pool
5037 + MAYBE_SWAP (index.symbol_table[idx].vec));
5038 vec_len = MAYBE_SWAP (vec[0]);
5039 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
5041 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
5042 /* This value is only valid for index versions >= 7. */
5043 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
5044 gdb_index_symbol_kind symbol_kind =
5045 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
5046 int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
5047 /* Only check the symbol attributes if they're present.
5048 Indices prior to version 7 don't record them,
5049 and indices >= 7 may elide them for certain symbols
5050 (gold does this). */
5053 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
5055 /* Work around gold/15646. */
5058 if (!is_static && global_seen)
5064 /* Only check the symbol's kind if it has one. */
5069 case VARIABLES_DOMAIN:
5070 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
5073 case FUNCTIONS_DOMAIN:
5074 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
5078 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
5086 /* Don't crash on bad data. */
5087 if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
5088 + dwarf2_per_objfile->all_type_units.size ()))
5090 complaint (_(".gdb_index entry has bad CU index"
5092 objfile_name (dwarf2_per_objfile->objfile));
5096 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
5097 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
5102 /* If FILE_MATCHER is non-NULL, set all the
5103 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5104 that match FILE_MATCHER. */
5107 dw_expand_symtabs_matching_file_matcher
5108 (struct dwarf2_per_objfile *dwarf2_per_objfile,
5109 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher)
5111 if (file_matcher == NULL)
5114 objfile *const objfile = dwarf2_per_objfile->objfile;
5116 htab_up visited_found (htab_create_alloc (10, htab_hash_pointer,
5118 NULL, xcalloc, xfree));
5119 htab_up visited_not_found (htab_create_alloc (10, htab_hash_pointer,
5121 NULL, xcalloc, xfree));
5123 /* The rule is CUs specify all the files, including those used by
5124 any TU, so there's no need to scan TUs here. */
5126 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5130 per_cu->v.quick->mark = 0;
5132 /* We only need to look at symtabs not already expanded. */
5133 if (per_cu->v.quick->compunit_symtab)
5136 quick_file_names *file_data = dw2_get_file_names (per_cu);
5137 if (file_data == NULL)
5140 if (htab_find (visited_not_found.get (), file_data) != NULL)
5142 else if (htab_find (visited_found.get (), file_data) != NULL)
5144 per_cu->v.quick->mark = 1;
5148 for (int j = 0; j < file_data->num_file_names; ++j)
5150 const char *this_real_name;
5152 if (file_matcher (file_data->file_names[j], false))
5154 per_cu->v.quick->mark = 1;
5158 /* Before we invoke realpath, which can get expensive when many
5159 files are involved, do a quick comparison of the basenames. */
5160 if (!basenames_may_differ
5161 && !file_matcher (lbasename (file_data->file_names[j]),
5165 this_real_name = dw2_get_real_path (objfile, file_data, j);
5166 if (file_matcher (this_real_name, false))
5168 per_cu->v.quick->mark = 1;
5173 void **slot = htab_find_slot (per_cu->v.quick->mark
5174 ? visited_found.get ()
5175 : visited_not_found.get (),
5182 dw2_expand_symtabs_matching
5183 (struct objfile *objfile,
5184 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5185 const lookup_name_info &lookup_name,
5186 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
5187 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5188 enum search_domain kind)
5190 struct dwarf2_per_objfile *dwarf2_per_objfile
5191 = get_dwarf2_per_objfile (objfile);
5193 /* index_table is NULL if OBJF_READNOW. */
5194 if (!dwarf2_per_objfile->index_table)
5197 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
5199 mapped_index &index = *dwarf2_per_objfile->index_table;
5201 dw2_expand_symtabs_matching_symbol (index, lookup_name,
5203 kind, [&] (offset_type idx)
5205 dw2_expand_marked_cus (dwarf2_per_objfile, idx, file_matcher,
5206 expansion_notify, kind);
5210 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5213 static struct compunit_symtab *
5214 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab *cust,
5219 if (COMPUNIT_BLOCKVECTOR (cust) != NULL
5220 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust), pc))
5223 if (cust->includes == NULL)
5226 for (i = 0; cust->includes[i]; ++i)
5228 struct compunit_symtab *s = cust->includes[i];
5230 s = recursively_find_pc_sect_compunit_symtab (s, pc);
5238 static struct compunit_symtab *
5239 dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
5240 struct bound_minimal_symbol msymbol,
5242 struct obj_section *section,
5245 struct dwarf2_per_cu_data *data;
5246 struct compunit_symtab *result;
5248 if (!objfile->partial_symtabs->psymtabs_addrmap)
5251 CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
5252 SECT_OFF_TEXT (objfile));
5253 data = (struct dwarf2_per_cu_data *) addrmap_find
5254 (objfile->partial_symtabs->psymtabs_addrmap, pc - baseaddr);
5258 if (warn_if_readin && data->v.quick->compunit_symtab)
5259 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5260 paddress (get_objfile_arch (objfile), pc));
5263 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data,
5266 gdb_assert (result != NULL);
5271 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
5272 void *data, int need_fullname)
5274 struct dwarf2_per_objfile *dwarf2_per_objfile
5275 = get_dwarf2_per_objfile (objfile);
5277 if (!dwarf2_per_objfile->filenames_cache)
5279 dwarf2_per_objfile->filenames_cache.emplace ();
5281 htab_up visited (htab_create_alloc (10,
5282 htab_hash_pointer, htab_eq_pointer,
5283 NULL, xcalloc, xfree));
5285 /* The rule is CUs specify all the files, including those used
5286 by any TU, so there's no need to scan TUs here. We can
5287 ignore file names coming from already-expanded CUs. */
5289 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5291 if (per_cu->v.quick->compunit_symtab)
5293 void **slot = htab_find_slot (visited.get (),
5294 per_cu->v.quick->file_names,
5297 *slot = per_cu->v.quick->file_names;
5301 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5303 /* We only need to look at symtabs not already expanded. */
5304 if (per_cu->v.quick->compunit_symtab)
5307 quick_file_names *file_data = dw2_get_file_names (per_cu);
5308 if (file_data == NULL)
5311 void **slot = htab_find_slot (visited.get (), file_data, INSERT);
5314 /* Already visited. */
5319 for (int j = 0; j < file_data->num_file_names; ++j)
5321 const char *filename = file_data->file_names[j];
5322 dwarf2_per_objfile->filenames_cache->seen (filename);
5327 dwarf2_per_objfile->filenames_cache->traverse ([&] (const char *filename)
5329 gdb::unique_xmalloc_ptr<char> this_real_name;
5332 this_real_name = gdb_realpath (filename);
5333 (*fun) (filename, this_real_name.get (), data);
5338 dw2_has_symbols (struct objfile *objfile)
5343 const struct quick_symbol_functions dwarf2_gdb_index_functions =
5346 dw2_find_last_source_symtab,
5347 dw2_forget_cached_source_info,
5348 dw2_map_symtabs_matching_filename,
5352 dw2_expand_symtabs_for_function,
5353 dw2_expand_all_symtabs,
5354 dw2_expand_symtabs_with_fullname,
5355 dw2_map_matching_symbols,
5356 dw2_expand_symtabs_matching,
5357 dw2_find_pc_sect_compunit_symtab,
5359 dw2_map_symbol_filenames
5362 /* DWARF-5 debug_names reader. */
5364 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5365 static const gdb_byte dwarf5_augmentation[] = { 'G', 'D', 'B', 0 };
5367 /* A helper function that reads the .debug_names section in SECTION
5368 and fills in MAP. FILENAME is the name of the file containing the
5369 section; it is used for error reporting.
5371 Returns true if all went well, false otherwise. */
5374 read_debug_names_from_section (struct objfile *objfile,
5375 const char *filename,
5376 struct dwarf2_section_info *section,
5377 mapped_debug_names &map)
5379 if (dwarf2_section_empty_p (section))
5382 /* Older elfutils strip versions could keep the section in the main
5383 executable while splitting it for the separate debug info file. */
5384 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
5387 dwarf2_read_section (objfile, section);
5389 map.dwarf5_byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
5391 const gdb_byte *addr = section->buffer;
5393 bfd *const abfd = get_section_bfd_owner (section);
5395 unsigned int bytes_read;
5396 LONGEST length = read_initial_length (abfd, addr, &bytes_read);
5399 map.dwarf5_is_dwarf64 = bytes_read != 4;
5400 map.offset_size = map.dwarf5_is_dwarf64 ? 8 : 4;
5401 if (bytes_read + length != section->size)
5403 /* There may be multiple per-CU indices. */
5404 warning (_("Section .debug_names in %s length %s does not match "
5405 "section length %s, ignoring .debug_names."),
5406 filename, plongest (bytes_read + length),
5407 pulongest (section->size));
5411 /* The version number. */
5412 uint16_t version = read_2_bytes (abfd, addr);
5416 warning (_("Section .debug_names in %s has unsupported version %d, "
5417 "ignoring .debug_names."),
5423 uint16_t padding = read_2_bytes (abfd, addr);
5427 warning (_("Section .debug_names in %s has unsupported padding %d, "
5428 "ignoring .debug_names."),
5433 /* comp_unit_count - The number of CUs in the CU list. */
5434 map.cu_count = read_4_bytes (abfd, addr);
5437 /* local_type_unit_count - The number of TUs in the local TU
5439 map.tu_count = read_4_bytes (abfd, addr);
5442 /* foreign_type_unit_count - The number of TUs in the foreign TU
5444 uint32_t foreign_tu_count = read_4_bytes (abfd, addr);
5446 if (foreign_tu_count != 0)
5448 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5449 "ignoring .debug_names."),
5450 filename, static_cast<unsigned long> (foreign_tu_count));
5454 /* bucket_count - The number of hash buckets in the hash lookup
5456 map.bucket_count = read_4_bytes (abfd, addr);
5459 /* name_count - The number of unique names in the index. */
5460 map.name_count = read_4_bytes (abfd, addr);
5463 /* abbrev_table_size - The size in bytes of the abbreviations
5465 uint32_t abbrev_table_size = read_4_bytes (abfd, addr);
5468 /* augmentation_string_size - The size in bytes of the augmentation
5469 string. This value is rounded up to a multiple of 4. */
5470 uint32_t augmentation_string_size = read_4_bytes (abfd, addr);
5472 map.augmentation_is_gdb = ((augmentation_string_size
5473 == sizeof (dwarf5_augmentation))
5474 && memcmp (addr, dwarf5_augmentation,
5475 sizeof (dwarf5_augmentation)) == 0);
5476 augmentation_string_size += (-augmentation_string_size) & 3;
5477 addr += augmentation_string_size;
5480 map.cu_table_reordered = addr;
5481 addr += map.cu_count * map.offset_size;
5483 /* List of Local TUs */
5484 map.tu_table_reordered = addr;
5485 addr += map.tu_count * map.offset_size;
5487 /* Hash Lookup Table */
5488 map.bucket_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5489 addr += map.bucket_count * 4;
5490 map.hash_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5491 addr += map.name_count * 4;
5494 map.name_table_string_offs_reordered = addr;
5495 addr += map.name_count * map.offset_size;
5496 map.name_table_entry_offs_reordered = addr;
5497 addr += map.name_count * map.offset_size;
5499 const gdb_byte *abbrev_table_start = addr;
5502 const ULONGEST index_num = read_unsigned_leb128 (abfd, addr, &bytes_read);
5507 const auto insertpair
5508 = map.abbrev_map.emplace (index_num, mapped_debug_names::index_val ());
5509 if (!insertpair.second)
5511 warning (_("Section .debug_names in %s has duplicate index %s, "
5512 "ignoring .debug_names."),
5513 filename, pulongest (index_num));
5516 mapped_debug_names::index_val &indexval = insertpair.first->second;
5517 indexval.dwarf_tag = read_unsigned_leb128 (abfd, addr, &bytes_read);
5522 mapped_debug_names::index_val::attr attr;
5523 attr.dw_idx = read_unsigned_leb128 (abfd, addr, &bytes_read);
5525 attr.form = read_unsigned_leb128 (abfd, addr, &bytes_read);
5527 if (attr.form == DW_FORM_implicit_const)
5529 attr.implicit_const = read_signed_leb128 (abfd, addr,
5533 if (attr.dw_idx == 0 && attr.form == 0)
5535 indexval.attr_vec.push_back (std::move (attr));
5538 if (addr != abbrev_table_start + abbrev_table_size)
5540 warning (_("Section .debug_names in %s has abbreviation_table "
5541 "of size %zu vs. written as %u, ignoring .debug_names."),
5542 filename, addr - abbrev_table_start, abbrev_table_size);
5545 map.entry_pool = addr;
5550 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5554 create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
5555 const mapped_debug_names &map,
5556 dwarf2_section_info §ion,
5559 sect_offset sect_off_prev;
5560 for (uint32_t i = 0; i <= map.cu_count; ++i)
5562 sect_offset sect_off_next;
5563 if (i < map.cu_count)
5566 = (sect_offset) (extract_unsigned_integer
5567 (map.cu_table_reordered + i * map.offset_size,
5569 map.dwarf5_byte_order));
5572 sect_off_next = (sect_offset) section.size;
5575 const ULONGEST length = sect_off_next - sect_off_prev;
5576 dwarf2_per_cu_data *per_cu
5577 = create_cu_from_index_list (dwarf2_per_objfile, §ion, is_dwz,
5578 sect_off_prev, length);
5579 dwarf2_per_objfile->all_comp_units.push_back (per_cu);
5581 sect_off_prev = sect_off_next;
5585 /* Read the CU list from the mapped index, and use it to create all
5586 the CU objects for this dwarf2_per_objfile. */
5589 create_cus_from_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
5590 const mapped_debug_names &map,
5591 const mapped_debug_names &dwz_map)
5593 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
5594 dwarf2_per_objfile->all_comp_units.reserve (map.cu_count + dwz_map.cu_count);
5596 create_cus_from_debug_names_list (dwarf2_per_objfile, map,
5597 dwarf2_per_objfile->info,
5598 false /* is_dwz */);
5600 if (dwz_map.cu_count == 0)
5603 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5604 create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
5608 /* Read .debug_names. If everything went ok, initialize the "quick"
5609 elements of all the CUs and return true. Otherwise, return false. */
5612 dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
5614 std::unique_ptr<mapped_debug_names> map
5615 (new mapped_debug_names (dwarf2_per_objfile));
5616 mapped_debug_names dwz_map (dwarf2_per_objfile);
5617 struct objfile *objfile = dwarf2_per_objfile->objfile;
5619 if (!read_debug_names_from_section (objfile, objfile_name (objfile),
5620 &dwarf2_per_objfile->debug_names,
5624 /* Don't use the index if it's empty. */
5625 if (map->name_count == 0)
5628 /* If there is a .dwz file, read it so we can get its CU list as
5630 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5633 if (!read_debug_names_from_section (objfile,
5634 bfd_get_filename (dwz->dwz_bfd),
5635 &dwz->debug_names, dwz_map))
5637 warning (_("could not read '.debug_names' section from %s; skipping"),
5638 bfd_get_filename (dwz->dwz_bfd));
5643 create_cus_from_debug_names (dwarf2_per_objfile, *map, dwz_map);
5645 if (map->tu_count != 0)
5647 /* We can only handle a single .debug_types when we have an
5649 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
5652 dwarf2_section_info *section = VEC_index (dwarf2_section_info_def,
5653 dwarf2_per_objfile->types, 0);
5655 create_signatured_type_table_from_debug_names
5656 (dwarf2_per_objfile, *map, section, &dwarf2_per_objfile->abbrev);
5659 create_addrmap_from_aranges (dwarf2_per_objfile,
5660 &dwarf2_per_objfile->debug_aranges);
5662 dwarf2_per_objfile->debug_names_table = std::move (map);
5663 dwarf2_per_objfile->using_index = 1;
5664 dwarf2_per_objfile->quick_file_names_table =
5665 create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
5670 /* Type used to manage iterating over all CUs looking for a symbol for
5673 class dw2_debug_names_iterator
5676 /* If WANT_SPECIFIC_BLOCK is true, only look for symbols in block
5677 BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
5678 dw2_debug_names_iterator (const mapped_debug_names &map,
5679 bool want_specific_block,
5680 block_enum block_index, domain_enum domain,
5682 : m_map (map), m_want_specific_block (want_specific_block),
5683 m_block_index (block_index), m_domain (domain),
5684 m_addr (find_vec_in_debug_names (map, name))
5687 dw2_debug_names_iterator (const mapped_debug_names &map,
5688 search_domain search, uint32_t namei)
5691 m_addr (find_vec_in_debug_names (map, namei))
5694 /* Return the next matching CU or NULL if there are no more. */
5695 dwarf2_per_cu_data *next ();
5698 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5700 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5703 /* The internalized form of .debug_names. */
5704 const mapped_debug_names &m_map;
5706 /* If true, only look for symbols that match BLOCK_INDEX. */
5707 const bool m_want_specific_block = false;
5709 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
5710 Unused if !WANT_SPECIFIC_BLOCK - FIRST_LOCAL_BLOCK is an invalid
5712 const block_enum m_block_index = FIRST_LOCAL_BLOCK;
5714 /* The kind of symbol we're looking for. */
5715 const domain_enum m_domain = UNDEF_DOMAIN;
5716 const search_domain m_search = ALL_DOMAIN;
5718 /* The list of CUs from the index entry of the symbol, or NULL if
5720 const gdb_byte *m_addr;
5724 mapped_debug_names::namei_to_name (uint32_t namei) const
5726 const ULONGEST namei_string_offs
5727 = extract_unsigned_integer ((name_table_string_offs_reordered
5728 + namei * offset_size),
5731 return read_indirect_string_at_offset
5732 (dwarf2_per_objfile, dwarf2_per_objfile->objfile->obfd, namei_string_offs);
5735 /* Find a slot in .debug_names for the object named NAME. If NAME is
5736 found, return pointer to its pool data. If NAME cannot be found,
5740 dw2_debug_names_iterator::find_vec_in_debug_names
5741 (const mapped_debug_names &map, const char *name)
5743 int (*cmp) (const char *, const char *);
5745 if (current_language->la_language == language_cplus
5746 || current_language->la_language == language_fortran
5747 || current_language->la_language == language_d)
5749 /* NAME is already canonical. Drop any qualifiers as
5750 .debug_names does not contain any. */
5752 if (strchr (name, '(') != NULL)
5754 gdb::unique_xmalloc_ptr<char> without_params
5755 = cp_remove_params (name);
5757 if (without_params != NULL)
5759 name = without_params.get();
5764 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
5766 const uint32_t full_hash = dwarf5_djb_hash (name);
5768 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5769 (map.bucket_table_reordered
5770 + (full_hash % map.bucket_count)), 4,
5771 map.dwarf5_byte_order);
5775 if (namei >= map.name_count)
5777 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5779 namei, map.name_count,
5780 objfile_name (map.dwarf2_per_objfile->objfile));
5786 const uint32_t namei_full_hash
5787 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5788 (map.hash_table_reordered + namei), 4,
5789 map.dwarf5_byte_order);
5790 if (full_hash % map.bucket_count != namei_full_hash % map.bucket_count)
5793 if (full_hash == namei_full_hash)
5795 const char *const namei_string = map.namei_to_name (namei);
5797 #if 0 /* An expensive sanity check. */
5798 if (namei_full_hash != dwarf5_djb_hash (namei_string))
5800 complaint (_("Wrong .debug_names hash for string at index %u "
5802 namei, objfile_name (dwarf2_per_objfile->objfile));
5807 if (cmp (namei_string, name) == 0)
5809 const ULONGEST namei_entry_offs
5810 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5811 + namei * map.offset_size),
5812 map.offset_size, map.dwarf5_byte_order);
5813 return map.entry_pool + namei_entry_offs;
5818 if (namei >= map.name_count)
5824 dw2_debug_names_iterator::find_vec_in_debug_names
5825 (const mapped_debug_names &map, uint32_t namei)
5827 if (namei >= map.name_count)
5829 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5831 namei, map.name_count,
5832 objfile_name (map.dwarf2_per_objfile->objfile));
5836 const ULONGEST namei_entry_offs
5837 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5838 + namei * map.offset_size),
5839 map.offset_size, map.dwarf5_byte_order);
5840 return map.entry_pool + namei_entry_offs;
5843 /* See dw2_debug_names_iterator. */
5845 dwarf2_per_cu_data *
5846 dw2_debug_names_iterator::next ()
5851 struct dwarf2_per_objfile *dwarf2_per_objfile = m_map.dwarf2_per_objfile;
5852 struct objfile *objfile = dwarf2_per_objfile->objfile;
5853 bfd *const abfd = objfile->obfd;
5857 unsigned int bytes_read;
5858 const ULONGEST abbrev = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5859 m_addr += bytes_read;
5863 const auto indexval_it = m_map.abbrev_map.find (abbrev);
5864 if (indexval_it == m_map.abbrev_map.cend ())
5866 complaint (_("Wrong .debug_names undefined abbrev code %s "
5868 pulongest (abbrev), objfile_name (objfile));
5871 const mapped_debug_names::index_val &indexval = indexval_it->second;
5872 bool have_is_static = false;
5874 dwarf2_per_cu_data *per_cu = NULL;
5875 for (const mapped_debug_names::index_val::attr &attr : indexval.attr_vec)
5880 case DW_FORM_implicit_const:
5881 ull = attr.implicit_const;
5883 case DW_FORM_flag_present:
5887 ull = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5888 m_addr += bytes_read;
5891 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5892 dwarf_form_name (attr.form),
5893 objfile_name (objfile));
5896 switch (attr.dw_idx)
5898 case DW_IDX_compile_unit:
5899 /* Don't crash on bad data. */
5900 if (ull >= dwarf2_per_objfile->all_comp_units.size ())
5902 complaint (_(".debug_names entry has bad CU index %s"
5905 objfile_name (dwarf2_per_objfile->objfile));
5908 per_cu = dwarf2_per_objfile->get_cutu (ull);
5910 case DW_IDX_type_unit:
5911 /* Don't crash on bad data. */
5912 if (ull >= dwarf2_per_objfile->all_type_units.size ())
5914 complaint (_(".debug_names entry has bad TU index %s"
5917 objfile_name (dwarf2_per_objfile->objfile));
5920 per_cu = &dwarf2_per_objfile->get_tu (ull)->per_cu;
5922 case DW_IDX_GNU_internal:
5923 if (!m_map.augmentation_is_gdb)
5925 have_is_static = true;
5928 case DW_IDX_GNU_external:
5929 if (!m_map.augmentation_is_gdb)
5931 have_is_static = true;
5937 /* Skip if already read in. */
5938 if (per_cu->v.quick->compunit_symtab)
5941 /* Check static vs global. */
5944 const bool want_static = m_block_index != GLOBAL_BLOCK;
5945 if (m_want_specific_block && want_static != is_static)
5949 /* Match dw2_symtab_iter_next, symbol_kind
5950 and debug_names::psymbol_tag. */
5954 switch (indexval.dwarf_tag)
5956 case DW_TAG_variable:
5957 case DW_TAG_subprogram:
5958 /* Some types are also in VAR_DOMAIN. */
5959 case DW_TAG_typedef:
5960 case DW_TAG_structure_type:
5967 switch (indexval.dwarf_tag)
5969 case DW_TAG_typedef:
5970 case DW_TAG_structure_type:
5977 switch (indexval.dwarf_tag)
5980 case DW_TAG_variable:
5990 /* Match dw2_expand_symtabs_matching, symbol_kind and
5991 debug_names::psymbol_tag. */
5994 case VARIABLES_DOMAIN:
5995 switch (indexval.dwarf_tag)
5997 case DW_TAG_variable:
6003 case FUNCTIONS_DOMAIN:
6004 switch (indexval.dwarf_tag)
6006 case DW_TAG_subprogram:
6013 switch (indexval.dwarf_tag)
6015 case DW_TAG_typedef:
6016 case DW_TAG_structure_type:
6029 static struct compunit_symtab *
6030 dw2_debug_names_lookup_symbol (struct objfile *objfile, int block_index_int,
6031 const char *name, domain_enum domain)
6033 const block_enum block_index = static_cast<block_enum> (block_index_int);
6034 struct dwarf2_per_objfile *dwarf2_per_objfile
6035 = get_dwarf2_per_objfile (objfile);
6037 const auto &mapp = dwarf2_per_objfile->debug_names_table;
6040 /* index is NULL if OBJF_READNOW. */
6043 const auto &map = *mapp;
6045 dw2_debug_names_iterator iter (map, true /* want_specific_block */,
6046 block_index, domain, name);
6048 struct compunit_symtab *stab_best = NULL;
6049 struct dwarf2_per_cu_data *per_cu;
6050 while ((per_cu = iter.next ()) != NULL)
6052 struct symbol *sym, *with_opaque = NULL;
6053 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
6054 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
6055 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
6057 sym = block_find_symbol (block, name, domain,
6058 block_find_non_opaque_type_preferred,
6061 /* Some caution must be observed with overloaded functions and
6062 methods, since the index will not contain any overload
6063 information (but NAME might contain it). */
6066 && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
6068 if (with_opaque != NULL
6069 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
6072 /* Keep looking through other CUs. */
6078 /* This dumps minimal information about .debug_names. It is called
6079 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
6080 uses this to verify that .debug_names has been loaded. */
6083 dw2_debug_names_dump (struct objfile *objfile)
6085 struct dwarf2_per_objfile *dwarf2_per_objfile
6086 = get_dwarf2_per_objfile (objfile);
6088 gdb_assert (dwarf2_per_objfile->using_index);
6089 printf_filtered (".debug_names:");
6090 if (dwarf2_per_objfile->debug_names_table)
6091 printf_filtered (" exists\n");
6093 printf_filtered (" faked for \"readnow\"\n");
6094 printf_filtered ("\n");
6098 dw2_debug_names_expand_symtabs_for_function (struct objfile *objfile,
6099 const char *func_name)
6101 struct dwarf2_per_objfile *dwarf2_per_objfile
6102 = get_dwarf2_per_objfile (objfile);
6104 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
6105 if (dwarf2_per_objfile->debug_names_table)
6107 const mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6109 /* Note: It doesn't matter what we pass for block_index here. */
6110 dw2_debug_names_iterator iter (map, false /* want_specific_block */,
6111 GLOBAL_BLOCK, VAR_DOMAIN, func_name);
6113 struct dwarf2_per_cu_data *per_cu;
6114 while ((per_cu = iter.next ()) != NULL)
6115 dw2_instantiate_symtab (per_cu, false);
6120 dw2_debug_names_expand_symtabs_matching
6121 (struct objfile *objfile,
6122 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
6123 const lookup_name_info &lookup_name,
6124 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
6125 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
6126 enum search_domain kind)
6128 struct dwarf2_per_objfile *dwarf2_per_objfile
6129 = get_dwarf2_per_objfile (objfile);
6131 /* debug_names_table is NULL if OBJF_READNOW. */
6132 if (!dwarf2_per_objfile->debug_names_table)
6135 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
6137 mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6139 dw2_expand_symtabs_matching_symbol (map, lookup_name,
6141 kind, [&] (offset_type namei)
6143 /* The name was matched, now expand corresponding CUs that were
6145 dw2_debug_names_iterator iter (map, kind, namei);
6147 struct dwarf2_per_cu_data *per_cu;
6148 while ((per_cu = iter.next ()) != NULL)
6149 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
6154 const struct quick_symbol_functions dwarf2_debug_names_functions =
6157 dw2_find_last_source_symtab,
6158 dw2_forget_cached_source_info,
6159 dw2_map_symtabs_matching_filename,
6160 dw2_debug_names_lookup_symbol,
6162 dw2_debug_names_dump,
6163 dw2_debug_names_expand_symtabs_for_function,
6164 dw2_expand_all_symtabs,
6165 dw2_expand_symtabs_with_fullname,
6166 dw2_map_matching_symbols,
6167 dw2_debug_names_expand_symtabs_matching,
6168 dw2_find_pc_sect_compunit_symtab,
6170 dw2_map_symbol_filenames
6173 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
6174 to either a dwarf2_per_objfile or dwz_file object. */
6176 template <typename T>
6177 static gdb::array_view<const gdb_byte>
6178 get_gdb_index_contents_from_section (objfile *obj, T *section_owner)
6180 dwarf2_section_info *section = §ion_owner->gdb_index;
6182 if (dwarf2_section_empty_p (section))
6185 /* Older elfutils strip versions could keep the section in the main
6186 executable while splitting it for the separate debug info file. */
6187 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
6190 dwarf2_read_section (obj, section);
6192 /* dwarf2_section_info::size is a bfd_size_type, while
6193 gdb::array_view works with size_t. On 32-bit hosts, with
6194 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6195 is 32-bit. So we need an explicit narrowing conversion here.
6196 This is fine, because it's impossible to allocate or mmap an
6197 array/buffer larger than what size_t can represent. */
6198 return gdb::make_array_view (section->buffer, section->size);
6201 /* Lookup the index cache for the contents of the index associated to
6204 static gdb::array_view<const gdb_byte>
6205 get_gdb_index_contents_from_cache (objfile *obj, dwarf2_per_objfile *dwarf2_obj)
6207 const bfd_build_id *build_id = build_id_bfd_get (obj->obfd);
6208 if (build_id == nullptr)
6211 return global_index_cache.lookup_gdb_index (build_id,
6212 &dwarf2_obj->index_cache_res);
6215 /* Same as the above, but for DWZ. */
6217 static gdb::array_view<const gdb_byte>
6218 get_gdb_index_contents_from_cache_dwz (objfile *obj, dwz_file *dwz)
6220 const bfd_build_id *build_id = build_id_bfd_get (dwz->dwz_bfd.get ());
6221 if (build_id == nullptr)
6224 return global_index_cache.lookup_gdb_index (build_id, &dwz->index_cache_res);
6227 /* See symfile.h. */
6230 dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
6232 struct dwarf2_per_objfile *dwarf2_per_objfile
6233 = get_dwarf2_per_objfile (objfile);
6235 /* If we're about to read full symbols, don't bother with the
6236 indices. In this case we also don't care if some other debug
6237 format is making psymtabs, because they are all about to be
6239 if ((objfile->flags & OBJF_READNOW))
6241 dwarf2_per_objfile->using_index = 1;
6242 create_all_comp_units (dwarf2_per_objfile);
6243 create_all_type_units (dwarf2_per_objfile);
6244 dwarf2_per_objfile->quick_file_names_table
6245 = create_quick_file_names_table
6246 (dwarf2_per_objfile->all_comp_units.size ());
6248 for (int i = 0; i < (dwarf2_per_objfile->all_comp_units.size ()
6249 + dwarf2_per_objfile->all_type_units.size ()); ++i)
6251 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
6253 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6254 struct dwarf2_per_cu_quick_data);
6257 /* Return 1 so that gdb sees the "quick" functions. However,
6258 these functions will be no-ops because we will have expanded
6260 *index_kind = dw_index_kind::GDB_INDEX;
6264 if (dwarf2_read_debug_names (dwarf2_per_objfile))
6266 *index_kind = dw_index_kind::DEBUG_NAMES;
6270 if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6271 get_gdb_index_contents_from_section<struct dwarf2_per_objfile>,
6272 get_gdb_index_contents_from_section<dwz_file>))
6274 *index_kind = dw_index_kind::GDB_INDEX;
6278 /* ... otherwise, try to find the index in the index cache. */
6279 if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6280 get_gdb_index_contents_from_cache,
6281 get_gdb_index_contents_from_cache_dwz))
6283 global_index_cache.hit ();
6284 *index_kind = dw_index_kind::GDB_INDEX;
6288 global_index_cache.miss ();
6294 /* Build a partial symbol table. */
6297 dwarf2_build_psymtabs (struct objfile *objfile)
6299 struct dwarf2_per_objfile *dwarf2_per_objfile
6300 = get_dwarf2_per_objfile (objfile);
6302 init_psymbol_list (objfile, 1024);
6306 /* This isn't really ideal: all the data we allocate on the
6307 objfile's obstack is still uselessly kept around. However,
6308 freeing it seems unsafe. */
6309 psymtab_discarder psymtabs (objfile);
6310 dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
6313 /* (maybe) store an index in the cache. */
6314 global_index_cache.store (dwarf2_per_objfile);
6316 CATCH (except, RETURN_MASK_ERROR)
6318 exception_print (gdb_stderr, except);
6323 /* Return the total length of the CU described by HEADER. */
6326 get_cu_length (const struct comp_unit_head *header)
6328 return header->initial_length_size + header->length;
6331 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6334 offset_in_cu_p (const comp_unit_head *cu_header, sect_offset sect_off)
6336 sect_offset bottom = cu_header->sect_off;
6337 sect_offset top = cu_header->sect_off + get_cu_length (cu_header);
6339 return sect_off >= bottom && sect_off < top;
6342 /* Find the base address of the compilation unit for range lists and
6343 location lists. It will normally be specified by DW_AT_low_pc.
6344 In DWARF-3 draft 4, the base address could be overridden by
6345 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6346 compilation units with discontinuous ranges. */
6349 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
6351 struct attribute *attr;
6354 cu->base_address = 0;
6356 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
6359 cu->base_address = attr_value_as_address (attr);
6364 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6367 cu->base_address = attr_value_as_address (attr);
6373 /* Read in the comp unit header information from the debug_info at info_ptr.
6374 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6375 NOTE: This leaves members offset, first_die_offset to be filled in
6378 static const gdb_byte *
6379 read_comp_unit_head (struct comp_unit_head *cu_header,
6380 const gdb_byte *info_ptr,
6381 struct dwarf2_section_info *section,
6382 rcuh_kind section_kind)
6385 unsigned int bytes_read;
6386 const char *filename = get_section_file_name (section);
6387 bfd *abfd = get_section_bfd_owner (section);
6389 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
6390 cu_header->initial_length_size = bytes_read;
6391 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
6392 info_ptr += bytes_read;
6393 cu_header->version = read_2_bytes (abfd, info_ptr);
6394 if (cu_header->version < 2 || cu_header->version > 5)
6395 error (_("Dwarf Error: wrong version in compilation unit header "
6396 "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6397 cu_header->version, filename);
6399 if (cu_header->version < 5)
6400 switch (section_kind)
6402 case rcuh_kind::COMPILE:
6403 cu_header->unit_type = DW_UT_compile;
6405 case rcuh_kind::TYPE:
6406 cu_header->unit_type = DW_UT_type;
6409 internal_error (__FILE__, __LINE__,
6410 _("read_comp_unit_head: invalid section_kind"));
6414 cu_header->unit_type = static_cast<enum dwarf_unit_type>
6415 (read_1_byte (abfd, info_ptr));
6417 switch (cu_header->unit_type)
6420 if (section_kind != rcuh_kind::COMPILE)
6421 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6422 "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6426 section_kind = rcuh_kind::TYPE;
6429 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6430 "(is %d, should be %d or %d) [in module %s]"),
6431 cu_header->unit_type, DW_UT_compile, DW_UT_type, filename);
6434 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6437 cu_header->abbrev_sect_off = (sect_offset) read_offset (abfd, info_ptr,
6440 info_ptr += bytes_read;
6441 if (cu_header->version < 5)
6443 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6446 signed_addr = bfd_get_sign_extend_vma (abfd);
6447 if (signed_addr < 0)
6448 internal_error (__FILE__, __LINE__,
6449 _("read_comp_unit_head: dwarf from non elf file"));
6450 cu_header->signed_addr_p = signed_addr;
6452 if (section_kind == rcuh_kind::TYPE)
6454 LONGEST type_offset;
6456 cu_header->signature = read_8_bytes (abfd, info_ptr);
6459 type_offset = read_offset (abfd, info_ptr, cu_header, &bytes_read);
6460 info_ptr += bytes_read;
6461 cu_header->type_cu_offset_in_tu = (cu_offset) type_offset;
6462 if (to_underlying (cu_header->type_cu_offset_in_tu) != type_offset)
6463 error (_("Dwarf Error: Too big type_offset in compilation unit "
6464 "header (is %s) [in module %s]"), plongest (type_offset),
6471 /* Helper function that returns the proper abbrev section for
6474 static struct dwarf2_section_info *
6475 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
6477 struct dwarf2_section_info *abbrev;
6478 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
6480 if (this_cu->is_dwz)
6481 abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
6483 abbrev = &dwarf2_per_objfile->abbrev;
6488 /* Subroutine of read_and_check_comp_unit_head and
6489 read_and_check_type_unit_head to simplify them.
6490 Perform various error checking on the header. */
6493 error_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6494 struct comp_unit_head *header,
6495 struct dwarf2_section_info *section,
6496 struct dwarf2_section_info *abbrev_section)
6498 const char *filename = get_section_file_name (section);
6500 if (to_underlying (header->abbrev_sect_off)
6501 >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
6502 error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6503 "(offset %s + 6) [in module %s]"),
6504 sect_offset_str (header->abbrev_sect_off),
6505 sect_offset_str (header->sect_off),
6508 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6509 avoid potential 32-bit overflow. */
6510 if (((ULONGEST) header->sect_off + get_cu_length (header))
6512 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6513 "(offset %s + 0) [in module %s]"),
6514 header->length, sect_offset_str (header->sect_off),
6518 /* Read in a CU/TU header and perform some basic error checking.
6519 The contents of the header are stored in HEADER.
6520 The result is a pointer to the start of the first DIE. */
6522 static const gdb_byte *
6523 read_and_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6524 struct comp_unit_head *header,
6525 struct dwarf2_section_info *section,
6526 struct dwarf2_section_info *abbrev_section,
6527 const gdb_byte *info_ptr,
6528 rcuh_kind section_kind)
6530 const gdb_byte *beg_of_comp_unit = info_ptr;
6532 header->sect_off = (sect_offset) (beg_of_comp_unit - section->buffer);
6534 info_ptr = read_comp_unit_head (header, info_ptr, section, section_kind);
6536 header->first_die_cu_offset = (cu_offset) (info_ptr - beg_of_comp_unit);
6538 error_check_comp_unit_head (dwarf2_per_objfile, header, section,
6544 /* Fetch the abbreviation table offset from a comp or type unit header. */
6547 read_abbrev_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
6548 struct dwarf2_section_info *section,
6549 sect_offset sect_off)
6551 bfd *abfd = get_section_bfd_owner (section);
6552 const gdb_byte *info_ptr;
6553 unsigned int initial_length_size, offset_size;
6556 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
6557 info_ptr = section->buffer + to_underlying (sect_off);
6558 read_initial_length (abfd, info_ptr, &initial_length_size);
6559 offset_size = initial_length_size == 4 ? 4 : 8;
6560 info_ptr += initial_length_size;
6562 version = read_2_bytes (abfd, info_ptr);
6566 /* Skip unit type and address size. */
6570 return (sect_offset) read_offset_1 (abfd, info_ptr, offset_size);
6573 /* Allocate a new partial symtab for file named NAME and mark this new
6574 partial symtab as being an include of PST. */
6577 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
6578 struct objfile *objfile)
6580 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
6582 if (!IS_ABSOLUTE_PATH (subpst->filename))
6584 /* It shares objfile->objfile_obstack. */
6585 subpst->dirname = pst->dirname;
6588 subpst->dependencies = objfile->partial_symtabs->allocate_dependencies (1);
6589 subpst->dependencies[0] = pst;
6590 subpst->number_of_dependencies = 1;
6592 subpst->read_symtab = pst->read_symtab;
6594 /* No private part is necessary for include psymtabs. This property
6595 can be used to differentiate between such include psymtabs and
6596 the regular ones. */
6597 subpst->read_symtab_private = NULL;
6600 /* Read the Line Number Program data and extract the list of files
6601 included by the source file represented by PST. Build an include
6602 partial symtab for each of these included files. */
6605 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
6606 struct die_info *die,
6607 struct partial_symtab *pst)
6610 struct attribute *attr;
6612 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
6614 lh = dwarf_decode_line_header ((sect_offset) DW_UNSND (attr), cu);
6616 return; /* No linetable, so no includes. */
6618 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6619 that we pass in the raw text_low here; that is ok because we're
6620 only decoding the line table to make include partial symtabs, and
6621 so the addresses aren't really used. */
6622 dwarf_decode_lines (lh.get (), pst->dirname, cu, pst,
6623 pst->raw_text_low (), 1);
6627 hash_signatured_type (const void *item)
6629 const struct signatured_type *sig_type
6630 = (const struct signatured_type *) item;
6632 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6633 return sig_type->signature;
6637 eq_signatured_type (const void *item_lhs, const void *item_rhs)
6639 const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
6640 const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
6642 return lhs->signature == rhs->signature;
6645 /* Allocate a hash table for signatured types. */
6648 allocate_signatured_type_table (struct objfile *objfile)
6650 return htab_create_alloc_ex (41,
6651 hash_signatured_type,
6654 &objfile->objfile_obstack,
6655 hashtab_obstack_allocate,
6656 dummy_obstack_deallocate);
6659 /* A helper function to add a signatured type CU to a table. */
6662 add_signatured_type_cu_to_table (void **slot, void *datum)
6664 struct signatured_type *sigt = (struct signatured_type *) *slot;
6665 std::vector<signatured_type *> *all_type_units
6666 = (std::vector<signatured_type *> *) datum;
6668 all_type_units->push_back (sigt);
6673 /* A helper for create_debug_types_hash_table. Read types from SECTION
6674 and fill them into TYPES_HTAB. It will process only type units,
6675 therefore DW_UT_type. */
6678 create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6679 struct dwo_file *dwo_file,
6680 dwarf2_section_info *section, htab_t &types_htab,
6681 rcuh_kind section_kind)
6683 struct objfile *objfile = dwarf2_per_objfile->objfile;
6684 struct dwarf2_section_info *abbrev_section;
6686 const gdb_byte *info_ptr, *end_ptr;
6688 abbrev_section = (dwo_file != NULL
6689 ? &dwo_file->sections.abbrev
6690 : &dwarf2_per_objfile->abbrev);
6692 if (dwarf_read_debug)
6693 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
6694 get_section_name (section),
6695 get_section_file_name (abbrev_section));
6697 dwarf2_read_section (objfile, section);
6698 info_ptr = section->buffer;
6700 if (info_ptr == NULL)
6703 /* We can't set abfd until now because the section may be empty or
6704 not present, in which case the bfd is unknown. */
6705 abfd = get_section_bfd_owner (section);
6707 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6708 because we don't need to read any dies: the signature is in the
6711 end_ptr = info_ptr + section->size;
6712 while (info_ptr < end_ptr)
6714 struct signatured_type *sig_type;
6715 struct dwo_unit *dwo_tu;
6717 const gdb_byte *ptr = info_ptr;
6718 struct comp_unit_head header;
6719 unsigned int length;
6721 sect_offset sect_off = (sect_offset) (ptr - section->buffer);
6723 /* Initialize it due to a false compiler warning. */
6724 header.signature = -1;
6725 header.type_cu_offset_in_tu = (cu_offset) -1;
6727 /* We need to read the type's signature in order to build the hash
6728 table, but we don't need anything else just yet. */
6730 ptr = read_and_check_comp_unit_head (dwarf2_per_objfile, &header, section,
6731 abbrev_section, ptr, section_kind);
6733 length = get_cu_length (&header);
6735 /* Skip dummy type units. */
6736 if (ptr >= info_ptr + length
6737 || peek_abbrev_code (abfd, ptr) == 0
6738 || header.unit_type != DW_UT_type)
6744 if (types_htab == NULL)
6747 types_htab = allocate_dwo_unit_table (objfile);
6749 types_htab = allocate_signatured_type_table (objfile);
6755 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6757 dwo_tu->dwo_file = dwo_file;
6758 dwo_tu->signature = header.signature;
6759 dwo_tu->type_offset_in_tu = header.type_cu_offset_in_tu;
6760 dwo_tu->section = section;
6761 dwo_tu->sect_off = sect_off;
6762 dwo_tu->length = length;
6766 /* N.B.: type_offset is not usable if this type uses a DWO file.
6767 The real type_offset is in the DWO file. */
6769 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6770 struct signatured_type);
6771 sig_type->signature = header.signature;
6772 sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;
6773 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6774 sig_type->per_cu.is_debug_types = 1;
6775 sig_type->per_cu.section = section;
6776 sig_type->per_cu.sect_off = sect_off;
6777 sig_type->per_cu.length = length;
6780 slot = htab_find_slot (types_htab,
6781 dwo_file ? (void*) dwo_tu : (void *) sig_type,
6783 gdb_assert (slot != NULL);
6786 sect_offset dup_sect_off;
6790 const struct dwo_unit *dup_tu
6791 = (const struct dwo_unit *) *slot;
6793 dup_sect_off = dup_tu->sect_off;
6797 const struct signatured_type *dup_tu
6798 = (const struct signatured_type *) *slot;
6800 dup_sect_off = dup_tu->per_cu.sect_off;
6803 complaint (_("debug type entry at offset %s is duplicate to"
6804 " the entry at offset %s, signature %s"),
6805 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
6806 hex_string (header.signature));
6808 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
6810 if (dwarf_read_debug > 1)
6811 fprintf_unfiltered (gdb_stdlog, " offset %s, signature %s\n",
6812 sect_offset_str (sect_off),
6813 hex_string (header.signature));
6819 /* Create the hash table of all entries in the .debug_types
6820 (or .debug_types.dwo) section(s).
6821 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6822 otherwise it is NULL.
6824 The result is a pointer to the hash table or NULL if there are no types.
6826 Note: This function processes DWO files only, not DWP files. */
6829 create_debug_types_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6830 struct dwo_file *dwo_file,
6831 VEC (dwarf2_section_info_def) *types,
6835 struct dwarf2_section_info *section;
6837 if (VEC_empty (dwarf2_section_info_def, types))
6841 VEC_iterate (dwarf2_section_info_def, types, ix, section);
6843 create_debug_type_hash_table (dwarf2_per_objfile, dwo_file, section,
6844 types_htab, rcuh_kind::TYPE);
6847 /* Create the hash table of all entries in the .debug_types section,
6848 and initialize all_type_units.
6849 The result is zero if there is an error (e.g. missing .debug_types section),
6850 otherwise non-zero. */
6853 create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
6855 htab_t types_htab = NULL;
6857 create_debug_type_hash_table (dwarf2_per_objfile, NULL,
6858 &dwarf2_per_objfile->info, types_htab,
6859 rcuh_kind::COMPILE);
6860 create_debug_types_hash_table (dwarf2_per_objfile, NULL,
6861 dwarf2_per_objfile->types, types_htab);
6862 if (types_htab == NULL)
6864 dwarf2_per_objfile->signatured_types = NULL;
6868 dwarf2_per_objfile->signatured_types = types_htab;
6870 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
6871 dwarf2_per_objfile->all_type_units.reserve (htab_elements (types_htab));
6873 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table,
6874 &dwarf2_per_objfile->all_type_units);
6879 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6880 If SLOT is non-NULL, it is the entry to use in the hash table.
6881 Otherwise we find one. */
6883 static struct signatured_type *
6884 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
6887 struct objfile *objfile = dwarf2_per_objfile->objfile;
6889 if (dwarf2_per_objfile->all_type_units.size ()
6890 == dwarf2_per_objfile->all_type_units.capacity ())
6891 ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
6893 signatured_type *sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6894 struct signatured_type);
6896 dwarf2_per_objfile->all_type_units.push_back (sig_type);
6897 sig_type->signature = sig;
6898 sig_type->per_cu.is_debug_types = 1;
6899 if (dwarf2_per_objfile->using_index)
6901 sig_type->per_cu.v.quick =
6902 OBSTACK_ZALLOC (&objfile->objfile_obstack,
6903 struct dwarf2_per_cu_quick_data);
6908 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6911 gdb_assert (*slot == NULL);
6913 /* The rest of sig_type must be filled in by the caller. */
6917 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6918 Fill in SIG_ENTRY with DWO_ENTRY. */
6921 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
6922 struct signatured_type *sig_entry,
6923 struct dwo_unit *dwo_entry)
6925 /* Make sure we're not clobbering something we don't expect to. */
6926 gdb_assert (! sig_entry->per_cu.queued);
6927 gdb_assert (sig_entry->per_cu.cu == NULL);
6928 if (dwarf2_per_objfile->using_index)
6930 gdb_assert (sig_entry->per_cu.v.quick != NULL);
6931 gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
6934 gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
6935 gdb_assert (sig_entry->signature == dwo_entry->signature);
6936 gdb_assert (to_underlying (sig_entry->type_offset_in_section) == 0);
6937 gdb_assert (sig_entry->type_unit_group == NULL);
6938 gdb_assert (sig_entry->dwo_unit == NULL);
6940 sig_entry->per_cu.section = dwo_entry->section;
6941 sig_entry->per_cu.sect_off = dwo_entry->sect_off;
6942 sig_entry->per_cu.length = dwo_entry->length;
6943 sig_entry->per_cu.reading_dwo_directly = 1;
6944 sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6945 sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
6946 sig_entry->dwo_unit = dwo_entry;
6949 /* Subroutine of lookup_signatured_type.
6950 If we haven't read the TU yet, create the signatured_type data structure
6951 for a TU to be read in directly from a DWO file, bypassing the stub.
6952 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6953 using .gdb_index, then when reading a CU we want to stay in the DWO file
6954 containing that CU. Otherwise we could end up reading several other DWO
6955 files (due to comdat folding) to process the transitive closure of all the
6956 mentioned TUs, and that can be slow. The current DWO file will have every
6957 type signature that it needs.
6958 We only do this for .gdb_index because in the psymtab case we already have
6959 to read all the DWOs to build the type unit groups. */
6961 static struct signatured_type *
6962 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
6964 struct dwarf2_per_objfile *dwarf2_per_objfile
6965 = cu->per_cu->dwarf2_per_objfile;
6966 struct objfile *objfile = dwarf2_per_objfile->objfile;
6967 struct dwo_file *dwo_file;
6968 struct dwo_unit find_dwo_entry, *dwo_entry;
6969 struct signatured_type find_sig_entry, *sig_entry;
6972 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
6974 /* If TU skeletons have been removed then we may not have read in any
6976 if (dwarf2_per_objfile->signatured_types == NULL)
6978 dwarf2_per_objfile->signatured_types
6979 = allocate_signatured_type_table (objfile);
6982 /* We only ever need to read in one copy of a signatured type.
6983 Use the global signatured_types array to do our own comdat-folding
6984 of types. If this is the first time we're reading this TU, and
6985 the TU has an entry in .gdb_index, replace the recorded data from
6986 .gdb_index with this TU. */
6988 find_sig_entry.signature = sig;
6989 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6990 &find_sig_entry, INSERT);
6991 sig_entry = (struct signatured_type *) *slot;
6993 /* We can get here with the TU already read, *or* in the process of being
6994 read. Don't reassign the global entry to point to this DWO if that's
6995 the case. Also note that if the TU is already being read, it may not
6996 have come from a DWO, the program may be a mix of Fission-compiled
6997 code and non-Fission-compiled code. */
6999 /* Have we already tried to read this TU?
7000 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7001 needn't exist in the global table yet). */
7002 if (sig_entry != NULL && sig_entry->per_cu.tu_read)
7005 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
7006 dwo_unit of the TU itself. */
7007 dwo_file = cu->dwo_unit->dwo_file;
7009 /* Ok, this is the first time we're reading this TU. */
7010 if (dwo_file->tus == NULL)
7012 find_dwo_entry.signature = sig;
7013 dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
7014 if (dwo_entry == NULL)
7017 /* If the global table doesn't have an entry for this TU, add one. */
7018 if (sig_entry == NULL)
7019 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7021 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7022 sig_entry->per_cu.tu_read = 1;
7026 /* Subroutine of lookup_signatured_type.
7027 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7028 then try the DWP file. If the TU stub (skeleton) has been removed then
7029 it won't be in .gdb_index. */
7031 static struct signatured_type *
7032 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7034 struct dwarf2_per_objfile *dwarf2_per_objfile
7035 = cu->per_cu->dwarf2_per_objfile;
7036 struct objfile *objfile = dwarf2_per_objfile->objfile;
7037 struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
7038 struct dwo_unit *dwo_entry;
7039 struct signatured_type find_sig_entry, *sig_entry;
7042 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7043 gdb_assert (dwp_file != NULL);
7045 /* If TU skeletons have been removed then we may not have read in any
7047 if (dwarf2_per_objfile->signatured_types == NULL)
7049 dwarf2_per_objfile->signatured_types
7050 = allocate_signatured_type_table (objfile);
7053 find_sig_entry.signature = sig;
7054 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7055 &find_sig_entry, INSERT);
7056 sig_entry = (struct signatured_type *) *slot;
7058 /* Have we already tried to read this TU?
7059 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7060 needn't exist in the global table yet). */
7061 if (sig_entry != NULL)
7064 if (dwp_file->tus == NULL)
7066 dwo_entry = lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, NULL,
7067 sig, 1 /* is_debug_types */);
7068 if (dwo_entry == NULL)
7071 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7072 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7077 /* Lookup a signature based type for DW_FORM_ref_sig8.
7078 Returns NULL if signature SIG is not present in the table.
7079 It is up to the caller to complain about this. */
7081 static struct signatured_type *
7082 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7084 struct dwarf2_per_objfile *dwarf2_per_objfile
7085 = cu->per_cu->dwarf2_per_objfile;
7088 && dwarf2_per_objfile->using_index)
7090 /* We're in a DWO/DWP file, and we're using .gdb_index.
7091 These cases require special processing. */
7092 if (get_dwp_file (dwarf2_per_objfile) == NULL)
7093 return lookup_dwo_signatured_type (cu, sig);
7095 return lookup_dwp_signatured_type (cu, sig);
7099 struct signatured_type find_entry, *entry;
7101 if (dwarf2_per_objfile->signatured_types == NULL)
7103 find_entry.signature = sig;
7104 entry = ((struct signatured_type *)
7105 htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
7110 /* Low level DIE reading support. */
7112 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7115 init_cu_die_reader (struct die_reader_specs *reader,
7116 struct dwarf2_cu *cu,
7117 struct dwarf2_section_info *section,
7118 struct dwo_file *dwo_file,
7119 struct abbrev_table *abbrev_table)
7121 gdb_assert (section->readin && section->buffer != NULL);
7122 reader->abfd = get_section_bfd_owner (section);
7124 reader->dwo_file = dwo_file;
7125 reader->die_section = section;
7126 reader->buffer = section->buffer;
7127 reader->buffer_end = section->buffer + section->size;
7128 reader->comp_dir = NULL;
7129 reader->abbrev_table = abbrev_table;
7132 /* Subroutine of init_cutu_and_read_dies to simplify it.
7133 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7134 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7137 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7138 from it to the DIE in the DWO. If NULL we are skipping the stub.
7139 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7140 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7141 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7142 STUB_COMP_DIR may be non-NULL.
7143 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7144 are filled in with the info of the DIE from the DWO file.
7145 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7146 from the dwo. Since *RESULT_READER references this abbrev table, it must be
7147 kept around for at least as long as *RESULT_READER.
7149 The result is non-zero if a valid (non-dummy) DIE was found. */
7152 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
7153 struct dwo_unit *dwo_unit,
7154 struct die_info *stub_comp_unit_die,
7155 const char *stub_comp_dir,
7156 struct die_reader_specs *result_reader,
7157 const gdb_byte **result_info_ptr,
7158 struct die_info **result_comp_unit_die,
7159 int *result_has_children,
7160 abbrev_table_up *result_dwo_abbrev_table)
7162 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7163 struct objfile *objfile = dwarf2_per_objfile->objfile;
7164 struct dwarf2_cu *cu = this_cu->cu;
7166 const gdb_byte *begin_info_ptr, *info_ptr;
7167 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
7168 int i,num_extra_attrs;
7169 struct dwarf2_section_info *dwo_abbrev_section;
7170 struct attribute *attr;
7171 struct die_info *comp_unit_die;
7173 /* At most one of these may be provided. */
7174 gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
7176 /* These attributes aren't processed until later:
7177 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7178 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7179 referenced later. However, these attributes are found in the stub
7180 which we won't have later. In order to not impose this complication
7181 on the rest of the code, we read them here and copy them to the
7190 if (stub_comp_unit_die != NULL)
7192 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7194 if (! this_cu->is_debug_types)
7195 stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
7196 low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
7197 high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
7198 ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
7199 comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
7201 /* There should be a DW_AT_addr_base attribute here (if needed).
7202 We need the value before we can process DW_FORM_GNU_addr_index. */
7204 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
7206 cu->addr_base = DW_UNSND (attr);
7208 /* There should be a DW_AT_ranges_base attribute here (if needed).
7209 We need the value before we can process DW_AT_ranges. */
7210 cu->ranges_base = 0;
7211 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
7213 cu->ranges_base = DW_UNSND (attr);
7215 else if (stub_comp_dir != NULL)
7217 /* Reconstruct the comp_dir attribute to simplify the code below. */
7218 comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
7219 comp_dir->name = DW_AT_comp_dir;
7220 comp_dir->form = DW_FORM_string;
7221 DW_STRING_IS_CANONICAL (comp_dir) = 0;
7222 DW_STRING (comp_dir) = stub_comp_dir;
7225 /* Set up for reading the DWO CU/TU. */
7226 cu->dwo_unit = dwo_unit;
7227 dwarf2_section_info *section = dwo_unit->section;
7228 dwarf2_read_section (objfile, section);
7229 abfd = get_section_bfd_owner (section);
7230 begin_info_ptr = info_ptr = (section->buffer
7231 + to_underlying (dwo_unit->sect_off));
7232 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
7234 if (this_cu->is_debug_types)
7236 struct signatured_type *sig_type = (struct signatured_type *) this_cu;
7238 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7239 &cu->header, section,
7241 info_ptr, rcuh_kind::TYPE);
7242 /* This is not an assert because it can be caused by bad debug info. */
7243 if (sig_type->signature != cu->header.signature)
7245 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7246 " TU at offset %s [in module %s]"),
7247 hex_string (sig_type->signature),
7248 hex_string (cu->header.signature),
7249 sect_offset_str (dwo_unit->sect_off),
7250 bfd_get_filename (abfd));
7252 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7253 /* For DWOs coming from DWP files, we don't know the CU length
7254 nor the type's offset in the TU until now. */
7255 dwo_unit->length = get_cu_length (&cu->header);
7256 dwo_unit->type_offset_in_tu = cu->header.type_cu_offset_in_tu;
7258 /* Establish the type offset that can be used to lookup the type.
7259 For DWO files, we don't know it until now. */
7260 sig_type->type_offset_in_section
7261 = dwo_unit->sect_off + to_underlying (dwo_unit->type_offset_in_tu);
7265 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7266 &cu->header, section,
7268 info_ptr, rcuh_kind::COMPILE);
7269 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7270 /* For DWOs coming from DWP files, we don't know the CU length
7272 dwo_unit->length = get_cu_length (&cu->header);
7275 *result_dwo_abbrev_table
7276 = abbrev_table_read_table (dwarf2_per_objfile, dwo_abbrev_section,
7277 cu->header.abbrev_sect_off);
7278 init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file,
7279 result_dwo_abbrev_table->get ());
7281 /* Read in the die, but leave space to copy over the attributes
7282 from the stub. This has the benefit of simplifying the rest of
7283 the code - all the work to maintain the illusion of a single
7284 DW_TAG_{compile,type}_unit DIE is done here. */
7285 num_extra_attrs = ((stmt_list != NULL)
7289 + (comp_dir != NULL));
7290 info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
7291 result_has_children, num_extra_attrs);
7293 /* Copy over the attributes from the stub to the DIE we just read in. */
7294 comp_unit_die = *result_comp_unit_die;
7295 i = comp_unit_die->num_attrs;
7296 if (stmt_list != NULL)
7297 comp_unit_die->attrs[i++] = *stmt_list;
7299 comp_unit_die->attrs[i++] = *low_pc;
7300 if (high_pc != NULL)
7301 comp_unit_die->attrs[i++] = *high_pc;
7303 comp_unit_die->attrs[i++] = *ranges;
7304 if (comp_dir != NULL)
7305 comp_unit_die->attrs[i++] = *comp_dir;
7306 comp_unit_die->num_attrs += num_extra_attrs;
7308 if (dwarf_die_debug)
7310 fprintf_unfiltered (gdb_stdlog,
7311 "Read die from %s@0x%x of %s:\n",
7312 get_section_name (section),
7313 (unsigned) (begin_info_ptr - section->buffer),
7314 bfd_get_filename (abfd));
7315 dump_die (comp_unit_die, dwarf_die_debug);
7318 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7319 TUs by skipping the stub and going directly to the entry in the DWO file.
7320 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7321 to get it via circuitous means. Blech. */
7322 if (comp_dir != NULL)
7323 result_reader->comp_dir = DW_STRING (comp_dir);
7325 /* Skip dummy compilation units. */
7326 if (info_ptr >= begin_info_ptr + dwo_unit->length
7327 || peek_abbrev_code (abfd, info_ptr) == 0)
7330 *result_info_ptr = info_ptr;
7334 /* Subroutine of init_cutu_and_read_dies to simplify it.
7335 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7336 Returns NULL if the specified DWO unit cannot be found. */
7338 static struct dwo_unit *
7339 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
7340 struct die_info *comp_unit_die)
7342 struct dwarf2_cu *cu = this_cu->cu;
7344 struct dwo_unit *dwo_unit;
7345 const char *comp_dir, *dwo_name;
7347 gdb_assert (cu != NULL);
7349 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7350 dwo_name = dwarf2_string_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7351 comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7353 if (this_cu->is_debug_types)
7355 struct signatured_type *sig_type;
7357 /* Since this_cu is the first member of struct signatured_type,
7358 we can go from a pointer to one to a pointer to the other. */
7359 sig_type = (struct signatured_type *) this_cu;
7360 signature = sig_type->signature;
7361 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
7365 struct attribute *attr;
7367 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
7369 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7371 dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
7372 signature = DW_UNSND (attr);
7373 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
7380 /* Subroutine of init_cutu_and_read_dies to simplify it.
7381 See it for a description of the parameters.
7382 Read a TU directly from a DWO file, bypassing the stub. */
7385 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
7386 int use_existing_cu, int keep,
7387 die_reader_func_ftype *die_reader_func,
7390 std::unique_ptr<dwarf2_cu> new_cu;
7391 struct signatured_type *sig_type;
7392 struct die_reader_specs reader;
7393 const gdb_byte *info_ptr;
7394 struct die_info *comp_unit_die;
7396 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7398 /* Verify we can do the following downcast, and that we have the
7400 gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
7401 sig_type = (struct signatured_type *) this_cu;
7402 gdb_assert (sig_type->dwo_unit != NULL);
7404 if (use_existing_cu && this_cu->cu != NULL)
7406 gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
7407 /* There's no need to do the rereading_dwo_cu handling that
7408 init_cutu_and_read_dies does since we don't read the stub. */
7412 /* If !use_existing_cu, this_cu->cu must be NULL. */
7413 gdb_assert (this_cu->cu == NULL);
7414 new_cu.reset (new dwarf2_cu (this_cu));
7417 /* A future optimization, if needed, would be to use an existing
7418 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7419 could share abbrev tables. */
7421 /* The abbreviation table used by READER, this must live at least as long as
7423 abbrev_table_up dwo_abbrev_table;
7425 if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
7426 NULL /* stub_comp_unit_die */,
7427 sig_type->dwo_unit->dwo_file->comp_dir,
7429 &comp_unit_die, &has_children,
7430 &dwo_abbrev_table) == 0)
7436 /* All the "real" work is done here. */
7437 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7439 /* This duplicates the code in init_cutu_and_read_dies,
7440 but the alternative is making the latter more complex.
7441 This function is only for the special case of using DWO files directly:
7442 no point in overly complicating the general case just to handle this. */
7443 if (new_cu != NULL && keep)
7445 /* Link this CU into read_in_chain. */
7446 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7447 dwarf2_per_objfile->read_in_chain = this_cu;
7448 /* The chain owns it now. */
7453 /* Initialize a CU (or TU) and read its DIEs.
7454 If the CU defers to a DWO file, read the DWO file as well.
7456 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7457 Otherwise the table specified in the comp unit header is read in and used.
7458 This is an optimization for when we already have the abbrev table.
7460 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7461 Otherwise, a new CU is allocated with xmalloc.
7463 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7464 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7466 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7467 linker) then DIE_READER_FUNC will not get called. */
7470 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
7471 struct abbrev_table *abbrev_table,
7472 int use_existing_cu, int keep,
7474 die_reader_func_ftype *die_reader_func,
7477 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7478 struct objfile *objfile = dwarf2_per_objfile->objfile;
7479 struct dwarf2_section_info *section = this_cu->section;
7480 bfd *abfd = get_section_bfd_owner (section);
7481 struct dwarf2_cu *cu;
7482 const gdb_byte *begin_info_ptr, *info_ptr;
7483 struct die_reader_specs reader;
7484 struct die_info *comp_unit_die;
7486 struct attribute *attr;
7487 struct signatured_type *sig_type = NULL;
7488 struct dwarf2_section_info *abbrev_section;
7489 /* Non-zero if CU currently points to a DWO file and we need to
7490 reread it. When this happens we need to reread the skeleton die
7491 before we can reread the DWO file (this only applies to CUs, not TUs). */
7492 int rereading_dwo_cu = 0;
7494 if (dwarf_die_debug)
7495 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7496 this_cu->is_debug_types ? "type" : "comp",
7497 sect_offset_str (this_cu->sect_off));
7499 if (use_existing_cu)
7502 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7503 file (instead of going through the stub), short-circuit all of this. */
7504 if (this_cu->reading_dwo_directly)
7506 /* Narrow down the scope of possibilities to have to understand. */
7507 gdb_assert (this_cu->is_debug_types);
7508 gdb_assert (abbrev_table == NULL);
7509 init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
7510 die_reader_func, data);
7514 /* This is cheap if the section is already read in. */
7515 dwarf2_read_section (objfile, section);
7517 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7519 abbrev_section = get_abbrev_section_for_cu (this_cu);
7521 std::unique_ptr<dwarf2_cu> new_cu;
7522 if (use_existing_cu && this_cu->cu != NULL)
7525 /* If this CU is from a DWO file we need to start over, we need to
7526 refetch the attributes from the skeleton CU.
7527 This could be optimized by retrieving those attributes from when we
7528 were here the first time: the previous comp_unit_die was stored in
7529 comp_unit_obstack. But there's no data yet that we need this
7531 if (cu->dwo_unit != NULL)
7532 rereading_dwo_cu = 1;
7536 /* If !use_existing_cu, this_cu->cu must be NULL. */
7537 gdb_assert (this_cu->cu == NULL);
7538 new_cu.reset (new dwarf2_cu (this_cu));
7542 /* Get the header. */
7543 if (to_underlying (cu->header.first_die_cu_offset) != 0 && !rereading_dwo_cu)
7545 /* We already have the header, there's no need to read it in again. */
7546 info_ptr += to_underlying (cu->header.first_die_cu_offset);
7550 if (this_cu->is_debug_types)
7552 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7553 &cu->header, section,
7554 abbrev_section, info_ptr,
7557 /* Since per_cu is the first member of struct signatured_type,
7558 we can go from a pointer to one to a pointer to the other. */
7559 sig_type = (struct signatured_type *) this_cu;
7560 gdb_assert (sig_type->signature == cu->header.signature);
7561 gdb_assert (sig_type->type_offset_in_tu
7562 == cu->header.type_cu_offset_in_tu);
7563 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7565 /* LENGTH has not been set yet for type units if we're
7566 using .gdb_index. */
7567 this_cu->length = get_cu_length (&cu->header);
7569 /* Establish the type offset that can be used to lookup the type. */
7570 sig_type->type_offset_in_section =
7571 this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu);
7573 this_cu->dwarf_version = cu->header.version;
7577 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7578 &cu->header, section,
7581 rcuh_kind::COMPILE);
7583 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7584 gdb_assert (this_cu->length == get_cu_length (&cu->header));
7585 this_cu->dwarf_version = cu->header.version;
7589 /* Skip dummy compilation units. */
7590 if (info_ptr >= begin_info_ptr + this_cu->length
7591 || peek_abbrev_code (abfd, info_ptr) == 0)
7594 /* If we don't have them yet, read the abbrevs for this compilation unit.
7595 And if we need to read them now, make sure they're freed when we're
7596 done (own the table through ABBREV_TABLE_HOLDER). */
7597 abbrev_table_up abbrev_table_holder;
7598 if (abbrev_table != NULL)
7599 gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off);
7603 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7604 cu->header.abbrev_sect_off);
7605 abbrev_table = abbrev_table_holder.get ();
7608 /* Read the top level CU/TU die. */
7609 init_cu_die_reader (&reader, cu, section, NULL, abbrev_table);
7610 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7612 if (skip_partial && comp_unit_die->tag == DW_TAG_partial_unit)
7615 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7616 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7617 table from the DWO file and pass the ownership over to us. It will be
7618 referenced from READER, so we must make sure to free it after we're done
7621 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7622 DWO CU, that this test will fail (the attribute will not be present). */
7623 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7624 abbrev_table_up dwo_abbrev_table;
7627 struct dwo_unit *dwo_unit;
7628 struct die_info *dwo_comp_unit_die;
7632 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7633 " has children (offset %s) [in module %s]"),
7634 sect_offset_str (this_cu->sect_off),
7635 bfd_get_filename (abfd));
7637 dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
7638 if (dwo_unit != NULL)
7640 if (read_cutu_die_from_dwo (this_cu, dwo_unit,
7641 comp_unit_die, NULL,
7643 &dwo_comp_unit_die, &has_children,
7644 &dwo_abbrev_table) == 0)
7649 comp_unit_die = dwo_comp_unit_die;
7653 /* Yikes, we couldn't find the rest of the DIE, we only have
7654 the stub. A complaint has already been logged. There's
7655 not much more we can do except pass on the stub DIE to
7656 die_reader_func. We don't want to throw an error on bad
7661 /* All of the above is setup for this call. Yikes. */
7662 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7664 /* Done, clean up. */
7665 if (new_cu != NULL && keep)
7667 /* Link this CU into read_in_chain. */
7668 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7669 dwarf2_per_objfile->read_in_chain = this_cu;
7670 /* The chain owns it now. */
7675 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7676 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7677 to have already done the lookup to find the DWO file).
7679 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7680 THIS_CU->is_debug_types, but nothing else.
7682 We fill in THIS_CU->length.
7684 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7685 linker) then DIE_READER_FUNC will not get called.
7687 THIS_CU->cu is always freed when done.
7688 This is done in order to not leave THIS_CU->cu in a state where we have
7689 to care whether it refers to the "main" CU or the DWO CU. */
7692 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
7693 struct dwo_file *dwo_file,
7694 die_reader_func_ftype *die_reader_func,
7697 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7698 struct objfile *objfile = dwarf2_per_objfile->objfile;
7699 struct dwarf2_section_info *section = this_cu->section;
7700 bfd *abfd = get_section_bfd_owner (section);
7701 struct dwarf2_section_info *abbrev_section;
7702 const gdb_byte *begin_info_ptr, *info_ptr;
7703 struct die_reader_specs reader;
7704 struct die_info *comp_unit_die;
7707 if (dwarf_die_debug)
7708 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7709 this_cu->is_debug_types ? "type" : "comp",
7710 sect_offset_str (this_cu->sect_off));
7712 gdb_assert (this_cu->cu == NULL);
7714 abbrev_section = (dwo_file != NULL
7715 ? &dwo_file->sections.abbrev
7716 : get_abbrev_section_for_cu (this_cu));
7718 /* This is cheap if the section is already read in. */
7719 dwarf2_read_section (objfile, section);
7721 struct dwarf2_cu cu (this_cu);
7723 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7724 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7725 &cu.header, section,
7726 abbrev_section, info_ptr,
7727 (this_cu->is_debug_types
7729 : rcuh_kind::COMPILE));
7731 this_cu->length = get_cu_length (&cu.header);
7733 /* Skip dummy compilation units. */
7734 if (info_ptr >= begin_info_ptr + this_cu->length
7735 || peek_abbrev_code (abfd, info_ptr) == 0)
7738 abbrev_table_up abbrev_table
7739 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7740 cu.header.abbrev_sect_off);
7742 init_cu_die_reader (&reader, &cu, section, dwo_file, abbrev_table.get ());
7743 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7745 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7748 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7749 does not lookup the specified DWO file.
7750 This cannot be used to read DWO files.
7752 THIS_CU->cu is always freed when done.
7753 This is done in order to not leave THIS_CU->cu in a state where we have
7754 to care whether it refers to the "main" CU or the DWO CU.
7755 We can revisit this if the data shows there's a performance issue. */
7758 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
7759 die_reader_func_ftype *die_reader_func,
7762 init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
7765 /* Type Unit Groups.
7767 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7768 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7769 so that all types coming from the same compilation (.o file) are grouped
7770 together. A future step could be to put the types in the same symtab as
7771 the CU the types ultimately came from. */
7774 hash_type_unit_group (const void *item)
7776 const struct type_unit_group *tu_group
7777 = (const struct type_unit_group *) item;
7779 return hash_stmt_list_entry (&tu_group->hash);
7783 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
7785 const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
7786 const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
7788 return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
7791 /* Allocate a hash table for type unit groups. */
7794 allocate_type_unit_groups_table (struct objfile *objfile)
7796 return htab_create_alloc_ex (3,
7797 hash_type_unit_group,
7800 &objfile->objfile_obstack,
7801 hashtab_obstack_allocate,
7802 dummy_obstack_deallocate);
7805 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7806 partial symtabs. We combine several TUs per psymtab to not let the size
7807 of any one psymtab grow too big. */
7808 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7809 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7811 /* Helper routine for get_type_unit_group.
7812 Create the type_unit_group object used to hold one or more TUs. */
7814 static struct type_unit_group *
7815 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
7817 struct dwarf2_per_objfile *dwarf2_per_objfile
7818 = cu->per_cu->dwarf2_per_objfile;
7819 struct objfile *objfile = dwarf2_per_objfile->objfile;
7820 struct dwarf2_per_cu_data *per_cu;
7821 struct type_unit_group *tu_group;
7823 tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7824 struct type_unit_group);
7825 per_cu = &tu_group->per_cu;
7826 per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
7828 if (dwarf2_per_objfile->using_index)
7830 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7831 struct dwarf2_per_cu_quick_data);
7835 unsigned int line_offset = to_underlying (line_offset_struct);
7836 struct partial_symtab *pst;
7839 /* Give the symtab a useful name for debug purposes. */
7840 if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
7841 name = string_printf ("<type_units_%d>",
7842 (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
7844 name = string_printf ("<type_units_at_0x%x>", line_offset);
7846 pst = create_partial_symtab (per_cu, name.c_str ());
7850 tu_group->hash.dwo_unit = cu->dwo_unit;
7851 tu_group->hash.line_sect_off = line_offset_struct;
7856 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7857 STMT_LIST is a DW_AT_stmt_list attribute. */
7859 static struct type_unit_group *
7860 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
7862 struct dwarf2_per_objfile *dwarf2_per_objfile
7863 = cu->per_cu->dwarf2_per_objfile;
7864 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
7865 struct type_unit_group *tu_group;
7867 unsigned int line_offset;
7868 struct type_unit_group type_unit_group_for_lookup;
7870 if (dwarf2_per_objfile->type_unit_groups == NULL)
7872 dwarf2_per_objfile->type_unit_groups =
7873 allocate_type_unit_groups_table (dwarf2_per_objfile->objfile);
7876 /* Do we need to create a new group, or can we use an existing one? */
7880 line_offset = DW_UNSND (stmt_list);
7881 ++tu_stats->nr_symtab_sharers;
7885 /* Ugh, no stmt_list. Rare, but we have to handle it.
7886 We can do various things here like create one group per TU or
7887 spread them over multiple groups to split up the expansion work.
7888 To avoid worst case scenarios (too many groups or too large groups)
7889 we, umm, group them in bunches. */
7890 line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7891 | (tu_stats->nr_stmt_less_type_units
7892 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
7893 ++tu_stats->nr_stmt_less_type_units;
7896 type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
7897 type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;
7898 slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
7899 &type_unit_group_for_lookup, INSERT);
7902 tu_group = (struct type_unit_group *) *slot;
7903 gdb_assert (tu_group != NULL);
7907 sect_offset line_offset_struct = (sect_offset) line_offset;
7908 tu_group = create_type_unit_group (cu, line_offset_struct);
7910 ++tu_stats->nr_symtabs;
7916 /* Partial symbol tables. */
7918 /* Create a psymtab named NAME and assign it to PER_CU.
7920 The caller must fill in the following details:
7921 dirname, textlow, texthigh. */
7923 static struct partial_symtab *
7924 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
7926 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
7927 struct partial_symtab *pst;
7929 pst = start_psymtab_common (objfile, name, 0);
7931 pst->psymtabs_addrmap_supported = 1;
7933 /* This is the glue that links PST into GDB's symbol API. */
7934 pst->read_symtab_private = per_cu;
7935 pst->read_symtab = dwarf2_read_symtab;
7936 per_cu->v.psymtab = pst;
7941 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7944 struct process_psymtab_comp_unit_data
7946 /* True if we are reading a DW_TAG_partial_unit. */
7948 int want_partial_unit;
7950 /* The "pretend" language that is used if the CU doesn't declare a
7953 enum language pretend_language;
7956 /* die_reader_func for process_psymtab_comp_unit. */
7959 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
7960 const gdb_byte *info_ptr,
7961 struct die_info *comp_unit_die,
7965 struct dwarf2_cu *cu = reader->cu;
7966 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
7967 struct gdbarch *gdbarch = get_objfile_arch (objfile);
7968 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
7970 CORE_ADDR best_lowpc = 0, best_highpc = 0;
7971 struct partial_symtab *pst;
7972 enum pc_bounds_kind cu_bounds_kind;
7973 const char *filename;
7974 struct process_psymtab_comp_unit_data *info
7975 = (struct process_psymtab_comp_unit_data *) data;
7977 if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
7980 gdb_assert (! per_cu->is_debug_types);
7982 prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
7984 /* Allocate a new partial symbol table structure. */
7985 filename = dwarf2_string_attr (comp_unit_die, DW_AT_name, cu);
7986 if (filename == NULL)
7989 pst = create_partial_symtab (per_cu, filename);
7991 /* This must be done before calling dwarf2_build_include_psymtabs. */
7992 pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7994 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7996 dwarf2_find_base_address (comp_unit_die, cu);
7998 /* Possibly set the default values of LOWPC and HIGHPC from
8000 cu_bounds_kind = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
8001 &best_highpc, cu, pst);
8002 if (cu_bounds_kind == PC_BOUNDS_HIGH_LOW && best_lowpc < best_highpc)
8005 = (gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr)
8008 = (gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr)
8010 /* Store the contiguous range if it is not empty; it can be
8011 empty for CUs with no code. */
8012 addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
8016 /* Check if comp unit has_children.
8017 If so, read the rest of the partial symbols from this comp unit.
8018 If not, there's no more debug_info for this comp unit. */
8021 struct partial_die_info *first_die;
8022 CORE_ADDR lowpc, highpc;
8024 lowpc = ((CORE_ADDR) -1);
8025 highpc = ((CORE_ADDR) 0);
8027 first_die = load_partial_dies (reader, info_ptr, 1);
8029 scan_partial_symbols (first_die, &lowpc, &highpc,
8030 cu_bounds_kind <= PC_BOUNDS_INVALID, cu);
8032 /* If we didn't find a lowpc, set it to highpc to avoid
8033 complaints from `maint check'. */
8034 if (lowpc == ((CORE_ADDR) -1))
8037 /* If the compilation unit didn't have an explicit address range,
8038 then use the information extracted from its child dies. */
8039 if (cu_bounds_kind <= PC_BOUNDS_INVALID)
8042 best_highpc = highpc;
8045 pst->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch,
8046 best_lowpc + baseaddr)
8048 pst->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch,
8049 best_highpc + baseaddr)
8052 end_psymtab_common (objfile, pst);
8054 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
8057 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8058 struct dwarf2_per_cu_data *iter;
8060 /* Fill in 'dependencies' here; we fill in 'users' in a
8062 pst->number_of_dependencies = len;
8064 = objfile->partial_symtabs->allocate_dependencies (len);
8066 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8069 pst->dependencies[i] = iter->v.psymtab;
8071 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8074 /* Get the list of files included in the current compilation unit,
8075 and build a psymtab for each of them. */
8076 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
8078 if (dwarf_read_debug)
8079 fprintf_unfiltered (gdb_stdlog,
8080 "Psymtab for %s unit @%s: %s - %s"
8081 ", %d global, %d static syms\n",
8082 per_cu->is_debug_types ? "type" : "comp",
8083 sect_offset_str (per_cu->sect_off),
8084 paddress (gdbarch, pst->text_low (objfile)),
8085 paddress (gdbarch, pst->text_high (objfile)),
8086 pst->n_global_syms, pst->n_static_syms);
8089 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8090 Process compilation unit THIS_CU for a psymtab. */
8093 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
8094 int want_partial_unit,
8095 enum language pretend_language)
8097 /* If this compilation unit was already read in, free the
8098 cached copy in order to read it in again. This is
8099 necessary because we skipped some symbols when we first
8100 read in the compilation unit (see load_partial_dies).
8101 This problem could be avoided, but the benefit is unclear. */
8102 if (this_cu->cu != NULL)
8103 free_one_cached_comp_unit (this_cu);
8105 if (this_cu->is_debug_types)
8106 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8107 build_type_psymtabs_reader, NULL);
8110 process_psymtab_comp_unit_data info;
8111 info.want_partial_unit = want_partial_unit;
8112 info.pretend_language = pretend_language;
8113 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8114 process_psymtab_comp_unit_reader, &info);
8117 /* Age out any secondary CUs. */
8118 age_cached_comp_units (this_cu->dwarf2_per_objfile);
8121 /* Reader function for build_type_psymtabs. */
8124 build_type_psymtabs_reader (const struct die_reader_specs *reader,
8125 const gdb_byte *info_ptr,
8126 struct die_info *type_unit_die,
8130 struct dwarf2_per_objfile *dwarf2_per_objfile
8131 = reader->cu->per_cu->dwarf2_per_objfile;
8132 struct objfile *objfile = dwarf2_per_objfile->objfile;
8133 struct dwarf2_cu *cu = reader->cu;
8134 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8135 struct signatured_type *sig_type;
8136 struct type_unit_group *tu_group;
8137 struct attribute *attr;
8138 struct partial_die_info *first_die;
8139 CORE_ADDR lowpc, highpc;
8140 struct partial_symtab *pst;
8142 gdb_assert (data == NULL);
8143 gdb_assert (per_cu->is_debug_types);
8144 sig_type = (struct signatured_type *) per_cu;
8149 attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
8150 tu_group = get_type_unit_group (cu, attr);
8152 VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
8154 prepare_one_comp_unit (cu, type_unit_die, language_minimal);
8155 pst = create_partial_symtab (per_cu, "");
8158 first_die = load_partial_dies (reader, info_ptr, 1);
8160 lowpc = (CORE_ADDR) -1;
8161 highpc = (CORE_ADDR) 0;
8162 scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
8164 end_psymtab_common (objfile, pst);
8167 /* Struct used to sort TUs by their abbreviation table offset. */
8169 struct tu_abbrev_offset
8171 tu_abbrev_offset (signatured_type *sig_type_, sect_offset abbrev_offset_)
8172 : sig_type (sig_type_), abbrev_offset (abbrev_offset_)
8175 signatured_type *sig_type;
8176 sect_offset abbrev_offset;
8179 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
8182 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset &a,
8183 const struct tu_abbrev_offset &b)
8185 return a.abbrev_offset < b.abbrev_offset;
8188 /* Efficiently read all the type units.
8189 This does the bulk of the work for build_type_psymtabs.
8191 The efficiency is because we sort TUs by the abbrev table they use and
8192 only read each abbrev table once. In one program there are 200K TUs
8193 sharing 8K abbrev tables.
8195 The main purpose of this function is to support building the
8196 dwarf2_per_objfile->type_unit_groups table.
8197 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8198 can collapse the search space by grouping them by stmt_list.
8199 The savings can be significant, in the same program from above the 200K TUs
8200 share 8K stmt_list tables.
8202 FUNC is expected to call get_type_unit_group, which will create the
8203 struct type_unit_group if necessary and add it to
8204 dwarf2_per_objfile->type_unit_groups. */
8207 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
8209 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8210 abbrev_table_up abbrev_table;
8211 sect_offset abbrev_offset;
8213 /* It's up to the caller to not call us multiple times. */
8214 gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
8216 if (dwarf2_per_objfile->all_type_units.empty ())
8219 /* TUs typically share abbrev tables, and there can be way more TUs than
8220 abbrev tables. Sort by abbrev table to reduce the number of times we
8221 read each abbrev table in.
8222 Alternatives are to punt or to maintain a cache of abbrev tables.
8223 This is simpler and efficient enough for now.
8225 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8226 symtab to use). Typically TUs with the same abbrev offset have the same
8227 stmt_list value too so in practice this should work well.
8229 The basic algorithm here is:
8231 sort TUs by abbrev table
8232 for each TU with same abbrev table:
8233 read abbrev table if first user
8234 read TU top level DIE
8235 [IWBN if DWO skeletons had DW_AT_stmt_list]
8238 if (dwarf_read_debug)
8239 fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
8241 /* Sort in a separate table to maintain the order of all_type_units
8242 for .gdb_index: TU indices directly index all_type_units. */
8243 std::vector<tu_abbrev_offset> sorted_by_abbrev;
8244 sorted_by_abbrev.reserve (dwarf2_per_objfile->all_type_units.size ());
8246 for (signatured_type *sig_type : dwarf2_per_objfile->all_type_units)
8247 sorted_by_abbrev.emplace_back
8248 (sig_type, read_abbrev_offset (dwarf2_per_objfile,
8249 sig_type->per_cu.section,
8250 sig_type->per_cu.sect_off));
8252 std::sort (sorted_by_abbrev.begin (), sorted_by_abbrev.end (),
8253 sort_tu_by_abbrev_offset);
8255 abbrev_offset = (sect_offset) ~(unsigned) 0;
8257 for (const tu_abbrev_offset &tu : sorted_by_abbrev)
8259 /* Switch to the next abbrev table if necessary. */
8260 if (abbrev_table == NULL
8261 || tu.abbrev_offset != abbrev_offset)
8263 abbrev_offset = tu.abbrev_offset;
8265 abbrev_table_read_table (dwarf2_per_objfile,
8266 &dwarf2_per_objfile->abbrev,
8268 ++tu_stats->nr_uniq_abbrev_tables;
8271 init_cutu_and_read_dies (&tu.sig_type->per_cu, abbrev_table.get (),
8272 0, 0, false, build_type_psymtabs_reader, NULL);
8276 /* Print collected type unit statistics. */
8279 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
8281 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8283 fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
8284 fprintf_unfiltered (gdb_stdlog, " %zu TUs\n",
8285 dwarf2_per_objfile->all_type_units.size ());
8286 fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
8287 tu_stats->nr_uniq_abbrev_tables);
8288 fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
8289 tu_stats->nr_symtabs);
8290 fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
8291 tu_stats->nr_symtab_sharers);
8292 fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
8293 tu_stats->nr_stmt_less_type_units);
8294 fprintf_unfiltered (gdb_stdlog, " %d all_type_units reallocs\n",
8295 tu_stats->nr_all_type_units_reallocs);
8298 /* Traversal function for build_type_psymtabs. */
8301 build_type_psymtab_dependencies (void **slot, void *info)
8303 struct dwarf2_per_objfile *dwarf2_per_objfile
8304 = (struct dwarf2_per_objfile *) info;
8305 struct objfile *objfile = dwarf2_per_objfile->objfile;
8306 struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
8307 struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
8308 struct partial_symtab *pst = per_cu->v.psymtab;
8309 int len = VEC_length (sig_type_ptr, tu_group->tus);
8310 struct signatured_type *iter;
8313 gdb_assert (len > 0);
8314 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
8316 pst->number_of_dependencies = len;
8317 pst->dependencies = objfile->partial_symtabs->allocate_dependencies (len);
8319 VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
8322 gdb_assert (iter->per_cu.is_debug_types);
8323 pst->dependencies[i] = iter->per_cu.v.psymtab;
8324 iter->type_unit_group = tu_group;
8327 VEC_free (sig_type_ptr, tu_group->tus);
8332 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8333 Build partial symbol tables for the .debug_types comp-units. */
8336 build_type_psymtabs (struct dwarf2_per_objfile *dwarf2_per_objfile)
8338 if (! create_all_type_units (dwarf2_per_objfile))
8341 build_type_psymtabs_1 (dwarf2_per_objfile);
8344 /* Traversal function for process_skeletonless_type_unit.
8345 Read a TU in a DWO file and build partial symbols for it. */
8348 process_skeletonless_type_unit (void **slot, void *info)
8350 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
8351 struct dwarf2_per_objfile *dwarf2_per_objfile
8352 = (struct dwarf2_per_objfile *) info;
8353 struct signatured_type find_entry, *entry;
8355 /* If this TU doesn't exist in the global table, add it and read it in. */
8357 if (dwarf2_per_objfile->signatured_types == NULL)
8359 dwarf2_per_objfile->signatured_types
8360 = allocate_signatured_type_table (dwarf2_per_objfile->objfile);
8363 find_entry.signature = dwo_unit->signature;
8364 slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
8366 /* If we've already seen this type there's nothing to do. What's happening
8367 is we're doing our own version of comdat-folding here. */
8371 /* This does the job that create_all_type_units would have done for
8373 entry = add_type_unit (dwarf2_per_objfile, dwo_unit->signature, slot);
8374 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, entry, dwo_unit);
8377 /* This does the job that build_type_psymtabs_1 would have done. */
8378 init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0, false,
8379 build_type_psymtabs_reader, NULL);
8384 /* Traversal function for process_skeletonless_type_units. */
8387 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
8389 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
8391 if (dwo_file->tus != NULL)
8393 htab_traverse_noresize (dwo_file->tus,
8394 process_skeletonless_type_unit, info);
8400 /* Scan all TUs of DWO files, verifying we've processed them.
8401 This is needed in case a TU was emitted without its skeleton.
8402 Note: This can't be done until we know what all the DWO files are. */
8405 process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8407 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8408 if (get_dwp_file (dwarf2_per_objfile) == NULL
8409 && dwarf2_per_objfile->dwo_files != NULL)
8411 htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
8412 process_dwo_file_for_skeletonless_type_units,
8413 dwarf2_per_objfile);
8417 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8420 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
8422 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8424 struct partial_symtab *pst = per_cu->v.psymtab;
8429 for (int j = 0; j < pst->number_of_dependencies; ++j)
8431 /* Set the 'user' field only if it is not already set. */
8432 if (pst->dependencies[j]->user == NULL)
8433 pst->dependencies[j]->user = pst;
8438 /* Build the partial symbol table by doing a quick pass through the
8439 .debug_info and .debug_abbrev sections. */
8442 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
8444 struct objfile *objfile = dwarf2_per_objfile->objfile;
8446 if (dwarf_read_debug)
8448 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
8449 objfile_name (objfile));
8452 dwarf2_per_objfile->reading_partial_symbols = 1;
8454 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
8456 /* Any cached compilation units will be linked by the per-objfile
8457 read_in_chain. Make sure to free them when we're done. */
8458 free_cached_comp_units freer (dwarf2_per_objfile);
8460 build_type_psymtabs (dwarf2_per_objfile);
8462 create_all_comp_units (dwarf2_per_objfile);
8464 /* Create a temporary address map on a temporary obstack. We later
8465 copy this to the final obstack. */
8466 auto_obstack temp_obstack;
8468 scoped_restore save_psymtabs_addrmap
8469 = make_scoped_restore (&objfile->partial_symtabs->psymtabs_addrmap,
8470 addrmap_create_mutable (&temp_obstack));
8472 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8473 process_psymtab_comp_unit (per_cu, 0, language_minimal);
8475 /* This has to wait until we read the CUs, we need the list of DWOs. */
8476 process_skeletonless_type_units (dwarf2_per_objfile);
8478 /* Now that all TUs have been processed we can fill in the dependencies. */
8479 if (dwarf2_per_objfile->type_unit_groups != NULL)
8481 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
8482 build_type_psymtab_dependencies, dwarf2_per_objfile);
8485 if (dwarf_read_debug)
8486 print_tu_stats (dwarf2_per_objfile);
8488 set_partial_user (dwarf2_per_objfile);
8490 objfile->partial_symtabs->psymtabs_addrmap
8491 = addrmap_create_fixed (objfile->partial_symtabs->psymtabs_addrmap,
8492 objfile->partial_symtabs->obstack ());
8493 /* At this point we want to keep the address map. */
8494 save_psymtabs_addrmap.release ();
8496 if (dwarf_read_debug)
8497 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
8498 objfile_name (objfile));
8501 /* die_reader_func for load_partial_comp_unit. */
8504 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
8505 const gdb_byte *info_ptr,
8506 struct die_info *comp_unit_die,
8510 struct dwarf2_cu *cu = reader->cu;
8512 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
8514 /* Check if comp unit has_children.
8515 If so, read the rest of the partial symbols from this comp unit.
8516 If not, there's no more debug_info for this comp unit. */
8518 load_partial_dies (reader, info_ptr, 0);
8521 /* Load the partial DIEs for a secondary CU into memory.
8522 This is also used when rereading a primary CU with load_all_dies. */
8525 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
8527 init_cutu_and_read_dies (this_cu, NULL, 1, 1, false,
8528 load_partial_comp_unit_reader, NULL);
8532 read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
8533 struct dwarf2_section_info *section,
8534 struct dwarf2_section_info *abbrev_section,
8535 unsigned int is_dwz)
8537 const gdb_byte *info_ptr;
8538 struct objfile *objfile = dwarf2_per_objfile->objfile;
8540 if (dwarf_read_debug)
8541 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
8542 get_section_name (section),
8543 get_section_file_name (section));
8545 dwarf2_read_section (objfile, section);
8547 info_ptr = section->buffer;
8549 while (info_ptr < section->buffer + section->size)
8551 struct dwarf2_per_cu_data *this_cu;
8553 sect_offset sect_off = (sect_offset) (info_ptr - section->buffer);
8555 comp_unit_head cu_header;
8556 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
8557 abbrev_section, info_ptr,
8558 rcuh_kind::COMPILE);
8560 /* Save the compilation unit for later lookup. */
8561 if (cu_header.unit_type != DW_UT_type)
8563 this_cu = XOBNEW (&objfile->objfile_obstack,
8564 struct dwarf2_per_cu_data);
8565 memset (this_cu, 0, sizeof (*this_cu));
8569 auto sig_type = XOBNEW (&objfile->objfile_obstack,
8570 struct signatured_type);
8571 memset (sig_type, 0, sizeof (*sig_type));
8572 sig_type->signature = cu_header.signature;
8573 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
8574 this_cu = &sig_type->per_cu;
8576 this_cu->is_debug_types = (cu_header.unit_type == DW_UT_type);
8577 this_cu->sect_off = sect_off;
8578 this_cu->length = cu_header.length + cu_header.initial_length_size;
8579 this_cu->is_dwz = is_dwz;
8580 this_cu->dwarf2_per_objfile = dwarf2_per_objfile;
8581 this_cu->section = section;
8583 dwarf2_per_objfile->all_comp_units.push_back (this_cu);
8585 info_ptr = info_ptr + this_cu->length;
8589 /* Create a list of all compilation units in OBJFILE.
8590 This is only done for -readnow and building partial symtabs. */
8593 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8595 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
8596 read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
8597 &dwarf2_per_objfile->abbrev, 0);
8599 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
8601 read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
8605 /* Process all loaded DIEs for compilation unit CU, starting at
8606 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8607 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8608 DW_AT_ranges). See the comments of add_partial_subprogram on how
8609 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8612 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
8613 CORE_ADDR *highpc, int set_addrmap,
8614 struct dwarf2_cu *cu)
8616 struct partial_die_info *pdi;
8618 /* Now, march along the PDI's, descending into ones which have
8619 interesting children but skipping the children of the other ones,
8620 until we reach the end of the compilation unit. */
8628 /* Anonymous namespaces or modules have no name but have interesting
8629 children, so we need to look at them. Ditto for anonymous
8632 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
8633 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
8634 || pdi->tag == DW_TAG_imported_unit
8635 || pdi->tag == DW_TAG_inlined_subroutine)
8639 case DW_TAG_subprogram:
8640 case DW_TAG_inlined_subroutine:
8641 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
8643 case DW_TAG_constant:
8644 case DW_TAG_variable:
8645 case DW_TAG_typedef:
8646 case DW_TAG_union_type:
8647 if (!pdi->is_declaration)
8649 add_partial_symbol (pdi, cu);
8652 case DW_TAG_class_type:
8653 case DW_TAG_interface_type:
8654 case DW_TAG_structure_type:
8655 if (!pdi->is_declaration)
8657 add_partial_symbol (pdi, cu);
8659 if ((cu->language == language_rust
8660 || cu->language == language_cplus) && pdi->has_children)
8661 scan_partial_symbols (pdi->die_child, lowpc, highpc,
8664 case DW_TAG_enumeration_type:
8665 if (!pdi->is_declaration)
8666 add_partial_enumeration (pdi, cu);
8668 case DW_TAG_base_type:
8669 case DW_TAG_subrange_type:
8670 /* File scope base type definitions are added to the partial
8672 add_partial_symbol (pdi, cu);
8674 case DW_TAG_namespace:
8675 add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
8678 add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
8680 case DW_TAG_imported_unit:
8682 struct dwarf2_per_cu_data *per_cu;
8684 /* For now we don't handle imported units in type units. */
8685 if (cu->per_cu->is_debug_types)
8687 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8688 " supported in type units [in module %s]"),
8689 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
8692 per_cu = dwarf2_find_containing_comp_unit
8693 (pdi->d.sect_off, pdi->is_dwz,
8694 cu->per_cu->dwarf2_per_objfile);
8696 /* Go read the partial unit, if needed. */
8697 if (per_cu->v.psymtab == NULL)
8698 process_psymtab_comp_unit (per_cu, 1, cu->language);
8700 VEC_safe_push (dwarf2_per_cu_ptr,
8701 cu->per_cu->imported_symtabs, per_cu);
8704 case DW_TAG_imported_declaration:
8705 add_partial_symbol (pdi, cu);
8712 /* If the die has a sibling, skip to the sibling. */
8714 pdi = pdi->die_sibling;
8718 /* Functions used to compute the fully scoped name of a partial DIE.
8720 Normally, this is simple. For C++, the parent DIE's fully scoped
8721 name is concatenated with "::" and the partial DIE's name.
8722 Enumerators are an exception; they use the scope of their parent
8723 enumeration type, i.e. the name of the enumeration type is not
8724 prepended to the enumerator.
8726 There are two complexities. One is DW_AT_specification; in this
8727 case "parent" means the parent of the target of the specification,
8728 instead of the direct parent of the DIE. The other is compilers
8729 which do not emit DW_TAG_namespace; in this case we try to guess
8730 the fully qualified name of structure types from their members'
8731 linkage names. This must be done using the DIE's children rather
8732 than the children of any DW_AT_specification target. We only need
8733 to do this for structures at the top level, i.e. if the target of
8734 any DW_AT_specification (if any; otherwise the DIE itself) does not
8737 /* Compute the scope prefix associated with PDI's parent, in
8738 compilation unit CU. The result will be allocated on CU's
8739 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8740 field. NULL is returned if no prefix is necessary. */
8742 partial_die_parent_scope (struct partial_die_info *pdi,
8743 struct dwarf2_cu *cu)
8745 const char *grandparent_scope;
8746 struct partial_die_info *parent, *real_pdi;
8748 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8749 then this means the parent of the specification DIE. */
8752 while (real_pdi->has_specification)
8753 real_pdi = find_partial_die (real_pdi->spec_offset,
8754 real_pdi->spec_is_dwz, cu);
8756 parent = real_pdi->die_parent;
8760 if (parent->scope_set)
8761 return parent->scope;
8765 grandparent_scope = partial_die_parent_scope (parent, cu);
8767 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8768 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8769 Work around this problem here. */
8770 if (cu->language == language_cplus
8771 && parent->tag == DW_TAG_namespace
8772 && strcmp (parent->name, "::") == 0
8773 && grandparent_scope == NULL)
8775 parent->scope = NULL;
8776 parent->scope_set = 1;
8780 if (pdi->tag == DW_TAG_enumerator)
8781 /* Enumerators should not get the name of the enumeration as a prefix. */
8782 parent->scope = grandparent_scope;
8783 else if (parent->tag == DW_TAG_namespace
8784 || parent->tag == DW_TAG_module
8785 || parent->tag == DW_TAG_structure_type
8786 || parent->tag == DW_TAG_class_type
8787 || parent->tag == DW_TAG_interface_type
8788 || parent->tag == DW_TAG_union_type
8789 || parent->tag == DW_TAG_enumeration_type)
8791 if (grandparent_scope == NULL)
8792 parent->scope = parent->name;
8794 parent->scope = typename_concat (&cu->comp_unit_obstack,
8796 parent->name, 0, cu);
8800 /* FIXME drow/2004-04-01: What should we be doing with
8801 function-local names? For partial symbols, we should probably be
8803 complaint (_("unhandled containing DIE tag %d for DIE at %s"),
8804 parent->tag, sect_offset_str (pdi->sect_off));
8805 parent->scope = grandparent_scope;
8808 parent->scope_set = 1;
8809 return parent->scope;
8812 /* Return the fully scoped name associated with PDI, from compilation unit
8813 CU. The result will be allocated with malloc. */
8816 partial_die_full_name (struct partial_die_info *pdi,
8817 struct dwarf2_cu *cu)
8819 const char *parent_scope;
8821 /* If this is a template instantiation, we can not work out the
8822 template arguments from partial DIEs. So, unfortunately, we have
8823 to go through the full DIEs. At least any work we do building
8824 types here will be reused if full symbols are loaded later. */
8825 if (pdi->has_template_arguments)
8829 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
8831 struct die_info *die;
8832 struct attribute attr;
8833 struct dwarf2_cu *ref_cu = cu;
8835 /* DW_FORM_ref_addr is using section offset. */
8836 attr.name = (enum dwarf_attribute) 0;
8837 attr.form = DW_FORM_ref_addr;
8838 attr.u.unsnd = to_underlying (pdi->sect_off);
8839 die = follow_die_ref (NULL, &attr, &ref_cu);
8841 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
8845 parent_scope = partial_die_parent_scope (pdi, cu);
8846 if (parent_scope == NULL)
8849 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
8853 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
8855 struct dwarf2_per_objfile *dwarf2_per_objfile
8856 = cu->per_cu->dwarf2_per_objfile;
8857 struct objfile *objfile = dwarf2_per_objfile->objfile;
8858 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8860 const char *actual_name = NULL;
8862 char *built_actual_name;
8864 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8866 built_actual_name = partial_die_full_name (pdi, cu);
8867 if (built_actual_name != NULL)
8868 actual_name = built_actual_name;
8870 if (actual_name == NULL)
8871 actual_name = pdi->name;
8875 case DW_TAG_inlined_subroutine:
8876 case DW_TAG_subprogram:
8877 addr = (gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr)
8879 if (pdi->is_external || cu->language == language_ada)
8881 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8882 of the global scope. But in Ada, we want to be able to access
8883 nested procedures globally. So all Ada subprograms are stored
8884 in the global scope. */
8885 add_psymbol_to_list (actual_name, strlen (actual_name),
8886 built_actual_name != NULL,
8887 VAR_DOMAIN, LOC_BLOCK,
8888 SECT_OFF_TEXT (objfile),
8889 psymbol_placement::GLOBAL,
8891 cu->language, objfile);
8895 add_psymbol_to_list (actual_name, strlen (actual_name),
8896 built_actual_name != NULL,
8897 VAR_DOMAIN, LOC_BLOCK,
8898 SECT_OFF_TEXT (objfile),
8899 psymbol_placement::STATIC,
8900 addr, cu->language, objfile);
8903 if (pdi->main_subprogram && actual_name != NULL)
8904 set_objfile_main_name (objfile, actual_name, cu->language);
8906 case DW_TAG_constant:
8907 add_psymbol_to_list (actual_name, strlen (actual_name),
8908 built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
8909 -1, (pdi->is_external
8910 ? psymbol_placement::GLOBAL
8911 : psymbol_placement::STATIC),
8912 0, cu->language, objfile);
8914 case DW_TAG_variable:
8916 addr = decode_locdesc (pdi->d.locdesc, cu);
8920 && !dwarf2_per_objfile->has_section_at_zero)
8922 /* A global or static variable may also have been stripped
8923 out by the linker if unused, in which case its address
8924 will be nullified; do not add such variables into partial
8925 symbol table then. */
8927 else if (pdi->is_external)
8930 Don't enter into the minimal symbol tables as there is
8931 a minimal symbol table entry from the ELF symbols already.
8932 Enter into partial symbol table if it has a location
8933 descriptor or a type.
8934 If the location descriptor is missing, new_symbol will create
8935 a LOC_UNRESOLVED symbol, the address of the variable will then
8936 be determined from the minimal symbol table whenever the variable
8938 The address for the partial symbol table entry is not
8939 used by GDB, but it comes in handy for debugging partial symbol
8942 if (pdi->d.locdesc || pdi->has_type)
8943 add_psymbol_to_list (actual_name, strlen (actual_name),
8944 built_actual_name != NULL,
8945 VAR_DOMAIN, LOC_STATIC,
8946 SECT_OFF_TEXT (objfile),
8947 psymbol_placement::GLOBAL,
8948 addr, cu->language, objfile);
8952 int has_loc = pdi->d.locdesc != NULL;
8954 /* Static Variable. Skip symbols whose value we cannot know (those
8955 without location descriptors or constant values). */
8956 if (!has_loc && !pdi->has_const_value)
8958 xfree (built_actual_name);
8962 add_psymbol_to_list (actual_name, strlen (actual_name),
8963 built_actual_name != NULL,
8964 VAR_DOMAIN, LOC_STATIC,
8965 SECT_OFF_TEXT (objfile),
8966 psymbol_placement::STATIC,
8968 cu->language, objfile);
8971 case DW_TAG_typedef:
8972 case DW_TAG_base_type:
8973 case DW_TAG_subrange_type:
8974 add_psymbol_to_list (actual_name, strlen (actual_name),
8975 built_actual_name != NULL,
8976 VAR_DOMAIN, LOC_TYPEDEF, -1,
8977 psymbol_placement::STATIC,
8978 0, cu->language, objfile);
8980 case DW_TAG_imported_declaration:
8981 case DW_TAG_namespace:
8982 add_psymbol_to_list (actual_name, strlen (actual_name),
8983 built_actual_name != NULL,
8984 VAR_DOMAIN, LOC_TYPEDEF, -1,
8985 psymbol_placement::GLOBAL,
8986 0, cu->language, objfile);
8989 add_psymbol_to_list (actual_name, strlen (actual_name),
8990 built_actual_name != NULL,
8991 MODULE_DOMAIN, LOC_TYPEDEF, -1,
8992 psymbol_placement::GLOBAL,
8993 0, cu->language, objfile);
8995 case DW_TAG_class_type:
8996 case DW_TAG_interface_type:
8997 case DW_TAG_structure_type:
8998 case DW_TAG_union_type:
8999 case DW_TAG_enumeration_type:
9000 /* Skip external references. The DWARF standard says in the section
9001 about "Structure, Union, and Class Type Entries": "An incomplete
9002 structure, union or class type is represented by a structure,
9003 union or class entry that does not have a byte size attribute
9004 and that has a DW_AT_declaration attribute." */
9005 if (!pdi->has_byte_size && pdi->is_declaration)
9007 xfree (built_actual_name);
9011 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9012 static vs. global. */
9013 add_psymbol_to_list (actual_name, strlen (actual_name),
9014 built_actual_name != NULL,
9015 STRUCT_DOMAIN, LOC_TYPEDEF, -1,
9016 cu->language == language_cplus
9017 ? psymbol_placement::GLOBAL
9018 : psymbol_placement::STATIC,
9019 0, cu->language, objfile);
9022 case DW_TAG_enumerator:
9023 add_psymbol_to_list (actual_name, strlen (actual_name),
9024 built_actual_name != NULL,
9025 VAR_DOMAIN, LOC_CONST, -1,
9026 cu->language == language_cplus
9027 ? psymbol_placement::GLOBAL
9028 : psymbol_placement::STATIC,
9029 0, cu->language, objfile);
9035 xfree (built_actual_name);
9038 /* Read a partial die corresponding to a namespace; also, add a symbol
9039 corresponding to that namespace to the symbol table. NAMESPACE is
9040 the name of the enclosing namespace. */
9043 add_partial_namespace (struct partial_die_info *pdi,
9044 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9045 int set_addrmap, struct dwarf2_cu *cu)
9047 /* Add a symbol for the namespace. */
9049 add_partial_symbol (pdi, cu);
9051 /* Now scan partial symbols in that namespace. */
9053 if (pdi->has_children)
9054 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9057 /* Read a partial die corresponding to a Fortran module. */
9060 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
9061 CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
9063 /* Add a symbol for the namespace. */
9065 add_partial_symbol (pdi, cu);
9067 /* Now scan partial symbols in that module. */
9069 if (pdi->has_children)
9070 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9073 /* Read a partial die corresponding to a subprogram or an inlined
9074 subprogram and create a partial symbol for that subprogram.
9075 When the CU language allows it, this routine also defines a partial
9076 symbol for each nested subprogram that this subprogram contains.
9077 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9078 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9080 PDI may also be a lexical block, in which case we simply search
9081 recursively for subprograms defined inside that lexical block.
9082 Again, this is only performed when the CU language allows this
9083 type of definitions. */
9086 add_partial_subprogram (struct partial_die_info *pdi,
9087 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9088 int set_addrmap, struct dwarf2_cu *cu)
9090 if (pdi->tag == DW_TAG_subprogram || pdi->tag == DW_TAG_inlined_subroutine)
9092 if (pdi->has_pc_info)
9094 if (pdi->lowpc < *lowpc)
9095 *lowpc = pdi->lowpc;
9096 if (pdi->highpc > *highpc)
9097 *highpc = pdi->highpc;
9100 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9101 struct gdbarch *gdbarch = get_objfile_arch (objfile);
9103 CORE_ADDR this_highpc;
9104 CORE_ADDR this_lowpc;
9106 baseaddr = ANOFFSET (objfile->section_offsets,
9107 SECT_OFF_TEXT (objfile));
9109 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9110 pdi->lowpc + baseaddr)
9113 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9114 pdi->highpc + baseaddr)
9116 addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
9117 this_lowpc, this_highpc - 1,
9118 cu->per_cu->v.psymtab);
9122 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
9124 if (!pdi->is_declaration)
9125 /* Ignore subprogram DIEs that do not have a name, they are
9126 illegal. Do not emit a complaint at this point, we will
9127 do so when we convert this psymtab into a symtab. */
9129 add_partial_symbol (pdi, cu);
9133 if (! pdi->has_children)
9136 if (cu->language == language_ada)
9138 pdi = pdi->die_child;
9142 if (pdi->tag == DW_TAG_subprogram
9143 || pdi->tag == DW_TAG_inlined_subroutine
9144 || pdi->tag == DW_TAG_lexical_block)
9145 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
9146 pdi = pdi->die_sibling;
9151 /* Read a partial die corresponding to an enumeration type. */
9154 add_partial_enumeration (struct partial_die_info *enum_pdi,
9155 struct dwarf2_cu *cu)
9157 struct partial_die_info *pdi;
9159 if (enum_pdi->name != NULL)
9160 add_partial_symbol (enum_pdi, cu);
9162 pdi = enum_pdi->die_child;
9165 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
9166 complaint (_("malformed enumerator DIE ignored"));
9168 add_partial_symbol (pdi, cu);
9169 pdi = pdi->die_sibling;
9173 /* Return the initial uleb128 in the die at INFO_PTR. */
9176 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
9178 unsigned int bytes_read;
9180 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9183 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9184 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
9186 Return the corresponding abbrev, or NULL if the number is zero (indicating
9187 an empty DIE). In either case *BYTES_READ will be set to the length of
9188 the initial number. */
9190 static struct abbrev_info *
9191 peek_die_abbrev (const die_reader_specs &reader,
9192 const gdb_byte *info_ptr, unsigned int *bytes_read)
9194 dwarf2_cu *cu = reader.cu;
9195 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
9196 unsigned int abbrev_number
9197 = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
9199 if (abbrev_number == 0)
9202 abbrev_info *abbrev = reader.abbrev_table->lookup_abbrev (abbrev_number);
9205 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9206 " at offset %s [in module %s]"),
9207 abbrev_number, cu->per_cu->is_debug_types ? "TU" : "CU",
9208 sect_offset_str (cu->header.sect_off), bfd_get_filename (abfd));
9214 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9215 Returns a pointer to the end of a series of DIEs, terminated by an empty
9216 DIE. Any children of the skipped DIEs will also be skipped. */
9218 static const gdb_byte *
9219 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
9223 unsigned int bytes_read;
9224 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
9227 return info_ptr + bytes_read;
9229 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
9233 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9234 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9235 abbrev corresponding to that skipped uleb128 should be passed in
9236 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9239 static const gdb_byte *
9240 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
9241 struct abbrev_info *abbrev)
9243 unsigned int bytes_read;
9244 struct attribute attr;
9245 bfd *abfd = reader->abfd;
9246 struct dwarf2_cu *cu = reader->cu;
9247 const gdb_byte *buffer = reader->buffer;
9248 const gdb_byte *buffer_end = reader->buffer_end;
9249 unsigned int form, i;
9251 for (i = 0; i < abbrev->num_attrs; i++)
9253 /* The only abbrev we care about is DW_AT_sibling. */
9254 if (abbrev->attrs[i].name == DW_AT_sibling)
9256 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
9257 if (attr.form == DW_FORM_ref_addr)
9258 complaint (_("ignoring absolute DW_AT_sibling"));
9261 sect_offset off = dwarf2_get_ref_die_offset (&attr);
9262 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
9264 if (sibling_ptr < info_ptr)
9265 complaint (_("DW_AT_sibling points backwards"));
9266 else if (sibling_ptr > reader->buffer_end)
9267 dwarf2_section_buffer_overflow_complaint (reader->die_section);
9273 /* If it isn't DW_AT_sibling, skip this attribute. */
9274 form = abbrev->attrs[i].form;
9278 case DW_FORM_ref_addr:
9279 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9280 and later it is offset sized. */
9281 if (cu->header.version == 2)
9282 info_ptr += cu->header.addr_size;
9284 info_ptr += cu->header.offset_size;
9286 case DW_FORM_GNU_ref_alt:
9287 info_ptr += cu->header.offset_size;
9290 info_ptr += cu->header.addr_size;
9297 case DW_FORM_flag_present:
9298 case DW_FORM_implicit_const:
9310 case DW_FORM_ref_sig8:
9313 case DW_FORM_data16:
9316 case DW_FORM_string:
9317 read_direct_string (abfd, info_ptr, &bytes_read);
9318 info_ptr += bytes_read;
9320 case DW_FORM_sec_offset:
9322 case DW_FORM_GNU_strp_alt:
9323 info_ptr += cu->header.offset_size;
9325 case DW_FORM_exprloc:
9327 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9328 info_ptr += bytes_read;
9330 case DW_FORM_block1:
9331 info_ptr += 1 + read_1_byte (abfd, info_ptr);
9333 case DW_FORM_block2:
9334 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
9336 case DW_FORM_block4:
9337 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
9341 case DW_FORM_ref_udata:
9342 case DW_FORM_GNU_addr_index:
9343 case DW_FORM_GNU_str_index:
9344 info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
9346 case DW_FORM_indirect:
9347 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9348 info_ptr += bytes_read;
9349 /* We need to continue parsing from here, so just go back to
9351 goto skip_attribute;
9354 error (_("Dwarf Error: Cannot handle %s "
9355 "in DWARF reader [in module %s]"),
9356 dwarf_form_name (form),
9357 bfd_get_filename (abfd));
9361 if (abbrev->has_children)
9362 return skip_children (reader, info_ptr);
9367 /* Locate ORIG_PDI's sibling.
9368 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9370 static const gdb_byte *
9371 locate_pdi_sibling (const struct die_reader_specs *reader,
9372 struct partial_die_info *orig_pdi,
9373 const gdb_byte *info_ptr)
9375 /* Do we know the sibling already? */
9377 if (orig_pdi->sibling)
9378 return orig_pdi->sibling;
9380 /* Are there any children to deal with? */
9382 if (!orig_pdi->has_children)
9385 /* Skip the children the long way. */
9387 return skip_children (reader, info_ptr);
9390 /* Expand this partial symbol table into a full symbol table. SELF is
9394 dwarf2_read_symtab (struct partial_symtab *self,
9395 struct objfile *objfile)
9397 struct dwarf2_per_objfile *dwarf2_per_objfile
9398 = get_dwarf2_per_objfile (objfile);
9402 warning (_("bug: psymtab for %s is already read in."),
9409 printf_filtered (_("Reading in symbols for %s..."),
9411 gdb_flush (gdb_stdout);
9414 /* If this psymtab is constructed from a debug-only objfile, the
9415 has_section_at_zero flag will not necessarily be correct. We
9416 can get the correct value for this flag by looking at the data
9417 associated with the (presumably stripped) associated objfile. */
9418 if (objfile->separate_debug_objfile_backlink)
9420 struct dwarf2_per_objfile *dpo_backlink
9421 = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
9423 dwarf2_per_objfile->has_section_at_zero
9424 = dpo_backlink->has_section_at_zero;
9427 dwarf2_per_objfile->reading_partial_symbols = 0;
9429 psymtab_to_symtab_1 (self);
9431 /* Finish up the debug error message. */
9433 printf_filtered (_("done.\n"));
9436 process_cu_includes (dwarf2_per_objfile);
9439 /* Reading in full CUs. */
9441 /* Add PER_CU to the queue. */
9444 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
9445 enum language pretend_language)
9447 struct dwarf2_queue_item *item;
9450 item = XNEW (struct dwarf2_queue_item);
9451 item->per_cu = per_cu;
9452 item->pretend_language = pretend_language;
9455 if (dwarf2_queue == NULL)
9456 dwarf2_queue = item;
9458 dwarf2_queue_tail->next = item;
9460 dwarf2_queue_tail = item;
9463 /* If PER_CU is not yet queued, add it to the queue.
9464 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9466 The result is non-zero if PER_CU was queued, otherwise the result is zero
9467 meaning either PER_CU is already queued or it is already loaded.
9469 N.B. There is an invariant here that if a CU is queued then it is loaded.
9470 The caller is required to load PER_CU if we return non-zero. */
9473 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
9474 struct dwarf2_per_cu_data *per_cu,
9475 enum language pretend_language)
9477 /* We may arrive here during partial symbol reading, if we need full
9478 DIEs to process an unusual case (e.g. template arguments). Do
9479 not queue PER_CU, just tell our caller to load its DIEs. */
9480 if (per_cu->dwarf2_per_objfile->reading_partial_symbols)
9482 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
9487 /* Mark the dependence relation so that we don't flush PER_CU
9489 if (dependent_cu != NULL)
9490 dwarf2_add_dependence (dependent_cu, per_cu);
9492 /* If it's already on the queue, we have nothing to do. */
9496 /* If the compilation unit is already loaded, just mark it as
9498 if (per_cu->cu != NULL)
9500 per_cu->cu->last_used = 0;
9504 /* Add it to the queue. */
9505 queue_comp_unit (per_cu, pretend_language);
9510 /* Process the queue. */
9513 process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
9515 struct dwarf2_queue_item *item, *next_item;
9517 if (dwarf_read_debug)
9519 fprintf_unfiltered (gdb_stdlog,
9520 "Expanding one or more symtabs of objfile %s ...\n",
9521 objfile_name (dwarf2_per_objfile->objfile));
9524 /* The queue starts out with one item, but following a DIE reference
9525 may load a new CU, adding it to the end of the queue. */
9526 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
9528 if ((dwarf2_per_objfile->using_index
9529 ? !item->per_cu->v.quick->compunit_symtab
9530 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
9531 /* Skip dummy CUs. */
9532 && item->per_cu->cu != NULL)
9534 struct dwarf2_per_cu_data *per_cu = item->per_cu;
9535 unsigned int debug_print_threshold;
9538 if (per_cu->is_debug_types)
9540 struct signatured_type *sig_type =
9541 (struct signatured_type *) per_cu;
9543 sprintf (buf, "TU %s at offset %s",
9544 hex_string (sig_type->signature),
9545 sect_offset_str (per_cu->sect_off));
9546 /* There can be 100s of TUs.
9547 Only print them in verbose mode. */
9548 debug_print_threshold = 2;
9552 sprintf (buf, "CU at offset %s",
9553 sect_offset_str (per_cu->sect_off));
9554 debug_print_threshold = 1;
9557 if (dwarf_read_debug >= debug_print_threshold)
9558 fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
9560 if (per_cu->is_debug_types)
9561 process_full_type_unit (per_cu, item->pretend_language);
9563 process_full_comp_unit (per_cu, item->pretend_language);
9565 if (dwarf_read_debug >= debug_print_threshold)
9566 fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
9569 item->per_cu->queued = 0;
9570 next_item = item->next;
9574 dwarf2_queue_tail = NULL;
9576 if (dwarf_read_debug)
9578 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
9579 objfile_name (dwarf2_per_objfile->objfile));
9583 /* Read in full symbols for PST, and anything it depends on. */
9586 psymtab_to_symtab_1 (struct partial_symtab *pst)
9588 struct dwarf2_per_cu_data *per_cu;
9594 for (i = 0; i < pst->number_of_dependencies; i++)
9595 if (!pst->dependencies[i]->readin
9596 && pst->dependencies[i]->user == NULL)
9598 /* Inform about additional files that need to be read in. */
9601 /* FIXME: i18n: Need to make this a single string. */
9602 fputs_filtered (" ", gdb_stdout);
9604 fputs_filtered ("and ", gdb_stdout);
9606 printf_filtered ("%s...", pst->dependencies[i]->filename);
9607 wrap_here (""); /* Flush output. */
9608 gdb_flush (gdb_stdout);
9610 psymtab_to_symtab_1 (pst->dependencies[i]);
9613 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
9617 /* It's an include file, no symbols to read for it.
9618 Everything is in the parent symtab. */
9623 dw2_do_instantiate_symtab (per_cu, false);
9626 /* Trivial hash function for die_info: the hash value of a DIE
9627 is its offset in .debug_info for this objfile. */
9630 die_hash (const void *item)
9632 const struct die_info *die = (const struct die_info *) item;
9634 return to_underlying (die->sect_off);
9637 /* Trivial comparison function for die_info structures: two DIEs
9638 are equal if they have the same offset. */
9641 die_eq (const void *item_lhs, const void *item_rhs)
9643 const struct die_info *die_lhs = (const struct die_info *) item_lhs;
9644 const struct die_info *die_rhs = (const struct die_info *) item_rhs;
9646 return die_lhs->sect_off == die_rhs->sect_off;
9649 /* die_reader_func for load_full_comp_unit.
9650 This is identical to read_signatured_type_reader,
9651 but is kept separate for now. */
9654 load_full_comp_unit_reader (const struct die_reader_specs *reader,
9655 const gdb_byte *info_ptr,
9656 struct die_info *comp_unit_die,
9660 struct dwarf2_cu *cu = reader->cu;
9661 enum language *language_ptr = (enum language *) data;
9663 gdb_assert (cu->die_hash == NULL);
9665 htab_create_alloc_ex (cu->header.length / 12,
9669 &cu->comp_unit_obstack,
9670 hashtab_obstack_allocate,
9671 dummy_obstack_deallocate);
9674 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
9675 &info_ptr, comp_unit_die);
9676 cu->dies = comp_unit_die;
9677 /* comp_unit_die is not stored in die_hash, no need. */
9679 /* We try not to read any attributes in this function, because not
9680 all CUs needed for references have been loaded yet, and symbol
9681 table processing isn't initialized. But we have to set the CU language,
9682 or we won't be able to build types correctly.
9683 Similarly, if we do not read the producer, we can not apply
9684 producer-specific interpretation. */
9685 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
9688 /* Load the DIEs associated with PER_CU into memory. */
9691 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
9693 enum language pretend_language)
9695 gdb_assert (! this_cu->is_debug_types);
9697 init_cutu_and_read_dies (this_cu, NULL, 1, 1, skip_partial,
9698 load_full_comp_unit_reader, &pretend_language);
9701 /* Add a DIE to the delayed physname list. */
9704 add_to_method_list (struct type *type, int fnfield_index, int index,
9705 const char *name, struct die_info *die,
9706 struct dwarf2_cu *cu)
9708 struct delayed_method_info mi;
9710 mi.fnfield_index = fnfield_index;
9714 cu->method_list.push_back (mi);
9717 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9718 "const" / "volatile". If so, decrements LEN by the length of the
9719 modifier and return true. Otherwise return false. */
9723 check_modifier (const char *physname, size_t &len, const char (&mod)[N])
9725 size_t mod_len = sizeof (mod) - 1;
9726 if (len > mod_len && startswith (physname + (len - mod_len), mod))
9734 /* Compute the physnames of any methods on the CU's method list.
9736 The computation of method physnames is delayed in order to avoid the
9737 (bad) condition that one of the method's formal parameters is of an as yet
9741 compute_delayed_physnames (struct dwarf2_cu *cu)
9743 /* Only C++ delays computing physnames. */
9744 if (cu->method_list.empty ())
9746 gdb_assert (cu->language == language_cplus);
9748 for (const delayed_method_info &mi : cu->method_list)
9750 const char *physname;
9751 struct fn_fieldlist *fn_flp
9752 = &TYPE_FN_FIELDLIST (mi.type, mi.fnfield_index);
9753 physname = dwarf2_physname (mi.name, mi.die, cu);
9754 TYPE_FN_FIELD_PHYSNAME (fn_flp->fn_fields, mi.index)
9755 = physname ? physname : "";
9757 /* Since there's no tag to indicate whether a method is a
9758 const/volatile overload, extract that information out of the
9760 if (physname != NULL)
9762 size_t len = strlen (physname);
9766 if (physname[len] == ')') /* shortcut */
9768 else if (check_modifier (physname, len, " const"))
9769 TYPE_FN_FIELD_CONST (fn_flp->fn_fields, mi.index) = 1;
9770 else if (check_modifier (physname, len, " volatile"))
9771 TYPE_FN_FIELD_VOLATILE (fn_flp->fn_fields, mi.index) = 1;
9778 /* The list is no longer needed. */
9779 cu->method_list.clear ();
9782 /* A wrapper for add_symbol_to_list to ensure that SYMBOL's language is
9783 the same as all other symbols in LISTHEAD. If a new symbol is added
9784 with a different language, this function asserts. */
9787 dw2_add_symbol_to_list (struct symbol *symbol, struct pending **listhead)
9789 /* Only assert if LISTHEAD already contains symbols of a different
9790 language (dict_create_hashed/insert_symbol_hashed requires that all
9791 symbols in this list are of the same language). */
9792 gdb_assert ((*listhead) == NULL
9793 || (SYMBOL_LANGUAGE ((*listhead)->symbol[0])
9794 == SYMBOL_LANGUAGE (symbol)));
9796 add_symbol_to_list (symbol, listhead);
9799 /* Go objects should be embedded in a DW_TAG_module DIE,
9800 and it's not clear if/how imported objects will appear.
9801 To keep Go support simple until that's worked out,
9802 go back through what we've read and create something usable.
9803 We could do this while processing each DIE, and feels kinda cleaner,
9804 but that way is more invasive.
9805 This is to, for example, allow the user to type "p var" or "b main"
9806 without having to specify the package name, and allow lookups
9807 of module.object to work in contexts that use the expression
9811 fixup_go_packaging (struct dwarf2_cu *cu)
9813 char *package_name = NULL;
9814 struct pending *list;
9817 for (list = *cu->builder->get_global_symbols ();
9821 for (i = 0; i < list->nsyms; ++i)
9823 struct symbol *sym = list->symbol[i];
9825 if (SYMBOL_LANGUAGE (sym) == language_go
9826 && SYMBOL_CLASS (sym) == LOC_BLOCK)
9828 char *this_package_name = go_symbol_package_name (sym);
9830 if (this_package_name == NULL)
9832 if (package_name == NULL)
9833 package_name = this_package_name;
9836 struct objfile *objfile
9837 = cu->per_cu->dwarf2_per_objfile->objfile;
9838 if (strcmp (package_name, this_package_name) != 0)
9839 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9840 (symbol_symtab (sym) != NULL
9841 ? symtab_to_filename_for_display
9842 (symbol_symtab (sym))
9843 : objfile_name (objfile)),
9844 this_package_name, package_name);
9845 xfree (this_package_name);
9851 if (package_name != NULL)
9853 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9854 const char *saved_package_name
9855 = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
9857 strlen (package_name));
9858 struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
9859 saved_package_name);
9862 sym = allocate_symbol (objfile);
9863 SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
9864 SYMBOL_SET_NAMES (sym, saved_package_name,
9865 strlen (saved_package_name), 0, objfile);
9866 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9867 e.g., "main" finds the "main" module and not C's main(). */
9868 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
9869 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
9870 SYMBOL_TYPE (sym) = type;
9872 dw2_add_symbol_to_list (sym, cu->builder->get_global_symbols ());
9874 xfree (package_name);
9878 /* Allocate a fully-qualified name consisting of the two parts on the
9882 rust_fully_qualify (struct obstack *obstack, const char *p1, const char *p2)
9884 return obconcat (obstack, p1, "::", p2, (char *) NULL);
9887 /* A helper that allocates a struct discriminant_info to attach to a
9890 static struct discriminant_info *
9891 alloc_discriminant_info (struct type *type, int discriminant_index,
9894 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9895 gdb_assert (discriminant_index == -1
9896 || (discriminant_index >= 0
9897 && discriminant_index < TYPE_NFIELDS (type)));
9898 gdb_assert (default_index == -1
9899 || (default_index >= 0 && default_index < TYPE_NFIELDS (type)));
9901 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
9903 struct discriminant_info *disc
9904 = ((struct discriminant_info *)
9906 offsetof (struct discriminant_info, discriminants)
9907 + TYPE_NFIELDS (type) * sizeof (disc->discriminants[0])));
9908 disc->default_index = default_index;
9909 disc->discriminant_index = discriminant_index;
9911 struct dynamic_prop prop;
9912 prop.kind = PROP_UNDEFINED;
9913 prop.data.baton = disc;
9915 add_dyn_prop (DYN_PROP_DISCRIMINATED, prop, type);
9920 /* Some versions of rustc emitted enums in an unusual way.
9922 Ordinary enums were emitted as unions. The first element of each
9923 structure in the union was named "RUST$ENUM$DISR". This element
9924 held the discriminant.
9926 These versions of Rust also implemented the "non-zero"
9927 optimization. When the enum had two values, and one is empty and
9928 the other holds a pointer that cannot be zero, the pointer is used
9929 as the discriminant, with a zero value meaning the empty variant.
9930 Here, the union's first member is of the form
9931 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9932 where the fieldnos are the indices of the fields that should be
9933 traversed in order to find the field (which may be several fields deep)
9934 and the variantname is the name of the variant of the case when the
9937 This function recognizes whether TYPE is of one of these forms,
9938 and, if so, smashes it to be a variant type. */
9941 quirk_rust_enum (struct type *type, struct objfile *objfile)
9943 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9945 /* We don't need to deal with empty enums. */
9946 if (TYPE_NFIELDS (type) == 0)
9949 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9950 if (TYPE_NFIELDS (type) == 1
9951 && startswith (TYPE_FIELD_NAME (type, 0), RUST_ENUM_PREFIX))
9953 const char *name = TYPE_FIELD_NAME (type, 0) + strlen (RUST_ENUM_PREFIX);
9955 /* Decode the field name to find the offset of the
9957 ULONGEST bit_offset = 0;
9958 struct type *field_type = TYPE_FIELD_TYPE (type, 0);
9959 while (name[0] >= '0' && name[0] <= '9')
9962 unsigned long index = strtoul (name, &tail, 10);
9965 || index >= TYPE_NFIELDS (field_type)
9966 || (TYPE_FIELD_LOC_KIND (field_type, index)
9967 != FIELD_LOC_KIND_BITPOS))
9969 complaint (_("Could not parse Rust enum encoding string \"%s\""
9971 TYPE_FIELD_NAME (type, 0),
9972 objfile_name (objfile));
9977 bit_offset += TYPE_FIELD_BITPOS (field_type, index);
9978 field_type = TYPE_FIELD_TYPE (field_type, index);
9981 /* Make a union to hold the variants. */
9982 struct type *union_type = alloc_type (objfile);
9983 TYPE_CODE (union_type) = TYPE_CODE_UNION;
9984 TYPE_NFIELDS (union_type) = 3;
9985 TYPE_FIELDS (union_type)
9986 = (struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field));
9987 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
9988 set_type_align (union_type, TYPE_RAW_ALIGN (type));
9990 /* Put the discriminant must at index 0. */
9991 TYPE_FIELD_TYPE (union_type, 0) = field_type;
9992 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
9993 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
9994 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 0), bit_offset);
9996 /* The order of fields doesn't really matter, so put the real
9997 field at index 1 and the data-less field at index 2. */
9998 struct discriminant_info *disc
9999 = alloc_discriminant_info (union_type, 0, 1);
10000 TYPE_FIELD (union_type, 1) = TYPE_FIELD (type, 0);
10001 TYPE_FIELD_NAME (union_type, 1)
10002 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1)));
10003 TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1))
10004 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10005 TYPE_FIELD_NAME (union_type, 1));
10007 const char *dataless_name
10008 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10010 struct type *dataless_type = init_type (objfile, TYPE_CODE_VOID, 0,
10012 TYPE_FIELD_TYPE (union_type, 2) = dataless_type;
10013 /* NAME points into the original discriminant name, which
10014 already has the correct lifetime. */
10015 TYPE_FIELD_NAME (union_type, 2) = name;
10016 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 2), 0);
10017 disc->discriminants[2] = 0;
10019 /* Smash this type to be a structure type. We have to do this
10020 because the type has already been recorded. */
10021 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10022 TYPE_NFIELDS (type) = 1;
10024 = (struct field *) TYPE_ZALLOC (type, sizeof (struct field));
10026 /* Install the variant part. */
10027 TYPE_FIELD_TYPE (type, 0) = union_type;
10028 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10029 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10031 else if (TYPE_NFIELDS (type) == 1)
10033 /* We assume that a union with a single field is a univariant
10035 /* Smash this type to be a structure type. We have to do this
10036 because the type has already been recorded. */
10037 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10039 /* Make a union to hold the variants. */
10040 struct type *union_type = alloc_type (objfile);
10041 TYPE_CODE (union_type) = TYPE_CODE_UNION;
10042 TYPE_NFIELDS (union_type) = TYPE_NFIELDS (type);
10043 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10044 set_type_align (union_type, TYPE_RAW_ALIGN (type));
10045 TYPE_FIELDS (union_type) = TYPE_FIELDS (type);
10047 struct type *field_type = TYPE_FIELD_TYPE (union_type, 0);
10048 const char *variant_name
10049 = rust_last_path_segment (TYPE_NAME (field_type));
10050 TYPE_FIELD_NAME (union_type, 0) = variant_name;
10051 TYPE_NAME (field_type)
10052 = rust_fully_qualify (&objfile->objfile_obstack,
10053 TYPE_NAME (type), variant_name);
10055 /* Install the union in the outer struct type. */
10056 TYPE_NFIELDS (type) = 1;
10058 = (struct field *) TYPE_ZALLOC (union_type, sizeof (struct field));
10059 TYPE_FIELD_TYPE (type, 0) = union_type;
10060 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10061 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10063 alloc_discriminant_info (union_type, -1, 0);
10067 struct type *disr_type = nullptr;
10068 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
10070 disr_type = TYPE_FIELD_TYPE (type, i);
10072 if (TYPE_CODE (disr_type) != TYPE_CODE_STRUCT)
10074 /* All fields of a true enum will be structs. */
10077 else if (TYPE_NFIELDS (disr_type) == 0)
10079 /* Could be data-less variant, so keep going. */
10080 disr_type = nullptr;
10082 else if (strcmp (TYPE_FIELD_NAME (disr_type, 0),
10083 "RUST$ENUM$DISR") != 0)
10085 /* Not a Rust enum. */
10095 /* If we got here without a discriminant, then it's probably
10097 if (disr_type == nullptr)
10100 /* Smash this type to be a structure type. We have to do this
10101 because the type has already been recorded. */
10102 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10104 /* Make a union to hold the variants. */
10105 struct field *disr_field = &TYPE_FIELD (disr_type, 0);
10106 struct type *union_type = alloc_type (objfile);
10107 TYPE_CODE (union_type) = TYPE_CODE_UNION;
10108 TYPE_NFIELDS (union_type) = 1 + TYPE_NFIELDS (type);
10109 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10110 set_type_align (union_type, TYPE_RAW_ALIGN (type));
10111 TYPE_FIELDS (union_type)
10112 = (struct field *) TYPE_ZALLOC (union_type,
10113 (TYPE_NFIELDS (union_type)
10114 * sizeof (struct field)));
10116 memcpy (TYPE_FIELDS (union_type) + 1, TYPE_FIELDS (type),
10117 TYPE_NFIELDS (type) * sizeof (struct field));
10119 /* Install the discriminant at index 0 in the union. */
10120 TYPE_FIELD (union_type, 0) = *disr_field;
10121 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10122 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10124 /* Install the union in the outer struct type. */
10125 TYPE_FIELD_TYPE (type, 0) = union_type;
10126 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10127 TYPE_NFIELDS (type) = 1;
10129 /* Set the size and offset of the union type. */
10130 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10132 /* We need a way to find the correct discriminant given a
10133 variant name. For convenience we build a map here. */
10134 struct type *enum_type = FIELD_TYPE (*disr_field);
10135 std::unordered_map<std::string, ULONGEST> discriminant_map;
10136 for (int i = 0; i < TYPE_NFIELDS (enum_type); ++i)
10138 if (TYPE_FIELD_LOC_KIND (enum_type, i) == FIELD_LOC_KIND_ENUMVAL)
10141 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type, i));
10142 discriminant_map[name] = TYPE_FIELD_ENUMVAL (enum_type, i);
10146 int n_fields = TYPE_NFIELDS (union_type);
10147 struct discriminant_info *disc
10148 = alloc_discriminant_info (union_type, 0, -1);
10149 /* Skip the discriminant here. */
10150 for (int i = 1; i < n_fields; ++i)
10152 /* Find the final word in the name of this variant's type.
10153 That name can be used to look up the correct
10155 const char *variant_name
10156 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type,
10159 auto iter = discriminant_map.find (variant_name);
10160 if (iter != discriminant_map.end ())
10161 disc->discriminants[i] = iter->second;
10163 /* Remove the discriminant field, if it exists. */
10164 struct type *sub_type = TYPE_FIELD_TYPE (union_type, i);
10165 if (TYPE_NFIELDS (sub_type) > 0)
10167 --TYPE_NFIELDS (sub_type);
10168 ++TYPE_FIELDS (sub_type);
10170 TYPE_FIELD_NAME (union_type, i) = variant_name;
10171 TYPE_NAME (sub_type)
10172 = rust_fully_qualify (&objfile->objfile_obstack,
10173 TYPE_NAME (type), variant_name);
10178 /* Rewrite some Rust unions to be structures with variants parts. */
10181 rust_union_quirks (struct dwarf2_cu *cu)
10183 gdb_assert (cu->language == language_rust);
10184 for (type *type_ : cu->rust_unions)
10185 quirk_rust_enum (type_, cu->per_cu->dwarf2_per_objfile->objfile);
10186 /* We don't need this any more. */
10187 cu->rust_unions.clear ();
10190 /* Return the symtab for PER_CU. This works properly regardless of
10191 whether we're using the index or psymtabs. */
10193 static struct compunit_symtab *
10194 get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
10196 return (per_cu->dwarf2_per_objfile->using_index
10197 ? per_cu->v.quick->compunit_symtab
10198 : per_cu->v.psymtab->compunit_symtab);
10201 /* A helper function for computing the list of all symbol tables
10202 included by PER_CU. */
10205 recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
10206 htab_t all_children, htab_t all_type_symtabs,
10207 struct dwarf2_per_cu_data *per_cu,
10208 struct compunit_symtab *immediate_parent)
10212 struct compunit_symtab *cust;
10213 struct dwarf2_per_cu_data *iter;
10215 slot = htab_find_slot (all_children, per_cu, INSERT);
10218 /* This inclusion and its children have been processed. */
10223 /* Only add a CU if it has a symbol table. */
10224 cust = get_compunit_symtab (per_cu);
10227 /* If this is a type unit only add its symbol table if we haven't
10228 seen it yet (type unit per_cu's can share symtabs). */
10229 if (per_cu->is_debug_types)
10231 slot = htab_find_slot (all_type_symtabs, cust, INSERT);
10235 result->push_back (cust);
10236 if (cust->user == NULL)
10237 cust->user = immediate_parent;
10242 result->push_back (cust);
10243 if (cust->user == NULL)
10244 cust->user = immediate_parent;
10249 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
10252 recursively_compute_inclusions (result, all_children,
10253 all_type_symtabs, iter, cust);
10257 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10261 compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
10263 gdb_assert (! per_cu->is_debug_types);
10265 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
10268 struct dwarf2_per_cu_data *per_cu_iter;
10269 std::vector<compunit_symtab *> result_symtabs;
10270 htab_t all_children, all_type_symtabs;
10271 struct compunit_symtab *cust = get_compunit_symtab (per_cu);
10273 /* If we don't have a symtab, we can just skip this case. */
10277 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10278 NULL, xcalloc, xfree);
10279 all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10280 NULL, xcalloc, xfree);
10283 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
10287 recursively_compute_inclusions (&result_symtabs, all_children,
10288 all_type_symtabs, per_cu_iter,
10292 /* Now we have a transitive closure of all the included symtabs. */
10293 len = result_symtabs.size ();
10295 = XOBNEWVEC (&per_cu->dwarf2_per_objfile->objfile->objfile_obstack,
10296 struct compunit_symtab *, len + 1);
10297 memcpy (cust->includes, result_symtabs.data (),
10298 len * sizeof (compunit_symtab *));
10299 cust->includes[len] = NULL;
10301 htab_delete (all_children);
10302 htab_delete (all_type_symtabs);
10306 /* Compute the 'includes' field for the symtabs of all the CUs we just
10310 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
10312 for (dwarf2_per_cu_data *iter : dwarf2_per_objfile->just_read_cus)
10314 if (! iter->is_debug_types)
10315 compute_compunit_symtab_includes (iter);
10318 dwarf2_per_objfile->just_read_cus.clear ();
10321 /* Generate full symbol information for PER_CU, whose DIEs have
10322 already been loaded into memory. */
10325 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
10326 enum language pretend_language)
10328 struct dwarf2_cu *cu = per_cu->cu;
10329 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10330 struct objfile *objfile = dwarf2_per_objfile->objfile;
10331 struct gdbarch *gdbarch = get_objfile_arch (objfile);
10332 CORE_ADDR lowpc, highpc;
10333 struct compunit_symtab *cust;
10334 CORE_ADDR baseaddr;
10335 struct block *static_block;
10338 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
10340 /* Clear the list here in case something was left over. */
10341 cu->method_list.clear ();
10343 cu->language = pretend_language;
10344 cu->language_defn = language_def (cu->language);
10346 /* Do line number decoding in read_file_scope () */
10347 process_die (cu->dies, cu);
10349 /* For now fudge the Go package. */
10350 if (cu->language == language_go)
10351 fixup_go_packaging (cu);
10353 /* Now that we have processed all the DIEs in the CU, all the types
10354 should be complete, and it should now be safe to compute all of the
10356 compute_delayed_physnames (cu);
10358 if (cu->language == language_rust)
10359 rust_union_quirks (cu);
10361 /* Some compilers don't define a DW_AT_high_pc attribute for the
10362 compilation unit. If the DW_AT_high_pc is missing, synthesize
10363 it, by scanning the DIE's below the compilation unit. */
10364 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
10366 addr = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
10367 static_block = cu->builder->end_symtab_get_static_block (addr, 0, 1);
10369 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10370 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10371 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10372 addrmap to help ensure it has an accurate map of pc values belonging to
10374 dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
10376 cust = cu->builder->end_symtab_from_static_block (static_block,
10377 SECT_OFF_TEXT (objfile),
10382 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
10384 /* Set symtab language to language from DW_AT_language. If the
10385 compilation is from a C file generated by language preprocessors, do
10386 not set the language if it was already deduced by start_subfile. */
10387 if (!(cu->language == language_c
10388 && COMPUNIT_FILETABS (cust)->language != language_unknown))
10389 COMPUNIT_FILETABS (cust)->language = cu->language;
10391 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10392 produce DW_AT_location with location lists but it can be possibly
10393 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10394 there were bugs in prologue debug info, fixed later in GCC-4.5
10395 by "unwind info for epilogues" patch (which is not directly related).
10397 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10398 needed, it would be wrong due to missing DW_AT_producer there.
10400 Still one can confuse GDB by using non-standard GCC compilation
10401 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10403 if (cu->has_loclist && gcc_4_minor >= 5)
10404 cust->locations_valid = 1;
10406 if (gcc_4_minor >= 5)
10407 cust->epilogue_unwind_valid = 1;
10409 cust->call_site_htab = cu->call_site_htab;
10412 if (dwarf2_per_objfile->using_index)
10413 per_cu->v.quick->compunit_symtab = cust;
10416 struct partial_symtab *pst = per_cu->v.psymtab;
10417 pst->compunit_symtab = cust;
10421 /* Push it for inclusion processing later. */
10422 dwarf2_per_objfile->just_read_cus.push_back (per_cu);
10424 /* Not needed any more. */
10425 cu->builder.reset ();
10428 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10429 already been loaded into memory. */
10432 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
10433 enum language pretend_language)
10435 struct dwarf2_cu *cu = per_cu->cu;
10436 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10437 struct objfile *objfile = dwarf2_per_objfile->objfile;
10438 struct compunit_symtab *cust;
10439 struct signatured_type *sig_type;
10441 gdb_assert (per_cu->is_debug_types);
10442 sig_type = (struct signatured_type *) per_cu;
10444 /* Clear the list here in case something was left over. */
10445 cu->method_list.clear ();
10447 cu->language = pretend_language;
10448 cu->language_defn = language_def (cu->language);
10450 /* The symbol tables are set up in read_type_unit_scope. */
10451 process_die (cu->dies, cu);
10453 /* For now fudge the Go package. */
10454 if (cu->language == language_go)
10455 fixup_go_packaging (cu);
10457 /* Now that we have processed all the DIEs in the CU, all the types
10458 should be complete, and it should now be safe to compute all of the
10460 compute_delayed_physnames (cu);
10462 if (cu->language == language_rust)
10463 rust_union_quirks (cu);
10465 /* TUs share symbol tables.
10466 If this is the first TU to use this symtab, complete the construction
10467 of it with end_expandable_symtab. Otherwise, complete the addition of
10468 this TU's symbols to the existing symtab. */
10469 if (sig_type->type_unit_group->compunit_symtab == NULL)
10471 cust = cu->builder->end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
10472 sig_type->type_unit_group->compunit_symtab = cust;
10476 /* Set symtab language to language from DW_AT_language. If the
10477 compilation is from a C file generated by language preprocessors,
10478 do not set the language if it was already deduced by
10480 if (!(cu->language == language_c
10481 && COMPUNIT_FILETABS (cust)->language != language_c))
10482 COMPUNIT_FILETABS (cust)->language = cu->language;
10487 cu->builder->augment_type_symtab ();
10488 cust = sig_type->type_unit_group->compunit_symtab;
10491 if (dwarf2_per_objfile->using_index)
10492 per_cu->v.quick->compunit_symtab = cust;
10495 struct partial_symtab *pst = per_cu->v.psymtab;
10496 pst->compunit_symtab = cust;
10500 /* Not needed any more. */
10501 cu->builder.reset ();
10504 /* Process an imported unit DIE. */
10507 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
10509 struct attribute *attr;
10511 /* For now we don't handle imported units in type units. */
10512 if (cu->per_cu->is_debug_types)
10514 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10515 " supported in type units [in module %s]"),
10516 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
10519 attr = dwarf2_attr (die, DW_AT_import, cu);
10522 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
10523 bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
10524 dwarf2_per_cu_data *per_cu
10525 = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
10526 cu->per_cu->dwarf2_per_objfile);
10528 /* If necessary, add it to the queue and load its DIEs. */
10529 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
10530 load_full_comp_unit (per_cu, false, cu->language);
10532 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
10537 /* RAII object that represents a process_die scope: i.e.,
10538 starts/finishes processing a DIE. */
10539 class process_die_scope
10542 process_die_scope (die_info *die, dwarf2_cu *cu)
10543 : m_die (die), m_cu (cu)
10545 /* We should only be processing DIEs not already in process. */
10546 gdb_assert (!m_die->in_process);
10547 m_die->in_process = true;
10550 ~process_die_scope ()
10552 m_die->in_process = false;
10554 /* If we're done processing the DIE for the CU that owns the line
10555 header, we don't need the line header anymore. */
10556 if (m_cu->line_header_die_owner == m_die)
10558 delete m_cu->line_header;
10559 m_cu->line_header = NULL;
10560 m_cu->line_header_die_owner = NULL;
10569 /* Process a die and its children. */
10572 process_die (struct die_info *die, struct dwarf2_cu *cu)
10574 process_die_scope scope (die, cu);
10578 case DW_TAG_padding:
10580 case DW_TAG_compile_unit:
10581 case DW_TAG_partial_unit:
10582 read_file_scope (die, cu);
10584 case DW_TAG_type_unit:
10585 read_type_unit_scope (die, cu);
10587 case DW_TAG_subprogram:
10588 case DW_TAG_inlined_subroutine:
10589 read_func_scope (die, cu);
10591 case DW_TAG_lexical_block:
10592 case DW_TAG_try_block:
10593 case DW_TAG_catch_block:
10594 read_lexical_block_scope (die, cu);
10596 case DW_TAG_call_site:
10597 case DW_TAG_GNU_call_site:
10598 read_call_site_scope (die, cu);
10600 case DW_TAG_class_type:
10601 case DW_TAG_interface_type:
10602 case DW_TAG_structure_type:
10603 case DW_TAG_union_type:
10604 process_structure_scope (die, cu);
10606 case DW_TAG_enumeration_type:
10607 process_enumeration_scope (die, cu);
10610 /* These dies have a type, but processing them does not create
10611 a symbol or recurse to process the children. Therefore we can
10612 read them on-demand through read_type_die. */
10613 case DW_TAG_subroutine_type:
10614 case DW_TAG_set_type:
10615 case DW_TAG_array_type:
10616 case DW_TAG_pointer_type:
10617 case DW_TAG_ptr_to_member_type:
10618 case DW_TAG_reference_type:
10619 case DW_TAG_rvalue_reference_type:
10620 case DW_TAG_string_type:
10623 case DW_TAG_base_type:
10624 case DW_TAG_subrange_type:
10625 case DW_TAG_typedef:
10626 /* Add a typedef symbol for the type definition, if it has a
10628 new_symbol (die, read_type_die (die, cu), cu);
10630 case DW_TAG_common_block:
10631 read_common_block (die, cu);
10633 case DW_TAG_common_inclusion:
10635 case DW_TAG_namespace:
10636 cu->processing_has_namespace_info = true;
10637 read_namespace (die, cu);
10639 case DW_TAG_module:
10640 cu->processing_has_namespace_info = true;
10641 read_module (die, cu);
10643 case DW_TAG_imported_declaration:
10644 cu->processing_has_namespace_info = true;
10645 if (read_namespace_alias (die, cu))
10647 /* The declaration is not a global namespace alias. */
10648 /* Fall through. */
10649 case DW_TAG_imported_module:
10650 cu->processing_has_namespace_info = true;
10651 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
10652 || cu->language != language_fortran))
10653 complaint (_("Tag '%s' has unexpected children"),
10654 dwarf_tag_name (die->tag));
10655 read_import_statement (die, cu);
10658 case DW_TAG_imported_unit:
10659 process_imported_unit_die (die, cu);
10662 case DW_TAG_variable:
10663 read_variable (die, cu);
10667 new_symbol (die, NULL, cu);
10672 /* DWARF name computation. */
10674 /* A helper function for dwarf2_compute_name which determines whether DIE
10675 needs to have the name of the scope prepended to the name listed in the
10679 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
10681 struct attribute *attr;
10685 case DW_TAG_namespace:
10686 case DW_TAG_typedef:
10687 case DW_TAG_class_type:
10688 case DW_TAG_interface_type:
10689 case DW_TAG_structure_type:
10690 case DW_TAG_union_type:
10691 case DW_TAG_enumeration_type:
10692 case DW_TAG_enumerator:
10693 case DW_TAG_subprogram:
10694 case DW_TAG_inlined_subroutine:
10695 case DW_TAG_member:
10696 case DW_TAG_imported_declaration:
10699 case DW_TAG_variable:
10700 case DW_TAG_constant:
10701 /* We only need to prefix "globally" visible variables. These include
10702 any variable marked with DW_AT_external or any variable that
10703 lives in a namespace. [Variables in anonymous namespaces
10704 require prefixing, but they are not DW_AT_external.] */
10706 if (dwarf2_attr (die, DW_AT_specification, cu))
10708 struct dwarf2_cu *spec_cu = cu;
10710 return die_needs_namespace (die_specification (die, &spec_cu),
10714 attr = dwarf2_attr (die, DW_AT_external, cu);
10715 if (attr == NULL && die->parent->tag != DW_TAG_namespace
10716 && die->parent->tag != DW_TAG_module)
10718 /* A variable in a lexical block of some kind does not need a
10719 namespace, even though in C++ such variables may be external
10720 and have a mangled name. */
10721 if (die->parent->tag == DW_TAG_lexical_block
10722 || die->parent->tag == DW_TAG_try_block
10723 || die->parent->tag == DW_TAG_catch_block
10724 || die->parent->tag == DW_TAG_subprogram)
10733 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10734 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10735 defined for the given DIE. */
10737 static struct attribute *
10738 dw2_linkage_name_attr (struct die_info *die, struct dwarf2_cu *cu)
10740 struct attribute *attr;
10742 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
10744 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
10749 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10750 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10751 defined for the given DIE. */
10753 static const char *
10754 dw2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
10756 const char *linkage_name;
10758 linkage_name = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
10759 if (linkage_name == NULL)
10760 linkage_name = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
10762 return linkage_name;
10765 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10766 compute the physname for the object, which include a method's:
10767 - formal parameters (C++),
10768 - receiver type (Go),
10770 The term "physname" is a bit confusing.
10771 For C++, for example, it is the demangled name.
10772 For Go, for example, it's the mangled name.
10774 For Ada, return the DIE's linkage name rather than the fully qualified
10775 name. PHYSNAME is ignored..
10777 The result is allocated on the objfile_obstack and canonicalized. */
10779 static const char *
10780 dwarf2_compute_name (const char *name,
10781 struct die_info *die, struct dwarf2_cu *cu,
10784 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10787 name = dwarf2_name (die, cu);
10789 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10790 but otherwise compute it by typename_concat inside GDB.
10791 FIXME: Actually this is not really true, or at least not always true.
10792 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
10793 Fortran names because there is no mangling standard. So new_symbol
10794 will set the demangled name to the result of dwarf2_full_name, and it is
10795 the demangled name that GDB uses if it exists. */
10796 if (cu->language == language_ada
10797 || (cu->language == language_fortran && physname))
10799 /* For Ada unit, we prefer the linkage name over the name, as
10800 the former contains the exported name, which the user expects
10801 to be able to reference. Ideally, we want the user to be able
10802 to reference this entity using either natural or linkage name,
10803 but we haven't started looking at this enhancement yet. */
10804 const char *linkage_name = dw2_linkage_name (die, cu);
10806 if (linkage_name != NULL)
10807 return linkage_name;
10810 /* These are the only languages we know how to qualify names in. */
10812 && (cu->language == language_cplus
10813 || cu->language == language_fortran || cu->language == language_d
10814 || cu->language == language_rust))
10816 if (die_needs_namespace (die, cu))
10818 const char *prefix;
10819 const char *canonical_name = NULL;
10823 prefix = determine_prefix (die, cu);
10824 if (*prefix != '\0')
10826 char *prefixed_name = typename_concat (NULL, prefix, name,
10829 buf.puts (prefixed_name);
10830 xfree (prefixed_name);
10835 /* Template parameters may be specified in the DIE's DW_AT_name, or
10836 as children with DW_TAG_template_type_param or
10837 DW_TAG_value_type_param. If the latter, add them to the name
10838 here. If the name already has template parameters, then
10839 skip this step; some versions of GCC emit both, and
10840 it is more efficient to use the pre-computed name.
10842 Something to keep in mind about this process: it is very
10843 unlikely, or in some cases downright impossible, to produce
10844 something that will match the mangled name of a function.
10845 If the definition of the function has the same debug info,
10846 we should be able to match up with it anyway. But fallbacks
10847 using the minimal symbol, for instance to find a method
10848 implemented in a stripped copy of libstdc++, will not work.
10849 If we do not have debug info for the definition, we will have to
10850 match them up some other way.
10852 When we do name matching there is a related problem with function
10853 templates; two instantiated function templates are allowed to
10854 differ only by their return types, which we do not add here. */
10856 if (cu->language == language_cplus && strchr (name, '<') == NULL)
10858 struct attribute *attr;
10859 struct die_info *child;
10862 die->building_fullname = 1;
10864 for (child = die->child; child != NULL; child = child->sibling)
10868 const gdb_byte *bytes;
10869 struct dwarf2_locexpr_baton *baton;
10872 if (child->tag != DW_TAG_template_type_param
10873 && child->tag != DW_TAG_template_value_param)
10884 attr = dwarf2_attr (child, DW_AT_type, cu);
10887 complaint (_("template parameter missing DW_AT_type"));
10888 buf.puts ("UNKNOWN_TYPE");
10891 type = die_type (child, cu);
10893 if (child->tag == DW_TAG_template_type_param)
10895 c_print_type (type, "", &buf, -1, 0, cu->language,
10896 &type_print_raw_options);
10900 attr = dwarf2_attr (child, DW_AT_const_value, cu);
10903 complaint (_("template parameter missing "
10904 "DW_AT_const_value"));
10905 buf.puts ("UNKNOWN_VALUE");
10909 dwarf2_const_value_attr (attr, type, name,
10910 &cu->comp_unit_obstack, cu,
10911 &value, &bytes, &baton);
10913 if (TYPE_NOSIGN (type))
10914 /* GDB prints characters as NUMBER 'CHAR'. If that's
10915 changed, this can use value_print instead. */
10916 c_printchar (value, type, &buf);
10919 struct value_print_options opts;
10922 v = dwarf2_evaluate_loc_desc (type, NULL,
10926 else if (bytes != NULL)
10928 v = allocate_value (type);
10929 memcpy (value_contents_writeable (v), bytes,
10930 TYPE_LENGTH (type));
10933 v = value_from_longest (type, value);
10935 /* Specify decimal so that we do not depend on
10937 get_formatted_print_options (&opts, 'd');
10939 value_print (v, &buf, &opts);
10944 die->building_fullname = 0;
10948 /* Close the argument list, with a space if necessary
10949 (nested templates). */
10950 if (!buf.empty () && buf.string ().back () == '>')
10957 /* For C++ methods, append formal parameter type
10958 information, if PHYSNAME. */
10960 if (physname && die->tag == DW_TAG_subprogram
10961 && cu->language == language_cplus)
10963 struct type *type = read_type_die (die, cu);
10965 c_type_print_args (type, &buf, 1, cu->language,
10966 &type_print_raw_options);
10968 if (cu->language == language_cplus)
10970 /* Assume that an artificial first parameter is
10971 "this", but do not crash if it is not. RealView
10972 marks unnamed (and thus unused) parameters as
10973 artificial; there is no way to differentiate
10975 if (TYPE_NFIELDS (type) > 0
10976 && TYPE_FIELD_ARTIFICIAL (type, 0)
10977 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
10978 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
10980 buf.puts (" const");
10984 const std::string &intermediate_name = buf.string ();
10986 if (cu->language == language_cplus)
10988 = dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
10989 &objfile->per_bfd->storage_obstack);
10991 /* If we only computed INTERMEDIATE_NAME, or if
10992 INTERMEDIATE_NAME is already canonical, then we need to
10993 copy it to the appropriate obstack. */
10994 if (canonical_name == NULL || canonical_name == intermediate_name.c_str ())
10995 name = ((const char *)
10996 obstack_copy0 (&objfile->per_bfd->storage_obstack,
10997 intermediate_name.c_str (),
10998 intermediate_name.length ()));
11000 name = canonical_name;
11007 /* Return the fully qualified name of DIE, based on its DW_AT_name.
11008 If scope qualifiers are appropriate they will be added. The result
11009 will be allocated on the storage_obstack, or NULL if the DIE does
11010 not have a name. NAME may either be from a previous call to
11011 dwarf2_name or NULL.
11013 The output string will be canonicalized (if C++). */
11015 static const char *
11016 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11018 return dwarf2_compute_name (name, die, cu, 0);
11021 /* Construct a physname for the given DIE in CU. NAME may either be
11022 from a previous call to dwarf2_name or NULL. The result will be
11023 allocated on the objfile_objstack or NULL if the DIE does not have a
11026 The output string will be canonicalized (if C++). */
11028 static const char *
11029 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11031 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11032 const char *retval, *mangled = NULL, *canon = NULL;
11035 /* In this case dwarf2_compute_name is just a shortcut not building anything
11037 if (!die_needs_namespace (die, cu))
11038 return dwarf2_compute_name (name, die, cu, 1);
11040 mangled = dw2_linkage_name (die, cu);
11042 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
11043 See https://github.com/rust-lang/rust/issues/32925. */
11044 if (cu->language == language_rust && mangled != NULL
11045 && strchr (mangled, '{') != NULL)
11048 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11050 gdb::unique_xmalloc_ptr<char> demangled;
11051 if (mangled != NULL)
11054 if (language_def (cu->language)->la_store_sym_names_in_linkage_form_p)
11056 /* Do nothing (do not demangle the symbol name). */
11058 else if (cu->language == language_go)
11060 /* This is a lie, but we already lie to the caller new_symbol.
11061 new_symbol assumes we return the mangled name.
11062 This just undoes that lie until things are cleaned up. */
11066 /* Use DMGL_RET_DROP for C++ template functions to suppress
11067 their return type. It is easier for GDB users to search
11068 for such functions as `name(params)' than `long name(params)'.
11069 In such case the minimal symbol names do not match the full
11070 symbol names but for template functions there is never a need
11071 to look up their definition from their declaration so
11072 the only disadvantage remains the minimal symbol variant
11073 `long name(params)' does not have the proper inferior type. */
11074 demangled.reset (gdb_demangle (mangled,
11075 (DMGL_PARAMS | DMGL_ANSI
11076 | DMGL_RET_DROP)));
11079 canon = demangled.get ();
11087 if (canon == NULL || check_physname)
11089 const char *physname = dwarf2_compute_name (name, die, cu, 1);
11091 if (canon != NULL && strcmp (physname, canon) != 0)
11093 /* It may not mean a bug in GDB. The compiler could also
11094 compute DW_AT_linkage_name incorrectly. But in such case
11095 GDB would need to be bug-to-bug compatible. */
11097 complaint (_("Computed physname <%s> does not match demangled <%s> "
11098 "(from linkage <%s>) - DIE at %s [in module %s]"),
11099 physname, canon, mangled, sect_offset_str (die->sect_off),
11100 objfile_name (objfile));
11102 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11103 is available here - over computed PHYSNAME. It is safer
11104 against both buggy GDB and buggy compilers. */
11118 retval = ((const char *)
11119 obstack_copy0 (&objfile->per_bfd->storage_obstack,
11120 retval, strlen (retval)));
11125 /* Inspect DIE in CU for a namespace alias. If one exists, record
11126 a new symbol for it.
11128 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11131 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
11133 struct attribute *attr;
11135 /* If the die does not have a name, this is not a namespace
11137 attr = dwarf2_attr (die, DW_AT_name, cu);
11141 struct die_info *d = die;
11142 struct dwarf2_cu *imported_cu = cu;
11144 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11145 keep inspecting DIEs until we hit the underlying import. */
11146 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11147 for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
11149 attr = dwarf2_attr (d, DW_AT_import, cu);
11153 d = follow_die_ref (d, attr, &imported_cu);
11154 if (d->tag != DW_TAG_imported_declaration)
11158 if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
11160 complaint (_("DIE at %s has too many recursively imported "
11161 "declarations"), sect_offset_str (d->sect_off));
11168 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
11170 type = get_die_type_at_offset (sect_off, cu->per_cu);
11171 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
11173 /* This declaration is a global namespace alias. Add
11174 a symbol for it whose type is the aliased namespace. */
11175 new_symbol (die, type, cu);
11184 /* Return the using directives repository (global or local?) to use in the
11185 current context for CU.
11187 For Ada, imported declarations can materialize renamings, which *may* be
11188 global. However it is impossible (for now?) in DWARF to distinguish
11189 "external" imported declarations and "static" ones. As all imported
11190 declarations seem to be static in all other languages, make them all CU-wide
11191 global only in Ada. */
11193 static struct using_direct **
11194 using_directives (struct dwarf2_cu *cu)
11196 if (cu->language == language_ada && cu->builder->outermost_context_p ())
11197 return cu->builder->get_global_using_directives ();
11199 return cu->builder->get_local_using_directives ();
11202 /* Read the import statement specified by the given die and record it. */
11205 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
11207 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11208 struct attribute *import_attr;
11209 struct die_info *imported_die, *child_die;
11210 struct dwarf2_cu *imported_cu;
11211 const char *imported_name;
11212 const char *imported_name_prefix;
11213 const char *canonical_name;
11214 const char *import_alias;
11215 const char *imported_declaration = NULL;
11216 const char *import_prefix;
11217 std::vector<const char *> excludes;
11219 import_attr = dwarf2_attr (die, DW_AT_import, cu);
11220 if (import_attr == NULL)
11222 complaint (_("Tag '%s' has no DW_AT_import"),
11223 dwarf_tag_name (die->tag));
11228 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
11229 imported_name = dwarf2_name (imported_die, imported_cu);
11230 if (imported_name == NULL)
11232 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11234 The import in the following code:
11248 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11249 <52> DW_AT_decl_file : 1
11250 <53> DW_AT_decl_line : 6
11251 <54> DW_AT_import : <0x75>
11252 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11253 <59> DW_AT_name : B
11254 <5b> DW_AT_decl_file : 1
11255 <5c> DW_AT_decl_line : 2
11256 <5d> DW_AT_type : <0x6e>
11258 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11259 <76> DW_AT_byte_size : 4
11260 <77> DW_AT_encoding : 5 (signed)
11262 imports the wrong die ( 0x75 instead of 0x58 ).
11263 This case will be ignored until the gcc bug is fixed. */
11267 /* Figure out the local name after import. */
11268 import_alias = dwarf2_name (die, cu);
11270 /* Figure out where the statement is being imported to. */
11271 import_prefix = determine_prefix (die, cu);
11273 /* Figure out what the scope of the imported die is and prepend it
11274 to the name of the imported die. */
11275 imported_name_prefix = determine_prefix (imported_die, imported_cu);
11277 if (imported_die->tag != DW_TAG_namespace
11278 && imported_die->tag != DW_TAG_module)
11280 imported_declaration = imported_name;
11281 canonical_name = imported_name_prefix;
11283 else if (strlen (imported_name_prefix) > 0)
11284 canonical_name = obconcat (&objfile->objfile_obstack,
11285 imported_name_prefix,
11286 (cu->language == language_d ? "." : "::"),
11287 imported_name, (char *) NULL);
11289 canonical_name = imported_name;
11291 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
11292 for (child_die = die->child; child_die && child_die->tag;
11293 child_die = sibling_die (child_die))
11295 /* DWARF-4: A Fortran use statement with a “rename list” may be
11296 represented by an imported module entry with an import attribute
11297 referring to the module and owned entries corresponding to those
11298 entities that are renamed as part of being imported. */
11300 if (child_die->tag != DW_TAG_imported_declaration)
11302 complaint (_("child DW_TAG_imported_declaration expected "
11303 "- DIE at %s [in module %s]"),
11304 sect_offset_str (child_die->sect_off),
11305 objfile_name (objfile));
11309 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
11310 if (import_attr == NULL)
11312 complaint (_("Tag '%s' has no DW_AT_import"),
11313 dwarf_tag_name (child_die->tag));
11318 imported_die = follow_die_ref_or_sig (child_die, import_attr,
11320 imported_name = dwarf2_name (imported_die, imported_cu);
11321 if (imported_name == NULL)
11323 complaint (_("child DW_TAG_imported_declaration has unknown "
11324 "imported name - DIE at %s [in module %s]"),
11325 sect_offset_str (child_die->sect_off),
11326 objfile_name (objfile));
11330 excludes.push_back (imported_name);
11332 process_die (child_die, cu);
11335 add_using_directive (using_directives (cu),
11339 imported_declaration,
11342 &objfile->objfile_obstack);
11345 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11346 types, but gives them a size of zero. Starting with version 14,
11347 ICC is compatible with GCC. */
11350 producer_is_icc_lt_14 (struct dwarf2_cu *cu)
11352 if (!cu->checked_producer)
11353 check_producer (cu);
11355 return cu->producer_is_icc_lt_14;
11358 /* ICC generates a DW_AT_type for C void functions. This was observed on
11359 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11360 which says that void functions should not have a DW_AT_type. */
11363 producer_is_icc (struct dwarf2_cu *cu)
11365 if (!cu->checked_producer)
11366 check_producer (cu);
11368 return cu->producer_is_icc;
11371 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11372 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11373 this, it was first present in GCC release 4.3.0. */
11376 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
11378 if (!cu->checked_producer)
11379 check_producer (cu);
11381 return cu->producer_is_gcc_lt_4_3;
11384 static file_and_directory
11385 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu)
11387 file_and_directory res;
11389 /* Find the filename. Do not use dwarf2_name here, since the filename
11390 is not a source language identifier. */
11391 res.name = dwarf2_string_attr (die, DW_AT_name, cu);
11392 res.comp_dir = dwarf2_string_attr (die, DW_AT_comp_dir, cu);
11394 if (res.comp_dir == NULL
11395 && producer_is_gcc_lt_4_3 (cu) && res.name != NULL
11396 && IS_ABSOLUTE_PATH (res.name))
11398 res.comp_dir_storage = ldirname (res.name);
11399 if (!res.comp_dir_storage.empty ())
11400 res.comp_dir = res.comp_dir_storage.c_str ();
11402 if (res.comp_dir != NULL)
11404 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11405 directory, get rid of it. */
11406 const char *cp = strchr (res.comp_dir, ':');
11408 if (cp && cp != res.comp_dir && cp[-1] == '.' && cp[1] == '/')
11409 res.comp_dir = cp + 1;
11412 if (res.name == NULL)
11413 res.name = "<unknown>";
11418 /* Handle DW_AT_stmt_list for a compilation unit.
11419 DIE is the DW_TAG_compile_unit die for CU.
11420 COMP_DIR is the compilation directory. LOWPC is passed to
11421 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11424 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
11425 const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
11427 struct dwarf2_per_objfile *dwarf2_per_objfile
11428 = cu->per_cu->dwarf2_per_objfile;
11429 struct objfile *objfile = dwarf2_per_objfile->objfile;
11430 struct attribute *attr;
11431 struct line_header line_header_local;
11432 hashval_t line_header_local_hash;
11434 int decode_mapping;
11436 gdb_assert (! cu->per_cu->is_debug_types);
11438 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11442 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11444 /* The line header hash table is only created if needed (it exists to
11445 prevent redundant reading of the line table for partial_units).
11446 If we're given a partial_unit, we'll need it. If we're given a
11447 compile_unit, then use the line header hash table if it's already
11448 created, but don't create one just yet. */
11450 if (dwarf2_per_objfile->line_header_hash == NULL
11451 && die->tag == DW_TAG_partial_unit)
11453 dwarf2_per_objfile->line_header_hash
11454 = htab_create_alloc_ex (127, line_header_hash_voidp,
11455 line_header_eq_voidp,
11456 free_line_header_voidp,
11457 &objfile->objfile_obstack,
11458 hashtab_obstack_allocate,
11459 dummy_obstack_deallocate);
11462 line_header_local.sect_off = line_offset;
11463 line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
11464 line_header_local_hash = line_header_hash (&line_header_local);
11465 if (dwarf2_per_objfile->line_header_hash != NULL)
11467 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11468 &line_header_local,
11469 line_header_local_hash, NO_INSERT);
11471 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11472 is not present in *SLOT (since if there is something in *SLOT then
11473 it will be for a partial_unit). */
11474 if (die->tag == DW_TAG_partial_unit && slot != NULL)
11476 gdb_assert (*slot != NULL);
11477 cu->line_header = (struct line_header *) *slot;
11482 /* dwarf_decode_line_header does not yet provide sufficient information.
11483 We always have to call also dwarf_decode_lines for it. */
11484 line_header_up lh = dwarf_decode_line_header (line_offset, cu);
11488 cu->line_header = lh.release ();
11489 cu->line_header_die_owner = die;
11491 if (dwarf2_per_objfile->line_header_hash == NULL)
11495 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11496 &line_header_local,
11497 line_header_local_hash, INSERT);
11498 gdb_assert (slot != NULL);
11500 if (slot != NULL && *slot == NULL)
11502 /* This newly decoded line number information unit will be owned
11503 by line_header_hash hash table. */
11504 *slot = cu->line_header;
11505 cu->line_header_die_owner = NULL;
11509 /* We cannot free any current entry in (*slot) as that struct line_header
11510 may be already used by multiple CUs. Create only temporary decoded
11511 line_header for this CU - it may happen at most once for each line
11512 number information unit. And if we're not using line_header_hash
11513 then this is what we want as well. */
11514 gdb_assert (die->tag != DW_TAG_partial_unit);
11516 decode_mapping = (die->tag != DW_TAG_partial_unit);
11517 dwarf_decode_lines (cu->line_header, comp_dir, cu, NULL, lowpc,
11522 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11525 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
11527 struct dwarf2_per_objfile *dwarf2_per_objfile
11528 = cu->per_cu->dwarf2_per_objfile;
11529 struct objfile *objfile = dwarf2_per_objfile->objfile;
11530 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11531 CORE_ADDR lowpc = ((CORE_ADDR) -1);
11532 CORE_ADDR highpc = ((CORE_ADDR) 0);
11533 struct attribute *attr;
11534 struct die_info *child_die;
11535 CORE_ADDR baseaddr;
11537 prepare_one_comp_unit (cu, die, cu->language);
11538 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11540 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
11542 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11543 from finish_block. */
11544 if (lowpc == ((CORE_ADDR) -1))
11546 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11548 file_and_directory fnd = find_file_and_directory (die, cu);
11550 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11551 standardised yet. As a workaround for the language detection we fall
11552 back to the DW_AT_producer string. */
11553 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
11554 cu->language = language_opencl;
11556 /* Similar hack for Go. */
11557 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
11558 set_cu_language (DW_LANG_Go, cu);
11560 dwarf2_start_symtab (cu, fnd.name, fnd.comp_dir, lowpc);
11562 /* Decode line number information if present. We do this before
11563 processing child DIEs, so that the line header table is available
11564 for DW_AT_decl_file. */
11565 handle_DW_AT_stmt_list (die, cu, fnd.comp_dir, lowpc);
11567 /* Process all dies in compilation unit. */
11568 if (die->child != NULL)
11570 child_die = die->child;
11571 while (child_die && child_die->tag)
11573 process_die (child_die, cu);
11574 child_die = sibling_die (child_die);
11578 /* Decode macro information, if present. Dwarf 2 macro information
11579 refers to information in the line number info statement program
11580 header, so we can only read it if we've read the header
11582 attr = dwarf2_attr (die, DW_AT_macros, cu);
11584 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
11585 if (attr && cu->line_header)
11587 if (dwarf2_attr (die, DW_AT_macro_info, cu))
11588 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11590 dwarf_decode_macros (cu, DW_UNSND (attr), 1);
11594 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
11595 if (attr && cu->line_header)
11597 unsigned int macro_offset = DW_UNSND (attr);
11599 dwarf_decode_macros (cu, macro_offset, 0);
11604 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
11605 Create the set of symtabs used by this TU, or if this TU is sharing
11606 symtabs with another TU and the symtabs have already been created
11607 then restore those symtabs in the line header.
11608 We don't need the pc/line-number mapping for type units. */
11611 setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
11613 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
11614 struct type_unit_group *tu_group;
11616 struct attribute *attr;
11618 struct signatured_type *sig_type;
11620 gdb_assert (per_cu->is_debug_types);
11621 sig_type = (struct signatured_type *) per_cu;
11623 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11625 /* If we're using .gdb_index (includes -readnow) then
11626 per_cu->type_unit_group may not have been set up yet. */
11627 if (sig_type->type_unit_group == NULL)
11628 sig_type->type_unit_group = get_type_unit_group (cu, attr);
11629 tu_group = sig_type->type_unit_group;
11631 /* If we've already processed this stmt_list there's no real need to
11632 do it again, we could fake it and just recreate the part we need
11633 (file name,index -> symtab mapping). If data shows this optimization
11634 is useful we can do it then. */
11635 first_time = tu_group->compunit_symtab == NULL;
11637 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11642 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11643 lh = dwarf_decode_line_header (line_offset, cu);
11648 dwarf2_start_symtab (cu, "", NULL, 0);
11651 gdb_assert (tu_group->symtabs == NULL);
11652 gdb_assert (cu->builder == nullptr);
11653 struct compunit_symtab *cust = tu_group->compunit_symtab;
11654 cu->builder.reset (new struct buildsym_compunit
11655 (COMPUNIT_OBJFILE (cust), "",
11656 COMPUNIT_DIRNAME (cust),
11657 compunit_language (cust),
11663 cu->line_header = lh.release ();
11664 cu->line_header_die_owner = die;
11668 struct compunit_symtab *cust = dwarf2_start_symtab (cu, "", NULL, 0);
11670 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11671 still initializing it, and our caller (a few levels up)
11672 process_full_type_unit still needs to know if this is the first
11675 tu_group->num_symtabs = cu->line_header->file_names.size ();
11676 tu_group->symtabs = XNEWVEC (struct symtab *,
11677 cu->line_header->file_names.size ());
11679 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11681 file_entry &fe = cu->line_header->file_names[i];
11683 dwarf2_start_subfile (cu, fe.name, fe.include_dir (cu->line_header));
11685 if (cu->builder->get_current_subfile ()->symtab == NULL)
11687 /* NOTE: start_subfile will recognize when it's been
11688 passed a file it has already seen. So we can't
11689 assume there's a simple mapping from
11690 cu->line_header->file_names to subfiles, plus
11691 cu->line_header->file_names may contain dups. */
11692 cu->builder->get_current_subfile ()->symtab
11693 = allocate_symtab (cust,
11694 cu->builder->get_current_subfile ()->name);
11697 fe.symtab = cu->builder->get_current_subfile ()->symtab;
11698 tu_group->symtabs[i] = fe.symtab;
11703 gdb_assert (cu->builder == nullptr);
11704 struct compunit_symtab *cust = tu_group->compunit_symtab;
11705 cu->builder.reset (new struct buildsym_compunit
11706 (COMPUNIT_OBJFILE (cust), "",
11707 COMPUNIT_DIRNAME (cust),
11708 compunit_language (cust),
11711 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11713 file_entry &fe = cu->line_header->file_names[i];
11715 fe.symtab = tu_group->symtabs[i];
11719 /* The main symtab is allocated last. Type units don't have DW_AT_name
11720 so they don't have a "real" (so to speak) symtab anyway.
11721 There is later code that will assign the main symtab to all symbols
11722 that don't have one. We need to handle the case of a symbol with a
11723 missing symtab (DW_AT_decl_file) anyway. */
11726 /* Process DW_TAG_type_unit.
11727 For TUs we want to skip the first top level sibling if it's not the
11728 actual type being defined by this TU. In this case the first top
11729 level sibling is there to provide context only. */
11732 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
11734 struct die_info *child_die;
11736 prepare_one_comp_unit (cu, die, language_minimal);
11738 /* Initialize (or reinitialize) the machinery for building symtabs.
11739 We do this before processing child DIEs, so that the line header table
11740 is available for DW_AT_decl_file. */
11741 setup_type_unit_groups (die, cu);
11743 if (die->child != NULL)
11745 child_die = die->child;
11746 while (child_die && child_die->tag)
11748 process_die (child_die, cu);
11749 child_die = sibling_die (child_die);
11756 http://gcc.gnu.org/wiki/DebugFission
11757 http://gcc.gnu.org/wiki/DebugFissionDWP
11759 To simplify handling of both DWO files ("object" files with the DWARF info)
11760 and DWP files (a file with the DWOs packaged up into one file), we treat
11761 DWP files as having a collection of virtual DWO files. */
11764 hash_dwo_file (const void *item)
11766 const struct dwo_file *dwo_file = (const struct dwo_file *) item;
11769 hash = htab_hash_string (dwo_file->dwo_name);
11770 if (dwo_file->comp_dir != NULL)
11771 hash += htab_hash_string (dwo_file->comp_dir);
11776 eq_dwo_file (const void *item_lhs, const void *item_rhs)
11778 const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
11779 const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
11781 if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
11783 if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
11784 return lhs->comp_dir == rhs->comp_dir;
11785 return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
11788 /* Allocate a hash table for DWO files. */
11791 allocate_dwo_file_hash_table (struct objfile *objfile)
11793 return htab_create_alloc_ex (41,
11797 &objfile->objfile_obstack,
11798 hashtab_obstack_allocate,
11799 dummy_obstack_deallocate);
11802 /* Lookup DWO file DWO_NAME. */
11805 lookup_dwo_file_slot (struct dwarf2_per_objfile *dwarf2_per_objfile,
11806 const char *dwo_name,
11807 const char *comp_dir)
11809 struct dwo_file find_entry;
11812 if (dwarf2_per_objfile->dwo_files == NULL)
11813 dwarf2_per_objfile->dwo_files
11814 = allocate_dwo_file_hash_table (dwarf2_per_objfile->objfile);
11816 memset (&find_entry, 0, sizeof (find_entry));
11817 find_entry.dwo_name = dwo_name;
11818 find_entry.comp_dir = comp_dir;
11819 slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
11825 hash_dwo_unit (const void *item)
11827 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
11829 /* This drops the top 32 bits of the id, but is ok for a hash. */
11830 return dwo_unit->signature;
11834 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
11836 const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
11837 const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
11839 /* The signature is assumed to be unique within the DWO file.
11840 So while object file CU dwo_id's always have the value zero,
11841 that's OK, assuming each object file DWO file has only one CU,
11842 and that's the rule for now. */
11843 return lhs->signature == rhs->signature;
11846 /* Allocate a hash table for DWO CUs,TUs.
11847 There is one of these tables for each of CUs,TUs for each DWO file. */
11850 allocate_dwo_unit_table (struct objfile *objfile)
11852 /* Start out with a pretty small number.
11853 Generally DWO files contain only one CU and maybe some TUs. */
11854 return htab_create_alloc_ex (3,
11858 &objfile->objfile_obstack,
11859 hashtab_obstack_allocate,
11860 dummy_obstack_deallocate);
11863 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11865 struct create_dwo_cu_data
11867 struct dwo_file *dwo_file;
11868 struct dwo_unit dwo_unit;
11871 /* die_reader_func for create_dwo_cu. */
11874 create_dwo_cu_reader (const struct die_reader_specs *reader,
11875 const gdb_byte *info_ptr,
11876 struct die_info *comp_unit_die,
11880 struct dwarf2_cu *cu = reader->cu;
11881 sect_offset sect_off = cu->per_cu->sect_off;
11882 struct dwarf2_section_info *section = cu->per_cu->section;
11883 struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
11884 struct dwo_file *dwo_file = data->dwo_file;
11885 struct dwo_unit *dwo_unit = &data->dwo_unit;
11886 struct attribute *attr;
11888 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
11891 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11892 " its dwo_id [in module %s]"),
11893 sect_offset_str (sect_off), dwo_file->dwo_name);
11897 dwo_unit->dwo_file = dwo_file;
11898 dwo_unit->signature = DW_UNSND (attr);
11899 dwo_unit->section = section;
11900 dwo_unit->sect_off = sect_off;
11901 dwo_unit->length = cu->per_cu->length;
11903 if (dwarf_read_debug)
11904 fprintf_unfiltered (gdb_stdlog, " offset %s, dwo_id %s\n",
11905 sect_offset_str (sect_off),
11906 hex_string (dwo_unit->signature));
11909 /* Create the dwo_units for the CUs in a DWO_FILE.
11910 Note: This function processes DWO files only, not DWP files. */
11913 create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
11914 struct dwo_file &dwo_file, dwarf2_section_info §ion,
11917 struct objfile *objfile = dwarf2_per_objfile->objfile;
11918 const gdb_byte *info_ptr, *end_ptr;
11920 dwarf2_read_section (objfile, §ion);
11921 info_ptr = section.buffer;
11923 if (info_ptr == NULL)
11926 if (dwarf_read_debug)
11928 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
11929 get_section_name (§ion),
11930 get_section_file_name (§ion));
11933 end_ptr = info_ptr + section.size;
11934 while (info_ptr < end_ptr)
11936 struct dwarf2_per_cu_data per_cu;
11937 struct create_dwo_cu_data create_dwo_cu_data;
11938 struct dwo_unit *dwo_unit;
11940 sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
11942 memset (&create_dwo_cu_data.dwo_unit, 0,
11943 sizeof (create_dwo_cu_data.dwo_unit));
11944 memset (&per_cu, 0, sizeof (per_cu));
11945 per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
11946 per_cu.is_debug_types = 0;
11947 per_cu.sect_off = sect_offset (info_ptr - section.buffer);
11948 per_cu.section = §ion;
11949 create_dwo_cu_data.dwo_file = &dwo_file;
11951 init_cutu_and_read_dies_no_follow (
11952 &per_cu, &dwo_file, create_dwo_cu_reader, &create_dwo_cu_data);
11953 info_ptr += per_cu.length;
11955 // If the unit could not be parsed, skip it.
11956 if (create_dwo_cu_data.dwo_unit.dwo_file == NULL)
11959 if (cus_htab == NULL)
11960 cus_htab = allocate_dwo_unit_table (objfile);
11962 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
11963 *dwo_unit = create_dwo_cu_data.dwo_unit;
11964 slot = htab_find_slot (cus_htab, dwo_unit, INSERT);
11965 gdb_assert (slot != NULL);
11968 const struct dwo_unit *dup_cu = (const struct dwo_unit *)*slot;
11969 sect_offset dup_sect_off = dup_cu->sect_off;
11971 complaint (_("debug cu entry at offset %s is duplicate to"
11972 " the entry at offset %s, signature %s"),
11973 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
11974 hex_string (dwo_unit->signature));
11976 *slot = (void *)dwo_unit;
11980 /* DWP file .debug_{cu,tu}_index section format:
11981 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11985 Both index sections have the same format, and serve to map a 64-bit
11986 signature to a set of section numbers. Each section begins with a header,
11987 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11988 indexes, and a pool of 32-bit section numbers. The index sections will be
11989 aligned at 8-byte boundaries in the file.
11991 The index section header consists of:
11993 V, 32 bit version number
11995 N, 32 bit number of compilation units or type units in the index
11996 M, 32 bit number of slots in the hash table
11998 Numbers are recorded using the byte order of the application binary.
12000 The hash table begins at offset 16 in the section, and consists of an array
12001 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
12002 order of the application binary). Unused slots in the hash table are 0.
12003 (We rely on the extreme unlikeliness of a signature being exactly 0.)
12005 The parallel table begins immediately after the hash table
12006 (at offset 16 + 8 * M from the beginning of the section), and consists of an
12007 array of 32-bit indexes (using the byte order of the application binary),
12008 corresponding 1-1 with slots in the hash table. Each entry in the parallel
12009 table contains a 32-bit index into the pool of section numbers. For unused
12010 hash table slots, the corresponding entry in the parallel table will be 0.
12012 The pool of section numbers begins immediately following the hash table
12013 (at offset 16 + 12 * M from the beginning of the section). The pool of
12014 section numbers consists of an array of 32-bit words (using the byte order
12015 of the application binary). Each item in the array is indexed starting
12016 from 0. The hash table entry provides the index of the first section
12017 number in the set. Additional section numbers in the set follow, and the
12018 set is terminated by a 0 entry (section number 0 is not used in ELF).
12020 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12021 section must be the first entry in the set, and the .debug_abbrev.dwo must
12022 be the second entry. Other members of the set may follow in any order.
12028 DWP Version 2 combines all the .debug_info, etc. sections into one,
12029 and the entries in the index tables are now offsets into these sections.
12030 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
12033 Index Section Contents:
12035 Hash Table of Signatures dwp_hash_table.hash_table
12036 Parallel Table of Indices dwp_hash_table.unit_table
12037 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
12038 Table of Section Sizes dwp_hash_table.v2.sizes
12040 The index section header consists of:
12042 V, 32 bit version number
12043 L, 32 bit number of columns in the table of section offsets
12044 N, 32 bit number of compilation units or type units in the index
12045 M, 32 bit number of slots in the hash table
12047 Numbers are recorded using the byte order of the application binary.
12049 The hash table has the same format as version 1.
12050 The parallel table of indices has the same format as version 1,
12051 except that the entries are origin-1 indices into the table of sections
12052 offsets and the table of section sizes.
12054 The table of offsets begins immediately following the parallel table
12055 (at offset 16 + 12 * M from the beginning of the section). The table is
12056 a two-dimensional array of 32-bit words (using the byte order of the
12057 application binary), with L columns and N+1 rows, in row-major order.
12058 Each row in the array is indexed starting from 0. The first row provides
12059 a key to the remaining rows: each column in this row provides an identifier
12060 for a debug section, and the offsets in the same column of subsequent rows
12061 refer to that section. The section identifiers are:
12063 DW_SECT_INFO 1 .debug_info.dwo
12064 DW_SECT_TYPES 2 .debug_types.dwo
12065 DW_SECT_ABBREV 3 .debug_abbrev.dwo
12066 DW_SECT_LINE 4 .debug_line.dwo
12067 DW_SECT_LOC 5 .debug_loc.dwo
12068 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
12069 DW_SECT_MACINFO 7 .debug_macinfo.dwo
12070 DW_SECT_MACRO 8 .debug_macro.dwo
12072 The offsets provided by the CU and TU index sections are the base offsets
12073 for the contributions made by each CU or TU to the corresponding section
12074 in the package file. Each CU and TU header contains an abbrev_offset
12075 field, used to find the abbreviations table for that CU or TU within the
12076 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12077 be interpreted as relative to the base offset given in the index section.
12078 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12079 should be interpreted as relative to the base offset for .debug_line.dwo,
12080 and offsets into other debug sections obtained from DWARF attributes should
12081 also be interpreted as relative to the corresponding base offset.
12083 The table of sizes begins immediately following the table of offsets.
12084 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12085 with L columns and N rows, in row-major order. Each row in the array is
12086 indexed starting from 1 (row 0 is shared by the two tables).
12090 Hash table lookup is handled the same in version 1 and 2:
12092 We assume that N and M will not exceed 2^32 - 1.
12093 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12095 Given a 64-bit compilation unit signature or a type signature S, an entry
12096 in the hash table is located as follows:
12098 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12099 the low-order k bits all set to 1.
12101 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12103 3) If the hash table entry at index H matches the signature, use that
12104 entry. If the hash table entry at index H is unused (all zeroes),
12105 terminate the search: the signature is not present in the table.
12107 4) Let H = (H + H') modulo M. Repeat at Step 3.
12109 Because M > N and H' and M are relatively prime, the search is guaranteed
12110 to stop at an unused slot or find the match. */
12112 /* Create a hash table to map DWO IDs to their CU/TU entry in
12113 .debug_{info,types}.dwo in DWP_FILE.
12114 Returns NULL if there isn't one.
12115 Note: This function processes DWP files only, not DWO files. */
12117 static struct dwp_hash_table *
12118 create_dwp_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
12119 struct dwp_file *dwp_file, int is_debug_types)
12121 struct objfile *objfile = dwarf2_per_objfile->objfile;
12122 bfd *dbfd = dwp_file->dbfd.get ();
12123 const gdb_byte *index_ptr, *index_end;
12124 struct dwarf2_section_info *index;
12125 uint32_t version, nr_columns, nr_units, nr_slots;
12126 struct dwp_hash_table *htab;
12128 if (is_debug_types)
12129 index = &dwp_file->sections.tu_index;
12131 index = &dwp_file->sections.cu_index;
12133 if (dwarf2_section_empty_p (index))
12135 dwarf2_read_section (objfile, index);
12137 index_ptr = index->buffer;
12138 index_end = index_ptr + index->size;
12140 version = read_4_bytes (dbfd, index_ptr);
12143 nr_columns = read_4_bytes (dbfd, index_ptr);
12147 nr_units = read_4_bytes (dbfd, index_ptr);
12149 nr_slots = read_4_bytes (dbfd, index_ptr);
12152 if (version != 1 && version != 2)
12154 error (_("Dwarf Error: unsupported DWP file version (%s)"
12155 " [in module %s]"),
12156 pulongest (version), dwp_file->name);
12158 if (nr_slots != (nr_slots & -nr_slots))
12160 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12161 " is not power of 2 [in module %s]"),
12162 pulongest (nr_slots), dwp_file->name);
12165 htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
12166 htab->version = version;
12167 htab->nr_columns = nr_columns;
12168 htab->nr_units = nr_units;
12169 htab->nr_slots = nr_slots;
12170 htab->hash_table = index_ptr;
12171 htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
12173 /* Exit early if the table is empty. */
12174 if (nr_slots == 0 || nr_units == 0
12175 || (version == 2 && nr_columns == 0))
12177 /* All must be zero. */
12178 if (nr_slots != 0 || nr_units != 0
12179 || (version == 2 && nr_columns != 0))
12181 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12182 " all zero [in modules %s]"),
12190 htab->section_pool.v1.indices =
12191 htab->unit_table + sizeof (uint32_t) * nr_slots;
12192 /* It's harder to decide whether the section is too small in v1.
12193 V1 is deprecated anyway so we punt. */
12197 const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
12198 int *ids = htab->section_pool.v2.section_ids;
12199 size_t sizeof_ids = sizeof (htab->section_pool.v2.section_ids);
12200 /* Reverse map for error checking. */
12201 int ids_seen[DW_SECT_MAX + 1];
12204 if (nr_columns < 2)
12206 error (_("Dwarf Error: bad DWP hash table, too few columns"
12207 " in section table [in module %s]"),
12210 if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
12212 error (_("Dwarf Error: bad DWP hash table, too many columns"
12213 " in section table [in module %s]"),
12216 memset (ids, 255, sizeof_ids);
12217 memset (ids_seen, 255, sizeof (ids_seen));
12218 for (i = 0; i < nr_columns; ++i)
12220 int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
12222 if (id < DW_SECT_MIN || id > DW_SECT_MAX)
12224 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12225 " in section table [in module %s]"),
12226 id, dwp_file->name);
12228 if (ids_seen[id] != -1)
12230 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12231 " id %d in section table [in module %s]"),
12232 id, dwp_file->name);
12237 /* Must have exactly one info or types section. */
12238 if (((ids_seen[DW_SECT_INFO] != -1)
12239 + (ids_seen[DW_SECT_TYPES] != -1))
12242 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12243 " DWO info/types section [in module %s]"),
12246 /* Must have an abbrev section. */
12247 if (ids_seen[DW_SECT_ABBREV] == -1)
12249 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12250 " section [in module %s]"),
12253 htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
12254 htab->section_pool.v2.sizes =
12255 htab->section_pool.v2.offsets + (sizeof (uint32_t)
12256 * nr_units * nr_columns);
12257 if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
12258 * nr_units * nr_columns))
12261 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12262 " [in module %s]"),
12270 /* Update SECTIONS with the data from SECTP.
12272 This function is like the other "locate" section routines that are
12273 passed to bfd_map_over_sections, but in this context the sections to
12274 read comes from the DWP V1 hash table, not the full ELF section table.
12276 The result is non-zero for success, or zero if an error was found. */
12279 locate_v1_virtual_dwo_sections (asection *sectp,
12280 struct virtual_v1_dwo_sections *sections)
12282 const struct dwop_section_names *names = &dwop_section_names;
12284 if (section_is_p (sectp->name, &names->abbrev_dwo))
12286 /* There can be only one. */
12287 if (sections->abbrev.s.section != NULL)
12289 sections->abbrev.s.section = sectp;
12290 sections->abbrev.size = bfd_get_section_size (sectp);
12292 else if (section_is_p (sectp->name, &names->info_dwo)
12293 || section_is_p (sectp->name, &names->types_dwo))
12295 /* There can be only one. */
12296 if (sections->info_or_types.s.section != NULL)
12298 sections->info_or_types.s.section = sectp;
12299 sections->info_or_types.size = bfd_get_section_size (sectp);
12301 else if (section_is_p (sectp->name, &names->line_dwo))
12303 /* There can be only one. */
12304 if (sections->line.s.section != NULL)
12306 sections->line.s.section = sectp;
12307 sections->line.size = bfd_get_section_size (sectp);
12309 else if (section_is_p (sectp->name, &names->loc_dwo))
12311 /* There can be only one. */
12312 if (sections->loc.s.section != NULL)
12314 sections->loc.s.section = sectp;
12315 sections->loc.size = bfd_get_section_size (sectp);
12317 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12319 /* There can be only one. */
12320 if (sections->macinfo.s.section != NULL)
12322 sections->macinfo.s.section = sectp;
12323 sections->macinfo.size = bfd_get_section_size (sectp);
12325 else if (section_is_p (sectp->name, &names->macro_dwo))
12327 /* There can be only one. */
12328 if (sections->macro.s.section != NULL)
12330 sections->macro.s.section = sectp;
12331 sections->macro.size = bfd_get_section_size (sectp);
12333 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12335 /* There can be only one. */
12336 if (sections->str_offsets.s.section != NULL)
12338 sections->str_offsets.s.section = sectp;
12339 sections->str_offsets.size = bfd_get_section_size (sectp);
12343 /* No other kind of section is valid. */
12350 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12351 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12352 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12353 This is for DWP version 1 files. */
12355 static struct dwo_unit *
12356 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12357 struct dwp_file *dwp_file,
12358 uint32_t unit_index,
12359 const char *comp_dir,
12360 ULONGEST signature, int is_debug_types)
12362 struct objfile *objfile = dwarf2_per_objfile->objfile;
12363 const struct dwp_hash_table *dwp_htab =
12364 is_debug_types ? dwp_file->tus : dwp_file->cus;
12365 bfd *dbfd = dwp_file->dbfd.get ();
12366 const char *kind = is_debug_types ? "TU" : "CU";
12367 struct dwo_file *dwo_file;
12368 struct dwo_unit *dwo_unit;
12369 struct virtual_v1_dwo_sections sections;
12370 void **dwo_file_slot;
12373 gdb_assert (dwp_file->version == 1);
12375 if (dwarf_read_debug)
12377 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
12379 pulongest (unit_index), hex_string (signature),
12383 /* Fetch the sections of this DWO unit.
12384 Put a limit on the number of sections we look for so that bad data
12385 doesn't cause us to loop forever. */
12387 #define MAX_NR_V1_DWO_SECTIONS \
12388 (1 /* .debug_info or .debug_types */ \
12389 + 1 /* .debug_abbrev */ \
12390 + 1 /* .debug_line */ \
12391 + 1 /* .debug_loc */ \
12392 + 1 /* .debug_str_offsets */ \
12393 + 1 /* .debug_macro or .debug_macinfo */ \
12394 + 1 /* trailing zero */)
12396 memset (§ions, 0, sizeof (sections));
12398 for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
12401 uint32_t section_nr =
12402 read_4_bytes (dbfd,
12403 dwp_htab->section_pool.v1.indices
12404 + (unit_index + i) * sizeof (uint32_t));
12406 if (section_nr == 0)
12408 if (section_nr >= dwp_file->num_sections)
12410 error (_("Dwarf Error: bad DWP hash table, section number too large"
12411 " [in module %s]"),
12415 sectp = dwp_file->elf_sections[section_nr];
12416 if (! locate_v1_virtual_dwo_sections (sectp, §ions))
12418 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12419 " [in module %s]"),
12425 || dwarf2_section_empty_p (§ions.info_or_types)
12426 || dwarf2_section_empty_p (§ions.abbrev))
12428 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12429 " [in module %s]"),
12432 if (i == MAX_NR_V1_DWO_SECTIONS)
12434 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12435 " [in module %s]"),
12439 /* It's easier for the rest of the code if we fake a struct dwo_file and
12440 have dwo_unit "live" in that. At least for now.
12442 The DWP file can be made up of a random collection of CUs and TUs.
12443 However, for each CU + set of TUs that came from the same original DWO
12444 file, we can combine them back into a virtual DWO file to save space
12445 (fewer struct dwo_file objects to allocate). Remember that for really
12446 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12448 std::string virtual_dwo_name =
12449 string_printf ("virtual-dwo/%d-%d-%d-%d",
12450 get_section_id (§ions.abbrev),
12451 get_section_id (§ions.line),
12452 get_section_id (§ions.loc),
12453 get_section_id (§ions.str_offsets));
12454 /* Can we use an existing virtual DWO file? */
12455 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12456 virtual_dwo_name.c_str (),
12458 /* Create one if necessary. */
12459 if (*dwo_file_slot == NULL)
12461 if (dwarf_read_debug)
12463 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12464 virtual_dwo_name.c_str ());
12466 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12468 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12469 virtual_dwo_name.c_str (),
12470 virtual_dwo_name.size ());
12471 dwo_file->comp_dir = comp_dir;
12472 dwo_file->sections.abbrev = sections.abbrev;
12473 dwo_file->sections.line = sections.line;
12474 dwo_file->sections.loc = sections.loc;
12475 dwo_file->sections.macinfo = sections.macinfo;
12476 dwo_file->sections.macro = sections.macro;
12477 dwo_file->sections.str_offsets = sections.str_offsets;
12478 /* The "str" section is global to the entire DWP file. */
12479 dwo_file->sections.str = dwp_file->sections.str;
12480 /* The info or types section is assigned below to dwo_unit,
12481 there's no need to record it in dwo_file.
12482 Also, we can't simply record type sections in dwo_file because
12483 we record a pointer into the vector in dwo_unit. As we collect more
12484 types we'll grow the vector and eventually have to reallocate space
12485 for it, invalidating all copies of pointers into the previous
12487 *dwo_file_slot = dwo_file;
12491 if (dwarf_read_debug)
12493 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12494 virtual_dwo_name.c_str ());
12496 dwo_file = (struct dwo_file *) *dwo_file_slot;
12499 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12500 dwo_unit->dwo_file = dwo_file;
12501 dwo_unit->signature = signature;
12502 dwo_unit->section =
12503 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12504 *dwo_unit->section = sections.info_or_types;
12505 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12510 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12511 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12512 piece within that section used by a TU/CU, return a virtual section
12513 of just that piece. */
12515 static struct dwarf2_section_info
12516 create_dwp_v2_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
12517 struct dwarf2_section_info *section,
12518 bfd_size_type offset, bfd_size_type size)
12520 struct dwarf2_section_info result;
12523 gdb_assert (section != NULL);
12524 gdb_assert (!section->is_virtual);
12526 memset (&result, 0, sizeof (result));
12527 result.s.containing_section = section;
12528 result.is_virtual = 1;
12533 sectp = get_section_bfd_section (section);
12535 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12536 bounds of the real section. This is a pretty-rare event, so just
12537 flag an error (easier) instead of a warning and trying to cope. */
12539 || offset + size > bfd_get_section_size (sectp))
12541 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12542 " in section %s [in module %s]"),
12543 sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
12544 objfile_name (dwarf2_per_objfile->objfile));
12547 result.virtual_offset = offset;
12548 result.size = size;
12552 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12553 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12554 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12555 This is for DWP version 2 files. */
12557 static struct dwo_unit *
12558 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12559 struct dwp_file *dwp_file,
12560 uint32_t unit_index,
12561 const char *comp_dir,
12562 ULONGEST signature, int is_debug_types)
12564 struct objfile *objfile = dwarf2_per_objfile->objfile;
12565 const struct dwp_hash_table *dwp_htab =
12566 is_debug_types ? dwp_file->tus : dwp_file->cus;
12567 bfd *dbfd = dwp_file->dbfd.get ();
12568 const char *kind = is_debug_types ? "TU" : "CU";
12569 struct dwo_file *dwo_file;
12570 struct dwo_unit *dwo_unit;
12571 struct virtual_v2_dwo_sections sections;
12572 void **dwo_file_slot;
12575 gdb_assert (dwp_file->version == 2);
12577 if (dwarf_read_debug)
12579 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
12581 pulongest (unit_index), hex_string (signature),
12585 /* Fetch the section offsets of this DWO unit. */
12587 memset (§ions, 0, sizeof (sections));
12589 for (i = 0; i < dwp_htab->nr_columns; ++i)
12591 uint32_t offset = read_4_bytes (dbfd,
12592 dwp_htab->section_pool.v2.offsets
12593 + (((unit_index - 1) * dwp_htab->nr_columns
12595 * sizeof (uint32_t)));
12596 uint32_t size = read_4_bytes (dbfd,
12597 dwp_htab->section_pool.v2.sizes
12598 + (((unit_index - 1) * dwp_htab->nr_columns
12600 * sizeof (uint32_t)));
12602 switch (dwp_htab->section_pool.v2.section_ids[i])
12605 case DW_SECT_TYPES:
12606 sections.info_or_types_offset = offset;
12607 sections.info_or_types_size = size;
12609 case DW_SECT_ABBREV:
12610 sections.abbrev_offset = offset;
12611 sections.abbrev_size = size;
12614 sections.line_offset = offset;
12615 sections.line_size = size;
12618 sections.loc_offset = offset;
12619 sections.loc_size = size;
12621 case DW_SECT_STR_OFFSETS:
12622 sections.str_offsets_offset = offset;
12623 sections.str_offsets_size = size;
12625 case DW_SECT_MACINFO:
12626 sections.macinfo_offset = offset;
12627 sections.macinfo_size = size;
12629 case DW_SECT_MACRO:
12630 sections.macro_offset = offset;
12631 sections.macro_size = size;
12636 /* It's easier for the rest of the code if we fake a struct dwo_file and
12637 have dwo_unit "live" in that. At least for now.
12639 The DWP file can be made up of a random collection of CUs and TUs.
12640 However, for each CU + set of TUs that came from the same original DWO
12641 file, we can combine them back into a virtual DWO file to save space
12642 (fewer struct dwo_file objects to allocate). Remember that for really
12643 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12645 std::string virtual_dwo_name =
12646 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12647 (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
12648 (long) (sections.line_size ? sections.line_offset : 0),
12649 (long) (sections.loc_size ? sections.loc_offset : 0),
12650 (long) (sections.str_offsets_size
12651 ? sections.str_offsets_offset : 0));
12652 /* Can we use an existing virtual DWO file? */
12653 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12654 virtual_dwo_name.c_str (),
12656 /* Create one if necessary. */
12657 if (*dwo_file_slot == NULL)
12659 if (dwarf_read_debug)
12661 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12662 virtual_dwo_name.c_str ());
12664 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12666 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12667 virtual_dwo_name.c_str (),
12668 virtual_dwo_name.size ());
12669 dwo_file->comp_dir = comp_dir;
12670 dwo_file->sections.abbrev =
12671 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,
12672 sections.abbrev_offset, sections.abbrev_size);
12673 dwo_file->sections.line =
12674 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.line,
12675 sections.line_offset, sections.line_size);
12676 dwo_file->sections.loc =
12677 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.loc,
12678 sections.loc_offset, sections.loc_size);
12679 dwo_file->sections.macinfo =
12680 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macinfo,
12681 sections.macinfo_offset, sections.macinfo_size);
12682 dwo_file->sections.macro =
12683 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macro,
12684 sections.macro_offset, sections.macro_size);
12685 dwo_file->sections.str_offsets =
12686 create_dwp_v2_section (dwarf2_per_objfile,
12687 &dwp_file->sections.str_offsets,
12688 sections.str_offsets_offset,
12689 sections.str_offsets_size);
12690 /* The "str" section is global to the entire DWP file. */
12691 dwo_file->sections.str = dwp_file->sections.str;
12692 /* The info or types section is assigned below to dwo_unit,
12693 there's no need to record it in dwo_file.
12694 Also, we can't simply record type sections in dwo_file because
12695 we record a pointer into the vector in dwo_unit. As we collect more
12696 types we'll grow the vector and eventually have to reallocate space
12697 for it, invalidating all copies of pointers into the previous
12699 *dwo_file_slot = dwo_file;
12703 if (dwarf_read_debug)
12705 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12706 virtual_dwo_name.c_str ());
12708 dwo_file = (struct dwo_file *) *dwo_file_slot;
12711 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12712 dwo_unit->dwo_file = dwo_file;
12713 dwo_unit->signature = signature;
12714 dwo_unit->section =
12715 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12716 *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
12718 ? &dwp_file->sections.types
12719 : &dwp_file->sections.info,
12720 sections.info_or_types_offset,
12721 sections.info_or_types_size);
12722 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12727 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12728 Returns NULL if the signature isn't found. */
12730 static struct dwo_unit *
12731 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile *dwarf2_per_objfile,
12732 struct dwp_file *dwp_file, const char *comp_dir,
12733 ULONGEST signature, int is_debug_types)
12735 const struct dwp_hash_table *dwp_htab =
12736 is_debug_types ? dwp_file->tus : dwp_file->cus;
12737 bfd *dbfd = dwp_file->dbfd.get ();
12738 uint32_t mask = dwp_htab->nr_slots - 1;
12739 uint32_t hash = signature & mask;
12740 uint32_t hash2 = ((signature >> 32) & mask) | 1;
12743 struct dwo_unit find_dwo_cu;
12745 memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
12746 find_dwo_cu.signature = signature;
12747 slot = htab_find_slot (is_debug_types
12748 ? dwp_file->loaded_tus
12749 : dwp_file->loaded_cus,
12750 &find_dwo_cu, INSERT);
12753 return (struct dwo_unit *) *slot;
12755 /* Use a for loop so that we don't loop forever on bad debug info. */
12756 for (i = 0; i < dwp_htab->nr_slots; ++i)
12758 ULONGEST signature_in_table;
12760 signature_in_table =
12761 read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
12762 if (signature_in_table == signature)
12764 uint32_t unit_index =
12765 read_4_bytes (dbfd,
12766 dwp_htab->unit_table + hash * sizeof (uint32_t));
12768 if (dwp_file->version == 1)
12770 *slot = create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile,
12771 dwp_file, unit_index,
12772 comp_dir, signature,
12777 *slot = create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile,
12778 dwp_file, unit_index,
12779 comp_dir, signature,
12782 return (struct dwo_unit *) *slot;
12784 if (signature_in_table == 0)
12786 hash = (hash + hash2) & mask;
12789 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12790 " [in module %s]"),
12794 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12795 Open the file specified by FILE_NAME and hand it off to BFD for
12796 preliminary analysis. Return a newly initialized bfd *, which
12797 includes a canonicalized copy of FILE_NAME.
12798 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12799 SEARCH_CWD is true if the current directory is to be searched.
12800 It will be searched before debug-file-directory.
12801 If successful, the file is added to the bfd include table of the
12802 objfile's bfd (see gdb_bfd_record_inclusion).
12803 If unable to find/open the file, return NULL.
12804 NOTE: This function is derived from symfile_bfd_open. */
12806 static gdb_bfd_ref_ptr
12807 try_open_dwop_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12808 const char *file_name, int is_dwp, int search_cwd)
12811 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12812 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12813 to debug_file_directory. */
12814 const char *search_path;
12815 static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
12817 gdb::unique_xmalloc_ptr<char> search_path_holder;
12820 if (*debug_file_directory != '\0')
12822 search_path_holder.reset (concat (".", dirname_separator_string,
12823 debug_file_directory,
12825 search_path = search_path_holder.get ();
12831 search_path = debug_file_directory;
12833 openp_flags flags = OPF_RETURN_REALPATH;
12835 flags |= OPF_SEARCH_IN_PATH;
12837 gdb::unique_xmalloc_ptr<char> absolute_name;
12838 desc = openp (search_path, flags, file_name,
12839 O_RDONLY | O_BINARY, &absolute_name);
12843 gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (absolute_name.get (),
12845 if (sym_bfd == NULL)
12847 bfd_set_cacheable (sym_bfd.get (), 1);
12849 if (!bfd_check_format (sym_bfd.get (), bfd_object))
12852 /* Success. Record the bfd as having been included by the objfile's bfd.
12853 This is important because things like demangled_names_hash lives in the
12854 objfile's per_bfd space and may have references to things like symbol
12855 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12856 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd.get ());
12861 /* Try to open DWO file FILE_NAME.
12862 COMP_DIR is the DW_AT_comp_dir attribute.
12863 The result is the bfd handle of the file.
12864 If there is a problem finding or opening the file, return NULL.
12865 Upon success, the canonicalized path of the file is stored in the bfd,
12866 same as symfile_bfd_open. */
12868 static gdb_bfd_ref_ptr
12869 open_dwo_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12870 const char *file_name, const char *comp_dir)
12872 if (IS_ABSOLUTE_PATH (file_name))
12873 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12874 0 /*is_dwp*/, 0 /*search_cwd*/);
12876 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12878 if (comp_dir != NULL)
12880 char *path_to_try = concat (comp_dir, SLASH_STRING,
12881 file_name, (char *) NULL);
12883 /* NOTE: If comp_dir is a relative path, this will also try the
12884 search path, which seems useful. */
12885 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile,
12888 1 /*search_cwd*/));
12889 xfree (path_to_try);
12894 /* That didn't work, try debug-file-directory, which, despite its name,
12895 is a list of paths. */
12897 if (*debug_file_directory == '\0')
12900 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12901 0 /*is_dwp*/, 1 /*search_cwd*/);
12904 /* This function is mapped across the sections and remembers the offset and
12905 size of each of the DWO debugging sections we are interested in. */
12908 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
12910 struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
12911 const struct dwop_section_names *names = &dwop_section_names;
12913 if (section_is_p (sectp->name, &names->abbrev_dwo))
12915 dwo_sections->abbrev.s.section = sectp;
12916 dwo_sections->abbrev.size = bfd_get_section_size (sectp);
12918 else if (section_is_p (sectp->name, &names->info_dwo))
12920 dwo_sections->info.s.section = sectp;
12921 dwo_sections->info.size = bfd_get_section_size (sectp);
12923 else if (section_is_p (sectp->name, &names->line_dwo))
12925 dwo_sections->line.s.section = sectp;
12926 dwo_sections->line.size = bfd_get_section_size (sectp);
12928 else if (section_is_p (sectp->name, &names->loc_dwo))
12930 dwo_sections->loc.s.section = sectp;
12931 dwo_sections->loc.size = bfd_get_section_size (sectp);
12933 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12935 dwo_sections->macinfo.s.section = sectp;
12936 dwo_sections->macinfo.size = bfd_get_section_size (sectp);
12938 else if (section_is_p (sectp->name, &names->macro_dwo))
12940 dwo_sections->macro.s.section = sectp;
12941 dwo_sections->macro.size = bfd_get_section_size (sectp);
12943 else if (section_is_p (sectp->name, &names->str_dwo))
12945 dwo_sections->str.s.section = sectp;
12946 dwo_sections->str.size = bfd_get_section_size (sectp);
12948 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12950 dwo_sections->str_offsets.s.section = sectp;
12951 dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
12953 else if (section_is_p (sectp->name, &names->types_dwo))
12955 struct dwarf2_section_info type_section;
12957 memset (&type_section, 0, sizeof (type_section));
12958 type_section.s.section = sectp;
12959 type_section.size = bfd_get_section_size (sectp);
12960 VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
12965 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12966 by PER_CU. This is for the non-DWP case.
12967 The result is NULL if DWO_NAME can't be found. */
12969 static struct dwo_file *
12970 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
12971 const char *dwo_name, const char *comp_dir)
12973 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
12974 struct objfile *objfile = dwarf2_per_objfile->objfile;
12976 gdb_bfd_ref_ptr dbfd (open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir));
12979 if (dwarf_read_debug)
12980 fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
12984 /* We use a unique pointer here, despite the obstack allocation,
12985 because a dwo_file needs some cleanup if it is abandoned. */
12986 dwo_file_up dwo_file (OBSTACK_ZALLOC (&objfile->objfile_obstack,
12988 dwo_file->dwo_name = dwo_name;
12989 dwo_file->comp_dir = comp_dir;
12990 dwo_file->dbfd = dbfd.release ();
12992 bfd_map_over_sections (dwo_file->dbfd, dwarf2_locate_dwo_sections,
12993 &dwo_file->sections);
12995 create_cus_hash_table (dwarf2_per_objfile, *dwo_file, dwo_file->sections.info,
12998 create_debug_types_hash_table (dwarf2_per_objfile, dwo_file.get (),
12999 dwo_file->sections.types, dwo_file->tus);
13001 if (dwarf_read_debug)
13002 fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
13004 return dwo_file.release ();
13007 /* This function is mapped across the sections and remembers the offset and
13008 size of each of the DWP debugging sections common to version 1 and 2 that
13009 we are interested in. */
13012 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
13013 void *dwp_file_ptr)
13015 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13016 const struct dwop_section_names *names = &dwop_section_names;
13017 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13019 /* Record the ELF section number for later lookup: this is what the
13020 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13021 gdb_assert (elf_section_nr < dwp_file->num_sections);
13022 dwp_file->elf_sections[elf_section_nr] = sectp;
13024 /* Look for specific sections that we need. */
13025 if (section_is_p (sectp->name, &names->str_dwo))
13027 dwp_file->sections.str.s.section = sectp;
13028 dwp_file->sections.str.size = bfd_get_section_size (sectp);
13030 else if (section_is_p (sectp->name, &names->cu_index))
13032 dwp_file->sections.cu_index.s.section = sectp;
13033 dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
13035 else if (section_is_p (sectp->name, &names->tu_index))
13037 dwp_file->sections.tu_index.s.section = sectp;
13038 dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
13042 /* This function is mapped across the sections and remembers the offset and
13043 size of each of the DWP version 2 debugging sections that we are interested
13044 in. This is split into a separate function because we don't know if we
13045 have version 1 or 2 until we parse the cu_index/tu_index sections. */
13048 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
13050 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13051 const struct dwop_section_names *names = &dwop_section_names;
13052 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13054 /* Record the ELF section number for later lookup: this is what the
13055 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13056 gdb_assert (elf_section_nr < dwp_file->num_sections);
13057 dwp_file->elf_sections[elf_section_nr] = sectp;
13059 /* Look for specific sections that we need. */
13060 if (section_is_p (sectp->name, &names->abbrev_dwo))
13062 dwp_file->sections.abbrev.s.section = sectp;
13063 dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
13065 else if (section_is_p (sectp->name, &names->info_dwo))
13067 dwp_file->sections.info.s.section = sectp;
13068 dwp_file->sections.info.size = bfd_get_section_size (sectp);
13070 else if (section_is_p (sectp->name, &names->line_dwo))
13072 dwp_file->sections.line.s.section = sectp;
13073 dwp_file->sections.line.size = bfd_get_section_size (sectp);
13075 else if (section_is_p (sectp->name, &names->loc_dwo))
13077 dwp_file->sections.loc.s.section = sectp;
13078 dwp_file->sections.loc.size = bfd_get_section_size (sectp);
13080 else if (section_is_p (sectp->name, &names->macinfo_dwo))
13082 dwp_file->sections.macinfo.s.section = sectp;
13083 dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
13085 else if (section_is_p (sectp->name, &names->macro_dwo))
13087 dwp_file->sections.macro.s.section = sectp;
13088 dwp_file->sections.macro.size = bfd_get_section_size (sectp);
13090 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
13092 dwp_file->sections.str_offsets.s.section = sectp;
13093 dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
13095 else if (section_is_p (sectp->name, &names->types_dwo))
13097 dwp_file->sections.types.s.section = sectp;
13098 dwp_file->sections.types.size = bfd_get_section_size (sectp);
13102 /* Hash function for dwp_file loaded CUs/TUs. */
13105 hash_dwp_loaded_cutus (const void *item)
13107 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
13109 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13110 return dwo_unit->signature;
13113 /* Equality function for dwp_file loaded CUs/TUs. */
13116 eq_dwp_loaded_cutus (const void *a, const void *b)
13118 const struct dwo_unit *dua = (const struct dwo_unit *) a;
13119 const struct dwo_unit *dub = (const struct dwo_unit *) b;
13121 return dua->signature == dub->signature;
13124 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13127 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
13129 return htab_create_alloc_ex (3,
13130 hash_dwp_loaded_cutus,
13131 eq_dwp_loaded_cutus,
13133 &objfile->objfile_obstack,
13134 hashtab_obstack_allocate,
13135 dummy_obstack_deallocate);
13138 /* Try to open DWP file FILE_NAME.
13139 The result is the bfd handle of the file.
13140 If there is a problem finding or opening the file, return NULL.
13141 Upon success, the canonicalized path of the file is stored in the bfd,
13142 same as symfile_bfd_open. */
13144 static gdb_bfd_ref_ptr
13145 open_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
13146 const char *file_name)
13148 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile, file_name,
13150 1 /*search_cwd*/));
13154 /* Work around upstream bug 15652.
13155 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13156 [Whether that's a "bug" is debatable, but it is getting in our way.]
13157 We have no real idea where the dwp file is, because gdb's realpath-ing
13158 of the executable's path may have discarded the needed info.
13159 [IWBN if the dwp file name was recorded in the executable, akin to
13160 .gnu_debuglink, but that doesn't exist yet.]
13161 Strip the directory from FILE_NAME and search again. */
13162 if (*debug_file_directory != '\0')
13164 /* Don't implicitly search the current directory here.
13165 If the user wants to search "." to handle this case,
13166 it must be added to debug-file-directory. */
13167 return try_open_dwop_file (dwarf2_per_objfile,
13168 lbasename (file_name), 1 /*is_dwp*/,
13175 /* Initialize the use of the DWP file for the current objfile.
13176 By convention the name of the DWP file is ${objfile}.dwp.
13177 The result is NULL if it can't be found. */
13179 static std::unique_ptr<struct dwp_file>
13180 open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13182 struct objfile *objfile = dwarf2_per_objfile->objfile;
13184 /* Try to find first .dwp for the binary file before any symbolic links
13187 /* If the objfile is a debug file, find the name of the real binary
13188 file and get the name of dwp file from there. */
13189 std::string dwp_name;
13190 if (objfile->separate_debug_objfile_backlink != NULL)
13192 struct objfile *backlink = objfile->separate_debug_objfile_backlink;
13193 const char *backlink_basename = lbasename (backlink->original_name);
13195 dwp_name = ldirname (objfile->original_name) + SLASH_STRING + backlink_basename;
13198 dwp_name = objfile->original_name;
13200 dwp_name += ".dwp";
13202 gdb_bfd_ref_ptr dbfd (open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ()));
13204 && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
13206 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13207 dwp_name = objfile_name (objfile);
13208 dwp_name += ".dwp";
13209 dbfd = open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ());
13214 if (dwarf_read_debug)
13215 fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name.c_str ());
13216 return std::unique_ptr<dwp_file> ();
13219 const char *name = bfd_get_filename (dbfd.get ());
13220 std::unique_ptr<struct dwp_file> dwp_file
13221 (new struct dwp_file (name, std::move (dbfd)));
13223 /* +1: section 0 is unused */
13224 dwp_file->num_sections = bfd_count_sections (dwp_file->dbfd) + 1;
13225 dwp_file->elf_sections =
13226 OBSTACK_CALLOC (&objfile->objfile_obstack,
13227 dwp_file->num_sections, asection *);
13229 bfd_map_over_sections (dwp_file->dbfd.get (),
13230 dwarf2_locate_common_dwp_sections,
13233 dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13236 dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13239 /* The DWP file version is stored in the hash table. Oh well. */
13240 if (dwp_file->cus && dwp_file->tus
13241 && dwp_file->cus->version != dwp_file->tus->version)
13243 /* Technically speaking, we should try to limp along, but this is
13244 pretty bizarre. We use pulongest here because that's the established
13245 portability solution (e.g, we cannot use %u for uint32_t). */
13246 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13247 " TU version %s [in DWP file %s]"),
13248 pulongest (dwp_file->cus->version),
13249 pulongest (dwp_file->tus->version), dwp_name.c_str ());
13253 dwp_file->version = dwp_file->cus->version;
13254 else if (dwp_file->tus)
13255 dwp_file->version = dwp_file->tus->version;
13257 dwp_file->version = 2;
13259 if (dwp_file->version == 2)
13260 bfd_map_over_sections (dwp_file->dbfd.get (),
13261 dwarf2_locate_v2_dwp_sections,
13264 dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
13265 dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
13267 if (dwarf_read_debug)
13269 fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
13270 fprintf_unfiltered (gdb_stdlog,
13271 " %s CUs, %s TUs\n",
13272 pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
13273 pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
13279 /* Wrapper around open_and_init_dwp_file, only open it once. */
13281 static struct dwp_file *
13282 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13284 if (! dwarf2_per_objfile->dwp_checked)
13286 dwarf2_per_objfile->dwp_file
13287 = open_and_init_dwp_file (dwarf2_per_objfile);
13288 dwarf2_per_objfile->dwp_checked = 1;
13290 return dwarf2_per_objfile->dwp_file.get ();
13293 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13294 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13295 or in the DWP file for the objfile, referenced by THIS_UNIT.
13296 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13297 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13299 This is called, for example, when wanting to read a variable with a
13300 complex location. Therefore we don't want to do file i/o for every call.
13301 Therefore we don't want to look for a DWO file on every call.
13302 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13303 then we check if we've already seen DWO_NAME, and only THEN do we check
13306 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13307 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13309 static struct dwo_unit *
13310 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
13311 const char *dwo_name, const char *comp_dir,
13312 ULONGEST signature, int is_debug_types)
13314 struct dwarf2_per_objfile *dwarf2_per_objfile = this_unit->dwarf2_per_objfile;
13315 struct objfile *objfile = dwarf2_per_objfile->objfile;
13316 const char *kind = is_debug_types ? "TU" : "CU";
13317 void **dwo_file_slot;
13318 struct dwo_file *dwo_file;
13319 struct dwp_file *dwp_file;
13321 /* First see if there's a DWP file.
13322 If we have a DWP file but didn't find the DWO inside it, don't
13323 look for the original DWO file. It makes gdb behave differently
13324 depending on whether one is debugging in the build tree. */
13326 dwp_file = get_dwp_file (dwarf2_per_objfile);
13327 if (dwp_file != NULL)
13329 const struct dwp_hash_table *dwp_htab =
13330 is_debug_types ? dwp_file->tus : dwp_file->cus;
13332 if (dwp_htab != NULL)
13334 struct dwo_unit *dwo_cutu =
13335 lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, comp_dir,
13336 signature, is_debug_types);
13338 if (dwo_cutu != NULL)
13340 if (dwarf_read_debug)
13342 fprintf_unfiltered (gdb_stdlog,
13343 "Virtual DWO %s %s found: @%s\n",
13344 kind, hex_string (signature),
13345 host_address_to_string (dwo_cutu));
13353 /* No DWP file, look for the DWO file. */
13355 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
13356 dwo_name, comp_dir);
13357 if (*dwo_file_slot == NULL)
13359 /* Read in the file and build a table of the CUs/TUs it contains. */
13360 *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
13362 /* NOTE: This will be NULL if unable to open the file. */
13363 dwo_file = (struct dwo_file *) *dwo_file_slot;
13365 if (dwo_file != NULL)
13367 struct dwo_unit *dwo_cutu = NULL;
13369 if (is_debug_types && dwo_file->tus)
13371 struct dwo_unit find_dwo_cutu;
13373 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13374 find_dwo_cutu.signature = signature;
13376 = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
13378 else if (!is_debug_types && dwo_file->cus)
13380 struct dwo_unit find_dwo_cutu;
13382 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13383 find_dwo_cutu.signature = signature;
13384 dwo_cutu = (struct dwo_unit *)htab_find (dwo_file->cus,
13388 if (dwo_cutu != NULL)
13390 if (dwarf_read_debug)
13392 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
13393 kind, dwo_name, hex_string (signature),
13394 host_address_to_string (dwo_cutu));
13401 /* We didn't find it. This could mean a dwo_id mismatch, or
13402 someone deleted the DWO/DWP file, or the search path isn't set up
13403 correctly to find the file. */
13405 if (dwarf_read_debug)
13407 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
13408 kind, dwo_name, hex_string (signature));
13411 /* This is a warning and not a complaint because it can be caused by
13412 pilot error (e.g., user accidentally deleting the DWO). */
13414 /* Print the name of the DWP file if we looked there, helps the user
13415 better diagnose the problem. */
13416 std::string dwp_text;
13418 if (dwp_file != NULL)
13419 dwp_text = string_printf (" [in DWP file %s]",
13420 lbasename (dwp_file->name));
13422 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13423 " [in module %s]"),
13424 kind, dwo_name, hex_string (signature),
13426 this_unit->is_debug_types ? "TU" : "CU",
13427 sect_offset_str (this_unit->sect_off), objfile_name (objfile));
13432 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13433 See lookup_dwo_cutu_unit for details. */
13435 static struct dwo_unit *
13436 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
13437 const char *dwo_name, const char *comp_dir,
13438 ULONGEST signature)
13440 return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
13443 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13444 See lookup_dwo_cutu_unit for details. */
13446 static struct dwo_unit *
13447 lookup_dwo_type_unit (struct signatured_type *this_tu,
13448 const char *dwo_name, const char *comp_dir)
13450 return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
13453 /* Traversal function for queue_and_load_all_dwo_tus. */
13456 queue_and_load_dwo_tu (void **slot, void *info)
13458 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
13459 struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
13460 ULONGEST signature = dwo_unit->signature;
13461 struct signatured_type *sig_type =
13462 lookup_dwo_signatured_type (per_cu->cu, signature);
13464 if (sig_type != NULL)
13466 struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
13468 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13469 a real dependency of PER_CU on SIG_TYPE. That is detected later
13470 while processing PER_CU. */
13471 if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
13472 load_full_type_unit (sig_cu);
13473 VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
13479 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13480 The DWO may have the only definition of the type, though it may not be
13481 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13482 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13485 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
13487 struct dwo_unit *dwo_unit;
13488 struct dwo_file *dwo_file;
13490 gdb_assert (!per_cu->is_debug_types);
13491 gdb_assert (get_dwp_file (per_cu->dwarf2_per_objfile) == NULL);
13492 gdb_assert (per_cu->cu != NULL);
13494 dwo_unit = per_cu->cu->dwo_unit;
13495 gdb_assert (dwo_unit != NULL);
13497 dwo_file = dwo_unit->dwo_file;
13498 if (dwo_file->tus != NULL)
13499 htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
13502 /* Free all resources associated with DWO_FILE.
13503 Close the DWO file and munmap the sections. */
13506 free_dwo_file (struct dwo_file *dwo_file)
13508 /* Note: dbfd is NULL for virtual DWO files. */
13509 gdb_bfd_unref (dwo_file->dbfd);
13511 VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
13514 /* Traversal function for free_dwo_files. */
13517 free_dwo_file_from_slot (void **slot, void *info)
13519 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
13521 free_dwo_file (dwo_file);
13526 /* Free all resources associated with DWO_FILES. */
13529 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
13531 htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
13534 /* Read in various DIEs. */
13536 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13537 Inherit only the children of the DW_AT_abstract_origin DIE not being
13538 already referenced by DW_AT_abstract_origin from the children of the
13542 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
13544 struct die_info *child_die;
13545 sect_offset *offsetp;
13546 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13547 struct die_info *origin_die;
13548 /* Iterator of the ORIGIN_DIE children. */
13549 struct die_info *origin_child_die;
13550 struct attribute *attr;
13551 struct dwarf2_cu *origin_cu;
13552 struct pending **origin_previous_list_in_scope;
13554 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13558 /* Note that following die references may follow to a die in a
13562 origin_die = follow_die_ref (die, attr, &origin_cu);
13564 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13566 origin_previous_list_in_scope = origin_cu->list_in_scope;
13567 origin_cu->list_in_scope = cu->list_in_scope;
13569 if (die->tag != origin_die->tag
13570 && !(die->tag == DW_TAG_inlined_subroutine
13571 && origin_die->tag == DW_TAG_subprogram))
13572 complaint (_("DIE %s and its abstract origin %s have different tags"),
13573 sect_offset_str (die->sect_off),
13574 sect_offset_str (origin_die->sect_off));
13576 std::vector<sect_offset> offsets;
13578 for (child_die = die->child;
13579 child_die && child_die->tag;
13580 child_die = sibling_die (child_die))
13582 struct die_info *child_origin_die;
13583 struct dwarf2_cu *child_origin_cu;
13585 /* We are trying to process concrete instance entries:
13586 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13587 it's not relevant to our analysis here. i.e. detecting DIEs that are
13588 present in the abstract instance but not referenced in the concrete
13590 if (child_die->tag == DW_TAG_call_site
13591 || child_die->tag == DW_TAG_GNU_call_site)
13594 /* For each CHILD_DIE, find the corresponding child of
13595 ORIGIN_DIE. If there is more than one layer of
13596 DW_AT_abstract_origin, follow them all; there shouldn't be,
13597 but GCC versions at least through 4.4 generate this (GCC PR
13599 child_origin_die = child_die;
13600 child_origin_cu = cu;
13603 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
13607 child_origin_die = follow_die_ref (child_origin_die, attr,
13611 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13612 counterpart may exist. */
13613 if (child_origin_die != child_die)
13615 if (child_die->tag != child_origin_die->tag
13616 && !(child_die->tag == DW_TAG_inlined_subroutine
13617 && child_origin_die->tag == DW_TAG_subprogram))
13618 complaint (_("Child DIE %s and its abstract origin %s have "
13620 sect_offset_str (child_die->sect_off),
13621 sect_offset_str (child_origin_die->sect_off));
13622 if (child_origin_die->parent != origin_die)
13623 complaint (_("Child DIE %s and its abstract origin %s have "
13624 "different parents"),
13625 sect_offset_str (child_die->sect_off),
13626 sect_offset_str (child_origin_die->sect_off));
13628 offsets.push_back (child_origin_die->sect_off);
13631 std::sort (offsets.begin (), offsets.end ());
13632 sect_offset *offsets_end = offsets.data () + offsets.size ();
13633 for (offsetp = offsets.data () + 1; offsetp < offsets_end; offsetp++)
13634 if (offsetp[-1] == *offsetp)
13635 complaint (_("Multiple children of DIE %s refer "
13636 "to DIE %s as their abstract origin"),
13637 sect_offset_str (die->sect_off), sect_offset_str (*offsetp));
13639 offsetp = offsets.data ();
13640 origin_child_die = origin_die->child;
13641 while (origin_child_die && origin_child_die->tag)
13643 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13644 while (offsetp < offsets_end
13645 && *offsetp < origin_child_die->sect_off)
13647 if (offsetp >= offsets_end
13648 || *offsetp > origin_child_die->sect_off)
13650 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13651 Check whether we're already processing ORIGIN_CHILD_DIE.
13652 This can happen with mutually referenced abstract_origins.
13654 if (!origin_child_die->in_process)
13655 process_die (origin_child_die, origin_cu);
13657 origin_child_die = sibling_die (origin_child_die);
13659 origin_cu->list_in_scope = origin_previous_list_in_scope;
13663 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
13665 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13666 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13667 struct context_stack *newobj;
13670 struct die_info *child_die;
13671 struct attribute *attr, *call_line, *call_file;
13673 CORE_ADDR baseaddr;
13674 struct block *block;
13675 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
13676 std::vector<struct symbol *> template_args;
13677 struct template_symbol *templ_func = NULL;
13681 /* If we do not have call site information, we can't show the
13682 caller of this inlined function. That's too confusing, so
13683 only use the scope for local variables. */
13684 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
13685 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
13686 if (call_line == NULL || call_file == NULL)
13688 read_lexical_block_scope (die, cu);
13693 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13695 name = dwarf2_name (die, cu);
13697 /* Ignore functions with missing or empty names. These are actually
13698 illegal according to the DWARF standard. */
13701 complaint (_("missing name for subprogram DIE at %s"),
13702 sect_offset_str (die->sect_off));
13706 /* Ignore functions with missing or invalid low and high pc attributes. */
13707 if (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL)
13708 <= PC_BOUNDS_INVALID)
13710 attr = dwarf2_attr (die, DW_AT_external, cu);
13711 if (!attr || !DW_UNSND (attr))
13712 complaint (_("cannot get low and high bounds "
13713 "for subprogram DIE at %s"),
13714 sect_offset_str (die->sect_off));
13718 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13719 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13721 /* If we have any template arguments, then we must allocate a
13722 different sort of symbol. */
13723 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
13725 if (child_die->tag == DW_TAG_template_type_param
13726 || child_die->tag == DW_TAG_template_value_param)
13728 templ_func = allocate_template_symbol (objfile);
13729 templ_func->subclass = SYMBOL_TEMPLATE;
13734 newobj = cu->builder->push_context (0, lowpc);
13735 newobj->name = new_symbol (die, read_type_die (die, cu), cu,
13736 (struct symbol *) templ_func);
13738 /* If there is a location expression for DW_AT_frame_base, record
13740 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
13742 dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
13744 /* If there is a location for the static link, record it. */
13745 newobj->static_link = NULL;
13746 attr = dwarf2_attr (die, DW_AT_static_link, cu);
13749 newobj->static_link
13750 = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
13751 attr_to_dynamic_prop (attr, die, cu, newobj->static_link);
13754 cu->list_in_scope = cu->builder->get_local_symbols ();
13756 if (die->child != NULL)
13758 child_die = die->child;
13759 while (child_die && child_die->tag)
13761 if (child_die->tag == DW_TAG_template_type_param
13762 || child_die->tag == DW_TAG_template_value_param)
13764 struct symbol *arg = new_symbol (child_die, NULL, cu);
13767 template_args.push_back (arg);
13770 process_die (child_die, cu);
13771 child_die = sibling_die (child_die);
13775 inherit_abstract_dies (die, cu);
13777 /* If we have a DW_AT_specification, we might need to import using
13778 directives from the context of the specification DIE. See the
13779 comment in determine_prefix. */
13780 if (cu->language == language_cplus
13781 && dwarf2_attr (die, DW_AT_specification, cu))
13783 struct dwarf2_cu *spec_cu = cu;
13784 struct die_info *spec_die = die_specification (die, &spec_cu);
13788 child_die = spec_die->child;
13789 while (child_die && child_die->tag)
13791 if (child_die->tag == DW_TAG_imported_module)
13792 process_die (child_die, spec_cu);
13793 child_die = sibling_die (child_die);
13796 /* In some cases, GCC generates specification DIEs that
13797 themselves contain DW_AT_specification attributes. */
13798 spec_die = die_specification (spec_die, &spec_cu);
13802 struct context_stack cstk = cu->builder->pop_context ();
13803 /* Make a block for the local symbols within. */
13804 block = cu->builder->finish_block (cstk.name, cstk.old_blocks,
13805 cstk.static_link, lowpc, highpc);
13807 /* For C++, set the block's scope. */
13808 if ((cu->language == language_cplus
13809 || cu->language == language_fortran
13810 || cu->language == language_d
13811 || cu->language == language_rust)
13812 && cu->processing_has_namespace_info)
13813 block_set_scope (block, determine_prefix (die, cu),
13814 &objfile->objfile_obstack);
13816 /* If we have address ranges, record them. */
13817 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13819 gdbarch_make_symbol_special (gdbarch, cstk.name, objfile);
13821 /* Attach template arguments to function. */
13822 if (!template_args.empty ())
13824 gdb_assert (templ_func != NULL);
13826 templ_func->n_template_arguments = template_args.size ();
13827 templ_func->template_arguments
13828 = XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
13829 templ_func->n_template_arguments);
13830 memcpy (templ_func->template_arguments,
13831 template_args.data (),
13832 (templ_func->n_template_arguments * sizeof (struct symbol *)));
13834 /* Make sure that the symtab is set on the new symbols. Even
13835 though they don't appear in this symtab directly, other parts
13836 of gdb assume that symbols do, and this is reasonably
13838 for (symbol *sym : template_args)
13839 symbol_set_symtab (sym, symbol_symtab (templ_func));
13842 /* In C++, we can have functions nested inside functions (e.g., when
13843 a function declares a class that has methods). This means that
13844 when we finish processing a function scope, we may need to go
13845 back to building a containing block's symbol lists. */
13846 *cu->builder->get_local_symbols () = cstk.locals;
13847 cu->builder->set_local_using_directives (cstk.local_using_directives);
13849 /* If we've finished processing a top-level function, subsequent
13850 symbols go in the file symbol list. */
13851 if (cu->builder->outermost_context_p ())
13852 cu->list_in_scope = cu->builder->get_file_symbols ();
13855 /* Process all the DIES contained within a lexical block scope. Start
13856 a new scope, process the dies, and then close the scope. */
13859 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
13861 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13862 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13863 CORE_ADDR lowpc, highpc;
13864 struct die_info *child_die;
13865 CORE_ADDR baseaddr;
13867 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13869 /* Ignore blocks with missing or invalid low and high pc attributes. */
13870 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13871 as multiple lexical blocks? Handling children in a sane way would
13872 be nasty. Might be easier to properly extend generic blocks to
13873 describe ranges. */
13874 switch (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
13876 case PC_BOUNDS_NOT_PRESENT:
13877 /* DW_TAG_lexical_block has no attributes, process its children as if
13878 there was no wrapping by that DW_TAG_lexical_block.
13879 GCC does no longer produces such DWARF since GCC r224161. */
13880 for (child_die = die->child;
13881 child_die != NULL && child_die->tag;
13882 child_die = sibling_die (child_die))
13883 process_die (child_die, cu);
13885 case PC_BOUNDS_INVALID:
13888 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13889 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13891 cu->builder->push_context (0, lowpc);
13892 if (die->child != NULL)
13894 child_die = die->child;
13895 while (child_die && child_die->tag)
13897 process_die (child_die, cu);
13898 child_die = sibling_die (child_die);
13901 inherit_abstract_dies (die, cu);
13902 struct context_stack cstk = cu->builder->pop_context ();
13904 if (*cu->builder->get_local_symbols () != NULL
13905 || (*cu->builder->get_local_using_directives ()) != NULL)
13907 struct block *block
13908 = cu->builder->finish_block (0, cstk.old_blocks, NULL,
13909 cstk.start_addr, highpc);
13911 /* Note that recording ranges after traversing children, as we
13912 do here, means that recording a parent's ranges entails
13913 walking across all its children's ranges as they appear in
13914 the address map, which is quadratic behavior.
13916 It would be nicer to record the parent's ranges before
13917 traversing its children, simply overriding whatever you find
13918 there. But since we don't even decide whether to create a
13919 block until after we've traversed its children, that's hard
13921 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13923 *cu->builder->get_local_symbols () = cstk.locals;
13924 cu->builder->set_local_using_directives (cstk.local_using_directives);
13927 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13930 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
13932 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13933 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13934 CORE_ADDR pc, baseaddr;
13935 struct attribute *attr;
13936 struct call_site *call_site, call_site_local;
13939 struct die_info *child_die;
13941 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13943 attr = dwarf2_attr (die, DW_AT_call_return_pc, cu);
13946 /* This was a pre-DWARF-5 GNU extension alias
13947 for DW_AT_call_return_pc. */
13948 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
13952 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13953 "DIE %s [in module %s]"),
13954 sect_offset_str (die->sect_off), objfile_name (objfile));
13957 pc = attr_value_as_address (attr) + baseaddr;
13958 pc = gdbarch_adjust_dwarf2_addr (gdbarch, pc);
13960 if (cu->call_site_htab == NULL)
13961 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
13962 NULL, &objfile->objfile_obstack,
13963 hashtab_obstack_allocate, NULL);
13964 call_site_local.pc = pc;
13965 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
13968 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13969 "DIE %s [in module %s]"),
13970 paddress (gdbarch, pc), sect_offset_str (die->sect_off),
13971 objfile_name (objfile));
13975 /* Count parameters at the caller. */
13978 for (child_die = die->child; child_die && child_die->tag;
13979 child_die = sibling_die (child_die))
13981 if (child_die->tag != DW_TAG_call_site_parameter
13982 && child_die->tag != DW_TAG_GNU_call_site_parameter)
13984 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13985 "DW_TAG_call_site child DIE %s [in module %s]"),
13986 child_die->tag, sect_offset_str (child_die->sect_off),
13987 objfile_name (objfile));
13995 = ((struct call_site *)
13996 obstack_alloc (&objfile->objfile_obstack,
13997 sizeof (*call_site)
13998 + (sizeof (*call_site->parameter) * (nparams - 1))));
14000 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
14001 call_site->pc = pc;
14003 if (dwarf2_flag_true_p (die, DW_AT_call_tail_call, cu)
14004 || dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
14006 struct die_info *func_die;
14008 /* Skip also over DW_TAG_inlined_subroutine. */
14009 for (func_die = die->parent;
14010 func_die && func_die->tag != DW_TAG_subprogram
14011 && func_die->tag != DW_TAG_subroutine_type;
14012 func_die = func_die->parent);
14014 /* DW_AT_call_all_calls is a superset
14015 of DW_AT_call_all_tail_calls. */
14017 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_calls, cu)
14018 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
14019 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_tail_calls, cu)
14020 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
14022 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
14023 not complete. But keep CALL_SITE for look ups via call_site_htab,
14024 both the initial caller containing the real return address PC and
14025 the final callee containing the current PC of a chain of tail
14026 calls do not need to have the tail call list complete. But any
14027 function candidate for a virtual tail call frame searched via
14028 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14029 determined unambiguously. */
14033 struct type *func_type = NULL;
14036 func_type = get_die_type (func_die, cu);
14037 if (func_type != NULL)
14039 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
14041 /* Enlist this call site to the function. */
14042 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
14043 TYPE_TAIL_CALL_LIST (func_type) = call_site;
14046 complaint (_("Cannot find function owning DW_TAG_call_site "
14047 "DIE %s [in module %s]"),
14048 sect_offset_str (die->sect_off), objfile_name (objfile));
14052 attr = dwarf2_attr (die, DW_AT_call_target, cu);
14054 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
14056 attr = dwarf2_attr (die, DW_AT_call_origin, cu);
14059 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
14060 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14062 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
14063 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
14064 /* Keep NULL DWARF_BLOCK. */;
14065 else if (attr_form_is_block (attr))
14067 struct dwarf2_locexpr_baton *dlbaton;
14069 dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
14070 dlbaton->data = DW_BLOCK (attr)->data;
14071 dlbaton->size = DW_BLOCK (attr)->size;
14072 dlbaton->per_cu = cu->per_cu;
14074 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
14076 else if (attr_form_is_ref (attr))
14078 struct dwarf2_cu *target_cu = cu;
14079 struct die_info *target_die;
14081 target_die = follow_die_ref (die, attr, &target_cu);
14082 gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
14083 if (die_is_declaration (target_die, target_cu))
14085 const char *target_physname;
14087 /* Prefer the mangled name; otherwise compute the demangled one. */
14088 target_physname = dw2_linkage_name (target_die, target_cu);
14089 if (target_physname == NULL)
14090 target_physname = dwarf2_physname (NULL, target_die, target_cu);
14091 if (target_physname == NULL)
14092 complaint (_("DW_AT_call_target target DIE has invalid "
14093 "physname, for referencing DIE %s [in module %s]"),
14094 sect_offset_str (die->sect_off), objfile_name (objfile));
14096 SET_FIELD_PHYSNAME (call_site->target, target_physname);
14102 /* DW_AT_entry_pc should be preferred. */
14103 if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
14104 <= PC_BOUNDS_INVALID)
14105 complaint (_("DW_AT_call_target target DIE has invalid "
14106 "low pc, for referencing DIE %s [in module %s]"),
14107 sect_offset_str (die->sect_off), objfile_name (objfile));
14110 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
14111 SET_FIELD_PHYSADDR (call_site->target, lowpc);
14116 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14117 "block nor reference, for DIE %s [in module %s]"),
14118 sect_offset_str (die->sect_off), objfile_name (objfile));
14120 call_site->per_cu = cu->per_cu;
14122 for (child_die = die->child;
14123 child_die && child_die->tag;
14124 child_die = sibling_die (child_die))
14126 struct call_site_parameter *parameter;
14127 struct attribute *loc, *origin;
14129 if (child_die->tag != DW_TAG_call_site_parameter
14130 && child_die->tag != DW_TAG_GNU_call_site_parameter)
14132 /* Already printed the complaint above. */
14136 gdb_assert (call_site->parameter_count < nparams);
14137 parameter = &call_site->parameter[call_site->parameter_count];
14139 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14140 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14141 register is contained in DW_AT_call_value. */
14143 loc = dwarf2_attr (child_die, DW_AT_location, cu);
14144 origin = dwarf2_attr (child_die, DW_AT_call_parameter, cu);
14145 if (origin == NULL)
14147 /* This was a pre-DWARF-5 GNU extension alias
14148 for DW_AT_call_parameter. */
14149 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
14151 if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
14153 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
14155 sect_offset sect_off
14156 = (sect_offset) dwarf2_get_ref_die_offset (origin);
14157 if (!offset_in_cu_p (&cu->header, sect_off))
14159 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14160 binding can be done only inside one CU. Such referenced DIE
14161 therefore cannot be even moved to DW_TAG_partial_unit. */
14162 complaint (_("DW_AT_call_parameter offset is not in CU for "
14163 "DW_TAG_call_site child DIE %s [in module %s]"),
14164 sect_offset_str (child_die->sect_off),
14165 objfile_name (objfile));
14168 parameter->u.param_cu_off
14169 = (cu_offset) (sect_off - cu->header.sect_off);
14171 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
14173 complaint (_("No DW_FORM_block* DW_AT_location for "
14174 "DW_TAG_call_site child DIE %s [in module %s]"),
14175 sect_offset_str (child_die->sect_off), objfile_name (objfile));
14180 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
14181 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
14182 if (parameter->u.dwarf_reg != -1)
14183 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
14184 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
14185 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
14186 ¶meter->u.fb_offset))
14187 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
14190 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14191 "for DW_FORM_block* DW_AT_location is supported for "
14192 "DW_TAG_call_site child DIE %s "
14194 sect_offset_str (child_die->sect_off),
14195 objfile_name (objfile));
14200 attr = dwarf2_attr (child_die, DW_AT_call_value, cu);
14202 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
14203 if (!attr_form_is_block (attr))
14205 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14206 "DW_TAG_call_site child DIE %s [in module %s]"),
14207 sect_offset_str (child_die->sect_off),
14208 objfile_name (objfile));
14211 parameter->value = DW_BLOCK (attr)->data;
14212 parameter->value_size = DW_BLOCK (attr)->size;
14214 /* Parameters are not pre-cleared by memset above. */
14215 parameter->data_value = NULL;
14216 parameter->data_value_size = 0;
14217 call_site->parameter_count++;
14219 attr = dwarf2_attr (child_die, DW_AT_call_data_value, cu);
14221 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
14224 if (!attr_form_is_block (attr))
14225 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14226 "DW_TAG_call_site child DIE %s [in module %s]"),
14227 sect_offset_str (child_die->sect_off),
14228 objfile_name (objfile));
14231 parameter->data_value = DW_BLOCK (attr)->data;
14232 parameter->data_value_size = DW_BLOCK (attr)->size;
14238 /* Helper function for read_variable. If DIE represents a virtual
14239 table, then return the type of the concrete object that is
14240 associated with the virtual table. Otherwise, return NULL. */
14242 static struct type *
14243 rust_containing_type (struct die_info *die, struct dwarf2_cu *cu)
14245 struct attribute *attr = dwarf2_attr (die, DW_AT_type, cu);
14249 /* Find the type DIE. */
14250 struct die_info *type_die = NULL;
14251 struct dwarf2_cu *type_cu = cu;
14253 if (attr_form_is_ref (attr))
14254 type_die = follow_die_ref (die, attr, &type_cu);
14255 if (type_die == NULL)
14258 if (dwarf2_attr (type_die, DW_AT_containing_type, type_cu) == NULL)
14260 return die_containing_type (type_die, type_cu);
14263 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14266 read_variable (struct die_info *die, struct dwarf2_cu *cu)
14268 struct rust_vtable_symbol *storage = NULL;
14270 if (cu->language == language_rust)
14272 struct type *containing_type = rust_containing_type (die, cu);
14274 if (containing_type != NULL)
14276 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14278 storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
14279 struct rust_vtable_symbol);
14280 initialize_objfile_symbol (storage);
14281 storage->concrete_type = containing_type;
14282 storage->subclass = SYMBOL_RUST_VTABLE;
14286 struct symbol *res = new_symbol (die, NULL, cu, storage);
14287 struct attribute *abstract_origin
14288 = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14289 struct attribute *loc = dwarf2_attr (die, DW_AT_location, cu);
14290 if (res == NULL && loc && abstract_origin)
14292 /* We have a variable without a name, but with a location and an abstract
14293 origin. This may be a concrete instance of an abstract variable
14294 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14296 struct dwarf2_cu *origin_cu = cu;
14297 struct die_info *origin_die
14298 = follow_die_ref (die, abstract_origin, &origin_cu);
14299 dwarf2_per_objfile *dpo = cu->per_cu->dwarf2_per_objfile;
14300 dpo->abstract_to_concrete[origin_die].push_back (die);
14304 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14305 reading .debug_rnglists.
14306 Callback's type should be:
14307 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14308 Return true if the attributes are present and valid, otherwise,
14311 template <typename Callback>
14313 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
14314 Callback &&callback)
14316 struct dwarf2_per_objfile *dwarf2_per_objfile
14317 = cu->per_cu->dwarf2_per_objfile;
14318 struct objfile *objfile = dwarf2_per_objfile->objfile;
14319 bfd *obfd = objfile->obfd;
14320 /* Base address selection entry. */
14323 const gdb_byte *buffer;
14324 CORE_ADDR baseaddr;
14325 bool overflow = false;
14327 found_base = cu->base_known;
14328 base = cu->base_address;
14330 dwarf2_read_section (objfile, &dwarf2_per_objfile->rnglists);
14331 if (offset >= dwarf2_per_objfile->rnglists.size)
14333 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14337 buffer = dwarf2_per_objfile->rnglists.buffer + offset;
14339 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14343 /* Initialize it due to a false compiler warning. */
14344 CORE_ADDR range_beginning = 0, range_end = 0;
14345 const gdb_byte *buf_end = (dwarf2_per_objfile->rnglists.buffer
14346 + dwarf2_per_objfile->rnglists.size);
14347 unsigned int bytes_read;
14349 if (buffer == buf_end)
14354 const auto rlet = static_cast<enum dwarf_range_list_entry>(*buffer++);
14357 case DW_RLE_end_of_list:
14359 case DW_RLE_base_address:
14360 if (buffer + cu->header.addr_size > buf_end)
14365 base = read_address (obfd, buffer, cu, &bytes_read);
14367 buffer += bytes_read;
14369 case DW_RLE_start_length:
14370 if (buffer + cu->header.addr_size > buf_end)
14375 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14376 buffer += bytes_read;
14377 range_end = (range_beginning
14378 + read_unsigned_leb128 (obfd, buffer, &bytes_read));
14379 buffer += bytes_read;
14380 if (buffer > buf_end)
14386 case DW_RLE_offset_pair:
14387 range_beginning = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14388 buffer += bytes_read;
14389 if (buffer > buf_end)
14394 range_end = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14395 buffer += bytes_read;
14396 if (buffer > buf_end)
14402 case DW_RLE_start_end:
14403 if (buffer + 2 * cu->header.addr_size > buf_end)
14408 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14409 buffer += bytes_read;
14410 range_end = read_address (obfd, buffer, cu, &bytes_read);
14411 buffer += bytes_read;
14414 complaint (_("Invalid .debug_rnglists data (no base address)"));
14417 if (rlet == DW_RLE_end_of_list || overflow)
14419 if (rlet == DW_RLE_base_address)
14424 /* We have no valid base address for the ranges
14426 complaint (_("Invalid .debug_rnglists data (no base address)"));
14430 if (range_beginning > range_end)
14432 /* Inverted range entries are invalid. */
14433 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14437 /* Empty range entries have no effect. */
14438 if (range_beginning == range_end)
14441 range_beginning += base;
14444 /* A not-uncommon case of bad debug info.
14445 Don't pollute the addrmap with bad data. */
14446 if (range_beginning + baseaddr == 0
14447 && !dwarf2_per_objfile->has_section_at_zero)
14449 complaint (_(".debug_rnglists entry has start address of zero"
14450 " [in module %s]"), objfile_name (objfile));
14454 callback (range_beginning, range_end);
14459 complaint (_("Offset %d is not terminated "
14460 "for DW_AT_ranges attribute"),
14468 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14469 Callback's type should be:
14470 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14471 Return 1 if the attributes are present and valid, otherwise, return 0. */
14473 template <typename Callback>
14475 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
14476 Callback &&callback)
14478 struct dwarf2_per_objfile *dwarf2_per_objfile
14479 = cu->per_cu->dwarf2_per_objfile;
14480 struct objfile *objfile = dwarf2_per_objfile->objfile;
14481 struct comp_unit_head *cu_header = &cu->header;
14482 bfd *obfd = objfile->obfd;
14483 unsigned int addr_size = cu_header->addr_size;
14484 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
14485 /* Base address selection entry. */
14488 unsigned int dummy;
14489 const gdb_byte *buffer;
14490 CORE_ADDR baseaddr;
14492 if (cu_header->version >= 5)
14493 return dwarf2_rnglists_process (offset, cu, callback);
14495 found_base = cu->base_known;
14496 base = cu->base_address;
14498 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
14499 if (offset >= dwarf2_per_objfile->ranges.size)
14501 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14505 buffer = dwarf2_per_objfile->ranges.buffer + offset;
14507 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14511 CORE_ADDR range_beginning, range_end;
14513 range_beginning = read_address (obfd, buffer, cu, &dummy);
14514 buffer += addr_size;
14515 range_end = read_address (obfd, buffer, cu, &dummy);
14516 buffer += addr_size;
14517 offset += 2 * addr_size;
14519 /* An end of list marker is a pair of zero addresses. */
14520 if (range_beginning == 0 && range_end == 0)
14521 /* Found the end of list entry. */
14524 /* Each base address selection entry is a pair of 2 values.
14525 The first is the largest possible address, the second is
14526 the base address. Check for a base address here. */
14527 if ((range_beginning & mask) == mask)
14529 /* If we found the largest possible address, then we already
14530 have the base address in range_end. */
14538 /* We have no valid base address for the ranges
14540 complaint (_("Invalid .debug_ranges data (no base address)"));
14544 if (range_beginning > range_end)
14546 /* Inverted range entries are invalid. */
14547 complaint (_("Invalid .debug_ranges data (inverted range)"));
14551 /* Empty range entries have no effect. */
14552 if (range_beginning == range_end)
14555 range_beginning += base;
14558 /* A not-uncommon case of bad debug info.
14559 Don't pollute the addrmap with bad data. */
14560 if (range_beginning + baseaddr == 0
14561 && !dwarf2_per_objfile->has_section_at_zero)
14563 complaint (_(".debug_ranges entry has start address of zero"
14564 " [in module %s]"), objfile_name (objfile));
14568 callback (range_beginning, range_end);
14574 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14575 Return 1 if the attributes are present and valid, otherwise, return 0.
14576 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14579 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
14580 CORE_ADDR *high_return, struct dwarf2_cu *cu,
14581 struct partial_symtab *ranges_pst)
14583 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14584 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14585 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
14586 SECT_OFF_TEXT (objfile));
14589 CORE_ADDR high = 0;
14592 retval = dwarf2_ranges_process (offset, cu,
14593 [&] (CORE_ADDR range_beginning, CORE_ADDR range_end)
14595 if (ranges_pst != NULL)
14600 lowpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14601 range_beginning + baseaddr)
14603 highpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14604 range_end + baseaddr)
14606 addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
14607 lowpc, highpc - 1, ranges_pst);
14610 /* FIXME: This is recording everything as a low-high
14611 segment of consecutive addresses. We should have a
14612 data structure for discontiguous block ranges
14616 low = range_beginning;
14622 if (range_beginning < low)
14623 low = range_beginning;
14624 if (range_end > high)
14632 /* If the first entry is an end-of-list marker, the range
14633 describes an empty scope, i.e. no instructions. */
14639 *high_return = high;
14643 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14644 definition for the return value. *LOWPC and *HIGHPC are set iff
14645 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14647 static enum pc_bounds_kind
14648 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
14649 CORE_ADDR *highpc, struct dwarf2_cu *cu,
14650 struct partial_symtab *pst)
14652 struct dwarf2_per_objfile *dwarf2_per_objfile
14653 = cu->per_cu->dwarf2_per_objfile;
14654 struct attribute *attr;
14655 struct attribute *attr_high;
14657 CORE_ADDR high = 0;
14658 enum pc_bounds_kind ret;
14660 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14663 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14666 low = attr_value_as_address (attr);
14667 high = attr_value_as_address (attr_high);
14668 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14672 /* Found high w/o low attribute. */
14673 return PC_BOUNDS_INVALID;
14675 /* Found consecutive range of addresses. */
14676 ret = PC_BOUNDS_HIGH_LOW;
14680 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14683 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14684 We take advantage of the fact that DW_AT_ranges does not appear
14685 in DW_TAG_compile_unit of DWO files. */
14686 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14687 unsigned int ranges_offset = (DW_UNSND (attr)
14688 + (need_ranges_base
14692 /* Value of the DW_AT_ranges attribute is the offset in the
14693 .debug_ranges section. */
14694 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
14695 return PC_BOUNDS_INVALID;
14696 /* Found discontinuous range of addresses. */
14697 ret = PC_BOUNDS_RANGES;
14700 return PC_BOUNDS_NOT_PRESENT;
14703 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14705 return PC_BOUNDS_INVALID;
14707 /* When using the GNU linker, .gnu.linkonce. sections are used to
14708 eliminate duplicate copies of functions and vtables and such.
14709 The linker will arbitrarily choose one and discard the others.
14710 The AT_*_pc values for such functions refer to local labels in
14711 these sections. If the section from that file was discarded, the
14712 labels are not in the output, so the relocs get a value of 0.
14713 If this is a discarded function, mark the pc bounds as invalid,
14714 so that GDB will ignore it. */
14715 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
14716 return PC_BOUNDS_INVALID;
14724 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14725 its low and high PC addresses. Do nothing if these addresses could not
14726 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14727 and HIGHPC to the high address if greater than HIGHPC. */
14730 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
14731 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14732 struct dwarf2_cu *cu)
14734 CORE_ADDR low, high;
14735 struct die_info *child = die->child;
14737 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL) >= PC_BOUNDS_RANGES)
14739 *lowpc = std::min (*lowpc, low);
14740 *highpc = std::max (*highpc, high);
14743 /* If the language does not allow nested subprograms (either inside
14744 subprograms or lexical blocks), we're done. */
14745 if (cu->language != language_ada)
14748 /* Check all the children of the given DIE. If it contains nested
14749 subprograms, then check their pc bounds. Likewise, we need to
14750 check lexical blocks as well, as they may also contain subprogram
14752 while (child && child->tag)
14754 if (child->tag == DW_TAG_subprogram
14755 || child->tag == DW_TAG_lexical_block)
14756 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
14757 child = sibling_die (child);
14761 /* Get the low and high pc's represented by the scope DIE, and store
14762 them in *LOWPC and *HIGHPC. If the correct values can't be
14763 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14766 get_scope_pc_bounds (struct die_info *die,
14767 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14768 struct dwarf2_cu *cu)
14770 CORE_ADDR best_low = (CORE_ADDR) -1;
14771 CORE_ADDR best_high = (CORE_ADDR) 0;
14772 CORE_ADDR current_low, current_high;
14774 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL)
14775 >= PC_BOUNDS_RANGES)
14777 best_low = current_low;
14778 best_high = current_high;
14782 struct die_info *child = die->child;
14784 while (child && child->tag)
14786 switch (child->tag) {
14787 case DW_TAG_subprogram:
14788 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
14790 case DW_TAG_namespace:
14791 case DW_TAG_module:
14792 /* FIXME: carlton/2004-01-16: Should we do this for
14793 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14794 that current GCC's always emit the DIEs corresponding
14795 to definitions of methods of classes as children of a
14796 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14797 the DIEs giving the declarations, which could be
14798 anywhere). But I don't see any reason why the
14799 standards says that they have to be there. */
14800 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
14802 if (current_low != ((CORE_ADDR) -1))
14804 best_low = std::min (best_low, current_low);
14805 best_high = std::max (best_high, current_high);
14813 child = sibling_die (child);
14818 *highpc = best_high;
14821 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14825 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
14826 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
14828 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14829 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14830 struct attribute *attr;
14831 struct attribute *attr_high;
14833 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14836 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14839 CORE_ADDR low = attr_value_as_address (attr);
14840 CORE_ADDR high = attr_value_as_address (attr_high);
14842 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14845 low = gdbarch_adjust_dwarf2_addr (gdbarch, low + baseaddr);
14846 high = gdbarch_adjust_dwarf2_addr (gdbarch, high + baseaddr);
14847 cu->builder->record_block_range (block, low, high - 1);
14851 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14854 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14855 We take advantage of the fact that DW_AT_ranges does not appear
14856 in DW_TAG_compile_unit of DWO files. */
14857 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14859 /* The value of the DW_AT_ranges attribute is the offset of the
14860 address range list in the .debug_ranges section. */
14861 unsigned long offset = (DW_UNSND (attr)
14862 + (need_ranges_base ? cu->ranges_base : 0));
14864 std::vector<blockrange> blockvec;
14865 dwarf2_ranges_process (offset, cu,
14866 [&] (CORE_ADDR start, CORE_ADDR end)
14870 start = gdbarch_adjust_dwarf2_addr (gdbarch, start);
14871 end = gdbarch_adjust_dwarf2_addr (gdbarch, end);
14872 cu->builder->record_block_range (block, start, end - 1);
14873 blockvec.emplace_back (start, end);
14876 BLOCK_RANGES(block) = make_blockranges (objfile, blockvec);
14880 /* Check whether the producer field indicates either of GCC < 4.6, or the
14881 Intel C/C++ compiler, and cache the result in CU. */
14884 check_producer (struct dwarf2_cu *cu)
14888 if (cu->producer == NULL)
14890 /* For unknown compilers expect their behavior is DWARF version
14893 GCC started to support .debug_types sections by -gdwarf-4 since
14894 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14895 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14896 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14897 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14899 else if (producer_is_gcc (cu->producer, &major, &minor))
14901 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
14902 cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
14904 else if (producer_is_icc (cu->producer, &major, &minor))
14906 cu->producer_is_icc = true;
14907 cu->producer_is_icc_lt_14 = major < 14;
14909 else if (startswith (cu->producer, "CodeWarrior S12/L-ISA"))
14910 cu->producer_is_codewarrior = true;
14913 /* For other non-GCC compilers, expect their behavior is DWARF version
14917 cu->checked_producer = true;
14920 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14921 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14922 during 4.6.0 experimental. */
14925 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
14927 if (!cu->checked_producer)
14928 check_producer (cu);
14930 return cu->producer_is_gxx_lt_4_6;
14934 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14935 with incorrect is_stmt attributes. */
14938 producer_is_codewarrior (struct dwarf2_cu *cu)
14940 if (!cu->checked_producer)
14941 check_producer (cu);
14943 return cu->producer_is_codewarrior;
14946 /* Return the default accessibility type if it is not overriden by
14947 DW_AT_accessibility. */
14949 static enum dwarf_access_attribute
14950 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
14952 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
14954 /* The default DWARF 2 accessibility for members is public, the default
14955 accessibility for inheritance is private. */
14957 if (die->tag != DW_TAG_inheritance)
14958 return DW_ACCESS_public;
14960 return DW_ACCESS_private;
14964 /* DWARF 3+ defines the default accessibility a different way. The same
14965 rules apply now for DW_TAG_inheritance as for the members and it only
14966 depends on the container kind. */
14968 if (die->parent->tag == DW_TAG_class_type)
14969 return DW_ACCESS_private;
14971 return DW_ACCESS_public;
14975 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14976 offset. If the attribute was not found return 0, otherwise return
14977 1. If it was found but could not properly be handled, set *OFFSET
14981 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
14984 struct attribute *attr;
14986 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
14991 /* Note that we do not check for a section offset first here.
14992 This is because DW_AT_data_member_location is new in DWARF 4,
14993 so if we see it, we can assume that a constant form is really
14994 a constant and not a section offset. */
14995 if (attr_form_is_constant (attr))
14996 *offset = dwarf2_get_attr_constant_value (attr, 0);
14997 else if (attr_form_is_section_offset (attr))
14998 dwarf2_complex_location_expr_complaint ();
14999 else if (attr_form_is_block (attr))
15000 *offset = decode_locdesc (DW_BLOCK (attr), cu);
15002 dwarf2_complex_location_expr_complaint ();
15010 /* Add an aggregate field to the field list. */
15013 dwarf2_add_field (struct field_info *fip, struct die_info *die,
15014 struct dwarf2_cu *cu)
15016 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15017 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15018 struct nextfield *new_field;
15019 struct attribute *attr;
15021 const char *fieldname = "";
15023 if (die->tag == DW_TAG_inheritance)
15025 fip->baseclasses.emplace_back ();
15026 new_field = &fip->baseclasses.back ();
15030 fip->fields.emplace_back ();
15031 new_field = &fip->fields.back ();
15036 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15038 new_field->accessibility = DW_UNSND (attr);
15040 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
15041 if (new_field->accessibility != DW_ACCESS_public)
15042 fip->non_public_fields = 1;
15044 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15046 new_field->virtuality = DW_UNSND (attr);
15048 new_field->virtuality = DW_VIRTUALITY_none;
15050 fp = &new_field->field;
15052 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
15056 /* Data member other than a C++ static data member. */
15058 /* Get type of field. */
15059 fp->type = die_type (die, cu);
15061 SET_FIELD_BITPOS (*fp, 0);
15063 /* Get bit size of field (zero if none). */
15064 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
15067 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
15071 FIELD_BITSIZE (*fp) = 0;
15074 /* Get bit offset of field. */
15075 if (handle_data_member_location (die, cu, &offset))
15076 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15077 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
15080 if (gdbarch_bits_big_endian (gdbarch))
15082 /* For big endian bits, the DW_AT_bit_offset gives the
15083 additional bit offset from the MSB of the containing
15084 anonymous object to the MSB of the field. We don't
15085 have to do anything special since we don't need to
15086 know the size of the anonymous object. */
15087 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
15091 /* For little endian bits, compute the bit offset to the
15092 MSB of the anonymous object, subtract off the number of
15093 bits from the MSB of the field to the MSB of the
15094 object, and then subtract off the number of bits of
15095 the field itself. The result is the bit offset of
15096 the LSB of the field. */
15097 int anonymous_size;
15098 int bit_offset = DW_UNSND (attr);
15100 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15103 /* The size of the anonymous object containing
15104 the bit field is explicit, so use the
15105 indicated size (in bytes). */
15106 anonymous_size = DW_UNSND (attr);
15110 /* The size of the anonymous object containing
15111 the bit field must be inferred from the type
15112 attribute of the data member containing the
15114 anonymous_size = TYPE_LENGTH (fp->type);
15116 SET_FIELD_BITPOS (*fp,
15117 (FIELD_BITPOS (*fp)
15118 + anonymous_size * bits_per_byte
15119 - bit_offset - FIELD_BITSIZE (*fp)));
15122 attr = dwarf2_attr (die, DW_AT_data_bit_offset, cu);
15124 SET_FIELD_BITPOS (*fp, (FIELD_BITPOS (*fp)
15125 + dwarf2_get_attr_constant_value (attr, 0)));
15127 /* Get name of field. */
15128 fieldname = dwarf2_name (die, cu);
15129 if (fieldname == NULL)
15132 /* The name is already allocated along with this objfile, so we don't
15133 need to duplicate it for the type. */
15134 fp->name = fieldname;
15136 /* Change accessibility for artificial fields (e.g. virtual table
15137 pointer or virtual base class pointer) to private. */
15138 if (dwarf2_attr (die, DW_AT_artificial, cu))
15140 FIELD_ARTIFICIAL (*fp) = 1;
15141 new_field->accessibility = DW_ACCESS_private;
15142 fip->non_public_fields = 1;
15145 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
15147 /* C++ static member. */
15149 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15150 is a declaration, but all versions of G++ as of this writing
15151 (so through at least 3.2.1) incorrectly generate
15152 DW_TAG_variable tags. */
15154 const char *physname;
15156 /* Get name of field. */
15157 fieldname = dwarf2_name (die, cu);
15158 if (fieldname == NULL)
15161 attr = dwarf2_attr (die, DW_AT_const_value, cu);
15163 /* Only create a symbol if this is an external value.
15164 new_symbol checks this and puts the value in the global symbol
15165 table, which we want. If it is not external, new_symbol
15166 will try to put the value in cu->list_in_scope which is wrong. */
15167 && dwarf2_flag_true_p (die, DW_AT_external, cu))
15169 /* A static const member, not much different than an enum as far as
15170 we're concerned, except that we can support more types. */
15171 new_symbol (die, NULL, cu);
15174 /* Get physical name. */
15175 physname = dwarf2_physname (fieldname, die, cu);
15177 /* The name is already allocated along with this objfile, so we don't
15178 need to duplicate it for the type. */
15179 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
15180 FIELD_TYPE (*fp) = die_type (die, cu);
15181 FIELD_NAME (*fp) = fieldname;
15183 else if (die->tag == DW_TAG_inheritance)
15187 /* C++ base class field. */
15188 if (handle_data_member_location (die, cu, &offset))
15189 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15190 FIELD_BITSIZE (*fp) = 0;
15191 FIELD_TYPE (*fp) = die_type (die, cu);
15192 FIELD_NAME (*fp) = TYPE_NAME (fp->type);
15194 else if (die->tag == DW_TAG_variant_part)
15196 /* process_structure_scope will treat this DIE as a union. */
15197 process_structure_scope (die, cu);
15199 /* The variant part is relative to the start of the enclosing
15201 SET_FIELD_BITPOS (*fp, 0);
15202 fp->type = get_die_type (die, cu);
15203 fp->artificial = 1;
15204 fp->name = "<<variant>>";
15206 /* Normally a DW_TAG_variant_part won't have a size, but our
15207 representation requires one, so set it to the maximum of the
15209 if (TYPE_LENGTH (fp->type) == 0)
15212 for (int i = 0; i < TYPE_NFIELDS (fp->type); ++i)
15213 if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i)) > max)
15214 max = TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i));
15215 TYPE_LENGTH (fp->type) = max;
15219 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15222 /* Can the type given by DIE define another type? */
15225 type_can_define_types (const struct die_info *die)
15229 case DW_TAG_typedef:
15230 case DW_TAG_class_type:
15231 case DW_TAG_structure_type:
15232 case DW_TAG_union_type:
15233 case DW_TAG_enumeration_type:
15241 /* Add a type definition defined in the scope of the FIP's class. */
15244 dwarf2_add_type_defn (struct field_info *fip, struct die_info *die,
15245 struct dwarf2_cu *cu)
15247 struct decl_field fp;
15248 memset (&fp, 0, sizeof (fp));
15250 gdb_assert (type_can_define_types (die));
15252 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15253 fp.name = dwarf2_name (die, cu);
15254 fp.type = read_type_die (die, cu);
15256 /* Save accessibility. */
15257 enum dwarf_access_attribute accessibility;
15258 struct attribute *attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15260 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15262 accessibility = dwarf2_default_access_attribute (die, cu);
15263 switch (accessibility)
15265 case DW_ACCESS_public:
15266 /* The assumed value if neither private nor protected. */
15268 case DW_ACCESS_private:
15271 case DW_ACCESS_protected:
15272 fp.is_protected = 1;
15275 complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility);
15278 if (die->tag == DW_TAG_typedef)
15279 fip->typedef_field_list.push_back (fp);
15281 fip->nested_types_list.push_back (fp);
15284 /* Create the vector of fields, and attach it to the type. */
15287 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
15288 struct dwarf2_cu *cu)
15290 int nfields = fip->nfields;
15292 /* Record the field count, allocate space for the array of fields,
15293 and create blank accessibility bitfields if necessary. */
15294 TYPE_NFIELDS (type) = nfields;
15295 TYPE_FIELDS (type) = (struct field *)
15296 TYPE_ZALLOC (type, sizeof (struct field) * nfields);
15298 if (fip->non_public_fields && cu->language != language_ada)
15300 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15302 TYPE_FIELD_PRIVATE_BITS (type) =
15303 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15304 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
15306 TYPE_FIELD_PROTECTED_BITS (type) =
15307 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15308 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
15310 TYPE_FIELD_IGNORE_BITS (type) =
15311 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15312 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
15315 /* If the type has baseclasses, allocate and clear a bit vector for
15316 TYPE_FIELD_VIRTUAL_BITS. */
15317 if (!fip->baseclasses.empty () && cu->language != language_ada)
15319 int num_bytes = B_BYTES (fip->baseclasses.size ());
15320 unsigned char *pointer;
15322 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15323 pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes);
15324 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
15325 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->baseclasses.size ());
15326 TYPE_N_BASECLASSES (type) = fip->baseclasses.size ();
15329 if (TYPE_FLAG_DISCRIMINATED_UNION (type))
15331 struct discriminant_info *di = alloc_discriminant_info (type, -1, -1);
15333 for (int index = 0; index < nfields; ++index)
15335 struct nextfield &field = fip->fields[index];
15337 if (field.variant.is_discriminant)
15338 di->discriminant_index = index;
15339 else if (field.variant.default_branch)
15340 di->default_index = index;
15342 di->discriminants[index] = field.variant.discriminant_value;
15346 /* Copy the saved-up fields into the field vector. */
15347 for (int i = 0; i < nfields; ++i)
15349 struct nextfield &field
15350 = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i]
15351 : fip->fields[i - fip->baseclasses.size ()]);
15353 TYPE_FIELD (type, i) = field.field;
15354 switch (field.accessibility)
15356 case DW_ACCESS_private:
15357 if (cu->language != language_ada)
15358 SET_TYPE_FIELD_PRIVATE (type, i);
15361 case DW_ACCESS_protected:
15362 if (cu->language != language_ada)
15363 SET_TYPE_FIELD_PROTECTED (type, i);
15366 case DW_ACCESS_public:
15370 /* Unknown accessibility. Complain and treat it as public. */
15372 complaint (_("unsupported accessibility %d"),
15373 field.accessibility);
15377 if (i < fip->baseclasses.size ())
15379 switch (field.virtuality)
15381 case DW_VIRTUALITY_virtual:
15382 case DW_VIRTUALITY_pure_virtual:
15383 if (cu->language == language_ada)
15384 error (_("unexpected virtuality in component of Ada type"));
15385 SET_TYPE_FIELD_VIRTUAL (type, i);
15392 /* Return true if this member function is a constructor, false
15396 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
15398 const char *fieldname;
15399 const char *type_name;
15402 if (die->parent == NULL)
15405 if (die->parent->tag != DW_TAG_structure_type
15406 && die->parent->tag != DW_TAG_union_type
15407 && die->parent->tag != DW_TAG_class_type)
15410 fieldname = dwarf2_name (die, cu);
15411 type_name = dwarf2_name (die->parent, cu);
15412 if (fieldname == NULL || type_name == NULL)
15415 len = strlen (fieldname);
15416 return (strncmp (fieldname, type_name, len) == 0
15417 && (type_name[len] == '\0' || type_name[len] == '<'));
15420 /* Add a member function to the proper fieldlist. */
15423 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
15424 struct type *type, struct dwarf2_cu *cu)
15426 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15427 struct attribute *attr;
15429 struct fnfieldlist *flp = nullptr;
15430 struct fn_field *fnp;
15431 const char *fieldname;
15432 struct type *this_type;
15433 enum dwarf_access_attribute accessibility;
15435 if (cu->language == language_ada)
15436 error (_("unexpected member function in Ada type"));
15438 /* Get name of member function. */
15439 fieldname = dwarf2_name (die, cu);
15440 if (fieldname == NULL)
15443 /* Look up member function name in fieldlist. */
15444 for (i = 0; i < fip->fnfieldlists.size (); i++)
15446 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
15448 flp = &fip->fnfieldlists[i];
15453 /* Create a new fnfieldlist if necessary. */
15454 if (flp == nullptr)
15456 fip->fnfieldlists.emplace_back ();
15457 flp = &fip->fnfieldlists.back ();
15458 flp->name = fieldname;
15459 i = fip->fnfieldlists.size () - 1;
15462 /* Create a new member function field and add it to the vector of
15464 flp->fnfields.emplace_back ();
15465 fnp = &flp->fnfields.back ();
15467 /* Delay processing of the physname until later. */
15468 if (cu->language == language_cplus)
15469 add_to_method_list (type, i, flp->fnfields.size () - 1, fieldname,
15473 const char *physname = dwarf2_physname (fieldname, die, cu);
15474 fnp->physname = physname ? physname : "";
15477 fnp->type = alloc_type (objfile);
15478 this_type = read_type_die (die, cu);
15479 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
15481 int nparams = TYPE_NFIELDS (this_type);
15483 /* TYPE is the domain of this method, and THIS_TYPE is the type
15484 of the method itself (TYPE_CODE_METHOD). */
15485 smash_to_method_type (fnp->type, type,
15486 TYPE_TARGET_TYPE (this_type),
15487 TYPE_FIELDS (this_type),
15488 TYPE_NFIELDS (this_type),
15489 TYPE_VARARGS (this_type));
15491 /* Handle static member functions.
15492 Dwarf2 has no clean way to discern C++ static and non-static
15493 member functions. G++ helps GDB by marking the first
15494 parameter for non-static member functions (which is the this
15495 pointer) as artificial. We obtain this information from
15496 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15497 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
15498 fnp->voffset = VOFFSET_STATIC;
15501 complaint (_("member function type missing for '%s'"),
15502 dwarf2_full_name (fieldname, die, cu));
15504 /* Get fcontext from DW_AT_containing_type if present. */
15505 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
15506 fnp->fcontext = die_containing_type (die, cu);
15508 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15509 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15511 /* Get accessibility. */
15512 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15514 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15516 accessibility = dwarf2_default_access_attribute (die, cu);
15517 switch (accessibility)
15519 case DW_ACCESS_private:
15520 fnp->is_private = 1;
15522 case DW_ACCESS_protected:
15523 fnp->is_protected = 1;
15527 /* Check for artificial methods. */
15528 attr = dwarf2_attr (die, DW_AT_artificial, cu);
15529 if (attr && DW_UNSND (attr) != 0)
15530 fnp->is_artificial = 1;
15532 fnp->is_constructor = dwarf2_is_constructor (die, cu);
15534 /* Get index in virtual function table if it is a virtual member
15535 function. For older versions of GCC, this is an offset in the
15536 appropriate virtual table, as specified by DW_AT_containing_type.
15537 For everyone else, it is an expression to be evaluated relative
15538 to the object address. */
15540 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
15543 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
15545 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
15547 /* Old-style GCC. */
15548 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
15550 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
15551 || (DW_BLOCK (attr)->size > 1
15552 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
15553 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
15555 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
15556 if ((fnp->voffset % cu->header.addr_size) != 0)
15557 dwarf2_complex_location_expr_complaint ();
15559 fnp->voffset /= cu->header.addr_size;
15563 dwarf2_complex_location_expr_complaint ();
15565 if (!fnp->fcontext)
15567 /* If there is no `this' field and no DW_AT_containing_type,
15568 we cannot actually find a base class context for the
15570 if (TYPE_NFIELDS (this_type) == 0
15571 || !TYPE_FIELD_ARTIFICIAL (this_type, 0))
15573 complaint (_("cannot determine context for virtual member "
15574 "function \"%s\" (offset %s)"),
15575 fieldname, sect_offset_str (die->sect_off));
15580 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
15584 else if (attr_form_is_section_offset (attr))
15586 dwarf2_complex_location_expr_complaint ();
15590 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15596 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15597 if (attr && DW_UNSND (attr))
15599 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15600 complaint (_("Member function \"%s\" (offset %s) is virtual "
15601 "but the vtable offset is not specified"),
15602 fieldname, sect_offset_str (die->sect_off));
15603 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15604 TYPE_CPLUS_DYNAMIC (type) = 1;
15609 /* Create the vector of member function fields, and attach it to the type. */
15612 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
15613 struct dwarf2_cu *cu)
15615 if (cu->language == language_ada)
15616 error (_("unexpected member functions in Ada type"));
15618 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15619 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
15621 sizeof (struct fn_fieldlist) * fip->fnfieldlists.size ());
15623 for (int i = 0; i < fip->fnfieldlists.size (); i++)
15625 struct fnfieldlist &nf = fip->fnfieldlists[i];
15626 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
15628 TYPE_FN_FIELDLIST_NAME (type, i) = nf.name;
15629 TYPE_FN_FIELDLIST_LENGTH (type, i) = nf.fnfields.size ();
15630 fn_flp->fn_fields = (struct fn_field *)
15631 TYPE_ALLOC (type, sizeof (struct fn_field) * nf.fnfields.size ());
15633 for (int k = 0; k < nf.fnfields.size (); ++k)
15634 fn_flp->fn_fields[k] = nf.fnfields[k];
15637 TYPE_NFN_FIELDS (type) = fip->fnfieldlists.size ();
15640 /* Returns non-zero if NAME is the name of a vtable member in CU's
15641 language, zero otherwise. */
15643 is_vtable_name (const char *name, struct dwarf2_cu *cu)
15645 static const char vptr[] = "_vptr";
15647 /* Look for the C++ form of the vtable. */
15648 if (startswith (name, vptr) && is_cplus_marker (name[sizeof (vptr) - 1]))
15654 /* GCC outputs unnamed structures that are really pointers to member
15655 functions, with the ABI-specified layout. If TYPE describes
15656 such a structure, smash it into a member function type.
15658 GCC shouldn't do this; it should just output pointer to member DIEs.
15659 This is GCC PR debug/28767. */
15662 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
15664 struct type *pfn_type, *self_type, *new_type;
15666 /* Check for a structure with no name and two children. */
15667 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
15670 /* Check for __pfn and __delta members. */
15671 if (TYPE_FIELD_NAME (type, 0) == NULL
15672 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
15673 || TYPE_FIELD_NAME (type, 1) == NULL
15674 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
15677 /* Find the type of the method. */
15678 pfn_type = TYPE_FIELD_TYPE (type, 0);
15679 if (pfn_type == NULL
15680 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
15681 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
15684 /* Look for the "this" argument. */
15685 pfn_type = TYPE_TARGET_TYPE (pfn_type);
15686 if (TYPE_NFIELDS (pfn_type) == 0
15687 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15688 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
15691 self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
15692 new_type = alloc_type (objfile);
15693 smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
15694 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
15695 TYPE_VARARGS (pfn_type));
15696 smash_to_methodptr_type (type, new_type);
15699 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15700 appropriate error checking and issuing complaints if there is a
15704 get_alignment (struct dwarf2_cu *cu, struct die_info *die)
15706 struct attribute *attr = dwarf2_attr (die, DW_AT_alignment, cu);
15708 if (attr == nullptr)
15711 if (!attr_form_is_constant (attr))
15713 complaint (_("DW_AT_alignment must have constant form"
15714 " - DIE at %s [in module %s]"),
15715 sect_offset_str (die->sect_off),
15716 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15721 if (attr->form == DW_FORM_sdata)
15723 LONGEST val = DW_SND (attr);
15726 complaint (_("DW_AT_alignment value must not be negative"
15727 " - DIE at %s [in module %s]"),
15728 sect_offset_str (die->sect_off),
15729 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15735 align = DW_UNSND (attr);
15739 complaint (_("DW_AT_alignment value must not be zero"
15740 " - DIE at %s [in module %s]"),
15741 sect_offset_str (die->sect_off),
15742 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15745 if ((align & (align - 1)) != 0)
15747 complaint (_("DW_AT_alignment value must be a power of 2"
15748 " - DIE at %s [in module %s]"),
15749 sect_offset_str (die->sect_off),
15750 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15757 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15758 the alignment for TYPE. */
15761 maybe_set_alignment (struct dwarf2_cu *cu, struct die_info *die,
15764 if (!set_type_align (type, get_alignment (cu, die)))
15765 complaint (_("DW_AT_alignment value too large"
15766 " - DIE at %s [in module %s]"),
15767 sect_offset_str (die->sect_off),
15768 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15771 /* Called when we find the DIE that starts a structure or union scope
15772 (definition) to create a type for the structure or union. Fill in
15773 the type's name and general properties; the members will not be
15774 processed until process_structure_scope. A symbol table entry for
15775 the type will also not be done until process_structure_scope (assuming
15776 the type has a name).
15778 NOTE: we need to call these functions regardless of whether or not the
15779 DIE has a DW_AT_name attribute, since it might be an anonymous
15780 structure or union. This gets the type entered into our set of
15781 user defined types. */
15783 static struct type *
15784 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
15786 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15788 struct attribute *attr;
15791 /* If the definition of this type lives in .debug_types, read that type.
15792 Don't follow DW_AT_specification though, that will take us back up
15793 the chain and we want to go down. */
15794 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
15797 type = get_DW_AT_signature_type (die, attr, cu);
15799 /* The type's CU may not be the same as CU.
15800 Ensure TYPE is recorded with CU in die_type_hash. */
15801 return set_die_type (die, type, cu);
15804 type = alloc_type (objfile);
15805 INIT_CPLUS_SPECIFIC (type);
15807 name = dwarf2_name (die, cu);
15810 if (cu->language == language_cplus
15811 || cu->language == language_d
15812 || cu->language == language_rust)
15814 const char *full_name = dwarf2_full_name (name, die, cu);
15816 /* dwarf2_full_name might have already finished building the DIE's
15817 type. If so, there is no need to continue. */
15818 if (get_die_type (die, cu) != NULL)
15819 return get_die_type (die, cu);
15821 TYPE_NAME (type) = full_name;
15825 /* The name is already allocated along with this objfile, so
15826 we don't need to duplicate it for the type. */
15827 TYPE_NAME (type) = name;
15831 if (die->tag == DW_TAG_structure_type)
15833 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15835 else if (die->tag == DW_TAG_union_type)
15837 TYPE_CODE (type) = TYPE_CODE_UNION;
15839 else if (die->tag == DW_TAG_variant_part)
15841 TYPE_CODE (type) = TYPE_CODE_UNION;
15842 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
15846 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15849 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
15850 TYPE_DECLARED_CLASS (type) = 1;
15852 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15855 if (attr_form_is_constant (attr))
15856 TYPE_LENGTH (type) = DW_UNSND (attr);
15859 /* For the moment, dynamic type sizes are not supported
15860 by GDB's struct type. The actual size is determined
15861 on-demand when resolving the type of a given object,
15862 so set the type's length to zero for now. Otherwise,
15863 we record an expression as the length, and that expression
15864 could lead to a very large value, which could eventually
15865 lead to us trying to allocate that much memory when creating
15866 a value of that type. */
15867 TYPE_LENGTH (type) = 0;
15872 TYPE_LENGTH (type) = 0;
15875 maybe_set_alignment (cu, die, type);
15877 if (producer_is_icc_lt_14 (cu) && (TYPE_LENGTH (type) == 0))
15879 /* ICC<14 does not output the required DW_AT_declaration on
15880 incomplete types, but gives them a size of zero. */
15881 TYPE_STUB (type) = 1;
15884 TYPE_STUB_SUPPORTED (type) = 1;
15886 if (die_is_declaration (die, cu))
15887 TYPE_STUB (type) = 1;
15888 else if (attr == NULL && die->child == NULL
15889 && producer_is_realview (cu->producer))
15890 /* RealView does not output the required DW_AT_declaration
15891 on incomplete types. */
15892 TYPE_STUB (type) = 1;
15894 /* We need to add the type field to the die immediately so we don't
15895 infinitely recurse when dealing with pointers to the structure
15896 type within the structure itself. */
15897 set_die_type (die, type, cu);
15899 /* set_die_type should be already done. */
15900 set_descriptive_type (type, die, cu);
15905 /* A helper for process_structure_scope that handles a single member
15909 handle_struct_member_die (struct die_info *child_die, struct type *type,
15910 struct field_info *fi,
15911 std::vector<struct symbol *> *template_args,
15912 struct dwarf2_cu *cu)
15914 if (child_die->tag == DW_TAG_member
15915 || child_die->tag == DW_TAG_variable
15916 || child_die->tag == DW_TAG_variant_part)
15918 /* NOTE: carlton/2002-11-05: A C++ static data member
15919 should be a DW_TAG_member that is a declaration, but
15920 all versions of G++ as of this writing (so through at
15921 least 3.2.1) incorrectly generate DW_TAG_variable
15922 tags for them instead. */
15923 dwarf2_add_field (fi, child_die, cu);
15925 else if (child_die->tag == DW_TAG_subprogram)
15927 /* Rust doesn't have member functions in the C++ sense.
15928 However, it does emit ordinary functions as children
15929 of a struct DIE. */
15930 if (cu->language == language_rust)
15931 read_func_scope (child_die, cu);
15934 /* C++ member function. */
15935 dwarf2_add_member_fn (fi, child_die, type, cu);
15938 else if (child_die->tag == DW_TAG_inheritance)
15940 /* C++ base class field. */
15941 dwarf2_add_field (fi, child_die, cu);
15943 else if (type_can_define_types (child_die))
15944 dwarf2_add_type_defn (fi, child_die, cu);
15945 else if (child_die->tag == DW_TAG_template_type_param
15946 || child_die->tag == DW_TAG_template_value_param)
15948 struct symbol *arg = new_symbol (child_die, NULL, cu);
15951 template_args->push_back (arg);
15953 else if (child_die->tag == DW_TAG_variant)
15955 /* In a variant we want to get the discriminant and also add a
15956 field for our sole member child. */
15957 struct attribute *discr = dwarf2_attr (child_die, DW_AT_discr_value, cu);
15959 for (struct die_info *variant_child = child_die->child;
15960 variant_child != NULL;
15961 variant_child = sibling_die (variant_child))
15963 if (variant_child->tag == DW_TAG_member)
15965 handle_struct_member_die (variant_child, type, fi,
15966 template_args, cu);
15967 /* Only handle the one. */
15972 /* We don't handle this but we might as well report it if we see
15974 if (dwarf2_attr (child_die, DW_AT_discr_list, cu) != nullptr)
15975 complaint (_("DW_AT_discr_list is not supported yet"
15976 " - DIE at %s [in module %s]"),
15977 sect_offset_str (child_die->sect_off),
15978 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15980 /* The first field was just added, so we can stash the
15981 discriminant there. */
15982 gdb_assert (!fi->fields.empty ());
15984 fi->fields.back ().variant.default_branch = true;
15986 fi->fields.back ().variant.discriminant_value = DW_UNSND (discr);
15990 /* Finish creating a structure or union type, including filling in
15991 its members and creating a symbol for it. */
15994 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
15996 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15997 struct die_info *child_die;
16000 type = get_die_type (die, cu);
16002 type = read_structure_type (die, cu);
16004 /* When reading a DW_TAG_variant_part, we need to notice when we
16005 read the discriminant member, so we can record it later in the
16006 discriminant_info. */
16007 bool is_variant_part = TYPE_FLAG_DISCRIMINATED_UNION (type);
16008 sect_offset discr_offset;
16009 bool has_template_parameters = false;
16011 if (is_variant_part)
16013 struct attribute *discr = dwarf2_attr (die, DW_AT_discr, cu);
16016 /* Maybe it's a univariant form, an extension we support.
16017 In this case arrange not to check the offset. */
16018 is_variant_part = false;
16020 else if (attr_form_is_ref (discr))
16022 struct dwarf2_cu *target_cu = cu;
16023 struct die_info *target_die = follow_die_ref (die, discr, &target_cu);
16025 discr_offset = target_die->sect_off;
16029 complaint (_("DW_AT_discr does not have DIE reference form"
16030 " - DIE at %s [in module %s]"),
16031 sect_offset_str (die->sect_off),
16032 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16033 is_variant_part = false;
16037 if (die->child != NULL && ! die_is_declaration (die, cu))
16039 struct field_info fi;
16040 std::vector<struct symbol *> template_args;
16042 child_die = die->child;
16044 while (child_die && child_die->tag)
16046 handle_struct_member_die (child_die, type, &fi, &template_args, cu);
16048 if (is_variant_part && discr_offset == child_die->sect_off)
16049 fi.fields.back ().variant.is_discriminant = true;
16051 child_die = sibling_die (child_die);
16054 /* Attach template arguments to type. */
16055 if (!template_args.empty ())
16057 has_template_parameters = true;
16058 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16059 TYPE_N_TEMPLATE_ARGUMENTS (type) = template_args.size ();
16060 TYPE_TEMPLATE_ARGUMENTS (type)
16061 = XOBNEWVEC (&objfile->objfile_obstack,
16063 TYPE_N_TEMPLATE_ARGUMENTS (type));
16064 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
16065 template_args.data (),
16066 (TYPE_N_TEMPLATE_ARGUMENTS (type)
16067 * sizeof (struct symbol *)));
16070 /* Attach fields and member functions to the type. */
16072 dwarf2_attach_fields_to_type (&fi, type, cu);
16073 if (!fi.fnfieldlists.empty ())
16075 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
16077 /* Get the type which refers to the base class (possibly this
16078 class itself) which contains the vtable pointer for the current
16079 class from the DW_AT_containing_type attribute. This use of
16080 DW_AT_containing_type is a GNU extension. */
16082 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
16084 struct type *t = die_containing_type (die, cu);
16086 set_type_vptr_basetype (type, t);
16091 /* Our own class provides vtbl ptr. */
16092 for (i = TYPE_NFIELDS (t) - 1;
16093 i >= TYPE_N_BASECLASSES (t);
16096 const char *fieldname = TYPE_FIELD_NAME (t, i);
16098 if (is_vtable_name (fieldname, cu))
16100 set_type_vptr_fieldno (type, i);
16105 /* Complain if virtual function table field not found. */
16106 if (i < TYPE_N_BASECLASSES (t))
16107 complaint (_("virtual function table pointer "
16108 "not found when defining class '%s'"),
16109 TYPE_NAME (type) ? TYPE_NAME (type) : "");
16113 set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
16116 else if (cu->producer
16117 && startswith (cu->producer, "IBM(R) XL C/C++ Advanced Edition"))
16119 /* The IBM XLC compiler does not provide direct indication
16120 of the containing type, but the vtable pointer is
16121 always named __vfp. */
16125 for (i = TYPE_NFIELDS (type) - 1;
16126 i >= TYPE_N_BASECLASSES (type);
16129 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
16131 set_type_vptr_fieldno (type, i);
16132 set_type_vptr_basetype (type, type);
16139 /* Copy fi.typedef_field_list linked list elements content into the
16140 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16141 if (!fi.typedef_field_list.empty ())
16143 int count = fi.typedef_field_list.size ();
16145 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16146 TYPE_TYPEDEF_FIELD_ARRAY (type)
16147 = ((struct decl_field *)
16149 sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * count));
16150 TYPE_TYPEDEF_FIELD_COUNT (type) = count;
16152 for (int i = 0; i < fi.typedef_field_list.size (); ++i)
16153 TYPE_TYPEDEF_FIELD (type, i) = fi.typedef_field_list[i];
16156 /* Copy fi.nested_types_list linked list elements content into the
16157 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16158 if (!fi.nested_types_list.empty () && cu->language != language_ada)
16160 int count = fi.nested_types_list.size ();
16162 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16163 TYPE_NESTED_TYPES_ARRAY (type)
16164 = ((struct decl_field *)
16165 TYPE_ALLOC (type, sizeof (struct decl_field) * count));
16166 TYPE_NESTED_TYPES_COUNT (type) = count;
16168 for (int i = 0; i < fi.nested_types_list.size (); ++i)
16169 TYPE_NESTED_TYPES_FIELD (type, i) = fi.nested_types_list[i];
16173 quirk_gcc_member_function_pointer (type, objfile);
16174 if (cu->language == language_rust && die->tag == DW_TAG_union_type)
16175 cu->rust_unions.push_back (type);
16177 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16178 snapshots) has been known to create a die giving a declaration
16179 for a class that has, as a child, a die giving a definition for a
16180 nested class. So we have to process our children even if the
16181 current die is a declaration. Normally, of course, a declaration
16182 won't have any children at all. */
16184 child_die = die->child;
16186 while (child_die != NULL && child_die->tag)
16188 if (child_die->tag == DW_TAG_member
16189 || child_die->tag == DW_TAG_variable
16190 || child_die->tag == DW_TAG_inheritance
16191 || child_die->tag == DW_TAG_template_value_param
16192 || child_die->tag == DW_TAG_template_type_param)
16197 process_die (child_die, cu);
16199 child_die = sibling_die (child_die);
16202 /* Do not consider external references. According to the DWARF standard,
16203 these DIEs are identified by the fact that they have no byte_size
16204 attribute, and a declaration attribute. */
16205 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
16206 || !die_is_declaration (die, cu))
16208 struct symbol *sym = new_symbol (die, type, cu);
16210 if (has_template_parameters)
16212 /* Make sure that the symtab is set on the new symbols.
16213 Even though they don't appear in this symtab directly,
16214 other parts of gdb assume that symbols do, and this is
16215 reasonably true. */
16216 for (int i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
16217 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type, i),
16218 symbol_symtab (sym));
16223 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16224 update TYPE using some information only available in DIE's children. */
16227 update_enumeration_type_from_children (struct die_info *die,
16229 struct dwarf2_cu *cu)
16231 struct die_info *child_die;
16232 int unsigned_enum = 1;
16236 auto_obstack obstack;
16238 for (child_die = die->child;
16239 child_die != NULL && child_die->tag;
16240 child_die = sibling_die (child_die))
16242 struct attribute *attr;
16244 const gdb_byte *bytes;
16245 struct dwarf2_locexpr_baton *baton;
16248 if (child_die->tag != DW_TAG_enumerator)
16251 attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
16255 name = dwarf2_name (child_die, cu);
16257 name = "<anonymous enumerator>";
16259 dwarf2_const_value_attr (attr, type, name, &obstack, cu,
16260 &value, &bytes, &baton);
16266 else if ((mask & value) != 0)
16271 /* If we already know that the enum type is neither unsigned, nor
16272 a flag type, no need to look at the rest of the enumerates. */
16273 if (!unsigned_enum && !flag_enum)
16278 TYPE_UNSIGNED (type) = 1;
16280 TYPE_FLAG_ENUM (type) = 1;
16283 /* Given a DW_AT_enumeration_type die, set its type. We do not
16284 complete the type's fields yet, or create any symbols. */
16286 static struct type *
16287 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
16289 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16291 struct attribute *attr;
16294 /* If the definition of this type lives in .debug_types, read that type.
16295 Don't follow DW_AT_specification though, that will take us back up
16296 the chain and we want to go down. */
16297 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
16300 type = get_DW_AT_signature_type (die, attr, cu);
16302 /* The type's CU may not be the same as CU.
16303 Ensure TYPE is recorded with CU in die_type_hash. */
16304 return set_die_type (die, type, cu);
16307 type = alloc_type (objfile);
16309 TYPE_CODE (type) = TYPE_CODE_ENUM;
16310 name = dwarf2_full_name (NULL, die, cu);
16312 TYPE_NAME (type) = name;
16314 attr = dwarf2_attr (die, DW_AT_type, cu);
16317 struct type *underlying_type = die_type (die, cu);
16319 TYPE_TARGET_TYPE (type) = underlying_type;
16322 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16325 TYPE_LENGTH (type) = DW_UNSND (attr);
16329 TYPE_LENGTH (type) = 0;
16332 maybe_set_alignment (cu, die, type);
16334 /* The enumeration DIE can be incomplete. In Ada, any type can be
16335 declared as private in the package spec, and then defined only
16336 inside the package body. Such types are known as Taft Amendment
16337 Types. When another package uses such a type, an incomplete DIE
16338 may be generated by the compiler. */
16339 if (die_is_declaration (die, cu))
16340 TYPE_STUB (type) = 1;
16342 /* Finish the creation of this type by using the enum's children.
16343 We must call this even when the underlying type has been provided
16344 so that we can determine if we're looking at a "flag" enum. */
16345 update_enumeration_type_from_children (die, type, cu);
16347 /* If this type has an underlying type that is not a stub, then we
16348 may use its attributes. We always use the "unsigned" attribute
16349 in this situation, because ordinarily we guess whether the type
16350 is unsigned -- but the guess can be wrong and the underlying type
16351 can tell us the reality. However, we defer to a local size
16352 attribute if one exists, because this lets the compiler override
16353 the underlying type if needed. */
16354 if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
16356 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
16357 if (TYPE_LENGTH (type) == 0)
16358 TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
16359 if (TYPE_RAW_ALIGN (type) == 0
16360 && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)) != 0)
16361 set_type_align (type, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)));
16364 TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
16366 return set_die_type (die, type, cu);
16369 /* Given a pointer to a die which begins an enumeration, process all
16370 the dies that define the members of the enumeration, and create the
16371 symbol for the enumeration type.
16373 NOTE: We reverse the order of the element list. */
16376 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
16378 struct type *this_type;
16380 this_type = get_die_type (die, cu);
16381 if (this_type == NULL)
16382 this_type = read_enumeration_type (die, cu);
16384 if (die->child != NULL)
16386 struct die_info *child_die;
16387 struct symbol *sym;
16388 struct field *fields = NULL;
16389 int num_fields = 0;
16392 child_die = die->child;
16393 while (child_die && child_die->tag)
16395 if (child_die->tag != DW_TAG_enumerator)
16397 process_die (child_die, cu);
16401 name = dwarf2_name (child_die, cu);
16404 sym = new_symbol (child_die, this_type, cu);
16406 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
16408 fields = (struct field *)
16410 (num_fields + DW_FIELD_ALLOC_CHUNK)
16411 * sizeof (struct field));
16414 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
16415 FIELD_TYPE (fields[num_fields]) = NULL;
16416 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
16417 FIELD_BITSIZE (fields[num_fields]) = 0;
16423 child_die = sibling_die (child_die);
16428 TYPE_NFIELDS (this_type) = num_fields;
16429 TYPE_FIELDS (this_type) = (struct field *)
16430 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
16431 memcpy (TYPE_FIELDS (this_type), fields,
16432 sizeof (struct field) * num_fields);
16437 /* If we are reading an enum from a .debug_types unit, and the enum
16438 is a declaration, and the enum is not the signatured type in the
16439 unit, then we do not want to add a symbol for it. Adding a
16440 symbol would in some cases obscure the true definition of the
16441 enum, giving users an incomplete type when the definition is
16442 actually available. Note that we do not want to do this for all
16443 enums which are just declarations, because C++0x allows forward
16444 enum declarations. */
16445 if (cu->per_cu->is_debug_types
16446 && die_is_declaration (die, cu))
16448 struct signatured_type *sig_type;
16450 sig_type = (struct signatured_type *) cu->per_cu;
16451 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
16452 if (sig_type->type_offset_in_section != die->sect_off)
16456 new_symbol (die, this_type, cu);
16459 /* Extract all information from a DW_TAG_array_type DIE and put it in
16460 the DIE's type field. For now, this only handles one dimensional
16463 static struct type *
16464 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
16466 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16467 struct die_info *child_die;
16469 struct type *element_type, *range_type, *index_type;
16470 struct attribute *attr;
16472 struct dynamic_prop *byte_stride_prop = NULL;
16473 unsigned int bit_stride = 0;
16475 element_type = die_type (die, cu);
16477 /* The die_type call above may have already set the type for this DIE. */
16478 type = get_die_type (die, cu);
16482 attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
16488 = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
16489 stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop);
16492 complaint (_("unable to read array DW_AT_byte_stride "
16493 " - DIE at %s [in module %s]"),
16494 sect_offset_str (die->sect_off),
16495 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16496 /* Ignore this attribute. We will likely not be able to print
16497 arrays of this type correctly, but there is little we can do
16498 to help if we cannot read the attribute's value. */
16499 byte_stride_prop = NULL;
16503 attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
16505 bit_stride = DW_UNSND (attr);
16507 /* Irix 6.2 native cc creates array types without children for
16508 arrays with unspecified length. */
16509 if (die->child == NULL)
16511 index_type = objfile_type (objfile)->builtin_int;
16512 range_type = create_static_range_type (NULL, index_type, 0, -1);
16513 type = create_array_type_with_stride (NULL, element_type, range_type,
16514 byte_stride_prop, bit_stride);
16515 return set_die_type (die, type, cu);
16518 std::vector<struct type *> range_types;
16519 child_die = die->child;
16520 while (child_die && child_die->tag)
16522 if (child_die->tag == DW_TAG_subrange_type)
16524 struct type *child_type = read_type_die (child_die, cu);
16526 if (child_type != NULL)
16528 /* The range type was succesfully read. Save it for the
16529 array type creation. */
16530 range_types.push_back (child_type);
16533 child_die = sibling_die (child_die);
16536 /* Dwarf2 dimensions are output from left to right, create the
16537 necessary array types in backwards order. */
16539 type = element_type;
16541 if (read_array_order (die, cu) == DW_ORD_col_major)
16545 while (i < range_types.size ())
16546 type = create_array_type_with_stride (NULL, type, range_types[i++],
16547 byte_stride_prop, bit_stride);
16551 size_t ndim = range_types.size ();
16553 type = create_array_type_with_stride (NULL, type, range_types[ndim],
16554 byte_stride_prop, bit_stride);
16557 /* Understand Dwarf2 support for vector types (like they occur on
16558 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16559 array type. This is not part of the Dwarf2/3 standard yet, but a
16560 custom vendor extension. The main difference between a regular
16561 array and the vector variant is that vectors are passed by value
16563 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
16565 make_vector_type (type);
16567 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16568 implementation may choose to implement triple vectors using this
16570 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16573 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
16574 TYPE_LENGTH (type) = DW_UNSND (attr);
16576 complaint (_("DW_AT_byte_size for array type smaller "
16577 "than the total size of elements"));
16580 name = dwarf2_name (die, cu);
16582 TYPE_NAME (type) = name;
16584 maybe_set_alignment (cu, die, type);
16586 /* Install the type in the die. */
16587 set_die_type (die, type, cu);
16589 /* set_die_type should be already done. */
16590 set_descriptive_type (type, die, cu);
16595 static enum dwarf_array_dim_ordering
16596 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
16598 struct attribute *attr;
16600 attr = dwarf2_attr (die, DW_AT_ordering, cu);
16603 return (enum dwarf_array_dim_ordering) DW_SND (attr);
16605 /* GNU F77 is a special case, as at 08/2004 array type info is the
16606 opposite order to the dwarf2 specification, but data is still
16607 laid out as per normal fortran.
16609 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16610 version checking. */
16612 if (cu->language == language_fortran
16613 && cu->producer && strstr (cu->producer, "GNU F77"))
16615 return DW_ORD_row_major;
16618 switch (cu->language_defn->la_array_ordering)
16620 case array_column_major:
16621 return DW_ORD_col_major;
16622 case array_row_major:
16624 return DW_ORD_row_major;
16628 /* Extract all information from a DW_TAG_set_type DIE and put it in
16629 the DIE's type field. */
16631 static struct type *
16632 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
16634 struct type *domain_type, *set_type;
16635 struct attribute *attr;
16637 domain_type = die_type (die, cu);
16639 /* The die_type call above may have already set the type for this DIE. */
16640 set_type = get_die_type (die, cu);
16644 set_type = create_set_type (NULL, domain_type);
16646 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16648 TYPE_LENGTH (set_type) = DW_UNSND (attr);
16650 maybe_set_alignment (cu, die, set_type);
16652 return set_die_type (die, set_type, cu);
16655 /* A helper for read_common_block that creates a locexpr baton.
16656 SYM is the symbol which we are marking as computed.
16657 COMMON_DIE is the DIE for the common block.
16658 COMMON_LOC is the location expression attribute for the common
16660 MEMBER_LOC is the location expression attribute for the particular
16661 member of the common block that we are processing.
16662 CU is the CU from which the above come. */
16665 mark_common_block_symbol_computed (struct symbol *sym,
16666 struct die_info *common_die,
16667 struct attribute *common_loc,
16668 struct attribute *member_loc,
16669 struct dwarf2_cu *cu)
16671 struct dwarf2_per_objfile *dwarf2_per_objfile
16672 = cu->per_cu->dwarf2_per_objfile;
16673 struct objfile *objfile = dwarf2_per_objfile->objfile;
16674 struct dwarf2_locexpr_baton *baton;
16676 unsigned int cu_off;
16677 enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
16678 LONGEST offset = 0;
16680 gdb_assert (common_loc && member_loc);
16681 gdb_assert (attr_form_is_block (common_loc));
16682 gdb_assert (attr_form_is_block (member_loc)
16683 || attr_form_is_constant (member_loc));
16685 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
16686 baton->per_cu = cu->per_cu;
16687 gdb_assert (baton->per_cu);
16689 baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16691 if (attr_form_is_constant (member_loc))
16693 offset = dwarf2_get_attr_constant_value (member_loc, 0);
16694 baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
16697 baton->size += DW_BLOCK (member_loc)->size;
16699 ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
16702 *ptr++ = DW_OP_call4;
16703 cu_off = common_die->sect_off - cu->per_cu->sect_off;
16704 store_unsigned_integer (ptr, 4, byte_order, cu_off);
16707 if (attr_form_is_constant (member_loc))
16709 *ptr++ = DW_OP_addr;
16710 store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
16711 ptr += cu->header.addr_size;
16715 /* We have to copy the data here, because DW_OP_call4 will only
16716 use a DW_AT_location attribute. */
16717 memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
16718 ptr += DW_BLOCK (member_loc)->size;
16721 *ptr++ = DW_OP_plus;
16722 gdb_assert (ptr - baton->data == baton->size);
16724 SYMBOL_LOCATION_BATON (sym) = baton;
16725 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
16728 /* Create appropriate locally-scoped variables for all the
16729 DW_TAG_common_block entries. Also create a struct common_block
16730 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16731 is used to sepate the common blocks name namespace from regular
16735 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
16737 struct attribute *attr;
16739 attr = dwarf2_attr (die, DW_AT_location, cu);
16742 /* Support the .debug_loc offsets. */
16743 if (attr_form_is_block (attr))
16747 else if (attr_form_is_section_offset (attr))
16749 dwarf2_complex_location_expr_complaint ();
16754 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16755 "common block member");
16760 if (die->child != NULL)
16762 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16763 struct die_info *child_die;
16764 size_t n_entries = 0, size;
16765 struct common_block *common_block;
16766 struct symbol *sym;
16768 for (child_die = die->child;
16769 child_die && child_die->tag;
16770 child_die = sibling_die (child_die))
16773 size = (sizeof (struct common_block)
16774 + (n_entries - 1) * sizeof (struct symbol *));
16776 = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
16778 memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
16779 common_block->n_entries = 0;
16781 for (child_die = die->child;
16782 child_die && child_die->tag;
16783 child_die = sibling_die (child_die))
16785 /* Create the symbol in the DW_TAG_common_block block in the current
16787 sym = new_symbol (child_die, NULL, cu);
16790 struct attribute *member_loc;
16792 common_block->contents[common_block->n_entries++] = sym;
16794 member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
16798 /* GDB has handled this for a long time, but it is
16799 not specified by DWARF. It seems to have been
16800 emitted by gfortran at least as recently as:
16801 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16802 complaint (_("Variable in common block has "
16803 "DW_AT_data_member_location "
16804 "- DIE at %s [in module %s]"),
16805 sect_offset_str (child_die->sect_off),
16806 objfile_name (objfile));
16808 if (attr_form_is_section_offset (member_loc))
16809 dwarf2_complex_location_expr_complaint ();
16810 else if (attr_form_is_constant (member_loc)
16811 || attr_form_is_block (member_loc))
16814 mark_common_block_symbol_computed (sym, die, attr,
16818 dwarf2_complex_location_expr_complaint ();
16823 sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
16824 SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
16828 /* Create a type for a C++ namespace. */
16830 static struct type *
16831 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
16833 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16834 const char *previous_prefix, *name;
16838 /* For extensions, reuse the type of the original namespace. */
16839 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
16841 struct die_info *ext_die;
16842 struct dwarf2_cu *ext_cu = cu;
16844 ext_die = dwarf2_extension (die, &ext_cu);
16845 type = read_type_die (ext_die, ext_cu);
16847 /* EXT_CU may not be the same as CU.
16848 Ensure TYPE is recorded with CU in die_type_hash. */
16849 return set_die_type (die, type, cu);
16852 name = namespace_name (die, &is_anonymous, cu);
16854 /* Now build the name of the current namespace. */
16856 previous_prefix = determine_prefix (die, cu);
16857 if (previous_prefix[0] != '\0')
16858 name = typename_concat (&objfile->objfile_obstack,
16859 previous_prefix, name, 0, cu);
16861 /* Create the type. */
16862 type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
16864 return set_die_type (die, type, cu);
16867 /* Read a namespace scope. */
16870 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
16872 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16875 /* Add a symbol associated to this if we haven't seen the namespace
16876 before. Also, add a using directive if it's an anonymous
16879 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
16883 type = read_type_die (die, cu);
16884 new_symbol (die, type, cu);
16886 namespace_name (die, &is_anonymous, cu);
16889 const char *previous_prefix = determine_prefix (die, cu);
16891 std::vector<const char *> excludes;
16892 add_using_directive (using_directives (cu),
16893 previous_prefix, TYPE_NAME (type), NULL,
16894 NULL, excludes, 0, &objfile->objfile_obstack);
16898 if (die->child != NULL)
16900 struct die_info *child_die = die->child;
16902 while (child_die && child_die->tag)
16904 process_die (child_die, cu);
16905 child_die = sibling_die (child_die);
16910 /* Read a Fortran module as type. This DIE can be only a declaration used for
16911 imported module. Still we need that type as local Fortran "use ... only"
16912 declaration imports depend on the created type in determine_prefix. */
16914 static struct type *
16915 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
16917 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16918 const char *module_name;
16921 module_name = dwarf2_name (die, cu);
16923 complaint (_("DW_TAG_module has no name, offset %s"),
16924 sect_offset_str (die->sect_off));
16925 type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
16927 return set_die_type (die, type, cu);
16930 /* Read a Fortran module. */
16933 read_module (struct die_info *die, struct dwarf2_cu *cu)
16935 struct die_info *child_die = die->child;
16938 type = read_type_die (die, cu);
16939 new_symbol (die, type, cu);
16941 while (child_die && child_die->tag)
16943 process_die (child_die, cu);
16944 child_die = sibling_die (child_die);
16948 /* Return the name of the namespace represented by DIE. Set
16949 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16952 static const char *
16953 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
16955 struct die_info *current_die;
16956 const char *name = NULL;
16958 /* Loop through the extensions until we find a name. */
16960 for (current_die = die;
16961 current_die != NULL;
16962 current_die = dwarf2_extension (die, &cu))
16964 /* We don't use dwarf2_name here so that we can detect the absence
16965 of a name -> anonymous namespace. */
16966 name = dwarf2_string_attr (die, DW_AT_name, cu);
16972 /* Is it an anonymous namespace? */
16974 *is_anonymous = (name == NULL);
16976 name = CP_ANONYMOUS_NAMESPACE_STR;
16981 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16982 the user defined type vector. */
16984 static struct type *
16985 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
16987 struct gdbarch *gdbarch
16988 = get_objfile_arch (cu->per_cu->dwarf2_per_objfile->objfile);
16989 struct comp_unit_head *cu_header = &cu->header;
16991 struct attribute *attr_byte_size;
16992 struct attribute *attr_address_class;
16993 int byte_size, addr_class;
16994 struct type *target_type;
16996 target_type = die_type (die, cu);
16998 /* The die_type call above may have already set the type for this DIE. */
16999 type = get_die_type (die, cu);
17003 type = lookup_pointer_type (target_type);
17005 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
17006 if (attr_byte_size)
17007 byte_size = DW_UNSND (attr_byte_size);
17009 byte_size = cu_header->addr_size;
17011 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
17012 if (attr_address_class)
17013 addr_class = DW_UNSND (attr_address_class);
17015 addr_class = DW_ADDR_none;
17017 ULONGEST alignment = get_alignment (cu, die);
17019 /* If the pointer size, alignment, or address class is different
17020 than the default, create a type variant marked as such and set
17021 the length accordingly. */
17022 if (TYPE_LENGTH (type) != byte_size
17023 || (alignment != 0 && TYPE_RAW_ALIGN (type) != 0
17024 && alignment != TYPE_RAW_ALIGN (type))
17025 || addr_class != DW_ADDR_none)
17027 if (gdbarch_address_class_type_flags_p (gdbarch))
17031 type_flags = gdbarch_address_class_type_flags
17032 (gdbarch, byte_size, addr_class);
17033 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
17035 type = make_type_with_address_space (type, type_flags);
17037 else if (TYPE_LENGTH (type) != byte_size)
17039 complaint (_("invalid pointer size %d"), byte_size);
17041 else if (TYPE_RAW_ALIGN (type) != alignment)
17043 complaint (_("Invalid DW_AT_alignment"
17044 " - DIE at %s [in module %s]"),
17045 sect_offset_str (die->sect_off),
17046 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17050 /* Should we also complain about unhandled address classes? */
17054 TYPE_LENGTH (type) = byte_size;
17055 set_type_align (type, alignment);
17056 return set_die_type (die, type, cu);
17059 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17060 the user defined type vector. */
17062 static struct type *
17063 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
17066 struct type *to_type;
17067 struct type *domain;
17069 to_type = die_type (die, cu);
17070 domain = die_containing_type (die, cu);
17072 /* The calls above may have already set the type for this DIE. */
17073 type = get_die_type (die, cu);
17077 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
17078 type = lookup_methodptr_type (to_type);
17079 else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
17081 struct type *new_type
17082 = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
17084 smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
17085 TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
17086 TYPE_VARARGS (to_type));
17087 type = lookup_methodptr_type (new_type);
17090 type = lookup_memberptr_type (to_type, domain);
17092 return set_die_type (die, type, cu);
17095 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17096 the user defined type vector. */
17098 static struct type *
17099 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
17100 enum type_code refcode)
17102 struct comp_unit_head *cu_header = &cu->header;
17103 struct type *type, *target_type;
17104 struct attribute *attr;
17106 gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
17108 target_type = die_type (die, cu);
17110 /* The die_type call above may have already set the type for this DIE. */
17111 type = get_die_type (die, cu);
17115 type = lookup_reference_type (target_type, refcode);
17116 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17119 TYPE_LENGTH (type) = DW_UNSND (attr);
17123 TYPE_LENGTH (type) = cu_header->addr_size;
17125 maybe_set_alignment (cu, die, type);
17126 return set_die_type (die, type, cu);
17129 /* Add the given cv-qualifiers to the element type of the array. GCC
17130 outputs DWARF type qualifiers that apply to an array, not the
17131 element type. But GDB relies on the array element type to carry
17132 the cv-qualifiers. This mimics section 6.7.3 of the C99
17135 static struct type *
17136 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
17137 struct type *base_type, int cnst, int voltl)
17139 struct type *el_type, *inner_array;
17141 base_type = copy_type (base_type);
17142 inner_array = base_type;
17144 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
17146 TYPE_TARGET_TYPE (inner_array) =
17147 copy_type (TYPE_TARGET_TYPE (inner_array));
17148 inner_array = TYPE_TARGET_TYPE (inner_array);
17151 el_type = TYPE_TARGET_TYPE (inner_array);
17152 cnst |= TYPE_CONST (el_type);
17153 voltl |= TYPE_VOLATILE (el_type);
17154 TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
17156 return set_die_type (die, base_type, cu);
17159 static struct type *
17160 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
17162 struct type *base_type, *cv_type;
17164 base_type = die_type (die, cu);
17166 /* The die_type call above may have already set the type for this DIE. */
17167 cv_type = get_die_type (die, cu);
17171 /* In case the const qualifier is applied to an array type, the element type
17172 is so qualified, not the array type (section 6.7.3 of C99). */
17173 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17174 return add_array_cv_type (die, cu, base_type, 1, 0);
17176 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
17177 return set_die_type (die, cv_type, cu);
17180 static struct type *
17181 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
17183 struct type *base_type, *cv_type;
17185 base_type = die_type (die, cu);
17187 /* The die_type call above may have already set the type for this DIE. */
17188 cv_type = get_die_type (die, cu);
17192 /* In case the volatile qualifier is applied to an array type, the
17193 element type is so qualified, not the array type (section 6.7.3
17195 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17196 return add_array_cv_type (die, cu, base_type, 0, 1);
17198 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
17199 return set_die_type (die, cv_type, cu);
17202 /* Handle DW_TAG_restrict_type. */
17204 static struct type *
17205 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
17207 struct type *base_type, *cv_type;
17209 base_type = die_type (die, cu);
17211 /* The die_type call above may have already set the type for this DIE. */
17212 cv_type = get_die_type (die, cu);
17216 cv_type = make_restrict_type (base_type);
17217 return set_die_type (die, cv_type, cu);
17220 /* Handle DW_TAG_atomic_type. */
17222 static struct type *
17223 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
17225 struct type *base_type, *cv_type;
17227 base_type = die_type (die, cu);
17229 /* The die_type call above may have already set the type for this DIE. */
17230 cv_type = get_die_type (die, cu);
17234 cv_type = make_atomic_type (base_type);
17235 return set_die_type (die, cv_type, cu);
17238 /* Extract all information from a DW_TAG_string_type DIE and add to
17239 the user defined type vector. It isn't really a user defined type,
17240 but it behaves like one, with other DIE's using an AT_user_def_type
17241 attribute to reference it. */
17243 static struct type *
17244 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
17246 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17247 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17248 struct type *type, *range_type, *index_type, *char_type;
17249 struct attribute *attr;
17250 unsigned int length;
17252 attr = dwarf2_attr (die, DW_AT_string_length, cu);
17255 length = DW_UNSND (attr);
17259 /* Check for the DW_AT_byte_size attribute. */
17260 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17263 length = DW_UNSND (attr);
17271 index_type = objfile_type (objfile)->builtin_int;
17272 range_type = create_static_range_type (NULL, index_type, 1, length);
17273 char_type = language_string_char_type (cu->language_defn, gdbarch);
17274 type = create_string_type (NULL, char_type, range_type);
17276 return set_die_type (die, type, cu);
17279 /* Assuming that DIE corresponds to a function, returns nonzero
17280 if the function is prototyped. */
17283 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
17285 struct attribute *attr;
17287 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
17288 if (attr && (DW_UNSND (attr) != 0))
17291 /* The DWARF standard implies that the DW_AT_prototyped attribute
17292 is only meaninful for C, but the concept also extends to other
17293 languages that allow unprototyped functions (Eg: Objective C).
17294 For all other languages, assume that functions are always
17296 if (cu->language != language_c
17297 && cu->language != language_objc
17298 && cu->language != language_opencl)
17301 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17302 prototyped and unprototyped functions; default to prototyped,
17303 since that is more common in modern code (and RealView warns
17304 about unprototyped functions). */
17305 if (producer_is_realview (cu->producer))
17311 /* Handle DIES due to C code like:
17315 int (*funcp)(int a, long l);
17319 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17321 static struct type *
17322 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
17324 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17325 struct type *type; /* Type that this function returns. */
17326 struct type *ftype; /* Function that returns above type. */
17327 struct attribute *attr;
17329 type = die_type (die, cu);
17331 /* The die_type call above may have already set the type for this DIE. */
17332 ftype = get_die_type (die, cu);
17336 ftype = lookup_function_type (type);
17338 if (prototyped_function_p (die, cu))
17339 TYPE_PROTOTYPED (ftype) = 1;
17341 /* Store the calling convention in the type if it's available in
17342 the subroutine die. Otherwise set the calling convention to
17343 the default value DW_CC_normal. */
17344 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
17346 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
17347 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
17348 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
17350 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
17352 /* Record whether the function returns normally to its caller or not
17353 if the DWARF producer set that information. */
17354 attr = dwarf2_attr (die, DW_AT_noreturn, cu);
17355 if (attr && (DW_UNSND (attr) != 0))
17356 TYPE_NO_RETURN (ftype) = 1;
17358 /* We need to add the subroutine type to the die immediately so
17359 we don't infinitely recurse when dealing with parameters
17360 declared as the same subroutine type. */
17361 set_die_type (die, ftype, cu);
17363 if (die->child != NULL)
17365 struct type *void_type = objfile_type (objfile)->builtin_void;
17366 struct die_info *child_die;
17367 int nparams, iparams;
17369 /* Count the number of parameters.
17370 FIXME: GDB currently ignores vararg functions, but knows about
17371 vararg member functions. */
17373 child_die = die->child;
17374 while (child_die && child_die->tag)
17376 if (child_die->tag == DW_TAG_formal_parameter)
17378 else if (child_die->tag == DW_TAG_unspecified_parameters)
17379 TYPE_VARARGS (ftype) = 1;
17380 child_die = sibling_die (child_die);
17383 /* Allocate storage for parameters and fill them in. */
17384 TYPE_NFIELDS (ftype) = nparams;
17385 TYPE_FIELDS (ftype) = (struct field *)
17386 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
17388 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17389 even if we error out during the parameters reading below. */
17390 for (iparams = 0; iparams < nparams; iparams++)
17391 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
17394 child_die = die->child;
17395 while (child_die && child_die->tag)
17397 if (child_die->tag == DW_TAG_formal_parameter)
17399 struct type *arg_type;
17401 /* DWARF version 2 has no clean way to discern C++
17402 static and non-static member functions. G++ helps
17403 GDB by marking the first parameter for non-static
17404 member functions (which is the this pointer) as
17405 artificial. We pass this information to
17406 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17408 DWARF version 3 added DW_AT_object_pointer, which GCC
17409 4.5 does not yet generate. */
17410 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
17412 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
17414 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
17415 arg_type = die_type (child_die, cu);
17417 /* RealView does not mark THIS as const, which the testsuite
17418 expects. GCC marks THIS as const in method definitions,
17419 but not in the class specifications (GCC PR 43053). */
17420 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
17421 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
17424 struct dwarf2_cu *arg_cu = cu;
17425 const char *name = dwarf2_name (child_die, cu);
17427 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
17430 /* If the compiler emits this, use it. */
17431 if (follow_die_ref (die, attr, &arg_cu) == child_die)
17434 else if (name && strcmp (name, "this") == 0)
17435 /* Function definitions will have the argument names. */
17437 else if (name == NULL && iparams == 0)
17438 /* Declarations may not have the names, so like
17439 elsewhere in GDB, assume an artificial first
17440 argument is "this". */
17444 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
17448 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
17451 child_die = sibling_die (child_die);
17458 static struct type *
17459 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
17461 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17462 const char *name = NULL;
17463 struct type *this_type, *target_type;
17465 name = dwarf2_full_name (NULL, die, cu);
17466 this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
17467 TYPE_TARGET_STUB (this_type) = 1;
17468 set_die_type (die, this_type, cu);
17469 target_type = die_type (die, cu);
17470 if (target_type != this_type)
17471 TYPE_TARGET_TYPE (this_type) = target_type;
17474 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17475 spec and cause infinite loops in GDB. */
17476 complaint (_("Self-referential DW_TAG_typedef "
17477 "- DIE at %s [in module %s]"),
17478 sect_offset_str (die->sect_off), objfile_name (objfile));
17479 TYPE_TARGET_TYPE (this_type) = NULL;
17484 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17485 (which may be different from NAME) to the architecture back-end to allow
17486 it to guess the correct format if necessary. */
17488 static struct type *
17489 dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
17490 const char *name_hint)
17492 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17493 const struct floatformat **format;
17496 format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
17498 type = init_float_type (objfile, bits, name, format);
17500 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17505 /* Allocate an integer type of size BITS and name NAME. */
17507 static struct type *
17508 dwarf2_init_integer_type (struct dwarf2_cu *cu, struct objfile *objfile,
17509 int bits, int unsigned_p, const char *name)
17513 /* Versions of Intel's C Compiler generate an integer type called "void"
17514 instead of using DW_TAG_unspecified_type. This has been seen on
17515 at least versions 14, 17, and 18. */
17516 if (bits == 0 && producer_is_icc (cu) && name != nullptr
17517 && strcmp (name, "void") == 0)
17518 type = objfile_type (objfile)->builtin_void;
17520 type = init_integer_type (objfile, bits, unsigned_p, name);
17525 /* Find a representation of a given base type and install
17526 it in the TYPE field of the die. */
17528 static struct type *
17529 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
17531 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17533 struct attribute *attr;
17534 int encoding = 0, bits = 0;
17537 attr = dwarf2_attr (die, DW_AT_encoding, cu);
17540 encoding = DW_UNSND (attr);
17542 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17545 bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
17547 name = dwarf2_name (die, cu);
17550 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17555 case DW_ATE_address:
17556 /* Turn DW_ATE_address into a void * pointer. */
17557 type = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
17558 type = init_pointer_type (objfile, bits, name, type);
17560 case DW_ATE_boolean:
17561 type = init_boolean_type (objfile, bits, 1, name);
17563 case DW_ATE_complex_float:
17564 type = dwarf2_init_float_type (objfile, bits / 2, NULL, name);
17565 type = init_complex_type (objfile, name, type);
17567 case DW_ATE_decimal_float:
17568 type = init_decfloat_type (objfile, bits, name);
17571 type = dwarf2_init_float_type (objfile, bits, name, name);
17573 case DW_ATE_signed:
17574 type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17576 case DW_ATE_unsigned:
17577 if (cu->language == language_fortran
17579 && startswith (name, "character("))
17580 type = init_character_type (objfile, bits, 1, name);
17582 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17584 case DW_ATE_signed_char:
17585 if (cu->language == language_ada || cu->language == language_m2
17586 || cu->language == language_pascal
17587 || cu->language == language_fortran)
17588 type = init_character_type (objfile, bits, 0, name);
17590 type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17592 case DW_ATE_unsigned_char:
17593 if (cu->language == language_ada || cu->language == language_m2
17594 || cu->language == language_pascal
17595 || cu->language == language_fortran
17596 || cu->language == language_rust)
17597 type = init_character_type (objfile, bits, 1, name);
17599 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17603 gdbarch *arch = get_objfile_arch (objfile);
17606 type = builtin_type (arch)->builtin_char16;
17607 else if (bits == 32)
17608 type = builtin_type (arch)->builtin_char32;
17611 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17613 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17615 return set_die_type (die, type, cu);
17620 complaint (_("unsupported DW_AT_encoding: '%s'"),
17621 dwarf_type_encoding_name (encoding));
17622 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17626 if (name && strcmp (name, "char") == 0)
17627 TYPE_NOSIGN (type) = 1;
17629 maybe_set_alignment (cu, die, type);
17631 return set_die_type (die, type, cu);
17634 /* Parse dwarf attribute if it's a block, reference or constant and put the
17635 resulting value of the attribute into struct bound_prop.
17636 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17639 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
17640 struct dwarf2_cu *cu, struct dynamic_prop *prop)
17642 struct dwarf2_property_baton *baton;
17643 struct obstack *obstack
17644 = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
17646 if (attr == NULL || prop == NULL)
17649 if (attr_form_is_block (attr))
17651 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17652 baton->referenced_type = NULL;
17653 baton->locexpr.per_cu = cu->per_cu;
17654 baton->locexpr.size = DW_BLOCK (attr)->size;
17655 baton->locexpr.data = DW_BLOCK (attr)->data;
17656 prop->data.baton = baton;
17657 prop->kind = PROP_LOCEXPR;
17658 gdb_assert (prop->data.baton != NULL);
17660 else if (attr_form_is_ref (attr))
17662 struct dwarf2_cu *target_cu = cu;
17663 struct die_info *target_die;
17664 struct attribute *target_attr;
17666 target_die = follow_die_ref (die, attr, &target_cu);
17667 target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
17668 if (target_attr == NULL)
17669 target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
17671 if (target_attr == NULL)
17674 switch (target_attr->name)
17676 case DW_AT_location:
17677 if (attr_form_is_section_offset (target_attr))
17679 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17680 baton->referenced_type = die_type (target_die, target_cu);
17681 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
17682 prop->data.baton = baton;
17683 prop->kind = PROP_LOCLIST;
17684 gdb_assert (prop->data.baton != NULL);
17686 else if (attr_form_is_block (target_attr))
17688 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17689 baton->referenced_type = die_type (target_die, target_cu);
17690 baton->locexpr.per_cu = cu->per_cu;
17691 baton->locexpr.size = DW_BLOCK (target_attr)->size;
17692 baton->locexpr.data = DW_BLOCK (target_attr)->data;
17693 prop->data.baton = baton;
17694 prop->kind = PROP_LOCEXPR;
17695 gdb_assert (prop->data.baton != NULL);
17699 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17700 "dynamic property");
17704 case DW_AT_data_member_location:
17708 if (!handle_data_member_location (target_die, target_cu,
17712 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17713 baton->referenced_type = read_type_die (target_die->parent,
17715 baton->offset_info.offset = offset;
17716 baton->offset_info.type = die_type (target_die, target_cu);
17717 prop->data.baton = baton;
17718 prop->kind = PROP_ADDR_OFFSET;
17723 else if (attr_form_is_constant (attr))
17725 prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
17726 prop->kind = PROP_CONST;
17730 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
17731 dwarf2_name (die, cu));
17738 /* Read the given DW_AT_subrange DIE. */
17740 static struct type *
17741 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
17743 struct type *base_type, *orig_base_type;
17744 struct type *range_type;
17745 struct attribute *attr;
17746 struct dynamic_prop low, high;
17747 int low_default_is_valid;
17748 int high_bound_is_count = 0;
17750 ULONGEST negative_mask;
17752 orig_base_type = die_type (die, cu);
17753 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17754 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17755 creating the range type, but we use the result of check_typedef
17756 when examining properties of the type. */
17757 base_type = check_typedef (orig_base_type);
17759 /* The die_type call above may have already set the type for this DIE. */
17760 range_type = get_die_type (die, cu);
17764 low.kind = PROP_CONST;
17765 high.kind = PROP_CONST;
17766 high.data.const_val = 0;
17768 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17769 omitting DW_AT_lower_bound. */
17770 switch (cu->language)
17773 case language_cplus:
17774 low.data.const_val = 0;
17775 low_default_is_valid = 1;
17777 case language_fortran:
17778 low.data.const_val = 1;
17779 low_default_is_valid = 1;
17782 case language_objc:
17783 case language_rust:
17784 low.data.const_val = 0;
17785 low_default_is_valid = (cu->header.version >= 4);
17789 case language_pascal:
17790 low.data.const_val = 1;
17791 low_default_is_valid = (cu->header.version >= 4);
17794 low.data.const_val = 0;
17795 low_default_is_valid = 0;
17799 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
17801 attr_to_dynamic_prop (attr, die, cu, &low);
17802 else if (!low_default_is_valid)
17803 complaint (_("Missing DW_AT_lower_bound "
17804 "- DIE at %s [in module %s]"),
17805 sect_offset_str (die->sect_off),
17806 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17808 struct attribute *attr_ub, *attr_count;
17809 attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);
17810 if (!attr_to_dynamic_prop (attr, die, cu, &high))
17812 attr = attr_count = dwarf2_attr (die, DW_AT_count, cu);
17813 if (attr_to_dynamic_prop (attr, die, cu, &high))
17815 /* If bounds are constant do the final calculation here. */
17816 if (low.kind == PROP_CONST && high.kind == PROP_CONST)
17817 high.data.const_val = low.data.const_val + high.data.const_val - 1;
17819 high_bound_is_count = 1;
17823 if (attr_ub != NULL)
17824 complaint (_("Unresolved DW_AT_upper_bound "
17825 "- DIE at %s [in module %s]"),
17826 sect_offset_str (die->sect_off),
17827 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17828 if (attr_count != NULL)
17829 complaint (_("Unresolved DW_AT_count "
17830 "- DIE at %s [in module %s]"),
17831 sect_offset_str (die->sect_off),
17832 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17837 /* Dwarf-2 specifications explicitly allows to create subrange types
17838 without specifying a base type.
17839 In that case, the base type must be set to the type of
17840 the lower bound, upper bound or count, in that order, if any of these
17841 three attributes references an object that has a type.
17842 If no base type is found, the Dwarf-2 specifications say that
17843 a signed integer type of size equal to the size of an address should
17845 For the following C code: `extern char gdb_int [];'
17846 GCC produces an empty range DIE.
17847 FIXME: muller/2010-05-28: Possible references to object for low bound,
17848 high bound or count are not yet handled by this code. */
17849 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
17851 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17852 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17853 int addr_size = gdbarch_addr_bit (gdbarch) /8;
17854 struct type *int_type = objfile_type (objfile)->builtin_int;
17856 /* Test "int", "long int", and "long long int" objfile types,
17857 and select the first one having a size above or equal to the
17858 architecture address size. */
17859 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17860 base_type = int_type;
17863 int_type = objfile_type (objfile)->builtin_long;
17864 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17865 base_type = int_type;
17868 int_type = objfile_type (objfile)->builtin_long_long;
17869 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17870 base_type = int_type;
17875 /* Normally, the DWARF producers are expected to use a signed
17876 constant form (Eg. DW_FORM_sdata) to express negative bounds.
17877 But this is unfortunately not always the case, as witnessed
17878 with GCC, for instance, where the ambiguous DW_FORM_dataN form
17879 is used instead. To work around that ambiguity, we treat
17880 the bounds as signed, and thus sign-extend their values, when
17881 the base type is signed. */
17883 -((ULONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
17884 if (low.kind == PROP_CONST
17885 && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
17886 low.data.const_val |= negative_mask;
17887 if (high.kind == PROP_CONST
17888 && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
17889 high.data.const_val |= negative_mask;
17891 range_type = create_range_type (NULL, orig_base_type, &low, &high);
17893 if (high_bound_is_count)
17894 TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
17896 /* Ada expects an empty array on no boundary attributes. */
17897 if (attr == NULL && cu->language != language_ada)
17898 TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
17900 name = dwarf2_name (die, cu);
17902 TYPE_NAME (range_type) = name;
17904 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17906 TYPE_LENGTH (range_type) = DW_UNSND (attr);
17908 maybe_set_alignment (cu, die, range_type);
17910 set_die_type (die, range_type, cu);
17912 /* set_die_type should be already done. */
17913 set_descriptive_type (range_type, die, cu);
17918 static struct type *
17919 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
17923 type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
17925 TYPE_NAME (type) = dwarf2_name (die, cu);
17927 /* In Ada, an unspecified type is typically used when the description
17928 of the type is defered to a different unit. When encountering
17929 such a type, we treat it as a stub, and try to resolve it later on,
17931 if (cu->language == language_ada)
17932 TYPE_STUB (type) = 1;
17934 return set_die_type (die, type, cu);
17937 /* Read a single die and all its descendents. Set the die's sibling
17938 field to NULL; set other fields in the die correctly, and set all
17939 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
17940 location of the info_ptr after reading all of those dies. PARENT
17941 is the parent of the die in question. */
17943 static struct die_info *
17944 read_die_and_children (const struct die_reader_specs *reader,
17945 const gdb_byte *info_ptr,
17946 const gdb_byte **new_info_ptr,
17947 struct die_info *parent)
17949 struct die_info *die;
17950 const gdb_byte *cur_ptr;
17953 cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
17956 *new_info_ptr = cur_ptr;
17959 store_in_ref_table (die, reader->cu);
17962 die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
17966 *new_info_ptr = cur_ptr;
17969 die->sibling = NULL;
17970 die->parent = parent;
17974 /* Read a die, all of its descendents, and all of its siblings; set
17975 all of the fields of all of the dies correctly. Arguments are as
17976 in read_die_and_children. */
17978 static struct die_info *
17979 read_die_and_siblings_1 (const struct die_reader_specs *reader,
17980 const gdb_byte *info_ptr,
17981 const gdb_byte **new_info_ptr,
17982 struct die_info *parent)
17984 struct die_info *first_die, *last_sibling;
17985 const gdb_byte *cur_ptr;
17987 cur_ptr = info_ptr;
17988 first_die = last_sibling = NULL;
17992 struct die_info *die
17993 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
17997 *new_info_ptr = cur_ptr;
18004 last_sibling->sibling = die;
18006 last_sibling = die;
18010 /* Read a die, all of its descendents, and all of its siblings; set
18011 all of the fields of all of the dies correctly. Arguments are as
18012 in read_die_and_children.
18013 This the main entry point for reading a DIE and all its children. */
18015 static struct die_info *
18016 read_die_and_siblings (const struct die_reader_specs *reader,
18017 const gdb_byte *info_ptr,
18018 const gdb_byte **new_info_ptr,
18019 struct die_info *parent)
18021 struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
18022 new_info_ptr, parent);
18024 if (dwarf_die_debug)
18026 fprintf_unfiltered (gdb_stdlog,
18027 "Read die from %s@0x%x of %s:\n",
18028 get_section_name (reader->die_section),
18029 (unsigned) (info_ptr - reader->die_section->buffer),
18030 bfd_get_filename (reader->abfd));
18031 dump_die (die, dwarf_die_debug);
18037 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18039 The caller is responsible for filling in the extra attributes
18040 and updating (*DIEP)->num_attrs.
18041 Set DIEP to point to a newly allocated die with its information,
18042 except for its child, sibling, and parent fields.
18043 Set HAS_CHILDREN to tell whether the die has children or not. */
18045 static const gdb_byte *
18046 read_full_die_1 (const struct die_reader_specs *reader,
18047 struct die_info **diep, const gdb_byte *info_ptr,
18048 int *has_children, int num_extra_attrs)
18050 unsigned int abbrev_number, bytes_read, i;
18051 struct abbrev_info *abbrev;
18052 struct die_info *die;
18053 struct dwarf2_cu *cu = reader->cu;
18054 bfd *abfd = reader->abfd;
18056 sect_offset sect_off = (sect_offset) (info_ptr - reader->buffer);
18057 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
18058 info_ptr += bytes_read;
18059 if (!abbrev_number)
18066 abbrev = reader->abbrev_table->lookup_abbrev (abbrev_number);
18068 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18070 bfd_get_filename (abfd));
18072 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
18073 die->sect_off = sect_off;
18074 die->tag = abbrev->tag;
18075 die->abbrev = abbrev_number;
18077 /* Make the result usable.
18078 The caller needs to update num_attrs after adding the extra
18080 die->num_attrs = abbrev->num_attrs;
18082 for (i = 0; i < abbrev->num_attrs; ++i)
18083 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
18087 *has_children = abbrev->has_children;
18091 /* Read a die and all its attributes.
18092 Set DIEP to point to a newly allocated die with its information,
18093 except for its child, sibling, and parent fields.
18094 Set HAS_CHILDREN to tell whether the die has children or not. */
18096 static const gdb_byte *
18097 read_full_die (const struct die_reader_specs *reader,
18098 struct die_info **diep, const gdb_byte *info_ptr,
18101 const gdb_byte *result;
18103 result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
18105 if (dwarf_die_debug)
18107 fprintf_unfiltered (gdb_stdlog,
18108 "Read die from %s@0x%x of %s:\n",
18109 get_section_name (reader->die_section),
18110 (unsigned) (info_ptr - reader->die_section->buffer),
18111 bfd_get_filename (reader->abfd));
18112 dump_die (*diep, dwarf_die_debug);
18118 /* Abbreviation tables.
18120 In DWARF version 2, the description of the debugging information is
18121 stored in a separate .debug_abbrev section. Before we read any
18122 dies from a section we read in all abbreviations and install them
18123 in a hash table. */
18125 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18127 struct abbrev_info *
18128 abbrev_table::alloc_abbrev ()
18130 struct abbrev_info *abbrev;
18132 abbrev = XOBNEW (&abbrev_obstack, struct abbrev_info);
18133 memset (abbrev, 0, sizeof (struct abbrev_info));
18138 /* Add an abbreviation to the table. */
18141 abbrev_table::add_abbrev (unsigned int abbrev_number,
18142 struct abbrev_info *abbrev)
18144 unsigned int hash_number;
18146 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18147 abbrev->next = m_abbrevs[hash_number];
18148 m_abbrevs[hash_number] = abbrev;
18151 /* Look up an abbrev in the table.
18152 Returns NULL if the abbrev is not found. */
18154 struct abbrev_info *
18155 abbrev_table::lookup_abbrev (unsigned int abbrev_number)
18157 unsigned int hash_number;
18158 struct abbrev_info *abbrev;
18160 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18161 abbrev = m_abbrevs[hash_number];
18165 if (abbrev->number == abbrev_number)
18167 abbrev = abbrev->next;
18172 /* Read in an abbrev table. */
18174 static abbrev_table_up
18175 abbrev_table_read_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
18176 struct dwarf2_section_info *section,
18177 sect_offset sect_off)
18179 struct objfile *objfile = dwarf2_per_objfile->objfile;
18180 bfd *abfd = get_section_bfd_owner (section);
18181 const gdb_byte *abbrev_ptr;
18182 struct abbrev_info *cur_abbrev;
18183 unsigned int abbrev_number, bytes_read, abbrev_name;
18184 unsigned int abbrev_form;
18185 struct attr_abbrev *cur_attrs;
18186 unsigned int allocated_attrs;
18188 abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
18190 dwarf2_read_section (objfile, section);
18191 abbrev_ptr = section->buffer + to_underlying (sect_off);
18192 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18193 abbrev_ptr += bytes_read;
18195 allocated_attrs = ATTR_ALLOC_CHUNK;
18196 cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
18198 /* Loop until we reach an abbrev number of 0. */
18199 while (abbrev_number)
18201 cur_abbrev = abbrev_table->alloc_abbrev ();
18203 /* read in abbrev header */
18204 cur_abbrev->number = abbrev_number;
18206 = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18207 abbrev_ptr += bytes_read;
18208 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
18211 /* now read in declarations */
18214 LONGEST implicit_const;
18216 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18217 abbrev_ptr += bytes_read;
18218 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18219 abbrev_ptr += bytes_read;
18220 if (abbrev_form == DW_FORM_implicit_const)
18222 implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
18224 abbrev_ptr += bytes_read;
18228 /* Initialize it due to a false compiler warning. */
18229 implicit_const = -1;
18232 if (abbrev_name == 0)
18235 if (cur_abbrev->num_attrs == allocated_attrs)
18237 allocated_attrs += ATTR_ALLOC_CHUNK;
18239 = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
18242 cur_attrs[cur_abbrev->num_attrs].name
18243 = (enum dwarf_attribute) abbrev_name;
18244 cur_attrs[cur_abbrev->num_attrs].form
18245 = (enum dwarf_form) abbrev_form;
18246 cur_attrs[cur_abbrev->num_attrs].implicit_const = implicit_const;
18247 ++cur_abbrev->num_attrs;
18250 cur_abbrev->attrs =
18251 XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
18252 cur_abbrev->num_attrs);
18253 memcpy (cur_abbrev->attrs, cur_attrs,
18254 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
18256 abbrev_table->add_abbrev (abbrev_number, cur_abbrev);
18258 /* Get next abbreviation.
18259 Under Irix6 the abbreviations for a compilation unit are not
18260 always properly terminated with an abbrev number of 0.
18261 Exit loop if we encounter an abbreviation which we have
18262 already read (which means we are about to read the abbreviations
18263 for the next compile unit) or if the end of the abbreviation
18264 table is reached. */
18265 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
18267 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18268 abbrev_ptr += bytes_read;
18269 if (abbrev_table->lookup_abbrev (abbrev_number) != NULL)
18274 return abbrev_table;
18277 /* Returns nonzero if TAG represents a type that we might generate a partial
18281 is_type_tag_for_partial (int tag)
18286 /* Some types that would be reasonable to generate partial symbols for,
18287 that we don't at present. */
18288 case DW_TAG_array_type:
18289 case DW_TAG_file_type:
18290 case DW_TAG_ptr_to_member_type:
18291 case DW_TAG_set_type:
18292 case DW_TAG_string_type:
18293 case DW_TAG_subroutine_type:
18295 case DW_TAG_base_type:
18296 case DW_TAG_class_type:
18297 case DW_TAG_interface_type:
18298 case DW_TAG_enumeration_type:
18299 case DW_TAG_structure_type:
18300 case DW_TAG_subrange_type:
18301 case DW_TAG_typedef:
18302 case DW_TAG_union_type:
18309 /* Load all DIEs that are interesting for partial symbols into memory. */
18311 static struct partial_die_info *
18312 load_partial_dies (const struct die_reader_specs *reader,
18313 const gdb_byte *info_ptr, int building_psymtab)
18315 struct dwarf2_cu *cu = reader->cu;
18316 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18317 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
18318 unsigned int bytes_read;
18319 unsigned int load_all = 0;
18320 int nesting_level = 1;
18325 gdb_assert (cu->per_cu != NULL);
18326 if (cu->per_cu->load_all_dies)
18330 = htab_create_alloc_ex (cu->header.length / 12,
18334 &cu->comp_unit_obstack,
18335 hashtab_obstack_allocate,
18336 dummy_obstack_deallocate);
18340 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
18342 /* A NULL abbrev means the end of a series of children. */
18343 if (abbrev == NULL)
18345 if (--nesting_level == 0)
18348 info_ptr += bytes_read;
18349 last_die = parent_die;
18350 parent_die = parent_die->die_parent;
18354 /* Check for template arguments. We never save these; if
18355 they're seen, we just mark the parent, and go on our way. */
18356 if (parent_die != NULL
18357 && cu->language == language_cplus
18358 && (abbrev->tag == DW_TAG_template_type_param
18359 || abbrev->tag == DW_TAG_template_value_param))
18361 parent_die->has_template_arguments = 1;
18365 /* We don't need a partial DIE for the template argument. */
18366 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18371 /* We only recurse into c++ subprograms looking for template arguments.
18372 Skip their other children. */
18374 && cu->language == language_cplus
18375 && parent_die != NULL
18376 && parent_die->tag == DW_TAG_subprogram)
18378 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18382 /* Check whether this DIE is interesting enough to save. Normally
18383 we would not be interested in members here, but there may be
18384 later variables referencing them via DW_AT_specification (for
18385 static members). */
18387 && !is_type_tag_for_partial (abbrev->tag)
18388 && abbrev->tag != DW_TAG_constant
18389 && abbrev->tag != DW_TAG_enumerator
18390 && abbrev->tag != DW_TAG_subprogram
18391 && abbrev->tag != DW_TAG_inlined_subroutine
18392 && abbrev->tag != DW_TAG_lexical_block
18393 && abbrev->tag != DW_TAG_variable
18394 && abbrev->tag != DW_TAG_namespace
18395 && abbrev->tag != DW_TAG_module
18396 && abbrev->tag != DW_TAG_member
18397 && abbrev->tag != DW_TAG_imported_unit
18398 && abbrev->tag != DW_TAG_imported_declaration)
18400 /* Otherwise we skip to the next sibling, if any. */
18401 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18405 struct partial_die_info pdi ((sect_offset) (info_ptr - reader->buffer),
18408 info_ptr = pdi.read (reader, *abbrev, info_ptr + bytes_read);
18410 /* This two-pass algorithm for processing partial symbols has a
18411 high cost in cache pressure. Thus, handle some simple cases
18412 here which cover the majority of C partial symbols. DIEs
18413 which neither have specification tags in them, nor could have
18414 specification tags elsewhere pointing at them, can simply be
18415 processed and discarded.
18417 This segment is also optional; scan_partial_symbols and
18418 add_partial_symbol will handle these DIEs if we chain
18419 them in normally. When compilers which do not emit large
18420 quantities of duplicate debug information are more common,
18421 this code can probably be removed. */
18423 /* Any complete simple types at the top level (pretty much all
18424 of them, for a language without namespaces), can be processed
18426 if (parent_die == NULL
18427 && pdi.has_specification == 0
18428 && pdi.is_declaration == 0
18429 && ((pdi.tag == DW_TAG_typedef && !pdi.has_children)
18430 || pdi.tag == DW_TAG_base_type
18431 || pdi.tag == DW_TAG_subrange_type))
18433 if (building_psymtab && pdi.name != NULL)
18434 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18435 VAR_DOMAIN, LOC_TYPEDEF, -1,
18436 psymbol_placement::STATIC,
18437 0, cu->language, objfile);
18438 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18442 /* The exception for DW_TAG_typedef with has_children above is
18443 a workaround of GCC PR debug/47510. In the case of this complaint
18444 type_name_or_error will error on such types later.
18446 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18447 it could not find the child DIEs referenced later, this is checked
18448 above. In correct DWARF DW_TAG_typedef should have no children. */
18450 if (pdi.tag == DW_TAG_typedef && pdi.has_children)
18451 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18452 "- DIE at %s [in module %s]"),
18453 sect_offset_str (pdi.sect_off), objfile_name (objfile));
18455 /* If we're at the second level, and we're an enumerator, and
18456 our parent has no specification (meaning possibly lives in a
18457 namespace elsewhere), then we can add the partial symbol now
18458 instead of queueing it. */
18459 if (pdi.tag == DW_TAG_enumerator
18460 && parent_die != NULL
18461 && parent_die->die_parent == NULL
18462 && parent_die->tag == DW_TAG_enumeration_type
18463 && parent_die->has_specification == 0)
18465 if (pdi.name == NULL)
18466 complaint (_("malformed enumerator DIE ignored"));
18467 else if (building_psymtab)
18468 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18469 VAR_DOMAIN, LOC_CONST, -1,
18470 cu->language == language_cplus
18471 ? psymbol_placement::GLOBAL
18472 : psymbol_placement::STATIC,
18473 0, cu->language, objfile);
18475 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18479 struct partial_die_info *part_die
18480 = new (&cu->comp_unit_obstack) partial_die_info (pdi);
18482 /* We'll save this DIE so link it in. */
18483 part_die->die_parent = parent_die;
18484 part_die->die_sibling = NULL;
18485 part_die->die_child = NULL;
18487 if (last_die && last_die == parent_die)
18488 last_die->die_child = part_die;
18490 last_die->die_sibling = part_die;
18492 last_die = part_die;
18494 if (first_die == NULL)
18495 first_die = part_die;
18497 /* Maybe add the DIE to the hash table. Not all DIEs that we
18498 find interesting need to be in the hash table, because we
18499 also have the parent/sibling/child chains; only those that we
18500 might refer to by offset later during partial symbol reading.
18502 For now this means things that might have be the target of a
18503 DW_AT_specification, DW_AT_abstract_origin, or
18504 DW_AT_extension. DW_AT_extension will refer only to
18505 namespaces; DW_AT_abstract_origin refers to functions (and
18506 many things under the function DIE, but we do not recurse
18507 into function DIEs during partial symbol reading) and
18508 possibly variables as well; DW_AT_specification refers to
18509 declarations. Declarations ought to have the DW_AT_declaration
18510 flag. It happens that GCC forgets to put it in sometimes, but
18511 only for functions, not for types.
18513 Adding more things than necessary to the hash table is harmless
18514 except for the performance cost. Adding too few will result in
18515 wasted time in find_partial_die, when we reread the compilation
18516 unit with load_all_dies set. */
18519 || abbrev->tag == DW_TAG_constant
18520 || abbrev->tag == DW_TAG_subprogram
18521 || abbrev->tag == DW_TAG_variable
18522 || abbrev->tag == DW_TAG_namespace
18523 || part_die->is_declaration)
18527 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
18528 to_underlying (part_die->sect_off),
18533 /* For some DIEs we want to follow their children (if any). For C
18534 we have no reason to follow the children of structures; for other
18535 languages we have to, so that we can get at method physnames
18536 to infer fully qualified class names, for DW_AT_specification,
18537 and for C++ template arguments. For C++, we also look one level
18538 inside functions to find template arguments (if the name of the
18539 function does not already contain the template arguments).
18541 For Ada, we need to scan the children of subprograms and lexical
18542 blocks as well because Ada allows the definition of nested
18543 entities that could be interesting for the debugger, such as
18544 nested subprograms for instance. */
18545 if (last_die->has_children
18547 || last_die->tag == DW_TAG_namespace
18548 || last_die->tag == DW_TAG_module
18549 || last_die->tag == DW_TAG_enumeration_type
18550 || (cu->language == language_cplus
18551 && last_die->tag == DW_TAG_subprogram
18552 && (last_die->name == NULL
18553 || strchr (last_die->name, '<') == NULL))
18554 || (cu->language != language_c
18555 && (last_die->tag == DW_TAG_class_type
18556 || last_die->tag == DW_TAG_interface_type
18557 || last_die->tag == DW_TAG_structure_type
18558 || last_die->tag == DW_TAG_union_type))
18559 || (cu->language == language_ada
18560 && (last_die->tag == DW_TAG_subprogram
18561 || last_die->tag == DW_TAG_lexical_block))))
18564 parent_die = last_die;
18568 /* Otherwise we skip to the next sibling, if any. */
18569 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
18571 /* Back to the top, do it again. */
18575 partial_die_info::partial_die_info (sect_offset sect_off_,
18576 struct abbrev_info *abbrev)
18577 : partial_die_info (sect_off_, abbrev->tag, abbrev->has_children)
18581 /* Read a minimal amount of information into the minimal die structure.
18582 INFO_PTR should point just after the initial uleb128 of a DIE. */
18585 partial_die_info::read (const struct die_reader_specs *reader,
18586 const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
18588 struct dwarf2_cu *cu = reader->cu;
18589 struct dwarf2_per_objfile *dwarf2_per_objfile
18590 = cu->per_cu->dwarf2_per_objfile;
18592 int has_low_pc_attr = 0;
18593 int has_high_pc_attr = 0;
18594 int high_pc_relative = 0;
18596 for (i = 0; i < abbrev.num_attrs; ++i)
18598 struct attribute attr;
18600 info_ptr = read_attribute (reader, &attr, &abbrev.attrs[i], info_ptr);
18602 /* Store the data if it is of an attribute we want to keep in a
18603 partial symbol table. */
18609 case DW_TAG_compile_unit:
18610 case DW_TAG_partial_unit:
18611 case DW_TAG_type_unit:
18612 /* Compilation units have a DW_AT_name that is a filename, not
18613 a source language identifier. */
18614 case DW_TAG_enumeration_type:
18615 case DW_TAG_enumerator:
18616 /* These tags always have simple identifiers already; no need
18617 to canonicalize them. */
18618 name = DW_STRING (&attr);
18622 struct objfile *objfile = dwarf2_per_objfile->objfile;
18625 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
18626 &objfile->per_bfd->storage_obstack);
18631 case DW_AT_linkage_name:
18632 case DW_AT_MIPS_linkage_name:
18633 /* Note that both forms of linkage name might appear. We
18634 assume they will be the same, and we only store the last
18636 if (cu->language == language_ada)
18637 name = DW_STRING (&attr);
18638 linkage_name = DW_STRING (&attr);
18641 has_low_pc_attr = 1;
18642 lowpc = attr_value_as_address (&attr);
18644 case DW_AT_high_pc:
18645 has_high_pc_attr = 1;
18646 highpc = attr_value_as_address (&attr);
18647 if (cu->header.version >= 4 && attr_form_is_constant (&attr))
18648 high_pc_relative = 1;
18650 case DW_AT_location:
18651 /* Support the .debug_loc offsets. */
18652 if (attr_form_is_block (&attr))
18654 d.locdesc = DW_BLOCK (&attr);
18656 else if (attr_form_is_section_offset (&attr))
18658 dwarf2_complex_location_expr_complaint ();
18662 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18663 "partial symbol information");
18666 case DW_AT_external:
18667 is_external = DW_UNSND (&attr);
18669 case DW_AT_declaration:
18670 is_declaration = DW_UNSND (&attr);
18675 case DW_AT_abstract_origin:
18676 case DW_AT_specification:
18677 case DW_AT_extension:
18678 has_specification = 1;
18679 spec_offset = dwarf2_get_ref_die_offset (&attr);
18680 spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18681 || cu->per_cu->is_dwz);
18683 case DW_AT_sibling:
18684 /* Ignore absolute siblings, they might point outside of
18685 the current compile unit. */
18686 if (attr.form == DW_FORM_ref_addr)
18687 complaint (_("ignoring absolute DW_AT_sibling"));
18690 const gdb_byte *buffer = reader->buffer;
18691 sect_offset off = dwarf2_get_ref_die_offset (&attr);
18692 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
18694 if (sibling_ptr < info_ptr)
18695 complaint (_("DW_AT_sibling points backwards"));
18696 else if (sibling_ptr > reader->buffer_end)
18697 dwarf2_section_buffer_overflow_complaint (reader->die_section);
18699 sibling = sibling_ptr;
18702 case DW_AT_byte_size:
18705 case DW_AT_const_value:
18706 has_const_value = 1;
18708 case DW_AT_calling_convention:
18709 /* DWARF doesn't provide a way to identify a program's source-level
18710 entry point. DW_AT_calling_convention attributes are only meant
18711 to describe functions' calling conventions.
18713 However, because it's a necessary piece of information in
18714 Fortran, and before DWARF 4 DW_CC_program was the only
18715 piece of debugging information whose definition refers to
18716 a 'main program' at all, several compilers marked Fortran
18717 main programs with DW_CC_program --- even when those
18718 functions use the standard calling conventions.
18720 Although DWARF now specifies a way to provide this
18721 information, we support this practice for backward
18723 if (DW_UNSND (&attr) == DW_CC_program
18724 && cu->language == language_fortran)
18725 main_subprogram = 1;
18728 if (DW_UNSND (&attr) == DW_INL_inlined
18729 || DW_UNSND (&attr) == DW_INL_declared_inlined)
18730 may_be_inlined = 1;
18734 if (tag == DW_TAG_imported_unit)
18736 d.sect_off = dwarf2_get_ref_die_offset (&attr);
18737 is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18738 || cu->per_cu->is_dwz);
18742 case DW_AT_main_subprogram:
18743 main_subprogram = DW_UNSND (&attr);
18751 if (high_pc_relative)
18754 if (has_low_pc_attr && has_high_pc_attr)
18756 /* When using the GNU linker, .gnu.linkonce. sections are used to
18757 eliminate duplicate copies of functions and vtables and such.
18758 The linker will arbitrarily choose one and discard the others.
18759 The AT_*_pc values for such functions refer to local labels in
18760 these sections. If the section from that file was discarded, the
18761 labels are not in the output, so the relocs get a value of 0.
18762 If this is a discarded function, mark the pc bounds as invalid,
18763 so that GDB will ignore it. */
18764 if (lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
18766 struct objfile *objfile = dwarf2_per_objfile->objfile;
18767 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18769 complaint (_("DW_AT_low_pc %s is zero "
18770 "for DIE at %s [in module %s]"),
18771 paddress (gdbarch, lowpc),
18772 sect_offset_str (sect_off),
18773 objfile_name (objfile));
18775 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18776 else if (lowpc >= highpc)
18778 struct objfile *objfile = dwarf2_per_objfile->objfile;
18779 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18781 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18782 "for DIE at %s [in module %s]"),
18783 paddress (gdbarch, lowpc),
18784 paddress (gdbarch, highpc),
18785 sect_offset_str (sect_off),
18786 objfile_name (objfile));
18795 /* Find a cached partial DIE at OFFSET in CU. */
18797 struct partial_die_info *
18798 dwarf2_cu::find_partial_die (sect_offset sect_off)
18800 struct partial_die_info *lookup_die = NULL;
18801 struct partial_die_info part_die (sect_off);
18803 lookup_die = ((struct partial_die_info *)
18804 htab_find_with_hash (partial_dies, &part_die,
18805 to_underlying (sect_off)));
18810 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18811 except in the case of .debug_types DIEs which do not reference
18812 outside their CU (they do however referencing other types via
18813 DW_FORM_ref_sig8). */
18815 static struct partial_die_info *
18816 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
18818 struct dwarf2_per_objfile *dwarf2_per_objfile
18819 = cu->per_cu->dwarf2_per_objfile;
18820 struct objfile *objfile = dwarf2_per_objfile->objfile;
18821 struct dwarf2_per_cu_data *per_cu = NULL;
18822 struct partial_die_info *pd = NULL;
18824 if (offset_in_dwz == cu->per_cu->is_dwz
18825 && offset_in_cu_p (&cu->header, sect_off))
18827 pd = cu->find_partial_die (sect_off);
18830 /* We missed recording what we needed.
18831 Load all dies and try again. */
18832 per_cu = cu->per_cu;
18836 /* TUs don't reference other CUs/TUs (except via type signatures). */
18837 if (cu->per_cu->is_debug_types)
18839 error (_("Dwarf Error: Type Unit at offset %s contains"
18840 " external reference to offset %s [in module %s].\n"),
18841 sect_offset_str (cu->header.sect_off), sect_offset_str (sect_off),
18842 bfd_get_filename (objfile->obfd));
18844 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
18845 dwarf2_per_objfile);
18847 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
18848 load_partial_comp_unit (per_cu);
18850 per_cu->cu->last_used = 0;
18851 pd = per_cu->cu->find_partial_die (sect_off);
18854 /* If we didn't find it, and not all dies have been loaded,
18855 load them all and try again. */
18857 if (pd == NULL && per_cu->load_all_dies == 0)
18859 per_cu->load_all_dies = 1;
18861 /* This is nasty. When we reread the DIEs, somewhere up the call chain
18862 THIS_CU->cu may already be in use. So we can't just free it and
18863 replace its DIEs with the ones we read in. Instead, we leave those
18864 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18865 and clobber THIS_CU->cu->partial_dies with the hash table for the new
18867 load_partial_comp_unit (per_cu);
18869 pd = per_cu->cu->find_partial_die (sect_off);
18873 internal_error (__FILE__, __LINE__,
18874 _("could not find partial DIE %s "
18875 "in cache [from module %s]\n"),
18876 sect_offset_str (sect_off), bfd_get_filename (objfile->obfd));
18880 /* See if we can figure out if the class lives in a namespace. We do
18881 this by looking for a member function; its demangled name will
18882 contain namespace info, if there is any. */
18885 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
18886 struct dwarf2_cu *cu)
18888 /* NOTE: carlton/2003-10-07: Getting the info this way changes
18889 what template types look like, because the demangler
18890 frequently doesn't give the same name as the debug info. We
18891 could fix this by only using the demangled name to get the
18892 prefix (but see comment in read_structure_type). */
18894 struct partial_die_info *real_pdi;
18895 struct partial_die_info *child_pdi;
18897 /* If this DIE (this DIE's specification, if any) has a parent, then
18898 we should not do this. We'll prepend the parent's fully qualified
18899 name when we create the partial symbol. */
18901 real_pdi = struct_pdi;
18902 while (real_pdi->has_specification)
18903 real_pdi = find_partial_die (real_pdi->spec_offset,
18904 real_pdi->spec_is_dwz, cu);
18906 if (real_pdi->die_parent != NULL)
18909 for (child_pdi = struct_pdi->die_child;
18911 child_pdi = child_pdi->die_sibling)
18913 if (child_pdi->tag == DW_TAG_subprogram
18914 && child_pdi->linkage_name != NULL)
18916 char *actual_class_name
18917 = language_class_name_from_physname (cu->language_defn,
18918 child_pdi->linkage_name);
18919 if (actual_class_name != NULL)
18921 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18924 obstack_copy0 (&objfile->per_bfd->storage_obstack,
18926 strlen (actual_class_name)));
18927 xfree (actual_class_name);
18935 partial_die_info::fixup (struct dwarf2_cu *cu)
18937 /* Once we've fixed up a die, there's no point in doing so again.
18938 This also avoids a memory leak if we were to call
18939 guess_partial_die_structure_name multiple times. */
18943 /* If we found a reference attribute and the DIE has no name, try
18944 to find a name in the referred to DIE. */
18946 if (name == NULL && has_specification)
18948 struct partial_die_info *spec_die;
18950 spec_die = find_partial_die (spec_offset, spec_is_dwz, cu);
18952 spec_die->fixup (cu);
18954 if (spec_die->name)
18956 name = spec_die->name;
18958 /* Copy DW_AT_external attribute if it is set. */
18959 if (spec_die->is_external)
18960 is_external = spec_die->is_external;
18964 /* Set default names for some unnamed DIEs. */
18966 if (name == NULL && tag == DW_TAG_namespace)
18967 name = CP_ANONYMOUS_NAMESPACE_STR;
18969 /* If there is no parent die to provide a namespace, and there are
18970 children, see if we can determine the namespace from their linkage
18972 if (cu->language == language_cplus
18973 && !VEC_empty (dwarf2_section_info_def,
18974 cu->per_cu->dwarf2_per_objfile->types)
18975 && die_parent == NULL
18977 && (tag == DW_TAG_class_type
18978 || tag == DW_TAG_structure_type
18979 || tag == DW_TAG_union_type))
18980 guess_partial_die_structure_name (this, cu);
18982 /* GCC might emit a nameless struct or union that has a linkage
18983 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18985 && (tag == DW_TAG_class_type
18986 || tag == DW_TAG_interface_type
18987 || tag == DW_TAG_structure_type
18988 || tag == DW_TAG_union_type)
18989 && linkage_name != NULL)
18993 demangled = gdb_demangle (linkage_name, DMGL_TYPES);
18998 /* Strip any leading namespaces/classes, keep only the base name.
18999 DW_AT_name for named DIEs does not contain the prefixes. */
19000 base = strrchr (demangled, ':');
19001 if (base && base > demangled && base[-1] == ':')
19006 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
19009 obstack_copy0 (&objfile->per_bfd->storage_obstack,
19010 base, strlen (base)));
19018 /* Read an attribute value described by an attribute form. */
19020 static const gdb_byte *
19021 read_attribute_value (const struct die_reader_specs *reader,
19022 struct attribute *attr, unsigned form,
19023 LONGEST implicit_const, const gdb_byte *info_ptr)
19025 struct dwarf2_cu *cu = reader->cu;
19026 struct dwarf2_per_objfile *dwarf2_per_objfile
19027 = cu->per_cu->dwarf2_per_objfile;
19028 struct objfile *objfile = dwarf2_per_objfile->objfile;
19029 struct gdbarch *gdbarch = get_objfile_arch (objfile);
19030 bfd *abfd = reader->abfd;
19031 struct comp_unit_head *cu_header = &cu->header;
19032 unsigned int bytes_read;
19033 struct dwarf_block *blk;
19035 attr->form = (enum dwarf_form) form;
19038 case DW_FORM_ref_addr:
19039 if (cu->header.version == 2)
19040 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19042 DW_UNSND (attr) = read_offset (abfd, info_ptr,
19043 &cu->header, &bytes_read);
19044 info_ptr += bytes_read;
19046 case DW_FORM_GNU_ref_alt:
19047 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19048 info_ptr += bytes_read;
19051 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19052 DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
19053 info_ptr += bytes_read;
19055 case DW_FORM_block2:
19056 blk = dwarf_alloc_block (cu);
19057 blk->size = read_2_bytes (abfd, info_ptr);
19059 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19060 info_ptr += blk->size;
19061 DW_BLOCK (attr) = blk;
19063 case DW_FORM_block4:
19064 blk = dwarf_alloc_block (cu);
19065 blk->size = read_4_bytes (abfd, info_ptr);
19067 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19068 info_ptr += blk->size;
19069 DW_BLOCK (attr) = blk;
19071 case DW_FORM_data2:
19072 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
19075 case DW_FORM_data4:
19076 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
19079 case DW_FORM_data8:
19080 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
19083 case DW_FORM_data16:
19084 blk = dwarf_alloc_block (cu);
19086 blk->data = read_n_bytes (abfd, info_ptr, 16);
19088 DW_BLOCK (attr) = blk;
19090 case DW_FORM_sec_offset:
19091 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19092 info_ptr += bytes_read;
19094 case DW_FORM_string:
19095 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
19096 DW_STRING_IS_CANONICAL (attr) = 0;
19097 info_ptr += bytes_read;
19100 if (!cu->per_cu->is_dwz)
19102 DW_STRING (attr) = read_indirect_string (dwarf2_per_objfile,
19103 abfd, info_ptr, cu_header,
19105 DW_STRING_IS_CANONICAL (attr) = 0;
19106 info_ptr += bytes_read;
19110 case DW_FORM_line_strp:
19111 if (!cu->per_cu->is_dwz)
19113 DW_STRING (attr) = read_indirect_line_string (dwarf2_per_objfile,
19115 cu_header, &bytes_read);
19116 DW_STRING_IS_CANONICAL (attr) = 0;
19117 info_ptr += bytes_read;
19121 case DW_FORM_GNU_strp_alt:
19123 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19124 LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
19127 DW_STRING (attr) = read_indirect_string_from_dwz (objfile,
19129 DW_STRING_IS_CANONICAL (attr) = 0;
19130 info_ptr += bytes_read;
19133 case DW_FORM_exprloc:
19134 case DW_FORM_block:
19135 blk = dwarf_alloc_block (cu);
19136 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19137 info_ptr += bytes_read;
19138 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19139 info_ptr += blk->size;
19140 DW_BLOCK (attr) = blk;
19142 case DW_FORM_block1:
19143 blk = dwarf_alloc_block (cu);
19144 blk->size = read_1_byte (abfd, info_ptr);
19146 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19147 info_ptr += blk->size;
19148 DW_BLOCK (attr) = blk;
19150 case DW_FORM_data1:
19151 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19155 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19158 case DW_FORM_flag_present:
19159 DW_UNSND (attr) = 1;
19161 case DW_FORM_sdata:
19162 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19163 info_ptr += bytes_read;
19165 case DW_FORM_udata:
19166 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19167 info_ptr += bytes_read;
19170 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19171 + read_1_byte (abfd, info_ptr));
19175 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19176 + read_2_bytes (abfd, info_ptr));
19180 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19181 + read_4_bytes (abfd, info_ptr));
19185 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19186 + read_8_bytes (abfd, info_ptr));
19189 case DW_FORM_ref_sig8:
19190 DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
19193 case DW_FORM_ref_udata:
19194 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19195 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
19196 info_ptr += bytes_read;
19198 case DW_FORM_indirect:
19199 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19200 info_ptr += bytes_read;
19201 if (form == DW_FORM_implicit_const)
19203 implicit_const = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19204 info_ptr += bytes_read;
19206 info_ptr = read_attribute_value (reader, attr, form, implicit_const,
19209 case DW_FORM_implicit_const:
19210 DW_SND (attr) = implicit_const;
19212 case DW_FORM_GNU_addr_index:
19213 if (reader->dwo_file == NULL)
19215 /* For now flag a hard error.
19216 Later we can turn this into a complaint. */
19217 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19218 dwarf_form_name (form),
19219 bfd_get_filename (abfd));
19221 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
19222 info_ptr += bytes_read;
19224 case DW_FORM_GNU_str_index:
19225 if (reader->dwo_file == NULL)
19227 /* For now flag a hard error.
19228 Later we can turn this into a complaint if warranted. */
19229 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19230 dwarf_form_name (form),
19231 bfd_get_filename (abfd));
19234 ULONGEST str_index =
19235 read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19237 DW_STRING (attr) = read_str_index (reader, str_index);
19238 DW_STRING_IS_CANONICAL (attr) = 0;
19239 info_ptr += bytes_read;
19243 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19244 dwarf_form_name (form),
19245 bfd_get_filename (abfd));
19249 if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
19250 attr->form = DW_FORM_GNU_ref_alt;
19252 /* We have seen instances where the compiler tried to emit a byte
19253 size attribute of -1 which ended up being encoded as an unsigned
19254 0xffffffff. Although 0xffffffff is technically a valid size value,
19255 an object of this size seems pretty unlikely so we can relatively
19256 safely treat these cases as if the size attribute was invalid and
19257 treat them as zero by default. */
19258 if (attr->name == DW_AT_byte_size
19259 && form == DW_FORM_data4
19260 && DW_UNSND (attr) >= 0xffffffff)
19263 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19264 hex_string (DW_UNSND (attr)));
19265 DW_UNSND (attr) = 0;
19271 /* Read an attribute described by an abbreviated attribute. */
19273 static const gdb_byte *
19274 read_attribute (const struct die_reader_specs *reader,
19275 struct attribute *attr, struct attr_abbrev *abbrev,
19276 const gdb_byte *info_ptr)
19278 attr->name = abbrev->name;
19279 return read_attribute_value (reader, attr, abbrev->form,
19280 abbrev->implicit_const, info_ptr);
19283 /* Read dwarf information from a buffer. */
19285 static unsigned int
19286 read_1_byte (bfd *abfd, const gdb_byte *buf)
19288 return bfd_get_8 (abfd, buf);
19292 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
19294 return bfd_get_signed_8 (abfd, buf);
19297 static unsigned int
19298 read_2_bytes (bfd *abfd, const gdb_byte *buf)
19300 return bfd_get_16 (abfd, buf);
19304 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
19306 return bfd_get_signed_16 (abfd, buf);
19309 static unsigned int
19310 read_4_bytes (bfd *abfd, const gdb_byte *buf)
19312 return bfd_get_32 (abfd, buf);
19316 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
19318 return bfd_get_signed_32 (abfd, buf);
19322 read_8_bytes (bfd *abfd, const gdb_byte *buf)
19324 return bfd_get_64 (abfd, buf);
19328 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
19329 unsigned int *bytes_read)
19331 struct comp_unit_head *cu_header = &cu->header;
19332 CORE_ADDR retval = 0;
19334 if (cu_header->signed_addr_p)
19336 switch (cu_header->addr_size)
19339 retval = bfd_get_signed_16 (abfd, buf);
19342 retval = bfd_get_signed_32 (abfd, buf);
19345 retval = bfd_get_signed_64 (abfd, buf);
19348 internal_error (__FILE__, __LINE__,
19349 _("read_address: bad switch, signed [in module %s]"),
19350 bfd_get_filename (abfd));
19355 switch (cu_header->addr_size)
19358 retval = bfd_get_16 (abfd, buf);
19361 retval = bfd_get_32 (abfd, buf);
19364 retval = bfd_get_64 (abfd, buf);
19367 internal_error (__FILE__, __LINE__,
19368 _("read_address: bad switch, "
19369 "unsigned [in module %s]"),
19370 bfd_get_filename (abfd));
19374 *bytes_read = cu_header->addr_size;
19378 /* Read the initial length from a section. The (draft) DWARF 3
19379 specification allows the initial length to take up either 4 bytes
19380 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19381 bytes describe the length and all offsets will be 8 bytes in length
19384 An older, non-standard 64-bit format is also handled by this
19385 function. The older format in question stores the initial length
19386 as an 8-byte quantity without an escape value. Lengths greater
19387 than 2^32 aren't very common which means that the initial 4 bytes
19388 is almost always zero. Since a length value of zero doesn't make
19389 sense for the 32-bit format, this initial zero can be considered to
19390 be an escape value which indicates the presence of the older 64-bit
19391 format. As written, the code can't detect (old format) lengths
19392 greater than 4GB. If it becomes necessary to handle lengths
19393 somewhat larger than 4GB, we could allow other small values (such
19394 as the non-sensical values of 1, 2, and 3) to also be used as
19395 escape values indicating the presence of the old format.
19397 The value returned via bytes_read should be used to increment the
19398 relevant pointer after calling read_initial_length().
19400 [ Note: read_initial_length() and read_offset() are based on the
19401 document entitled "DWARF Debugging Information Format", revision
19402 3, draft 8, dated November 19, 2001. This document was obtained
19405 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19407 This document is only a draft and is subject to change. (So beware.)
19409 Details regarding the older, non-standard 64-bit format were
19410 determined empirically by examining 64-bit ELF files produced by
19411 the SGI toolchain on an IRIX 6.5 machine.
19413 - Kevin, July 16, 2002
19417 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
19419 LONGEST length = bfd_get_32 (abfd, buf);
19421 if (length == 0xffffffff)
19423 length = bfd_get_64 (abfd, buf + 4);
19426 else if (length == 0)
19428 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19429 length = bfd_get_64 (abfd, buf);
19440 /* Cover function for read_initial_length.
19441 Returns the length of the object at BUF, and stores the size of the
19442 initial length in *BYTES_READ and stores the size that offsets will be in
19444 If the initial length size is not equivalent to that specified in
19445 CU_HEADER then issue a complaint.
19446 This is useful when reading non-comp-unit headers. */
19449 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
19450 const struct comp_unit_head *cu_header,
19451 unsigned int *bytes_read,
19452 unsigned int *offset_size)
19454 LONGEST length = read_initial_length (abfd, buf, bytes_read);
19456 gdb_assert (cu_header->initial_length_size == 4
19457 || cu_header->initial_length_size == 8
19458 || cu_header->initial_length_size == 12);
19460 if (cu_header->initial_length_size != *bytes_read)
19461 complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19463 *offset_size = (*bytes_read == 4) ? 4 : 8;
19467 /* Read an offset from the data stream. The size of the offset is
19468 given by cu_header->offset_size. */
19471 read_offset (bfd *abfd, const gdb_byte *buf,
19472 const struct comp_unit_head *cu_header,
19473 unsigned int *bytes_read)
19475 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
19477 *bytes_read = cu_header->offset_size;
19481 /* Read an offset from the data stream. */
19484 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
19486 LONGEST retval = 0;
19488 switch (offset_size)
19491 retval = bfd_get_32 (abfd, buf);
19494 retval = bfd_get_64 (abfd, buf);
19497 internal_error (__FILE__, __LINE__,
19498 _("read_offset_1: bad switch [in module %s]"),
19499 bfd_get_filename (abfd));
19505 static const gdb_byte *
19506 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
19508 /* If the size of a host char is 8 bits, we can return a pointer
19509 to the buffer, otherwise we have to copy the data to a buffer
19510 allocated on the temporary obstack. */
19511 gdb_assert (HOST_CHAR_BIT == 8);
19515 static const char *
19516 read_direct_string (bfd *abfd, const gdb_byte *buf,
19517 unsigned int *bytes_read_ptr)
19519 /* If the size of a host char is 8 bits, we can return a pointer
19520 to the string, otherwise we have to copy the string to a buffer
19521 allocated on the temporary obstack. */
19522 gdb_assert (HOST_CHAR_BIT == 8);
19525 *bytes_read_ptr = 1;
19528 *bytes_read_ptr = strlen ((const char *) buf) + 1;
19529 return (const char *) buf;
19532 /* Return pointer to string at section SECT offset STR_OFFSET with error
19533 reporting strings FORM_NAME and SECT_NAME. */
19535 static const char *
19536 read_indirect_string_at_offset_from (struct objfile *objfile,
19537 bfd *abfd, LONGEST str_offset,
19538 struct dwarf2_section_info *sect,
19539 const char *form_name,
19540 const char *sect_name)
19542 dwarf2_read_section (objfile, sect);
19543 if (sect->buffer == NULL)
19544 error (_("%s used without %s section [in module %s]"),
19545 form_name, sect_name, bfd_get_filename (abfd));
19546 if (str_offset >= sect->size)
19547 error (_("%s pointing outside of %s section [in module %s]"),
19548 form_name, sect_name, bfd_get_filename (abfd));
19549 gdb_assert (HOST_CHAR_BIT == 8);
19550 if (sect->buffer[str_offset] == '\0')
19552 return (const char *) (sect->buffer + str_offset);
19555 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19557 static const char *
19558 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19559 bfd *abfd, LONGEST str_offset)
19561 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19563 &dwarf2_per_objfile->str,
19564 "DW_FORM_strp", ".debug_str");
19567 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
19569 static const char *
19570 read_indirect_line_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19571 bfd *abfd, LONGEST str_offset)
19573 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19575 &dwarf2_per_objfile->line_str,
19576 "DW_FORM_line_strp",
19577 ".debug_line_str");
19580 /* Read a string at offset STR_OFFSET in the .debug_str section from
19581 the .dwz file DWZ. Throw an error if the offset is too large. If
19582 the string consists of a single NUL byte, return NULL; otherwise
19583 return a pointer to the string. */
19585 static const char *
19586 read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz,
19587 LONGEST str_offset)
19589 dwarf2_read_section (objfile, &dwz->str);
19591 if (dwz->str.buffer == NULL)
19592 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19593 "section [in module %s]"),
19594 bfd_get_filename (dwz->dwz_bfd));
19595 if (str_offset >= dwz->str.size)
19596 error (_("DW_FORM_GNU_strp_alt pointing outside of "
19597 ".debug_str section [in module %s]"),
19598 bfd_get_filename (dwz->dwz_bfd));
19599 gdb_assert (HOST_CHAR_BIT == 8);
19600 if (dwz->str.buffer[str_offset] == '\0')
19602 return (const char *) (dwz->str.buffer + str_offset);
19605 /* Return pointer to string at .debug_str offset as read from BUF.
19606 BUF is assumed to be in a compilation unit described by CU_HEADER.
19607 Return *BYTES_READ_PTR count of bytes read from BUF. */
19609 static const char *
19610 read_indirect_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
19611 const gdb_byte *buf,
19612 const struct comp_unit_head *cu_header,
19613 unsigned int *bytes_read_ptr)
19615 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19617 return read_indirect_string_at_offset (dwarf2_per_objfile, abfd, str_offset);
19620 /* Return pointer to string at .debug_line_str offset as read from BUF.
19621 BUF is assumed to be in a compilation unit described by CU_HEADER.
19622 Return *BYTES_READ_PTR count of bytes read from BUF. */
19624 static const char *
19625 read_indirect_line_string (struct dwarf2_per_objfile *dwarf2_per_objfile,
19626 bfd *abfd, const gdb_byte *buf,
19627 const struct comp_unit_head *cu_header,
19628 unsigned int *bytes_read_ptr)
19630 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19632 return read_indirect_line_string_at_offset (dwarf2_per_objfile, abfd,
19637 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
19638 unsigned int *bytes_read_ptr)
19641 unsigned int num_read;
19643 unsigned char byte;
19650 byte = bfd_get_8 (abfd, buf);
19653 result |= ((ULONGEST) (byte & 127) << shift);
19654 if ((byte & 128) == 0)
19660 *bytes_read_ptr = num_read;
19665 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
19666 unsigned int *bytes_read_ptr)
19669 int shift, num_read;
19670 unsigned char byte;
19677 byte = bfd_get_8 (abfd, buf);
19680 result |= ((ULONGEST) (byte & 127) << shift);
19682 if ((byte & 128) == 0)
19687 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
19688 result |= -(((ULONGEST) 1) << shift);
19689 *bytes_read_ptr = num_read;
19693 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19694 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19695 ADDR_SIZE is the size of addresses from the CU header. */
19698 read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
19699 unsigned int addr_index, ULONGEST addr_base, int addr_size)
19701 struct objfile *objfile = dwarf2_per_objfile->objfile;
19702 bfd *abfd = objfile->obfd;
19703 const gdb_byte *info_ptr;
19705 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
19706 if (dwarf2_per_objfile->addr.buffer == NULL)
19707 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19708 objfile_name (objfile));
19709 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
19710 error (_("DW_FORM_addr_index pointing outside of "
19711 ".debug_addr section [in module %s]"),
19712 objfile_name (objfile));
19713 info_ptr = (dwarf2_per_objfile->addr.buffer
19714 + addr_base + addr_index * addr_size);
19715 if (addr_size == 4)
19716 return bfd_get_32 (abfd, info_ptr);
19718 return bfd_get_64 (abfd, info_ptr);
19721 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
19724 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
19726 return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
19727 cu->addr_base, cu->header.addr_size);
19730 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
19733 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
19734 unsigned int *bytes_read)
19736 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
19737 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
19739 return read_addr_index (cu, addr_index);
19742 /* Data structure to pass results from dwarf2_read_addr_index_reader
19743 back to dwarf2_read_addr_index. */
19745 struct dwarf2_read_addr_index_data
19747 ULONGEST addr_base;
19751 /* die_reader_func for dwarf2_read_addr_index. */
19754 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
19755 const gdb_byte *info_ptr,
19756 struct die_info *comp_unit_die,
19760 struct dwarf2_cu *cu = reader->cu;
19761 struct dwarf2_read_addr_index_data *aidata =
19762 (struct dwarf2_read_addr_index_data *) data;
19764 aidata->addr_base = cu->addr_base;
19765 aidata->addr_size = cu->header.addr_size;
19768 /* Given an index in .debug_addr, fetch the value.
19769 NOTE: This can be called during dwarf expression evaluation,
19770 long after the debug information has been read, and thus per_cu->cu
19771 may no longer exist. */
19774 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
19775 unsigned int addr_index)
19777 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
19778 struct dwarf2_cu *cu = per_cu->cu;
19779 ULONGEST addr_base;
19782 /* We need addr_base and addr_size.
19783 If we don't have PER_CU->cu, we have to get it.
19784 Nasty, but the alternative is storing the needed info in PER_CU,
19785 which at this point doesn't seem justified: it's not clear how frequently
19786 it would get used and it would increase the size of every PER_CU.
19787 Entry points like dwarf2_per_cu_addr_size do a similar thing
19788 so we're not in uncharted territory here.
19789 Alas we need to be a bit more complicated as addr_base is contained
19792 We don't need to read the entire CU(/TU).
19793 We just need the header and top level die.
19795 IWBN to use the aging mechanism to let us lazily later discard the CU.
19796 For now we skip this optimization. */
19800 addr_base = cu->addr_base;
19801 addr_size = cu->header.addr_size;
19805 struct dwarf2_read_addr_index_data aidata;
19807 /* Note: We can't use init_cutu_and_read_dies_simple here,
19808 we need addr_base. */
19809 init_cutu_and_read_dies (per_cu, NULL, 0, 0, false,
19810 dwarf2_read_addr_index_reader, &aidata);
19811 addr_base = aidata.addr_base;
19812 addr_size = aidata.addr_size;
19815 return read_addr_index_1 (dwarf2_per_objfile, addr_index, addr_base,
19819 /* Given a DW_FORM_GNU_str_index, fetch the string.
19820 This is only used by the Fission support. */
19822 static const char *
19823 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
19825 struct dwarf2_cu *cu = reader->cu;
19826 struct dwarf2_per_objfile *dwarf2_per_objfile
19827 = cu->per_cu->dwarf2_per_objfile;
19828 struct objfile *objfile = dwarf2_per_objfile->objfile;
19829 const char *objf_name = objfile_name (objfile);
19830 bfd *abfd = objfile->obfd;
19831 struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
19832 struct dwarf2_section_info *str_offsets_section =
19833 &reader->dwo_file->sections.str_offsets;
19834 const gdb_byte *info_ptr;
19835 ULONGEST str_offset;
19836 static const char form_name[] = "DW_FORM_GNU_str_index";
19838 dwarf2_read_section (objfile, str_section);
19839 dwarf2_read_section (objfile, str_offsets_section);
19840 if (str_section->buffer == NULL)
19841 error (_("%s used without .debug_str.dwo section"
19842 " in CU at offset %s [in module %s]"),
19843 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19844 if (str_offsets_section->buffer == NULL)
19845 error (_("%s used without .debug_str_offsets.dwo section"
19846 " in CU at offset %s [in module %s]"),
19847 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19848 if (str_index * cu->header.offset_size >= str_offsets_section->size)
19849 error (_("%s pointing outside of .debug_str_offsets.dwo"
19850 " section in CU at offset %s [in module %s]"),
19851 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19852 info_ptr = (str_offsets_section->buffer
19853 + str_index * cu->header.offset_size);
19854 if (cu->header.offset_size == 4)
19855 str_offset = bfd_get_32 (abfd, info_ptr);
19857 str_offset = bfd_get_64 (abfd, info_ptr);
19858 if (str_offset >= str_section->size)
19859 error (_("Offset from %s pointing outside of"
19860 " .debug_str.dwo section in CU at offset %s [in module %s]"),
19861 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19862 return (const char *) (str_section->buffer + str_offset);
19865 /* Return the length of an LEB128 number in BUF. */
19868 leb128_size (const gdb_byte *buf)
19870 const gdb_byte *begin = buf;
19876 if ((byte & 128) == 0)
19877 return buf - begin;
19882 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
19891 cu->language = language_c;
19894 case DW_LANG_C_plus_plus:
19895 case DW_LANG_C_plus_plus_11:
19896 case DW_LANG_C_plus_plus_14:
19897 cu->language = language_cplus;
19900 cu->language = language_d;
19902 case DW_LANG_Fortran77:
19903 case DW_LANG_Fortran90:
19904 case DW_LANG_Fortran95:
19905 case DW_LANG_Fortran03:
19906 case DW_LANG_Fortran08:
19907 cu->language = language_fortran;
19910 cu->language = language_go;
19912 case DW_LANG_Mips_Assembler:
19913 cu->language = language_asm;
19915 case DW_LANG_Ada83:
19916 case DW_LANG_Ada95:
19917 cu->language = language_ada;
19919 case DW_LANG_Modula2:
19920 cu->language = language_m2;
19922 case DW_LANG_Pascal83:
19923 cu->language = language_pascal;
19926 cu->language = language_objc;
19929 case DW_LANG_Rust_old:
19930 cu->language = language_rust;
19932 case DW_LANG_Cobol74:
19933 case DW_LANG_Cobol85:
19935 cu->language = language_minimal;
19938 cu->language_defn = language_def (cu->language);
19941 /* Return the named attribute or NULL if not there. */
19943 static struct attribute *
19944 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
19949 struct attribute *spec = NULL;
19951 for (i = 0; i < die->num_attrs; ++i)
19953 if (die->attrs[i].name == name)
19954 return &die->attrs[i];
19955 if (die->attrs[i].name == DW_AT_specification
19956 || die->attrs[i].name == DW_AT_abstract_origin)
19957 spec = &die->attrs[i];
19963 die = follow_die_ref (die, spec, &cu);
19969 /* Return the named attribute or NULL if not there,
19970 but do not follow DW_AT_specification, etc.
19971 This is for use in contexts where we're reading .debug_types dies.
19972 Following DW_AT_specification, DW_AT_abstract_origin will take us
19973 back up the chain, and we want to go down. */
19975 static struct attribute *
19976 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
19980 for (i = 0; i < die->num_attrs; ++i)
19981 if (die->attrs[i].name == name)
19982 return &die->attrs[i];
19987 /* Return the string associated with a string-typed attribute, or NULL if it
19988 is either not found or is of an incorrect type. */
19990 static const char *
19991 dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
19993 struct attribute *attr;
19994 const char *str = NULL;
19996 attr = dwarf2_attr (die, name, cu);
20000 if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp
20001 || attr->form == DW_FORM_string
20002 || attr->form == DW_FORM_GNU_str_index
20003 || attr->form == DW_FORM_GNU_strp_alt)
20004 str = DW_STRING (attr);
20006 complaint (_("string type expected for attribute %s for "
20007 "DIE at %s in module %s"),
20008 dwarf_attr_name (name), sect_offset_str (die->sect_off),
20009 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
20015 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20016 and holds a non-zero value. This function should only be used for
20017 DW_FORM_flag or DW_FORM_flag_present attributes. */
20020 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
20022 struct attribute *attr = dwarf2_attr (die, name, cu);
20024 return (attr && DW_UNSND (attr));
20028 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
20030 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20031 which value is non-zero. However, we have to be careful with
20032 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20033 (via dwarf2_flag_true_p) follows this attribute. So we may
20034 end up accidently finding a declaration attribute that belongs
20035 to a different DIE referenced by the specification attribute,
20036 even though the given DIE does not have a declaration attribute. */
20037 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
20038 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
20041 /* Return the die giving the specification for DIE, if there is
20042 one. *SPEC_CU is the CU containing DIE on input, and the CU
20043 containing the return value on output. If there is no
20044 specification, but there is an abstract origin, that is
20047 static struct die_info *
20048 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
20050 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
20053 if (spec_attr == NULL)
20054 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
20056 if (spec_attr == NULL)
20059 return follow_die_ref (die, spec_attr, spec_cu);
20062 /* Stub for free_line_header to match void * callback types. */
20065 free_line_header_voidp (void *arg)
20067 struct line_header *lh = (struct line_header *) arg;
20073 line_header::add_include_dir (const char *include_dir)
20075 if (dwarf_line_debug >= 2)
20076 fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
20077 include_dirs.size () + 1, include_dir);
20079 include_dirs.push_back (include_dir);
20083 line_header::add_file_name (const char *name,
20085 unsigned int mod_time,
20086 unsigned int length)
20088 if (dwarf_line_debug >= 2)
20089 fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
20090 (unsigned) file_names.size () + 1, name);
20092 file_names.emplace_back (name, d_index, mod_time, length);
20095 /* A convenience function to find the proper .debug_line section for a CU. */
20097 static struct dwarf2_section_info *
20098 get_debug_line_section (struct dwarf2_cu *cu)
20100 struct dwarf2_section_info *section;
20101 struct dwarf2_per_objfile *dwarf2_per_objfile
20102 = cu->per_cu->dwarf2_per_objfile;
20104 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20106 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20107 section = &cu->dwo_unit->dwo_file->sections.line;
20108 else if (cu->per_cu->is_dwz)
20110 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
20112 section = &dwz->line;
20115 section = &dwarf2_per_objfile->line;
20120 /* Read directory or file name entry format, starting with byte of
20121 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20122 entries count and the entries themselves in the described entry
20126 read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
20127 bfd *abfd, const gdb_byte **bufp,
20128 struct line_header *lh,
20129 const struct comp_unit_head *cu_header,
20130 void (*callback) (struct line_header *lh,
20133 unsigned int mod_time,
20134 unsigned int length))
20136 gdb_byte format_count, formati;
20137 ULONGEST data_count, datai;
20138 const gdb_byte *buf = *bufp;
20139 const gdb_byte *format_header_data;
20140 unsigned int bytes_read;
20142 format_count = read_1_byte (abfd, buf);
20144 format_header_data = buf;
20145 for (formati = 0; formati < format_count; formati++)
20147 read_unsigned_leb128 (abfd, buf, &bytes_read);
20149 read_unsigned_leb128 (abfd, buf, &bytes_read);
20153 data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
20155 for (datai = 0; datai < data_count; datai++)
20157 const gdb_byte *format = format_header_data;
20158 struct file_entry fe;
20160 for (formati = 0; formati < format_count; formati++)
20162 ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
20163 format += bytes_read;
20165 ULONGEST form = read_unsigned_leb128 (abfd, format, &bytes_read);
20166 format += bytes_read;
20168 gdb::optional<const char *> string;
20169 gdb::optional<unsigned int> uint;
20173 case DW_FORM_string:
20174 string.emplace (read_direct_string (abfd, buf, &bytes_read));
20178 case DW_FORM_line_strp:
20179 string.emplace (read_indirect_line_string (dwarf2_per_objfile,
20186 case DW_FORM_data1:
20187 uint.emplace (read_1_byte (abfd, buf));
20191 case DW_FORM_data2:
20192 uint.emplace (read_2_bytes (abfd, buf));
20196 case DW_FORM_data4:
20197 uint.emplace (read_4_bytes (abfd, buf));
20201 case DW_FORM_data8:
20202 uint.emplace (read_8_bytes (abfd, buf));
20206 case DW_FORM_udata:
20207 uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
20211 case DW_FORM_block:
20212 /* It is valid only for DW_LNCT_timestamp which is ignored by
20217 switch (content_type)
20220 if (string.has_value ())
20223 case DW_LNCT_directory_index:
20224 if (uint.has_value ())
20225 fe.d_index = (dir_index) *uint;
20227 case DW_LNCT_timestamp:
20228 if (uint.has_value ())
20229 fe.mod_time = *uint;
20232 if (uint.has_value ())
20238 complaint (_("Unknown format content type %s"),
20239 pulongest (content_type));
20243 callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
20249 /* Read the statement program header starting at OFFSET in
20250 .debug_line, or .debug_line.dwo. Return a pointer
20251 to a struct line_header, allocated using xmalloc.
20252 Returns NULL if there is a problem reading the header, e.g., if it
20253 has a version we don't understand.
20255 NOTE: the strings in the include directory and file name tables of
20256 the returned object point into the dwarf line section buffer,
20257 and must not be freed. */
20259 static line_header_up
20260 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
20262 const gdb_byte *line_ptr;
20263 unsigned int bytes_read, offset_size;
20265 const char *cur_dir, *cur_file;
20266 struct dwarf2_section_info *section;
20268 struct dwarf2_per_objfile *dwarf2_per_objfile
20269 = cu->per_cu->dwarf2_per_objfile;
20271 section = get_debug_line_section (cu);
20272 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20273 if (section->buffer == NULL)
20275 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20276 complaint (_("missing .debug_line.dwo section"));
20278 complaint (_("missing .debug_line section"));
20282 /* We can't do this until we know the section is non-empty.
20283 Only then do we know we have such a section. */
20284 abfd = get_section_bfd_owner (section);
20286 /* Make sure that at least there's room for the total_length field.
20287 That could be 12 bytes long, but we're just going to fudge that. */
20288 if (to_underlying (sect_off) + 4 >= section->size)
20290 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20294 line_header_up lh (new line_header ());
20296 lh->sect_off = sect_off;
20297 lh->offset_in_dwz = cu->per_cu->is_dwz;
20299 line_ptr = section->buffer + to_underlying (sect_off);
20301 /* Read in the header. */
20303 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
20304 &bytes_read, &offset_size);
20305 line_ptr += bytes_read;
20306 if (line_ptr + lh->total_length > (section->buffer + section->size))
20308 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20311 lh->statement_program_end = line_ptr + lh->total_length;
20312 lh->version = read_2_bytes (abfd, line_ptr);
20314 if (lh->version > 5)
20316 /* This is a version we don't understand. The format could have
20317 changed in ways we don't handle properly so just punt. */
20318 complaint (_("unsupported version in .debug_line section"));
20321 if (lh->version >= 5)
20323 gdb_byte segment_selector_size;
20325 /* Skip address size. */
20326 read_1_byte (abfd, line_ptr);
20329 segment_selector_size = read_1_byte (abfd, line_ptr);
20331 if (segment_selector_size != 0)
20333 complaint (_("unsupported segment selector size %u "
20334 "in .debug_line section"),
20335 segment_selector_size);
20339 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
20340 line_ptr += offset_size;
20341 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
20343 if (lh->version >= 4)
20345 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
20349 lh->maximum_ops_per_instruction = 1;
20351 if (lh->maximum_ops_per_instruction == 0)
20353 lh->maximum_ops_per_instruction = 1;
20354 complaint (_("invalid maximum_ops_per_instruction "
20355 "in `.debug_line' section"));
20358 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
20360 lh->line_base = read_1_signed_byte (abfd, line_ptr);
20362 lh->line_range = read_1_byte (abfd, line_ptr);
20364 lh->opcode_base = read_1_byte (abfd, line_ptr);
20366 lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
20368 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
20369 for (i = 1; i < lh->opcode_base; ++i)
20371 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
20375 if (lh->version >= 5)
20377 /* Read directory table. */
20378 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20380 [] (struct line_header *header, const char *name,
20381 dir_index d_index, unsigned int mod_time,
20382 unsigned int length)
20384 header->add_include_dir (name);
20387 /* Read file name table. */
20388 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20390 [] (struct line_header *header, const char *name,
20391 dir_index d_index, unsigned int mod_time,
20392 unsigned int length)
20394 header->add_file_name (name, d_index, mod_time, length);
20399 /* Read directory table. */
20400 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20402 line_ptr += bytes_read;
20403 lh->add_include_dir (cur_dir);
20405 line_ptr += bytes_read;
20407 /* Read file name table. */
20408 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20410 unsigned int mod_time, length;
20413 line_ptr += bytes_read;
20414 d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20415 line_ptr += bytes_read;
20416 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20417 line_ptr += bytes_read;
20418 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20419 line_ptr += bytes_read;
20421 lh->add_file_name (cur_file, d_index, mod_time, length);
20423 line_ptr += bytes_read;
20425 lh->statement_program_start = line_ptr;
20427 if (line_ptr > (section->buffer + section->size))
20428 complaint (_("line number info header doesn't "
20429 "fit in `.debug_line' section"));
20434 /* Subroutine of dwarf_decode_lines to simplify it.
20435 Return the file name of the psymtab for included file FILE_INDEX
20436 in line header LH of PST.
20437 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20438 If space for the result is malloc'd, *NAME_HOLDER will be set.
20439 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20441 static const char *
20442 psymtab_include_file_name (const struct line_header *lh, int file_index,
20443 const struct partial_symtab *pst,
20444 const char *comp_dir,
20445 gdb::unique_xmalloc_ptr<char> *name_holder)
20447 const file_entry &fe = lh->file_names[file_index];
20448 const char *include_name = fe.name;
20449 const char *include_name_to_compare = include_name;
20450 const char *pst_filename;
20453 const char *dir_name = fe.include_dir (lh);
20455 gdb::unique_xmalloc_ptr<char> hold_compare;
20456 if (!IS_ABSOLUTE_PATH (include_name)
20457 && (dir_name != NULL || comp_dir != NULL))
20459 /* Avoid creating a duplicate psymtab for PST.
20460 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20461 Before we do the comparison, however, we need to account
20462 for DIR_NAME and COMP_DIR.
20463 First prepend dir_name (if non-NULL). If we still don't
20464 have an absolute path prepend comp_dir (if non-NULL).
20465 However, the directory we record in the include-file's
20466 psymtab does not contain COMP_DIR (to match the
20467 corresponding symtab(s)).
20472 bash$ gcc -g ./hello.c
20473 include_name = "hello.c"
20475 DW_AT_comp_dir = comp_dir = "/tmp"
20476 DW_AT_name = "./hello.c"
20480 if (dir_name != NULL)
20482 name_holder->reset (concat (dir_name, SLASH_STRING,
20483 include_name, (char *) NULL));
20484 include_name = name_holder->get ();
20485 include_name_to_compare = include_name;
20487 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
20489 hold_compare.reset (concat (comp_dir, SLASH_STRING,
20490 include_name, (char *) NULL));
20491 include_name_to_compare = hold_compare.get ();
20495 pst_filename = pst->filename;
20496 gdb::unique_xmalloc_ptr<char> copied_name;
20497 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
20499 copied_name.reset (concat (pst->dirname, SLASH_STRING,
20500 pst_filename, (char *) NULL));
20501 pst_filename = copied_name.get ();
20504 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
20508 return include_name;
20511 /* State machine to track the state of the line number program. */
20513 class lnp_state_machine
20516 /* Initialize a machine state for the start of a line number
20518 lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch, line_header *lh,
20519 bool record_lines_p);
20521 file_entry *current_file ()
20523 /* lh->file_names is 0-based, but the file name numbers in the
20524 statement program are 1-based. */
20525 return m_line_header->file_name_at (m_file);
20528 /* Record the line in the state machine. END_SEQUENCE is true if
20529 we're processing the end of a sequence. */
20530 void record_line (bool end_sequence);
20532 /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20533 nop-out rest of the lines in this sequence. */
20534 void check_line_address (struct dwarf2_cu *cu,
20535 const gdb_byte *line_ptr,
20536 CORE_ADDR unrelocated_lowpc, CORE_ADDR address);
20538 void handle_set_discriminator (unsigned int discriminator)
20540 m_discriminator = discriminator;
20541 m_line_has_non_zero_discriminator |= discriminator != 0;
20544 /* Handle DW_LNE_set_address. */
20545 void handle_set_address (CORE_ADDR baseaddr, CORE_ADDR address)
20548 address += baseaddr;
20549 m_address = gdbarch_adjust_dwarf2_line (m_gdbarch, address, false);
20552 /* Handle DW_LNS_advance_pc. */
20553 void handle_advance_pc (CORE_ADDR adjust);
20555 /* Handle a special opcode. */
20556 void handle_special_opcode (unsigned char op_code);
20558 /* Handle DW_LNS_advance_line. */
20559 void handle_advance_line (int line_delta)
20561 advance_line (line_delta);
20564 /* Handle DW_LNS_set_file. */
20565 void handle_set_file (file_name_index file);
20567 /* Handle DW_LNS_negate_stmt. */
20568 void handle_negate_stmt ()
20570 m_is_stmt = !m_is_stmt;
20573 /* Handle DW_LNS_const_add_pc. */
20574 void handle_const_add_pc ();
20576 /* Handle DW_LNS_fixed_advance_pc. */
20577 void handle_fixed_advance_pc (CORE_ADDR addr_adj)
20579 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20583 /* Handle DW_LNS_copy. */
20584 void handle_copy ()
20586 record_line (false);
20587 m_discriminator = 0;
20590 /* Handle DW_LNE_end_sequence. */
20591 void handle_end_sequence ()
20593 m_currently_recording_lines = true;
20597 /* Advance the line by LINE_DELTA. */
20598 void advance_line (int line_delta)
20600 m_line += line_delta;
20602 if (line_delta != 0)
20603 m_line_has_non_zero_discriminator = m_discriminator != 0;
20606 struct dwarf2_cu *m_cu;
20608 gdbarch *m_gdbarch;
20610 /* True if we're recording lines.
20611 Otherwise we're building partial symtabs and are just interested in
20612 finding include files mentioned by the line number program. */
20613 bool m_record_lines_p;
20615 /* The line number header. */
20616 line_header *m_line_header;
20618 /* These are part of the standard DWARF line number state machine,
20619 and initialized according to the DWARF spec. */
20621 unsigned char m_op_index = 0;
20622 /* The line table index (1-based) of the current file. */
20623 file_name_index m_file = (file_name_index) 1;
20624 unsigned int m_line = 1;
20626 /* These are initialized in the constructor. */
20628 CORE_ADDR m_address;
20630 unsigned int m_discriminator;
20632 /* Additional bits of state we need to track. */
20634 /* The last file that we called dwarf2_start_subfile for.
20635 This is only used for TLLs. */
20636 unsigned int m_last_file = 0;
20637 /* The last file a line number was recorded for. */
20638 struct subfile *m_last_subfile = NULL;
20640 /* When true, record the lines we decode. */
20641 bool m_currently_recording_lines = false;
20643 /* The last line number that was recorded, used to coalesce
20644 consecutive entries for the same line. This can happen, for
20645 example, when discriminators are present. PR 17276. */
20646 unsigned int m_last_line = 0;
20647 bool m_line_has_non_zero_discriminator = false;
20651 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust)
20653 CORE_ADDR addr_adj = (((m_op_index + adjust)
20654 / m_line_header->maximum_ops_per_instruction)
20655 * m_line_header->minimum_instruction_length);
20656 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20657 m_op_index = ((m_op_index + adjust)
20658 % m_line_header->maximum_ops_per_instruction);
20662 lnp_state_machine::handle_special_opcode (unsigned char op_code)
20664 unsigned char adj_opcode = op_code - m_line_header->opcode_base;
20665 CORE_ADDR addr_adj = (((m_op_index
20666 + (adj_opcode / m_line_header->line_range))
20667 / m_line_header->maximum_ops_per_instruction)
20668 * m_line_header->minimum_instruction_length);
20669 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20670 m_op_index = ((m_op_index + (adj_opcode / m_line_header->line_range))
20671 % m_line_header->maximum_ops_per_instruction);
20673 int line_delta = (m_line_header->line_base
20674 + (adj_opcode % m_line_header->line_range));
20675 advance_line (line_delta);
20676 record_line (false);
20677 m_discriminator = 0;
20681 lnp_state_machine::handle_set_file (file_name_index file)
20685 const file_entry *fe = current_file ();
20687 dwarf2_debug_line_missing_file_complaint ();
20688 else if (m_record_lines_p)
20690 const char *dir = fe->include_dir (m_line_header);
20692 m_last_subfile = m_cu->builder->get_current_subfile ();
20693 m_line_has_non_zero_discriminator = m_discriminator != 0;
20694 dwarf2_start_subfile (m_cu, fe->name, dir);
20699 lnp_state_machine::handle_const_add_pc ()
20702 = (255 - m_line_header->opcode_base) / m_line_header->line_range;
20705 = (((m_op_index + adjust)
20706 / m_line_header->maximum_ops_per_instruction)
20707 * m_line_header->minimum_instruction_length);
20709 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20710 m_op_index = ((m_op_index + adjust)
20711 % m_line_header->maximum_ops_per_instruction);
20714 /* Return non-zero if we should add LINE to the line number table.
20715 LINE is the line to add, LAST_LINE is the last line that was added,
20716 LAST_SUBFILE is the subfile for LAST_LINE.
20717 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20718 had a non-zero discriminator.
20720 We have to be careful in the presence of discriminators.
20721 E.g., for this line:
20723 for (i = 0; i < 100000; i++);
20725 clang can emit four line number entries for that one line,
20726 each with a different discriminator.
20727 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20729 However, we want gdb to coalesce all four entries into one.
20730 Otherwise the user could stepi into the middle of the line and
20731 gdb would get confused about whether the pc really was in the
20732 middle of the line.
20734 Things are further complicated by the fact that two consecutive
20735 line number entries for the same line is a heuristic used by gcc
20736 to denote the end of the prologue. So we can't just discard duplicate
20737 entries, we have to be selective about it. The heuristic we use is
20738 that we only collapse consecutive entries for the same line if at least
20739 one of those entries has a non-zero discriminator. PR 17276.
20741 Note: Addresses in the line number state machine can never go backwards
20742 within one sequence, thus this coalescing is ok. */
20745 dwarf_record_line_p (struct dwarf2_cu *cu,
20746 unsigned int line, unsigned int last_line,
20747 int line_has_non_zero_discriminator,
20748 struct subfile *last_subfile)
20750 if (cu->builder->get_current_subfile () != last_subfile)
20752 if (line != last_line)
20754 /* Same line for the same file that we've seen already.
20755 As a last check, for pr 17276, only record the line if the line
20756 has never had a non-zero discriminator. */
20757 if (!line_has_non_zero_discriminator)
20762 /* Use the CU's builder to record line number LINE beginning at
20763 address ADDRESS in the line table of subfile SUBFILE. */
20766 dwarf_record_line_1 (struct gdbarch *gdbarch, struct subfile *subfile,
20767 unsigned int line, CORE_ADDR address,
20768 struct dwarf2_cu *cu)
20770 CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
20772 if (dwarf_line_debug)
20774 fprintf_unfiltered (gdb_stdlog,
20775 "Recording line %u, file %s, address %s\n",
20776 line, lbasename (subfile->name),
20777 paddress (gdbarch, address));
20781 cu->builder->record_line (subfile, line, addr);
20784 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20785 Mark the end of a set of line number records.
20786 The arguments are the same as for dwarf_record_line_1.
20787 If SUBFILE is NULL the request is ignored. */
20790 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
20791 CORE_ADDR address, struct dwarf2_cu *cu)
20793 if (subfile == NULL)
20796 if (dwarf_line_debug)
20798 fprintf_unfiltered (gdb_stdlog,
20799 "Finishing current line, file %s, address %s\n",
20800 lbasename (subfile->name),
20801 paddress (gdbarch, address));
20804 dwarf_record_line_1 (gdbarch, subfile, 0, address, cu);
20808 lnp_state_machine::record_line (bool end_sequence)
20810 if (dwarf_line_debug)
20812 fprintf_unfiltered (gdb_stdlog,
20813 "Processing actual line %u: file %u,"
20814 " address %s, is_stmt %u, discrim %u\n",
20815 m_line, to_underlying (m_file),
20816 paddress (m_gdbarch, m_address),
20817 m_is_stmt, m_discriminator);
20820 file_entry *fe = current_file ();
20823 dwarf2_debug_line_missing_file_complaint ();
20824 /* For now we ignore lines not starting on an instruction boundary.
20825 But not when processing end_sequence for compatibility with the
20826 previous version of the code. */
20827 else if (m_op_index == 0 || end_sequence)
20829 fe->included_p = 1;
20830 if (m_record_lines_p && (producer_is_codewarrior (m_cu) || m_is_stmt))
20832 if (m_last_subfile != m_cu->builder->get_current_subfile ()
20835 dwarf_finish_line (m_gdbarch, m_last_subfile, m_address,
20836 m_currently_recording_lines ? m_cu : nullptr);
20841 if (dwarf_record_line_p (m_cu, m_line, m_last_line,
20842 m_line_has_non_zero_discriminator,
20845 dwarf_record_line_1 (m_gdbarch,
20846 m_cu->builder->get_current_subfile (),
20848 m_currently_recording_lines ? m_cu : nullptr);
20850 m_last_subfile = m_cu->builder->get_current_subfile ();
20851 m_last_line = m_line;
20857 lnp_state_machine::lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch,
20858 line_header *lh, bool record_lines_p)
20862 m_record_lines_p = record_lines_p;
20863 m_line_header = lh;
20865 m_currently_recording_lines = true;
20867 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20868 was a line entry for it so that the backend has a chance to adjust it
20869 and also record it in case it needs it. This is currently used by MIPS
20870 code, cf. `mips_adjust_dwarf2_line'. */
20871 m_address = gdbarch_adjust_dwarf2_line (arch, 0, 0);
20872 m_is_stmt = lh->default_is_stmt;
20873 m_discriminator = 0;
20877 lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
20878 const gdb_byte *line_ptr,
20879 CORE_ADDR unrelocated_lowpc, CORE_ADDR address)
20881 /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
20882 the pc range of the CU. However, we restrict the test to only ADDRESS
20883 values of zero to preserve GDB's previous behaviour which is to handle
20884 the specific case of a function being GC'd by the linker. */
20886 if (address == 0 && address < unrelocated_lowpc)
20888 /* This line table is for a function which has been
20889 GCd by the linker. Ignore it. PR gdb/12528 */
20891 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20892 long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
20894 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20895 line_offset, objfile_name (objfile));
20896 m_currently_recording_lines = false;
20897 /* Note: m_currently_recording_lines is left as false until we see
20898 DW_LNE_end_sequence. */
20902 /* Subroutine of dwarf_decode_lines to simplify it.
20903 Process the line number information in LH.
20904 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20905 program in order to set included_p for every referenced header. */
20908 dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
20909 const int decode_for_pst_p, CORE_ADDR lowpc)
20911 const gdb_byte *line_ptr, *extended_end;
20912 const gdb_byte *line_end;
20913 unsigned int bytes_read, extended_len;
20914 unsigned char op_code, extended_op;
20915 CORE_ADDR baseaddr;
20916 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20917 bfd *abfd = objfile->obfd;
20918 struct gdbarch *gdbarch = get_objfile_arch (objfile);
20919 /* True if we're recording line info (as opposed to building partial
20920 symtabs and just interested in finding include files mentioned by
20921 the line number program). */
20922 bool record_lines_p = !decode_for_pst_p;
20924 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
20926 line_ptr = lh->statement_program_start;
20927 line_end = lh->statement_program_end;
20929 /* Read the statement sequences until there's nothing left. */
20930 while (line_ptr < line_end)
20932 /* The DWARF line number program state machine. Reset the state
20933 machine at the start of each sequence. */
20934 lnp_state_machine state_machine (cu, gdbarch, lh, record_lines_p);
20935 bool end_sequence = false;
20937 if (record_lines_p)
20939 /* Start a subfile for the current file of the state
20941 const file_entry *fe = state_machine.current_file ();
20944 dwarf2_start_subfile (cu, fe->name, fe->include_dir (lh));
20947 /* Decode the table. */
20948 while (line_ptr < line_end && !end_sequence)
20950 op_code = read_1_byte (abfd, line_ptr);
20953 if (op_code >= lh->opcode_base)
20955 /* Special opcode. */
20956 state_machine.handle_special_opcode (op_code);
20958 else switch (op_code)
20960 case DW_LNS_extended_op:
20961 extended_len = read_unsigned_leb128 (abfd, line_ptr,
20963 line_ptr += bytes_read;
20964 extended_end = line_ptr + extended_len;
20965 extended_op = read_1_byte (abfd, line_ptr);
20967 switch (extended_op)
20969 case DW_LNE_end_sequence:
20970 state_machine.handle_end_sequence ();
20971 end_sequence = true;
20973 case DW_LNE_set_address:
20976 = read_address (abfd, line_ptr, cu, &bytes_read);
20977 line_ptr += bytes_read;
20979 state_machine.check_line_address (cu, line_ptr,
20980 lowpc - baseaddr, address);
20981 state_machine.handle_set_address (baseaddr, address);
20984 case DW_LNE_define_file:
20986 const char *cur_file;
20987 unsigned int mod_time, length;
20990 cur_file = read_direct_string (abfd, line_ptr,
20992 line_ptr += bytes_read;
20993 dindex = (dir_index)
20994 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20995 line_ptr += bytes_read;
20997 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20998 line_ptr += bytes_read;
21000 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21001 line_ptr += bytes_read;
21002 lh->add_file_name (cur_file, dindex, mod_time, length);
21005 case DW_LNE_set_discriminator:
21007 /* The discriminator is not interesting to the
21008 debugger; just ignore it. We still need to
21009 check its value though:
21010 if there are consecutive entries for the same
21011 (non-prologue) line we want to coalesce them.
21014 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21015 line_ptr += bytes_read;
21017 state_machine.handle_set_discriminator (discr);
21021 complaint (_("mangled .debug_line section"));
21024 /* Make sure that we parsed the extended op correctly. If e.g.
21025 we expected a different address size than the producer used,
21026 we may have read the wrong number of bytes. */
21027 if (line_ptr != extended_end)
21029 complaint (_("mangled .debug_line section"));
21034 state_machine.handle_copy ();
21036 case DW_LNS_advance_pc:
21039 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21040 line_ptr += bytes_read;
21042 state_machine.handle_advance_pc (adjust);
21045 case DW_LNS_advance_line:
21048 = read_signed_leb128 (abfd, line_ptr, &bytes_read);
21049 line_ptr += bytes_read;
21051 state_machine.handle_advance_line (line_delta);
21054 case DW_LNS_set_file:
21056 file_name_index file
21057 = (file_name_index) read_unsigned_leb128 (abfd, line_ptr,
21059 line_ptr += bytes_read;
21061 state_machine.handle_set_file (file);
21064 case DW_LNS_set_column:
21065 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21066 line_ptr += bytes_read;
21068 case DW_LNS_negate_stmt:
21069 state_machine.handle_negate_stmt ();
21071 case DW_LNS_set_basic_block:
21073 /* Add to the address register of the state machine the
21074 address increment value corresponding to special opcode
21075 255. I.e., this value is scaled by the minimum
21076 instruction length since special opcode 255 would have
21077 scaled the increment. */
21078 case DW_LNS_const_add_pc:
21079 state_machine.handle_const_add_pc ();
21081 case DW_LNS_fixed_advance_pc:
21083 CORE_ADDR addr_adj = read_2_bytes (abfd, line_ptr);
21086 state_machine.handle_fixed_advance_pc (addr_adj);
21091 /* Unknown standard opcode, ignore it. */
21094 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
21096 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21097 line_ptr += bytes_read;
21104 dwarf2_debug_line_missing_end_sequence_complaint ();
21106 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21107 in which case we still finish recording the last line). */
21108 state_machine.record_line (true);
21112 /* Decode the Line Number Program (LNP) for the given line_header
21113 structure and CU. The actual information extracted and the type
21114 of structures created from the LNP depends on the value of PST.
21116 1. If PST is NULL, then this procedure uses the data from the program
21117 to create all necessary symbol tables, and their linetables.
21119 2. If PST is not NULL, this procedure reads the program to determine
21120 the list of files included by the unit represented by PST, and
21121 builds all the associated partial symbol tables.
21123 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21124 It is used for relative paths in the line table.
21125 NOTE: When processing partial symtabs (pst != NULL),
21126 comp_dir == pst->dirname.
21128 NOTE: It is important that psymtabs have the same file name (via strcmp)
21129 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21130 symtab we don't use it in the name of the psymtabs we create.
21131 E.g. expand_line_sal requires this when finding psymtabs to expand.
21132 A good testcase for this is mb-inline.exp.
21134 LOWPC is the lowest address in CU (or 0 if not known).
21136 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21137 for its PC<->lines mapping information. Otherwise only the filename
21138 table is read in. */
21141 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
21142 struct dwarf2_cu *cu, struct partial_symtab *pst,
21143 CORE_ADDR lowpc, int decode_mapping)
21145 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21146 const int decode_for_pst_p = (pst != NULL);
21148 if (decode_mapping)
21149 dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
21151 if (decode_for_pst_p)
21155 /* Now that we're done scanning the Line Header Program, we can
21156 create the psymtab of each included file. */
21157 for (file_index = 0; file_index < lh->file_names.size (); file_index++)
21158 if (lh->file_names[file_index].included_p == 1)
21160 gdb::unique_xmalloc_ptr<char> name_holder;
21161 const char *include_name =
21162 psymtab_include_file_name (lh, file_index, pst, comp_dir,
21164 if (include_name != NULL)
21165 dwarf2_create_include_psymtab (include_name, pst, objfile);
21170 /* Make sure a symtab is created for every file, even files
21171 which contain only variables (i.e. no code with associated
21173 struct compunit_symtab *cust = cu->builder->get_compunit_symtab ();
21176 for (i = 0; i < lh->file_names.size (); i++)
21178 file_entry &fe = lh->file_names[i];
21180 dwarf2_start_subfile (cu, fe.name, fe.include_dir (lh));
21182 if (cu->builder->get_current_subfile ()->symtab == NULL)
21184 cu->builder->get_current_subfile ()->symtab
21185 = allocate_symtab (cust,
21186 cu->builder->get_current_subfile ()->name);
21188 fe.symtab = cu->builder->get_current_subfile ()->symtab;
21193 /* Start a subfile for DWARF. FILENAME is the name of the file and
21194 DIRNAME the name of the source directory which contains FILENAME
21195 or NULL if not known.
21196 This routine tries to keep line numbers from identical absolute and
21197 relative file names in a common subfile.
21199 Using the `list' example from the GDB testsuite, which resides in
21200 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21201 of /srcdir/list0.c yields the following debugging information for list0.c:
21203 DW_AT_name: /srcdir/list0.c
21204 DW_AT_comp_dir: /compdir
21205 files.files[0].name: list0.h
21206 files.files[0].dir: /srcdir
21207 files.files[1].name: list0.c
21208 files.files[1].dir: /srcdir
21210 The line number information for list0.c has to end up in a single
21211 subfile, so that `break /srcdir/list0.c:1' works as expected.
21212 start_subfile will ensure that this happens provided that we pass the
21213 concatenation of files.files[1].dir and files.files[1].name as the
21217 dwarf2_start_subfile (struct dwarf2_cu *cu, const char *filename,
21218 const char *dirname)
21222 /* In order not to lose the line information directory,
21223 we concatenate it to the filename when it makes sense.
21224 Note that the Dwarf3 standard says (speaking of filenames in line
21225 information): ``The directory index is ignored for file names
21226 that represent full path names''. Thus ignoring dirname in the
21227 `else' branch below isn't an issue. */
21229 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
21231 copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
21235 cu->builder->start_subfile (filename);
21241 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21242 buildsym_compunit constructor. */
21244 static struct compunit_symtab *
21245 dwarf2_start_symtab (struct dwarf2_cu *cu,
21246 const char *name, const char *comp_dir, CORE_ADDR low_pc)
21248 gdb_assert (cu->builder == nullptr);
21250 cu->builder.reset (new struct buildsym_compunit
21251 (cu->per_cu->dwarf2_per_objfile->objfile,
21252 name, comp_dir, cu->language, low_pc));
21254 cu->list_in_scope = cu->builder->get_file_symbols ();
21256 cu->builder->record_debugformat ("DWARF 2");
21257 cu->builder->record_producer (cu->producer);
21259 cu->processing_has_namespace_info = false;
21261 return cu->builder->get_compunit_symtab ();
21265 var_decode_location (struct attribute *attr, struct symbol *sym,
21266 struct dwarf2_cu *cu)
21268 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21269 struct comp_unit_head *cu_header = &cu->header;
21271 /* NOTE drow/2003-01-30: There used to be a comment and some special
21272 code here to turn a symbol with DW_AT_external and a
21273 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21274 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21275 with some versions of binutils) where shared libraries could have
21276 relocations against symbols in their debug information - the
21277 minimal symbol would have the right address, but the debug info
21278 would not. It's no longer necessary, because we will explicitly
21279 apply relocations when we read in the debug information now. */
21281 /* A DW_AT_location attribute with no contents indicates that a
21282 variable has been optimized away. */
21283 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
21285 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21289 /* Handle one degenerate form of location expression specially, to
21290 preserve GDB's previous behavior when section offsets are
21291 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
21292 then mark this symbol as LOC_STATIC. */
21294 if (attr_form_is_block (attr)
21295 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
21296 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
21297 || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
21298 && (DW_BLOCK (attr)->size
21299 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
21301 unsigned int dummy;
21303 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
21304 SYMBOL_VALUE_ADDRESS (sym) =
21305 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
21307 SYMBOL_VALUE_ADDRESS (sym) =
21308 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
21309 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
21310 fixup_symbol_section (sym, objfile);
21311 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
21312 SYMBOL_SECTION (sym));
21316 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21317 expression evaluator, and use LOC_COMPUTED only when necessary
21318 (i.e. when the value of a register or memory location is
21319 referenced, or a thread-local block, etc.). Then again, it might
21320 not be worthwhile. I'm assuming that it isn't unless performance
21321 or memory numbers show me otherwise. */
21323 dwarf2_symbol_mark_computed (attr, sym, cu, 0);
21325 if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
21326 cu->has_loclist = true;
21329 /* Given a pointer to a DWARF information entry, figure out if we need
21330 to make a symbol table entry for it, and if so, create a new entry
21331 and return a pointer to it.
21332 If TYPE is NULL, determine symbol type from the die, otherwise
21333 used the passed type.
21334 If SPACE is not NULL, use it to hold the new symbol. If it is
21335 NULL, allocate a new symbol on the objfile's obstack. */
21337 static struct symbol *
21338 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
21339 struct symbol *space)
21341 struct dwarf2_per_objfile *dwarf2_per_objfile
21342 = cu->per_cu->dwarf2_per_objfile;
21343 struct objfile *objfile = dwarf2_per_objfile->objfile;
21344 struct gdbarch *gdbarch = get_objfile_arch (objfile);
21345 struct symbol *sym = NULL;
21347 struct attribute *attr = NULL;
21348 struct attribute *attr2 = NULL;
21349 CORE_ADDR baseaddr;
21350 struct pending **list_to_add = NULL;
21352 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
21354 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21356 name = dwarf2_name (die, cu);
21359 const char *linkagename;
21360 int suppress_add = 0;
21365 sym = allocate_symbol (objfile);
21366 OBJSTAT (objfile, n_syms++);
21368 /* Cache this symbol's name and the name's demangled form (if any). */
21369 SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
21370 linkagename = dwarf2_physname (name, die, cu);
21371 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
21373 /* Fortran does not have mangling standard and the mangling does differ
21374 between gfortran, iFort etc. */
21375 if (cu->language == language_fortran
21376 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
21377 symbol_set_demangled_name (&(sym->ginfo),
21378 dwarf2_full_name (name, die, cu),
21381 /* Default assumptions.
21382 Use the passed type or decode it from the die. */
21383 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21384 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21386 SYMBOL_TYPE (sym) = type;
21388 SYMBOL_TYPE (sym) = die_type (die, cu);
21389 attr = dwarf2_attr (die,
21390 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
21394 SYMBOL_LINE (sym) = DW_UNSND (attr);
21397 attr = dwarf2_attr (die,
21398 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
21402 file_name_index file_index = (file_name_index) DW_UNSND (attr);
21403 struct file_entry *fe;
21405 if (cu->line_header != NULL)
21406 fe = cu->line_header->file_name_at (file_index);
21411 complaint (_("file index out of range"));
21413 symbol_set_symtab (sym, fe->symtab);
21419 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
21424 addr = attr_value_as_address (attr);
21425 addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
21426 SYMBOL_VALUE_ADDRESS (sym) = addr;
21428 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
21429 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
21430 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
21431 dw2_add_symbol_to_list (sym, cu->list_in_scope);
21433 case DW_TAG_subprogram:
21434 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21436 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21437 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21438 if ((attr2 && (DW_UNSND (attr2) != 0))
21439 || cu->language == language_ada)
21441 /* Subprograms marked external are stored as a global symbol.
21442 Ada subprograms, whether marked external or not, are always
21443 stored as a global symbol, because we want to be able to
21444 access them globally. For instance, we want to be able
21445 to break on a nested subprogram without having to
21446 specify the context. */
21447 list_to_add = cu->builder->get_global_symbols ();
21451 list_to_add = cu->list_in_scope;
21454 case DW_TAG_inlined_subroutine:
21455 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21457 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21458 SYMBOL_INLINED (sym) = 1;
21459 list_to_add = cu->list_in_scope;
21461 case DW_TAG_template_value_param:
21463 /* Fall through. */
21464 case DW_TAG_constant:
21465 case DW_TAG_variable:
21466 case DW_TAG_member:
21467 /* Compilation with minimal debug info may result in
21468 variables with missing type entries. Change the
21469 misleading `void' type to something sensible. */
21470 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
21471 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
21473 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21474 /* In the case of DW_TAG_member, we should only be called for
21475 static const members. */
21476 if (die->tag == DW_TAG_member)
21478 /* dwarf2_add_field uses die_is_declaration,
21479 so we do the same. */
21480 gdb_assert (die_is_declaration (die, cu));
21485 dwarf2_const_value (attr, sym, cu);
21486 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21489 if (attr2 && (DW_UNSND (attr2) != 0))
21490 list_to_add = cu->builder->get_global_symbols ();
21492 list_to_add = cu->list_in_scope;
21496 attr = dwarf2_attr (die, DW_AT_location, cu);
21499 var_decode_location (attr, sym, cu);
21500 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21502 /* Fortran explicitly imports any global symbols to the local
21503 scope by DW_TAG_common_block. */
21504 if (cu->language == language_fortran && die->parent
21505 && die->parent->tag == DW_TAG_common_block)
21508 if (SYMBOL_CLASS (sym) == LOC_STATIC
21509 && SYMBOL_VALUE_ADDRESS (sym) == 0
21510 && !dwarf2_per_objfile->has_section_at_zero)
21512 /* When a static variable is eliminated by the linker,
21513 the corresponding debug information is not stripped
21514 out, but the variable address is set to null;
21515 do not add such variables into symbol table. */
21517 else if (attr2 && (DW_UNSND (attr2) != 0))
21519 /* Workaround gfortran PR debug/40040 - it uses
21520 DW_AT_location for variables in -fPIC libraries which may
21521 get overriden by other libraries/executable and get
21522 a different address. Resolve it by the minimal symbol
21523 which may come from inferior's executable using copy
21524 relocation. Make this workaround only for gfortran as for
21525 other compilers GDB cannot guess the minimal symbol
21526 Fortran mangling kind. */
21527 if (cu->language == language_fortran && die->parent
21528 && die->parent->tag == DW_TAG_module
21530 && startswith (cu->producer, "GNU Fortran"))
21531 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21533 /* A variable with DW_AT_external is never static,
21534 but it may be block-scoped. */
21536 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21537 ? cu->builder->get_global_symbols ()
21538 : cu->list_in_scope);
21541 list_to_add = cu->list_in_scope;
21545 /* We do not know the address of this symbol.
21546 If it is an external symbol and we have type information
21547 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21548 The address of the variable will then be determined from
21549 the minimal symbol table whenever the variable is
21551 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21553 /* Fortran explicitly imports any global symbols to the local
21554 scope by DW_TAG_common_block. */
21555 if (cu->language == language_fortran && die->parent
21556 && die->parent->tag == DW_TAG_common_block)
21558 /* SYMBOL_CLASS doesn't matter here because
21559 read_common_block is going to reset it. */
21561 list_to_add = cu->list_in_scope;
21563 else if (attr2 && (DW_UNSND (attr2) != 0)
21564 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
21566 /* A variable with DW_AT_external is never static, but it
21567 may be block-scoped. */
21569 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21570 ? cu->builder->get_global_symbols ()
21571 : cu->list_in_scope);
21573 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21575 else if (!die_is_declaration (die, cu))
21577 /* Use the default LOC_OPTIMIZED_OUT class. */
21578 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
21580 list_to_add = cu->list_in_scope;
21584 case DW_TAG_formal_parameter:
21586 /* If we are inside a function, mark this as an argument. If
21587 not, we might be looking at an argument to an inlined function
21588 when we do not have enough information to show inlined frames;
21589 pretend it's a local variable in that case so that the user can
21591 struct context_stack *curr
21592 = cu->builder->get_current_context_stack ();
21593 if (curr != nullptr && curr->name != nullptr)
21594 SYMBOL_IS_ARGUMENT (sym) = 1;
21595 attr = dwarf2_attr (die, DW_AT_location, cu);
21598 var_decode_location (attr, sym, cu);
21600 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21603 dwarf2_const_value (attr, sym, cu);
21606 list_to_add = cu->list_in_scope;
21609 case DW_TAG_unspecified_parameters:
21610 /* From varargs functions; gdb doesn't seem to have any
21611 interest in this information, so just ignore it for now.
21614 case DW_TAG_template_type_param:
21616 /* Fall through. */
21617 case DW_TAG_class_type:
21618 case DW_TAG_interface_type:
21619 case DW_TAG_structure_type:
21620 case DW_TAG_union_type:
21621 case DW_TAG_set_type:
21622 case DW_TAG_enumeration_type:
21623 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21624 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
21627 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21628 really ever be static objects: otherwise, if you try
21629 to, say, break of a class's method and you're in a file
21630 which doesn't mention that class, it won't work unless
21631 the check for all static symbols in lookup_symbol_aux
21632 saves you. See the OtherFileClass tests in
21633 gdb.c++/namespace.exp. */
21638 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21639 && cu->language == language_cplus
21640 ? cu->builder->get_global_symbols ()
21641 : cu->list_in_scope);
21643 /* The semantics of C++ state that "struct foo {
21644 ... }" also defines a typedef for "foo". */
21645 if (cu->language == language_cplus
21646 || cu->language == language_ada
21647 || cu->language == language_d
21648 || cu->language == language_rust)
21650 /* The symbol's name is already allocated along
21651 with this objfile, so we don't need to
21652 duplicate it for the type. */
21653 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
21654 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
21659 case DW_TAG_typedef:
21660 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21661 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21662 list_to_add = cu->list_in_scope;
21664 case DW_TAG_base_type:
21665 case DW_TAG_subrange_type:
21666 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21667 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21668 list_to_add = cu->list_in_scope;
21670 case DW_TAG_enumerator:
21671 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21674 dwarf2_const_value (attr, sym, cu);
21677 /* NOTE: carlton/2003-11-10: See comment above in the
21678 DW_TAG_class_type, etc. block. */
21681 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21682 && cu->language == language_cplus
21683 ? cu->builder->get_global_symbols ()
21684 : cu->list_in_scope);
21687 case DW_TAG_imported_declaration:
21688 case DW_TAG_namespace:
21689 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21690 list_to_add = cu->builder->get_global_symbols ();
21692 case DW_TAG_module:
21693 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21694 SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
21695 list_to_add = cu->builder->get_global_symbols ();
21697 case DW_TAG_common_block:
21698 SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
21699 SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
21700 dw2_add_symbol_to_list (sym, cu->list_in_scope);
21703 /* Not a tag we recognize. Hopefully we aren't processing
21704 trash data, but since we must specifically ignore things
21705 we don't recognize, there is nothing else we should do at
21707 complaint (_("unsupported tag: '%s'"),
21708 dwarf_tag_name (die->tag));
21714 sym->hash_next = objfile->template_symbols;
21715 objfile->template_symbols = sym;
21716 list_to_add = NULL;
21719 if (list_to_add != NULL)
21720 dw2_add_symbol_to_list (sym, list_to_add);
21722 /* For the benefit of old versions of GCC, check for anonymous
21723 namespaces based on the demangled name. */
21724 if (!cu->processing_has_namespace_info
21725 && cu->language == language_cplus)
21726 cp_scan_for_anonymous_namespaces (cu->builder.get (), sym, objfile);
21731 /* Given an attr with a DW_FORM_dataN value in host byte order,
21732 zero-extend it as appropriate for the symbol's type. The DWARF
21733 standard (v4) is not entirely clear about the meaning of using
21734 DW_FORM_dataN for a constant with a signed type, where the type is
21735 wider than the data. The conclusion of a discussion on the DWARF
21736 list was that this is unspecified. We choose to always zero-extend
21737 because that is the interpretation long in use by GCC. */
21740 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
21741 struct dwarf2_cu *cu, LONGEST *value, int bits)
21743 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21744 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
21745 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
21746 LONGEST l = DW_UNSND (attr);
21748 if (bits < sizeof (*value) * 8)
21750 l &= ((LONGEST) 1 << bits) - 1;
21753 else if (bits == sizeof (*value) * 8)
21757 gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
21758 store_unsigned_integer (bytes, bits / 8, byte_order, l);
21765 /* Read a constant value from an attribute. Either set *VALUE, or if
21766 the value does not fit in *VALUE, set *BYTES - either already
21767 allocated on the objfile obstack, or newly allocated on OBSTACK,
21768 or, set *BATON, if we translated the constant to a location
21772 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
21773 const char *name, struct obstack *obstack,
21774 struct dwarf2_cu *cu,
21775 LONGEST *value, const gdb_byte **bytes,
21776 struct dwarf2_locexpr_baton **baton)
21778 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21779 struct comp_unit_head *cu_header = &cu->header;
21780 struct dwarf_block *blk;
21781 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
21782 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
21788 switch (attr->form)
21791 case DW_FORM_GNU_addr_index:
21795 if (TYPE_LENGTH (type) != cu_header->addr_size)
21796 dwarf2_const_value_length_mismatch_complaint (name,
21797 cu_header->addr_size,
21798 TYPE_LENGTH (type));
21799 /* Symbols of this form are reasonably rare, so we just
21800 piggyback on the existing location code rather than writing
21801 a new implementation of symbol_computed_ops. */
21802 *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
21803 (*baton)->per_cu = cu->per_cu;
21804 gdb_assert ((*baton)->per_cu);
21806 (*baton)->size = 2 + cu_header->addr_size;
21807 data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
21808 (*baton)->data = data;
21810 data[0] = DW_OP_addr;
21811 store_unsigned_integer (&data[1], cu_header->addr_size,
21812 byte_order, DW_ADDR (attr));
21813 data[cu_header->addr_size + 1] = DW_OP_stack_value;
21816 case DW_FORM_string:
21818 case DW_FORM_GNU_str_index:
21819 case DW_FORM_GNU_strp_alt:
21820 /* DW_STRING is already allocated on the objfile obstack, point
21822 *bytes = (const gdb_byte *) DW_STRING (attr);
21824 case DW_FORM_block1:
21825 case DW_FORM_block2:
21826 case DW_FORM_block4:
21827 case DW_FORM_block:
21828 case DW_FORM_exprloc:
21829 case DW_FORM_data16:
21830 blk = DW_BLOCK (attr);
21831 if (TYPE_LENGTH (type) != blk->size)
21832 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
21833 TYPE_LENGTH (type));
21834 *bytes = blk->data;
21837 /* The DW_AT_const_value attributes are supposed to carry the
21838 symbol's value "represented as it would be on the target
21839 architecture." By the time we get here, it's already been
21840 converted to host endianness, so we just need to sign- or
21841 zero-extend it as appropriate. */
21842 case DW_FORM_data1:
21843 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
21845 case DW_FORM_data2:
21846 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
21848 case DW_FORM_data4:
21849 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
21851 case DW_FORM_data8:
21852 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
21855 case DW_FORM_sdata:
21856 case DW_FORM_implicit_const:
21857 *value = DW_SND (attr);
21860 case DW_FORM_udata:
21861 *value = DW_UNSND (attr);
21865 complaint (_("unsupported const value attribute form: '%s'"),
21866 dwarf_form_name (attr->form));
21873 /* Copy constant value from an attribute to a symbol. */
21876 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
21877 struct dwarf2_cu *cu)
21879 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21881 const gdb_byte *bytes;
21882 struct dwarf2_locexpr_baton *baton;
21884 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
21885 SYMBOL_PRINT_NAME (sym),
21886 &objfile->objfile_obstack, cu,
21887 &value, &bytes, &baton);
21891 SYMBOL_LOCATION_BATON (sym) = baton;
21892 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
21894 else if (bytes != NULL)
21896 SYMBOL_VALUE_BYTES (sym) = bytes;
21897 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
21901 SYMBOL_VALUE (sym) = value;
21902 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
21906 /* Return the type of the die in question using its DW_AT_type attribute. */
21908 static struct type *
21909 die_type (struct die_info *die, struct dwarf2_cu *cu)
21911 struct attribute *type_attr;
21913 type_attr = dwarf2_attr (die, DW_AT_type, cu);
21916 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21917 /* A missing DW_AT_type represents a void type. */
21918 return objfile_type (objfile)->builtin_void;
21921 return lookup_die_type (die, type_attr, cu);
21924 /* True iff CU's producer generates GNAT Ada auxiliary information
21925 that allows to find parallel types through that information instead
21926 of having to do expensive parallel lookups by type name. */
21929 need_gnat_info (struct dwarf2_cu *cu)
21931 /* Assume that the Ada compiler was GNAT, which always produces
21932 the auxiliary information. */
21933 return (cu->language == language_ada);
21936 /* Return the auxiliary type of the die in question using its
21937 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
21938 attribute is not present. */
21940 static struct type *
21941 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
21943 struct attribute *type_attr;
21945 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
21949 return lookup_die_type (die, type_attr, cu);
21952 /* If DIE has a descriptive_type attribute, then set the TYPE's
21953 descriptive type accordingly. */
21956 set_descriptive_type (struct type *type, struct die_info *die,
21957 struct dwarf2_cu *cu)
21959 struct type *descriptive_type = die_descriptive_type (die, cu);
21961 if (descriptive_type)
21963 ALLOCATE_GNAT_AUX_TYPE (type);
21964 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
21968 /* Return the containing type of the die in question using its
21969 DW_AT_containing_type attribute. */
21971 static struct type *
21972 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
21974 struct attribute *type_attr;
21975 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21977 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
21979 error (_("Dwarf Error: Problem turning containing type into gdb type "
21980 "[in module %s]"), objfile_name (objfile));
21982 return lookup_die_type (die, type_attr, cu);
21985 /* Return an error marker type to use for the ill formed type in DIE/CU. */
21987 static struct type *
21988 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
21990 struct dwarf2_per_objfile *dwarf2_per_objfile
21991 = cu->per_cu->dwarf2_per_objfile;
21992 struct objfile *objfile = dwarf2_per_objfile->objfile;
21995 std::string message
21996 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
21997 objfile_name (objfile),
21998 sect_offset_str (cu->header.sect_off),
21999 sect_offset_str (die->sect_off));
22000 saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
22001 message.c_str (), message.length ());
22003 return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
22006 /* Look up the type of DIE in CU using its type attribute ATTR.
22007 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22008 DW_AT_containing_type.
22009 If there is no type substitute an error marker. */
22011 static struct type *
22012 lookup_die_type (struct die_info *die, const struct attribute *attr,
22013 struct dwarf2_cu *cu)
22015 struct dwarf2_per_objfile *dwarf2_per_objfile
22016 = cu->per_cu->dwarf2_per_objfile;
22017 struct objfile *objfile = dwarf2_per_objfile->objfile;
22018 struct type *this_type;
22020 gdb_assert (attr->name == DW_AT_type
22021 || attr->name == DW_AT_GNAT_descriptive_type
22022 || attr->name == DW_AT_containing_type);
22024 /* First see if we have it cached. */
22026 if (attr->form == DW_FORM_GNU_ref_alt)
22028 struct dwarf2_per_cu_data *per_cu;
22029 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22031 per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
22032 dwarf2_per_objfile);
22033 this_type = get_die_type_at_offset (sect_off, per_cu);
22035 else if (attr_form_is_ref (attr))
22037 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22039 this_type = get_die_type_at_offset (sect_off, cu->per_cu);
22041 else if (attr->form == DW_FORM_ref_sig8)
22043 ULONGEST signature = DW_SIGNATURE (attr);
22045 return get_signatured_type (die, signature, cu);
22049 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22050 " at %s [in module %s]"),
22051 dwarf_attr_name (attr->name), sect_offset_str (die->sect_off),
22052 objfile_name (objfile));
22053 return build_error_marker_type (cu, die);
22056 /* If not cached we need to read it in. */
22058 if (this_type == NULL)
22060 struct die_info *type_die = NULL;
22061 struct dwarf2_cu *type_cu = cu;
22063 if (attr_form_is_ref (attr))
22064 type_die = follow_die_ref (die, attr, &type_cu);
22065 if (type_die == NULL)
22066 return build_error_marker_type (cu, die);
22067 /* If we find the type now, it's probably because the type came
22068 from an inter-CU reference and the type's CU got expanded before
22070 this_type = read_type_die (type_die, type_cu);
22073 /* If we still don't have a type use an error marker. */
22075 if (this_type == NULL)
22076 return build_error_marker_type (cu, die);
22081 /* Return the type in DIE, CU.
22082 Returns NULL for invalid types.
22084 This first does a lookup in die_type_hash,
22085 and only reads the die in if necessary.
22087 NOTE: This can be called when reading in partial or full symbols. */
22089 static struct type *
22090 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
22092 struct type *this_type;
22094 this_type = get_die_type (die, cu);
22098 return read_type_die_1 (die, cu);
22101 /* Read the type in DIE, CU.
22102 Returns NULL for invalid types. */
22104 static struct type *
22105 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
22107 struct type *this_type = NULL;
22111 case DW_TAG_class_type:
22112 case DW_TAG_interface_type:
22113 case DW_TAG_structure_type:
22114 case DW_TAG_union_type:
22115 this_type = read_structure_type (die, cu);
22117 case DW_TAG_enumeration_type:
22118 this_type = read_enumeration_type (die, cu);
22120 case DW_TAG_subprogram:
22121 case DW_TAG_subroutine_type:
22122 case DW_TAG_inlined_subroutine:
22123 this_type = read_subroutine_type (die, cu);
22125 case DW_TAG_array_type:
22126 this_type = read_array_type (die, cu);
22128 case DW_TAG_set_type:
22129 this_type = read_set_type (die, cu);
22131 case DW_TAG_pointer_type:
22132 this_type = read_tag_pointer_type (die, cu);
22134 case DW_TAG_ptr_to_member_type:
22135 this_type = read_tag_ptr_to_member_type (die, cu);
22137 case DW_TAG_reference_type:
22138 this_type = read_tag_reference_type (die, cu, TYPE_CODE_REF);
22140 case DW_TAG_rvalue_reference_type:
22141 this_type = read_tag_reference_type (die, cu, TYPE_CODE_RVALUE_REF);
22143 case DW_TAG_const_type:
22144 this_type = read_tag_const_type (die, cu);
22146 case DW_TAG_volatile_type:
22147 this_type = read_tag_volatile_type (die, cu);
22149 case DW_TAG_restrict_type:
22150 this_type = read_tag_restrict_type (die, cu);
22152 case DW_TAG_string_type:
22153 this_type = read_tag_string_type (die, cu);
22155 case DW_TAG_typedef:
22156 this_type = read_typedef (die, cu);
22158 case DW_TAG_subrange_type:
22159 this_type = read_subrange_type (die, cu);
22161 case DW_TAG_base_type:
22162 this_type = read_base_type (die, cu);
22164 case DW_TAG_unspecified_type:
22165 this_type = read_unspecified_type (die, cu);
22167 case DW_TAG_namespace:
22168 this_type = read_namespace_type (die, cu);
22170 case DW_TAG_module:
22171 this_type = read_module_type (die, cu);
22173 case DW_TAG_atomic_type:
22174 this_type = read_tag_atomic_type (die, cu);
22177 complaint (_("unexpected tag in read_type_die: '%s'"),
22178 dwarf_tag_name (die->tag));
22185 /* See if we can figure out if the class lives in a namespace. We do
22186 this by looking for a member function; its demangled name will
22187 contain namespace info, if there is any.
22188 Return the computed name or NULL.
22189 Space for the result is allocated on the objfile's obstack.
22190 This is the full-die version of guess_partial_die_structure_name.
22191 In this case we know DIE has no useful parent. */
22194 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
22196 struct die_info *spec_die;
22197 struct dwarf2_cu *spec_cu;
22198 struct die_info *child;
22199 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22202 spec_die = die_specification (die, &spec_cu);
22203 if (spec_die != NULL)
22209 for (child = die->child;
22211 child = child->sibling)
22213 if (child->tag == DW_TAG_subprogram)
22215 const char *linkage_name = dw2_linkage_name (child, cu);
22217 if (linkage_name != NULL)
22220 = language_class_name_from_physname (cu->language_defn,
22224 if (actual_name != NULL)
22226 const char *die_name = dwarf2_name (die, cu);
22228 if (die_name != NULL
22229 && strcmp (die_name, actual_name) != 0)
22231 /* Strip off the class name from the full name.
22232 We want the prefix. */
22233 int die_name_len = strlen (die_name);
22234 int actual_name_len = strlen (actual_name);
22236 /* Test for '::' as a sanity check. */
22237 if (actual_name_len > die_name_len + 2
22238 && actual_name[actual_name_len
22239 - die_name_len - 1] == ':')
22240 name = (char *) obstack_copy0 (
22241 &objfile->per_bfd->storage_obstack,
22242 actual_name, actual_name_len - die_name_len - 2);
22245 xfree (actual_name);
22254 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22255 prefix part in such case. See
22256 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22258 static const char *
22259 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
22261 struct attribute *attr;
22264 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
22265 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
22268 if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
22271 attr = dw2_linkage_name_attr (die, cu);
22272 if (attr == NULL || DW_STRING (attr) == NULL)
22275 /* dwarf2_name had to be already called. */
22276 gdb_assert (DW_STRING_IS_CANONICAL (attr));
22278 /* Strip the base name, keep any leading namespaces/classes. */
22279 base = strrchr (DW_STRING (attr), ':');
22280 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
22283 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22284 return (char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
22286 &base[-1] - DW_STRING (attr));
22289 /* Return the name of the namespace/class that DIE is defined within,
22290 or "" if we can't tell. The caller should not xfree the result.
22292 For example, if we're within the method foo() in the following
22302 then determine_prefix on foo's die will return "N::C". */
22304 static const char *
22305 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
22307 struct dwarf2_per_objfile *dwarf2_per_objfile
22308 = cu->per_cu->dwarf2_per_objfile;
22309 struct die_info *parent, *spec_die;
22310 struct dwarf2_cu *spec_cu;
22311 struct type *parent_type;
22312 const char *retval;
22314 if (cu->language != language_cplus
22315 && cu->language != language_fortran && cu->language != language_d
22316 && cu->language != language_rust)
22319 retval = anonymous_struct_prefix (die, cu);
22323 /* We have to be careful in the presence of DW_AT_specification.
22324 For example, with GCC 3.4, given the code
22328 // Definition of N::foo.
22332 then we'll have a tree of DIEs like this:
22334 1: DW_TAG_compile_unit
22335 2: DW_TAG_namespace // N
22336 3: DW_TAG_subprogram // declaration of N::foo
22337 4: DW_TAG_subprogram // definition of N::foo
22338 DW_AT_specification // refers to die #3
22340 Thus, when processing die #4, we have to pretend that we're in
22341 the context of its DW_AT_specification, namely the contex of die
22344 spec_die = die_specification (die, &spec_cu);
22345 if (spec_die == NULL)
22346 parent = die->parent;
22349 parent = spec_die->parent;
22353 if (parent == NULL)
22355 else if (parent->building_fullname)
22358 const char *parent_name;
22360 /* It has been seen on RealView 2.2 built binaries,
22361 DW_TAG_template_type_param types actually _defined_ as
22362 children of the parent class:
22365 template class <class Enum> Class{};
22366 Class<enum E> class_e;
22368 1: DW_TAG_class_type (Class)
22369 2: DW_TAG_enumeration_type (E)
22370 3: DW_TAG_enumerator (enum1:0)
22371 3: DW_TAG_enumerator (enum2:1)
22373 2: DW_TAG_template_type_param
22374 DW_AT_type DW_FORM_ref_udata (E)
22376 Besides being broken debug info, it can put GDB into an
22377 infinite loop. Consider:
22379 When we're building the full name for Class<E>, we'll start
22380 at Class, and go look over its template type parameters,
22381 finding E. We'll then try to build the full name of E, and
22382 reach here. We're now trying to build the full name of E,
22383 and look over the parent DIE for containing scope. In the
22384 broken case, if we followed the parent DIE of E, we'd again
22385 find Class, and once again go look at its template type
22386 arguments, etc., etc. Simply don't consider such parent die
22387 as source-level parent of this die (it can't be, the language
22388 doesn't allow it), and break the loop here. */
22389 name = dwarf2_name (die, cu);
22390 parent_name = dwarf2_name (parent, cu);
22391 complaint (_("template param type '%s' defined within parent '%s'"),
22392 name ? name : "<unknown>",
22393 parent_name ? parent_name : "<unknown>");
22397 switch (parent->tag)
22399 case DW_TAG_namespace:
22400 parent_type = read_type_die (parent, cu);
22401 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22402 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22403 Work around this problem here. */
22404 if (cu->language == language_cplus
22405 && strcmp (TYPE_NAME (parent_type), "::") == 0)
22407 /* We give a name to even anonymous namespaces. */
22408 return TYPE_NAME (parent_type);
22409 case DW_TAG_class_type:
22410 case DW_TAG_interface_type:
22411 case DW_TAG_structure_type:
22412 case DW_TAG_union_type:
22413 case DW_TAG_module:
22414 parent_type = read_type_die (parent, cu);
22415 if (TYPE_NAME (parent_type) != NULL)
22416 return TYPE_NAME (parent_type);
22418 /* An anonymous structure is only allowed non-static data
22419 members; no typedefs, no member functions, et cetera.
22420 So it does not need a prefix. */
22422 case DW_TAG_compile_unit:
22423 case DW_TAG_partial_unit:
22424 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22425 if (cu->language == language_cplus
22426 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
22427 && die->child != NULL
22428 && (die->tag == DW_TAG_class_type
22429 || die->tag == DW_TAG_structure_type
22430 || die->tag == DW_TAG_union_type))
22432 char *name = guess_full_die_structure_name (die, cu);
22437 case DW_TAG_enumeration_type:
22438 parent_type = read_type_die (parent, cu);
22439 if (TYPE_DECLARED_CLASS (parent_type))
22441 if (TYPE_NAME (parent_type) != NULL)
22442 return TYPE_NAME (parent_type);
22445 /* Fall through. */
22447 return determine_prefix (parent, cu);
22451 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22452 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22453 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22454 an obconcat, otherwise allocate storage for the result. The CU argument is
22455 used to determine the language and hence, the appropriate separator. */
22457 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22460 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
22461 int physname, struct dwarf2_cu *cu)
22463 const char *lead = "";
22466 if (suffix == NULL || suffix[0] == '\0'
22467 || prefix == NULL || prefix[0] == '\0')
22469 else if (cu->language == language_d)
22471 /* For D, the 'main' function could be defined in any module, but it
22472 should never be prefixed. */
22473 if (strcmp (suffix, "D main") == 0)
22481 else if (cu->language == language_fortran && physname)
22483 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22484 DW_AT_MIPS_linkage_name is preferred and used instead. */
22492 if (prefix == NULL)
22494 if (suffix == NULL)
22501 xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
22503 strcpy (retval, lead);
22504 strcat (retval, prefix);
22505 strcat (retval, sep);
22506 strcat (retval, suffix);
22511 /* We have an obstack. */
22512 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
22516 /* Return sibling of die, NULL if no sibling. */
22518 static struct die_info *
22519 sibling_die (struct die_info *die)
22521 return die->sibling;
22524 /* Get name of a die, return NULL if not found. */
22526 static const char *
22527 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
22528 struct obstack *obstack)
22530 if (name && cu->language == language_cplus)
22532 std::string canon_name = cp_canonicalize_string (name);
22534 if (!canon_name.empty ())
22536 if (canon_name != name)
22537 name = (const char *) obstack_copy0 (obstack,
22538 canon_name.c_str (),
22539 canon_name.length ());
22546 /* Get name of a die, return NULL if not found.
22547 Anonymous namespaces are converted to their magic string. */
22549 static const char *
22550 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
22552 struct attribute *attr;
22553 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22555 attr = dwarf2_attr (die, DW_AT_name, cu);
22556 if ((!attr || !DW_STRING (attr))
22557 && die->tag != DW_TAG_namespace
22558 && die->tag != DW_TAG_class_type
22559 && die->tag != DW_TAG_interface_type
22560 && die->tag != DW_TAG_structure_type
22561 && die->tag != DW_TAG_union_type)
22566 case DW_TAG_compile_unit:
22567 case DW_TAG_partial_unit:
22568 /* Compilation units have a DW_AT_name that is a filename, not
22569 a source language identifier. */
22570 case DW_TAG_enumeration_type:
22571 case DW_TAG_enumerator:
22572 /* These tags always have simple identifiers already; no need
22573 to canonicalize them. */
22574 return DW_STRING (attr);
22576 case DW_TAG_namespace:
22577 if (attr != NULL && DW_STRING (attr) != NULL)
22578 return DW_STRING (attr);
22579 return CP_ANONYMOUS_NAMESPACE_STR;
22581 case DW_TAG_class_type:
22582 case DW_TAG_interface_type:
22583 case DW_TAG_structure_type:
22584 case DW_TAG_union_type:
22585 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22586 structures or unions. These were of the form "._%d" in GCC 4.1,
22587 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22588 and GCC 4.4. We work around this problem by ignoring these. */
22589 if (attr && DW_STRING (attr)
22590 && (startswith (DW_STRING (attr), "._")
22591 || startswith (DW_STRING (attr), "<anonymous")))
22594 /* GCC might emit a nameless typedef that has a linkage name. See
22595 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22596 if (!attr || DW_STRING (attr) == NULL)
22598 char *demangled = NULL;
22600 attr = dw2_linkage_name_attr (die, cu);
22601 if (attr == NULL || DW_STRING (attr) == NULL)
22604 /* Avoid demangling DW_STRING (attr) the second time on a second
22605 call for the same DIE. */
22606 if (!DW_STRING_IS_CANONICAL (attr))
22607 demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
22613 /* FIXME: we already did this for the partial symbol... */
22616 obstack_copy0 (&objfile->per_bfd->storage_obstack,
22617 demangled, strlen (demangled)));
22618 DW_STRING_IS_CANONICAL (attr) = 1;
22621 /* Strip any leading namespaces/classes, keep only the base name.
22622 DW_AT_name for named DIEs does not contain the prefixes. */
22623 base = strrchr (DW_STRING (attr), ':');
22624 if (base && base > DW_STRING (attr) && base[-1] == ':')
22627 return DW_STRING (attr);
22636 if (!DW_STRING_IS_CANONICAL (attr))
22639 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
22640 &objfile->per_bfd->storage_obstack);
22641 DW_STRING_IS_CANONICAL (attr) = 1;
22643 return DW_STRING (attr);
22646 /* Return the die that this die in an extension of, or NULL if there
22647 is none. *EXT_CU is the CU containing DIE on input, and the CU
22648 containing the return value on output. */
22650 static struct die_info *
22651 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
22653 struct attribute *attr;
22655 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
22659 return follow_die_ref (die, attr, ext_cu);
22662 /* Convert a DIE tag into its string name. */
22664 static const char *
22665 dwarf_tag_name (unsigned tag)
22667 const char *name = get_DW_TAG_name (tag);
22670 return "DW_TAG_<unknown>";
22675 /* Convert a DWARF attribute code into its string name. */
22677 static const char *
22678 dwarf_attr_name (unsigned attr)
22682 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22683 if (attr == DW_AT_MIPS_fde)
22684 return "DW_AT_MIPS_fde";
22686 if (attr == DW_AT_HP_block_index)
22687 return "DW_AT_HP_block_index";
22690 name = get_DW_AT_name (attr);
22693 return "DW_AT_<unknown>";
22698 /* Convert a DWARF value form code into its string name. */
22700 static const char *
22701 dwarf_form_name (unsigned form)
22703 const char *name = get_DW_FORM_name (form);
22706 return "DW_FORM_<unknown>";
22711 static const char *
22712 dwarf_bool_name (unsigned mybool)
22720 /* Convert a DWARF type code into its string name. */
22722 static const char *
22723 dwarf_type_encoding_name (unsigned enc)
22725 const char *name = get_DW_ATE_name (enc);
22728 return "DW_ATE_<unknown>";
22734 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
22738 print_spaces (indent, f);
22739 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset %s)\n",
22740 dwarf_tag_name (die->tag), die->abbrev,
22741 sect_offset_str (die->sect_off));
22743 if (die->parent != NULL)
22745 print_spaces (indent, f);
22746 fprintf_unfiltered (f, " parent at offset: %s\n",
22747 sect_offset_str (die->parent->sect_off));
22750 print_spaces (indent, f);
22751 fprintf_unfiltered (f, " has children: %s\n",
22752 dwarf_bool_name (die->child != NULL));
22754 print_spaces (indent, f);
22755 fprintf_unfiltered (f, " attributes:\n");
22757 for (i = 0; i < die->num_attrs; ++i)
22759 print_spaces (indent, f);
22760 fprintf_unfiltered (f, " %s (%s) ",
22761 dwarf_attr_name (die->attrs[i].name),
22762 dwarf_form_name (die->attrs[i].form));
22764 switch (die->attrs[i].form)
22767 case DW_FORM_GNU_addr_index:
22768 fprintf_unfiltered (f, "address: ");
22769 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
22771 case DW_FORM_block2:
22772 case DW_FORM_block4:
22773 case DW_FORM_block:
22774 case DW_FORM_block1:
22775 fprintf_unfiltered (f, "block: size %s",
22776 pulongest (DW_BLOCK (&die->attrs[i])->size));
22778 case DW_FORM_exprloc:
22779 fprintf_unfiltered (f, "expression: size %s",
22780 pulongest (DW_BLOCK (&die->attrs[i])->size));
22782 case DW_FORM_data16:
22783 fprintf_unfiltered (f, "constant of 16 bytes");
22785 case DW_FORM_ref_addr:
22786 fprintf_unfiltered (f, "ref address: ");
22787 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22789 case DW_FORM_GNU_ref_alt:
22790 fprintf_unfiltered (f, "alt ref address: ");
22791 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22797 case DW_FORM_ref_udata:
22798 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
22799 (long) (DW_UNSND (&die->attrs[i])));
22801 case DW_FORM_data1:
22802 case DW_FORM_data2:
22803 case DW_FORM_data4:
22804 case DW_FORM_data8:
22805 case DW_FORM_udata:
22806 case DW_FORM_sdata:
22807 fprintf_unfiltered (f, "constant: %s",
22808 pulongest (DW_UNSND (&die->attrs[i])));
22810 case DW_FORM_sec_offset:
22811 fprintf_unfiltered (f, "section offset: %s",
22812 pulongest (DW_UNSND (&die->attrs[i])));
22814 case DW_FORM_ref_sig8:
22815 fprintf_unfiltered (f, "signature: %s",
22816 hex_string (DW_SIGNATURE (&die->attrs[i])));
22818 case DW_FORM_string:
22820 case DW_FORM_line_strp:
22821 case DW_FORM_GNU_str_index:
22822 case DW_FORM_GNU_strp_alt:
22823 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
22824 DW_STRING (&die->attrs[i])
22825 ? DW_STRING (&die->attrs[i]) : "",
22826 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
22829 if (DW_UNSND (&die->attrs[i]))
22830 fprintf_unfiltered (f, "flag: TRUE");
22832 fprintf_unfiltered (f, "flag: FALSE");
22834 case DW_FORM_flag_present:
22835 fprintf_unfiltered (f, "flag: TRUE");
22837 case DW_FORM_indirect:
22838 /* The reader will have reduced the indirect form to
22839 the "base form" so this form should not occur. */
22840 fprintf_unfiltered (f,
22841 "unexpected attribute form: DW_FORM_indirect");
22843 case DW_FORM_implicit_const:
22844 fprintf_unfiltered (f, "constant: %s",
22845 plongest (DW_SND (&die->attrs[i])));
22848 fprintf_unfiltered (f, "unsupported attribute form: %d.",
22849 die->attrs[i].form);
22852 fprintf_unfiltered (f, "\n");
22857 dump_die_for_error (struct die_info *die)
22859 dump_die_shallow (gdb_stderr, 0, die);
22863 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
22865 int indent = level * 4;
22867 gdb_assert (die != NULL);
22869 if (level >= max_level)
22872 dump_die_shallow (f, indent, die);
22874 if (die->child != NULL)
22876 print_spaces (indent, f);
22877 fprintf_unfiltered (f, " Children:");
22878 if (level + 1 < max_level)
22880 fprintf_unfiltered (f, "\n");
22881 dump_die_1 (f, level + 1, max_level, die->child);
22885 fprintf_unfiltered (f,
22886 " [not printed, max nesting level reached]\n");
22890 if (die->sibling != NULL && level > 0)
22892 dump_die_1 (f, level, max_level, die->sibling);
22896 /* This is called from the pdie macro in gdbinit.in.
22897 It's not static so gcc will keep a copy callable from gdb. */
22900 dump_die (struct die_info *die, int max_level)
22902 dump_die_1 (gdb_stdlog, 0, max_level, die);
22906 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
22910 slot = htab_find_slot_with_hash (cu->die_hash, die,
22911 to_underlying (die->sect_off),
22917 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
22921 dwarf2_get_ref_die_offset (const struct attribute *attr)
22923 if (attr_form_is_ref (attr))
22924 return (sect_offset) DW_UNSND (attr);
22926 complaint (_("unsupported die ref attribute form: '%s'"),
22927 dwarf_form_name (attr->form));
22931 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
22932 * the value held by the attribute is not constant. */
22935 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
22937 if (attr->form == DW_FORM_sdata || attr->form == DW_FORM_implicit_const)
22938 return DW_SND (attr);
22939 else if (attr->form == DW_FORM_udata
22940 || attr->form == DW_FORM_data1
22941 || attr->form == DW_FORM_data2
22942 || attr->form == DW_FORM_data4
22943 || attr->form == DW_FORM_data8)
22944 return DW_UNSND (attr);
22947 /* For DW_FORM_data16 see attr_form_is_constant. */
22948 complaint (_("Attribute value is not a constant (%s)"),
22949 dwarf_form_name (attr->form));
22950 return default_value;
22954 /* Follow reference or signature attribute ATTR of SRC_DIE.
22955 On entry *REF_CU is the CU of SRC_DIE.
22956 On exit *REF_CU is the CU of the result. */
22958 static struct die_info *
22959 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
22960 struct dwarf2_cu **ref_cu)
22962 struct die_info *die;
22964 if (attr_form_is_ref (attr))
22965 die = follow_die_ref (src_die, attr, ref_cu);
22966 else if (attr->form == DW_FORM_ref_sig8)
22967 die = follow_die_sig (src_die, attr, ref_cu);
22970 dump_die_for_error (src_die);
22971 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
22972 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
22978 /* Follow reference OFFSET.
22979 On entry *REF_CU is the CU of the source die referencing OFFSET.
22980 On exit *REF_CU is the CU of the result.
22981 Returns NULL if OFFSET is invalid. */
22983 static struct die_info *
22984 follow_die_offset (sect_offset sect_off, int offset_in_dwz,
22985 struct dwarf2_cu **ref_cu)
22987 struct die_info temp_die;
22988 struct dwarf2_cu *target_cu, *cu = *ref_cu;
22989 struct dwarf2_per_objfile *dwarf2_per_objfile
22990 = cu->per_cu->dwarf2_per_objfile;
22992 gdb_assert (cu->per_cu != NULL);
22996 if (cu->per_cu->is_debug_types)
22998 /* .debug_types CUs cannot reference anything outside their CU.
22999 If they need to, they have to reference a signatured type via
23000 DW_FORM_ref_sig8. */
23001 if (!offset_in_cu_p (&cu->header, sect_off))
23004 else if (offset_in_dwz != cu->per_cu->is_dwz
23005 || !offset_in_cu_p (&cu->header, sect_off))
23007 struct dwarf2_per_cu_data *per_cu;
23009 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
23010 dwarf2_per_objfile);
23012 /* If necessary, add it to the queue and load its DIEs. */
23013 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
23014 load_full_comp_unit (per_cu, false, cu->language);
23016 target_cu = per_cu->cu;
23018 else if (cu->dies == NULL)
23020 /* We're loading full DIEs during partial symbol reading. */
23021 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
23022 load_full_comp_unit (cu->per_cu, false, language_minimal);
23025 *ref_cu = target_cu;
23026 temp_die.sect_off = sect_off;
23027 return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
23029 to_underlying (sect_off));
23032 /* Follow reference attribute ATTR of SRC_DIE.
23033 On entry *REF_CU is the CU of SRC_DIE.
23034 On exit *REF_CU is the CU of the result. */
23036 static struct die_info *
23037 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
23038 struct dwarf2_cu **ref_cu)
23040 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
23041 struct dwarf2_cu *cu = *ref_cu;
23042 struct die_info *die;
23044 die = follow_die_offset (sect_off,
23045 (attr->form == DW_FORM_GNU_ref_alt
23046 || cu->per_cu->is_dwz),
23049 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23050 "at %s [in module %s]"),
23051 sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
23052 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
23057 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23058 Returned value is intended for DW_OP_call*. Returned
23059 dwarf2_locexpr_baton->data has lifetime of
23060 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
23062 struct dwarf2_locexpr_baton
23063 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
23064 struct dwarf2_per_cu_data *per_cu,
23065 CORE_ADDR (*get_frame_pc) (void *baton),
23066 void *baton, bool resolve_abstract_p)
23068 struct dwarf2_cu *cu;
23069 struct die_info *die;
23070 struct attribute *attr;
23071 struct dwarf2_locexpr_baton retval;
23072 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
23073 struct objfile *objfile = dwarf2_per_objfile->objfile;
23075 if (per_cu->cu == NULL)
23076 load_cu (per_cu, false);
23080 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23081 Instead just throw an error, not much else we can do. */
23082 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23083 sect_offset_str (sect_off), objfile_name (objfile));
23086 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23088 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23089 sect_offset_str (sect_off), objfile_name (objfile));
23091 attr = dwarf2_attr (die, DW_AT_location, cu);
23092 if (!attr && resolve_abstract_p
23093 && (dwarf2_per_objfile->abstract_to_concrete.find (die)
23094 != dwarf2_per_objfile->abstract_to_concrete.end ()))
23096 CORE_ADDR pc = (*get_frame_pc) (baton);
23098 for (const auto &cand : dwarf2_per_objfile->abstract_to_concrete[die])
23101 || cand->parent->tag != DW_TAG_subprogram)
23104 CORE_ADDR pc_low, pc_high;
23105 get_scope_pc_bounds (cand->parent, &pc_low, &pc_high, cu);
23106 if (pc_low == ((CORE_ADDR) -1)
23107 || !(pc_low <= pc && pc < pc_high))
23111 attr = dwarf2_attr (die, DW_AT_location, cu);
23118 /* DWARF: "If there is no such attribute, then there is no effect.".
23119 DATA is ignored if SIZE is 0. */
23121 retval.data = NULL;
23124 else if (attr_form_is_section_offset (attr))
23126 struct dwarf2_loclist_baton loclist_baton;
23127 CORE_ADDR pc = (*get_frame_pc) (baton);
23130 fill_in_loclist_baton (cu, &loclist_baton, attr);
23132 retval.data = dwarf2_find_location_expression (&loclist_baton,
23134 retval.size = size;
23138 if (!attr_form_is_block (attr))
23139 error (_("Dwarf Error: DIE at %s referenced in module %s "
23140 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23141 sect_offset_str (sect_off), objfile_name (objfile));
23143 retval.data = DW_BLOCK (attr)->data;
23144 retval.size = DW_BLOCK (attr)->size;
23146 retval.per_cu = cu->per_cu;
23148 age_cached_comp_units (dwarf2_per_objfile);
23153 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23156 struct dwarf2_locexpr_baton
23157 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
23158 struct dwarf2_per_cu_data *per_cu,
23159 CORE_ADDR (*get_frame_pc) (void *baton),
23162 sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
23164 return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
23167 /* Write a constant of a given type as target-ordered bytes into
23170 static const gdb_byte *
23171 write_constant_as_bytes (struct obstack *obstack,
23172 enum bfd_endian byte_order,
23179 *len = TYPE_LENGTH (type);
23180 result = (gdb_byte *) obstack_alloc (obstack, *len);
23181 store_unsigned_integer (result, *len, byte_order, value);
23186 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23187 pointer to the constant bytes and set LEN to the length of the
23188 data. If memory is needed, allocate it on OBSTACK. If the DIE
23189 does not have a DW_AT_const_value, return NULL. */
23192 dwarf2_fetch_constant_bytes (sect_offset sect_off,
23193 struct dwarf2_per_cu_data *per_cu,
23194 struct obstack *obstack,
23197 struct dwarf2_cu *cu;
23198 struct die_info *die;
23199 struct attribute *attr;
23200 const gdb_byte *result = NULL;
23203 enum bfd_endian byte_order;
23204 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23206 if (per_cu->cu == NULL)
23207 load_cu (per_cu, false);
23211 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23212 Instead just throw an error, not much else we can do. */
23213 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23214 sect_offset_str (sect_off), objfile_name (objfile));
23217 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23219 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23220 sect_offset_str (sect_off), objfile_name (objfile));
23222 attr = dwarf2_attr (die, DW_AT_const_value, cu);
23226 byte_order = (bfd_big_endian (objfile->obfd)
23227 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
23229 switch (attr->form)
23232 case DW_FORM_GNU_addr_index:
23236 *len = cu->header.addr_size;
23237 tem = (gdb_byte *) obstack_alloc (obstack, *len);
23238 store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
23242 case DW_FORM_string:
23244 case DW_FORM_GNU_str_index:
23245 case DW_FORM_GNU_strp_alt:
23246 /* DW_STRING is already allocated on the objfile obstack, point
23248 result = (const gdb_byte *) DW_STRING (attr);
23249 *len = strlen (DW_STRING (attr));
23251 case DW_FORM_block1:
23252 case DW_FORM_block2:
23253 case DW_FORM_block4:
23254 case DW_FORM_block:
23255 case DW_FORM_exprloc:
23256 case DW_FORM_data16:
23257 result = DW_BLOCK (attr)->data;
23258 *len = DW_BLOCK (attr)->size;
23261 /* The DW_AT_const_value attributes are supposed to carry the
23262 symbol's value "represented as it would be on the target
23263 architecture." By the time we get here, it's already been
23264 converted to host endianness, so we just need to sign- or
23265 zero-extend it as appropriate. */
23266 case DW_FORM_data1:
23267 type = die_type (die, cu);
23268 result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
23269 if (result == NULL)
23270 result = write_constant_as_bytes (obstack, byte_order,
23273 case DW_FORM_data2:
23274 type = die_type (die, cu);
23275 result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
23276 if (result == NULL)
23277 result = write_constant_as_bytes (obstack, byte_order,
23280 case DW_FORM_data4:
23281 type = die_type (die, cu);
23282 result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
23283 if (result == NULL)
23284 result = write_constant_as_bytes (obstack, byte_order,
23287 case DW_FORM_data8:
23288 type = die_type (die, cu);
23289 result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
23290 if (result == NULL)
23291 result = write_constant_as_bytes (obstack, byte_order,
23295 case DW_FORM_sdata:
23296 case DW_FORM_implicit_const:
23297 type = die_type (die, cu);
23298 result = write_constant_as_bytes (obstack, byte_order,
23299 type, DW_SND (attr), len);
23302 case DW_FORM_udata:
23303 type = die_type (die, cu);
23304 result = write_constant_as_bytes (obstack, byte_order,
23305 type, DW_UNSND (attr), len);
23309 complaint (_("unsupported const value attribute form: '%s'"),
23310 dwarf_form_name (attr->form));
23317 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23318 valid type for this die is found. */
23321 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
23322 struct dwarf2_per_cu_data *per_cu)
23324 struct dwarf2_cu *cu;
23325 struct die_info *die;
23327 if (per_cu->cu == NULL)
23328 load_cu (per_cu, false);
23333 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23337 return die_type (die, cu);
23340 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23344 dwarf2_get_die_type (cu_offset die_offset,
23345 struct dwarf2_per_cu_data *per_cu)
23347 sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
23348 return get_die_type_at_offset (die_offset_sect, per_cu);
23351 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23352 On entry *REF_CU is the CU of SRC_DIE.
23353 On exit *REF_CU is the CU of the result.
23354 Returns NULL if the referenced DIE isn't found. */
23356 static struct die_info *
23357 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
23358 struct dwarf2_cu **ref_cu)
23360 struct die_info temp_die;
23361 struct dwarf2_cu *sig_cu;
23362 struct die_info *die;
23364 /* While it might be nice to assert sig_type->type == NULL here,
23365 we can get here for DW_AT_imported_declaration where we need
23366 the DIE not the type. */
23368 /* If necessary, add it to the queue and load its DIEs. */
23370 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
23371 read_signatured_type (sig_type);
23373 sig_cu = sig_type->per_cu.cu;
23374 gdb_assert (sig_cu != NULL);
23375 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
23376 temp_die.sect_off = sig_type->type_offset_in_section;
23377 die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
23378 to_underlying (temp_die.sect_off));
23381 struct dwarf2_per_objfile *dwarf2_per_objfile
23382 = (*ref_cu)->per_cu->dwarf2_per_objfile;
23384 /* For .gdb_index version 7 keep track of included TUs.
23385 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23386 if (dwarf2_per_objfile->index_table != NULL
23387 && dwarf2_per_objfile->index_table->version <= 7)
23389 VEC_safe_push (dwarf2_per_cu_ptr,
23390 (*ref_cu)->per_cu->imported_symtabs,
23401 /* Follow signatured type referenced by ATTR in SRC_DIE.
23402 On entry *REF_CU is the CU of SRC_DIE.
23403 On exit *REF_CU is the CU of the result.
23404 The result is the DIE of the type.
23405 If the referenced type cannot be found an error is thrown. */
23407 static struct die_info *
23408 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
23409 struct dwarf2_cu **ref_cu)
23411 ULONGEST signature = DW_SIGNATURE (attr);
23412 struct signatured_type *sig_type;
23413 struct die_info *die;
23415 gdb_assert (attr->form == DW_FORM_ref_sig8);
23417 sig_type = lookup_signatured_type (*ref_cu, signature);
23418 /* sig_type will be NULL if the signatured type is missing from
23420 if (sig_type == NULL)
23422 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23423 " from DIE at %s [in module %s]"),
23424 hex_string (signature), sect_offset_str (src_die->sect_off),
23425 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23428 die = follow_die_sig_1 (src_die, sig_type, ref_cu);
23431 dump_die_for_error (src_die);
23432 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23433 " from DIE at %s [in module %s]"),
23434 hex_string (signature), sect_offset_str (src_die->sect_off),
23435 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23441 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23442 reading in and processing the type unit if necessary. */
23444 static struct type *
23445 get_signatured_type (struct die_info *die, ULONGEST signature,
23446 struct dwarf2_cu *cu)
23448 struct dwarf2_per_objfile *dwarf2_per_objfile
23449 = cu->per_cu->dwarf2_per_objfile;
23450 struct signatured_type *sig_type;
23451 struct dwarf2_cu *type_cu;
23452 struct die_info *type_die;
23455 sig_type = lookup_signatured_type (cu, signature);
23456 /* sig_type will be NULL if the signatured type is missing from
23458 if (sig_type == NULL)
23460 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23461 " from DIE at %s [in module %s]"),
23462 hex_string (signature), sect_offset_str (die->sect_off),
23463 objfile_name (dwarf2_per_objfile->objfile));
23464 return build_error_marker_type (cu, die);
23467 /* If we already know the type we're done. */
23468 if (sig_type->type != NULL)
23469 return sig_type->type;
23472 type_die = follow_die_sig_1 (die, sig_type, &type_cu);
23473 if (type_die != NULL)
23475 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23476 is created. This is important, for example, because for c++ classes
23477 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23478 type = read_type_die (type_die, type_cu);
23481 complaint (_("Dwarf Error: Cannot build signatured type %s"
23482 " referenced from DIE at %s [in module %s]"),
23483 hex_string (signature), sect_offset_str (die->sect_off),
23484 objfile_name (dwarf2_per_objfile->objfile));
23485 type = build_error_marker_type (cu, die);
23490 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23491 " from DIE at %s [in module %s]"),
23492 hex_string (signature), sect_offset_str (die->sect_off),
23493 objfile_name (dwarf2_per_objfile->objfile));
23494 type = build_error_marker_type (cu, die);
23496 sig_type->type = type;
23501 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23502 reading in and processing the type unit if necessary. */
23504 static struct type *
23505 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
23506 struct dwarf2_cu *cu) /* ARI: editCase function */
23508 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23509 if (attr_form_is_ref (attr))
23511 struct dwarf2_cu *type_cu = cu;
23512 struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
23514 return read_type_die (type_die, type_cu);
23516 else if (attr->form == DW_FORM_ref_sig8)
23518 return get_signatured_type (die, DW_SIGNATURE (attr), cu);
23522 struct dwarf2_per_objfile *dwarf2_per_objfile
23523 = cu->per_cu->dwarf2_per_objfile;
23525 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23526 " at %s [in module %s]"),
23527 dwarf_form_name (attr->form), sect_offset_str (die->sect_off),
23528 objfile_name (dwarf2_per_objfile->objfile));
23529 return build_error_marker_type (cu, die);
23533 /* Load the DIEs associated with type unit PER_CU into memory. */
23536 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
23538 struct signatured_type *sig_type;
23540 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23541 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
23543 /* We have the per_cu, but we need the signatured_type.
23544 Fortunately this is an easy translation. */
23545 gdb_assert (per_cu->is_debug_types);
23546 sig_type = (struct signatured_type *) per_cu;
23548 gdb_assert (per_cu->cu == NULL);
23550 read_signatured_type (sig_type);
23552 gdb_assert (per_cu->cu != NULL);
23555 /* die_reader_func for read_signatured_type.
23556 This is identical to load_full_comp_unit_reader,
23557 but is kept separate for now. */
23560 read_signatured_type_reader (const struct die_reader_specs *reader,
23561 const gdb_byte *info_ptr,
23562 struct die_info *comp_unit_die,
23566 struct dwarf2_cu *cu = reader->cu;
23568 gdb_assert (cu->die_hash == NULL);
23570 htab_create_alloc_ex (cu->header.length / 12,
23574 &cu->comp_unit_obstack,
23575 hashtab_obstack_allocate,
23576 dummy_obstack_deallocate);
23579 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
23580 &info_ptr, comp_unit_die);
23581 cu->dies = comp_unit_die;
23582 /* comp_unit_die is not stored in die_hash, no need. */
23584 /* We try not to read any attributes in this function, because not
23585 all CUs needed for references have been loaded yet, and symbol
23586 table processing isn't initialized. But we have to set the CU language,
23587 or we won't be able to build types correctly.
23588 Similarly, if we do not read the producer, we can not apply
23589 producer-specific interpretation. */
23590 prepare_one_comp_unit (cu, cu->dies, language_minimal);
23593 /* Read in a signatured type and build its CU and DIEs.
23594 If the type is a stub for the real type in a DWO file,
23595 read in the real type from the DWO file as well. */
23598 read_signatured_type (struct signatured_type *sig_type)
23600 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
23602 gdb_assert (per_cu->is_debug_types);
23603 gdb_assert (per_cu->cu == NULL);
23605 init_cutu_and_read_dies (per_cu, NULL, 0, 1, false,
23606 read_signatured_type_reader, NULL);
23607 sig_type->per_cu.tu_read = 1;
23610 /* Decode simple location descriptions.
23611 Given a pointer to a dwarf block that defines a location, compute
23612 the location and return the value.
23614 NOTE drow/2003-11-18: This function is called in two situations
23615 now: for the address of static or global variables (partial symbols
23616 only) and for offsets into structures which are expected to be
23617 (more or less) constant. The partial symbol case should go away,
23618 and only the constant case should remain. That will let this
23619 function complain more accurately. A few special modes are allowed
23620 without complaint for global variables (for instance, global
23621 register values and thread-local values).
23623 A location description containing no operations indicates that the
23624 object is optimized out. The return value is 0 for that case.
23625 FIXME drow/2003-11-16: No callers check for this case any more; soon all
23626 callers will only want a very basic result and this can become a
23629 Note that stack[0] is unused except as a default error return. */
23632 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
23634 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
23636 size_t size = blk->size;
23637 const gdb_byte *data = blk->data;
23638 CORE_ADDR stack[64];
23640 unsigned int bytes_read, unsnd;
23646 stack[++stacki] = 0;
23685 stack[++stacki] = op - DW_OP_lit0;
23720 stack[++stacki] = op - DW_OP_reg0;
23722 dwarf2_complex_location_expr_complaint ();
23726 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
23728 stack[++stacki] = unsnd;
23730 dwarf2_complex_location_expr_complaint ();
23734 stack[++stacki] = read_address (objfile->obfd, &data[i],
23739 case DW_OP_const1u:
23740 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
23744 case DW_OP_const1s:
23745 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
23749 case DW_OP_const2u:
23750 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
23754 case DW_OP_const2s:
23755 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
23759 case DW_OP_const4u:
23760 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
23764 case DW_OP_const4s:
23765 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
23769 case DW_OP_const8u:
23770 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
23775 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
23781 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
23786 stack[stacki + 1] = stack[stacki];
23791 stack[stacki - 1] += stack[stacki];
23795 case DW_OP_plus_uconst:
23796 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
23802 stack[stacki - 1] -= stack[stacki];
23807 /* If we're not the last op, then we definitely can't encode
23808 this using GDB's address_class enum. This is valid for partial
23809 global symbols, although the variable's address will be bogus
23812 dwarf2_complex_location_expr_complaint ();
23815 case DW_OP_GNU_push_tls_address:
23816 case DW_OP_form_tls_address:
23817 /* The top of the stack has the offset from the beginning
23818 of the thread control block at which the variable is located. */
23819 /* Nothing should follow this operator, so the top of stack would
23821 /* This is valid for partial global symbols, but the variable's
23822 address will be bogus in the psymtab. Make it always at least
23823 non-zero to not look as a variable garbage collected by linker
23824 which have DW_OP_addr 0. */
23826 dwarf2_complex_location_expr_complaint ();
23830 case DW_OP_GNU_uninit:
23833 case DW_OP_GNU_addr_index:
23834 case DW_OP_GNU_const_index:
23835 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
23842 const char *name = get_DW_OP_name (op);
23845 complaint (_("unsupported stack op: '%s'"),
23848 complaint (_("unsupported stack op: '%02x'"),
23852 return (stack[stacki]);
23855 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23856 outside of the allocated space. Also enforce minimum>0. */
23857 if (stacki >= ARRAY_SIZE (stack) - 1)
23859 complaint (_("location description stack overflow"));
23865 complaint (_("location description stack underflow"));
23869 return (stack[stacki]);
23872 /* memory allocation interface */
23874 static struct dwarf_block *
23875 dwarf_alloc_block (struct dwarf2_cu *cu)
23877 return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
23880 static struct die_info *
23881 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
23883 struct die_info *die;
23884 size_t size = sizeof (struct die_info);
23887 size += (num_attrs - 1) * sizeof (struct attribute);
23889 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
23890 memset (die, 0, sizeof (struct die_info));
23895 /* Macro support. */
23897 /* Return file name relative to the compilation directory of file number I in
23898 *LH's file name table. The result is allocated using xmalloc; the caller is
23899 responsible for freeing it. */
23902 file_file_name (int file, struct line_header *lh)
23904 /* Is the file number a valid index into the line header's file name
23905 table? Remember that file numbers start with one, not zero. */
23906 if (1 <= file && file <= lh->file_names.size ())
23908 const file_entry &fe = lh->file_names[file - 1];
23910 if (!IS_ABSOLUTE_PATH (fe.name))
23912 const char *dir = fe.include_dir (lh);
23914 return concat (dir, SLASH_STRING, fe.name, (char *) NULL);
23916 return xstrdup (fe.name);
23920 /* The compiler produced a bogus file number. We can at least
23921 record the macro definitions made in the file, even if we
23922 won't be able to find the file by name. */
23923 char fake_name[80];
23925 xsnprintf (fake_name, sizeof (fake_name),
23926 "<bad macro file number %d>", file);
23928 complaint (_("bad file number in macro information (%d)"),
23931 return xstrdup (fake_name);
23935 /* Return the full name of file number I in *LH's file name table.
23936 Use COMP_DIR as the name of the current directory of the
23937 compilation. The result is allocated using xmalloc; the caller is
23938 responsible for freeing it. */
23940 file_full_name (int file, struct line_header *lh, const char *comp_dir)
23942 /* Is the file number a valid index into the line header's file name
23943 table? Remember that file numbers start with one, not zero. */
23944 if (1 <= file && file <= lh->file_names.size ())
23946 char *relative = file_file_name (file, lh);
23948 if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
23950 return reconcat (relative, comp_dir, SLASH_STRING,
23951 relative, (char *) NULL);
23954 return file_file_name (file, lh);
23958 static struct macro_source_file *
23959 macro_start_file (struct dwarf2_cu *cu,
23960 int file, int line,
23961 struct macro_source_file *current_file,
23962 struct line_header *lh)
23964 /* File name relative to the compilation directory of this source file. */
23965 char *file_name = file_file_name (file, lh);
23967 if (! current_file)
23969 /* Note: We don't create a macro table for this compilation unit
23970 at all until we actually get a filename. */
23971 struct macro_table *macro_table = cu->builder->get_macro_table ();
23973 /* If we have no current file, then this must be the start_file
23974 directive for the compilation unit's main source file. */
23975 current_file = macro_set_main (macro_table, file_name);
23976 macro_define_special (macro_table);
23979 current_file = macro_include (current_file, line, file_name);
23983 return current_file;
23986 static const char *
23987 consume_improper_spaces (const char *p, const char *body)
23991 complaint (_("macro definition contains spaces "
23992 "in formal argument list:\n`%s'"),
24004 parse_macro_definition (struct macro_source_file *file, int line,
24009 /* The body string takes one of two forms. For object-like macro
24010 definitions, it should be:
24012 <macro name> " " <definition>
24014 For function-like macro definitions, it should be:
24016 <macro name> "() " <definition>
24018 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24020 Spaces may appear only where explicitly indicated, and in the
24023 The Dwarf 2 spec says that an object-like macro's name is always
24024 followed by a space, but versions of GCC around March 2002 omit
24025 the space when the macro's definition is the empty string.
24027 The Dwarf 2 spec says that there should be no spaces between the
24028 formal arguments in a function-like macro's formal argument list,
24029 but versions of GCC around March 2002 include spaces after the
24033 /* Find the extent of the macro name. The macro name is terminated
24034 by either a space or null character (for an object-like macro) or
24035 an opening paren (for a function-like macro). */
24036 for (p = body; *p; p++)
24037 if (*p == ' ' || *p == '(')
24040 if (*p == ' ' || *p == '\0')
24042 /* It's an object-like macro. */
24043 int name_len = p - body;
24044 char *name = savestring (body, name_len);
24045 const char *replacement;
24048 replacement = body + name_len + 1;
24051 dwarf2_macro_malformed_definition_complaint (body);
24052 replacement = body + name_len;
24055 macro_define_object (file, line, name, replacement);
24059 else if (*p == '(')
24061 /* It's a function-like macro. */
24062 char *name = savestring (body, p - body);
24065 char **argv = XNEWVEC (char *, argv_size);
24069 p = consume_improper_spaces (p, body);
24071 /* Parse the formal argument list. */
24072 while (*p && *p != ')')
24074 /* Find the extent of the current argument name. */
24075 const char *arg_start = p;
24077 while (*p && *p != ',' && *p != ')' && *p != ' ')
24080 if (! *p || p == arg_start)
24081 dwarf2_macro_malformed_definition_complaint (body);
24084 /* Make sure argv has room for the new argument. */
24085 if (argc >= argv_size)
24088 argv = XRESIZEVEC (char *, argv, argv_size);
24091 argv[argc++] = savestring (arg_start, p - arg_start);
24094 p = consume_improper_spaces (p, body);
24096 /* Consume the comma, if present. */
24101 p = consume_improper_spaces (p, body);
24110 /* Perfectly formed definition, no complaints. */
24111 macro_define_function (file, line, name,
24112 argc, (const char **) argv,
24114 else if (*p == '\0')
24116 /* Complain, but do define it. */
24117 dwarf2_macro_malformed_definition_complaint (body);
24118 macro_define_function (file, line, name,
24119 argc, (const char **) argv,
24123 /* Just complain. */
24124 dwarf2_macro_malformed_definition_complaint (body);
24127 /* Just complain. */
24128 dwarf2_macro_malformed_definition_complaint (body);
24134 for (i = 0; i < argc; i++)
24140 dwarf2_macro_malformed_definition_complaint (body);
24143 /* Skip some bytes from BYTES according to the form given in FORM.
24144 Returns the new pointer. */
24146 static const gdb_byte *
24147 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
24148 enum dwarf_form form,
24149 unsigned int offset_size,
24150 struct dwarf2_section_info *section)
24152 unsigned int bytes_read;
24156 case DW_FORM_data1:
24161 case DW_FORM_data2:
24165 case DW_FORM_data4:
24169 case DW_FORM_data8:
24173 case DW_FORM_data16:
24177 case DW_FORM_string:
24178 read_direct_string (abfd, bytes, &bytes_read);
24179 bytes += bytes_read;
24182 case DW_FORM_sec_offset:
24184 case DW_FORM_GNU_strp_alt:
24185 bytes += offset_size;
24188 case DW_FORM_block:
24189 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
24190 bytes += bytes_read;
24193 case DW_FORM_block1:
24194 bytes += 1 + read_1_byte (abfd, bytes);
24196 case DW_FORM_block2:
24197 bytes += 2 + read_2_bytes (abfd, bytes);
24199 case DW_FORM_block4:
24200 bytes += 4 + read_4_bytes (abfd, bytes);
24203 case DW_FORM_sdata:
24204 case DW_FORM_udata:
24205 case DW_FORM_GNU_addr_index:
24206 case DW_FORM_GNU_str_index:
24207 bytes = gdb_skip_leb128 (bytes, buffer_end);
24210 dwarf2_section_buffer_overflow_complaint (section);
24215 case DW_FORM_implicit_const:
24220 complaint (_("invalid form 0x%x in `%s'"),
24221 form, get_section_name (section));
24229 /* A helper for dwarf_decode_macros that handles skipping an unknown
24230 opcode. Returns an updated pointer to the macro data buffer; or,
24231 on error, issues a complaint and returns NULL. */
24233 static const gdb_byte *
24234 skip_unknown_opcode (unsigned int opcode,
24235 const gdb_byte **opcode_definitions,
24236 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24238 unsigned int offset_size,
24239 struct dwarf2_section_info *section)
24241 unsigned int bytes_read, i;
24243 const gdb_byte *defn;
24245 if (opcode_definitions[opcode] == NULL)
24247 complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24252 defn = opcode_definitions[opcode];
24253 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
24254 defn += bytes_read;
24256 for (i = 0; i < arg; ++i)
24258 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end,
24259 (enum dwarf_form) defn[i], offset_size,
24261 if (mac_ptr == NULL)
24263 /* skip_form_bytes already issued the complaint. */
24271 /* A helper function which parses the header of a macro section.
24272 If the macro section is the extended (for now called "GNU") type,
24273 then this updates *OFFSET_SIZE. Returns a pointer to just after
24274 the header, or issues a complaint and returns NULL on error. */
24276 static const gdb_byte *
24277 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
24279 const gdb_byte *mac_ptr,
24280 unsigned int *offset_size,
24281 int section_is_gnu)
24283 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
24285 if (section_is_gnu)
24287 unsigned int version, flags;
24289 version = read_2_bytes (abfd, mac_ptr);
24290 if (version != 4 && version != 5)
24292 complaint (_("unrecognized version `%d' in .debug_macro section"),
24298 flags = read_1_byte (abfd, mac_ptr);
24300 *offset_size = (flags & 1) ? 8 : 4;
24302 if ((flags & 2) != 0)
24303 /* We don't need the line table offset. */
24304 mac_ptr += *offset_size;
24306 /* Vendor opcode descriptions. */
24307 if ((flags & 4) != 0)
24309 unsigned int i, count;
24311 count = read_1_byte (abfd, mac_ptr);
24313 for (i = 0; i < count; ++i)
24315 unsigned int opcode, bytes_read;
24318 opcode = read_1_byte (abfd, mac_ptr);
24320 opcode_definitions[opcode] = mac_ptr;
24321 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24322 mac_ptr += bytes_read;
24331 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24332 including DW_MACRO_import. */
24335 dwarf_decode_macro_bytes (struct dwarf2_cu *cu,
24337 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24338 struct macro_source_file *current_file,
24339 struct line_header *lh,
24340 struct dwarf2_section_info *section,
24341 int section_is_gnu, int section_is_dwz,
24342 unsigned int offset_size,
24343 htab_t include_hash)
24345 struct dwarf2_per_objfile *dwarf2_per_objfile
24346 = cu->per_cu->dwarf2_per_objfile;
24347 struct objfile *objfile = dwarf2_per_objfile->objfile;
24348 enum dwarf_macro_record_type macinfo_type;
24349 int at_commandline;
24350 const gdb_byte *opcode_definitions[256];
24352 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24353 &offset_size, section_is_gnu);
24354 if (mac_ptr == NULL)
24356 /* We already issued a complaint. */
24360 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24361 GDB is still reading the definitions from command line. First
24362 DW_MACINFO_start_file will need to be ignored as it was already executed
24363 to create CURRENT_FILE for the main source holding also the command line
24364 definitions. On first met DW_MACINFO_start_file this flag is reset to
24365 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24367 at_commandline = 1;
24371 /* Do we at least have room for a macinfo type byte? */
24372 if (mac_ptr >= mac_end)
24374 dwarf2_section_buffer_overflow_complaint (section);
24378 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24381 /* Note that we rely on the fact that the corresponding GNU and
24382 DWARF constants are the same. */
24384 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24385 switch (macinfo_type)
24387 /* A zero macinfo type indicates the end of the macro
24392 case DW_MACRO_define:
24393 case DW_MACRO_undef:
24394 case DW_MACRO_define_strp:
24395 case DW_MACRO_undef_strp:
24396 case DW_MACRO_define_sup:
24397 case DW_MACRO_undef_sup:
24399 unsigned int bytes_read;
24404 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24405 mac_ptr += bytes_read;
24407 if (macinfo_type == DW_MACRO_define
24408 || macinfo_type == DW_MACRO_undef)
24410 body = read_direct_string (abfd, mac_ptr, &bytes_read);
24411 mac_ptr += bytes_read;
24415 LONGEST str_offset;
24417 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
24418 mac_ptr += offset_size;
24420 if (macinfo_type == DW_MACRO_define_sup
24421 || macinfo_type == DW_MACRO_undef_sup
24424 struct dwz_file *dwz
24425 = dwarf2_get_dwz_file (dwarf2_per_objfile);
24427 body = read_indirect_string_from_dwz (objfile,
24431 body = read_indirect_string_at_offset (dwarf2_per_objfile,
24435 is_define = (macinfo_type == DW_MACRO_define
24436 || macinfo_type == DW_MACRO_define_strp
24437 || macinfo_type == DW_MACRO_define_sup);
24438 if (! current_file)
24440 /* DWARF violation as no main source is present. */
24441 complaint (_("debug info with no main source gives macro %s "
24443 is_define ? _("definition") : _("undefinition"),
24447 if ((line == 0 && !at_commandline)
24448 || (line != 0 && at_commandline))
24449 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24450 at_commandline ? _("command-line") : _("in-file"),
24451 is_define ? _("definition") : _("undefinition"),
24452 line == 0 ? _("zero") : _("non-zero"), line, body);
24455 parse_macro_definition (current_file, line, body);
24458 gdb_assert (macinfo_type == DW_MACRO_undef
24459 || macinfo_type == DW_MACRO_undef_strp
24460 || macinfo_type == DW_MACRO_undef_sup);
24461 macro_undef (current_file, line, body);
24466 case DW_MACRO_start_file:
24468 unsigned int bytes_read;
24471 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24472 mac_ptr += bytes_read;
24473 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24474 mac_ptr += bytes_read;
24476 if ((line == 0 && !at_commandline)
24477 || (line != 0 && at_commandline))
24478 complaint (_("debug info gives source %d included "
24479 "from %s at %s line %d"),
24480 file, at_commandline ? _("command-line") : _("file"),
24481 line == 0 ? _("zero") : _("non-zero"), line);
24483 if (at_commandline)
24485 /* This DW_MACRO_start_file was executed in the
24487 at_commandline = 0;
24490 current_file = macro_start_file (cu, file, line, current_file,
24495 case DW_MACRO_end_file:
24496 if (! current_file)
24497 complaint (_("macro debug info has an unmatched "
24498 "`close_file' directive"));
24501 current_file = current_file->included_by;
24502 if (! current_file)
24504 enum dwarf_macro_record_type next_type;
24506 /* GCC circa March 2002 doesn't produce the zero
24507 type byte marking the end of the compilation
24508 unit. Complain if it's not there, but exit no
24511 /* Do we at least have room for a macinfo type byte? */
24512 if (mac_ptr >= mac_end)
24514 dwarf2_section_buffer_overflow_complaint (section);
24518 /* We don't increment mac_ptr here, so this is just
24521 = (enum dwarf_macro_record_type) read_1_byte (abfd,
24523 if (next_type != 0)
24524 complaint (_("no terminating 0-type entry for "
24525 "macros in `.debug_macinfo' section"));
24532 case DW_MACRO_import:
24533 case DW_MACRO_import_sup:
24537 bfd *include_bfd = abfd;
24538 struct dwarf2_section_info *include_section = section;
24539 const gdb_byte *include_mac_end = mac_end;
24540 int is_dwz = section_is_dwz;
24541 const gdb_byte *new_mac_ptr;
24543 offset = read_offset_1 (abfd, mac_ptr, offset_size);
24544 mac_ptr += offset_size;
24546 if (macinfo_type == DW_MACRO_import_sup)
24548 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
24550 dwarf2_read_section (objfile, &dwz->macro);
24552 include_section = &dwz->macro;
24553 include_bfd = get_section_bfd_owner (include_section);
24554 include_mac_end = dwz->macro.buffer + dwz->macro.size;
24558 new_mac_ptr = include_section->buffer + offset;
24559 slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
24563 /* This has actually happened; see
24564 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
24565 complaint (_("recursive DW_MACRO_import in "
24566 ".debug_macro section"));
24570 *slot = (void *) new_mac_ptr;
24572 dwarf_decode_macro_bytes (cu, include_bfd, new_mac_ptr,
24573 include_mac_end, current_file, lh,
24574 section, section_is_gnu, is_dwz,
24575 offset_size, include_hash);
24577 htab_remove_elt (include_hash, (void *) new_mac_ptr);
24582 case DW_MACINFO_vendor_ext:
24583 if (!section_is_gnu)
24585 unsigned int bytes_read;
24587 /* This reads the constant, but since we don't recognize
24588 any vendor extensions, we ignore it. */
24589 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24590 mac_ptr += bytes_read;
24591 read_direct_string (abfd, mac_ptr, &bytes_read);
24592 mac_ptr += bytes_read;
24594 /* We don't recognize any vendor extensions. */
24600 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24601 mac_ptr, mac_end, abfd, offset_size,
24603 if (mac_ptr == NULL)
24608 } while (macinfo_type != 0);
24612 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
24613 int section_is_gnu)
24615 struct dwarf2_per_objfile *dwarf2_per_objfile
24616 = cu->per_cu->dwarf2_per_objfile;
24617 struct objfile *objfile = dwarf2_per_objfile->objfile;
24618 struct line_header *lh = cu->line_header;
24620 const gdb_byte *mac_ptr, *mac_end;
24621 struct macro_source_file *current_file = 0;
24622 enum dwarf_macro_record_type macinfo_type;
24623 unsigned int offset_size = cu->header.offset_size;
24624 const gdb_byte *opcode_definitions[256];
24626 struct dwarf2_section_info *section;
24627 const char *section_name;
24629 if (cu->dwo_unit != NULL)
24631 if (section_is_gnu)
24633 section = &cu->dwo_unit->dwo_file->sections.macro;
24634 section_name = ".debug_macro.dwo";
24638 section = &cu->dwo_unit->dwo_file->sections.macinfo;
24639 section_name = ".debug_macinfo.dwo";
24644 if (section_is_gnu)
24646 section = &dwarf2_per_objfile->macro;
24647 section_name = ".debug_macro";
24651 section = &dwarf2_per_objfile->macinfo;
24652 section_name = ".debug_macinfo";
24656 dwarf2_read_section (objfile, section);
24657 if (section->buffer == NULL)
24659 complaint (_("missing %s section"), section_name);
24662 abfd = get_section_bfd_owner (section);
24664 /* First pass: Find the name of the base filename.
24665 This filename is needed in order to process all macros whose definition
24666 (or undefinition) comes from the command line. These macros are defined
24667 before the first DW_MACINFO_start_file entry, and yet still need to be
24668 associated to the base file.
24670 To determine the base file name, we scan the macro definitions until we
24671 reach the first DW_MACINFO_start_file entry. We then initialize
24672 CURRENT_FILE accordingly so that any macro definition found before the
24673 first DW_MACINFO_start_file can still be associated to the base file. */
24675 mac_ptr = section->buffer + offset;
24676 mac_end = section->buffer + section->size;
24678 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24679 &offset_size, section_is_gnu);
24680 if (mac_ptr == NULL)
24682 /* We already issued a complaint. */
24688 /* Do we at least have room for a macinfo type byte? */
24689 if (mac_ptr >= mac_end)
24691 /* Complaint is printed during the second pass as GDB will probably
24692 stop the first pass earlier upon finding
24693 DW_MACINFO_start_file. */
24697 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24700 /* Note that we rely on the fact that the corresponding GNU and
24701 DWARF constants are the same. */
24703 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24704 switch (macinfo_type)
24706 /* A zero macinfo type indicates the end of the macro
24711 case DW_MACRO_define:
24712 case DW_MACRO_undef:
24713 /* Only skip the data by MAC_PTR. */
24715 unsigned int bytes_read;
24717 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24718 mac_ptr += bytes_read;
24719 read_direct_string (abfd, mac_ptr, &bytes_read);
24720 mac_ptr += bytes_read;
24724 case DW_MACRO_start_file:
24726 unsigned int bytes_read;
24729 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24730 mac_ptr += bytes_read;
24731 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24732 mac_ptr += bytes_read;
24734 current_file = macro_start_file (cu, file, line, current_file, lh);
24738 case DW_MACRO_end_file:
24739 /* No data to skip by MAC_PTR. */
24742 case DW_MACRO_define_strp:
24743 case DW_MACRO_undef_strp:
24744 case DW_MACRO_define_sup:
24745 case DW_MACRO_undef_sup:
24747 unsigned int bytes_read;
24749 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24750 mac_ptr += bytes_read;
24751 mac_ptr += offset_size;
24755 case DW_MACRO_import:
24756 case DW_MACRO_import_sup:
24757 /* Note that, according to the spec, a transparent include
24758 chain cannot call DW_MACRO_start_file. So, we can just
24759 skip this opcode. */
24760 mac_ptr += offset_size;
24763 case DW_MACINFO_vendor_ext:
24764 /* Only skip the data by MAC_PTR. */
24765 if (!section_is_gnu)
24767 unsigned int bytes_read;
24769 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24770 mac_ptr += bytes_read;
24771 read_direct_string (abfd, mac_ptr, &bytes_read);
24772 mac_ptr += bytes_read;
24777 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24778 mac_ptr, mac_end, abfd, offset_size,
24780 if (mac_ptr == NULL)
24785 } while (macinfo_type != 0 && current_file == NULL);
24787 /* Second pass: Process all entries.
24789 Use the AT_COMMAND_LINE flag to determine whether we are still processing
24790 command-line macro definitions/undefinitions. This flag is unset when we
24791 reach the first DW_MACINFO_start_file entry. */
24793 htab_up include_hash (htab_create_alloc (1, htab_hash_pointer,
24795 NULL, xcalloc, xfree));
24796 mac_ptr = section->buffer + offset;
24797 slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT);
24798 *slot = (void *) mac_ptr;
24799 dwarf_decode_macro_bytes (cu, abfd, mac_ptr, mac_end,
24800 current_file, lh, section,
24801 section_is_gnu, 0, offset_size,
24802 include_hash.get ());
24805 /* Check if the attribute's form is a DW_FORM_block*
24806 if so return true else false. */
24809 attr_form_is_block (const struct attribute *attr)
24811 return (attr == NULL ? 0 :
24812 attr->form == DW_FORM_block1
24813 || attr->form == DW_FORM_block2
24814 || attr->form == DW_FORM_block4
24815 || attr->form == DW_FORM_block
24816 || attr->form == DW_FORM_exprloc);
24819 /* Return non-zero if ATTR's value is a section offset --- classes
24820 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24821 You may use DW_UNSND (attr) to retrieve such offsets.
24823 Section 7.5.4, "Attribute Encodings", explains that no attribute
24824 may have a value that belongs to more than one of these classes; it
24825 would be ambiguous if we did, because we use the same forms for all
24829 attr_form_is_section_offset (const struct attribute *attr)
24831 return (attr->form == DW_FORM_data4
24832 || attr->form == DW_FORM_data8
24833 || attr->form == DW_FORM_sec_offset);
24836 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24837 zero otherwise. When this function returns true, you can apply
24838 dwarf2_get_attr_constant_value to it.
24840 However, note that for some attributes you must check
24841 attr_form_is_section_offset before using this test. DW_FORM_data4
24842 and DW_FORM_data8 are members of both the constant class, and of
24843 the classes that contain offsets into other debug sections
24844 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
24845 that, if an attribute's can be either a constant or one of the
24846 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
24847 taken as section offsets, not constants.
24849 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
24850 cannot handle that. */
24853 attr_form_is_constant (const struct attribute *attr)
24855 switch (attr->form)
24857 case DW_FORM_sdata:
24858 case DW_FORM_udata:
24859 case DW_FORM_data1:
24860 case DW_FORM_data2:
24861 case DW_FORM_data4:
24862 case DW_FORM_data8:
24863 case DW_FORM_implicit_const:
24871 /* DW_ADDR is always stored already as sect_offset; despite for the forms
24872 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
24875 attr_form_is_ref (const struct attribute *attr)
24877 switch (attr->form)
24879 case DW_FORM_ref_addr:
24884 case DW_FORM_ref_udata:
24885 case DW_FORM_GNU_ref_alt:
24892 /* Return the .debug_loc section to use for CU.
24893 For DWO files use .debug_loc.dwo. */
24895 static struct dwarf2_section_info *
24896 cu_debug_loc_section (struct dwarf2_cu *cu)
24898 struct dwarf2_per_objfile *dwarf2_per_objfile
24899 = cu->per_cu->dwarf2_per_objfile;
24903 struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections;
24905 return cu->header.version >= 5 ? §ions->loclists : §ions->loc;
24907 return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
24908 : &dwarf2_per_objfile->loc);
24911 /* A helper function that fills in a dwarf2_loclist_baton. */
24914 fill_in_loclist_baton (struct dwarf2_cu *cu,
24915 struct dwarf2_loclist_baton *baton,
24916 const struct attribute *attr)
24918 struct dwarf2_per_objfile *dwarf2_per_objfile
24919 = cu->per_cu->dwarf2_per_objfile;
24920 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24922 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
24924 baton->per_cu = cu->per_cu;
24925 gdb_assert (baton->per_cu);
24926 /* We don't know how long the location list is, but make sure we
24927 don't run off the edge of the section. */
24928 baton->size = section->size - DW_UNSND (attr);
24929 baton->data = section->buffer + DW_UNSND (attr);
24930 baton->base_address = cu->base_address;
24931 baton->from_dwo = cu->dwo_unit != NULL;
24935 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
24936 struct dwarf2_cu *cu, int is_block)
24938 struct dwarf2_per_objfile *dwarf2_per_objfile
24939 = cu->per_cu->dwarf2_per_objfile;
24940 struct objfile *objfile = dwarf2_per_objfile->objfile;
24941 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24943 if (attr_form_is_section_offset (attr)
24944 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24945 the section. If so, fall through to the complaint in the
24947 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
24949 struct dwarf2_loclist_baton *baton;
24951 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
24953 fill_in_loclist_baton (cu, baton, attr);
24955 if (cu->base_known == 0)
24956 complaint (_("Location list used without "
24957 "specifying the CU base address."));
24959 SYMBOL_ACLASS_INDEX (sym) = (is_block
24960 ? dwarf2_loclist_block_index
24961 : dwarf2_loclist_index);
24962 SYMBOL_LOCATION_BATON (sym) = baton;
24966 struct dwarf2_locexpr_baton *baton;
24968 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
24969 baton->per_cu = cu->per_cu;
24970 gdb_assert (baton->per_cu);
24972 if (attr_form_is_block (attr))
24974 /* Note that we're just copying the block's data pointer
24975 here, not the actual data. We're still pointing into the
24976 info_buffer for SYM's objfile; right now we never release
24977 that buffer, but when we do clean up properly this may
24979 baton->size = DW_BLOCK (attr)->size;
24980 baton->data = DW_BLOCK (attr)->data;
24984 dwarf2_invalid_attrib_class_complaint ("location description",
24985 SYMBOL_NATURAL_NAME (sym));
24989 SYMBOL_ACLASS_INDEX (sym) = (is_block
24990 ? dwarf2_locexpr_block_index
24991 : dwarf2_locexpr_index);
24992 SYMBOL_LOCATION_BATON (sym) = baton;
24996 /* Return the OBJFILE associated with the compilation unit CU. If CU
24997 came from a separate debuginfo file, then the master objfile is
25001 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
25003 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25005 /* Return the master objfile, so that we can report and look up the
25006 correct file containing this variable. */
25007 if (objfile->separate_debug_objfile_backlink)
25008 objfile = objfile->separate_debug_objfile_backlink;
25013 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25014 (CU_HEADERP is unused in such case) or prepare a temporary copy at
25015 CU_HEADERP first. */
25017 static const struct comp_unit_head *
25018 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
25019 struct dwarf2_per_cu_data *per_cu)
25021 const gdb_byte *info_ptr;
25024 return &per_cu->cu->header;
25026 info_ptr = per_cu->section->buffer + to_underlying (per_cu->sect_off);
25028 memset (cu_headerp, 0, sizeof (*cu_headerp));
25029 read_comp_unit_head (cu_headerp, info_ptr, per_cu->section,
25030 rcuh_kind::COMPILE);
25035 /* Return the address size given in the compilation unit header for CU. */
25038 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
25040 struct comp_unit_head cu_header_local;
25041 const struct comp_unit_head *cu_headerp;
25043 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25045 return cu_headerp->addr_size;
25048 /* Return the offset size given in the compilation unit header for CU. */
25051 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
25053 struct comp_unit_head cu_header_local;
25054 const struct comp_unit_head *cu_headerp;
25056 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25058 return cu_headerp->offset_size;
25061 /* See its dwarf2loc.h declaration. */
25064 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
25066 struct comp_unit_head cu_header_local;
25067 const struct comp_unit_head *cu_headerp;
25069 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25071 if (cu_headerp->version == 2)
25072 return cu_headerp->addr_size;
25074 return cu_headerp->offset_size;
25077 /* Return the text offset of the CU. The returned offset comes from
25078 this CU's objfile. If this objfile came from a separate debuginfo
25079 file, then the offset may be different from the corresponding
25080 offset in the parent objfile. */
25083 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
25085 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25087 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
25090 /* Return DWARF version number of PER_CU. */
25093 dwarf2_version (struct dwarf2_per_cu_data *per_cu)
25095 return per_cu->dwarf_version;
25098 /* Locate the .debug_info compilation unit from CU's objfile which contains
25099 the DIE at OFFSET. Raises an error on failure. */
25101 static struct dwarf2_per_cu_data *
25102 dwarf2_find_containing_comp_unit (sect_offset sect_off,
25103 unsigned int offset_in_dwz,
25104 struct dwarf2_per_objfile *dwarf2_per_objfile)
25106 struct dwarf2_per_cu_data *this_cu;
25110 high = dwarf2_per_objfile->all_comp_units.size () - 1;
25113 struct dwarf2_per_cu_data *mid_cu;
25114 int mid = low + (high - low) / 2;
25116 mid_cu = dwarf2_per_objfile->all_comp_units[mid];
25117 if (mid_cu->is_dwz > offset_in_dwz
25118 || (mid_cu->is_dwz == offset_in_dwz
25119 && mid_cu->sect_off + mid_cu->length >= sect_off))
25124 gdb_assert (low == high);
25125 this_cu = dwarf2_per_objfile->all_comp_units[low];
25126 if (this_cu->is_dwz != offset_in_dwz || this_cu->sect_off > sect_off)
25128 if (low == 0 || this_cu->is_dwz != offset_in_dwz)
25129 error (_("Dwarf Error: could not find partial DIE containing "
25130 "offset %s [in module %s]"),
25131 sect_offset_str (sect_off),
25132 bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
25134 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
25136 return dwarf2_per_objfile->all_comp_units[low-1];
25140 this_cu = dwarf2_per_objfile->all_comp_units[low];
25141 if (low == dwarf2_per_objfile->all_comp_units.size () - 1
25142 && sect_off >= this_cu->sect_off + this_cu->length)
25143 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
25144 gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
25149 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25151 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data *per_cu_)
25152 : per_cu (per_cu_),
25154 has_loclist (false),
25155 checked_producer (false),
25156 producer_is_gxx_lt_4_6 (false),
25157 producer_is_gcc_lt_4_3 (false),
25158 producer_is_icc (false),
25159 producer_is_icc_lt_14 (false),
25160 producer_is_codewarrior (false),
25161 processing_has_namespace_info (false)
25166 /* Destroy a dwarf2_cu. */
25168 dwarf2_cu::~dwarf2_cu ()
25173 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25176 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
25177 enum language pretend_language)
25179 struct attribute *attr;
25181 /* Set the language we're debugging. */
25182 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
25184 set_cu_language (DW_UNSND (attr), cu);
25187 cu->language = pretend_language;
25188 cu->language_defn = language_def (cu->language);
25191 cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
25194 /* Increase the age counter on each cached compilation unit, and free
25195 any that are too old. */
25198 age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
25200 struct dwarf2_per_cu_data *per_cu, **last_chain;
25202 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
25203 per_cu = dwarf2_per_objfile->read_in_chain;
25204 while (per_cu != NULL)
25206 per_cu->cu->last_used ++;
25207 if (per_cu->cu->last_used <= dwarf_max_cache_age)
25208 dwarf2_mark (per_cu->cu);
25209 per_cu = per_cu->cu->read_in_chain;
25212 per_cu = dwarf2_per_objfile->read_in_chain;
25213 last_chain = &dwarf2_per_objfile->read_in_chain;
25214 while (per_cu != NULL)
25216 struct dwarf2_per_cu_data *next_cu;
25218 next_cu = per_cu->cu->read_in_chain;
25220 if (!per_cu->cu->mark)
25223 *last_chain = next_cu;
25226 last_chain = &per_cu->cu->read_in_chain;
25232 /* Remove a single compilation unit from the cache. */
25235 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
25237 struct dwarf2_per_cu_data *per_cu, **last_chain;
25238 struct dwarf2_per_objfile *dwarf2_per_objfile
25239 = target_per_cu->dwarf2_per_objfile;
25241 per_cu = dwarf2_per_objfile->read_in_chain;
25242 last_chain = &dwarf2_per_objfile->read_in_chain;
25243 while (per_cu != NULL)
25245 struct dwarf2_per_cu_data *next_cu;
25247 next_cu = per_cu->cu->read_in_chain;
25249 if (per_cu == target_per_cu)
25253 *last_chain = next_cu;
25257 last_chain = &per_cu->cu->read_in_chain;
25263 /* Cleanup function for the dwarf2_per_objfile data. */
25266 dwarf2_free_objfile (struct objfile *objfile, void *datum)
25268 struct dwarf2_per_objfile *dwarf2_per_objfile
25269 = static_cast<struct dwarf2_per_objfile *> (datum);
25271 delete dwarf2_per_objfile;
25274 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25275 We store these in a hash table separate from the DIEs, and preserve them
25276 when the DIEs are flushed out of cache.
25278 The CU "per_cu" pointer is needed because offset alone is not enough to
25279 uniquely identify the type. A file may have multiple .debug_types sections,
25280 or the type may come from a DWO file. Furthermore, while it's more logical
25281 to use per_cu->section+offset, with Fission the section with the data is in
25282 the DWO file but we don't know that section at the point we need it.
25283 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25284 because we can enter the lookup routine, get_die_type_at_offset, from
25285 outside this file, and thus won't necessarily have PER_CU->cu.
25286 Fortunately, PER_CU is stable for the life of the objfile. */
25288 struct dwarf2_per_cu_offset_and_type
25290 const struct dwarf2_per_cu_data *per_cu;
25291 sect_offset sect_off;
25295 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25298 per_cu_offset_and_type_hash (const void *item)
25300 const struct dwarf2_per_cu_offset_and_type *ofs
25301 = (const struct dwarf2_per_cu_offset_and_type *) item;
25303 return (uintptr_t) ofs->per_cu + to_underlying (ofs->sect_off);
25306 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25309 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
25311 const struct dwarf2_per_cu_offset_and_type *ofs_lhs
25312 = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
25313 const struct dwarf2_per_cu_offset_and_type *ofs_rhs
25314 = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
25316 return (ofs_lhs->per_cu == ofs_rhs->per_cu
25317 && ofs_lhs->sect_off == ofs_rhs->sect_off);
25320 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25321 table if necessary. For convenience, return TYPE.
25323 The DIEs reading must have careful ordering to:
25324 * Not cause infite loops trying to read in DIEs as a prerequisite for
25325 reading current DIE.
25326 * Not trying to dereference contents of still incompletely read in types
25327 while reading in other DIEs.
25328 * Enable referencing still incompletely read in types just by a pointer to
25329 the type without accessing its fields.
25331 Therefore caller should follow these rules:
25332 * Try to fetch any prerequisite types we may need to build this DIE type
25333 before building the type and calling set_die_type.
25334 * After building type call set_die_type for current DIE as soon as
25335 possible before fetching more types to complete the current type.
25336 * Make the type as complete as possible before fetching more types. */
25338 static struct type *
25339 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
25341 struct dwarf2_per_objfile *dwarf2_per_objfile
25342 = cu->per_cu->dwarf2_per_objfile;
25343 struct dwarf2_per_cu_offset_and_type **slot, ofs;
25344 struct objfile *objfile = dwarf2_per_objfile->objfile;
25345 struct attribute *attr;
25346 struct dynamic_prop prop;
25348 /* For Ada types, make sure that the gnat-specific data is always
25349 initialized (if not already set). There are a few types where
25350 we should not be doing so, because the type-specific area is
25351 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25352 where the type-specific area is used to store the floatformat).
25353 But this is not a problem, because the gnat-specific information
25354 is actually not needed for these types. */
25355 if (need_gnat_info (cu)
25356 && TYPE_CODE (type) != TYPE_CODE_FUNC
25357 && TYPE_CODE (type) != TYPE_CODE_FLT
25358 && TYPE_CODE (type) != TYPE_CODE_METHODPTR
25359 && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
25360 && TYPE_CODE (type) != TYPE_CODE_METHOD
25361 && !HAVE_GNAT_AUX_INFO (type))
25362 INIT_GNAT_SPECIFIC (type);
25364 /* Read DW_AT_allocated and set in type. */
25365 attr = dwarf2_attr (die, DW_AT_allocated, cu);
25366 if (attr_form_is_block (attr))
25368 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25369 add_dyn_prop (DYN_PROP_ALLOCATED, prop, type);
25371 else if (attr != NULL)
25373 complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25374 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25375 sect_offset_str (die->sect_off));
25378 /* Read DW_AT_associated and set in type. */
25379 attr = dwarf2_attr (die, DW_AT_associated, cu);
25380 if (attr_form_is_block (attr))
25382 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25383 add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type);
25385 else if (attr != NULL)
25387 complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25388 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25389 sect_offset_str (die->sect_off));
25392 /* Read DW_AT_data_location and set in type. */
25393 attr = dwarf2_attr (die, DW_AT_data_location, cu);
25394 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25395 add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type);
25397 if (dwarf2_per_objfile->die_type_hash == NULL)
25399 dwarf2_per_objfile->die_type_hash =
25400 htab_create_alloc_ex (127,
25401 per_cu_offset_and_type_hash,
25402 per_cu_offset_and_type_eq,
25404 &objfile->objfile_obstack,
25405 hashtab_obstack_allocate,
25406 dummy_obstack_deallocate);
25409 ofs.per_cu = cu->per_cu;
25410 ofs.sect_off = die->sect_off;
25412 slot = (struct dwarf2_per_cu_offset_and_type **)
25413 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
25415 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25416 sect_offset_str (die->sect_off));
25417 *slot = XOBNEW (&objfile->objfile_obstack,
25418 struct dwarf2_per_cu_offset_and_type);
25423 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25424 or return NULL if the die does not have a saved type. */
25426 static struct type *
25427 get_die_type_at_offset (sect_offset sect_off,
25428 struct dwarf2_per_cu_data *per_cu)
25430 struct dwarf2_per_cu_offset_and_type *slot, ofs;
25431 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
25433 if (dwarf2_per_objfile->die_type_hash == NULL)
25436 ofs.per_cu = per_cu;
25437 ofs.sect_off = sect_off;
25438 slot = ((struct dwarf2_per_cu_offset_and_type *)
25439 htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
25446 /* Look up the type for DIE in CU in die_type_hash,
25447 or return NULL if DIE does not have a saved type. */
25449 static struct type *
25450 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
25452 return get_die_type_at_offset (die->sect_off, cu->per_cu);
25455 /* Add a dependence relationship from CU to REF_PER_CU. */
25458 dwarf2_add_dependence (struct dwarf2_cu *cu,
25459 struct dwarf2_per_cu_data *ref_per_cu)
25463 if (cu->dependencies == NULL)
25465 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
25466 NULL, &cu->comp_unit_obstack,
25467 hashtab_obstack_allocate,
25468 dummy_obstack_deallocate);
25470 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
25472 *slot = ref_per_cu;
25475 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25476 Set the mark field in every compilation unit in the
25477 cache that we must keep because we are keeping CU. */
25480 dwarf2_mark_helper (void **slot, void *data)
25482 struct dwarf2_per_cu_data *per_cu;
25484 per_cu = (struct dwarf2_per_cu_data *) *slot;
25486 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25487 reading of the chain. As such dependencies remain valid it is not much
25488 useful to track and undo them during QUIT cleanups. */
25489 if (per_cu->cu == NULL)
25492 if (per_cu->cu->mark)
25494 per_cu->cu->mark = true;
25496 if (per_cu->cu->dependencies != NULL)
25497 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
25502 /* Set the mark field in CU and in every other compilation unit in the
25503 cache that we must keep because we are keeping CU. */
25506 dwarf2_mark (struct dwarf2_cu *cu)
25511 if (cu->dependencies != NULL)
25512 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
25516 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
25520 per_cu->cu->mark = false;
25521 per_cu = per_cu->cu->read_in_chain;
25525 /* Trivial hash function for partial_die_info: the hash value of a DIE
25526 is its offset in .debug_info for this objfile. */
25529 partial_die_hash (const void *item)
25531 const struct partial_die_info *part_die
25532 = (const struct partial_die_info *) item;
25534 return to_underlying (part_die->sect_off);
25537 /* Trivial comparison function for partial_die_info structures: two DIEs
25538 are equal if they have the same offset. */
25541 partial_die_eq (const void *item_lhs, const void *item_rhs)
25543 const struct partial_die_info *part_die_lhs
25544 = (const struct partial_die_info *) item_lhs;
25545 const struct partial_die_info *part_die_rhs
25546 = (const struct partial_die_info *) item_rhs;
25548 return part_die_lhs->sect_off == part_die_rhs->sect_off;
25551 struct cmd_list_element *set_dwarf_cmdlist;
25552 struct cmd_list_element *show_dwarf_cmdlist;
25555 set_dwarf_cmd (const char *args, int from_tty)
25557 help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
25562 show_dwarf_cmd (const char *args, int from_tty)
25564 cmd_show_list (show_dwarf_cmdlist, from_tty, "");
25567 int dwarf_always_disassemble;
25570 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
25571 struct cmd_list_element *c, const char *value)
25573 fprintf_filtered (file,
25574 _("Whether to always disassemble "
25575 "DWARF expressions is %s.\n"),
25580 show_check_physname (struct ui_file *file, int from_tty,
25581 struct cmd_list_element *c, const char *value)
25583 fprintf_filtered (file,
25584 _("Whether to check \"physname\" is %s.\n"),
25589 _initialize_dwarf2_read (void)
25591 dwarf2_objfile_data_key
25592 = register_objfile_data_with_cleanup (nullptr, dwarf2_free_objfile);
25594 add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
25595 Set DWARF specific variables.\n\
25596 Configure DWARF variables such as the cache size"),
25597 &set_dwarf_cmdlist, "maintenance set dwarf ",
25598 0/*allow-unknown*/, &maintenance_set_cmdlist);
25600 add_prefix_cmd ("dwarf", class_maintenance, show_dwarf_cmd, _("\
25601 Show DWARF specific variables\n\
25602 Show DWARF variables such as the cache size"),
25603 &show_dwarf_cmdlist, "maintenance show dwarf ",
25604 0/*allow-unknown*/, &maintenance_show_cmdlist);
25606 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
25607 &dwarf_max_cache_age, _("\
25608 Set the upper bound on the age of cached DWARF compilation units."), _("\
25609 Show the upper bound on the age of cached DWARF compilation units."), _("\
25610 A higher limit means that cached compilation units will be stored\n\
25611 in memory longer, and more total memory will be used. Zero disables\n\
25612 caching, which can slow down startup."),
25614 show_dwarf_max_cache_age,
25615 &set_dwarf_cmdlist,
25616 &show_dwarf_cmdlist);
25618 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
25619 &dwarf_always_disassemble, _("\
25620 Set whether `info address' always disassembles DWARF expressions."), _("\
25621 Show whether `info address' always disassembles DWARF expressions."), _("\
25622 When enabled, DWARF expressions are always printed in an assembly-like\n\
25623 syntax. When disabled, expressions will be printed in a more\n\
25624 conversational style, when possible."),
25626 show_dwarf_always_disassemble,
25627 &set_dwarf_cmdlist,
25628 &show_dwarf_cmdlist);
25630 add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
25631 Set debugging of the DWARF reader."), _("\
25632 Show debugging of the DWARF reader."), _("\
25633 When enabled (non-zero), debugging messages are printed during DWARF\n\
25634 reading and symtab expansion. A value of 1 (one) provides basic\n\
25635 information. A value greater than 1 provides more verbose information."),
25638 &setdebuglist, &showdebuglist);
25640 add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
25641 Set debugging of the DWARF DIE reader."), _("\
25642 Show debugging of the DWARF DIE reader."), _("\
25643 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25644 The value is the maximum depth to print."),
25647 &setdebuglist, &showdebuglist);
25649 add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
25650 Set debugging of the dwarf line reader."), _("\
25651 Show debugging of the dwarf line reader."), _("\
25652 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25653 A value of 1 (one) provides basic information.\n\
25654 A value greater than 1 provides more verbose information."),
25657 &setdebuglist, &showdebuglist);
25659 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
25660 Set cross-checking of \"physname\" code against demangler."), _("\
25661 Show cross-checking of \"physname\" code against demangler."), _("\
25662 When enabled, GDB's internal \"physname\" code is checked against\n\
25664 NULL, show_check_physname,
25665 &setdebuglist, &showdebuglist);
25667 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25668 no_class, &use_deprecated_index_sections, _("\
25669 Set whether to use deprecated gdb_index sections."), _("\
25670 Show whether to use deprecated gdb_index sections."), _("\
25671 When enabled, deprecated .gdb_index sections are used anyway.\n\
25672 Normally they are ignored either because of a missing feature or\n\
25673 performance issue.\n\
25674 Warning: This option must be enabled before gdb reads the file."),
25677 &setlist, &showlist);
25679 dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
25680 &dwarf2_locexpr_funcs);
25681 dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
25682 &dwarf2_loclist_funcs);
25684 dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
25685 &dwarf2_block_frame_base_locexpr_funcs);
25686 dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
25687 &dwarf2_block_frame_base_loclist_funcs);
25690 selftests::register_test ("dw2_expand_symtabs_matching",
25691 selftests::dw2_expand_symtabs_matching::run_test);