1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2018 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* FIXME: Various die-reading functions need to be more careful with
28 reading off the end of the section.
29 E.g., load_partial_dies, read_partial_die. */
32 #include "dwarf2read.h"
33 #include "dwarf-index-cache.h"
34 #include "dwarf-index-common.h"
43 #include "gdb-demangle.h"
44 #include "expression.h"
45 #include "filenames.h" /* for DOSish file names */
48 #include "complaints.h"
50 #include "dwarf2expr.h"
51 #include "dwarf2loc.h"
52 #include "cp-support.h"
58 #include "typeprint.h"
61 #include "completer.h"
66 #include "gdbcore.h" /* for gnutarget */
67 #include "gdb/gdb-index.h"
72 #include "filestuff.h"
74 #include "namespace.h"
75 #include "common/gdb_unlinker.h"
76 #include "common/function-view.h"
77 #include "common/gdb_optional.h"
78 #include "common/underlying.h"
79 #include "common/byte-vector.h"
80 #include "common/hash_enum.h"
81 #include "filename-seen-cache.h"
84 #include <sys/types.h>
86 #include <unordered_set>
87 #include <unordered_map>
91 #include <forward_list>
92 #include "rust-lang.h"
93 #include "common/pathstuff.h"
95 /* When == 1, print basic high level tracing messages.
96 When > 1, be more verbose.
97 This is in contrast to the low level DIE reading of dwarf_die_debug. */
98 static unsigned int dwarf_read_debug = 0;
100 /* When non-zero, dump DIEs after they are read in. */
101 static unsigned int dwarf_die_debug = 0;
103 /* When non-zero, dump line number entries as they are read in. */
104 static unsigned int dwarf_line_debug = 0;
106 /* When non-zero, cross-check physname against demangler. */
107 static int check_physname = 0;
109 /* When non-zero, do not reject deprecated .gdb_index sections. */
110 static int use_deprecated_index_sections = 0;
112 static const struct objfile_data *dwarf2_objfile_data_key;
114 /* The "aclass" indices for various kinds of computed DWARF symbols. */
116 static int dwarf2_locexpr_index;
117 static int dwarf2_loclist_index;
118 static int dwarf2_locexpr_block_index;
119 static int dwarf2_loclist_block_index;
121 /* An index into a (C++) symbol name component in a symbol name as
122 recorded in the mapped_index's symbol table. For each C++ symbol
123 in the symbol table, we record one entry for the start of each
124 component in the symbol in a table of name components, and then
125 sort the table, in order to be able to binary search symbol names,
126 ignoring leading namespaces, both completion and regular look up.
127 For example, for symbol "A::B::C", we'll have an entry that points
128 to "A::B::C", another that points to "B::C", and another for "C".
129 Note that function symbols in GDB index have no parameter
130 information, just the function/method names. You can convert a
131 name_component to a "const char *" using the
132 'mapped_index::symbol_name_at(offset_type)' method. */
134 struct name_component
136 /* Offset in the symbol name where the component starts. Stored as
137 a (32-bit) offset instead of a pointer to save memory and improve
138 locality on 64-bit architectures. */
139 offset_type name_offset;
141 /* The symbol's index in the symbol and constant pool tables of a
146 /* Base class containing bits shared by both .gdb_index and
147 .debug_name indexes. */
149 struct mapped_index_base
151 mapped_index_base () = default;
152 DISABLE_COPY_AND_ASSIGN (mapped_index_base);
154 /* The name_component table (a sorted vector). See name_component's
155 description above. */
156 std::vector<name_component> name_components;
158 /* How NAME_COMPONENTS is sorted. */
159 enum case_sensitivity name_components_casing;
161 /* Return the number of names in the symbol table. */
162 virtual size_t symbol_name_count () const = 0;
164 /* Get the name of the symbol at IDX in the symbol table. */
165 virtual const char *symbol_name_at (offset_type idx) const = 0;
167 /* Return whether the name at IDX in the symbol table should be
169 virtual bool symbol_name_slot_invalid (offset_type idx) const
174 /* Build the symbol name component sorted vector, if we haven't
176 void build_name_components ();
178 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
179 possible matches for LN_NO_PARAMS in the name component
181 std::pair<std::vector<name_component>::const_iterator,
182 std::vector<name_component>::const_iterator>
183 find_name_components_bounds (const lookup_name_info &ln_no_params) const;
185 /* Prevent deleting/destroying via a base class pointer. */
187 ~mapped_index_base() = default;
190 /* A description of the mapped index. The file format is described in
191 a comment by the code that writes the index. */
192 struct mapped_index final : public mapped_index_base
194 /* A slot/bucket in the symbol table hash. */
195 struct symbol_table_slot
197 const offset_type name;
198 const offset_type vec;
201 /* Index data format version. */
204 /* The address table data. */
205 gdb::array_view<const gdb_byte> address_table;
207 /* The symbol table, implemented as a hash table. */
208 gdb::array_view<symbol_table_slot> symbol_table;
210 /* A pointer to the constant pool. */
211 const char *constant_pool = nullptr;
213 bool symbol_name_slot_invalid (offset_type idx) const override
215 const auto &bucket = this->symbol_table[idx];
216 return bucket.name == 0 && bucket.vec;
219 /* Convenience method to get at the name of the symbol at IDX in the
221 const char *symbol_name_at (offset_type idx) const override
222 { return this->constant_pool + MAYBE_SWAP (this->symbol_table[idx].name); }
224 size_t symbol_name_count () const override
225 { return this->symbol_table.size (); }
228 /* A description of the mapped .debug_names.
229 Uninitialized map has CU_COUNT 0. */
230 struct mapped_debug_names final : public mapped_index_base
232 mapped_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile_)
233 : dwarf2_per_objfile (dwarf2_per_objfile_)
236 struct dwarf2_per_objfile *dwarf2_per_objfile;
237 bfd_endian dwarf5_byte_order;
238 bool dwarf5_is_dwarf64;
239 bool augmentation_is_gdb;
241 uint32_t cu_count = 0;
242 uint32_t tu_count, bucket_count, name_count;
243 const gdb_byte *cu_table_reordered, *tu_table_reordered;
244 const uint32_t *bucket_table_reordered, *hash_table_reordered;
245 const gdb_byte *name_table_string_offs_reordered;
246 const gdb_byte *name_table_entry_offs_reordered;
247 const gdb_byte *entry_pool;
254 /* Attribute name DW_IDX_*. */
257 /* Attribute form DW_FORM_*. */
260 /* Value if FORM is DW_FORM_implicit_const. */
261 LONGEST implicit_const;
263 std::vector<attr> attr_vec;
266 std::unordered_map<ULONGEST, index_val> abbrev_map;
268 const char *namei_to_name (uint32_t namei) const;
270 /* Implementation of the mapped_index_base virtual interface, for
271 the name_components cache. */
273 const char *symbol_name_at (offset_type idx) const override
274 { return namei_to_name (idx); }
276 size_t symbol_name_count () const override
277 { return this->name_count; }
280 /* See dwarf2read.h. */
283 get_dwarf2_per_objfile (struct objfile *objfile)
285 return ((struct dwarf2_per_objfile *)
286 objfile_data (objfile, dwarf2_objfile_data_key));
289 /* Set the dwarf2_per_objfile associated to OBJFILE. */
292 set_dwarf2_per_objfile (struct objfile *objfile,
293 struct dwarf2_per_objfile *dwarf2_per_objfile)
295 gdb_assert (get_dwarf2_per_objfile (objfile) == NULL);
296 set_objfile_data (objfile, dwarf2_objfile_data_key, dwarf2_per_objfile);
299 /* Default names of the debugging sections. */
301 /* Note that if the debugging section has been compressed, it might
302 have a name like .zdebug_info. */
304 static const struct dwarf2_debug_sections dwarf2_elf_names =
306 { ".debug_info", ".zdebug_info" },
307 { ".debug_abbrev", ".zdebug_abbrev" },
308 { ".debug_line", ".zdebug_line" },
309 { ".debug_loc", ".zdebug_loc" },
310 { ".debug_loclists", ".zdebug_loclists" },
311 { ".debug_macinfo", ".zdebug_macinfo" },
312 { ".debug_macro", ".zdebug_macro" },
313 { ".debug_str", ".zdebug_str" },
314 { ".debug_line_str", ".zdebug_line_str" },
315 { ".debug_ranges", ".zdebug_ranges" },
316 { ".debug_rnglists", ".zdebug_rnglists" },
317 { ".debug_types", ".zdebug_types" },
318 { ".debug_addr", ".zdebug_addr" },
319 { ".debug_frame", ".zdebug_frame" },
320 { ".eh_frame", NULL },
321 { ".gdb_index", ".zgdb_index" },
322 { ".debug_names", ".zdebug_names" },
323 { ".debug_aranges", ".zdebug_aranges" },
327 /* List of DWO/DWP sections. */
329 static const struct dwop_section_names
331 struct dwarf2_section_names abbrev_dwo;
332 struct dwarf2_section_names info_dwo;
333 struct dwarf2_section_names line_dwo;
334 struct dwarf2_section_names loc_dwo;
335 struct dwarf2_section_names loclists_dwo;
336 struct dwarf2_section_names macinfo_dwo;
337 struct dwarf2_section_names macro_dwo;
338 struct dwarf2_section_names str_dwo;
339 struct dwarf2_section_names str_offsets_dwo;
340 struct dwarf2_section_names types_dwo;
341 struct dwarf2_section_names cu_index;
342 struct dwarf2_section_names tu_index;
346 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
347 { ".debug_info.dwo", ".zdebug_info.dwo" },
348 { ".debug_line.dwo", ".zdebug_line.dwo" },
349 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
350 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
351 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
352 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
353 { ".debug_str.dwo", ".zdebug_str.dwo" },
354 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
355 { ".debug_types.dwo", ".zdebug_types.dwo" },
356 { ".debug_cu_index", ".zdebug_cu_index" },
357 { ".debug_tu_index", ".zdebug_tu_index" },
360 /* local data types */
362 /* The data in a compilation unit header, after target2host
363 translation, looks like this. */
364 struct comp_unit_head
368 unsigned char addr_size;
369 unsigned char signed_addr_p;
370 sect_offset abbrev_sect_off;
372 /* Size of file offsets; either 4 or 8. */
373 unsigned int offset_size;
375 /* Size of the length field; either 4 or 12. */
376 unsigned int initial_length_size;
378 enum dwarf_unit_type unit_type;
380 /* Offset to the first byte of this compilation unit header in the
381 .debug_info section, for resolving relative reference dies. */
382 sect_offset sect_off;
384 /* Offset to first die in this cu from the start of the cu.
385 This will be the first byte following the compilation unit header. */
386 cu_offset first_die_cu_offset;
388 /* 64-bit signature of this type unit - it is valid only for
389 UNIT_TYPE DW_UT_type. */
392 /* For types, offset in the type's DIE of the type defined by this TU. */
393 cu_offset type_cu_offset_in_tu;
396 /* Type used for delaying computation of method physnames.
397 See comments for compute_delayed_physnames. */
398 struct delayed_method_info
400 /* The type to which the method is attached, i.e., its parent class. */
403 /* The index of the method in the type's function fieldlists. */
406 /* The index of the method in the fieldlist. */
409 /* The name of the DIE. */
412 /* The DIE associated with this method. */
413 struct die_info *die;
416 /* Internal state when decoding a particular compilation unit. */
419 explicit dwarf2_cu (struct dwarf2_per_cu_data *per_cu);
422 DISABLE_COPY_AND_ASSIGN (dwarf2_cu);
424 /* The header of the compilation unit. */
425 struct comp_unit_head header {};
427 /* Base address of this compilation unit. */
428 CORE_ADDR base_address = 0;
430 /* Non-zero if base_address has been set. */
433 /* The language we are debugging. */
434 enum language language = language_unknown;
435 const struct language_defn *language_defn = nullptr;
437 const char *producer = nullptr;
439 /* The symtab builder for this CU. This is only non-NULL when full
440 symbols are being read. */
441 std::unique_ptr<buildsym_compunit> builder;
443 /* The generic symbol table building routines have separate lists for
444 file scope symbols and all all other scopes (local scopes). So
445 we need to select the right one to pass to add_symbol_to_list().
446 We do it by keeping a pointer to the correct list in list_in_scope.
448 FIXME: The original dwarf code just treated the file scope as the
449 first local scope, and all other local scopes as nested local
450 scopes, and worked fine. Check to see if we really need to
451 distinguish these in buildsym.c. */
452 struct pending **list_in_scope = nullptr;
454 /* Hash table holding all the loaded partial DIEs
455 with partial_die->offset.SECT_OFF as hash. */
456 htab_t partial_dies = nullptr;
458 /* Storage for things with the same lifetime as this read-in compilation
459 unit, including partial DIEs. */
460 auto_obstack comp_unit_obstack;
462 /* When multiple dwarf2_cu structures are living in memory, this field
463 chains them all together, so that they can be released efficiently.
464 We will probably also want a generation counter so that most-recently-used
465 compilation units are cached... */
466 struct dwarf2_per_cu_data *read_in_chain = nullptr;
468 /* Backlink to our per_cu entry. */
469 struct dwarf2_per_cu_data *per_cu;
471 /* How many compilation units ago was this CU last referenced? */
474 /* A hash table of DIE cu_offset for following references with
475 die_info->offset.sect_off as hash. */
476 htab_t die_hash = nullptr;
478 /* Full DIEs if read in. */
479 struct die_info *dies = nullptr;
481 /* A set of pointers to dwarf2_per_cu_data objects for compilation
482 units referenced by this one. Only set during full symbol processing;
483 partial symbol tables do not have dependencies. */
484 htab_t dependencies = nullptr;
486 /* Header data from the line table, during full symbol processing. */
487 struct line_header *line_header = nullptr;
488 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
489 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
490 this is the DW_TAG_compile_unit die for this CU. We'll hold on
491 to the line header as long as this DIE is being processed. See
492 process_die_scope. */
493 die_info *line_header_die_owner = nullptr;
495 /* A list of methods which need to have physnames computed
496 after all type information has been read. */
497 std::vector<delayed_method_info> method_list;
499 /* To be copied to symtab->call_site_htab. */
500 htab_t call_site_htab = nullptr;
502 /* Non-NULL if this CU came from a DWO file.
503 There is an invariant here that is important to remember:
504 Except for attributes copied from the top level DIE in the "main"
505 (or "stub") file in preparation for reading the DWO file
506 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
507 Either there isn't a DWO file (in which case this is NULL and the point
508 is moot), or there is and either we're not going to read it (in which
509 case this is NULL) or there is and we are reading it (in which case this
511 struct dwo_unit *dwo_unit = nullptr;
513 /* The DW_AT_addr_base attribute if present, zero otherwise
514 (zero is a valid value though).
515 Note this value comes from the Fission stub CU/TU's DIE. */
516 ULONGEST addr_base = 0;
518 /* The DW_AT_ranges_base attribute if present, zero otherwise
519 (zero is a valid value though).
520 Note this value comes from the Fission stub CU/TU's DIE.
521 Also note that the value is zero in the non-DWO case so this value can
522 be used without needing to know whether DWO files are in use or not.
523 N.B. This does not apply to DW_AT_ranges appearing in
524 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
525 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
526 DW_AT_ranges_base *would* have to be applied, and we'd have to care
527 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
528 ULONGEST ranges_base = 0;
530 /* When reading debug info generated by older versions of rustc, we
531 have to rewrite some union types to be struct types with a
532 variant part. This rewriting must be done after the CU is fully
533 read in, because otherwise at the point of rewriting some struct
534 type might not have been fully processed. So, we keep a list of
535 all such types here and process them after expansion. */
536 std::vector<struct type *> rust_unions;
538 /* Mark used when releasing cached dies. */
541 /* This CU references .debug_loc. See the symtab->locations_valid field.
542 This test is imperfect as there may exist optimized debug code not using
543 any location list and still facing inlining issues if handled as
544 unoptimized code. For a future better test see GCC PR other/32998. */
545 bool has_loclist : 1;
547 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is true
548 if all the producer_is_* fields are valid. This information is cached
549 because profiling CU expansion showed excessive time spent in
550 producer_is_gxx_lt_4_6. */
551 bool checked_producer : 1;
552 bool producer_is_gxx_lt_4_6 : 1;
553 bool producer_is_gcc_lt_4_3 : 1;
554 bool producer_is_icc : 1;
555 bool producer_is_icc_lt_14 : 1;
556 bool producer_is_codewarrior : 1;
558 /* When true, the file that we're processing is known to have
559 debugging info for C++ namespaces. GCC 3.3.x did not produce
560 this information, but later versions do. */
562 bool processing_has_namespace_info : 1;
564 struct partial_die_info *find_partial_die (sect_offset sect_off);
567 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
568 This includes type_unit_group and quick_file_names. */
570 struct stmt_list_hash
572 /* The DWO unit this table is from or NULL if there is none. */
573 struct dwo_unit *dwo_unit;
575 /* Offset in .debug_line or .debug_line.dwo. */
576 sect_offset line_sect_off;
579 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
580 an object of this type. */
582 struct type_unit_group
584 /* dwarf2read.c's main "handle" on a TU symtab.
585 To simplify things we create an artificial CU that "includes" all the
586 type units using this stmt_list so that the rest of the code still has
587 a "per_cu" handle on the symtab.
588 This PER_CU is recognized by having no section. */
589 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
590 struct dwarf2_per_cu_data per_cu;
592 /* The TUs that share this DW_AT_stmt_list entry.
593 This is added to while parsing type units to build partial symtabs,
594 and is deleted afterwards and not used again. */
595 VEC (sig_type_ptr) *tus;
597 /* The compunit symtab.
598 Type units in a group needn't all be defined in the same source file,
599 so we create an essentially anonymous symtab as the compunit symtab. */
600 struct compunit_symtab *compunit_symtab;
602 /* The data used to construct the hash key. */
603 struct stmt_list_hash hash;
605 /* The number of symtabs from the line header.
606 The value here must match line_header.num_file_names. */
607 unsigned int num_symtabs;
609 /* The symbol tables for this TU (obtained from the files listed in
611 WARNING: The order of entries here must match the order of entries
612 in the line header. After the first TU using this type_unit_group, the
613 line header for the subsequent TUs is recreated from this. This is done
614 because we need to use the same symtabs for each TU using the same
615 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
616 there's no guarantee the line header doesn't have duplicate entries. */
617 struct symtab **symtabs;
620 /* These sections are what may appear in a (real or virtual) DWO file. */
624 struct dwarf2_section_info abbrev;
625 struct dwarf2_section_info line;
626 struct dwarf2_section_info loc;
627 struct dwarf2_section_info loclists;
628 struct dwarf2_section_info macinfo;
629 struct dwarf2_section_info macro;
630 struct dwarf2_section_info str;
631 struct dwarf2_section_info str_offsets;
632 /* In the case of a virtual DWO file, these two are unused. */
633 struct dwarf2_section_info info;
634 VEC (dwarf2_section_info_def) *types;
637 /* CUs/TUs in DWP/DWO files. */
641 /* Backlink to the containing struct dwo_file. */
642 struct dwo_file *dwo_file;
644 /* The "id" that distinguishes this CU/TU.
645 .debug_info calls this "dwo_id", .debug_types calls this "signature".
646 Since signatures came first, we stick with it for consistency. */
649 /* The section this CU/TU lives in, in the DWO file. */
650 struct dwarf2_section_info *section;
652 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
653 sect_offset sect_off;
656 /* For types, offset in the type's DIE of the type defined by this TU. */
657 cu_offset type_offset_in_tu;
660 /* include/dwarf2.h defines the DWP section codes.
661 It defines a max value but it doesn't define a min value, which we
662 use for error checking, so provide one. */
664 enum dwp_v2_section_ids
669 /* Data for one DWO file.
671 This includes virtual DWO files (a virtual DWO file is a DWO file as it
672 appears in a DWP file). DWP files don't really have DWO files per se -
673 comdat folding of types "loses" the DWO file they came from, and from
674 a high level view DWP files appear to contain a mass of random types.
675 However, to maintain consistency with the non-DWP case we pretend DWP
676 files contain virtual DWO files, and we assign each TU with one virtual
677 DWO file (generally based on the line and abbrev section offsets -
678 a heuristic that seems to work in practice). */
682 /* The DW_AT_GNU_dwo_name attribute.
683 For virtual DWO files the name is constructed from the section offsets
684 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
685 from related CU+TUs. */
686 const char *dwo_name;
688 /* The DW_AT_comp_dir attribute. */
689 const char *comp_dir;
691 /* The bfd, when the file is open. Otherwise this is NULL.
692 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
695 /* The sections that make up this DWO file.
696 Remember that for virtual DWO files in DWP V2, these are virtual
697 sections (for lack of a better name). */
698 struct dwo_sections sections;
700 /* The CUs in the file.
701 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
702 an extension to handle LLVM's Link Time Optimization output (where
703 multiple source files may be compiled into a single object/dwo pair). */
706 /* Table of TUs in the file.
707 Each element is a struct dwo_unit. */
711 /* These sections are what may appear in a DWP file. */
715 /* These are used by both DWP version 1 and 2. */
716 struct dwarf2_section_info str;
717 struct dwarf2_section_info cu_index;
718 struct dwarf2_section_info tu_index;
720 /* These are only used by DWP version 2 files.
721 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
722 sections are referenced by section number, and are not recorded here.
723 In DWP version 2 there is at most one copy of all these sections, each
724 section being (effectively) comprised of the concatenation of all of the
725 individual sections that exist in the version 1 format.
726 To keep the code simple we treat each of these concatenated pieces as a
727 section itself (a virtual section?). */
728 struct dwarf2_section_info abbrev;
729 struct dwarf2_section_info info;
730 struct dwarf2_section_info line;
731 struct dwarf2_section_info loc;
732 struct dwarf2_section_info macinfo;
733 struct dwarf2_section_info macro;
734 struct dwarf2_section_info str_offsets;
735 struct dwarf2_section_info types;
738 /* These sections are what may appear in a virtual DWO file in DWP version 1.
739 A virtual DWO file is a DWO file as it appears in a DWP file. */
741 struct virtual_v1_dwo_sections
743 struct dwarf2_section_info abbrev;
744 struct dwarf2_section_info line;
745 struct dwarf2_section_info loc;
746 struct dwarf2_section_info macinfo;
747 struct dwarf2_section_info macro;
748 struct dwarf2_section_info str_offsets;
749 /* Each DWP hash table entry records one CU or one TU.
750 That is recorded here, and copied to dwo_unit.section. */
751 struct dwarf2_section_info info_or_types;
754 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
755 In version 2, the sections of the DWO files are concatenated together
756 and stored in one section of that name. Thus each ELF section contains
757 several "virtual" sections. */
759 struct virtual_v2_dwo_sections
761 bfd_size_type abbrev_offset;
762 bfd_size_type abbrev_size;
764 bfd_size_type line_offset;
765 bfd_size_type line_size;
767 bfd_size_type loc_offset;
768 bfd_size_type loc_size;
770 bfd_size_type macinfo_offset;
771 bfd_size_type macinfo_size;
773 bfd_size_type macro_offset;
774 bfd_size_type macro_size;
776 bfd_size_type str_offsets_offset;
777 bfd_size_type str_offsets_size;
779 /* Each DWP hash table entry records one CU or one TU.
780 That is recorded here, and copied to dwo_unit.section. */
781 bfd_size_type info_or_types_offset;
782 bfd_size_type info_or_types_size;
785 /* Contents of DWP hash tables. */
787 struct dwp_hash_table
789 uint32_t version, nr_columns;
790 uint32_t nr_units, nr_slots;
791 const gdb_byte *hash_table, *unit_table;
796 const gdb_byte *indices;
800 /* This is indexed by column number and gives the id of the section
802 #define MAX_NR_V2_DWO_SECTIONS \
803 (1 /* .debug_info or .debug_types */ \
804 + 1 /* .debug_abbrev */ \
805 + 1 /* .debug_line */ \
806 + 1 /* .debug_loc */ \
807 + 1 /* .debug_str_offsets */ \
808 + 1 /* .debug_macro or .debug_macinfo */)
809 int section_ids[MAX_NR_V2_DWO_SECTIONS];
810 const gdb_byte *offsets;
811 const gdb_byte *sizes;
816 /* Data for one DWP file. */
820 dwp_file (const char *name_, gdb_bfd_ref_ptr &&abfd)
822 dbfd (std::move (abfd))
826 /* Name of the file. */
829 /* File format version. */
833 gdb_bfd_ref_ptr dbfd;
835 /* Section info for this file. */
836 struct dwp_sections sections {};
838 /* Table of CUs in the file. */
839 const struct dwp_hash_table *cus = nullptr;
841 /* Table of TUs in the file. */
842 const struct dwp_hash_table *tus = nullptr;
844 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
845 htab_t loaded_cus {};
846 htab_t loaded_tus {};
848 /* Table to map ELF section numbers to their sections.
849 This is only needed for the DWP V1 file format. */
850 unsigned int num_sections = 0;
851 asection **elf_sections = nullptr;
854 /* This represents a '.dwz' file. */
858 dwz_file (gdb_bfd_ref_ptr &&bfd)
859 : dwz_bfd (std::move (bfd))
863 /* A dwz file can only contain a few sections. */
864 struct dwarf2_section_info abbrev {};
865 struct dwarf2_section_info info {};
866 struct dwarf2_section_info str {};
867 struct dwarf2_section_info line {};
868 struct dwarf2_section_info macro {};
869 struct dwarf2_section_info gdb_index {};
870 struct dwarf2_section_info debug_names {};
873 gdb_bfd_ref_ptr dwz_bfd;
875 /* If we loaded the index from an external file, this contains the
876 resources associated to the open file, memory mapping, etc. */
877 std::unique_ptr<index_cache_resource> index_cache_res;
880 /* Struct used to pass misc. parameters to read_die_and_children, et
881 al. which are used for both .debug_info and .debug_types dies.
882 All parameters here are unchanging for the life of the call. This
883 struct exists to abstract away the constant parameters of die reading. */
885 struct die_reader_specs
887 /* The bfd of die_section. */
890 /* The CU of the DIE we are parsing. */
891 struct dwarf2_cu *cu;
893 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
894 struct dwo_file *dwo_file;
896 /* The section the die comes from.
897 This is either .debug_info or .debug_types, or the .dwo variants. */
898 struct dwarf2_section_info *die_section;
900 /* die_section->buffer. */
901 const gdb_byte *buffer;
903 /* The end of the buffer. */
904 const gdb_byte *buffer_end;
906 /* The value of the DW_AT_comp_dir attribute. */
907 const char *comp_dir;
909 /* The abbreviation table to use when reading the DIEs. */
910 struct abbrev_table *abbrev_table;
913 /* Type of function passed to init_cutu_and_read_dies, et.al. */
914 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
915 const gdb_byte *info_ptr,
916 struct die_info *comp_unit_die,
920 /* A 1-based directory index. This is a strong typedef to prevent
921 accidentally using a directory index as a 0-based index into an
923 enum class dir_index : unsigned int {};
925 /* Likewise, a 1-based file name index. */
926 enum class file_name_index : unsigned int {};
930 file_entry () = default;
932 file_entry (const char *name_, dir_index d_index_,
933 unsigned int mod_time_, unsigned int length_)
936 mod_time (mod_time_),
940 /* Return the include directory at D_INDEX stored in LH. Returns
941 NULL if D_INDEX is out of bounds. */
942 const char *include_dir (const line_header *lh) const;
944 /* The file name. Note this is an observing pointer. The memory is
945 owned by debug_line_buffer. */
948 /* The directory index (1-based). */
949 dir_index d_index {};
951 unsigned int mod_time {};
953 unsigned int length {};
955 /* True if referenced by the Line Number Program. */
958 /* The associated symbol table, if any. */
959 struct symtab *symtab {};
962 /* The line number information for a compilation unit (found in the
963 .debug_line section) begins with a "statement program header",
964 which contains the following information. */
971 /* Add an entry to the include directory table. */
972 void add_include_dir (const char *include_dir);
974 /* Add an entry to the file name table. */
975 void add_file_name (const char *name, dir_index d_index,
976 unsigned int mod_time, unsigned int length);
978 /* Return the include dir at INDEX (1-based). Returns NULL if INDEX
980 const char *include_dir_at (dir_index index) const
982 /* Convert directory index number (1-based) to vector index
984 size_t vec_index = to_underlying (index) - 1;
986 if (vec_index >= include_dirs.size ())
988 return include_dirs[vec_index];
991 /* Return the file name at INDEX (1-based). Returns NULL if INDEX
993 file_entry *file_name_at (file_name_index index)
995 /* Convert file name index number (1-based) to vector index
997 size_t vec_index = to_underlying (index) - 1;
999 if (vec_index >= file_names.size ())
1001 return &file_names[vec_index];
1004 /* Const version of the above. */
1005 const file_entry *file_name_at (unsigned int index) const
1007 if (index >= file_names.size ())
1009 return &file_names[index];
1012 /* Offset of line number information in .debug_line section. */
1013 sect_offset sect_off {};
1015 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1016 unsigned offset_in_dwz : 1; /* Can't initialize bitfields in-class. */
1018 unsigned int total_length {};
1019 unsigned short version {};
1020 unsigned int header_length {};
1021 unsigned char minimum_instruction_length {};
1022 unsigned char maximum_ops_per_instruction {};
1023 unsigned char default_is_stmt {};
1025 unsigned char line_range {};
1026 unsigned char opcode_base {};
1028 /* standard_opcode_lengths[i] is the number of operands for the
1029 standard opcode whose value is i. This means that
1030 standard_opcode_lengths[0] is unused, and the last meaningful
1031 element is standard_opcode_lengths[opcode_base - 1]. */
1032 std::unique_ptr<unsigned char[]> standard_opcode_lengths;
1034 /* The include_directories table. Note these are observing
1035 pointers. The memory is owned by debug_line_buffer. */
1036 std::vector<const char *> include_dirs;
1038 /* The file_names table. */
1039 std::vector<file_entry> file_names;
1041 /* The start and end of the statement program following this
1042 header. These point into dwarf2_per_objfile->line_buffer. */
1043 const gdb_byte *statement_program_start {}, *statement_program_end {};
1046 typedef std::unique_ptr<line_header> line_header_up;
1049 file_entry::include_dir (const line_header *lh) const
1051 return lh->include_dir_at (d_index);
1054 /* When we construct a partial symbol table entry we only
1055 need this much information. */
1056 struct partial_die_info : public allocate_on_obstack
1058 partial_die_info (sect_offset sect_off, struct abbrev_info *abbrev);
1060 /* Disable assign but still keep copy ctor, which is needed
1061 load_partial_dies. */
1062 partial_die_info& operator=(const partial_die_info& rhs) = delete;
1064 /* Adjust the partial die before generating a symbol for it. This
1065 function may set the is_external flag or change the DIE's
1067 void fixup (struct dwarf2_cu *cu);
1069 /* Read a minimal amount of information into the minimal die
1071 const gdb_byte *read (const struct die_reader_specs *reader,
1072 const struct abbrev_info &abbrev,
1073 const gdb_byte *info_ptr);
1075 /* Offset of this DIE. */
1076 const sect_offset sect_off;
1078 /* DWARF-2 tag for this DIE. */
1079 const ENUM_BITFIELD(dwarf_tag) tag : 16;
1081 /* Assorted flags describing the data found in this DIE. */
1082 const unsigned int has_children : 1;
1084 unsigned int is_external : 1;
1085 unsigned int is_declaration : 1;
1086 unsigned int has_type : 1;
1087 unsigned int has_specification : 1;
1088 unsigned int has_pc_info : 1;
1089 unsigned int may_be_inlined : 1;
1091 /* This DIE has been marked DW_AT_main_subprogram. */
1092 unsigned int main_subprogram : 1;
1094 /* Flag set if the SCOPE field of this structure has been
1096 unsigned int scope_set : 1;
1098 /* Flag set if the DIE has a byte_size attribute. */
1099 unsigned int has_byte_size : 1;
1101 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1102 unsigned int has_const_value : 1;
1104 /* Flag set if any of the DIE's children are template arguments. */
1105 unsigned int has_template_arguments : 1;
1107 /* Flag set if fixup has been called on this die. */
1108 unsigned int fixup_called : 1;
1110 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1111 unsigned int is_dwz : 1;
1113 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1114 unsigned int spec_is_dwz : 1;
1116 /* The name of this DIE. Normally the value of DW_AT_name, but
1117 sometimes a default name for unnamed DIEs. */
1118 const char *name = nullptr;
1120 /* The linkage name, if present. */
1121 const char *linkage_name = nullptr;
1123 /* The scope to prepend to our children. This is generally
1124 allocated on the comp_unit_obstack, so will disappear
1125 when this compilation unit leaves the cache. */
1126 const char *scope = nullptr;
1128 /* Some data associated with the partial DIE. The tag determines
1129 which field is live. */
1132 /* The location description associated with this DIE, if any. */
1133 struct dwarf_block *locdesc;
1134 /* The offset of an import, for DW_TAG_imported_unit. */
1135 sect_offset sect_off;
1138 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1139 CORE_ADDR lowpc = 0;
1140 CORE_ADDR highpc = 0;
1142 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1143 DW_AT_sibling, if any. */
1144 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1145 could return DW_AT_sibling values to its caller load_partial_dies. */
1146 const gdb_byte *sibling = nullptr;
1148 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1149 DW_AT_specification (or DW_AT_abstract_origin or
1150 DW_AT_extension). */
1151 sect_offset spec_offset {};
1153 /* Pointers to this DIE's parent, first child, and next sibling,
1155 struct partial_die_info *die_parent = nullptr;
1156 struct partial_die_info *die_child = nullptr;
1157 struct partial_die_info *die_sibling = nullptr;
1159 friend struct partial_die_info *
1160 dwarf2_cu::find_partial_die (sect_offset sect_off);
1163 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1164 partial_die_info (sect_offset sect_off)
1165 : partial_die_info (sect_off, DW_TAG_padding, 0)
1169 partial_die_info (sect_offset sect_off_, enum dwarf_tag tag_,
1171 : sect_off (sect_off_), tag (tag_), has_children (has_children_)
1176 has_specification = 0;
1179 main_subprogram = 0;
1182 has_const_value = 0;
1183 has_template_arguments = 0;
1190 /* This data structure holds the information of an abbrev. */
1193 unsigned int number; /* number identifying abbrev */
1194 enum dwarf_tag tag; /* dwarf tag */
1195 unsigned short has_children; /* boolean */
1196 unsigned short num_attrs; /* number of attributes */
1197 struct attr_abbrev *attrs; /* an array of attribute descriptions */
1198 struct abbrev_info *next; /* next in chain */
1203 ENUM_BITFIELD(dwarf_attribute) name : 16;
1204 ENUM_BITFIELD(dwarf_form) form : 16;
1206 /* It is valid only if FORM is DW_FORM_implicit_const. */
1207 LONGEST implicit_const;
1210 /* Size of abbrev_table.abbrev_hash_table. */
1211 #define ABBREV_HASH_SIZE 121
1213 /* Top level data structure to contain an abbreviation table. */
1217 explicit abbrev_table (sect_offset off)
1221 XOBNEWVEC (&abbrev_obstack, struct abbrev_info *, ABBREV_HASH_SIZE);
1222 memset (m_abbrevs, 0, ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
1225 DISABLE_COPY_AND_ASSIGN (abbrev_table);
1227 /* Allocate space for a struct abbrev_info object in
1229 struct abbrev_info *alloc_abbrev ();
1231 /* Add an abbreviation to the table. */
1232 void add_abbrev (unsigned int abbrev_number, struct abbrev_info *abbrev);
1234 /* Look up an abbrev in the table.
1235 Returns NULL if the abbrev is not found. */
1237 struct abbrev_info *lookup_abbrev (unsigned int abbrev_number);
1240 /* Where the abbrev table came from.
1241 This is used as a sanity check when the table is used. */
1242 const sect_offset sect_off;
1244 /* Storage for the abbrev table. */
1245 auto_obstack abbrev_obstack;
1249 /* Hash table of abbrevs.
1250 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1251 It could be statically allocated, but the previous code didn't so we
1253 struct abbrev_info **m_abbrevs;
1256 typedef std::unique_ptr<struct abbrev_table> abbrev_table_up;
1258 /* Attributes have a name and a value. */
1261 ENUM_BITFIELD(dwarf_attribute) name : 16;
1262 ENUM_BITFIELD(dwarf_form) form : 15;
1264 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1265 field should be in u.str (existing only for DW_STRING) but it is kept
1266 here for better struct attribute alignment. */
1267 unsigned int string_is_canonical : 1;
1272 struct dwarf_block *blk;
1281 /* This data structure holds a complete die structure. */
1284 /* DWARF-2 tag for this DIE. */
1285 ENUM_BITFIELD(dwarf_tag) tag : 16;
1287 /* Number of attributes */
1288 unsigned char num_attrs;
1290 /* True if we're presently building the full type name for the
1291 type derived from this DIE. */
1292 unsigned char building_fullname : 1;
1294 /* True if this die is in process. PR 16581. */
1295 unsigned char in_process : 1;
1298 unsigned int abbrev;
1300 /* Offset in .debug_info or .debug_types section. */
1301 sect_offset sect_off;
1303 /* The dies in a compilation unit form an n-ary tree. PARENT
1304 points to this die's parent; CHILD points to the first child of
1305 this node; and all the children of a given node are chained
1306 together via their SIBLING fields. */
1307 struct die_info *child; /* Its first child, if any. */
1308 struct die_info *sibling; /* Its next sibling, if any. */
1309 struct die_info *parent; /* Its parent, if any. */
1311 /* An array of attributes, with NUM_ATTRS elements. There may be
1312 zero, but it's not common and zero-sized arrays are not
1313 sufficiently portable C. */
1314 struct attribute attrs[1];
1317 /* Get at parts of an attribute structure. */
1319 #define DW_STRING(attr) ((attr)->u.str)
1320 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1321 #define DW_UNSND(attr) ((attr)->u.unsnd)
1322 #define DW_BLOCK(attr) ((attr)->u.blk)
1323 #define DW_SND(attr) ((attr)->u.snd)
1324 #define DW_ADDR(attr) ((attr)->u.addr)
1325 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1327 /* Blocks are a bunch of untyped bytes. */
1332 /* Valid only if SIZE is not zero. */
1333 const gdb_byte *data;
1336 #ifndef ATTR_ALLOC_CHUNK
1337 #define ATTR_ALLOC_CHUNK 4
1340 /* Allocate fields for structs, unions and enums in this size. */
1341 #ifndef DW_FIELD_ALLOC_CHUNK
1342 #define DW_FIELD_ALLOC_CHUNK 4
1345 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1346 but this would require a corresponding change in unpack_field_as_long
1348 static int bits_per_byte = 8;
1350 /* When reading a variant or variant part, we track a bit more
1351 information about the field, and store it in an object of this
1354 struct variant_field
1356 /* If we see a DW_TAG_variant, then this will be the discriminant
1358 ULONGEST discriminant_value;
1359 /* If we see a DW_TAG_variant, then this will be set if this is the
1361 bool default_branch;
1362 /* While reading a DW_TAG_variant_part, this will be set if this
1363 field is the discriminant. */
1364 bool is_discriminant;
1369 int accessibility = 0;
1371 /* Extra information to describe a variant or variant part. */
1372 struct variant_field variant {};
1373 struct field field {};
1378 const char *name = nullptr;
1379 std::vector<struct fn_field> fnfields;
1382 /* The routines that read and process dies for a C struct or C++ class
1383 pass lists of data member fields and lists of member function fields
1384 in an instance of a field_info structure, as defined below. */
1387 /* List of data member and baseclasses fields. */
1388 std::vector<struct nextfield> fields;
1389 std::vector<struct nextfield> baseclasses;
1391 /* Number of fields (including baseclasses). */
1394 /* Set if the accesibility of one of the fields is not public. */
1395 int non_public_fields = 0;
1397 /* Member function fieldlist array, contains name of possibly overloaded
1398 member function, number of overloaded member functions and a pointer
1399 to the head of the member function field chain. */
1400 std::vector<struct fnfieldlist> fnfieldlists;
1402 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1403 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1404 std::vector<struct decl_field> typedef_field_list;
1406 /* Nested types defined by this class and the number of elements in this
1408 std::vector<struct decl_field> nested_types_list;
1411 /* One item on the queue of compilation units to read in full symbols
1413 struct dwarf2_queue_item
1415 struct dwarf2_per_cu_data *per_cu;
1416 enum language pretend_language;
1417 struct dwarf2_queue_item *next;
1420 /* The current queue. */
1421 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1423 /* Loaded secondary compilation units are kept in memory until they
1424 have not been referenced for the processing of this many
1425 compilation units. Set this to zero to disable caching. Cache
1426 sizes of up to at least twenty will improve startup time for
1427 typical inter-CU-reference binaries, at an obvious memory cost. */
1428 static int dwarf_max_cache_age = 5;
1430 show_dwarf_max_cache_age (struct ui_file *file, int from_tty,
1431 struct cmd_list_element *c, const char *value)
1433 fprintf_filtered (file, _("The upper bound on the age of cached "
1434 "DWARF compilation units is %s.\n"),
1438 /* local function prototypes */
1440 static const char *get_section_name (const struct dwarf2_section_info *);
1442 static const char *get_section_file_name (const struct dwarf2_section_info *);
1444 static void dwarf2_find_base_address (struct die_info *die,
1445 struct dwarf2_cu *cu);
1447 static struct partial_symtab *create_partial_symtab
1448 (struct dwarf2_per_cu_data *per_cu, const char *name);
1450 static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
1451 const gdb_byte *info_ptr,
1452 struct die_info *type_unit_die,
1453 int has_children, void *data);
1455 static void dwarf2_build_psymtabs_hard
1456 (struct dwarf2_per_objfile *dwarf2_per_objfile);
1458 static void scan_partial_symbols (struct partial_die_info *,
1459 CORE_ADDR *, CORE_ADDR *,
1460 int, struct dwarf2_cu *);
1462 static void add_partial_symbol (struct partial_die_info *,
1463 struct dwarf2_cu *);
1465 static void add_partial_namespace (struct partial_die_info *pdi,
1466 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1467 int set_addrmap, struct dwarf2_cu *cu);
1469 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1470 CORE_ADDR *highpc, int set_addrmap,
1471 struct dwarf2_cu *cu);
1473 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1474 struct dwarf2_cu *cu);
1476 static void add_partial_subprogram (struct partial_die_info *pdi,
1477 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1478 int need_pc, struct dwarf2_cu *cu);
1480 static void dwarf2_read_symtab (struct partial_symtab *,
1483 static void psymtab_to_symtab_1 (struct partial_symtab *);
1485 static abbrev_table_up abbrev_table_read_table
1486 (struct dwarf2_per_objfile *dwarf2_per_objfile, struct dwarf2_section_info *,
1489 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1491 static struct partial_die_info *load_partial_dies
1492 (const struct die_reader_specs *, const gdb_byte *, int);
1494 static struct partial_die_info *find_partial_die (sect_offset, int,
1495 struct dwarf2_cu *);
1497 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1498 struct attribute *, struct attr_abbrev *,
1501 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1503 static int read_1_signed_byte (bfd *, const gdb_byte *);
1505 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1507 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1509 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1511 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1514 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1516 static LONGEST read_checked_initial_length_and_offset
1517 (bfd *, const gdb_byte *, const struct comp_unit_head *,
1518 unsigned int *, unsigned int *);
1520 static LONGEST read_offset (bfd *, const gdb_byte *,
1521 const struct comp_unit_head *,
1524 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1526 static sect_offset read_abbrev_offset
1527 (struct dwarf2_per_objfile *dwarf2_per_objfile,
1528 struct dwarf2_section_info *, sect_offset);
1530 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1532 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1534 static const char *read_indirect_string
1535 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1536 const struct comp_unit_head *, unsigned int *);
1538 static const char *read_indirect_line_string
1539 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1540 const struct comp_unit_head *, unsigned int *);
1542 static const char *read_indirect_string_at_offset
1543 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
1544 LONGEST str_offset);
1546 static const char *read_indirect_string_from_dwz
1547 (struct objfile *objfile, struct dwz_file *, LONGEST);
1549 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1551 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1555 static const char *read_str_index (const struct die_reader_specs *reader,
1556 ULONGEST str_index);
1558 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1560 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1561 struct dwarf2_cu *);
1563 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1566 static const char *dwarf2_string_attr (struct die_info *die, unsigned int name,
1567 struct dwarf2_cu *cu);
1569 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1570 struct dwarf2_cu *cu);
1572 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1574 static struct die_info *die_specification (struct die_info *die,
1575 struct dwarf2_cu **);
1577 static line_header_up dwarf_decode_line_header (sect_offset sect_off,
1578 struct dwarf2_cu *cu);
1580 static void dwarf_decode_lines (struct line_header *, const char *,
1581 struct dwarf2_cu *, struct partial_symtab *,
1582 CORE_ADDR, int decode_mapping);
1584 static void dwarf2_start_subfile (struct dwarf2_cu *, const char *,
1587 static struct compunit_symtab *dwarf2_start_symtab (struct dwarf2_cu *,
1588 const char *, const char *,
1591 static struct symbol *new_symbol (struct die_info *, struct type *,
1592 struct dwarf2_cu *, struct symbol * = NULL);
1594 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1595 struct dwarf2_cu *);
1597 static void dwarf2_const_value_attr (const struct attribute *attr,
1600 struct obstack *obstack,
1601 struct dwarf2_cu *cu, LONGEST *value,
1602 const gdb_byte **bytes,
1603 struct dwarf2_locexpr_baton **baton);
1605 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1607 static int need_gnat_info (struct dwarf2_cu *);
1609 static struct type *die_descriptive_type (struct die_info *,
1610 struct dwarf2_cu *);
1612 static void set_descriptive_type (struct type *, struct die_info *,
1613 struct dwarf2_cu *);
1615 static struct type *die_containing_type (struct die_info *,
1616 struct dwarf2_cu *);
1618 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1619 struct dwarf2_cu *);
1621 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1623 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1625 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1627 static char *typename_concat (struct obstack *obs, const char *prefix,
1628 const char *suffix, int physname,
1629 struct dwarf2_cu *cu);
1631 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1633 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1635 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1637 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1639 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1641 static void read_variable (struct die_info *die, struct dwarf2_cu *cu);
1643 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1644 struct dwarf2_cu *, struct partial_symtab *);
1646 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1647 values. Keep the items ordered with increasing constraints compliance. */
1650 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1651 PC_BOUNDS_NOT_PRESENT,
1653 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1654 were present but they do not form a valid range of PC addresses. */
1657 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1660 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1664 static enum pc_bounds_kind dwarf2_get_pc_bounds (struct die_info *,
1665 CORE_ADDR *, CORE_ADDR *,
1667 struct partial_symtab *);
1669 static void get_scope_pc_bounds (struct die_info *,
1670 CORE_ADDR *, CORE_ADDR *,
1671 struct dwarf2_cu *);
1673 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1674 CORE_ADDR, struct dwarf2_cu *);
1676 static void dwarf2_add_field (struct field_info *, struct die_info *,
1677 struct dwarf2_cu *);
1679 static void dwarf2_attach_fields_to_type (struct field_info *,
1680 struct type *, struct dwarf2_cu *);
1682 static void dwarf2_add_member_fn (struct field_info *,
1683 struct die_info *, struct type *,
1684 struct dwarf2_cu *);
1686 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1688 struct dwarf2_cu *);
1690 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1692 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1694 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1696 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1698 static struct using_direct **using_directives (struct dwarf2_cu *cu);
1700 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1702 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1704 static struct type *read_module_type (struct die_info *die,
1705 struct dwarf2_cu *cu);
1707 static const char *namespace_name (struct die_info *die,
1708 int *is_anonymous, struct dwarf2_cu *);
1710 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1712 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1714 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1715 struct dwarf2_cu *);
1717 static struct die_info *read_die_and_siblings_1
1718 (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1721 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1722 const gdb_byte *info_ptr,
1723 const gdb_byte **new_info_ptr,
1724 struct die_info *parent);
1726 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1727 struct die_info **, const gdb_byte *,
1730 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1731 struct die_info **, const gdb_byte *,
1734 static void process_die (struct die_info *, struct dwarf2_cu *);
1736 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1739 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1741 static const char *dwarf2_full_name (const char *name,
1742 struct die_info *die,
1743 struct dwarf2_cu *cu);
1745 static const char *dwarf2_physname (const char *name, struct die_info *die,
1746 struct dwarf2_cu *cu);
1748 static struct die_info *dwarf2_extension (struct die_info *die,
1749 struct dwarf2_cu **);
1751 static const char *dwarf_tag_name (unsigned int);
1753 static const char *dwarf_attr_name (unsigned int);
1755 static const char *dwarf_form_name (unsigned int);
1757 static const char *dwarf_bool_name (unsigned int);
1759 static const char *dwarf_type_encoding_name (unsigned int);
1761 static struct die_info *sibling_die (struct die_info *);
1763 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1765 static void dump_die_for_error (struct die_info *);
1767 static void dump_die_1 (struct ui_file *, int level, int max_level,
1770 /*static*/ void dump_die (struct die_info *, int max_level);
1772 static void store_in_ref_table (struct die_info *,
1773 struct dwarf2_cu *);
1775 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1777 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1779 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1780 const struct attribute *,
1781 struct dwarf2_cu **);
1783 static struct die_info *follow_die_ref (struct die_info *,
1784 const struct attribute *,
1785 struct dwarf2_cu **);
1787 static struct die_info *follow_die_sig (struct die_info *,
1788 const struct attribute *,
1789 struct dwarf2_cu **);
1791 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1792 struct dwarf2_cu *);
1794 static struct type *get_DW_AT_signature_type (struct die_info *,
1795 const struct attribute *,
1796 struct dwarf2_cu *);
1798 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1800 static void read_signatured_type (struct signatured_type *);
1802 static int attr_to_dynamic_prop (const struct attribute *attr,
1803 struct die_info *die, struct dwarf2_cu *cu,
1804 struct dynamic_prop *prop);
1806 /* memory allocation interface */
1808 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1810 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1812 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int, int);
1814 static int attr_form_is_block (const struct attribute *);
1816 static int attr_form_is_section_offset (const struct attribute *);
1818 static int attr_form_is_constant (const struct attribute *);
1820 static int attr_form_is_ref (const struct attribute *);
1822 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1823 struct dwarf2_loclist_baton *baton,
1824 const struct attribute *attr);
1826 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1828 struct dwarf2_cu *cu,
1831 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1832 const gdb_byte *info_ptr,
1833 struct abbrev_info *abbrev);
1835 static hashval_t partial_die_hash (const void *item);
1837 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1839 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1840 (sect_offset sect_off, unsigned int offset_in_dwz,
1841 struct dwarf2_per_objfile *dwarf2_per_objfile);
1843 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1844 struct die_info *comp_unit_die,
1845 enum language pretend_language);
1847 static void age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1849 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1851 static struct type *set_die_type (struct die_info *, struct type *,
1852 struct dwarf2_cu *);
1854 static void create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1856 static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1858 static void load_full_comp_unit (struct dwarf2_per_cu_data *, bool,
1861 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1864 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1867 static void dwarf2_add_dependence (struct dwarf2_cu *,
1868 struct dwarf2_per_cu_data *);
1870 static void dwarf2_mark (struct dwarf2_cu *);
1872 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1874 static struct type *get_die_type_at_offset (sect_offset,
1875 struct dwarf2_per_cu_data *);
1877 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1879 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1880 enum language pretend_language);
1882 static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile);
1884 /* Class, the destructor of which frees all allocated queue entries. This
1885 will only have work to do if an error was thrown while processing the
1886 dwarf. If no error was thrown then the queue entries should have all
1887 been processed, and freed, as we went along. */
1889 class dwarf2_queue_guard
1892 dwarf2_queue_guard () = default;
1894 /* Free any entries remaining on the queue. There should only be
1895 entries left if we hit an error while processing the dwarf. */
1896 ~dwarf2_queue_guard ()
1898 struct dwarf2_queue_item *item, *last;
1900 item = dwarf2_queue;
1903 /* Anything still marked queued is likely to be in an
1904 inconsistent state, so discard it. */
1905 if (item->per_cu->queued)
1907 if (item->per_cu->cu != NULL)
1908 free_one_cached_comp_unit (item->per_cu);
1909 item->per_cu->queued = 0;
1917 dwarf2_queue = dwarf2_queue_tail = NULL;
1921 /* The return type of find_file_and_directory. Note, the enclosed
1922 string pointers are only valid while this object is valid. */
1924 struct file_and_directory
1926 /* The filename. This is never NULL. */
1929 /* The compilation directory. NULL if not known. If we needed to
1930 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1931 points directly to the DW_AT_comp_dir string attribute owned by
1932 the obstack that owns the DIE. */
1933 const char *comp_dir;
1935 /* If we needed to build a new string for comp_dir, this is what
1936 owns the storage. */
1937 std::string comp_dir_storage;
1940 static file_and_directory find_file_and_directory (struct die_info *die,
1941 struct dwarf2_cu *cu);
1943 static char *file_full_name (int file, struct line_header *lh,
1944 const char *comp_dir);
1946 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
1947 enum class rcuh_kind { COMPILE, TYPE };
1949 static const gdb_byte *read_and_check_comp_unit_head
1950 (struct dwarf2_per_objfile* dwarf2_per_objfile,
1951 struct comp_unit_head *header,
1952 struct dwarf2_section_info *section,
1953 struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1954 rcuh_kind section_kind);
1956 static void init_cutu_and_read_dies
1957 (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1958 int use_existing_cu, int keep, bool skip_partial,
1959 die_reader_func_ftype *die_reader_func, void *data);
1961 static void init_cutu_and_read_dies_simple
1962 (struct dwarf2_per_cu_data *this_cu,
1963 die_reader_func_ftype *die_reader_func, void *data);
1965 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1967 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1969 static struct dwo_unit *lookup_dwo_unit_in_dwp
1970 (struct dwarf2_per_objfile *dwarf2_per_objfile,
1971 struct dwp_file *dwp_file, const char *comp_dir,
1972 ULONGEST signature, int is_debug_types);
1974 static struct dwp_file *get_dwp_file
1975 (struct dwarf2_per_objfile *dwarf2_per_objfile);
1977 static struct dwo_unit *lookup_dwo_comp_unit
1978 (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
1980 static struct dwo_unit *lookup_dwo_type_unit
1981 (struct signatured_type *, const char *, const char *);
1983 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
1985 static void free_dwo_file (struct dwo_file *);
1987 /* A unique_ptr helper to free a dwo_file. */
1989 struct dwo_file_deleter
1991 void operator() (struct dwo_file *df) const
1997 /* A unique pointer to a dwo_file. */
1999 typedef std::unique_ptr<struct dwo_file, dwo_file_deleter> dwo_file_up;
2001 static void process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile);
2003 static void check_producer (struct dwarf2_cu *cu);
2005 static void free_line_header_voidp (void *arg);
2007 /* Various complaints about symbol reading that don't abort the process. */
2010 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2012 complaint (_("statement list doesn't fit in .debug_line section"));
2016 dwarf2_debug_line_missing_file_complaint (void)
2018 complaint (_(".debug_line section has line data without a file"));
2022 dwarf2_debug_line_missing_end_sequence_complaint (void)
2024 complaint (_(".debug_line section has line "
2025 "program sequence without an end"));
2029 dwarf2_complex_location_expr_complaint (void)
2031 complaint (_("location expression too complex"));
2035 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
2038 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
2043 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
2045 complaint (_("debug info runs off end of %s section"
2047 get_section_name (section),
2048 get_section_file_name (section));
2052 dwarf2_macro_malformed_definition_complaint (const char *arg1)
2054 complaint (_("macro debug info contains a "
2055 "malformed macro definition:\n`%s'"),
2060 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
2062 complaint (_("invalid attribute class or form for '%s' in '%s'"),
2066 /* Hash function for line_header_hash. */
2069 line_header_hash (const struct line_header *ofs)
2071 return to_underlying (ofs->sect_off) ^ ofs->offset_in_dwz;
2074 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2077 line_header_hash_voidp (const void *item)
2079 const struct line_header *ofs = (const struct line_header *) item;
2081 return line_header_hash (ofs);
2084 /* Equality function for line_header_hash. */
2087 line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
2089 const struct line_header *ofs_lhs = (const struct line_header *) item_lhs;
2090 const struct line_header *ofs_rhs = (const struct line_header *) item_rhs;
2092 return (ofs_lhs->sect_off == ofs_rhs->sect_off
2093 && ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
2098 /* Read the given attribute value as an address, taking the attribute's
2099 form into account. */
2102 attr_value_as_address (struct attribute *attr)
2106 if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index)
2108 /* Aside from a few clearly defined exceptions, attributes that
2109 contain an address must always be in DW_FORM_addr form.
2110 Unfortunately, some compilers happen to be violating this
2111 requirement by encoding addresses using other forms, such
2112 as DW_FORM_data4 for example. For those broken compilers,
2113 we try to do our best, without any guarantee of success,
2114 to interpret the address correctly. It would also be nice
2115 to generate a complaint, but that would require us to maintain
2116 a list of legitimate cases where a non-address form is allowed,
2117 as well as update callers to pass in at least the CU's DWARF
2118 version. This is more overhead than what we're willing to
2119 expand for a pretty rare case. */
2120 addr = DW_UNSND (attr);
2123 addr = DW_ADDR (attr);
2128 /* See declaration. */
2130 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_,
2131 const dwarf2_debug_sections *names)
2132 : objfile (objfile_)
2135 names = &dwarf2_elf_names;
2137 bfd *obfd = objfile->obfd;
2139 for (asection *sec = obfd->sections; sec != NULL; sec = sec->next)
2140 locate_sections (obfd, sec, *names);
2143 static void free_dwo_files (htab_t dwo_files, struct objfile *objfile);
2145 dwarf2_per_objfile::~dwarf2_per_objfile ()
2147 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
2148 free_cached_comp_units ();
2150 if (quick_file_names_table)
2151 htab_delete (quick_file_names_table);
2153 if (line_header_hash)
2154 htab_delete (line_header_hash);
2156 for (dwarf2_per_cu_data *per_cu : all_comp_units)
2157 VEC_free (dwarf2_per_cu_ptr, per_cu->imported_symtabs);
2159 for (signatured_type *sig_type : all_type_units)
2160 VEC_free (dwarf2_per_cu_ptr, sig_type->per_cu.imported_symtabs);
2162 VEC_free (dwarf2_section_info_def, types);
2164 if (dwo_files != NULL)
2165 free_dwo_files (dwo_files, objfile);
2167 /* Everything else should be on the objfile obstack. */
2170 /* See declaration. */
2173 dwarf2_per_objfile::free_cached_comp_units ()
2175 dwarf2_per_cu_data *per_cu = read_in_chain;
2176 dwarf2_per_cu_data **last_chain = &read_in_chain;
2177 while (per_cu != NULL)
2179 dwarf2_per_cu_data *next_cu = per_cu->cu->read_in_chain;
2182 *last_chain = next_cu;
2187 /* A helper class that calls free_cached_comp_units on
2190 class free_cached_comp_units
2194 explicit free_cached_comp_units (dwarf2_per_objfile *per_objfile)
2195 : m_per_objfile (per_objfile)
2199 ~free_cached_comp_units ()
2201 m_per_objfile->free_cached_comp_units ();
2204 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units);
2208 dwarf2_per_objfile *m_per_objfile;
2211 /* Try to locate the sections we need for DWARF 2 debugging
2212 information and return true if we have enough to do something.
2213 NAMES points to the dwarf2 section names, or is NULL if the standard
2214 ELF names are used. */
2217 dwarf2_has_info (struct objfile *objfile,
2218 const struct dwarf2_debug_sections *names)
2220 if (objfile->flags & OBJF_READNEVER)
2223 struct dwarf2_per_objfile *dwarf2_per_objfile
2224 = get_dwarf2_per_objfile (objfile);
2226 if (dwarf2_per_objfile == NULL)
2228 /* Initialize per-objfile state. */
2230 = new (&objfile->objfile_obstack) struct dwarf2_per_objfile (objfile,
2232 set_dwarf2_per_objfile (objfile, dwarf2_per_objfile);
2234 return (!dwarf2_per_objfile->info.is_virtual
2235 && dwarf2_per_objfile->info.s.section != NULL
2236 && !dwarf2_per_objfile->abbrev.is_virtual
2237 && dwarf2_per_objfile->abbrev.s.section != NULL);
2240 /* Return the containing section of virtual section SECTION. */
2242 static struct dwarf2_section_info *
2243 get_containing_section (const struct dwarf2_section_info *section)
2245 gdb_assert (section->is_virtual);
2246 return section->s.containing_section;
2249 /* Return the bfd owner of SECTION. */
2252 get_section_bfd_owner (const struct dwarf2_section_info *section)
2254 if (section->is_virtual)
2256 section = get_containing_section (section);
2257 gdb_assert (!section->is_virtual);
2259 return section->s.section->owner;
2262 /* Return the bfd section of SECTION.
2263 Returns NULL if the section is not present. */
2266 get_section_bfd_section (const struct dwarf2_section_info *section)
2268 if (section->is_virtual)
2270 section = get_containing_section (section);
2271 gdb_assert (!section->is_virtual);
2273 return section->s.section;
2276 /* Return the name of SECTION. */
2279 get_section_name (const struct dwarf2_section_info *section)
2281 asection *sectp = get_section_bfd_section (section);
2283 gdb_assert (sectp != NULL);
2284 return bfd_section_name (get_section_bfd_owner (section), sectp);
2287 /* Return the name of the file SECTION is in. */
2290 get_section_file_name (const struct dwarf2_section_info *section)
2292 bfd *abfd = get_section_bfd_owner (section);
2294 return bfd_get_filename (abfd);
2297 /* Return the id of SECTION.
2298 Returns 0 if SECTION doesn't exist. */
2301 get_section_id (const struct dwarf2_section_info *section)
2303 asection *sectp = get_section_bfd_section (section);
2310 /* Return the flags of SECTION.
2311 SECTION (or containing section if this is a virtual section) must exist. */
2314 get_section_flags (const struct dwarf2_section_info *section)
2316 asection *sectp = get_section_bfd_section (section);
2318 gdb_assert (sectp != NULL);
2319 return bfd_get_section_flags (sectp->owner, sectp);
2322 /* When loading sections, we look either for uncompressed section or for
2323 compressed section names. */
2326 section_is_p (const char *section_name,
2327 const struct dwarf2_section_names *names)
2329 if (names->normal != NULL
2330 && strcmp (section_name, names->normal) == 0)
2332 if (names->compressed != NULL
2333 && strcmp (section_name, names->compressed) == 0)
2338 /* See declaration. */
2341 dwarf2_per_objfile::locate_sections (bfd *abfd, asection *sectp,
2342 const dwarf2_debug_sections &names)
2344 flagword aflag = bfd_get_section_flags (abfd, sectp);
2346 if ((aflag & SEC_HAS_CONTENTS) == 0)
2349 else if (section_is_p (sectp->name, &names.info))
2351 this->info.s.section = sectp;
2352 this->info.size = bfd_get_section_size (sectp);
2354 else if (section_is_p (sectp->name, &names.abbrev))
2356 this->abbrev.s.section = sectp;
2357 this->abbrev.size = bfd_get_section_size (sectp);
2359 else if (section_is_p (sectp->name, &names.line))
2361 this->line.s.section = sectp;
2362 this->line.size = bfd_get_section_size (sectp);
2364 else if (section_is_p (sectp->name, &names.loc))
2366 this->loc.s.section = sectp;
2367 this->loc.size = bfd_get_section_size (sectp);
2369 else if (section_is_p (sectp->name, &names.loclists))
2371 this->loclists.s.section = sectp;
2372 this->loclists.size = bfd_get_section_size (sectp);
2374 else if (section_is_p (sectp->name, &names.macinfo))
2376 this->macinfo.s.section = sectp;
2377 this->macinfo.size = bfd_get_section_size (sectp);
2379 else if (section_is_p (sectp->name, &names.macro))
2381 this->macro.s.section = sectp;
2382 this->macro.size = bfd_get_section_size (sectp);
2384 else if (section_is_p (sectp->name, &names.str))
2386 this->str.s.section = sectp;
2387 this->str.size = bfd_get_section_size (sectp);
2389 else if (section_is_p (sectp->name, &names.line_str))
2391 this->line_str.s.section = sectp;
2392 this->line_str.size = bfd_get_section_size (sectp);
2394 else if (section_is_p (sectp->name, &names.addr))
2396 this->addr.s.section = sectp;
2397 this->addr.size = bfd_get_section_size (sectp);
2399 else if (section_is_p (sectp->name, &names.frame))
2401 this->frame.s.section = sectp;
2402 this->frame.size = bfd_get_section_size (sectp);
2404 else if (section_is_p (sectp->name, &names.eh_frame))
2406 this->eh_frame.s.section = sectp;
2407 this->eh_frame.size = bfd_get_section_size (sectp);
2409 else if (section_is_p (sectp->name, &names.ranges))
2411 this->ranges.s.section = sectp;
2412 this->ranges.size = bfd_get_section_size (sectp);
2414 else if (section_is_p (sectp->name, &names.rnglists))
2416 this->rnglists.s.section = sectp;
2417 this->rnglists.size = bfd_get_section_size (sectp);
2419 else if (section_is_p (sectp->name, &names.types))
2421 struct dwarf2_section_info type_section;
2423 memset (&type_section, 0, sizeof (type_section));
2424 type_section.s.section = sectp;
2425 type_section.size = bfd_get_section_size (sectp);
2427 VEC_safe_push (dwarf2_section_info_def, this->types,
2430 else if (section_is_p (sectp->name, &names.gdb_index))
2432 this->gdb_index.s.section = sectp;
2433 this->gdb_index.size = bfd_get_section_size (sectp);
2435 else if (section_is_p (sectp->name, &names.debug_names))
2437 this->debug_names.s.section = sectp;
2438 this->debug_names.size = bfd_get_section_size (sectp);
2440 else if (section_is_p (sectp->name, &names.debug_aranges))
2442 this->debug_aranges.s.section = sectp;
2443 this->debug_aranges.size = bfd_get_section_size (sectp);
2446 if ((bfd_get_section_flags (abfd, sectp) & (SEC_LOAD | SEC_ALLOC))
2447 && bfd_section_vma (abfd, sectp) == 0)
2448 this->has_section_at_zero = true;
2451 /* A helper function that decides whether a section is empty,
2455 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2457 if (section->is_virtual)
2458 return section->size == 0;
2459 return section->s.section == NULL || section->size == 0;
2462 /* See dwarf2read.h. */
2465 dwarf2_read_section (struct objfile *objfile, dwarf2_section_info *info)
2469 gdb_byte *buf, *retbuf;
2473 info->buffer = NULL;
2476 if (dwarf2_section_empty_p (info))
2479 sectp = get_section_bfd_section (info);
2481 /* If this is a virtual section we need to read in the real one first. */
2482 if (info->is_virtual)
2484 struct dwarf2_section_info *containing_section =
2485 get_containing_section (info);
2487 gdb_assert (sectp != NULL);
2488 if ((sectp->flags & SEC_RELOC) != 0)
2490 error (_("Dwarf Error: DWP format V2 with relocations is not"
2491 " supported in section %s [in module %s]"),
2492 get_section_name (info), get_section_file_name (info));
2494 dwarf2_read_section (objfile, containing_section);
2495 /* Other code should have already caught virtual sections that don't
2497 gdb_assert (info->virtual_offset + info->size
2498 <= containing_section->size);
2499 /* If the real section is empty or there was a problem reading the
2500 section we shouldn't get here. */
2501 gdb_assert (containing_section->buffer != NULL);
2502 info->buffer = containing_section->buffer + info->virtual_offset;
2506 /* If the section has relocations, we must read it ourselves.
2507 Otherwise we attach it to the BFD. */
2508 if ((sectp->flags & SEC_RELOC) == 0)
2510 info->buffer = gdb_bfd_map_section (sectp, &info->size);
2514 buf = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, info->size);
2517 /* When debugging .o files, we may need to apply relocations; see
2518 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2519 We never compress sections in .o files, so we only need to
2520 try this when the section is not compressed. */
2521 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2524 info->buffer = retbuf;
2528 abfd = get_section_bfd_owner (info);
2529 gdb_assert (abfd != NULL);
2531 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2532 || bfd_bread (buf, info->size, abfd) != info->size)
2534 error (_("Dwarf Error: Can't read DWARF data"
2535 " in section %s [in module %s]"),
2536 bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2540 /* A helper function that returns the size of a section in a safe way.
2541 If you are positive that the section has been read before using the
2542 size, then it is safe to refer to the dwarf2_section_info object's
2543 "size" field directly. In other cases, you must call this
2544 function, because for compressed sections the size field is not set
2545 correctly until the section has been read. */
2547 static bfd_size_type
2548 dwarf2_section_size (struct objfile *objfile,
2549 struct dwarf2_section_info *info)
2552 dwarf2_read_section (objfile, info);
2556 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2560 dwarf2_get_section_info (struct objfile *objfile,
2561 enum dwarf2_section_enum sect,
2562 asection **sectp, const gdb_byte **bufp,
2563 bfd_size_type *sizep)
2565 struct dwarf2_per_objfile *data
2566 = (struct dwarf2_per_objfile *) objfile_data (objfile,
2567 dwarf2_objfile_data_key);
2568 struct dwarf2_section_info *info;
2570 /* We may see an objfile without any DWARF, in which case we just
2581 case DWARF2_DEBUG_FRAME:
2582 info = &data->frame;
2584 case DWARF2_EH_FRAME:
2585 info = &data->eh_frame;
2588 gdb_assert_not_reached ("unexpected section");
2591 dwarf2_read_section (objfile, info);
2593 *sectp = get_section_bfd_section (info);
2594 *bufp = info->buffer;
2595 *sizep = info->size;
2598 /* A helper function to find the sections for a .dwz file. */
2601 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2603 struct dwz_file *dwz_file = (struct dwz_file *) arg;
2605 /* Note that we only support the standard ELF names, because .dwz
2606 is ELF-only (at the time of writing). */
2607 if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2609 dwz_file->abbrev.s.section = sectp;
2610 dwz_file->abbrev.size = bfd_get_section_size (sectp);
2612 else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2614 dwz_file->info.s.section = sectp;
2615 dwz_file->info.size = bfd_get_section_size (sectp);
2617 else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2619 dwz_file->str.s.section = sectp;
2620 dwz_file->str.size = bfd_get_section_size (sectp);
2622 else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2624 dwz_file->line.s.section = sectp;
2625 dwz_file->line.size = bfd_get_section_size (sectp);
2627 else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2629 dwz_file->macro.s.section = sectp;
2630 dwz_file->macro.size = bfd_get_section_size (sectp);
2632 else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2634 dwz_file->gdb_index.s.section = sectp;
2635 dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2637 else if (section_is_p (sectp->name, &dwarf2_elf_names.debug_names))
2639 dwz_file->debug_names.s.section = sectp;
2640 dwz_file->debug_names.size = bfd_get_section_size (sectp);
2644 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2645 there is no .gnu_debugaltlink section in the file. Error if there
2646 is such a section but the file cannot be found. */
2648 static struct dwz_file *
2649 dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
2651 const char *filename;
2652 bfd_size_type buildid_len_arg;
2656 if (dwarf2_per_objfile->dwz_file != NULL)
2657 return dwarf2_per_objfile->dwz_file.get ();
2659 bfd_set_error (bfd_error_no_error);
2660 gdb::unique_xmalloc_ptr<char> data
2661 (bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2662 &buildid_len_arg, &buildid));
2665 if (bfd_get_error () == bfd_error_no_error)
2667 error (_("could not read '.gnu_debugaltlink' section: %s"),
2668 bfd_errmsg (bfd_get_error ()));
2671 gdb::unique_xmalloc_ptr<bfd_byte> buildid_holder (buildid);
2673 buildid_len = (size_t) buildid_len_arg;
2675 filename = data.get ();
2677 std::string abs_storage;
2678 if (!IS_ABSOLUTE_PATH (filename))
2680 gdb::unique_xmalloc_ptr<char> abs
2681 = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2683 abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
2684 filename = abs_storage.c_str ();
2687 /* First try the file name given in the section. If that doesn't
2688 work, try to use the build-id instead. */
2689 gdb_bfd_ref_ptr dwz_bfd (gdb_bfd_open (filename, gnutarget, -1));
2690 if (dwz_bfd != NULL)
2692 if (!build_id_verify (dwz_bfd.get (), buildid_len, buildid))
2696 if (dwz_bfd == NULL)
2697 dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2699 if (dwz_bfd == NULL)
2700 error (_("could not find '.gnu_debugaltlink' file for %s"),
2701 objfile_name (dwarf2_per_objfile->objfile));
2703 std::unique_ptr<struct dwz_file> result
2704 (new struct dwz_file (std::move (dwz_bfd)));
2706 bfd_map_over_sections (result->dwz_bfd.get (), locate_dwz_sections,
2709 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd,
2710 result->dwz_bfd.get ());
2711 dwarf2_per_objfile->dwz_file = std::move (result);
2712 return dwarf2_per_objfile->dwz_file.get ();
2715 /* DWARF quick_symbols_functions support. */
2717 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2718 unique line tables, so we maintain a separate table of all .debug_line
2719 derived entries to support the sharing.
2720 All the quick functions need is the list of file names. We discard the
2721 line_header when we're done and don't need to record it here. */
2722 struct quick_file_names
2724 /* The data used to construct the hash key. */
2725 struct stmt_list_hash hash;
2727 /* The number of entries in file_names, real_names. */
2728 unsigned int num_file_names;
2730 /* The file names from the line table, after being run through
2732 const char **file_names;
2734 /* The file names from the line table after being run through
2735 gdb_realpath. These are computed lazily. */
2736 const char **real_names;
2739 /* When using the index (and thus not using psymtabs), each CU has an
2740 object of this type. This is used to hold information needed by
2741 the various "quick" methods. */
2742 struct dwarf2_per_cu_quick_data
2744 /* The file table. This can be NULL if there was no file table
2745 or it's currently not read in.
2746 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2747 struct quick_file_names *file_names;
2749 /* The corresponding symbol table. This is NULL if symbols for this
2750 CU have not yet been read. */
2751 struct compunit_symtab *compunit_symtab;
2753 /* A temporary mark bit used when iterating over all CUs in
2754 expand_symtabs_matching. */
2755 unsigned int mark : 1;
2757 /* True if we've tried to read the file table and found there isn't one.
2758 There will be no point in trying to read it again next time. */
2759 unsigned int no_file_data : 1;
2762 /* Utility hash function for a stmt_list_hash. */
2765 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2769 if (stmt_list_hash->dwo_unit != NULL)
2770 v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2771 v += to_underlying (stmt_list_hash->line_sect_off);
2775 /* Utility equality function for a stmt_list_hash. */
2778 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2779 const struct stmt_list_hash *rhs)
2781 if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2783 if (lhs->dwo_unit != NULL
2784 && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2787 return lhs->line_sect_off == rhs->line_sect_off;
2790 /* Hash function for a quick_file_names. */
2793 hash_file_name_entry (const void *e)
2795 const struct quick_file_names *file_data
2796 = (const struct quick_file_names *) e;
2798 return hash_stmt_list_entry (&file_data->hash);
2801 /* Equality function for a quick_file_names. */
2804 eq_file_name_entry (const void *a, const void *b)
2806 const struct quick_file_names *ea = (const struct quick_file_names *) a;
2807 const struct quick_file_names *eb = (const struct quick_file_names *) b;
2809 return eq_stmt_list_entry (&ea->hash, &eb->hash);
2812 /* Delete function for a quick_file_names. */
2815 delete_file_name_entry (void *e)
2817 struct quick_file_names *file_data = (struct quick_file_names *) e;
2820 for (i = 0; i < file_data->num_file_names; ++i)
2822 xfree ((void*) file_data->file_names[i]);
2823 if (file_data->real_names)
2824 xfree ((void*) file_data->real_names[i]);
2827 /* The space for the struct itself lives on objfile_obstack,
2828 so we don't free it here. */
2831 /* Create a quick_file_names hash table. */
2834 create_quick_file_names_table (unsigned int nr_initial_entries)
2836 return htab_create_alloc (nr_initial_entries,
2837 hash_file_name_entry, eq_file_name_entry,
2838 delete_file_name_entry, xcalloc, xfree);
2841 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2842 have to be created afterwards. You should call age_cached_comp_units after
2843 processing PER_CU->CU. dw2_setup must have been already called. */
2846 load_cu (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2848 if (per_cu->is_debug_types)
2849 load_full_type_unit (per_cu);
2851 load_full_comp_unit (per_cu, skip_partial, language_minimal);
2853 if (per_cu->cu == NULL)
2854 return; /* Dummy CU. */
2856 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2859 /* Read in the symbols for PER_CU. */
2862 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2864 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2866 /* Skip type_unit_groups, reading the type units they contain
2867 is handled elsewhere. */
2868 if (IS_TYPE_UNIT_GROUP (per_cu))
2871 /* The destructor of dwarf2_queue_guard frees any entries left on
2872 the queue. After this point we're guaranteed to leave this function
2873 with the dwarf queue empty. */
2874 dwarf2_queue_guard q_guard;
2876 if (dwarf2_per_objfile->using_index
2877 ? per_cu->v.quick->compunit_symtab == NULL
2878 : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2880 queue_comp_unit (per_cu, language_minimal);
2881 load_cu (per_cu, skip_partial);
2883 /* If we just loaded a CU from a DWO, and we're working with an index
2884 that may badly handle TUs, load all the TUs in that DWO as well.
2885 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2886 if (!per_cu->is_debug_types
2887 && per_cu->cu != NULL
2888 && per_cu->cu->dwo_unit != NULL
2889 && dwarf2_per_objfile->index_table != NULL
2890 && dwarf2_per_objfile->index_table->version <= 7
2891 /* DWP files aren't supported yet. */
2892 && get_dwp_file (dwarf2_per_objfile) == NULL)
2893 queue_and_load_all_dwo_tus (per_cu);
2896 process_queue (dwarf2_per_objfile);
2898 /* Age the cache, releasing compilation units that have not
2899 been used recently. */
2900 age_cached_comp_units (dwarf2_per_objfile);
2903 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2904 the objfile from which this CU came. Returns the resulting symbol
2907 static struct compunit_symtab *
2908 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2910 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2912 gdb_assert (dwarf2_per_objfile->using_index);
2913 if (!per_cu->v.quick->compunit_symtab)
2915 free_cached_comp_units freer (dwarf2_per_objfile);
2916 scoped_restore decrementer = increment_reading_symtab ();
2917 dw2_do_instantiate_symtab (per_cu, skip_partial);
2918 process_cu_includes (dwarf2_per_objfile);
2921 return per_cu->v.quick->compunit_symtab;
2924 /* See declaration. */
2926 dwarf2_per_cu_data *
2927 dwarf2_per_objfile::get_cutu (int index)
2929 if (index >= this->all_comp_units.size ())
2931 index -= this->all_comp_units.size ();
2932 gdb_assert (index < this->all_type_units.size ());
2933 return &this->all_type_units[index]->per_cu;
2936 return this->all_comp_units[index];
2939 /* See declaration. */
2941 dwarf2_per_cu_data *
2942 dwarf2_per_objfile::get_cu (int index)
2944 gdb_assert (index >= 0 && index < this->all_comp_units.size ());
2946 return this->all_comp_units[index];
2949 /* See declaration. */
2952 dwarf2_per_objfile::get_tu (int index)
2954 gdb_assert (index >= 0 && index < this->all_type_units.size ());
2956 return this->all_type_units[index];
2959 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2960 objfile_obstack, and constructed with the specified field
2963 static dwarf2_per_cu_data *
2964 create_cu_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2965 struct dwarf2_section_info *section,
2967 sect_offset sect_off, ULONGEST length)
2969 struct objfile *objfile = dwarf2_per_objfile->objfile;
2970 dwarf2_per_cu_data *the_cu
2971 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2972 struct dwarf2_per_cu_data);
2973 the_cu->sect_off = sect_off;
2974 the_cu->length = length;
2975 the_cu->dwarf2_per_objfile = dwarf2_per_objfile;
2976 the_cu->section = section;
2977 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2978 struct dwarf2_per_cu_quick_data);
2979 the_cu->is_dwz = is_dwz;
2983 /* A helper for create_cus_from_index that handles a given list of
2987 create_cus_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2988 const gdb_byte *cu_list, offset_type n_elements,
2989 struct dwarf2_section_info *section,
2992 for (offset_type i = 0; i < n_elements; i += 2)
2994 gdb_static_assert (sizeof (ULONGEST) >= 8);
2996 sect_offset sect_off
2997 = (sect_offset) extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
2998 ULONGEST length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
3001 dwarf2_per_cu_data *per_cu
3002 = create_cu_from_index_list (dwarf2_per_objfile, section, is_dwz,
3004 dwarf2_per_objfile->all_comp_units.push_back (per_cu);
3008 /* Read the CU list from the mapped index, and use it to create all
3009 the CU objects for this objfile. */
3012 create_cus_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3013 const gdb_byte *cu_list, offset_type cu_list_elements,
3014 const gdb_byte *dwz_list, offset_type dwz_elements)
3016 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
3017 dwarf2_per_objfile->all_comp_units.reserve
3018 ((cu_list_elements + dwz_elements) / 2);
3020 create_cus_from_index_list (dwarf2_per_objfile, cu_list, cu_list_elements,
3021 &dwarf2_per_objfile->info, 0);
3023 if (dwz_elements == 0)
3026 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3027 create_cus_from_index_list (dwarf2_per_objfile, dwz_list, dwz_elements,
3031 /* Create the signatured type hash table from the index. */
3034 create_signatured_type_table_from_index
3035 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3036 struct dwarf2_section_info *section,
3037 const gdb_byte *bytes,
3038 offset_type elements)
3040 struct objfile *objfile = dwarf2_per_objfile->objfile;
3042 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3043 dwarf2_per_objfile->all_type_units.reserve (elements / 3);
3045 htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3047 for (offset_type i = 0; i < elements; i += 3)
3049 struct signatured_type *sig_type;
3052 cu_offset type_offset_in_tu;
3054 gdb_static_assert (sizeof (ULONGEST) >= 8);
3055 sect_offset sect_off
3056 = (sect_offset) extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
3058 = (cu_offset) extract_unsigned_integer (bytes + 8, 8,
3060 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
3063 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3064 struct signatured_type);
3065 sig_type->signature = signature;
3066 sig_type->type_offset_in_tu = type_offset_in_tu;
3067 sig_type->per_cu.is_debug_types = 1;
3068 sig_type->per_cu.section = section;
3069 sig_type->per_cu.sect_off = sect_off;
3070 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3071 sig_type->per_cu.v.quick
3072 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3073 struct dwarf2_per_cu_quick_data);
3075 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3078 dwarf2_per_objfile->all_type_units.push_back (sig_type);
3081 dwarf2_per_objfile->signatured_types = sig_types_hash;
3084 /* Create the signatured type hash table from .debug_names. */
3087 create_signatured_type_table_from_debug_names
3088 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3089 const mapped_debug_names &map,
3090 struct dwarf2_section_info *section,
3091 struct dwarf2_section_info *abbrev_section)
3093 struct objfile *objfile = dwarf2_per_objfile->objfile;
3095 dwarf2_read_section (objfile, section);
3096 dwarf2_read_section (objfile, abbrev_section);
3098 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3099 dwarf2_per_objfile->all_type_units.reserve (map.tu_count);
3101 htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3103 for (uint32_t i = 0; i < map.tu_count; ++i)
3105 struct signatured_type *sig_type;
3108 sect_offset sect_off
3109 = (sect_offset) (extract_unsigned_integer
3110 (map.tu_table_reordered + i * map.offset_size,
3112 map.dwarf5_byte_order));
3114 comp_unit_head cu_header;
3115 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
3117 section->buffer + to_underlying (sect_off),
3120 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3121 struct signatured_type);
3122 sig_type->signature = cu_header.signature;
3123 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
3124 sig_type->per_cu.is_debug_types = 1;
3125 sig_type->per_cu.section = section;
3126 sig_type->per_cu.sect_off = sect_off;
3127 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3128 sig_type->per_cu.v.quick
3129 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3130 struct dwarf2_per_cu_quick_data);
3132 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3135 dwarf2_per_objfile->all_type_units.push_back (sig_type);
3138 dwarf2_per_objfile->signatured_types = sig_types_hash;
3141 /* Read the address map data from the mapped index, and use it to
3142 populate the objfile's psymtabs_addrmap. */
3145 create_addrmap_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3146 struct mapped_index *index)
3148 struct objfile *objfile = dwarf2_per_objfile->objfile;
3149 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3150 const gdb_byte *iter, *end;
3151 struct addrmap *mutable_map;
3154 auto_obstack temp_obstack;
3156 mutable_map = addrmap_create_mutable (&temp_obstack);
3158 iter = index->address_table.data ();
3159 end = iter + index->address_table.size ();
3161 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3165 ULONGEST hi, lo, cu_index;
3166 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3168 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3170 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
3175 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
3176 hex_string (lo), hex_string (hi));
3180 if (cu_index >= dwarf2_per_objfile->all_comp_units.size ())
3182 complaint (_(".gdb_index address table has invalid CU number %u"),
3183 (unsigned) cu_index);
3187 lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr) - baseaddr;
3188 hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr) - baseaddr;
3189 addrmap_set_empty (mutable_map, lo, hi - 1,
3190 dwarf2_per_objfile->get_cu (cu_index));
3193 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
3194 &objfile->objfile_obstack);
3197 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3198 populate the objfile's psymtabs_addrmap. */
3201 create_addrmap_from_aranges (struct dwarf2_per_objfile *dwarf2_per_objfile,
3202 struct dwarf2_section_info *section)
3204 struct objfile *objfile = dwarf2_per_objfile->objfile;
3205 bfd *abfd = objfile->obfd;
3206 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3207 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
3208 SECT_OFF_TEXT (objfile));
3210 auto_obstack temp_obstack;
3211 addrmap *mutable_map = addrmap_create_mutable (&temp_obstack);
3213 std::unordered_map<sect_offset,
3214 dwarf2_per_cu_data *,
3215 gdb::hash_enum<sect_offset>>
3216 debug_info_offset_to_per_cu;
3217 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3219 const auto insertpair
3220 = debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);
3221 if (!insertpair.second)
3223 warning (_("Section .debug_aranges in %s has duplicate "
3224 "debug_info_offset %s, ignoring .debug_aranges."),
3225 objfile_name (objfile), sect_offset_str (per_cu->sect_off));
3230 dwarf2_read_section (objfile, section);
3232 const bfd_endian dwarf5_byte_order = gdbarch_byte_order (gdbarch);
3234 const gdb_byte *addr = section->buffer;
3236 while (addr < section->buffer + section->size)
3238 const gdb_byte *const entry_addr = addr;
3239 unsigned int bytes_read;
3241 const LONGEST entry_length = read_initial_length (abfd, addr,
3245 const gdb_byte *const entry_end = addr + entry_length;
3246 const bool dwarf5_is_dwarf64 = bytes_read != 4;
3247 const uint8_t offset_size = dwarf5_is_dwarf64 ? 8 : 4;
3248 if (addr + entry_length > section->buffer + section->size)
3250 warning (_("Section .debug_aranges in %s entry at offset %zu "
3251 "length %s exceeds section length %s, "
3252 "ignoring .debug_aranges."),
3253 objfile_name (objfile), entry_addr - section->buffer,
3254 plongest (bytes_read + entry_length),
3255 pulongest (section->size));
3259 /* The version number. */
3260 const uint16_t version = read_2_bytes (abfd, addr);
3264 warning (_("Section .debug_aranges in %s entry at offset %zu "
3265 "has unsupported version %d, ignoring .debug_aranges."),
3266 objfile_name (objfile), entry_addr - section->buffer,
3271 const uint64_t debug_info_offset
3272 = extract_unsigned_integer (addr, offset_size, dwarf5_byte_order);
3273 addr += offset_size;
3274 const auto per_cu_it
3275 = debug_info_offset_to_per_cu.find (sect_offset (debug_info_offset));
3276 if (per_cu_it == debug_info_offset_to_per_cu.cend ())
3278 warning (_("Section .debug_aranges in %s entry at offset %zu "
3279 "debug_info_offset %s does not exists, "
3280 "ignoring .debug_aranges."),
3281 objfile_name (objfile), entry_addr - section->buffer,
3282 pulongest (debug_info_offset));
3285 dwarf2_per_cu_data *const per_cu = per_cu_it->second;
3287 const uint8_t address_size = *addr++;
3288 if (address_size < 1 || address_size > 8)
3290 warning (_("Section .debug_aranges in %s entry at offset %zu "
3291 "address_size %u is invalid, ignoring .debug_aranges."),
3292 objfile_name (objfile), entry_addr - section->buffer,
3297 const uint8_t segment_selector_size = *addr++;
3298 if (segment_selector_size != 0)
3300 warning (_("Section .debug_aranges in %s entry at offset %zu "
3301 "segment_selector_size %u is not supported, "
3302 "ignoring .debug_aranges."),
3303 objfile_name (objfile), entry_addr - section->buffer,
3304 segment_selector_size);
3308 /* Must pad to an alignment boundary that is twice the address
3309 size. It is undocumented by the DWARF standard but GCC does
3311 for (size_t padding = ((-(addr - section->buffer))
3312 & (2 * address_size - 1));
3313 padding > 0; padding--)
3316 warning (_("Section .debug_aranges in %s entry at offset %zu "
3317 "padding is not zero, ignoring .debug_aranges."),
3318 objfile_name (objfile), entry_addr - section->buffer);
3324 if (addr + 2 * address_size > entry_end)
3326 warning (_("Section .debug_aranges in %s entry at offset %zu "
3327 "address list is not properly terminated, "
3328 "ignoring .debug_aranges."),
3329 objfile_name (objfile), entry_addr - section->buffer);
3332 ULONGEST start = extract_unsigned_integer (addr, address_size,
3334 addr += address_size;
3335 ULONGEST length = extract_unsigned_integer (addr, address_size,
3337 addr += address_size;
3338 if (start == 0 && length == 0)
3340 if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
3342 /* Symbol was eliminated due to a COMDAT group. */
3345 ULONGEST end = start + length;
3346 start = (gdbarch_adjust_dwarf2_addr (gdbarch, start + baseaddr)
3348 end = (gdbarch_adjust_dwarf2_addr (gdbarch, end + baseaddr)
3350 addrmap_set_empty (mutable_map, start, end - 1, per_cu);
3354 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
3355 &objfile->objfile_obstack);
3358 /* Find a slot in the mapped index INDEX for the object named NAME.
3359 If NAME is found, set *VEC_OUT to point to the CU vector in the
3360 constant pool and return true. If NAME cannot be found, return
3364 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
3365 offset_type **vec_out)
3368 offset_type slot, step;
3369 int (*cmp) (const char *, const char *);
3371 gdb::unique_xmalloc_ptr<char> without_params;
3372 if (current_language->la_language == language_cplus
3373 || current_language->la_language == language_fortran
3374 || current_language->la_language == language_d)
3376 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3379 if (strchr (name, '(') != NULL)
3381 without_params = cp_remove_params (name);
3383 if (without_params != NULL)
3384 name = without_params.get ();
3388 /* Index version 4 did not support case insensitive searches. But the
3389 indices for case insensitive languages are built in lowercase, therefore
3390 simulate our NAME being searched is also lowercased. */
3391 hash = mapped_index_string_hash ((index->version == 4
3392 && case_sensitivity == case_sensitive_off
3393 ? 5 : index->version),
3396 slot = hash & (index->symbol_table.size () - 1);
3397 step = ((hash * 17) & (index->symbol_table.size () - 1)) | 1;
3398 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
3404 const auto &bucket = index->symbol_table[slot];
3405 if (bucket.name == 0 && bucket.vec == 0)
3408 str = index->constant_pool + MAYBE_SWAP (bucket.name);
3409 if (!cmp (name, str))
3411 *vec_out = (offset_type *) (index->constant_pool
3412 + MAYBE_SWAP (bucket.vec));
3416 slot = (slot + step) & (index->symbol_table.size () - 1);
3420 /* A helper function that reads the .gdb_index from BUFFER and fills
3421 in MAP. FILENAME is the name of the file containing the data;
3422 it is used for error reporting. DEPRECATED_OK is true if it is
3423 ok to use deprecated sections.
3425 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3426 out parameters that are filled in with information about the CU and
3427 TU lists in the section.
3429 Returns true if all went well, false otherwise. */
3432 read_gdb_index_from_buffer (struct objfile *objfile,
3433 const char *filename,
3435 gdb::array_view<const gdb_byte> buffer,
3436 struct mapped_index *map,
3437 const gdb_byte **cu_list,
3438 offset_type *cu_list_elements,
3439 const gdb_byte **types_list,
3440 offset_type *types_list_elements)
3442 const gdb_byte *addr = &buffer[0];
3444 /* Version check. */
3445 offset_type version = MAYBE_SWAP (*(offset_type *) addr);
3446 /* Versions earlier than 3 emitted every copy of a psymbol. This
3447 causes the index to behave very poorly for certain requests. Version 3
3448 contained incomplete addrmap. So, it seems better to just ignore such
3452 static int warning_printed = 0;
3453 if (!warning_printed)
3455 warning (_("Skipping obsolete .gdb_index section in %s."),
3457 warning_printed = 1;
3461 /* Index version 4 uses a different hash function than index version
3464 Versions earlier than 6 did not emit psymbols for inlined
3465 functions. Using these files will cause GDB not to be able to
3466 set breakpoints on inlined functions by name, so we ignore these
3467 indices unless the user has done
3468 "set use-deprecated-index-sections on". */
3469 if (version < 6 && !deprecated_ok)
3471 static int warning_printed = 0;
3472 if (!warning_printed)
3475 Skipping deprecated .gdb_index section in %s.\n\
3476 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3477 to use the section anyway."),
3479 warning_printed = 1;
3483 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3484 of the TU (for symbols coming from TUs),
3485 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3486 Plus gold-generated indices can have duplicate entries for global symbols,
3487 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3488 These are just performance bugs, and we can't distinguish gdb-generated
3489 indices from gold-generated ones, so issue no warning here. */
3491 /* Indexes with higher version than the one supported by GDB may be no
3492 longer backward compatible. */
3496 map->version = version;
3498 offset_type *metadata = (offset_type *) (addr + sizeof (offset_type));
3501 *cu_list = addr + MAYBE_SWAP (metadata[i]);
3502 *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3506 *types_list = addr + MAYBE_SWAP (metadata[i]);
3507 *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3508 - MAYBE_SWAP (metadata[i]))
3512 const gdb_byte *address_table = addr + MAYBE_SWAP (metadata[i]);
3513 const gdb_byte *address_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3515 = gdb::array_view<const gdb_byte> (address_table, address_table_end);
3518 const gdb_byte *symbol_table = addr + MAYBE_SWAP (metadata[i]);
3519 const gdb_byte *symbol_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3521 = gdb::array_view<mapped_index::symbol_table_slot>
3522 ((mapped_index::symbol_table_slot *) symbol_table,
3523 (mapped_index::symbol_table_slot *) symbol_table_end);
3526 map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3531 /* Callback types for dwarf2_read_gdb_index. */
3533 typedef gdb::function_view
3534 <gdb::array_view<const gdb_byte>(objfile *, dwarf2_per_objfile *)>
3535 get_gdb_index_contents_ftype;
3536 typedef gdb::function_view
3537 <gdb::array_view<const gdb_byte>(objfile *, dwz_file *)>
3538 get_gdb_index_contents_dwz_ftype;
3540 /* Read .gdb_index. If everything went ok, initialize the "quick"
3541 elements of all the CUs and return 1. Otherwise, return 0. */
3544 dwarf2_read_gdb_index
3545 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3546 get_gdb_index_contents_ftype get_gdb_index_contents,
3547 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz)
3549 const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3550 offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3551 struct dwz_file *dwz;
3552 struct objfile *objfile = dwarf2_per_objfile->objfile;
3554 gdb::array_view<const gdb_byte> main_index_contents
3555 = get_gdb_index_contents (objfile, dwarf2_per_objfile);
3557 if (main_index_contents.empty ())
3560 std::unique_ptr<struct mapped_index> map (new struct mapped_index);
3561 if (!read_gdb_index_from_buffer (objfile, objfile_name (objfile),
3562 use_deprecated_index_sections,
3563 main_index_contents, map.get (), &cu_list,
3564 &cu_list_elements, &types_list,
3565 &types_list_elements))
3568 /* Don't use the index if it's empty. */
3569 if (map->symbol_table.empty ())
3572 /* If there is a .dwz file, read it so we can get its CU list as
3574 dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3577 struct mapped_index dwz_map;
3578 const gdb_byte *dwz_types_ignore;
3579 offset_type dwz_types_elements_ignore;
3581 gdb::array_view<const gdb_byte> dwz_index_content
3582 = get_gdb_index_contents_dwz (objfile, dwz);
3584 if (dwz_index_content.empty ())
3587 if (!read_gdb_index_from_buffer (objfile,
3588 bfd_get_filename (dwz->dwz_bfd), 1,
3589 dwz_index_content, &dwz_map,
3590 &dwz_list, &dwz_list_elements,
3592 &dwz_types_elements_ignore))
3594 warning (_("could not read '.gdb_index' section from %s; skipping"),
3595 bfd_get_filename (dwz->dwz_bfd));
3600 create_cus_from_index (dwarf2_per_objfile, cu_list, cu_list_elements,
3601 dwz_list, dwz_list_elements);
3603 if (types_list_elements)
3605 struct dwarf2_section_info *section;
3607 /* We can only handle a single .debug_types when we have an
3609 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3612 section = VEC_index (dwarf2_section_info_def,
3613 dwarf2_per_objfile->types, 0);
3615 create_signatured_type_table_from_index (dwarf2_per_objfile, section,
3616 types_list, types_list_elements);
3619 create_addrmap_from_index (dwarf2_per_objfile, map.get ());
3621 dwarf2_per_objfile->index_table = std::move (map);
3622 dwarf2_per_objfile->using_index = 1;
3623 dwarf2_per_objfile->quick_file_names_table =
3624 create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
3629 /* die_reader_func for dw2_get_file_names. */
3632 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3633 const gdb_byte *info_ptr,
3634 struct die_info *comp_unit_die,
3638 struct dwarf2_cu *cu = reader->cu;
3639 struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3640 struct dwarf2_per_objfile *dwarf2_per_objfile
3641 = cu->per_cu->dwarf2_per_objfile;
3642 struct objfile *objfile = dwarf2_per_objfile->objfile;
3643 struct dwarf2_per_cu_data *lh_cu;
3644 struct attribute *attr;
3647 struct quick_file_names *qfn;
3649 gdb_assert (! this_cu->is_debug_types);
3651 /* Our callers never want to match partial units -- instead they
3652 will match the enclosing full CU. */
3653 if (comp_unit_die->tag == DW_TAG_partial_unit)
3655 this_cu->v.quick->no_file_data = 1;
3663 sect_offset line_offset {};
3665 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3668 struct quick_file_names find_entry;
3670 line_offset = (sect_offset) DW_UNSND (attr);
3672 /* We may have already read in this line header (TU line header sharing).
3673 If we have we're done. */
3674 find_entry.hash.dwo_unit = cu->dwo_unit;
3675 find_entry.hash.line_sect_off = line_offset;
3676 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3677 &find_entry, INSERT);
3680 lh_cu->v.quick->file_names = (struct quick_file_names *) *slot;
3684 lh = dwarf_decode_line_header (line_offset, cu);
3688 lh_cu->v.quick->no_file_data = 1;
3692 qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
3693 qfn->hash.dwo_unit = cu->dwo_unit;
3694 qfn->hash.line_sect_off = line_offset;
3695 gdb_assert (slot != NULL);
3698 file_and_directory fnd = find_file_and_directory (comp_unit_die, cu);
3700 qfn->num_file_names = lh->file_names.size ();
3702 XOBNEWVEC (&objfile->objfile_obstack, const char *, lh->file_names.size ());
3703 for (i = 0; i < lh->file_names.size (); ++i)
3704 qfn->file_names[i] = file_full_name (i + 1, lh.get (), fnd.comp_dir);
3705 qfn->real_names = NULL;
3707 lh_cu->v.quick->file_names = qfn;
3710 /* A helper for the "quick" functions which attempts to read the line
3711 table for THIS_CU. */
3713 static struct quick_file_names *
3714 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3716 /* This should never be called for TUs. */
3717 gdb_assert (! this_cu->is_debug_types);
3718 /* Nor type unit groups. */
3719 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3721 if (this_cu->v.quick->file_names != NULL)
3722 return this_cu->v.quick->file_names;
3723 /* If we know there is no line data, no point in looking again. */
3724 if (this_cu->v.quick->no_file_data)
3727 init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3729 if (this_cu->v.quick->no_file_data)
3731 return this_cu->v.quick->file_names;
3734 /* A helper for the "quick" functions which computes and caches the
3735 real path for a given file name from the line table. */
3738 dw2_get_real_path (struct objfile *objfile,
3739 struct quick_file_names *qfn, int index)
3741 if (qfn->real_names == NULL)
3742 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3743 qfn->num_file_names, const char *);
3745 if (qfn->real_names[index] == NULL)
3746 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]).release ();
3748 return qfn->real_names[index];
3751 static struct symtab *
3752 dw2_find_last_source_symtab (struct objfile *objfile)
3754 struct dwarf2_per_objfile *dwarf2_per_objfile
3755 = get_dwarf2_per_objfile (objfile);
3756 dwarf2_per_cu_data *dwarf_cu = dwarf2_per_objfile->all_comp_units.back ();
3757 compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu, false);
3762 return compunit_primary_filetab (cust);
3765 /* Traversal function for dw2_forget_cached_source_info. */
3768 dw2_free_cached_file_names (void **slot, void *info)
3770 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3772 if (file_data->real_names)
3776 for (i = 0; i < file_data->num_file_names; ++i)
3778 xfree ((void*) file_data->real_names[i]);
3779 file_data->real_names[i] = NULL;
3787 dw2_forget_cached_source_info (struct objfile *objfile)
3789 struct dwarf2_per_objfile *dwarf2_per_objfile
3790 = get_dwarf2_per_objfile (objfile);
3792 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3793 dw2_free_cached_file_names, NULL);
3796 /* Helper function for dw2_map_symtabs_matching_filename that expands
3797 the symtabs and calls the iterator. */
3800 dw2_map_expand_apply (struct objfile *objfile,
3801 struct dwarf2_per_cu_data *per_cu,
3802 const char *name, const char *real_path,
3803 gdb::function_view<bool (symtab *)> callback)
3805 struct compunit_symtab *last_made = objfile->compunit_symtabs;
3807 /* Don't visit already-expanded CUs. */
3808 if (per_cu->v.quick->compunit_symtab)
3811 /* This may expand more than one symtab, and we want to iterate over
3813 dw2_instantiate_symtab (per_cu, false);
3815 return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
3816 last_made, callback);
3819 /* Implementation of the map_symtabs_matching_filename method. */
3822 dw2_map_symtabs_matching_filename
3823 (struct objfile *objfile, const char *name, const char *real_path,
3824 gdb::function_view<bool (symtab *)> callback)
3826 const char *name_basename = lbasename (name);
3827 struct dwarf2_per_objfile *dwarf2_per_objfile
3828 = get_dwarf2_per_objfile (objfile);
3830 /* The rule is CUs specify all the files, including those used by
3831 any TU, so there's no need to scan TUs here. */
3833 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3835 /* We only need to look at symtabs not already expanded. */
3836 if (per_cu->v.quick->compunit_symtab)
3839 quick_file_names *file_data = dw2_get_file_names (per_cu);
3840 if (file_data == NULL)
3843 for (int j = 0; j < file_data->num_file_names; ++j)
3845 const char *this_name = file_data->file_names[j];
3846 const char *this_real_name;
3848 if (compare_filenames_for_search (this_name, name))
3850 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3856 /* Before we invoke realpath, which can get expensive when many
3857 files are involved, do a quick comparison of the basenames. */
3858 if (! basenames_may_differ
3859 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3862 this_real_name = dw2_get_real_path (objfile, file_data, j);
3863 if (compare_filenames_for_search (this_real_name, name))
3865 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3871 if (real_path != NULL)
3873 gdb_assert (IS_ABSOLUTE_PATH (real_path));
3874 gdb_assert (IS_ABSOLUTE_PATH (name));
3875 if (this_real_name != NULL
3876 && FILENAME_CMP (real_path, this_real_name) == 0)
3878 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3890 /* Struct used to manage iterating over all CUs looking for a symbol. */
3892 struct dw2_symtab_iterator
3894 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3895 struct dwarf2_per_objfile *dwarf2_per_objfile;
3896 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3897 int want_specific_block;
3898 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3899 Unused if !WANT_SPECIFIC_BLOCK. */
3901 /* The kind of symbol we're looking for. */
3903 /* The list of CUs from the index entry of the symbol,
3904 or NULL if not found. */
3906 /* The next element in VEC to look at. */
3908 /* The number of elements in VEC, or zero if there is no match. */
3910 /* Have we seen a global version of the symbol?
3911 If so we can ignore all further global instances.
3912 This is to work around gold/15646, inefficient gold-generated
3917 /* Initialize the index symtab iterator ITER.
3918 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3919 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3922 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3923 struct dwarf2_per_objfile *dwarf2_per_objfile,
3924 int want_specific_block,
3929 iter->dwarf2_per_objfile = dwarf2_per_objfile;
3930 iter->want_specific_block = want_specific_block;
3931 iter->block_index = block_index;
3932 iter->domain = domain;
3934 iter->global_seen = 0;
3936 mapped_index *index = dwarf2_per_objfile->index_table.get ();
3938 /* index is NULL if OBJF_READNOW. */
3939 if (index != NULL && find_slot_in_mapped_hash (index, name, &iter->vec))
3940 iter->length = MAYBE_SWAP (*iter->vec);
3948 /* Return the next matching CU or NULL if there are no more. */
3950 static struct dwarf2_per_cu_data *
3951 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
3953 struct dwarf2_per_objfile *dwarf2_per_objfile = iter->dwarf2_per_objfile;
3955 for ( ; iter->next < iter->length; ++iter->next)
3957 offset_type cu_index_and_attrs =
3958 MAYBE_SWAP (iter->vec[iter->next + 1]);
3959 offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3960 int want_static = iter->block_index != GLOBAL_BLOCK;
3961 /* This value is only valid for index versions >= 7. */
3962 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3963 gdb_index_symbol_kind symbol_kind =
3964 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3965 /* Only check the symbol attributes if they're present.
3966 Indices prior to version 7 don't record them,
3967 and indices >= 7 may elide them for certain symbols
3968 (gold does this). */
3970 (dwarf2_per_objfile->index_table->version >= 7
3971 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3973 /* Don't crash on bad data. */
3974 if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
3975 + dwarf2_per_objfile->all_type_units.size ()))
3977 complaint (_(".gdb_index entry has bad CU index"
3979 objfile_name (dwarf2_per_objfile->objfile));
3983 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
3985 /* Skip if already read in. */
3986 if (per_cu->v.quick->compunit_symtab)
3989 /* Check static vs global. */
3992 if (iter->want_specific_block
3993 && want_static != is_static)
3995 /* Work around gold/15646. */
3996 if (!is_static && iter->global_seen)
3999 iter->global_seen = 1;
4002 /* Only check the symbol's kind if it has one. */
4005 switch (iter->domain)
4008 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
4009 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
4010 /* Some types are also in VAR_DOMAIN. */
4011 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4015 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4019 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
4034 static struct compunit_symtab *
4035 dw2_lookup_symbol (struct objfile *objfile, int block_index,
4036 const char *name, domain_enum domain)
4038 struct compunit_symtab *stab_best = NULL;
4039 struct dwarf2_per_objfile *dwarf2_per_objfile
4040 = get_dwarf2_per_objfile (objfile);
4042 lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
4044 struct dw2_symtab_iterator iter;
4045 struct dwarf2_per_cu_data *per_cu;
4047 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 1, block_index, domain, name);
4049 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4051 struct symbol *sym, *with_opaque = NULL;
4052 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
4053 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
4054 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
4056 sym = block_find_symbol (block, name, domain,
4057 block_find_non_opaque_type_preferred,
4060 /* Some caution must be observed with overloaded functions
4061 and methods, since the index will not contain any overload
4062 information (but NAME might contain it). */
4065 && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
4067 if (with_opaque != NULL
4068 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
4071 /* Keep looking through other CUs. */
4078 dw2_print_stats (struct objfile *objfile)
4080 struct dwarf2_per_objfile *dwarf2_per_objfile
4081 = get_dwarf2_per_objfile (objfile);
4082 int total = (dwarf2_per_objfile->all_comp_units.size ()
4083 + dwarf2_per_objfile->all_type_units.size ());
4086 for (int i = 0; i < total; ++i)
4088 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4090 if (!per_cu->v.quick->compunit_symtab)
4093 printf_filtered (_(" Number of read CUs: %d\n"), total - count);
4094 printf_filtered (_(" Number of unread CUs: %d\n"), count);
4097 /* This dumps minimal information about the index.
4098 It is called via "mt print objfiles".
4099 One use is to verify .gdb_index has been loaded by the
4100 gdb.dwarf2/gdb-index.exp testcase. */
4103 dw2_dump (struct objfile *objfile)
4105 struct dwarf2_per_objfile *dwarf2_per_objfile
4106 = get_dwarf2_per_objfile (objfile);
4108 gdb_assert (dwarf2_per_objfile->using_index);
4109 printf_filtered (".gdb_index:");
4110 if (dwarf2_per_objfile->index_table != NULL)
4112 printf_filtered (" version %d\n",
4113 dwarf2_per_objfile->index_table->version);
4116 printf_filtered (" faked for \"readnow\"\n");
4117 printf_filtered ("\n");
4121 dw2_expand_symtabs_for_function (struct objfile *objfile,
4122 const char *func_name)
4124 struct dwarf2_per_objfile *dwarf2_per_objfile
4125 = get_dwarf2_per_objfile (objfile);
4127 struct dw2_symtab_iterator iter;
4128 struct dwarf2_per_cu_data *per_cu;
4130 /* Note: It doesn't matter what we pass for block_index here. */
4131 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 0, GLOBAL_BLOCK, VAR_DOMAIN,
4134 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4135 dw2_instantiate_symtab (per_cu, false);
4140 dw2_expand_all_symtabs (struct objfile *objfile)
4142 struct dwarf2_per_objfile *dwarf2_per_objfile
4143 = get_dwarf2_per_objfile (objfile);
4144 int total_units = (dwarf2_per_objfile->all_comp_units.size ()
4145 + dwarf2_per_objfile->all_type_units.size ());
4147 for (int i = 0; i < total_units; ++i)
4149 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4151 /* We don't want to directly expand a partial CU, because if we
4152 read it with the wrong language, then assertion failures can
4153 be triggered later on. See PR symtab/23010. So, tell
4154 dw2_instantiate_symtab to skip partial CUs -- any important
4155 partial CU will be read via DW_TAG_imported_unit anyway. */
4156 dw2_instantiate_symtab (per_cu, true);
4161 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
4162 const char *fullname)
4164 struct dwarf2_per_objfile *dwarf2_per_objfile
4165 = get_dwarf2_per_objfile (objfile);
4167 /* We don't need to consider type units here.
4168 This is only called for examining code, e.g. expand_line_sal.
4169 There can be an order of magnitude (or more) more type units
4170 than comp units, and we avoid them if we can. */
4172 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
4174 /* We only need to look at symtabs not already expanded. */
4175 if (per_cu->v.quick->compunit_symtab)
4178 quick_file_names *file_data = dw2_get_file_names (per_cu);
4179 if (file_data == NULL)
4182 for (int j = 0; j < file_data->num_file_names; ++j)
4184 const char *this_fullname = file_data->file_names[j];
4186 if (filename_cmp (this_fullname, fullname) == 0)
4188 dw2_instantiate_symtab (per_cu, false);
4196 dw2_map_matching_symbols (struct objfile *objfile,
4197 const char * name, domain_enum domain,
4199 int (*callback) (struct block *,
4200 struct symbol *, void *),
4201 void *data, symbol_name_match_type match,
4202 symbol_compare_ftype *ordered_compare)
4204 /* Currently unimplemented; used for Ada. The function can be called if the
4205 current language is Ada for a non-Ada objfile using GNU index. As Ada
4206 does not look for non-Ada symbols this function should just return. */
4209 /* Symbol name matcher for .gdb_index names.
4211 Symbol names in .gdb_index have a few particularities:
4213 - There's no indication of which is the language of each symbol.
4215 Since each language has its own symbol name matching algorithm,
4216 and we don't know which language is the right one, we must match
4217 each symbol against all languages. This would be a potential
4218 performance problem if it were not mitigated by the
4219 mapped_index::name_components lookup table, which significantly
4220 reduces the number of times we need to call into this matcher,
4221 making it a non-issue.
4223 - Symbol names in the index have no overload (parameter)
4224 information. I.e., in C++, "foo(int)" and "foo(long)" both
4225 appear as "foo" in the index, for example.
4227 This means that the lookup names passed to the symbol name
4228 matcher functions must have no parameter information either
4229 because (e.g.) symbol search name "foo" does not match
4230 lookup-name "foo(int)" [while swapping search name for lookup
4233 class gdb_index_symbol_name_matcher
4236 /* Prepares the vector of comparison functions for LOOKUP_NAME. */
4237 gdb_index_symbol_name_matcher (const lookup_name_info &lookup_name);
4239 /* Walk all the matcher routines and match SYMBOL_NAME against them.
4240 Returns true if any matcher matches. */
4241 bool matches (const char *symbol_name);
4244 /* A reference to the lookup name we're matching against. */
4245 const lookup_name_info &m_lookup_name;
4247 /* A vector holding all the different symbol name matchers, for all
4249 std::vector<symbol_name_matcher_ftype *> m_symbol_name_matcher_funcs;
4252 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4253 (const lookup_name_info &lookup_name)
4254 : m_lookup_name (lookup_name)
4256 /* Prepare the vector of comparison functions upfront, to avoid
4257 doing the same work for each symbol. Care is taken to avoid
4258 matching with the same matcher more than once if/when multiple
4259 languages use the same matcher function. */
4260 auto &matchers = m_symbol_name_matcher_funcs;
4261 matchers.reserve (nr_languages);
4263 matchers.push_back (default_symbol_name_matcher);
4265 for (int i = 0; i < nr_languages; i++)
4267 const language_defn *lang = language_def ((enum language) i);
4268 symbol_name_matcher_ftype *name_matcher
4269 = get_symbol_name_matcher (lang, m_lookup_name);
4271 /* Don't insert the same comparison routine more than once.
4272 Note that we do this linear walk instead of a seemingly
4273 cheaper sorted insert, or use a std::set or something like
4274 that, because relative order of function addresses is not
4275 stable. This is not a problem in practice because the number
4276 of supported languages is low, and the cost here is tiny
4277 compared to the number of searches we'll do afterwards using
4279 if (name_matcher != default_symbol_name_matcher
4280 && (std::find (matchers.begin (), matchers.end (), name_matcher)
4281 == matchers.end ()))
4282 matchers.push_back (name_matcher);
4287 gdb_index_symbol_name_matcher::matches (const char *symbol_name)
4289 for (auto matches_name : m_symbol_name_matcher_funcs)
4290 if (matches_name (symbol_name, m_lookup_name, NULL))
4296 /* Starting from a search name, return the string that finds the upper
4297 bound of all strings that start with SEARCH_NAME in a sorted name
4298 list. Returns the empty string to indicate that the upper bound is
4299 the end of the list. */
4302 make_sort_after_prefix_name (const char *search_name)
4304 /* When looking to complete "func", we find the upper bound of all
4305 symbols that start with "func" by looking for where we'd insert
4306 the closest string that would follow "func" in lexicographical
4307 order. Usually, that's "func"-with-last-character-incremented,
4308 i.e. "fund". Mind non-ASCII characters, though. Usually those
4309 will be UTF-8 multi-byte sequences, but we can't be certain.
4310 Especially mind the 0xff character, which is a valid character in
4311 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4312 rule out compilers allowing it in identifiers. Note that
4313 conveniently, strcmp/strcasecmp are specified to compare
4314 characters interpreted as unsigned char. So what we do is treat
4315 the whole string as a base 256 number composed of a sequence of
4316 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4317 to 0, and carries 1 to the following more-significant position.
4318 If the very first character in SEARCH_NAME ends up incremented
4319 and carries/overflows, then the upper bound is the end of the
4320 list. The string after the empty string is also the empty
4323 Some examples of this operation:
4325 SEARCH_NAME => "+1" RESULT
4329 "\xff" "a" "\xff" => "\xff" "b"
4334 Then, with these symbols for example:
4340 completing "func" looks for symbols between "func" and
4341 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4342 which finds "func" and "func1", but not "fund".
4346 funcÿ (Latin1 'ÿ' [0xff])
4350 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4351 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4355 ÿÿ (Latin1 'ÿ' [0xff])
4358 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4359 the end of the list.
4361 std::string after = search_name;
4362 while (!after.empty () && (unsigned char) after.back () == 0xff)
4364 if (!after.empty ())
4365 after.back () = (unsigned char) after.back () + 1;
4369 /* See declaration. */
4371 std::pair<std::vector<name_component>::const_iterator,
4372 std::vector<name_component>::const_iterator>
4373 mapped_index_base::find_name_components_bounds
4374 (const lookup_name_info &lookup_name_without_params) const
4377 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4380 = lookup_name_without_params.cplus ().lookup_name ().c_str ();
4382 /* Comparison function object for lower_bound that matches against a
4383 given symbol name. */
4384 auto lookup_compare_lower = [&] (const name_component &elem,
4387 const char *elem_qualified = this->symbol_name_at (elem.idx);
4388 const char *elem_name = elem_qualified + elem.name_offset;
4389 return name_cmp (elem_name, name) < 0;
4392 /* Comparison function object for upper_bound that matches against a
4393 given symbol name. */
4394 auto lookup_compare_upper = [&] (const char *name,
4395 const name_component &elem)
4397 const char *elem_qualified = this->symbol_name_at (elem.idx);
4398 const char *elem_name = elem_qualified + elem.name_offset;
4399 return name_cmp (name, elem_name) < 0;
4402 auto begin = this->name_components.begin ();
4403 auto end = this->name_components.end ();
4405 /* Find the lower bound. */
4408 if (lookup_name_without_params.completion_mode () && cplus[0] == '\0')
4411 return std::lower_bound (begin, end, cplus, lookup_compare_lower);
4414 /* Find the upper bound. */
4417 if (lookup_name_without_params.completion_mode ())
4419 /* In completion mode, we want UPPER to point past all
4420 symbols names that have the same prefix. I.e., with
4421 these symbols, and completing "func":
4423 function << lower bound
4425 other_function << upper bound
4427 We find the upper bound by looking for the insertion
4428 point of "func"-with-last-character-incremented,
4430 std::string after = make_sort_after_prefix_name (cplus);
4433 return std::lower_bound (lower, end, after.c_str (),
4434 lookup_compare_lower);
4437 return std::upper_bound (lower, end, cplus, lookup_compare_upper);
4440 return {lower, upper};
4443 /* See declaration. */
4446 mapped_index_base::build_name_components ()
4448 if (!this->name_components.empty ())
4451 this->name_components_casing = case_sensitivity;
4453 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4455 /* The code below only knows how to break apart components of C++
4456 symbol names (and other languages that use '::' as
4457 namespace/module separator). If we add support for wild matching
4458 to some language that uses some other operator (E.g., Ada, Go and
4459 D use '.'), then we'll need to try splitting the symbol name
4460 according to that language too. Note that Ada does support wild
4461 matching, but doesn't currently support .gdb_index. */
4462 auto count = this->symbol_name_count ();
4463 for (offset_type idx = 0; idx < count; idx++)
4465 if (this->symbol_name_slot_invalid (idx))
4468 const char *name = this->symbol_name_at (idx);
4470 /* Add each name component to the name component table. */
4471 unsigned int previous_len = 0;
4472 for (unsigned int current_len = cp_find_first_component (name);
4473 name[current_len] != '\0';
4474 current_len += cp_find_first_component (name + current_len))
4476 gdb_assert (name[current_len] == ':');
4477 this->name_components.push_back ({previous_len, idx});
4478 /* Skip the '::'. */
4480 previous_len = current_len;
4482 this->name_components.push_back ({previous_len, idx});
4485 /* Sort name_components elements by name. */
4486 auto name_comp_compare = [&] (const name_component &left,
4487 const name_component &right)
4489 const char *left_qualified = this->symbol_name_at (left.idx);
4490 const char *right_qualified = this->symbol_name_at (right.idx);
4492 const char *left_name = left_qualified + left.name_offset;
4493 const char *right_name = right_qualified + right.name_offset;
4495 return name_cmp (left_name, right_name) < 0;
4498 std::sort (this->name_components.begin (),
4499 this->name_components.end (),
4503 /* Helper for dw2_expand_symtabs_matching that works with a
4504 mapped_index_base instead of the containing objfile. This is split
4505 to a separate function in order to be able to unit test the
4506 name_components matching using a mock mapped_index_base. For each
4507 symbol name that matches, calls MATCH_CALLBACK, passing it the
4508 symbol's index in the mapped_index_base symbol table. */
4511 dw2_expand_symtabs_matching_symbol
4512 (mapped_index_base &index,
4513 const lookup_name_info &lookup_name_in,
4514 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
4515 enum search_domain kind,
4516 gdb::function_view<void (offset_type)> match_callback)
4518 lookup_name_info lookup_name_without_params
4519 = lookup_name_in.make_ignore_params ();
4520 gdb_index_symbol_name_matcher lookup_name_matcher
4521 (lookup_name_without_params);
4523 /* Build the symbol name component sorted vector, if we haven't
4525 index.build_name_components ();
4527 auto bounds = index.find_name_components_bounds (lookup_name_without_params);
4529 /* Now for each symbol name in range, check to see if we have a name
4530 match, and if so, call the MATCH_CALLBACK callback. */
4532 /* The same symbol may appear more than once in the range though.
4533 E.g., if we're looking for symbols that complete "w", and we have
4534 a symbol named "w1::w2", we'll find the two name components for
4535 that same symbol in the range. To be sure we only call the
4536 callback once per symbol, we first collect the symbol name
4537 indexes that matched in a temporary vector and ignore
4539 std::vector<offset_type> matches;
4540 matches.reserve (std::distance (bounds.first, bounds.second));
4542 for (; bounds.first != bounds.second; ++bounds.first)
4544 const char *qualified = index.symbol_name_at (bounds.first->idx);
4546 if (!lookup_name_matcher.matches (qualified)
4547 || (symbol_matcher != NULL && !symbol_matcher (qualified)))
4550 matches.push_back (bounds.first->idx);
4553 std::sort (matches.begin (), matches.end ());
4555 /* Finally call the callback, once per match. */
4557 for (offset_type idx : matches)
4561 match_callback (idx);
4566 /* Above we use a type wider than idx's for 'prev', since 0 and
4567 (offset_type)-1 are both possible values. */
4568 static_assert (sizeof (prev) > sizeof (offset_type), "");
4573 namespace selftests { namespace dw2_expand_symtabs_matching {
4575 /* A mock .gdb_index/.debug_names-like name index table, enough to
4576 exercise dw2_expand_symtabs_matching_symbol, which works with the
4577 mapped_index_base interface. Builds an index from the symbol list
4578 passed as parameter to the constructor. */
4579 class mock_mapped_index : public mapped_index_base
4582 mock_mapped_index (gdb::array_view<const char *> symbols)
4583 : m_symbol_table (symbols)
4586 DISABLE_COPY_AND_ASSIGN (mock_mapped_index);
4588 /* Return the number of names in the symbol table. */
4589 size_t symbol_name_count () const override
4591 return m_symbol_table.size ();
4594 /* Get the name of the symbol at IDX in the symbol table. */
4595 const char *symbol_name_at (offset_type idx) const override
4597 return m_symbol_table[idx];
4601 gdb::array_view<const char *> m_symbol_table;
4604 /* Convenience function that converts a NULL pointer to a "<null>"
4605 string, to pass to print routines. */
4608 string_or_null (const char *str)
4610 return str != NULL ? str : "<null>";
4613 /* Check if a lookup_name_info built from
4614 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4615 index. EXPECTED_LIST is the list of expected matches, in expected
4616 matching order. If no match expected, then an empty list is
4617 specified. Returns true on success. On failure prints a warning
4618 indicating the file:line that failed, and returns false. */
4621 check_match (const char *file, int line,
4622 mock_mapped_index &mock_index,
4623 const char *name, symbol_name_match_type match_type,
4624 bool completion_mode,
4625 std::initializer_list<const char *> expected_list)
4627 lookup_name_info lookup_name (name, match_type, completion_mode);
4629 bool matched = true;
4631 auto mismatch = [&] (const char *expected_str,
4634 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4635 "expected=\"%s\", got=\"%s\"\n"),
4637 (match_type == symbol_name_match_type::FULL
4639 name, string_or_null (expected_str), string_or_null (got));
4643 auto expected_it = expected_list.begin ();
4644 auto expected_end = expected_list.end ();
4646 dw2_expand_symtabs_matching_symbol (mock_index, lookup_name,
4648 [&] (offset_type idx)
4650 const char *matched_name = mock_index.symbol_name_at (idx);
4651 const char *expected_str
4652 = expected_it == expected_end ? NULL : *expected_it++;
4654 if (expected_str == NULL || strcmp (expected_str, matched_name) != 0)
4655 mismatch (expected_str, matched_name);
4658 const char *expected_str
4659 = expected_it == expected_end ? NULL : *expected_it++;
4660 if (expected_str != NULL)
4661 mismatch (expected_str, NULL);
4666 /* The symbols added to the mock mapped_index for testing (in
4668 static const char *test_symbols[] = {
4677 "ns2::tmpl<int>::foo2",
4678 "(anonymous namespace)::A::B::C",
4680 /* These are used to check that the increment-last-char in the
4681 matching algorithm for completion doesn't match "t1_fund" when
4682 completing "t1_func". */
4688 /* A UTF-8 name with multi-byte sequences to make sure that
4689 cp-name-parser understands this as a single identifier ("função"
4690 is "function" in PT). */
4693 /* \377 (0xff) is Latin1 'ÿ'. */
4696 /* \377 (0xff) is Latin1 'ÿ'. */
4700 /* A name with all sorts of complications. Starts with "z" to make
4701 it easier for the completion tests below. */
4702 #define Z_SYM_NAME \
4703 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4704 "::tuple<(anonymous namespace)::ui*, " \
4705 "std::default_delete<(anonymous namespace)::ui>, void>"
4710 /* Returns true if the mapped_index_base::find_name_component_bounds
4711 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4712 in completion mode. */
4715 check_find_bounds_finds (mapped_index_base &index,
4716 const char *search_name,
4717 gdb::array_view<const char *> expected_syms)
4719 lookup_name_info lookup_name (search_name,
4720 symbol_name_match_type::FULL, true);
4722 auto bounds = index.find_name_components_bounds (lookup_name);
4724 size_t distance = std::distance (bounds.first, bounds.second);
4725 if (distance != expected_syms.size ())
4728 for (size_t exp_elem = 0; exp_elem < distance; exp_elem++)
4730 auto nc_elem = bounds.first + exp_elem;
4731 const char *qualified = index.symbol_name_at (nc_elem->idx);
4732 if (strcmp (qualified, expected_syms[exp_elem]) != 0)
4739 /* Test the lower-level mapped_index::find_name_component_bounds
4743 test_mapped_index_find_name_component_bounds ()
4745 mock_mapped_index mock_index (test_symbols);
4747 mock_index.build_name_components ();
4749 /* Test the lower-level mapped_index::find_name_component_bounds
4750 method in completion mode. */
4752 static const char *expected_syms[] = {
4757 SELF_CHECK (check_find_bounds_finds (mock_index,
4758 "t1_func", expected_syms));
4761 /* Check that the increment-last-char in the name matching algorithm
4762 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4764 static const char *expected_syms1[] = {
4768 SELF_CHECK (check_find_bounds_finds (mock_index,
4769 "\377", expected_syms1));
4771 static const char *expected_syms2[] = {
4774 SELF_CHECK (check_find_bounds_finds (mock_index,
4775 "\377\377", expected_syms2));
4779 /* Test dw2_expand_symtabs_matching_symbol. */
4782 test_dw2_expand_symtabs_matching_symbol ()
4784 mock_mapped_index mock_index (test_symbols);
4786 /* We let all tests run until the end even if some fails, for debug
4788 bool any_mismatch = false;
4790 /* Create the expected symbols list (an initializer_list). Needed
4791 because lists have commas, and we need to pass them to CHECK,
4792 which is a macro. */
4793 #define EXPECT(...) { __VA_ARGS__ }
4795 /* Wrapper for check_match that passes down the current
4796 __FILE__/__LINE__. */
4797 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4798 any_mismatch |= !check_match (__FILE__, __LINE__, \
4800 NAME, MATCH_TYPE, COMPLETION_MODE, \
4803 /* Identity checks. */
4804 for (const char *sym : test_symbols)
4806 /* Should be able to match all existing symbols. */
4807 CHECK_MATCH (sym, symbol_name_match_type::FULL, false,
4810 /* Should be able to match all existing symbols with
4812 std::string with_params = std::string (sym) + "(int)";
4813 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4816 /* Should be able to match all existing symbols with
4817 parameters and qualifiers. */
4818 with_params = std::string (sym) + " ( int ) const";
4819 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4822 /* This should really find sym, but cp-name-parser.y doesn't
4823 know about lvalue/rvalue qualifiers yet. */
4824 with_params = std::string (sym) + " ( int ) &&";
4825 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4829 /* Check that the name matching algorithm for completion doesn't get
4830 confused with Latin1 'ÿ' / 0xff. */
4832 static const char str[] = "\377";
4833 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4834 EXPECT ("\377", "\377\377123"));
4837 /* Check that the increment-last-char in the matching algorithm for
4838 completion doesn't match "t1_fund" when completing "t1_func". */
4840 static const char str[] = "t1_func";
4841 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4842 EXPECT ("t1_func", "t1_func1"));
4845 /* Check that completion mode works at each prefix of the expected
4848 static const char str[] = "function(int)";
4849 size_t len = strlen (str);
4852 for (size_t i = 1; i < len; i++)
4854 lookup.assign (str, i);
4855 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4856 EXPECT ("function"));
4860 /* While "w" is a prefix of both components, the match function
4861 should still only be called once. */
4863 CHECK_MATCH ("w", symbol_name_match_type::FULL, true,
4865 CHECK_MATCH ("w", symbol_name_match_type::WILD, true,
4869 /* Same, with a "complicated" symbol. */
4871 static const char str[] = Z_SYM_NAME;
4872 size_t len = strlen (str);
4875 for (size_t i = 1; i < len; i++)
4877 lookup.assign (str, i);
4878 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4879 EXPECT (Z_SYM_NAME));
4883 /* In FULL mode, an incomplete symbol doesn't match. */
4885 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL, false,
4889 /* A complete symbol with parameters matches any overload, since the
4890 index has no overload info. */
4892 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL, true,
4893 EXPECT ("std::zfunction", "std::zfunction2"));
4894 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD, true,
4895 EXPECT ("std::zfunction", "std::zfunction2"));
4896 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD, true,
4897 EXPECT ("std::zfunction", "std::zfunction2"));
4900 /* Check that whitespace is ignored appropriately. A symbol with a
4901 template argument list. */
4903 static const char expected[] = "ns::foo<int>";
4904 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL, false,
4906 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD, false,
4910 /* Check that whitespace is ignored appropriately. A symbol with a
4911 template argument list that includes a pointer. */
4913 static const char expected[] = "ns::foo<char*>";
4914 /* Try both completion and non-completion modes. */
4915 static const bool completion_mode[2] = {false, true};
4916 for (size_t i = 0; i < 2; i++)
4918 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL,
4919 completion_mode[i], EXPECT (expected));
4920 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD,
4921 completion_mode[i], EXPECT (expected));
4923 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL,
4924 completion_mode[i], EXPECT (expected));
4925 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD,
4926 completion_mode[i], EXPECT (expected));
4931 /* Check method qualifiers are ignored. */
4932 static const char expected[] = "ns::foo<char*>";
4933 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4934 symbol_name_match_type::FULL, true, EXPECT (expected));
4935 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4936 symbol_name_match_type::FULL, true, EXPECT (expected));
4937 CHECK_MATCH ("foo < char * > ( int ) const",
4938 symbol_name_match_type::WILD, true, EXPECT (expected));
4939 CHECK_MATCH ("foo < char * > ( int ) &&",
4940 symbol_name_match_type::WILD, true, EXPECT (expected));
4943 /* Test lookup names that don't match anything. */
4945 CHECK_MATCH ("bar2", symbol_name_match_type::WILD, false,
4948 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL, false,
4952 /* Some wild matching tests, exercising "(anonymous namespace)",
4953 which should not be confused with a parameter list. */
4955 static const char *syms[] = {
4959 "A :: B :: C ( int )",
4964 for (const char *s : syms)
4966 CHECK_MATCH (s, symbol_name_match_type::WILD, false,
4967 EXPECT ("(anonymous namespace)::A::B::C"));
4972 static const char expected[] = "ns2::tmpl<int>::foo2";
4973 CHECK_MATCH ("tmp", symbol_name_match_type::WILD, true,
4975 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD, true,
4979 SELF_CHECK (!any_mismatch);
4988 test_mapped_index_find_name_component_bounds ();
4989 test_dw2_expand_symtabs_matching_symbol ();
4992 }} // namespace selftests::dw2_expand_symtabs_matching
4994 #endif /* GDB_SELF_TEST */
4996 /* If FILE_MATCHER is NULL or if PER_CU has
4997 dwarf2_per_cu_quick_data::MARK set (see
4998 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4999 EXPANSION_NOTIFY on it. */
5002 dw2_expand_symtabs_matching_one
5003 (struct dwarf2_per_cu_data *per_cu,
5004 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5005 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify)
5007 if (file_matcher == NULL || per_cu->v.quick->mark)
5009 bool symtab_was_null
5010 = (per_cu->v.quick->compunit_symtab == NULL);
5012 dw2_instantiate_symtab (per_cu, false);
5014 if (expansion_notify != NULL
5016 && per_cu->v.quick->compunit_symtab != NULL)
5017 expansion_notify (per_cu->v.quick->compunit_symtab);
5021 /* Helper for dw2_expand_matching symtabs. Called on each symbol
5022 matched, to expand corresponding CUs that were marked. IDX is the
5023 index of the symbol name that matched. */
5026 dw2_expand_marked_cus
5027 (struct dwarf2_per_objfile *dwarf2_per_objfile, offset_type idx,
5028 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5029 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5032 offset_type *vec, vec_len, vec_idx;
5033 bool global_seen = false;
5034 mapped_index &index = *dwarf2_per_objfile->index_table;
5036 vec = (offset_type *) (index.constant_pool
5037 + MAYBE_SWAP (index.symbol_table[idx].vec));
5038 vec_len = MAYBE_SWAP (vec[0]);
5039 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
5041 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
5042 /* This value is only valid for index versions >= 7. */
5043 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
5044 gdb_index_symbol_kind symbol_kind =
5045 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
5046 int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
5047 /* Only check the symbol attributes if they're present.
5048 Indices prior to version 7 don't record them,
5049 and indices >= 7 may elide them for certain symbols
5050 (gold does this). */
5053 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
5055 /* Work around gold/15646. */
5058 if (!is_static && global_seen)
5064 /* Only check the symbol's kind if it has one. */
5069 case VARIABLES_DOMAIN:
5070 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
5073 case FUNCTIONS_DOMAIN:
5074 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
5078 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
5086 /* Don't crash on bad data. */
5087 if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
5088 + dwarf2_per_objfile->all_type_units.size ()))
5090 complaint (_(".gdb_index entry has bad CU index"
5092 objfile_name (dwarf2_per_objfile->objfile));
5096 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
5097 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
5102 /* If FILE_MATCHER is non-NULL, set all the
5103 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5104 that match FILE_MATCHER. */
5107 dw_expand_symtabs_matching_file_matcher
5108 (struct dwarf2_per_objfile *dwarf2_per_objfile,
5109 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher)
5111 if (file_matcher == NULL)
5114 objfile *const objfile = dwarf2_per_objfile->objfile;
5116 htab_up visited_found (htab_create_alloc (10, htab_hash_pointer,
5118 NULL, xcalloc, xfree));
5119 htab_up visited_not_found (htab_create_alloc (10, htab_hash_pointer,
5121 NULL, xcalloc, xfree));
5123 /* The rule is CUs specify all the files, including those used by
5124 any TU, so there's no need to scan TUs here. */
5126 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5130 per_cu->v.quick->mark = 0;
5132 /* We only need to look at symtabs not already expanded. */
5133 if (per_cu->v.quick->compunit_symtab)
5136 quick_file_names *file_data = dw2_get_file_names (per_cu);
5137 if (file_data == NULL)
5140 if (htab_find (visited_not_found.get (), file_data) != NULL)
5142 else if (htab_find (visited_found.get (), file_data) != NULL)
5144 per_cu->v.quick->mark = 1;
5148 for (int j = 0; j < file_data->num_file_names; ++j)
5150 const char *this_real_name;
5152 if (file_matcher (file_data->file_names[j], false))
5154 per_cu->v.quick->mark = 1;
5158 /* Before we invoke realpath, which can get expensive when many
5159 files are involved, do a quick comparison of the basenames. */
5160 if (!basenames_may_differ
5161 && !file_matcher (lbasename (file_data->file_names[j]),
5165 this_real_name = dw2_get_real_path (objfile, file_data, j);
5166 if (file_matcher (this_real_name, false))
5168 per_cu->v.quick->mark = 1;
5173 void **slot = htab_find_slot (per_cu->v.quick->mark
5174 ? visited_found.get ()
5175 : visited_not_found.get (),
5182 dw2_expand_symtabs_matching
5183 (struct objfile *objfile,
5184 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5185 const lookup_name_info &lookup_name,
5186 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
5187 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5188 enum search_domain kind)
5190 struct dwarf2_per_objfile *dwarf2_per_objfile
5191 = get_dwarf2_per_objfile (objfile);
5193 /* index_table is NULL if OBJF_READNOW. */
5194 if (!dwarf2_per_objfile->index_table)
5197 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
5199 mapped_index &index = *dwarf2_per_objfile->index_table;
5201 dw2_expand_symtabs_matching_symbol (index, lookup_name,
5203 kind, [&] (offset_type idx)
5205 dw2_expand_marked_cus (dwarf2_per_objfile, idx, file_matcher,
5206 expansion_notify, kind);
5210 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5213 static struct compunit_symtab *
5214 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab *cust,
5219 if (COMPUNIT_BLOCKVECTOR (cust) != NULL
5220 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust), pc))
5223 if (cust->includes == NULL)
5226 for (i = 0; cust->includes[i]; ++i)
5228 struct compunit_symtab *s = cust->includes[i];
5230 s = recursively_find_pc_sect_compunit_symtab (s, pc);
5238 static struct compunit_symtab *
5239 dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
5240 struct bound_minimal_symbol msymbol,
5242 struct obj_section *section,
5245 struct dwarf2_per_cu_data *data;
5246 struct compunit_symtab *result;
5248 if (!objfile->psymtabs_addrmap)
5251 CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
5252 SECT_OFF_TEXT (objfile));
5253 data = (struct dwarf2_per_cu_data *) addrmap_find (objfile->psymtabs_addrmap,
5258 if (warn_if_readin && data->v.quick->compunit_symtab)
5259 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5260 paddress (get_objfile_arch (objfile), pc));
5263 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data,
5266 gdb_assert (result != NULL);
5271 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
5272 void *data, int need_fullname)
5274 struct dwarf2_per_objfile *dwarf2_per_objfile
5275 = get_dwarf2_per_objfile (objfile);
5277 if (!dwarf2_per_objfile->filenames_cache)
5279 dwarf2_per_objfile->filenames_cache.emplace ();
5281 htab_up visited (htab_create_alloc (10,
5282 htab_hash_pointer, htab_eq_pointer,
5283 NULL, xcalloc, xfree));
5285 /* The rule is CUs specify all the files, including those used
5286 by any TU, so there's no need to scan TUs here. We can
5287 ignore file names coming from already-expanded CUs. */
5289 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5291 if (per_cu->v.quick->compunit_symtab)
5293 void **slot = htab_find_slot (visited.get (),
5294 per_cu->v.quick->file_names,
5297 *slot = per_cu->v.quick->file_names;
5301 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5303 /* We only need to look at symtabs not already expanded. */
5304 if (per_cu->v.quick->compunit_symtab)
5307 quick_file_names *file_data = dw2_get_file_names (per_cu);
5308 if (file_data == NULL)
5311 void **slot = htab_find_slot (visited.get (), file_data, INSERT);
5314 /* Already visited. */
5319 for (int j = 0; j < file_data->num_file_names; ++j)
5321 const char *filename = file_data->file_names[j];
5322 dwarf2_per_objfile->filenames_cache->seen (filename);
5327 dwarf2_per_objfile->filenames_cache->traverse ([&] (const char *filename)
5329 gdb::unique_xmalloc_ptr<char> this_real_name;
5332 this_real_name = gdb_realpath (filename);
5333 (*fun) (filename, this_real_name.get (), data);
5338 dw2_has_symbols (struct objfile *objfile)
5343 const struct quick_symbol_functions dwarf2_gdb_index_functions =
5346 dw2_find_last_source_symtab,
5347 dw2_forget_cached_source_info,
5348 dw2_map_symtabs_matching_filename,
5352 dw2_expand_symtabs_for_function,
5353 dw2_expand_all_symtabs,
5354 dw2_expand_symtabs_with_fullname,
5355 dw2_map_matching_symbols,
5356 dw2_expand_symtabs_matching,
5357 dw2_find_pc_sect_compunit_symtab,
5359 dw2_map_symbol_filenames
5362 /* DWARF-5 debug_names reader. */
5364 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5365 static const gdb_byte dwarf5_augmentation[] = { 'G', 'D', 'B', 0 };
5367 /* A helper function that reads the .debug_names section in SECTION
5368 and fills in MAP. FILENAME is the name of the file containing the
5369 section; it is used for error reporting.
5371 Returns true if all went well, false otherwise. */
5374 read_debug_names_from_section (struct objfile *objfile,
5375 const char *filename,
5376 struct dwarf2_section_info *section,
5377 mapped_debug_names &map)
5379 if (dwarf2_section_empty_p (section))
5382 /* Older elfutils strip versions could keep the section in the main
5383 executable while splitting it for the separate debug info file. */
5384 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
5387 dwarf2_read_section (objfile, section);
5389 map.dwarf5_byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
5391 const gdb_byte *addr = section->buffer;
5393 bfd *const abfd = get_section_bfd_owner (section);
5395 unsigned int bytes_read;
5396 LONGEST length = read_initial_length (abfd, addr, &bytes_read);
5399 map.dwarf5_is_dwarf64 = bytes_read != 4;
5400 map.offset_size = map.dwarf5_is_dwarf64 ? 8 : 4;
5401 if (bytes_read + length != section->size)
5403 /* There may be multiple per-CU indices. */
5404 warning (_("Section .debug_names in %s length %s does not match "
5405 "section length %s, ignoring .debug_names."),
5406 filename, plongest (bytes_read + length),
5407 pulongest (section->size));
5411 /* The version number. */
5412 uint16_t version = read_2_bytes (abfd, addr);
5416 warning (_("Section .debug_names in %s has unsupported version %d, "
5417 "ignoring .debug_names."),
5423 uint16_t padding = read_2_bytes (abfd, addr);
5427 warning (_("Section .debug_names in %s has unsupported padding %d, "
5428 "ignoring .debug_names."),
5433 /* comp_unit_count - The number of CUs in the CU list. */
5434 map.cu_count = read_4_bytes (abfd, addr);
5437 /* local_type_unit_count - The number of TUs in the local TU
5439 map.tu_count = read_4_bytes (abfd, addr);
5442 /* foreign_type_unit_count - The number of TUs in the foreign TU
5444 uint32_t foreign_tu_count = read_4_bytes (abfd, addr);
5446 if (foreign_tu_count != 0)
5448 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5449 "ignoring .debug_names."),
5450 filename, static_cast<unsigned long> (foreign_tu_count));
5454 /* bucket_count - The number of hash buckets in the hash lookup
5456 map.bucket_count = read_4_bytes (abfd, addr);
5459 /* name_count - The number of unique names in the index. */
5460 map.name_count = read_4_bytes (abfd, addr);
5463 /* abbrev_table_size - The size in bytes of the abbreviations
5465 uint32_t abbrev_table_size = read_4_bytes (abfd, addr);
5468 /* augmentation_string_size - The size in bytes of the augmentation
5469 string. This value is rounded up to a multiple of 4. */
5470 uint32_t augmentation_string_size = read_4_bytes (abfd, addr);
5472 map.augmentation_is_gdb = ((augmentation_string_size
5473 == sizeof (dwarf5_augmentation))
5474 && memcmp (addr, dwarf5_augmentation,
5475 sizeof (dwarf5_augmentation)) == 0);
5476 augmentation_string_size += (-augmentation_string_size) & 3;
5477 addr += augmentation_string_size;
5480 map.cu_table_reordered = addr;
5481 addr += map.cu_count * map.offset_size;
5483 /* List of Local TUs */
5484 map.tu_table_reordered = addr;
5485 addr += map.tu_count * map.offset_size;
5487 /* Hash Lookup Table */
5488 map.bucket_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5489 addr += map.bucket_count * 4;
5490 map.hash_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5491 addr += map.name_count * 4;
5494 map.name_table_string_offs_reordered = addr;
5495 addr += map.name_count * map.offset_size;
5496 map.name_table_entry_offs_reordered = addr;
5497 addr += map.name_count * map.offset_size;
5499 const gdb_byte *abbrev_table_start = addr;
5502 const ULONGEST index_num = read_unsigned_leb128 (abfd, addr, &bytes_read);
5507 const auto insertpair
5508 = map.abbrev_map.emplace (index_num, mapped_debug_names::index_val ());
5509 if (!insertpair.second)
5511 warning (_("Section .debug_names in %s has duplicate index %s, "
5512 "ignoring .debug_names."),
5513 filename, pulongest (index_num));
5516 mapped_debug_names::index_val &indexval = insertpair.first->second;
5517 indexval.dwarf_tag = read_unsigned_leb128 (abfd, addr, &bytes_read);
5522 mapped_debug_names::index_val::attr attr;
5523 attr.dw_idx = read_unsigned_leb128 (abfd, addr, &bytes_read);
5525 attr.form = read_unsigned_leb128 (abfd, addr, &bytes_read);
5527 if (attr.form == DW_FORM_implicit_const)
5529 attr.implicit_const = read_signed_leb128 (abfd, addr,
5533 if (attr.dw_idx == 0 && attr.form == 0)
5535 indexval.attr_vec.push_back (std::move (attr));
5538 if (addr != abbrev_table_start + abbrev_table_size)
5540 warning (_("Section .debug_names in %s has abbreviation_table "
5541 "of size %zu vs. written as %u, ignoring .debug_names."),
5542 filename, addr - abbrev_table_start, abbrev_table_size);
5545 map.entry_pool = addr;
5550 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5554 create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
5555 const mapped_debug_names &map,
5556 dwarf2_section_info §ion,
5559 sect_offset sect_off_prev;
5560 for (uint32_t i = 0; i <= map.cu_count; ++i)
5562 sect_offset sect_off_next;
5563 if (i < map.cu_count)
5566 = (sect_offset) (extract_unsigned_integer
5567 (map.cu_table_reordered + i * map.offset_size,
5569 map.dwarf5_byte_order));
5572 sect_off_next = (sect_offset) section.size;
5575 const ULONGEST length = sect_off_next - sect_off_prev;
5576 dwarf2_per_cu_data *per_cu
5577 = create_cu_from_index_list (dwarf2_per_objfile, §ion, is_dwz,
5578 sect_off_prev, length);
5579 dwarf2_per_objfile->all_comp_units.push_back (per_cu);
5581 sect_off_prev = sect_off_next;
5585 /* Read the CU list from the mapped index, and use it to create all
5586 the CU objects for this dwarf2_per_objfile. */
5589 create_cus_from_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
5590 const mapped_debug_names &map,
5591 const mapped_debug_names &dwz_map)
5593 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
5594 dwarf2_per_objfile->all_comp_units.reserve (map.cu_count + dwz_map.cu_count);
5596 create_cus_from_debug_names_list (dwarf2_per_objfile, map,
5597 dwarf2_per_objfile->info,
5598 false /* is_dwz */);
5600 if (dwz_map.cu_count == 0)
5603 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5604 create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
5608 /* Read .debug_names. If everything went ok, initialize the "quick"
5609 elements of all the CUs and return true. Otherwise, return false. */
5612 dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
5614 std::unique_ptr<mapped_debug_names> map
5615 (new mapped_debug_names (dwarf2_per_objfile));
5616 mapped_debug_names dwz_map (dwarf2_per_objfile);
5617 struct objfile *objfile = dwarf2_per_objfile->objfile;
5619 if (!read_debug_names_from_section (objfile, objfile_name (objfile),
5620 &dwarf2_per_objfile->debug_names,
5624 /* Don't use the index if it's empty. */
5625 if (map->name_count == 0)
5628 /* If there is a .dwz file, read it so we can get its CU list as
5630 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5633 if (!read_debug_names_from_section (objfile,
5634 bfd_get_filename (dwz->dwz_bfd),
5635 &dwz->debug_names, dwz_map))
5637 warning (_("could not read '.debug_names' section from %s; skipping"),
5638 bfd_get_filename (dwz->dwz_bfd));
5643 create_cus_from_debug_names (dwarf2_per_objfile, *map, dwz_map);
5645 if (map->tu_count != 0)
5647 /* We can only handle a single .debug_types when we have an
5649 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
5652 dwarf2_section_info *section = VEC_index (dwarf2_section_info_def,
5653 dwarf2_per_objfile->types, 0);
5655 create_signatured_type_table_from_debug_names
5656 (dwarf2_per_objfile, *map, section, &dwarf2_per_objfile->abbrev);
5659 create_addrmap_from_aranges (dwarf2_per_objfile,
5660 &dwarf2_per_objfile->debug_aranges);
5662 dwarf2_per_objfile->debug_names_table = std::move (map);
5663 dwarf2_per_objfile->using_index = 1;
5664 dwarf2_per_objfile->quick_file_names_table =
5665 create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
5670 /* Type used to manage iterating over all CUs looking for a symbol for
5673 class dw2_debug_names_iterator
5676 /* If WANT_SPECIFIC_BLOCK is true, only look for symbols in block
5677 BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
5678 dw2_debug_names_iterator (const mapped_debug_names &map,
5679 bool want_specific_block,
5680 block_enum block_index, domain_enum domain,
5682 : m_map (map), m_want_specific_block (want_specific_block),
5683 m_block_index (block_index), m_domain (domain),
5684 m_addr (find_vec_in_debug_names (map, name))
5687 dw2_debug_names_iterator (const mapped_debug_names &map,
5688 search_domain search, uint32_t namei)
5691 m_addr (find_vec_in_debug_names (map, namei))
5694 /* Return the next matching CU or NULL if there are no more. */
5695 dwarf2_per_cu_data *next ();
5698 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5700 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5703 /* The internalized form of .debug_names. */
5704 const mapped_debug_names &m_map;
5706 /* If true, only look for symbols that match BLOCK_INDEX. */
5707 const bool m_want_specific_block = false;
5709 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
5710 Unused if !WANT_SPECIFIC_BLOCK - FIRST_LOCAL_BLOCK is an invalid
5712 const block_enum m_block_index = FIRST_LOCAL_BLOCK;
5714 /* The kind of symbol we're looking for. */
5715 const domain_enum m_domain = UNDEF_DOMAIN;
5716 const search_domain m_search = ALL_DOMAIN;
5718 /* The list of CUs from the index entry of the symbol, or NULL if
5720 const gdb_byte *m_addr;
5724 mapped_debug_names::namei_to_name (uint32_t namei) const
5726 const ULONGEST namei_string_offs
5727 = extract_unsigned_integer ((name_table_string_offs_reordered
5728 + namei * offset_size),
5731 return read_indirect_string_at_offset
5732 (dwarf2_per_objfile, dwarf2_per_objfile->objfile->obfd, namei_string_offs);
5735 /* Find a slot in .debug_names for the object named NAME. If NAME is
5736 found, return pointer to its pool data. If NAME cannot be found,
5740 dw2_debug_names_iterator::find_vec_in_debug_names
5741 (const mapped_debug_names &map, const char *name)
5743 int (*cmp) (const char *, const char *);
5745 if (current_language->la_language == language_cplus
5746 || current_language->la_language == language_fortran
5747 || current_language->la_language == language_d)
5749 /* NAME is already canonical. Drop any qualifiers as
5750 .debug_names does not contain any. */
5752 if (strchr (name, '(') != NULL)
5754 gdb::unique_xmalloc_ptr<char> without_params
5755 = cp_remove_params (name);
5757 if (without_params != NULL)
5759 name = without_params.get();
5764 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
5766 const uint32_t full_hash = dwarf5_djb_hash (name);
5768 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5769 (map.bucket_table_reordered
5770 + (full_hash % map.bucket_count)), 4,
5771 map.dwarf5_byte_order);
5775 if (namei >= map.name_count)
5777 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5779 namei, map.name_count,
5780 objfile_name (map.dwarf2_per_objfile->objfile));
5786 const uint32_t namei_full_hash
5787 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5788 (map.hash_table_reordered + namei), 4,
5789 map.dwarf5_byte_order);
5790 if (full_hash % map.bucket_count != namei_full_hash % map.bucket_count)
5793 if (full_hash == namei_full_hash)
5795 const char *const namei_string = map.namei_to_name (namei);
5797 #if 0 /* An expensive sanity check. */
5798 if (namei_full_hash != dwarf5_djb_hash (namei_string))
5800 complaint (_("Wrong .debug_names hash for string at index %u "
5802 namei, objfile_name (dwarf2_per_objfile->objfile));
5807 if (cmp (namei_string, name) == 0)
5809 const ULONGEST namei_entry_offs
5810 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5811 + namei * map.offset_size),
5812 map.offset_size, map.dwarf5_byte_order);
5813 return map.entry_pool + namei_entry_offs;
5818 if (namei >= map.name_count)
5824 dw2_debug_names_iterator::find_vec_in_debug_names
5825 (const mapped_debug_names &map, uint32_t namei)
5827 if (namei >= map.name_count)
5829 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5831 namei, map.name_count,
5832 objfile_name (map.dwarf2_per_objfile->objfile));
5836 const ULONGEST namei_entry_offs
5837 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5838 + namei * map.offset_size),
5839 map.offset_size, map.dwarf5_byte_order);
5840 return map.entry_pool + namei_entry_offs;
5843 /* See dw2_debug_names_iterator. */
5845 dwarf2_per_cu_data *
5846 dw2_debug_names_iterator::next ()
5851 struct dwarf2_per_objfile *dwarf2_per_objfile = m_map.dwarf2_per_objfile;
5852 struct objfile *objfile = dwarf2_per_objfile->objfile;
5853 bfd *const abfd = objfile->obfd;
5857 unsigned int bytes_read;
5858 const ULONGEST abbrev = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5859 m_addr += bytes_read;
5863 const auto indexval_it = m_map.abbrev_map.find (abbrev);
5864 if (indexval_it == m_map.abbrev_map.cend ())
5866 complaint (_("Wrong .debug_names undefined abbrev code %s "
5868 pulongest (abbrev), objfile_name (objfile));
5871 const mapped_debug_names::index_val &indexval = indexval_it->second;
5872 bool have_is_static = false;
5874 dwarf2_per_cu_data *per_cu = NULL;
5875 for (const mapped_debug_names::index_val::attr &attr : indexval.attr_vec)
5880 case DW_FORM_implicit_const:
5881 ull = attr.implicit_const;
5883 case DW_FORM_flag_present:
5887 ull = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5888 m_addr += bytes_read;
5891 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5892 dwarf_form_name (attr.form),
5893 objfile_name (objfile));
5896 switch (attr.dw_idx)
5898 case DW_IDX_compile_unit:
5899 /* Don't crash on bad data. */
5900 if (ull >= dwarf2_per_objfile->all_comp_units.size ())
5902 complaint (_(".debug_names entry has bad CU index %s"
5905 objfile_name (dwarf2_per_objfile->objfile));
5908 per_cu = dwarf2_per_objfile->get_cutu (ull);
5910 case DW_IDX_type_unit:
5911 /* Don't crash on bad data. */
5912 if (ull >= dwarf2_per_objfile->all_type_units.size ())
5914 complaint (_(".debug_names entry has bad TU index %s"
5917 objfile_name (dwarf2_per_objfile->objfile));
5920 per_cu = &dwarf2_per_objfile->get_tu (ull)->per_cu;
5922 case DW_IDX_GNU_internal:
5923 if (!m_map.augmentation_is_gdb)
5925 have_is_static = true;
5928 case DW_IDX_GNU_external:
5929 if (!m_map.augmentation_is_gdb)
5931 have_is_static = true;
5937 /* Skip if already read in. */
5938 if (per_cu->v.quick->compunit_symtab)
5941 /* Check static vs global. */
5944 const bool want_static = m_block_index != GLOBAL_BLOCK;
5945 if (m_want_specific_block && want_static != is_static)
5949 /* Match dw2_symtab_iter_next, symbol_kind
5950 and debug_names::psymbol_tag. */
5954 switch (indexval.dwarf_tag)
5956 case DW_TAG_variable:
5957 case DW_TAG_subprogram:
5958 /* Some types are also in VAR_DOMAIN. */
5959 case DW_TAG_typedef:
5960 case DW_TAG_structure_type:
5967 switch (indexval.dwarf_tag)
5969 case DW_TAG_typedef:
5970 case DW_TAG_structure_type:
5977 switch (indexval.dwarf_tag)
5980 case DW_TAG_variable:
5990 /* Match dw2_expand_symtabs_matching, symbol_kind and
5991 debug_names::psymbol_tag. */
5994 case VARIABLES_DOMAIN:
5995 switch (indexval.dwarf_tag)
5997 case DW_TAG_variable:
6003 case FUNCTIONS_DOMAIN:
6004 switch (indexval.dwarf_tag)
6006 case DW_TAG_subprogram:
6013 switch (indexval.dwarf_tag)
6015 case DW_TAG_typedef:
6016 case DW_TAG_structure_type:
6029 static struct compunit_symtab *
6030 dw2_debug_names_lookup_symbol (struct objfile *objfile, int block_index_int,
6031 const char *name, domain_enum domain)
6033 const block_enum block_index = static_cast<block_enum> (block_index_int);
6034 struct dwarf2_per_objfile *dwarf2_per_objfile
6035 = get_dwarf2_per_objfile (objfile);
6037 const auto &mapp = dwarf2_per_objfile->debug_names_table;
6040 /* index is NULL if OBJF_READNOW. */
6043 const auto &map = *mapp;
6045 dw2_debug_names_iterator iter (map, true /* want_specific_block */,
6046 block_index, domain, name);
6048 struct compunit_symtab *stab_best = NULL;
6049 struct dwarf2_per_cu_data *per_cu;
6050 while ((per_cu = iter.next ()) != NULL)
6052 struct symbol *sym, *with_opaque = NULL;
6053 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
6054 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
6055 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
6057 sym = block_find_symbol (block, name, domain,
6058 block_find_non_opaque_type_preferred,
6061 /* Some caution must be observed with overloaded functions and
6062 methods, since the index will not contain any overload
6063 information (but NAME might contain it). */
6066 && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
6068 if (with_opaque != NULL
6069 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
6072 /* Keep looking through other CUs. */
6078 /* This dumps minimal information about .debug_names. It is called
6079 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
6080 uses this to verify that .debug_names has been loaded. */
6083 dw2_debug_names_dump (struct objfile *objfile)
6085 struct dwarf2_per_objfile *dwarf2_per_objfile
6086 = get_dwarf2_per_objfile (objfile);
6088 gdb_assert (dwarf2_per_objfile->using_index);
6089 printf_filtered (".debug_names:");
6090 if (dwarf2_per_objfile->debug_names_table)
6091 printf_filtered (" exists\n");
6093 printf_filtered (" faked for \"readnow\"\n");
6094 printf_filtered ("\n");
6098 dw2_debug_names_expand_symtabs_for_function (struct objfile *objfile,
6099 const char *func_name)
6101 struct dwarf2_per_objfile *dwarf2_per_objfile
6102 = get_dwarf2_per_objfile (objfile);
6104 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
6105 if (dwarf2_per_objfile->debug_names_table)
6107 const mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6109 /* Note: It doesn't matter what we pass for block_index here. */
6110 dw2_debug_names_iterator iter (map, false /* want_specific_block */,
6111 GLOBAL_BLOCK, VAR_DOMAIN, func_name);
6113 struct dwarf2_per_cu_data *per_cu;
6114 while ((per_cu = iter.next ()) != NULL)
6115 dw2_instantiate_symtab (per_cu, false);
6120 dw2_debug_names_expand_symtabs_matching
6121 (struct objfile *objfile,
6122 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
6123 const lookup_name_info &lookup_name,
6124 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
6125 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
6126 enum search_domain kind)
6128 struct dwarf2_per_objfile *dwarf2_per_objfile
6129 = get_dwarf2_per_objfile (objfile);
6131 /* debug_names_table is NULL if OBJF_READNOW. */
6132 if (!dwarf2_per_objfile->debug_names_table)
6135 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
6137 mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6139 dw2_expand_symtabs_matching_symbol (map, lookup_name,
6141 kind, [&] (offset_type namei)
6143 /* The name was matched, now expand corresponding CUs that were
6145 dw2_debug_names_iterator iter (map, kind, namei);
6147 struct dwarf2_per_cu_data *per_cu;
6148 while ((per_cu = iter.next ()) != NULL)
6149 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
6154 const struct quick_symbol_functions dwarf2_debug_names_functions =
6157 dw2_find_last_source_symtab,
6158 dw2_forget_cached_source_info,
6159 dw2_map_symtabs_matching_filename,
6160 dw2_debug_names_lookup_symbol,
6162 dw2_debug_names_dump,
6163 dw2_debug_names_expand_symtabs_for_function,
6164 dw2_expand_all_symtabs,
6165 dw2_expand_symtabs_with_fullname,
6166 dw2_map_matching_symbols,
6167 dw2_debug_names_expand_symtabs_matching,
6168 dw2_find_pc_sect_compunit_symtab,
6170 dw2_map_symbol_filenames
6173 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
6174 to either a dwarf2_per_objfile or dwz_file object. */
6176 template <typename T>
6177 static gdb::array_view<const gdb_byte>
6178 get_gdb_index_contents_from_section (objfile *obj, T *section_owner)
6180 dwarf2_section_info *section = §ion_owner->gdb_index;
6182 if (dwarf2_section_empty_p (section))
6185 /* Older elfutils strip versions could keep the section in the main
6186 executable while splitting it for the separate debug info file. */
6187 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
6190 dwarf2_read_section (obj, section);
6192 /* dwarf2_section_info::size is a bfd_size_type, while
6193 gdb::array_view works with size_t. On 32-bit hosts, with
6194 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6195 is 32-bit. So we need an explicit narrowing conversion here.
6196 This is fine, because it's impossible to allocate or mmap an
6197 array/buffer larger than what size_t can represent. */
6198 return gdb::make_array_view (section->buffer, section->size);
6201 /* Lookup the index cache for the contents of the index associated to
6204 static gdb::array_view<const gdb_byte>
6205 get_gdb_index_contents_from_cache (objfile *obj, dwarf2_per_objfile *dwarf2_obj)
6207 const bfd_build_id *build_id = build_id_bfd_get (obj->obfd);
6208 if (build_id == nullptr)
6211 return global_index_cache.lookup_gdb_index (build_id,
6212 &dwarf2_obj->index_cache_res);
6215 /* Same as the above, but for DWZ. */
6217 static gdb::array_view<const gdb_byte>
6218 get_gdb_index_contents_from_cache_dwz (objfile *obj, dwz_file *dwz)
6220 const bfd_build_id *build_id = build_id_bfd_get (dwz->dwz_bfd.get ());
6221 if (build_id == nullptr)
6224 return global_index_cache.lookup_gdb_index (build_id, &dwz->index_cache_res);
6227 /* See symfile.h. */
6230 dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
6232 struct dwarf2_per_objfile *dwarf2_per_objfile
6233 = get_dwarf2_per_objfile (objfile);
6235 /* If we're about to read full symbols, don't bother with the
6236 indices. In this case we also don't care if some other debug
6237 format is making psymtabs, because they are all about to be
6239 if ((objfile->flags & OBJF_READNOW))
6241 dwarf2_per_objfile->using_index = 1;
6242 create_all_comp_units (dwarf2_per_objfile);
6243 create_all_type_units (dwarf2_per_objfile);
6244 dwarf2_per_objfile->quick_file_names_table
6245 = create_quick_file_names_table
6246 (dwarf2_per_objfile->all_comp_units.size ());
6248 for (int i = 0; i < (dwarf2_per_objfile->all_comp_units.size ()
6249 + dwarf2_per_objfile->all_type_units.size ()); ++i)
6251 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
6253 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6254 struct dwarf2_per_cu_quick_data);
6257 /* Return 1 so that gdb sees the "quick" functions. However,
6258 these functions will be no-ops because we will have expanded
6260 *index_kind = dw_index_kind::GDB_INDEX;
6264 if (dwarf2_read_debug_names (dwarf2_per_objfile))
6266 *index_kind = dw_index_kind::DEBUG_NAMES;
6270 if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6271 get_gdb_index_contents_from_section<struct dwarf2_per_objfile>,
6272 get_gdb_index_contents_from_section<dwz_file>))
6274 *index_kind = dw_index_kind::GDB_INDEX;
6278 /* ... otherwise, try to find the index in the index cache. */
6279 if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6280 get_gdb_index_contents_from_cache,
6281 get_gdb_index_contents_from_cache_dwz))
6283 global_index_cache.hit ();
6284 *index_kind = dw_index_kind::GDB_INDEX;
6288 global_index_cache.miss ();
6294 /* Build a partial symbol table. */
6297 dwarf2_build_psymtabs (struct objfile *objfile)
6299 struct dwarf2_per_objfile *dwarf2_per_objfile
6300 = get_dwarf2_per_objfile (objfile);
6302 if (objfile->global_psymbols.capacity () == 0
6303 && objfile->static_psymbols.capacity () == 0)
6304 init_psymbol_list (objfile, 1024);
6308 /* This isn't really ideal: all the data we allocate on the
6309 objfile's obstack is still uselessly kept around. However,
6310 freeing it seems unsafe. */
6311 psymtab_discarder psymtabs (objfile);
6312 dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
6315 /* (maybe) store an index in the cache. */
6316 global_index_cache.store (dwarf2_per_objfile);
6318 CATCH (except, RETURN_MASK_ERROR)
6320 exception_print (gdb_stderr, except);
6325 /* Return the total length of the CU described by HEADER. */
6328 get_cu_length (const struct comp_unit_head *header)
6330 return header->initial_length_size + header->length;
6333 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6336 offset_in_cu_p (const comp_unit_head *cu_header, sect_offset sect_off)
6338 sect_offset bottom = cu_header->sect_off;
6339 sect_offset top = cu_header->sect_off + get_cu_length (cu_header);
6341 return sect_off >= bottom && sect_off < top;
6344 /* Find the base address of the compilation unit for range lists and
6345 location lists. It will normally be specified by DW_AT_low_pc.
6346 In DWARF-3 draft 4, the base address could be overridden by
6347 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6348 compilation units with discontinuous ranges. */
6351 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
6353 struct attribute *attr;
6356 cu->base_address = 0;
6358 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
6361 cu->base_address = attr_value_as_address (attr);
6366 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6369 cu->base_address = attr_value_as_address (attr);
6375 /* Read in the comp unit header information from the debug_info at info_ptr.
6376 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6377 NOTE: This leaves members offset, first_die_offset to be filled in
6380 static const gdb_byte *
6381 read_comp_unit_head (struct comp_unit_head *cu_header,
6382 const gdb_byte *info_ptr,
6383 struct dwarf2_section_info *section,
6384 rcuh_kind section_kind)
6387 unsigned int bytes_read;
6388 const char *filename = get_section_file_name (section);
6389 bfd *abfd = get_section_bfd_owner (section);
6391 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
6392 cu_header->initial_length_size = bytes_read;
6393 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
6394 info_ptr += bytes_read;
6395 cu_header->version = read_2_bytes (abfd, info_ptr);
6396 if (cu_header->version < 2 || cu_header->version > 5)
6397 error (_("Dwarf Error: wrong version in compilation unit header "
6398 "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6399 cu_header->version, filename);
6401 if (cu_header->version < 5)
6402 switch (section_kind)
6404 case rcuh_kind::COMPILE:
6405 cu_header->unit_type = DW_UT_compile;
6407 case rcuh_kind::TYPE:
6408 cu_header->unit_type = DW_UT_type;
6411 internal_error (__FILE__, __LINE__,
6412 _("read_comp_unit_head: invalid section_kind"));
6416 cu_header->unit_type = static_cast<enum dwarf_unit_type>
6417 (read_1_byte (abfd, info_ptr));
6419 switch (cu_header->unit_type)
6422 if (section_kind != rcuh_kind::COMPILE)
6423 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6424 "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6428 section_kind = rcuh_kind::TYPE;
6431 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6432 "(is %d, should be %d or %d) [in module %s]"),
6433 cu_header->unit_type, DW_UT_compile, DW_UT_type, filename);
6436 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6439 cu_header->abbrev_sect_off = (sect_offset) read_offset (abfd, info_ptr,
6442 info_ptr += bytes_read;
6443 if (cu_header->version < 5)
6445 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6448 signed_addr = bfd_get_sign_extend_vma (abfd);
6449 if (signed_addr < 0)
6450 internal_error (__FILE__, __LINE__,
6451 _("read_comp_unit_head: dwarf from non elf file"));
6452 cu_header->signed_addr_p = signed_addr;
6454 if (section_kind == rcuh_kind::TYPE)
6456 LONGEST type_offset;
6458 cu_header->signature = read_8_bytes (abfd, info_ptr);
6461 type_offset = read_offset (abfd, info_ptr, cu_header, &bytes_read);
6462 info_ptr += bytes_read;
6463 cu_header->type_cu_offset_in_tu = (cu_offset) type_offset;
6464 if (to_underlying (cu_header->type_cu_offset_in_tu) != type_offset)
6465 error (_("Dwarf Error: Too big type_offset in compilation unit "
6466 "header (is %s) [in module %s]"), plongest (type_offset),
6473 /* Helper function that returns the proper abbrev section for
6476 static struct dwarf2_section_info *
6477 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
6479 struct dwarf2_section_info *abbrev;
6480 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
6482 if (this_cu->is_dwz)
6483 abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
6485 abbrev = &dwarf2_per_objfile->abbrev;
6490 /* Subroutine of read_and_check_comp_unit_head and
6491 read_and_check_type_unit_head to simplify them.
6492 Perform various error checking on the header. */
6495 error_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6496 struct comp_unit_head *header,
6497 struct dwarf2_section_info *section,
6498 struct dwarf2_section_info *abbrev_section)
6500 const char *filename = get_section_file_name (section);
6502 if (to_underlying (header->abbrev_sect_off)
6503 >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
6504 error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6505 "(offset %s + 6) [in module %s]"),
6506 sect_offset_str (header->abbrev_sect_off),
6507 sect_offset_str (header->sect_off),
6510 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6511 avoid potential 32-bit overflow. */
6512 if (((ULONGEST) header->sect_off + get_cu_length (header))
6514 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6515 "(offset %s + 0) [in module %s]"),
6516 header->length, sect_offset_str (header->sect_off),
6520 /* Read in a CU/TU header and perform some basic error checking.
6521 The contents of the header are stored in HEADER.
6522 The result is a pointer to the start of the first DIE. */
6524 static const gdb_byte *
6525 read_and_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6526 struct comp_unit_head *header,
6527 struct dwarf2_section_info *section,
6528 struct dwarf2_section_info *abbrev_section,
6529 const gdb_byte *info_ptr,
6530 rcuh_kind section_kind)
6532 const gdb_byte *beg_of_comp_unit = info_ptr;
6534 header->sect_off = (sect_offset) (beg_of_comp_unit - section->buffer);
6536 info_ptr = read_comp_unit_head (header, info_ptr, section, section_kind);
6538 header->first_die_cu_offset = (cu_offset) (info_ptr - beg_of_comp_unit);
6540 error_check_comp_unit_head (dwarf2_per_objfile, header, section,
6546 /* Fetch the abbreviation table offset from a comp or type unit header. */
6549 read_abbrev_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
6550 struct dwarf2_section_info *section,
6551 sect_offset sect_off)
6553 bfd *abfd = get_section_bfd_owner (section);
6554 const gdb_byte *info_ptr;
6555 unsigned int initial_length_size, offset_size;
6558 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
6559 info_ptr = section->buffer + to_underlying (sect_off);
6560 read_initial_length (abfd, info_ptr, &initial_length_size);
6561 offset_size = initial_length_size == 4 ? 4 : 8;
6562 info_ptr += initial_length_size;
6564 version = read_2_bytes (abfd, info_ptr);
6568 /* Skip unit type and address size. */
6572 return (sect_offset) read_offset_1 (abfd, info_ptr, offset_size);
6575 /* Allocate a new partial symtab for file named NAME and mark this new
6576 partial symtab as being an include of PST. */
6579 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
6580 struct objfile *objfile)
6582 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
6584 if (!IS_ABSOLUTE_PATH (subpst->filename))
6586 /* It shares objfile->objfile_obstack. */
6587 subpst->dirname = pst->dirname;
6590 subpst->dependencies
6591 = XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
6592 subpst->dependencies[0] = pst;
6593 subpst->number_of_dependencies = 1;
6595 subpst->globals_offset = 0;
6596 subpst->n_global_syms = 0;
6597 subpst->statics_offset = 0;
6598 subpst->n_static_syms = 0;
6599 subpst->compunit_symtab = NULL;
6600 subpst->read_symtab = pst->read_symtab;
6603 /* No private part is necessary for include psymtabs. This property
6604 can be used to differentiate between such include psymtabs and
6605 the regular ones. */
6606 subpst->read_symtab_private = NULL;
6609 /* Read the Line Number Program data and extract the list of files
6610 included by the source file represented by PST. Build an include
6611 partial symtab for each of these included files. */
6614 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
6615 struct die_info *die,
6616 struct partial_symtab *pst)
6619 struct attribute *attr;
6621 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
6623 lh = dwarf_decode_line_header ((sect_offset) DW_UNSND (attr), cu);
6625 return; /* No linetable, so no includes. */
6627 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6628 that we pass in the raw text_low here; that is ok because we're
6629 only decoding the line table to make include partial symtabs, and
6630 so the addresses aren't really used. */
6631 dwarf_decode_lines (lh.get (), pst->dirname, cu, pst,
6632 pst->raw_text_low (), 1);
6636 hash_signatured_type (const void *item)
6638 const struct signatured_type *sig_type
6639 = (const struct signatured_type *) item;
6641 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6642 return sig_type->signature;
6646 eq_signatured_type (const void *item_lhs, const void *item_rhs)
6648 const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
6649 const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
6651 return lhs->signature == rhs->signature;
6654 /* Allocate a hash table for signatured types. */
6657 allocate_signatured_type_table (struct objfile *objfile)
6659 return htab_create_alloc_ex (41,
6660 hash_signatured_type,
6663 &objfile->objfile_obstack,
6664 hashtab_obstack_allocate,
6665 dummy_obstack_deallocate);
6668 /* A helper function to add a signatured type CU to a table. */
6671 add_signatured_type_cu_to_table (void **slot, void *datum)
6673 struct signatured_type *sigt = (struct signatured_type *) *slot;
6674 std::vector<signatured_type *> *all_type_units
6675 = (std::vector<signatured_type *> *) datum;
6677 all_type_units->push_back (sigt);
6682 /* A helper for create_debug_types_hash_table. Read types from SECTION
6683 and fill them into TYPES_HTAB. It will process only type units,
6684 therefore DW_UT_type. */
6687 create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6688 struct dwo_file *dwo_file,
6689 dwarf2_section_info *section, htab_t &types_htab,
6690 rcuh_kind section_kind)
6692 struct objfile *objfile = dwarf2_per_objfile->objfile;
6693 struct dwarf2_section_info *abbrev_section;
6695 const gdb_byte *info_ptr, *end_ptr;
6697 abbrev_section = (dwo_file != NULL
6698 ? &dwo_file->sections.abbrev
6699 : &dwarf2_per_objfile->abbrev);
6701 if (dwarf_read_debug)
6702 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
6703 get_section_name (section),
6704 get_section_file_name (abbrev_section));
6706 dwarf2_read_section (objfile, section);
6707 info_ptr = section->buffer;
6709 if (info_ptr == NULL)
6712 /* We can't set abfd until now because the section may be empty or
6713 not present, in which case the bfd is unknown. */
6714 abfd = get_section_bfd_owner (section);
6716 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6717 because we don't need to read any dies: the signature is in the
6720 end_ptr = info_ptr + section->size;
6721 while (info_ptr < end_ptr)
6723 struct signatured_type *sig_type;
6724 struct dwo_unit *dwo_tu;
6726 const gdb_byte *ptr = info_ptr;
6727 struct comp_unit_head header;
6728 unsigned int length;
6730 sect_offset sect_off = (sect_offset) (ptr - section->buffer);
6732 /* Initialize it due to a false compiler warning. */
6733 header.signature = -1;
6734 header.type_cu_offset_in_tu = (cu_offset) -1;
6736 /* We need to read the type's signature in order to build the hash
6737 table, but we don't need anything else just yet. */
6739 ptr = read_and_check_comp_unit_head (dwarf2_per_objfile, &header, section,
6740 abbrev_section, ptr, section_kind);
6742 length = get_cu_length (&header);
6744 /* Skip dummy type units. */
6745 if (ptr >= info_ptr + length
6746 || peek_abbrev_code (abfd, ptr) == 0
6747 || header.unit_type != DW_UT_type)
6753 if (types_htab == NULL)
6756 types_htab = allocate_dwo_unit_table (objfile);
6758 types_htab = allocate_signatured_type_table (objfile);
6764 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6766 dwo_tu->dwo_file = dwo_file;
6767 dwo_tu->signature = header.signature;
6768 dwo_tu->type_offset_in_tu = header.type_cu_offset_in_tu;
6769 dwo_tu->section = section;
6770 dwo_tu->sect_off = sect_off;
6771 dwo_tu->length = length;
6775 /* N.B.: type_offset is not usable if this type uses a DWO file.
6776 The real type_offset is in the DWO file. */
6778 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6779 struct signatured_type);
6780 sig_type->signature = header.signature;
6781 sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;
6782 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6783 sig_type->per_cu.is_debug_types = 1;
6784 sig_type->per_cu.section = section;
6785 sig_type->per_cu.sect_off = sect_off;
6786 sig_type->per_cu.length = length;
6789 slot = htab_find_slot (types_htab,
6790 dwo_file ? (void*) dwo_tu : (void *) sig_type,
6792 gdb_assert (slot != NULL);
6795 sect_offset dup_sect_off;
6799 const struct dwo_unit *dup_tu
6800 = (const struct dwo_unit *) *slot;
6802 dup_sect_off = dup_tu->sect_off;
6806 const struct signatured_type *dup_tu
6807 = (const struct signatured_type *) *slot;
6809 dup_sect_off = dup_tu->per_cu.sect_off;
6812 complaint (_("debug type entry at offset %s is duplicate to"
6813 " the entry at offset %s, signature %s"),
6814 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
6815 hex_string (header.signature));
6817 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
6819 if (dwarf_read_debug > 1)
6820 fprintf_unfiltered (gdb_stdlog, " offset %s, signature %s\n",
6821 sect_offset_str (sect_off),
6822 hex_string (header.signature));
6828 /* Create the hash table of all entries in the .debug_types
6829 (or .debug_types.dwo) section(s).
6830 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6831 otherwise it is NULL.
6833 The result is a pointer to the hash table or NULL if there are no types.
6835 Note: This function processes DWO files only, not DWP files. */
6838 create_debug_types_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6839 struct dwo_file *dwo_file,
6840 VEC (dwarf2_section_info_def) *types,
6844 struct dwarf2_section_info *section;
6846 if (VEC_empty (dwarf2_section_info_def, types))
6850 VEC_iterate (dwarf2_section_info_def, types, ix, section);
6852 create_debug_type_hash_table (dwarf2_per_objfile, dwo_file, section,
6853 types_htab, rcuh_kind::TYPE);
6856 /* Create the hash table of all entries in the .debug_types section,
6857 and initialize all_type_units.
6858 The result is zero if there is an error (e.g. missing .debug_types section),
6859 otherwise non-zero. */
6862 create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
6864 htab_t types_htab = NULL;
6866 create_debug_type_hash_table (dwarf2_per_objfile, NULL,
6867 &dwarf2_per_objfile->info, types_htab,
6868 rcuh_kind::COMPILE);
6869 create_debug_types_hash_table (dwarf2_per_objfile, NULL,
6870 dwarf2_per_objfile->types, types_htab);
6871 if (types_htab == NULL)
6873 dwarf2_per_objfile->signatured_types = NULL;
6877 dwarf2_per_objfile->signatured_types = types_htab;
6879 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
6880 dwarf2_per_objfile->all_type_units.reserve (htab_elements (types_htab));
6882 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table,
6883 &dwarf2_per_objfile->all_type_units);
6888 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6889 If SLOT is non-NULL, it is the entry to use in the hash table.
6890 Otherwise we find one. */
6892 static struct signatured_type *
6893 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
6896 struct objfile *objfile = dwarf2_per_objfile->objfile;
6898 if (dwarf2_per_objfile->all_type_units.size ()
6899 == dwarf2_per_objfile->all_type_units.capacity ())
6900 ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
6902 signatured_type *sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6903 struct signatured_type);
6905 dwarf2_per_objfile->all_type_units.push_back (sig_type);
6906 sig_type->signature = sig;
6907 sig_type->per_cu.is_debug_types = 1;
6908 if (dwarf2_per_objfile->using_index)
6910 sig_type->per_cu.v.quick =
6911 OBSTACK_ZALLOC (&objfile->objfile_obstack,
6912 struct dwarf2_per_cu_quick_data);
6917 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6920 gdb_assert (*slot == NULL);
6922 /* The rest of sig_type must be filled in by the caller. */
6926 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6927 Fill in SIG_ENTRY with DWO_ENTRY. */
6930 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
6931 struct signatured_type *sig_entry,
6932 struct dwo_unit *dwo_entry)
6934 /* Make sure we're not clobbering something we don't expect to. */
6935 gdb_assert (! sig_entry->per_cu.queued);
6936 gdb_assert (sig_entry->per_cu.cu == NULL);
6937 if (dwarf2_per_objfile->using_index)
6939 gdb_assert (sig_entry->per_cu.v.quick != NULL);
6940 gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
6943 gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
6944 gdb_assert (sig_entry->signature == dwo_entry->signature);
6945 gdb_assert (to_underlying (sig_entry->type_offset_in_section) == 0);
6946 gdb_assert (sig_entry->type_unit_group == NULL);
6947 gdb_assert (sig_entry->dwo_unit == NULL);
6949 sig_entry->per_cu.section = dwo_entry->section;
6950 sig_entry->per_cu.sect_off = dwo_entry->sect_off;
6951 sig_entry->per_cu.length = dwo_entry->length;
6952 sig_entry->per_cu.reading_dwo_directly = 1;
6953 sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6954 sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
6955 sig_entry->dwo_unit = dwo_entry;
6958 /* Subroutine of lookup_signatured_type.
6959 If we haven't read the TU yet, create the signatured_type data structure
6960 for a TU to be read in directly from a DWO file, bypassing the stub.
6961 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6962 using .gdb_index, then when reading a CU we want to stay in the DWO file
6963 containing that CU. Otherwise we could end up reading several other DWO
6964 files (due to comdat folding) to process the transitive closure of all the
6965 mentioned TUs, and that can be slow. The current DWO file will have every
6966 type signature that it needs.
6967 We only do this for .gdb_index because in the psymtab case we already have
6968 to read all the DWOs to build the type unit groups. */
6970 static struct signatured_type *
6971 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
6973 struct dwarf2_per_objfile *dwarf2_per_objfile
6974 = cu->per_cu->dwarf2_per_objfile;
6975 struct objfile *objfile = dwarf2_per_objfile->objfile;
6976 struct dwo_file *dwo_file;
6977 struct dwo_unit find_dwo_entry, *dwo_entry;
6978 struct signatured_type find_sig_entry, *sig_entry;
6981 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
6983 /* If TU skeletons have been removed then we may not have read in any
6985 if (dwarf2_per_objfile->signatured_types == NULL)
6987 dwarf2_per_objfile->signatured_types
6988 = allocate_signatured_type_table (objfile);
6991 /* We only ever need to read in one copy of a signatured type.
6992 Use the global signatured_types array to do our own comdat-folding
6993 of types. If this is the first time we're reading this TU, and
6994 the TU has an entry in .gdb_index, replace the recorded data from
6995 .gdb_index with this TU. */
6997 find_sig_entry.signature = sig;
6998 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6999 &find_sig_entry, INSERT);
7000 sig_entry = (struct signatured_type *) *slot;
7002 /* We can get here with the TU already read, *or* in the process of being
7003 read. Don't reassign the global entry to point to this DWO if that's
7004 the case. Also note that if the TU is already being read, it may not
7005 have come from a DWO, the program may be a mix of Fission-compiled
7006 code and non-Fission-compiled code. */
7008 /* Have we already tried to read this TU?
7009 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7010 needn't exist in the global table yet). */
7011 if (sig_entry != NULL && sig_entry->per_cu.tu_read)
7014 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
7015 dwo_unit of the TU itself. */
7016 dwo_file = cu->dwo_unit->dwo_file;
7018 /* Ok, this is the first time we're reading this TU. */
7019 if (dwo_file->tus == NULL)
7021 find_dwo_entry.signature = sig;
7022 dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
7023 if (dwo_entry == NULL)
7026 /* If the global table doesn't have an entry for this TU, add one. */
7027 if (sig_entry == NULL)
7028 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7030 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7031 sig_entry->per_cu.tu_read = 1;
7035 /* Subroutine of lookup_signatured_type.
7036 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7037 then try the DWP file. If the TU stub (skeleton) has been removed then
7038 it won't be in .gdb_index. */
7040 static struct signatured_type *
7041 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7043 struct dwarf2_per_objfile *dwarf2_per_objfile
7044 = cu->per_cu->dwarf2_per_objfile;
7045 struct objfile *objfile = dwarf2_per_objfile->objfile;
7046 struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
7047 struct dwo_unit *dwo_entry;
7048 struct signatured_type find_sig_entry, *sig_entry;
7051 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7052 gdb_assert (dwp_file != NULL);
7054 /* If TU skeletons have been removed then we may not have read in any
7056 if (dwarf2_per_objfile->signatured_types == NULL)
7058 dwarf2_per_objfile->signatured_types
7059 = allocate_signatured_type_table (objfile);
7062 find_sig_entry.signature = sig;
7063 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7064 &find_sig_entry, INSERT);
7065 sig_entry = (struct signatured_type *) *slot;
7067 /* Have we already tried to read this TU?
7068 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7069 needn't exist in the global table yet). */
7070 if (sig_entry != NULL)
7073 if (dwp_file->tus == NULL)
7075 dwo_entry = lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, NULL,
7076 sig, 1 /* is_debug_types */);
7077 if (dwo_entry == NULL)
7080 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7081 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7086 /* Lookup a signature based type for DW_FORM_ref_sig8.
7087 Returns NULL if signature SIG is not present in the table.
7088 It is up to the caller to complain about this. */
7090 static struct signatured_type *
7091 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7093 struct dwarf2_per_objfile *dwarf2_per_objfile
7094 = cu->per_cu->dwarf2_per_objfile;
7097 && dwarf2_per_objfile->using_index)
7099 /* We're in a DWO/DWP file, and we're using .gdb_index.
7100 These cases require special processing. */
7101 if (get_dwp_file (dwarf2_per_objfile) == NULL)
7102 return lookup_dwo_signatured_type (cu, sig);
7104 return lookup_dwp_signatured_type (cu, sig);
7108 struct signatured_type find_entry, *entry;
7110 if (dwarf2_per_objfile->signatured_types == NULL)
7112 find_entry.signature = sig;
7113 entry = ((struct signatured_type *)
7114 htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
7119 /* Low level DIE reading support. */
7121 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7124 init_cu_die_reader (struct die_reader_specs *reader,
7125 struct dwarf2_cu *cu,
7126 struct dwarf2_section_info *section,
7127 struct dwo_file *dwo_file,
7128 struct abbrev_table *abbrev_table)
7130 gdb_assert (section->readin && section->buffer != NULL);
7131 reader->abfd = get_section_bfd_owner (section);
7133 reader->dwo_file = dwo_file;
7134 reader->die_section = section;
7135 reader->buffer = section->buffer;
7136 reader->buffer_end = section->buffer + section->size;
7137 reader->comp_dir = NULL;
7138 reader->abbrev_table = abbrev_table;
7141 /* Subroutine of init_cutu_and_read_dies to simplify it.
7142 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7143 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7146 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7147 from it to the DIE in the DWO. If NULL we are skipping the stub.
7148 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7149 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7150 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7151 STUB_COMP_DIR may be non-NULL.
7152 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7153 are filled in with the info of the DIE from the DWO file.
7154 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7155 from the dwo. Since *RESULT_READER references this abbrev table, it must be
7156 kept around for at least as long as *RESULT_READER.
7158 The result is non-zero if a valid (non-dummy) DIE was found. */
7161 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
7162 struct dwo_unit *dwo_unit,
7163 struct die_info *stub_comp_unit_die,
7164 const char *stub_comp_dir,
7165 struct die_reader_specs *result_reader,
7166 const gdb_byte **result_info_ptr,
7167 struct die_info **result_comp_unit_die,
7168 int *result_has_children,
7169 abbrev_table_up *result_dwo_abbrev_table)
7171 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7172 struct objfile *objfile = dwarf2_per_objfile->objfile;
7173 struct dwarf2_cu *cu = this_cu->cu;
7175 const gdb_byte *begin_info_ptr, *info_ptr;
7176 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
7177 int i,num_extra_attrs;
7178 struct dwarf2_section_info *dwo_abbrev_section;
7179 struct attribute *attr;
7180 struct die_info *comp_unit_die;
7182 /* At most one of these may be provided. */
7183 gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
7185 /* These attributes aren't processed until later:
7186 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7187 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7188 referenced later. However, these attributes are found in the stub
7189 which we won't have later. In order to not impose this complication
7190 on the rest of the code, we read them here and copy them to the
7199 if (stub_comp_unit_die != NULL)
7201 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7203 if (! this_cu->is_debug_types)
7204 stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
7205 low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
7206 high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
7207 ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
7208 comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
7210 /* There should be a DW_AT_addr_base attribute here (if needed).
7211 We need the value before we can process DW_FORM_GNU_addr_index. */
7213 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
7215 cu->addr_base = DW_UNSND (attr);
7217 /* There should be a DW_AT_ranges_base attribute here (if needed).
7218 We need the value before we can process DW_AT_ranges. */
7219 cu->ranges_base = 0;
7220 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
7222 cu->ranges_base = DW_UNSND (attr);
7224 else if (stub_comp_dir != NULL)
7226 /* Reconstruct the comp_dir attribute to simplify the code below. */
7227 comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
7228 comp_dir->name = DW_AT_comp_dir;
7229 comp_dir->form = DW_FORM_string;
7230 DW_STRING_IS_CANONICAL (comp_dir) = 0;
7231 DW_STRING (comp_dir) = stub_comp_dir;
7234 /* Set up for reading the DWO CU/TU. */
7235 cu->dwo_unit = dwo_unit;
7236 dwarf2_section_info *section = dwo_unit->section;
7237 dwarf2_read_section (objfile, section);
7238 abfd = get_section_bfd_owner (section);
7239 begin_info_ptr = info_ptr = (section->buffer
7240 + to_underlying (dwo_unit->sect_off));
7241 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
7243 if (this_cu->is_debug_types)
7245 struct signatured_type *sig_type = (struct signatured_type *) this_cu;
7247 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7248 &cu->header, section,
7250 info_ptr, rcuh_kind::TYPE);
7251 /* This is not an assert because it can be caused by bad debug info. */
7252 if (sig_type->signature != cu->header.signature)
7254 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7255 " TU at offset %s [in module %s]"),
7256 hex_string (sig_type->signature),
7257 hex_string (cu->header.signature),
7258 sect_offset_str (dwo_unit->sect_off),
7259 bfd_get_filename (abfd));
7261 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7262 /* For DWOs coming from DWP files, we don't know the CU length
7263 nor the type's offset in the TU until now. */
7264 dwo_unit->length = get_cu_length (&cu->header);
7265 dwo_unit->type_offset_in_tu = cu->header.type_cu_offset_in_tu;
7267 /* Establish the type offset that can be used to lookup the type.
7268 For DWO files, we don't know it until now. */
7269 sig_type->type_offset_in_section
7270 = dwo_unit->sect_off + to_underlying (dwo_unit->type_offset_in_tu);
7274 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7275 &cu->header, section,
7277 info_ptr, rcuh_kind::COMPILE);
7278 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7279 /* For DWOs coming from DWP files, we don't know the CU length
7281 dwo_unit->length = get_cu_length (&cu->header);
7284 *result_dwo_abbrev_table
7285 = abbrev_table_read_table (dwarf2_per_objfile, dwo_abbrev_section,
7286 cu->header.abbrev_sect_off);
7287 init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file,
7288 result_dwo_abbrev_table->get ());
7290 /* Read in the die, but leave space to copy over the attributes
7291 from the stub. This has the benefit of simplifying the rest of
7292 the code - all the work to maintain the illusion of a single
7293 DW_TAG_{compile,type}_unit DIE is done here. */
7294 num_extra_attrs = ((stmt_list != NULL)
7298 + (comp_dir != NULL));
7299 info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
7300 result_has_children, num_extra_attrs);
7302 /* Copy over the attributes from the stub to the DIE we just read in. */
7303 comp_unit_die = *result_comp_unit_die;
7304 i = comp_unit_die->num_attrs;
7305 if (stmt_list != NULL)
7306 comp_unit_die->attrs[i++] = *stmt_list;
7308 comp_unit_die->attrs[i++] = *low_pc;
7309 if (high_pc != NULL)
7310 comp_unit_die->attrs[i++] = *high_pc;
7312 comp_unit_die->attrs[i++] = *ranges;
7313 if (comp_dir != NULL)
7314 comp_unit_die->attrs[i++] = *comp_dir;
7315 comp_unit_die->num_attrs += num_extra_attrs;
7317 if (dwarf_die_debug)
7319 fprintf_unfiltered (gdb_stdlog,
7320 "Read die from %s@0x%x of %s:\n",
7321 get_section_name (section),
7322 (unsigned) (begin_info_ptr - section->buffer),
7323 bfd_get_filename (abfd));
7324 dump_die (comp_unit_die, dwarf_die_debug);
7327 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7328 TUs by skipping the stub and going directly to the entry in the DWO file.
7329 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7330 to get it via circuitous means. Blech. */
7331 if (comp_dir != NULL)
7332 result_reader->comp_dir = DW_STRING (comp_dir);
7334 /* Skip dummy compilation units. */
7335 if (info_ptr >= begin_info_ptr + dwo_unit->length
7336 || peek_abbrev_code (abfd, info_ptr) == 0)
7339 *result_info_ptr = info_ptr;
7343 /* Subroutine of init_cutu_and_read_dies to simplify it.
7344 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7345 Returns NULL if the specified DWO unit cannot be found. */
7347 static struct dwo_unit *
7348 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
7349 struct die_info *comp_unit_die)
7351 struct dwarf2_cu *cu = this_cu->cu;
7353 struct dwo_unit *dwo_unit;
7354 const char *comp_dir, *dwo_name;
7356 gdb_assert (cu != NULL);
7358 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7359 dwo_name = dwarf2_string_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7360 comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7362 if (this_cu->is_debug_types)
7364 struct signatured_type *sig_type;
7366 /* Since this_cu is the first member of struct signatured_type,
7367 we can go from a pointer to one to a pointer to the other. */
7368 sig_type = (struct signatured_type *) this_cu;
7369 signature = sig_type->signature;
7370 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
7374 struct attribute *attr;
7376 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
7378 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7380 dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
7381 signature = DW_UNSND (attr);
7382 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
7389 /* Subroutine of init_cutu_and_read_dies to simplify it.
7390 See it for a description of the parameters.
7391 Read a TU directly from a DWO file, bypassing the stub. */
7394 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
7395 int use_existing_cu, int keep,
7396 die_reader_func_ftype *die_reader_func,
7399 std::unique_ptr<dwarf2_cu> new_cu;
7400 struct signatured_type *sig_type;
7401 struct die_reader_specs reader;
7402 const gdb_byte *info_ptr;
7403 struct die_info *comp_unit_die;
7405 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7407 /* Verify we can do the following downcast, and that we have the
7409 gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
7410 sig_type = (struct signatured_type *) this_cu;
7411 gdb_assert (sig_type->dwo_unit != NULL);
7413 if (use_existing_cu && this_cu->cu != NULL)
7415 gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
7416 /* There's no need to do the rereading_dwo_cu handling that
7417 init_cutu_and_read_dies does since we don't read the stub. */
7421 /* If !use_existing_cu, this_cu->cu must be NULL. */
7422 gdb_assert (this_cu->cu == NULL);
7423 new_cu.reset (new dwarf2_cu (this_cu));
7426 /* A future optimization, if needed, would be to use an existing
7427 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7428 could share abbrev tables. */
7430 /* The abbreviation table used by READER, this must live at least as long as
7432 abbrev_table_up dwo_abbrev_table;
7434 if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
7435 NULL /* stub_comp_unit_die */,
7436 sig_type->dwo_unit->dwo_file->comp_dir,
7438 &comp_unit_die, &has_children,
7439 &dwo_abbrev_table) == 0)
7445 /* All the "real" work is done here. */
7446 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7448 /* This duplicates the code in init_cutu_and_read_dies,
7449 but the alternative is making the latter more complex.
7450 This function is only for the special case of using DWO files directly:
7451 no point in overly complicating the general case just to handle this. */
7452 if (new_cu != NULL && keep)
7454 /* Link this CU into read_in_chain. */
7455 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7456 dwarf2_per_objfile->read_in_chain = this_cu;
7457 /* The chain owns it now. */
7462 /* Initialize a CU (or TU) and read its DIEs.
7463 If the CU defers to a DWO file, read the DWO file as well.
7465 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7466 Otherwise the table specified in the comp unit header is read in and used.
7467 This is an optimization for when we already have the abbrev table.
7469 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7470 Otherwise, a new CU is allocated with xmalloc.
7472 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7473 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7475 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7476 linker) then DIE_READER_FUNC will not get called. */
7479 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
7480 struct abbrev_table *abbrev_table,
7481 int use_existing_cu, int keep,
7483 die_reader_func_ftype *die_reader_func,
7486 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7487 struct objfile *objfile = dwarf2_per_objfile->objfile;
7488 struct dwarf2_section_info *section = this_cu->section;
7489 bfd *abfd = get_section_bfd_owner (section);
7490 struct dwarf2_cu *cu;
7491 const gdb_byte *begin_info_ptr, *info_ptr;
7492 struct die_reader_specs reader;
7493 struct die_info *comp_unit_die;
7495 struct attribute *attr;
7496 struct signatured_type *sig_type = NULL;
7497 struct dwarf2_section_info *abbrev_section;
7498 /* Non-zero if CU currently points to a DWO file and we need to
7499 reread it. When this happens we need to reread the skeleton die
7500 before we can reread the DWO file (this only applies to CUs, not TUs). */
7501 int rereading_dwo_cu = 0;
7503 if (dwarf_die_debug)
7504 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7505 this_cu->is_debug_types ? "type" : "comp",
7506 sect_offset_str (this_cu->sect_off));
7508 if (use_existing_cu)
7511 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7512 file (instead of going through the stub), short-circuit all of this. */
7513 if (this_cu->reading_dwo_directly)
7515 /* Narrow down the scope of possibilities to have to understand. */
7516 gdb_assert (this_cu->is_debug_types);
7517 gdb_assert (abbrev_table == NULL);
7518 init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
7519 die_reader_func, data);
7523 /* This is cheap if the section is already read in. */
7524 dwarf2_read_section (objfile, section);
7526 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7528 abbrev_section = get_abbrev_section_for_cu (this_cu);
7530 std::unique_ptr<dwarf2_cu> new_cu;
7531 if (use_existing_cu && this_cu->cu != NULL)
7534 /* If this CU is from a DWO file we need to start over, we need to
7535 refetch the attributes from the skeleton CU.
7536 This could be optimized by retrieving those attributes from when we
7537 were here the first time: the previous comp_unit_die was stored in
7538 comp_unit_obstack. But there's no data yet that we need this
7540 if (cu->dwo_unit != NULL)
7541 rereading_dwo_cu = 1;
7545 /* If !use_existing_cu, this_cu->cu must be NULL. */
7546 gdb_assert (this_cu->cu == NULL);
7547 new_cu.reset (new dwarf2_cu (this_cu));
7551 /* Get the header. */
7552 if (to_underlying (cu->header.first_die_cu_offset) != 0 && !rereading_dwo_cu)
7554 /* We already have the header, there's no need to read it in again. */
7555 info_ptr += to_underlying (cu->header.first_die_cu_offset);
7559 if (this_cu->is_debug_types)
7561 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7562 &cu->header, section,
7563 abbrev_section, info_ptr,
7566 /* Since per_cu is the first member of struct signatured_type,
7567 we can go from a pointer to one to a pointer to the other. */
7568 sig_type = (struct signatured_type *) this_cu;
7569 gdb_assert (sig_type->signature == cu->header.signature);
7570 gdb_assert (sig_type->type_offset_in_tu
7571 == cu->header.type_cu_offset_in_tu);
7572 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7574 /* LENGTH has not been set yet for type units if we're
7575 using .gdb_index. */
7576 this_cu->length = get_cu_length (&cu->header);
7578 /* Establish the type offset that can be used to lookup the type. */
7579 sig_type->type_offset_in_section =
7580 this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu);
7582 this_cu->dwarf_version = cu->header.version;
7586 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7587 &cu->header, section,
7590 rcuh_kind::COMPILE);
7592 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7593 gdb_assert (this_cu->length == get_cu_length (&cu->header));
7594 this_cu->dwarf_version = cu->header.version;
7598 /* Skip dummy compilation units. */
7599 if (info_ptr >= begin_info_ptr + this_cu->length
7600 || peek_abbrev_code (abfd, info_ptr) == 0)
7603 /* If we don't have them yet, read the abbrevs for this compilation unit.
7604 And if we need to read them now, make sure they're freed when we're
7605 done (own the table through ABBREV_TABLE_HOLDER). */
7606 abbrev_table_up abbrev_table_holder;
7607 if (abbrev_table != NULL)
7608 gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off);
7612 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7613 cu->header.abbrev_sect_off);
7614 abbrev_table = abbrev_table_holder.get ();
7617 /* Read the top level CU/TU die. */
7618 init_cu_die_reader (&reader, cu, section, NULL, abbrev_table);
7619 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7621 if (skip_partial && comp_unit_die->tag == DW_TAG_partial_unit)
7624 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7625 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7626 table from the DWO file and pass the ownership over to us. It will be
7627 referenced from READER, so we must make sure to free it after we're done
7630 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7631 DWO CU, that this test will fail (the attribute will not be present). */
7632 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7633 abbrev_table_up dwo_abbrev_table;
7636 struct dwo_unit *dwo_unit;
7637 struct die_info *dwo_comp_unit_die;
7641 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7642 " has children (offset %s) [in module %s]"),
7643 sect_offset_str (this_cu->sect_off),
7644 bfd_get_filename (abfd));
7646 dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
7647 if (dwo_unit != NULL)
7649 if (read_cutu_die_from_dwo (this_cu, dwo_unit,
7650 comp_unit_die, NULL,
7652 &dwo_comp_unit_die, &has_children,
7653 &dwo_abbrev_table) == 0)
7658 comp_unit_die = dwo_comp_unit_die;
7662 /* Yikes, we couldn't find the rest of the DIE, we only have
7663 the stub. A complaint has already been logged. There's
7664 not much more we can do except pass on the stub DIE to
7665 die_reader_func. We don't want to throw an error on bad
7670 /* All of the above is setup for this call. Yikes. */
7671 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7673 /* Done, clean up. */
7674 if (new_cu != NULL && keep)
7676 /* Link this CU into read_in_chain. */
7677 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7678 dwarf2_per_objfile->read_in_chain = this_cu;
7679 /* The chain owns it now. */
7684 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7685 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7686 to have already done the lookup to find the DWO file).
7688 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7689 THIS_CU->is_debug_types, but nothing else.
7691 We fill in THIS_CU->length.
7693 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7694 linker) then DIE_READER_FUNC will not get called.
7696 THIS_CU->cu is always freed when done.
7697 This is done in order to not leave THIS_CU->cu in a state where we have
7698 to care whether it refers to the "main" CU or the DWO CU. */
7701 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
7702 struct dwo_file *dwo_file,
7703 die_reader_func_ftype *die_reader_func,
7706 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7707 struct objfile *objfile = dwarf2_per_objfile->objfile;
7708 struct dwarf2_section_info *section = this_cu->section;
7709 bfd *abfd = get_section_bfd_owner (section);
7710 struct dwarf2_section_info *abbrev_section;
7711 const gdb_byte *begin_info_ptr, *info_ptr;
7712 struct die_reader_specs reader;
7713 struct die_info *comp_unit_die;
7716 if (dwarf_die_debug)
7717 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7718 this_cu->is_debug_types ? "type" : "comp",
7719 sect_offset_str (this_cu->sect_off));
7721 gdb_assert (this_cu->cu == NULL);
7723 abbrev_section = (dwo_file != NULL
7724 ? &dwo_file->sections.abbrev
7725 : get_abbrev_section_for_cu (this_cu));
7727 /* This is cheap if the section is already read in. */
7728 dwarf2_read_section (objfile, section);
7730 struct dwarf2_cu cu (this_cu);
7732 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7733 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7734 &cu.header, section,
7735 abbrev_section, info_ptr,
7736 (this_cu->is_debug_types
7738 : rcuh_kind::COMPILE));
7740 this_cu->length = get_cu_length (&cu.header);
7742 /* Skip dummy compilation units. */
7743 if (info_ptr >= begin_info_ptr + this_cu->length
7744 || peek_abbrev_code (abfd, info_ptr) == 0)
7747 abbrev_table_up abbrev_table
7748 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7749 cu.header.abbrev_sect_off);
7751 init_cu_die_reader (&reader, &cu, section, dwo_file, abbrev_table.get ());
7752 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7754 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7757 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7758 does not lookup the specified DWO file.
7759 This cannot be used to read DWO files.
7761 THIS_CU->cu is always freed when done.
7762 This is done in order to not leave THIS_CU->cu in a state where we have
7763 to care whether it refers to the "main" CU or the DWO CU.
7764 We can revisit this if the data shows there's a performance issue. */
7767 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
7768 die_reader_func_ftype *die_reader_func,
7771 init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
7774 /* Type Unit Groups.
7776 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7777 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7778 so that all types coming from the same compilation (.o file) are grouped
7779 together. A future step could be to put the types in the same symtab as
7780 the CU the types ultimately came from. */
7783 hash_type_unit_group (const void *item)
7785 const struct type_unit_group *tu_group
7786 = (const struct type_unit_group *) item;
7788 return hash_stmt_list_entry (&tu_group->hash);
7792 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
7794 const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
7795 const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
7797 return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
7800 /* Allocate a hash table for type unit groups. */
7803 allocate_type_unit_groups_table (struct objfile *objfile)
7805 return htab_create_alloc_ex (3,
7806 hash_type_unit_group,
7809 &objfile->objfile_obstack,
7810 hashtab_obstack_allocate,
7811 dummy_obstack_deallocate);
7814 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7815 partial symtabs. We combine several TUs per psymtab to not let the size
7816 of any one psymtab grow too big. */
7817 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7818 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7820 /* Helper routine for get_type_unit_group.
7821 Create the type_unit_group object used to hold one or more TUs. */
7823 static struct type_unit_group *
7824 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
7826 struct dwarf2_per_objfile *dwarf2_per_objfile
7827 = cu->per_cu->dwarf2_per_objfile;
7828 struct objfile *objfile = dwarf2_per_objfile->objfile;
7829 struct dwarf2_per_cu_data *per_cu;
7830 struct type_unit_group *tu_group;
7832 tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7833 struct type_unit_group);
7834 per_cu = &tu_group->per_cu;
7835 per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
7837 if (dwarf2_per_objfile->using_index)
7839 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7840 struct dwarf2_per_cu_quick_data);
7844 unsigned int line_offset = to_underlying (line_offset_struct);
7845 struct partial_symtab *pst;
7848 /* Give the symtab a useful name for debug purposes. */
7849 if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
7850 name = string_printf ("<type_units_%d>",
7851 (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
7853 name = string_printf ("<type_units_at_0x%x>", line_offset);
7855 pst = create_partial_symtab (per_cu, name.c_str ());
7859 tu_group->hash.dwo_unit = cu->dwo_unit;
7860 tu_group->hash.line_sect_off = line_offset_struct;
7865 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7866 STMT_LIST is a DW_AT_stmt_list attribute. */
7868 static struct type_unit_group *
7869 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
7871 struct dwarf2_per_objfile *dwarf2_per_objfile
7872 = cu->per_cu->dwarf2_per_objfile;
7873 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
7874 struct type_unit_group *tu_group;
7876 unsigned int line_offset;
7877 struct type_unit_group type_unit_group_for_lookup;
7879 if (dwarf2_per_objfile->type_unit_groups == NULL)
7881 dwarf2_per_objfile->type_unit_groups =
7882 allocate_type_unit_groups_table (dwarf2_per_objfile->objfile);
7885 /* Do we need to create a new group, or can we use an existing one? */
7889 line_offset = DW_UNSND (stmt_list);
7890 ++tu_stats->nr_symtab_sharers;
7894 /* Ugh, no stmt_list. Rare, but we have to handle it.
7895 We can do various things here like create one group per TU or
7896 spread them over multiple groups to split up the expansion work.
7897 To avoid worst case scenarios (too many groups or too large groups)
7898 we, umm, group them in bunches. */
7899 line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7900 | (tu_stats->nr_stmt_less_type_units
7901 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
7902 ++tu_stats->nr_stmt_less_type_units;
7905 type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
7906 type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;
7907 slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
7908 &type_unit_group_for_lookup, INSERT);
7911 tu_group = (struct type_unit_group *) *slot;
7912 gdb_assert (tu_group != NULL);
7916 sect_offset line_offset_struct = (sect_offset) line_offset;
7917 tu_group = create_type_unit_group (cu, line_offset_struct);
7919 ++tu_stats->nr_symtabs;
7925 /* Partial symbol tables. */
7927 /* Create a psymtab named NAME and assign it to PER_CU.
7929 The caller must fill in the following details:
7930 dirname, textlow, texthigh. */
7932 static struct partial_symtab *
7933 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
7935 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
7936 struct partial_symtab *pst;
7938 pst = start_psymtab_common (objfile, name, 0,
7939 objfile->global_psymbols,
7940 objfile->static_psymbols);
7942 pst->psymtabs_addrmap_supported = 1;
7944 /* This is the glue that links PST into GDB's symbol API. */
7945 pst->read_symtab_private = per_cu;
7946 pst->read_symtab = dwarf2_read_symtab;
7947 per_cu->v.psymtab = pst;
7952 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7955 struct process_psymtab_comp_unit_data
7957 /* True if we are reading a DW_TAG_partial_unit. */
7959 int want_partial_unit;
7961 /* The "pretend" language that is used if the CU doesn't declare a
7964 enum language pretend_language;
7967 /* die_reader_func for process_psymtab_comp_unit. */
7970 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
7971 const gdb_byte *info_ptr,
7972 struct die_info *comp_unit_die,
7976 struct dwarf2_cu *cu = reader->cu;
7977 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
7978 struct gdbarch *gdbarch = get_objfile_arch (objfile);
7979 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
7981 CORE_ADDR best_lowpc = 0, best_highpc = 0;
7982 struct partial_symtab *pst;
7983 enum pc_bounds_kind cu_bounds_kind;
7984 const char *filename;
7985 struct process_psymtab_comp_unit_data *info
7986 = (struct process_psymtab_comp_unit_data *) data;
7988 if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
7991 gdb_assert (! per_cu->is_debug_types);
7993 prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
7995 /* Allocate a new partial symbol table structure. */
7996 filename = dwarf2_string_attr (comp_unit_die, DW_AT_name, cu);
7997 if (filename == NULL)
8000 pst = create_partial_symtab (per_cu, filename);
8002 /* This must be done before calling dwarf2_build_include_psymtabs. */
8003 pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
8005 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8007 dwarf2_find_base_address (comp_unit_die, cu);
8009 /* Possibly set the default values of LOWPC and HIGHPC from
8011 cu_bounds_kind = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
8012 &best_highpc, cu, pst);
8013 if (cu_bounds_kind == PC_BOUNDS_HIGH_LOW && best_lowpc < best_highpc)
8016 = (gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr)
8019 = (gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr)
8021 /* Store the contiguous range if it is not empty; it can be
8022 empty for CUs with no code. */
8023 addrmap_set_empty (objfile->psymtabs_addrmap, low, high, pst);
8026 /* Check if comp unit has_children.
8027 If so, read the rest of the partial symbols from this comp unit.
8028 If not, there's no more debug_info for this comp unit. */
8031 struct partial_die_info *first_die;
8032 CORE_ADDR lowpc, highpc;
8034 lowpc = ((CORE_ADDR) -1);
8035 highpc = ((CORE_ADDR) 0);
8037 first_die = load_partial_dies (reader, info_ptr, 1);
8039 scan_partial_symbols (first_die, &lowpc, &highpc,
8040 cu_bounds_kind <= PC_BOUNDS_INVALID, cu);
8042 /* If we didn't find a lowpc, set it to highpc to avoid
8043 complaints from `maint check'. */
8044 if (lowpc == ((CORE_ADDR) -1))
8047 /* If the compilation unit didn't have an explicit address range,
8048 then use the information extracted from its child dies. */
8049 if (cu_bounds_kind <= PC_BOUNDS_INVALID)
8052 best_highpc = highpc;
8055 pst->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch,
8056 best_lowpc + baseaddr)
8058 pst->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch,
8059 best_highpc + baseaddr)
8062 end_psymtab_common (objfile, pst);
8064 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
8067 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8068 struct dwarf2_per_cu_data *iter;
8070 /* Fill in 'dependencies' here; we fill in 'users' in a
8072 pst->number_of_dependencies = len;
8074 XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
8076 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8079 pst->dependencies[i] = iter->v.psymtab;
8081 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8084 /* Get the list of files included in the current compilation unit,
8085 and build a psymtab for each of them. */
8086 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
8088 if (dwarf_read_debug)
8089 fprintf_unfiltered (gdb_stdlog,
8090 "Psymtab for %s unit @%s: %s - %s"
8091 ", %d global, %d static syms\n",
8092 per_cu->is_debug_types ? "type" : "comp",
8093 sect_offset_str (per_cu->sect_off),
8094 paddress (gdbarch, pst->text_low (objfile)),
8095 paddress (gdbarch, pst->text_high (objfile)),
8096 pst->n_global_syms, pst->n_static_syms);
8099 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8100 Process compilation unit THIS_CU for a psymtab. */
8103 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
8104 int want_partial_unit,
8105 enum language pretend_language)
8107 /* If this compilation unit was already read in, free the
8108 cached copy in order to read it in again. This is
8109 necessary because we skipped some symbols when we first
8110 read in the compilation unit (see load_partial_dies).
8111 This problem could be avoided, but the benefit is unclear. */
8112 if (this_cu->cu != NULL)
8113 free_one_cached_comp_unit (this_cu);
8115 if (this_cu->is_debug_types)
8116 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8117 build_type_psymtabs_reader, NULL);
8120 process_psymtab_comp_unit_data info;
8121 info.want_partial_unit = want_partial_unit;
8122 info.pretend_language = pretend_language;
8123 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8124 process_psymtab_comp_unit_reader, &info);
8127 /* Age out any secondary CUs. */
8128 age_cached_comp_units (this_cu->dwarf2_per_objfile);
8131 /* Reader function for build_type_psymtabs. */
8134 build_type_psymtabs_reader (const struct die_reader_specs *reader,
8135 const gdb_byte *info_ptr,
8136 struct die_info *type_unit_die,
8140 struct dwarf2_per_objfile *dwarf2_per_objfile
8141 = reader->cu->per_cu->dwarf2_per_objfile;
8142 struct objfile *objfile = dwarf2_per_objfile->objfile;
8143 struct dwarf2_cu *cu = reader->cu;
8144 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8145 struct signatured_type *sig_type;
8146 struct type_unit_group *tu_group;
8147 struct attribute *attr;
8148 struct partial_die_info *first_die;
8149 CORE_ADDR lowpc, highpc;
8150 struct partial_symtab *pst;
8152 gdb_assert (data == NULL);
8153 gdb_assert (per_cu->is_debug_types);
8154 sig_type = (struct signatured_type *) per_cu;
8159 attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
8160 tu_group = get_type_unit_group (cu, attr);
8162 VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
8164 prepare_one_comp_unit (cu, type_unit_die, language_minimal);
8165 pst = create_partial_symtab (per_cu, "");
8168 first_die = load_partial_dies (reader, info_ptr, 1);
8170 lowpc = (CORE_ADDR) -1;
8171 highpc = (CORE_ADDR) 0;
8172 scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
8174 end_psymtab_common (objfile, pst);
8177 /* Struct used to sort TUs by their abbreviation table offset. */
8179 struct tu_abbrev_offset
8181 tu_abbrev_offset (signatured_type *sig_type_, sect_offset abbrev_offset_)
8182 : sig_type (sig_type_), abbrev_offset (abbrev_offset_)
8185 signatured_type *sig_type;
8186 sect_offset abbrev_offset;
8189 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
8192 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset &a,
8193 const struct tu_abbrev_offset &b)
8195 return a.abbrev_offset < b.abbrev_offset;
8198 /* Efficiently read all the type units.
8199 This does the bulk of the work for build_type_psymtabs.
8201 The efficiency is because we sort TUs by the abbrev table they use and
8202 only read each abbrev table once. In one program there are 200K TUs
8203 sharing 8K abbrev tables.
8205 The main purpose of this function is to support building the
8206 dwarf2_per_objfile->type_unit_groups table.
8207 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8208 can collapse the search space by grouping them by stmt_list.
8209 The savings can be significant, in the same program from above the 200K TUs
8210 share 8K stmt_list tables.
8212 FUNC is expected to call get_type_unit_group, which will create the
8213 struct type_unit_group if necessary and add it to
8214 dwarf2_per_objfile->type_unit_groups. */
8217 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
8219 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8220 abbrev_table_up abbrev_table;
8221 sect_offset abbrev_offset;
8223 /* It's up to the caller to not call us multiple times. */
8224 gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
8226 if (dwarf2_per_objfile->all_type_units.empty ())
8229 /* TUs typically share abbrev tables, and there can be way more TUs than
8230 abbrev tables. Sort by abbrev table to reduce the number of times we
8231 read each abbrev table in.
8232 Alternatives are to punt or to maintain a cache of abbrev tables.
8233 This is simpler and efficient enough for now.
8235 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8236 symtab to use). Typically TUs with the same abbrev offset have the same
8237 stmt_list value too so in practice this should work well.
8239 The basic algorithm here is:
8241 sort TUs by abbrev table
8242 for each TU with same abbrev table:
8243 read abbrev table if first user
8244 read TU top level DIE
8245 [IWBN if DWO skeletons had DW_AT_stmt_list]
8248 if (dwarf_read_debug)
8249 fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
8251 /* Sort in a separate table to maintain the order of all_type_units
8252 for .gdb_index: TU indices directly index all_type_units. */
8253 std::vector<tu_abbrev_offset> sorted_by_abbrev;
8254 sorted_by_abbrev.reserve (dwarf2_per_objfile->all_type_units.size ());
8256 for (signatured_type *sig_type : dwarf2_per_objfile->all_type_units)
8257 sorted_by_abbrev.emplace_back
8258 (sig_type, read_abbrev_offset (dwarf2_per_objfile,
8259 sig_type->per_cu.section,
8260 sig_type->per_cu.sect_off));
8262 std::sort (sorted_by_abbrev.begin (), sorted_by_abbrev.end (),
8263 sort_tu_by_abbrev_offset);
8265 abbrev_offset = (sect_offset) ~(unsigned) 0;
8267 for (const tu_abbrev_offset &tu : sorted_by_abbrev)
8269 /* Switch to the next abbrev table if necessary. */
8270 if (abbrev_table == NULL
8271 || tu.abbrev_offset != abbrev_offset)
8273 abbrev_offset = tu.abbrev_offset;
8275 abbrev_table_read_table (dwarf2_per_objfile,
8276 &dwarf2_per_objfile->abbrev,
8278 ++tu_stats->nr_uniq_abbrev_tables;
8281 init_cutu_and_read_dies (&tu.sig_type->per_cu, abbrev_table.get (),
8282 0, 0, false, build_type_psymtabs_reader, NULL);
8286 /* Print collected type unit statistics. */
8289 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
8291 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8293 fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
8294 fprintf_unfiltered (gdb_stdlog, " %zu TUs\n",
8295 dwarf2_per_objfile->all_type_units.size ());
8296 fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
8297 tu_stats->nr_uniq_abbrev_tables);
8298 fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
8299 tu_stats->nr_symtabs);
8300 fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
8301 tu_stats->nr_symtab_sharers);
8302 fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
8303 tu_stats->nr_stmt_less_type_units);
8304 fprintf_unfiltered (gdb_stdlog, " %d all_type_units reallocs\n",
8305 tu_stats->nr_all_type_units_reallocs);
8308 /* Traversal function for build_type_psymtabs. */
8311 build_type_psymtab_dependencies (void **slot, void *info)
8313 struct dwarf2_per_objfile *dwarf2_per_objfile
8314 = (struct dwarf2_per_objfile *) info;
8315 struct objfile *objfile = dwarf2_per_objfile->objfile;
8316 struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
8317 struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
8318 struct partial_symtab *pst = per_cu->v.psymtab;
8319 int len = VEC_length (sig_type_ptr, tu_group->tus);
8320 struct signatured_type *iter;
8323 gdb_assert (len > 0);
8324 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
8326 pst->number_of_dependencies = len;
8328 XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
8330 VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
8333 gdb_assert (iter->per_cu.is_debug_types);
8334 pst->dependencies[i] = iter->per_cu.v.psymtab;
8335 iter->type_unit_group = tu_group;
8338 VEC_free (sig_type_ptr, tu_group->tus);
8343 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8344 Build partial symbol tables for the .debug_types comp-units. */
8347 build_type_psymtabs (struct dwarf2_per_objfile *dwarf2_per_objfile)
8349 if (! create_all_type_units (dwarf2_per_objfile))
8352 build_type_psymtabs_1 (dwarf2_per_objfile);
8355 /* Traversal function for process_skeletonless_type_unit.
8356 Read a TU in a DWO file and build partial symbols for it. */
8359 process_skeletonless_type_unit (void **slot, void *info)
8361 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
8362 struct dwarf2_per_objfile *dwarf2_per_objfile
8363 = (struct dwarf2_per_objfile *) info;
8364 struct signatured_type find_entry, *entry;
8366 /* If this TU doesn't exist in the global table, add it and read it in. */
8368 if (dwarf2_per_objfile->signatured_types == NULL)
8370 dwarf2_per_objfile->signatured_types
8371 = allocate_signatured_type_table (dwarf2_per_objfile->objfile);
8374 find_entry.signature = dwo_unit->signature;
8375 slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
8377 /* If we've already seen this type there's nothing to do. What's happening
8378 is we're doing our own version of comdat-folding here. */
8382 /* This does the job that create_all_type_units would have done for
8384 entry = add_type_unit (dwarf2_per_objfile, dwo_unit->signature, slot);
8385 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, entry, dwo_unit);
8388 /* This does the job that build_type_psymtabs_1 would have done. */
8389 init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0, false,
8390 build_type_psymtabs_reader, NULL);
8395 /* Traversal function for process_skeletonless_type_units. */
8398 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
8400 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
8402 if (dwo_file->tus != NULL)
8404 htab_traverse_noresize (dwo_file->tus,
8405 process_skeletonless_type_unit, info);
8411 /* Scan all TUs of DWO files, verifying we've processed them.
8412 This is needed in case a TU was emitted without its skeleton.
8413 Note: This can't be done until we know what all the DWO files are. */
8416 process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8418 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8419 if (get_dwp_file (dwarf2_per_objfile) == NULL
8420 && dwarf2_per_objfile->dwo_files != NULL)
8422 htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
8423 process_dwo_file_for_skeletonless_type_units,
8424 dwarf2_per_objfile);
8428 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8431 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
8433 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8435 struct partial_symtab *pst = per_cu->v.psymtab;
8440 for (int j = 0; j < pst->number_of_dependencies; ++j)
8442 /* Set the 'user' field only if it is not already set. */
8443 if (pst->dependencies[j]->user == NULL)
8444 pst->dependencies[j]->user = pst;
8449 /* Build the partial symbol table by doing a quick pass through the
8450 .debug_info and .debug_abbrev sections. */
8453 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
8455 struct objfile *objfile = dwarf2_per_objfile->objfile;
8457 if (dwarf_read_debug)
8459 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
8460 objfile_name (objfile));
8463 dwarf2_per_objfile->reading_partial_symbols = 1;
8465 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
8467 /* Any cached compilation units will be linked by the per-objfile
8468 read_in_chain. Make sure to free them when we're done. */
8469 free_cached_comp_units freer (dwarf2_per_objfile);
8471 build_type_psymtabs (dwarf2_per_objfile);
8473 create_all_comp_units (dwarf2_per_objfile);
8475 /* Create a temporary address map on a temporary obstack. We later
8476 copy this to the final obstack. */
8477 auto_obstack temp_obstack;
8479 scoped_restore save_psymtabs_addrmap
8480 = make_scoped_restore (&objfile->psymtabs_addrmap,
8481 addrmap_create_mutable (&temp_obstack));
8483 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8484 process_psymtab_comp_unit (per_cu, 0, language_minimal);
8486 /* This has to wait until we read the CUs, we need the list of DWOs. */
8487 process_skeletonless_type_units (dwarf2_per_objfile);
8489 /* Now that all TUs have been processed we can fill in the dependencies. */
8490 if (dwarf2_per_objfile->type_unit_groups != NULL)
8492 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
8493 build_type_psymtab_dependencies, dwarf2_per_objfile);
8496 if (dwarf_read_debug)
8497 print_tu_stats (dwarf2_per_objfile);
8499 set_partial_user (dwarf2_per_objfile);
8501 objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
8502 &objfile->objfile_obstack);
8503 /* At this point we want to keep the address map. */
8504 save_psymtabs_addrmap.release ();
8506 if (dwarf_read_debug)
8507 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
8508 objfile_name (objfile));
8511 /* die_reader_func for load_partial_comp_unit. */
8514 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
8515 const gdb_byte *info_ptr,
8516 struct die_info *comp_unit_die,
8520 struct dwarf2_cu *cu = reader->cu;
8522 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
8524 /* Check if comp unit has_children.
8525 If so, read the rest of the partial symbols from this comp unit.
8526 If not, there's no more debug_info for this comp unit. */
8528 load_partial_dies (reader, info_ptr, 0);
8531 /* Load the partial DIEs for a secondary CU into memory.
8532 This is also used when rereading a primary CU with load_all_dies. */
8535 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
8537 init_cutu_and_read_dies (this_cu, NULL, 1, 1, false,
8538 load_partial_comp_unit_reader, NULL);
8542 read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
8543 struct dwarf2_section_info *section,
8544 struct dwarf2_section_info *abbrev_section,
8545 unsigned int is_dwz)
8547 const gdb_byte *info_ptr;
8548 struct objfile *objfile = dwarf2_per_objfile->objfile;
8550 if (dwarf_read_debug)
8551 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
8552 get_section_name (section),
8553 get_section_file_name (section));
8555 dwarf2_read_section (objfile, section);
8557 info_ptr = section->buffer;
8559 while (info_ptr < section->buffer + section->size)
8561 struct dwarf2_per_cu_data *this_cu;
8563 sect_offset sect_off = (sect_offset) (info_ptr - section->buffer);
8565 comp_unit_head cu_header;
8566 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
8567 abbrev_section, info_ptr,
8568 rcuh_kind::COMPILE);
8570 /* Save the compilation unit for later lookup. */
8571 if (cu_header.unit_type != DW_UT_type)
8573 this_cu = XOBNEW (&objfile->objfile_obstack,
8574 struct dwarf2_per_cu_data);
8575 memset (this_cu, 0, sizeof (*this_cu));
8579 auto sig_type = XOBNEW (&objfile->objfile_obstack,
8580 struct signatured_type);
8581 memset (sig_type, 0, sizeof (*sig_type));
8582 sig_type->signature = cu_header.signature;
8583 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
8584 this_cu = &sig_type->per_cu;
8586 this_cu->is_debug_types = (cu_header.unit_type == DW_UT_type);
8587 this_cu->sect_off = sect_off;
8588 this_cu->length = cu_header.length + cu_header.initial_length_size;
8589 this_cu->is_dwz = is_dwz;
8590 this_cu->dwarf2_per_objfile = dwarf2_per_objfile;
8591 this_cu->section = section;
8593 dwarf2_per_objfile->all_comp_units.push_back (this_cu);
8595 info_ptr = info_ptr + this_cu->length;
8599 /* Create a list of all compilation units in OBJFILE.
8600 This is only done for -readnow and building partial symtabs. */
8603 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8605 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
8606 read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
8607 &dwarf2_per_objfile->abbrev, 0);
8609 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
8611 read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
8615 /* Process all loaded DIEs for compilation unit CU, starting at
8616 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8617 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8618 DW_AT_ranges). See the comments of add_partial_subprogram on how
8619 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8622 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
8623 CORE_ADDR *highpc, int set_addrmap,
8624 struct dwarf2_cu *cu)
8626 struct partial_die_info *pdi;
8628 /* Now, march along the PDI's, descending into ones which have
8629 interesting children but skipping the children of the other ones,
8630 until we reach the end of the compilation unit. */
8638 /* Anonymous namespaces or modules have no name but have interesting
8639 children, so we need to look at them. Ditto for anonymous
8642 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
8643 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
8644 || pdi->tag == DW_TAG_imported_unit
8645 || pdi->tag == DW_TAG_inlined_subroutine)
8649 case DW_TAG_subprogram:
8650 case DW_TAG_inlined_subroutine:
8651 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
8653 case DW_TAG_constant:
8654 case DW_TAG_variable:
8655 case DW_TAG_typedef:
8656 case DW_TAG_union_type:
8657 if (!pdi->is_declaration)
8659 add_partial_symbol (pdi, cu);
8662 case DW_TAG_class_type:
8663 case DW_TAG_interface_type:
8664 case DW_TAG_structure_type:
8665 if (!pdi->is_declaration)
8667 add_partial_symbol (pdi, cu);
8669 if ((cu->language == language_rust
8670 || cu->language == language_cplus) && pdi->has_children)
8671 scan_partial_symbols (pdi->die_child, lowpc, highpc,
8674 case DW_TAG_enumeration_type:
8675 if (!pdi->is_declaration)
8676 add_partial_enumeration (pdi, cu);
8678 case DW_TAG_base_type:
8679 case DW_TAG_subrange_type:
8680 /* File scope base type definitions are added to the partial
8682 add_partial_symbol (pdi, cu);
8684 case DW_TAG_namespace:
8685 add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
8688 add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
8690 case DW_TAG_imported_unit:
8692 struct dwarf2_per_cu_data *per_cu;
8694 /* For now we don't handle imported units in type units. */
8695 if (cu->per_cu->is_debug_types)
8697 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8698 " supported in type units [in module %s]"),
8699 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
8702 per_cu = dwarf2_find_containing_comp_unit
8703 (pdi->d.sect_off, pdi->is_dwz,
8704 cu->per_cu->dwarf2_per_objfile);
8706 /* Go read the partial unit, if needed. */
8707 if (per_cu->v.psymtab == NULL)
8708 process_psymtab_comp_unit (per_cu, 1, cu->language);
8710 VEC_safe_push (dwarf2_per_cu_ptr,
8711 cu->per_cu->imported_symtabs, per_cu);
8714 case DW_TAG_imported_declaration:
8715 add_partial_symbol (pdi, cu);
8722 /* If the die has a sibling, skip to the sibling. */
8724 pdi = pdi->die_sibling;
8728 /* Functions used to compute the fully scoped name of a partial DIE.
8730 Normally, this is simple. For C++, the parent DIE's fully scoped
8731 name is concatenated with "::" and the partial DIE's name.
8732 Enumerators are an exception; they use the scope of their parent
8733 enumeration type, i.e. the name of the enumeration type is not
8734 prepended to the enumerator.
8736 There are two complexities. One is DW_AT_specification; in this
8737 case "parent" means the parent of the target of the specification,
8738 instead of the direct parent of the DIE. The other is compilers
8739 which do not emit DW_TAG_namespace; in this case we try to guess
8740 the fully qualified name of structure types from their members'
8741 linkage names. This must be done using the DIE's children rather
8742 than the children of any DW_AT_specification target. We only need
8743 to do this for structures at the top level, i.e. if the target of
8744 any DW_AT_specification (if any; otherwise the DIE itself) does not
8747 /* Compute the scope prefix associated with PDI's parent, in
8748 compilation unit CU. The result will be allocated on CU's
8749 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8750 field. NULL is returned if no prefix is necessary. */
8752 partial_die_parent_scope (struct partial_die_info *pdi,
8753 struct dwarf2_cu *cu)
8755 const char *grandparent_scope;
8756 struct partial_die_info *parent, *real_pdi;
8758 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8759 then this means the parent of the specification DIE. */
8762 while (real_pdi->has_specification)
8763 real_pdi = find_partial_die (real_pdi->spec_offset,
8764 real_pdi->spec_is_dwz, cu);
8766 parent = real_pdi->die_parent;
8770 if (parent->scope_set)
8771 return parent->scope;
8775 grandparent_scope = partial_die_parent_scope (parent, cu);
8777 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8778 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8779 Work around this problem here. */
8780 if (cu->language == language_cplus
8781 && parent->tag == DW_TAG_namespace
8782 && strcmp (parent->name, "::") == 0
8783 && grandparent_scope == NULL)
8785 parent->scope = NULL;
8786 parent->scope_set = 1;
8790 if (pdi->tag == DW_TAG_enumerator)
8791 /* Enumerators should not get the name of the enumeration as a prefix. */
8792 parent->scope = grandparent_scope;
8793 else if (parent->tag == DW_TAG_namespace
8794 || parent->tag == DW_TAG_module
8795 || parent->tag == DW_TAG_structure_type
8796 || parent->tag == DW_TAG_class_type
8797 || parent->tag == DW_TAG_interface_type
8798 || parent->tag == DW_TAG_union_type
8799 || parent->tag == DW_TAG_enumeration_type)
8801 if (grandparent_scope == NULL)
8802 parent->scope = parent->name;
8804 parent->scope = typename_concat (&cu->comp_unit_obstack,
8806 parent->name, 0, cu);
8810 /* FIXME drow/2004-04-01: What should we be doing with
8811 function-local names? For partial symbols, we should probably be
8813 complaint (_("unhandled containing DIE tag %d for DIE at %s"),
8814 parent->tag, sect_offset_str (pdi->sect_off));
8815 parent->scope = grandparent_scope;
8818 parent->scope_set = 1;
8819 return parent->scope;
8822 /* Return the fully scoped name associated with PDI, from compilation unit
8823 CU. The result will be allocated with malloc. */
8826 partial_die_full_name (struct partial_die_info *pdi,
8827 struct dwarf2_cu *cu)
8829 const char *parent_scope;
8831 /* If this is a template instantiation, we can not work out the
8832 template arguments from partial DIEs. So, unfortunately, we have
8833 to go through the full DIEs. At least any work we do building
8834 types here will be reused if full symbols are loaded later. */
8835 if (pdi->has_template_arguments)
8839 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
8841 struct die_info *die;
8842 struct attribute attr;
8843 struct dwarf2_cu *ref_cu = cu;
8845 /* DW_FORM_ref_addr is using section offset. */
8846 attr.name = (enum dwarf_attribute) 0;
8847 attr.form = DW_FORM_ref_addr;
8848 attr.u.unsnd = to_underlying (pdi->sect_off);
8849 die = follow_die_ref (NULL, &attr, &ref_cu);
8851 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
8855 parent_scope = partial_die_parent_scope (pdi, cu);
8856 if (parent_scope == NULL)
8859 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
8863 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
8865 struct dwarf2_per_objfile *dwarf2_per_objfile
8866 = cu->per_cu->dwarf2_per_objfile;
8867 struct objfile *objfile = dwarf2_per_objfile->objfile;
8868 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8870 const char *actual_name = NULL;
8872 char *built_actual_name;
8874 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8876 built_actual_name = partial_die_full_name (pdi, cu);
8877 if (built_actual_name != NULL)
8878 actual_name = built_actual_name;
8880 if (actual_name == NULL)
8881 actual_name = pdi->name;
8885 case DW_TAG_inlined_subroutine:
8886 case DW_TAG_subprogram:
8887 addr = (gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr)
8889 if (pdi->is_external || cu->language == language_ada)
8891 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8892 of the global scope. But in Ada, we want to be able to access
8893 nested procedures globally. So all Ada subprograms are stored
8894 in the global scope. */
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 &objfile->global_psymbols,
8901 cu->language, objfile);
8905 add_psymbol_to_list (actual_name, strlen (actual_name),
8906 built_actual_name != NULL,
8907 VAR_DOMAIN, LOC_BLOCK,
8908 SECT_OFF_TEXT (objfile),
8909 &objfile->static_psymbols,
8910 addr, cu->language, objfile);
8913 if (pdi->main_subprogram && actual_name != NULL)
8914 set_objfile_main_name (objfile, actual_name, cu->language);
8916 case DW_TAG_constant:
8918 std::vector<partial_symbol *> *list;
8920 if (pdi->is_external)
8921 list = &objfile->global_psymbols;
8923 list = &objfile->static_psymbols;
8924 add_psymbol_to_list (actual_name, strlen (actual_name),
8925 built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
8926 -1, list, 0, cu->language, objfile);
8929 case DW_TAG_variable:
8931 addr = decode_locdesc (pdi->d.locdesc, cu);
8935 && !dwarf2_per_objfile->has_section_at_zero)
8937 /* A global or static variable may also have been stripped
8938 out by the linker if unused, in which case its address
8939 will be nullified; do not add such variables into partial
8940 symbol table then. */
8942 else if (pdi->is_external)
8945 Don't enter into the minimal symbol tables as there is
8946 a minimal symbol table entry from the ELF symbols already.
8947 Enter into partial symbol table if it has a location
8948 descriptor or a type.
8949 If the location descriptor is missing, new_symbol will create
8950 a LOC_UNRESOLVED symbol, the address of the variable will then
8951 be determined from the minimal symbol table whenever the variable
8953 The address for the partial symbol table entry is not
8954 used by GDB, but it comes in handy for debugging partial symbol
8957 if (pdi->d.locdesc || pdi->has_type)
8958 add_psymbol_to_list (actual_name, strlen (actual_name),
8959 built_actual_name != NULL,
8960 VAR_DOMAIN, LOC_STATIC,
8961 SECT_OFF_TEXT (objfile),
8962 &objfile->global_psymbols,
8963 addr, cu->language, objfile);
8967 int has_loc = pdi->d.locdesc != NULL;
8969 /* Static Variable. Skip symbols whose value we cannot know (those
8970 without location descriptors or constant values). */
8971 if (!has_loc && !pdi->has_const_value)
8973 xfree (built_actual_name);
8977 add_psymbol_to_list (actual_name, strlen (actual_name),
8978 built_actual_name != NULL,
8979 VAR_DOMAIN, LOC_STATIC,
8980 SECT_OFF_TEXT (objfile),
8981 &objfile->static_psymbols,
8983 cu->language, objfile);
8986 case DW_TAG_typedef:
8987 case DW_TAG_base_type:
8988 case DW_TAG_subrange_type:
8989 add_psymbol_to_list (actual_name, strlen (actual_name),
8990 built_actual_name != NULL,
8991 VAR_DOMAIN, LOC_TYPEDEF, -1,
8992 &objfile->static_psymbols,
8993 0, cu->language, objfile);
8995 case DW_TAG_imported_declaration:
8996 case DW_TAG_namespace:
8997 add_psymbol_to_list (actual_name, strlen (actual_name),
8998 built_actual_name != NULL,
8999 VAR_DOMAIN, LOC_TYPEDEF, -1,
9000 &objfile->global_psymbols,
9001 0, cu->language, objfile);
9004 add_psymbol_to_list (actual_name, strlen (actual_name),
9005 built_actual_name != NULL,
9006 MODULE_DOMAIN, LOC_TYPEDEF, -1,
9007 &objfile->global_psymbols,
9008 0, cu->language, objfile);
9010 case DW_TAG_class_type:
9011 case DW_TAG_interface_type:
9012 case DW_TAG_structure_type:
9013 case DW_TAG_union_type:
9014 case DW_TAG_enumeration_type:
9015 /* Skip external references. The DWARF standard says in the section
9016 about "Structure, Union, and Class Type Entries": "An incomplete
9017 structure, union or class type is represented by a structure,
9018 union or class entry that does not have a byte size attribute
9019 and that has a DW_AT_declaration attribute." */
9020 if (!pdi->has_byte_size && pdi->is_declaration)
9022 xfree (built_actual_name);
9026 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9027 static vs. global. */
9028 add_psymbol_to_list (actual_name, strlen (actual_name),
9029 built_actual_name != NULL,
9030 STRUCT_DOMAIN, LOC_TYPEDEF, -1,
9031 cu->language == language_cplus
9032 ? &objfile->global_psymbols
9033 : &objfile->static_psymbols,
9034 0, cu->language, objfile);
9037 case DW_TAG_enumerator:
9038 add_psymbol_to_list (actual_name, strlen (actual_name),
9039 built_actual_name != NULL,
9040 VAR_DOMAIN, LOC_CONST, -1,
9041 cu->language == language_cplus
9042 ? &objfile->global_psymbols
9043 : &objfile->static_psymbols,
9044 0, cu->language, objfile);
9050 xfree (built_actual_name);
9053 /* Read a partial die corresponding to a namespace; also, add a symbol
9054 corresponding to that namespace to the symbol table. NAMESPACE is
9055 the name of the enclosing namespace. */
9058 add_partial_namespace (struct partial_die_info *pdi,
9059 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9060 int set_addrmap, struct dwarf2_cu *cu)
9062 /* Add a symbol for the namespace. */
9064 add_partial_symbol (pdi, cu);
9066 /* Now scan partial symbols in that namespace. */
9068 if (pdi->has_children)
9069 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9072 /* Read a partial die corresponding to a Fortran module. */
9075 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
9076 CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
9078 /* Add a symbol for the namespace. */
9080 add_partial_symbol (pdi, cu);
9082 /* Now scan partial symbols in that module. */
9084 if (pdi->has_children)
9085 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9088 /* Read a partial die corresponding to a subprogram or an inlined
9089 subprogram and create a partial symbol for that subprogram.
9090 When the CU language allows it, this routine also defines a partial
9091 symbol for each nested subprogram that this subprogram contains.
9092 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9093 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9095 PDI may also be a lexical block, in which case we simply search
9096 recursively for subprograms defined inside that lexical block.
9097 Again, this is only performed when the CU language allows this
9098 type of definitions. */
9101 add_partial_subprogram (struct partial_die_info *pdi,
9102 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9103 int set_addrmap, struct dwarf2_cu *cu)
9105 if (pdi->tag == DW_TAG_subprogram || pdi->tag == DW_TAG_inlined_subroutine)
9107 if (pdi->has_pc_info)
9109 if (pdi->lowpc < *lowpc)
9110 *lowpc = pdi->lowpc;
9111 if (pdi->highpc > *highpc)
9112 *highpc = pdi->highpc;
9115 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9116 struct gdbarch *gdbarch = get_objfile_arch (objfile);
9118 CORE_ADDR this_highpc;
9119 CORE_ADDR this_lowpc;
9121 baseaddr = ANOFFSET (objfile->section_offsets,
9122 SECT_OFF_TEXT (objfile));
9124 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9125 pdi->lowpc + baseaddr)
9128 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9129 pdi->highpc + baseaddr)
9131 addrmap_set_empty (objfile->psymtabs_addrmap,
9132 this_lowpc, this_highpc - 1,
9133 cu->per_cu->v.psymtab);
9137 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
9139 if (!pdi->is_declaration)
9140 /* Ignore subprogram DIEs that do not have a name, they are
9141 illegal. Do not emit a complaint at this point, we will
9142 do so when we convert this psymtab into a symtab. */
9144 add_partial_symbol (pdi, cu);
9148 if (! pdi->has_children)
9151 if (cu->language == language_ada)
9153 pdi = pdi->die_child;
9157 if (pdi->tag == DW_TAG_subprogram
9158 || pdi->tag == DW_TAG_inlined_subroutine
9159 || pdi->tag == DW_TAG_lexical_block)
9160 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
9161 pdi = pdi->die_sibling;
9166 /* Read a partial die corresponding to an enumeration type. */
9169 add_partial_enumeration (struct partial_die_info *enum_pdi,
9170 struct dwarf2_cu *cu)
9172 struct partial_die_info *pdi;
9174 if (enum_pdi->name != NULL)
9175 add_partial_symbol (enum_pdi, cu);
9177 pdi = enum_pdi->die_child;
9180 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
9181 complaint (_("malformed enumerator DIE ignored"));
9183 add_partial_symbol (pdi, cu);
9184 pdi = pdi->die_sibling;
9188 /* Return the initial uleb128 in the die at INFO_PTR. */
9191 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
9193 unsigned int bytes_read;
9195 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9198 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9199 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
9201 Return the corresponding abbrev, or NULL if the number is zero (indicating
9202 an empty DIE). In either case *BYTES_READ will be set to the length of
9203 the initial number. */
9205 static struct abbrev_info *
9206 peek_die_abbrev (const die_reader_specs &reader,
9207 const gdb_byte *info_ptr, unsigned int *bytes_read)
9209 dwarf2_cu *cu = reader.cu;
9210 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
9211 unsigned int abbrev_number
9212 = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
9214 if (abbrev_number == 0)
9217 abbrev_info *abbrev = reader.abbrev_table->lookup_abbrev (abbrev_number);
9220 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9221 " at offset %s [in module %s]"),
9222 abbrev_number, cu->per_cu->is_debug_types ? "TU" : "CU",
9223 sect_offset_str (cu->header.sect_off), bfd_get_filename (abfd));
9229 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9230 Returns a pointer to the end of a series of DIEs, terminated by an empty
9231 DIE. Any children of the skipped DIEs will also be skipped. */
9233 static const gdb_byte *
9234 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
9238 unsigned int bytes_read;
9239 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
9242 return info_ptr + bytes_read;
9244 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
9248 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9249 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9250 abbrev corresponding to that skipped uleb128 should be passed in
9251 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9254 static const gdb_byte *
9255 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
9256 struct abbrev_info *abbrev)
9258 unsigned int bytes_read;
9259 struct attribute attr;
9260 bfd *abfd = reader->abfd;
9261 struct dwarf2_cu *cu = reader->cu;
9262 const gdb_byte *buffer = reader->buffer;
9263 const gdb_byte *buffer_end = reader->buffer_end;
9264 unsigned int form, i;
9266 for (i = 0; i < abbrev->num_attrs; i++)
9268 /* The only abbrev we care about is DW_AT_sibling. */
9269 if (abbrev->attrs[i].name == DW_AT_sibling)
9271 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
9272 if (attr.form == DW_FORM_ref_addr)
9273 complaint (_("ignoring absolute DW_AT_sibling"));
9276 sect_offset off = dwarf2_get_ref_die_offset (&attr);
9277 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
9279 if (sibling_ptr < info_ptr)
9280 complaint (_("DW_AT_sibling points backwards"));
9281 else if (sibling_ptr > reader->buffer_end)
9282 dwarf2_section_buffer_overflow_complaint (reader->die_section);
9288 /* If it isn't DW_AT_sibling, skip this attribute. */
9289 form = abbrev->attrs[i].form;
9293 case DW_FORM_ref_addr:
9294 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9295 and later it is offset sized. */
9296 if (cu->header.version == 2)
9297 info_ptr += cu->header.addr_size;
9299 info_ptr += cu->header.offset_size;
9301 case DW_FORM_GNU_ref_alt:
9302 info_ptr += cu->header.offset_size;
9305 info_ptr += cu->header.addr_size;
9312 case DW_FORM_flag_present:
9313 case DW_FORM_implicit_const:
9325 case DW_FORM_ref_sig8:
9328 case DW_FORM_data16:
9331 case DW_FORM_string:
9332 read_direct_string (abfd, info_ptr, &bytes_read);
9333 info_ptr += bytes_read;
9335 case DW_FORM_sec_offset:
9337 case DW_FORM_GNU_strp_alt:
9338 info_ptr += cu->header.offset_size;
9340 case DW_FORM_exprloc:
9342 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9343 info_ptr += bytes_read;
9345 case DW_FORM_block1:
9346 info_ptr += 1 + read_1_byte (abfd, info_ptr);
9348 case DW_FORM_block2:
9349 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
9351 case DW_FORM_block4:
9352 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
9356 case DW_FORM_ref_udata:
9357 case DW_FORM_GNU_addr_index:
9358 case DW_FORM_GNU_str_index:
9359 info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
9361 case DW_FORM_indirect:
9362 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9363 info_ptr += bytes_read;
9364 /* We need to continue parsing from here, so just go back to
9366 goto skip_attribute;
9369 error (_("Dwarf Error: Cannot handle %s "
9370 "in DWARF reader [in module %s]"),
9371 dwarf_form_name (form),
9372 bfd_get_filename (abfd));
9376 if (abbrev->has_children)
9377 return skip_children (reader, info_ptr);
9382 /* Locate ORIG_PDI's sibling.
9383 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9385 static const gdb_byte *
9386 locate_pdi_sibling (const struct die_reader_specs *reader,
9387 struct partial_die_info *orig_pdi,
9388 const gdb_byte *info_ptr)
9390 /* Do we know the sibling already? */
9392 if (orig_pdi->sibling)
9393 return orig_pdi->sibling;
9395 /* Are there any children to deal with? */
9397 if (!orig_pdi->has_children)
9400 /* Skip the children the long way. */
9402 return skip_children (reader, info_ptr);
9405 /* Expand this partial symbol table into a full symbol table. SELF is
9409 dwarf2_read_symtab (struct partial_symtab *self,
9410 struct objfile *objfile)
9412 struct dwarf2_per_objfile *dwarf2_per_objfile
9413 = get_dwarf2_per_objfile (objfile);
9417 warning (_("bug: psymtab for %s is already read in."),
9424 printf_filtered (_("Reading in symbols for %s..."),
9426 gdb_flush (gdb_stdout);
9429 /* If this psymtab is constructed from a debug-only objfile, the
9430 has_section_at_zero flag will not necessarily be correct. We
9431 can get the correct value for this flag by looking at the data
9432 associated with the (presumably stripped) associated objfile. */
9433 if (objfile->separate_debug_objfile_backlink)
9435 struct dwarf2_per_objfile *dpo_backlink
9436 = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
9438 dwarf2_per_objfile->has_section_at_zero
9439 = dpo_backlink->has_section_at_zero;
9442 dwarf2_per_objfile->reading_partial_symbols = 0;
9444 psymtab_to_symtab_1 (self);
9446 /* Finish up the debug error message. */
9448 printf_filtered (_("done.\n"));
9451 process_cu_includes (dwarf2_per_objfile);
9454 /* Reading in full CUs. */
9456 /* Add PER_CU to the queue. */
9459 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
9460 enum language pretend_language)
9462 struct dwarf2_queue_item *item;
9465 item = XNEW (struct dwarf2_queue_item);
9466 item->per_cu = per_cu;
9467 item->pretend_language = pretend_language;
9470 if (dwarf2_queue == NULL)
9471 dwarf2_queue = item;
9473 dwarf2_queue_tail->next = item;
9475 dwarf2_queue_tail = item;
9478 /* If PER_CU is not yet queued, add it to the queue.
9479 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9481 The result is non-zero if PER_CU was queued, otherwise the result is zero
9482 meaning either PER_CU is already queued or it is already loaded.
9484 N.B. There is an invariant here that if a CU is queued then it is loaded.
9485 The caller is required to load PER_CU if we return non-zero. */
9488 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
9489 struct dwarf2_per_cu_data *per_cu,
9490 enum language pretend_language)
9492 /* We may arrive here during partial symbol reading, if we need full
9493 DIEs to process an unusual case (e.g. template arguments). Do
9494 not queue PER_CU, just tell our caller to load its DIEs. */
9495 if (per_cu->dwarf2_per_objfile->reading_partial_symbols)
9497 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
9502 /* Mark the dependence relation so that we don't flush PER_CU
9504 if (dependent_cu != NULL)
9505 dwarf2_add_dependence (dependent_cu, per_cu);
9507 /* If it's already on the queue, we have nothing to do. */
9511 /* If the compilation unit is already loaded, just mark it as
9513 if (per_cu->cu != NULL)
9515 per_cu->cu->last_used = 0;
9519 /* Add it to the queue. */
9520 queue_comp_unit (per_cu, pretend_language);
9525 /* Process the queue. */
9528 process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
9530 struct dwarf2_queue_item *item, *next_item;
9532 if (dwarf_read_debug)
9534 fprintf_unfiltered (gdb_stdlog,
9535 "Expanding one or more symtabs of objfile %s ...\n",
9536 objfile_name (dwarf2_per_objfile->objfile));
9539 /* The queue starts out with one item, but following a DIE reference
9540 may load a new CU, adding it to the end of the queue. */
9541 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
9543 if ((dwarf2_per_objfile->using_index
9544 ? !item->per_cu->v.quick->compunit_symtab
9545 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
9546 /* Skip dummy CUs. */
9547 && item->per_cu->cu != NULL)
9549 struct dwarf2_per_cu_data *per_cu = item->per_cu;
9550 unsigned int debug_print_threshold;
9553 if (per_cu->is_debug_types)
9555 struct signatured_type *sig_type =
9556 (struct signatured_type *) per_cu;
9558 sprintf (buf, "TU %s at offset %s",
9559 hex_string (sig_type->signature),
9560 sect_offset_str (per_cu->sect_off));
9561 /* There can be 100s of TUs.
9562 Only print them in verbose mode. */
9563 debug_print_threshold = 2;
9567 sprintf (buf, "CU at offset %s",
9568 sect_offset_str (per_cu->sect_off));
9569 debug_print_threshold = 1;
9572 if (dwarf_read_debug >= debug_print_threshold)
9573 fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
9575 if (per_cu->is_debug_types)
9576 process_full_type_unit (per_cu, item->pretend_language);
9578 process_full_comp_unit (per_cu, item->pretend_language);
9580 if (dwarf_read_debug >= debug_print_threshold)
9581 fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
9584 item->per_cu->queued = 0;
9585 next_item = item->next;
9589 dwarf2_queue_tail = NULL;
9591 if (dwarf_read_debug)
9593 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
9594 objfile_name (dwarf2_per_objfile->objfile));
9598 /* Read in full symbols for PST, and anything it depends on. */
9601 psymtab_to_symtab_1 (struct partial_symtab *pst)
9603 struct dwarf2_per_cu_data *per_cu;
9609 for (i = 0; i < pst->number_of_dependencies; i++)
9610 if (!pst->dependencies[i]->readin
9611 && pst->dependencies[i]->user == NULL)
9613 /* Inform about additional files that need to be read in. */
9616 /* FIXME: i18n: Need to make this a single string. */
9617 fputs_filtered (" ", gdb_stdout);
9619 fputs_filtered ("and ", gdb_stdout);
9621 printf_filtered ("%s...", pst->dependencies[i]->filename);
9622 wrap_here (""); /* Flush output. */
9623 gdb_flush (gdb_stdout);
9625 psymtab_to_symtab_1 (pst->dependencies[i]);
9628 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
9632 /* It's an include file, no symbols to read for it.
9633 Everything is in the parent symtab. */
9638 dw2_do_instantiate_symtab (per_cu, false);
9641 /* Trivial hash function for die_info: the hash value of a DIE
9642 is its offset in .debug_info for this objfile. */
9645 die_hash (const void *item)
9647 const struct die_info *die = (const struct die_info *) item;
9649 return to_underlying (die->sect_off);
9652 /* Trivial comparison function for die_info structures: two DIEs
9653 are equal if they have the same offset. */
9656 die_eq (const void *item_lhs, const void *item_rhs)
9658 const struct die_info *die_lhs = (const struct die_info *) item_lhs;
9659 const struct die_info *die_rhs = (const struct die_info *) item_rhs;
9661 return die_lhs->sect_off == die_rhs->sect_off;
9664 /* die_reader_func for load_full_comp_unit.
9665 This is identical to read_signatured_type_reader,
9666 but is kept separate for now. */
9669 load_full_comp_unit_reader (const struct die_reader_specs *reader,
9670 const gdb_byte *info_ptr,
9671 struct die_info *comp_unit_die,
9675 struct dwarf2_cu *cu = reader->cu;
9676 enum language *language_ptr = (enum language *) data;
9678 gdb_assert (cu->die_hash == NULL);
9680 htab_create_alloc_ex (cu->header.length / 12,
9684 &cu->comp_unit_obstack,
9685 hashtab_obstack_allocate,
9686 dummy_obstack_deallocate);
9689 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
9690 &info_ptr, comp_unit_die);
9691 cu->dies = comp_unit_die;
9692 /* comp_unit_die is not stored in die_hash, no need. */
9694 /* We try not to read any attributes in this function, because not
9695 all CUs needed for references have been loaded yet, and symbol
9696 table processing isn't initialized. But we have to set the CU language,
9697 or we won't be able to build types correctly.
9698 Similarly, if we do not read the producer, we can not apply
9699 producer-specific interpretation. */
9700 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
9703 /* Load the DIEs associated with PER_CU into memory. */
9706 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
9708 enum language pretend_language)
9710 gdb_assert (! this_cu->is_debug_types);
9712 init_cutu_and_read_dies (this_cu, NULL, 1, 1, skip_partial,
9713 load_full_comp_unit_reader, &pretend_language);
9716 /* Add a DIE to the delayed physname list. */
9719 add_to_method_list (struct type *type, int fnfield_index, int index,
9720 const char *name, struct die_info *die,
9721 struct dwarf2_cu *cu)
9723 struct delayed_method_info mi;
9725 mi.fnfield_index = fnfield_index;
9729 cu->method_list.push_back (mi);
9732 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9733 "const" / "volatile". If so, decrements LEN by the length of the
9734 modifier and return true. Otherwise return false. */
9738 check_modifier (const char *physname, size_t &len, const char (&mod)[N])
9740 size_t mod_len = sizeof (mod) - 1;
9741 if (len > mod_len && startswith (physname + (len - mod_len), mod))
9749 /* Compute the physnames of any methods on the CU's method list.
9751 The computation of method physnames is delayed in order to avoid the
9752 (bad) condition that one of the method's formal parameters is of an as yet
9756 compute_delayed_physnames (struct dwarf2_cu *cu)
9758 /* Only C++ delays computing physnames. */
9759 if (cu->method_list.empty ())
9761 gdb_assert (cu->language == language_cplus);
9763 for (const delayed_method_info &mi : cu->method_list)
9765 const char *physname;
9766 struct fn_fieldlist *fn_flp
9767 = &TYPE_FN_FIELDLIST (mi.type, mi.fnfield_index);
9768 physname = dwarf2_physname (mi.name, mi.die, cu);
9769 TYPE_FN_FIELD_PHYSNAME (fn_flp->fn_fields, mi.index)
9770 = physname ? physname : "";
9772 /* Since there's no tag to indicate whether a method is a
9773 const/volatile overload, extract that information out of the
9775 if (physname != NULL)
9777 size_t len = strlen (physname);
9781 if (physname[len] == ')') /* shortcut */
9783 else if (check_modifier (physname, len, " const"))
9784 TYPE_FN_FIELD_CONST (fn_flp->fn_fields, mi.index) = 1;
9785 else if (check_modifier (physname, len, " volatile"))
9786 TYPE_FN_FIELD_VOLATILE (fn_flp->fn_fields, mi.index) = 1;
9793 /* The list is no longer needed. */
9794 cu->method_list.clear ();
9797 /* A wrapper for add_symbol_to_list to ensure that SYMBOL's language is
9798 the same as all other symbols in LISTHEAD. If a new symbol is added
9799 with a different language, this function asserts. */
9802 dw2_add_symbol_to_list (struct symbol *symbol, struct pending **listhead)
9804 /* Only assert if LISTHEAD already contains symbols of a different
9805 language (dict_create_hashed/insert_symbol_hashed requires that all
9806 symbols in this list are of the same language). */
9807 gdb_assert ((*listhead) == NULL
9808 || (SYMBOL_LANGUAGE ((*listhead)->symbol[0])
9809 == SYMBOL_LANGUAGE (symbol)));
9811 add_symbol_to_list (symbol, listhead);
9814 /* Go objects should be embedded in a DW_TAG_module DIE,
9815 and it's not clear if/how imported objects will appear.
9816 To keep Go support simple until that's worked out,
9817 go back through what we've read and create something usable.
9818 We could do this while processing each DIE, and feels kinda cleaner,
9819 but that way is more invasive.
9820 This is to, for example, allow the user to type "p var" or "b main"
9821 without having to specify the package name, and allow lookups
9822 of module.object to work in contexts that use the expression
9826 fixup_go_packaging (struct dwarf2_cu *cu)
9828 char *package_name = NULL;
9829 struct pending *list;
9832 for (list = *cu->builder->get_global_symbols ();
9836 for (i = 0; i < list->nsyms; ++i)
9838 struct symbol *sym = list->symbol[i];
9840 if (SYMBOL_LANGUAGE (sym) == language_go
9841 && SYMBOL_CLASS (sym) == LOC_BLOCK)
9843 char *this_package_name = go_symbol_package_name (sym);
9845 if (this_package_name == NULL)
9847 if (package_name == NULL)
9848 package_name = this_package_name;
9851 struct objfile *objfile
9852 = cu->per_cu->dwarf2_per_objfile->objfile;
9853 if (strcmp (package_name, this_package_name) != 0)
9854 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9855 (symbol_symtab (sym) != NULL
9856 ? symtab_to_filename_for_display
9857 (symbol_symtab (sym))
9858 : objfile_name (objfile)),
9859 this_package_name, package_name);
9860 xfree (this_package_name);
9866 if (package_name != NULL)
9868 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9869 const char *saved_package_name
9870 = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
9872 strlen (package_name));
9873 struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
9874 saved_package_name);
9877 sym = allocate_symbol (objfile);
9878 SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
9879 SYMBOL_SET_NAMES (sym, saved_package_name,
9880 strlen (saved_package_name), 0, objfile);
9881 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9882 e.g., "main" finds the "main" module and not C's main(). */
9883 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
9884 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
9885 SYMBOL_TYPE (sym) = type;
9887 dw2_add_symbol_to_list (sym, cu->builder->get_global_symbols ());
9889 xfree (package_name);
9893 /* Allocate a fully-qualified name consisting of the two parts on the
9897 rust_fully_qualify (struct obstack *obstack, const char *p1, const char *p2)
9899 return obconcat (obstack, p1, "::", p2, (char *) NULL);
9902 /* A helper that allocates a struct discriminant_info to attach to a
9905 static struct discriminant_info *
9906 alloc_discriminant_info (struct type *type, int discriminant_index,
9909 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9910 gdb_assert (discriminant_index == -1
9911 || (discriminant_index >= 0
9912 && discriminant_index < TYPE_NFIELDS (type)));
9913 gdb_assert (default_index == -1
9914 || (default_index >= 0 && default_index < TYPE_NFIELDS (type)));
9916 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
9918 struct discriminant_info *disc
9919 = ((struct discriminant_info *)
9921 offsetof (struct discriminant_info, discriminants)
9922 + TYPE_NFIELDS (type) * sizeof (disc->discriminants[0])));
9923 disc->default_index = default_index;
9924 disc->discriminant_index = discriminant_index;
9926 struct dynamic_prop prop;
9927 prop.kind = PROP_UNDEFINED;
9928 prop.data.baton = disc;
9930 add_dyn_prop (DYN_PROP_DISCRIMINATED, prop, type);
9935 /* Some versions of rustc emitted enums in an unusual way.
9937 Ordinary enums were emitted as unions. The first element of each
9938 structure in the union was named "RUST$ENUM$DISR". This element
9939 held the discriminant.
9941 These versions of Rust also implemented the "non-zero"
9942 optimization. When the enum had two values, and one is empty and
9943 the other holds a pointer that cannot be zero, the pointer is used
9944 as the discriminant, with a zero value meaning the empty variant.
9945 Here, the union's first member is of the form
9946 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9947 where the fieldnos are the indices of the fields that should be
9948 traversed in order to find the field (which may be several fields deep)
9949 and the variantname is the name of the variant of the case when the
9952 This function recognizes whether TYPE is of one of these forms,
9953 and, if so, smashes it to be a variant type. */
9956 quirk_rust_enum (struct type *type, struct objfile *objfile)
9958 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9960 /* We don't need to deal with empty enums. */
9961 if (TYPE_NFIELDS (type) == 0)
9964 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9965 if (TYPE_NFIELDS (type) == 1
9966 && startswith (TYPE_FIELD_NAME (type, 0), RUST_ENUM_PREFIX))
9968 const char *name = TYPE_FIELD_NAME (type, 0) + strlen (RUST_ENUM_PREFIX);
9970 /* Decode the field name to find the offset of the
9972 ULONGEST bit_offset = 0;
9973 struct type *field_type = TYPE_FIELD_TYPE (type, 0);
9974 while (name[0] >= '0' && name[0] <= '9')
9977 unsigned long index = strtoul (name, &tail, 10);
9980 || index >= TYPE_NFIELDS (field_type)
9981 || (TYPE_FIELD_LOC_KIND (field_type, index)
9982 != FIELD_LOC_KIND_BITPOS))
9984 complaint (_("Could not parse Rust enum encoding string \"%s\""
9986 TYPE_FIELD_NAME (type, 0),
9987 objfile_name (objfile));
9992 bit_offset += TYPE_FIELD_BITPOS (field_type, index);
9993 field_type = TYPE_FIELD_TYPE (field_type, index);
9996 /* Make a union to hold the variants. */
9997 struct type *union_type = alloc_type (objfile);
9998 TYPE_CODE (union_type) = TYPE_CODE_UNION;
9999 TYPE_NFIELDS (union_type) = 3;
10000 TYPE_FIELDS (union_type)
10001 = (struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field));
10002 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10003 set_type_align (union_type, TYPE_RAW_ALIGN (type));
10005 /* Put the discriminant must at index 0. */
10006 TYPE_FIELD_TYPE (union_type, 0) = field_type;
10007 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10008 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10009 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 0), bit_offset);
10011 /* The order of fields doesn't really matter, so put the real
10012 field at index 1 and the data-less field at index 2. */
10013 struct discriminant_info *disc
10014 = alloc_discriminant_info (union_type, 0, 1);
10015 TYPE_FIELD (union_type, 1) = TYPE_FIELD (type, 0);
10016 TYPE_FIELD_NAME (union_type, 1)
10017 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1)));
10018 TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1))
10019 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10020 TYPE_FIELD_NAME (union_type, 1));
10022 const char *dataless_name
10023 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10025 struct type *dataless_type = init_type (objfile, TYPE_CODE_VOID, 0,
10027 TYPE_FIELD_TYPE (union_type, 2) = dataless_type;
10028 /* NAME points into the original discriminant name, which
10029 already has the correct lifetime. */
10030 TYPE_FIELD_NAME (union_type, 2) = name;
10031 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 2), 0);
10032 disc->discriminants[2] = 0;
10034 /* Smash this type to be a structure type. We have to do this
10035 because the type has already been recorded. */
10036 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10037 TYPE_NFIELDS (type) = 1;
10039 = (struct field *) TYPE_ZALLOC (type, sizeof (struct field));
10041 /* Install the variant part. */
10042 TYPE_FIELD_TYPE (type, 0) = union_type;
10043 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10044 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10046 else if (TYPE_NFIELDS (type) == 1)
10048 /* We assume that a union with a single field is a univariant
10050 /* Smash this type to be a structure type. We have to do this
10051 because the type has already been recorded. */
10052 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10054 /* Make a union to hold the variants. */
10055 struct type *union_type = alloc_type (objfile);
10056 TYPE_CODE (union_type) = TYPE_CODE_UNION;
10057 TYPE_NFIELDS (union_type) = TYPE_NFIELDS (type);
10058 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10059 set_type_align (union_type, TYPE_RAW_ALIGN (type));
10060 TYPE_FIELDS (union_type) = TYPE_FIELDS (type);
10062 struct type *field_type = TYPE_FIELD_TYPE (union_type, 0);
10063 const char *variant_name
10064 = rust_last_path_segment (TYPE_NAME (field_type));
10065 TYPE_FIELD_NAME (union_type, 0) = variant_name;
10066 TYPE_NAME (field_type)
10067 = rust_fully_qualify (&objfile->objfile_obstack,
10068 TYPE_NAME (type), variant_name);
10070 /* Install the union in the outer struct type. */
10071 TYPE_NFIELDS (type) = 1;
10073 = (struct field *) TYPE_ZALLOC (union_type, sizeof (struct field));
10074 TYPE_FIELD_TYPE (type, 0) = union_type;
10075 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10076 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10078 alloc_discriminant_info (union_type, -1, 0);
10082 struct type *disr_type = nullptr;
10083 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
10085 disr_type = TYPE_FIELD_TYPE (type, i);
10087 if (TYPE_CODE (disr_type) != TYPE_CODE_STRUCT)
10089 /* All fields of a true enum will be structs. */
10092 else if (TYPE_NFIELDS (disr_type) == 0)
10094 /* Could be data-less variant, so keep going. */
10095 disr_type = nullptr;
10097 else if (strcmp (TYPE_FIELD_NAME (disr_type, 0),
10098 "RUST$ENUM$DISR") != 0)
10100 /* Not a Rust enum. */
10110 /* If we got here without a discriminant, then it's probably
10112 if (disr_type == nullptr)
10115 /* Smash this type to be a structure type. We have to do this
10116 because the type has already been recorded. */
10117 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10119 /* Make a union to hold the variants. */
10120 struct field *disr_field = &TYPE_FIELD (disr_type, 0);
10121 struct type *union_type = alloc_type (objfile);
10122 TYPE_CODE (union_type) = TYPE_CODE_UNION;
10123 TYPE_NFIELDS (union_type) = 1 + TYPE_NFIELDS (type);
10124 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10125 set_type_align (union_type, TYPE_RAW_ALIGN (type));
10126 TYPE_FIELDS (union_type)
10127 = (struct field *) TYPE_ZALLOC (union_type,
10128 (TYPE_NFIELDS (union_type)
10129 * sizeof (struct field)));
10131 memcpy (TYPE_FIELDS (union_type) + 1, TYPE_FIELDS (type),
10132 TYPE_NFIELDS (type) * sizeof (struct field));
10134 /* Install the discriminant at index 0 in the union. */
10135 TYPE_FIELD (union_type, 0) = *disr_field;
10136 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10137 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10139 /* Install the union in the outer struct type. */
10140 TYPE_FIELD_TYPE (type, 0) = union_type;
10141 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10142 TYPE_NFIELDS (type) = 1;
10144 /* Set the size and offset of the union type. */
10145 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10147 /* We need a way to find the correct discriminant given a
10148 variant name. For convenience we build a map here. */
10149 struct type *enum_type = FIELD_TYPE (*disr_field);
10150 std::unordered_map<std::string, ULONGEST> discriminant_map;
10151 for (int i = 0; i < TYPE_NFIELDS (enum_type); ++i)
10153 if (TYPE_FIELD_LOC_KIND (enum_type, i) == FIELD_LOC_KIND_ENUMVAL)
10156 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type, i));
10157 discriminant_map[name] = TYPE_FIELD_ENUMVAL (enum_type, i);
10161 int n_fields = TYPE_NFIELDS (union_type);
10162 struct discriminant_info *disc
10163 = alloc_discriminant_info (union_type, 0, -1);
10164 /* Skip the discriminant here. */
10165 for (int i = 1; i < n_fields; ++i)
10167 /* Find the final word in the name of this variant's type.
10168 That name can be used to look up the correct
10170 const char *variant_name
10171 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type,
10174 auto iter = discriminant_map.find (variant_name);
10175 if (iter != discriminant_map.end ())
10176 disc->discriminants[i] = iter->second;
10178 /* Remove the discriminant field, if it exists. */
10179 struct type *sub_type = TYPE_FIELD_TYPE (union_type, i);
10180 if (TYPE_NFIELDS (sub_type) > 0)
10182 --TYPE_NFIELDS (sub_type);
10183 ++TYPE_FIELDS (sub_type);
10185 TYPE_FIELD_NAME (union_type, i) = variant_name;
10186 TYPE_NAME (sub_type)
10187 = rust_fully_qualify (&objfile->objfile_obstack,
10188 TYPE_NAME (type), variant_name);
10193 /* Rewrite some Rust unions to be structures with variants parts. */
10196 rust_union_quirks (struct dwarf2_cu *cu)
10198 gdb_assert (cu->language == language_rust);
10199 for (type *type_ : cu->rust_unions)
10200 quirk_rust_enum (type_, cu->per_cu->dwarf2_per_objfile->objfile);
10201 /* We don't need this any more. */
10202 cu->rust_unions.clear ();
10205 /* Return the symtab for PER_CU. This works properly regardless of
10206 whether we're using the index or psymtabs. */
10208 static struct compunit_symtab *
10209 get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
10211 return (per_cu->dwarf2_per_objfile->using_index
10212 ? per_cu->v.quick->compunit_symtab
10213 : per_cu->v.psymtab->compunit_symtab);
10216 /* A helper function for computing the list of all symbol tables
10217 included by PER_CU. */
10220 recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
10221 htab_t all_children, htab_t all_type_symtabs,
10222 struct dwarf2_per_cu_data *per_cu,
10223 struct compunit_symtab *immediate_parent)
10227 struct compunit_symtab *cust;
10228 struct dwarf2_per_cu_data *iter;
10230 slot = htab_find_slot (all_children, per_cu, INSERT);
10233 /* This inclusion and its children have been processed. */
10238 /* Only add a CU if it has a symbol table. */
10239 cust = get_compunit_symtab (per_cu);
10242 /* If this is a type unit only add its symbol table if we haven't
10243 seen it yet (type unit per_cu's can share symtabs). */
10244 if (per_cu->is_debug_types)
10246 slot = htab_find_slot (all_type_symtabs, cust, INSERT);
10250 result->push_back (cust);
10251 if (cust->user == NULL)
10252 cust->user = immediate_parent;
10257 result->push_back (cust);
10258 if (cust->user == NULL)
10259 cust->user = immediate_parent;
10264 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
10267 recursively_compute_inclusions (result, all_children,
10268 all_type_symtabs, iter, cust);
10272 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10276 compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
10278 gdb_assert (! per_cu->is_debug_types);
10280 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
10283 struct dwarf2_per_cu_data *per_cu_iter;
10284 std::vector<compunit_symtab *> result_symtabs;
10285 htab_t all_children, all_type_symtabs;
10286 struct compunit_symtab *cust = get_compunit_symtab (per_cu);
10288 /* If we don't have a symtab, we can just skip this case. */
10292 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10293 NULL, xcalloc, xfree);
10294 all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10295 NULL, xcalloc, xfree);
10298 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
10302 recursively_compute_inclusions (&result_symtabs, all_children,
10303 all_type_symtabs, per_cu_iter,
10307 /* Now we have a transitive closure of all the included symtabs. */
10308 len = result_symtabs.size ();
10310 = XOBNEWVEC (&per_cu->dwarf2_per_objfile->objfile->objfile_obstack,
10311 struct compunit_symtab *, len + 1);
10312 memcpy (cust->includes, result_symtabs.data (),
10313 len * sizeof (compunit_symtab *));
10314 cust->includes[len] = NULL;
10316 htab_delete (all_children);
10317 htab_delete (all_type_symtabs);
10321 /* Compute the 'includes' field for the symtabs of all the CUs we just
10325 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
10327 for (dwarf2_per_cu_data *iter : dwarf2_per_objfile->just_read_cus)
10329 if (! iter->is_debug_types)
10330 compute_compunit_symtab_includes (iter);
10333 dwarf2_per_objfile->just_read_cus.clear ();
10336 /* Generate full symbol information for PER_CU, whose DIEs have
10337 already been loaded into memory. */
10340 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
10341 enum language pretend_language)
10343 struct dwarf2_cu *cu = per_cu->cu;
10344 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10345 struct objfile *objfile = dwarf2_per_objfile->objfile;
10346 struct gdbarch *gdbarch = get_objfile_arch (objfile);
10347 CORE_ADDR lowpc, highpc;
10348 struct compunit_symtab *cust;
10349 CORE_ADDR baseaddr;
10350 struct block *static_block;
10353 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
10355 /* Clear the list here in case something was left over. */
10356 cu->method_list.clear ();
10358 cu->language = pretend_language;
10359 cu->language_defn = language_def (cu->language);
10361 /* Do line number decoding in read_file_scope () */
10362 process_die (cu->dies, cu);
10364 /* For now fudge the Go package. */
10365 if (cu->language == language_go)
10366 fixup_go_packaging (cu);
10368 /* Now that we have processed all the DIEs in the CU, all the types
10369 should be complete, and it should now be safe to compute all of the
10371 compute_delayed_physnames (cu);
10373 if (cu->language == language_rust)
10374 rust_union_quirks (cu);
10376 /* Some compilers don't define a DW_AT_high_pc attribute for the
10377 compilation unit. If the DW_AT_high_pc is missing, synthesize
10378 it, by scanning the DIE's below the compilation unit. */
10379 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
10381 addr = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
10382 static_block = cu->builder->end_symtab_get_static_block (addr, 0, 1);
10384 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10385 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10386 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10387 addrmap to help ensure it has an accurate map of pc values belonging to
10389 dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
10391 cust = cu->builder->end_symtab_from_static_block (static_block,
10392 SECT_OFF_TEXT (objfile),
10397 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
10399 /* Set symtab language to language from DW_AT_language. If the
10400 compilation is from a C file generated by language preprocessors, do
10401 not set the language if it was already deduced by start_subfile. */
10402 if (!(cu->language == language_c
10403 && COMPUNIT_FILETABS (cust)->language != language_unknown))
10404 COMPUNIT_FILETABS (cust)->language = cu->language;
10406 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10407 produce DW_AT_location with location lists but it can be possibly
10408 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10409 there were bugs in prologue debug info, fixed later in GCC-4.5
10410 by "unwind info for epilogues" patch (which is not directly related).
10412 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10413 needed, it would be wrong due to missing DW_AT_producer there.
10415 Still one can confuse GDB by using non-standard GCC compilation
10416 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10418 if (cu->has_loclist && gcc_4_minor >= 5)
10419 cust->locations_valid = 1;
10421 if (gcc_4_minor >= 5)
10422 cust->epilogue_unwind_valid = 1;
10424 cust->call_site_htab = cu->call_site_htab;
10427 if (dwarf2_per_objfile->using_index)
10428 per_cu->v.quick->compunit_symtab = cust;
10431 struct partial_symtab *pst = per_cu->v.psymtab;
10432 pst->compunit_symtab = cust;
10436 /* Push it for inclusion processing later. */
10437 dwarf2_per_objfile->just_read_cus.push_back (per_cu);
10439 /* Not needed any more. */
10440 cu->builder.reset ();
10443 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10444 already been loaded into memory. */
10447 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
10448 enum language pretend_language)
10450 struct dwarf2_cu *cu = per_cu->cu;
10451 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10452 struct objfile *objfile = dwarf2_per_objfile->objfile;
10453 struct compunit_symtab *cust;
10454 struct signatured_type *sig_type;
10456 gdb_assert (per_cu->is_debug_types);
10457 sig_type = (struct signatured_type *) per_cu;
10459 /* Clear the list here in case something was left over. */
10460 cu->method_list.clear ();
10462 cu->language = pretend_language;
10463 cu->language_defn = language_def (cu->language);
10465 /* The symbol tables are set up in read_type_unit_scope. */
10466 process_die (cu->dies, cu);
10468 /* For now fudge the Go package. */
10469 if (cu->language == language_go)
10470 fixup_go_packaging (cu);
10472 /* Now that we have processed all the DIEs in the CU, all the types
10473 should be complete, and it should now be safe to compute all of the
10475 compute_delayed_physnames (cu);
10477 if (cu->language == language_rust)
10478 rust_union_quirks (cu);
10480 /* TUs share symbol tables.
10481 If this is the first TU to use this symtab, complete the construction
10482 of it with end_expandable_symtab. Otherwise, complete the addition of
10483 this TU's symbols to the existing symtab. */
10484 if (sig_type->type_unit_group->compunit_symtab == NULL)
10486 cust = cu->builder->end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
10487 sig_type->type_unit_group->compunit_symtab = cust;
10491 /* Set symtab language to language from DW_AT_language. If the
10492 compilation is from a C file generated by language preprocessors,
10493 do not set the language if it was already deduced by
10495 if (!(cu->language == language_c
10496 && COMPUNIT_FILETABS (cust)->language != language_c))
10497 COMPUNIT_FILETABS (cust)->language = cu->language;
10502 cu->builder->augment_type_symtab ();
10503 cust = sig_type->type_unit_group->compunit_symtab;
10506 if (dwarf2_per_objfile->using_index)
10507 per_cu->v.quick->compunit_symtab = cust;
10510 struct partial_symtab *pst = per_cu->v.psymtab;
10511 pst->compunit_symtab = cust;
10515 /* Not needed any more. */
10516 cu->builder.reset ();
10519 /* Process an imported unit DIE. */
10522 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
10524 struct attribute *attr;
10526 /* For now we don't handle imported units in type units. */
10527 if (cu->per_cu->is_debug_types)
10529 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10530 " supported in type units [in module %s]"),
10531 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
10534 attr = dwarf2_attr (die, DW_AT_import, cu);
10537 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
10538 bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
10539 dwarf2_per_cu_data *per_cu
10540 = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
10541 cu->per_cu->dwarf2_per_objfile);
10543 /* If necessary, add it to the queue and load its DIEs. */
10544 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
10545 load_full_comp_unit (per_cu, false, cu->language);
10547 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
10552 /* RAII object that represents a process_die scope: i.e.,
10553 starts/finishes processing a DIE. */
10554 class process_die_scope
10557 process_die_scope (die_info *die, dwarf2_cu *cu)
10558 : m_die (die), m_cu (cu)
10560 /* We should only be processing DIEs not already in process. */
10561 gdb_assert (!m_die->in_process);
10562 m_die->in_process = true;
10565 ~process_die_scope ()
10567 m_die->in_process = false;
10569 /* If we're done processing the DIE for the CU that owns the line
10570 header, we don't need the line header anymore. */
10571 if (m_cu->line_header_die_owner == m_die)
10573 delete m_cu->line_header;
10574 m_cu->line_header = NULL;
10575 m_cu->line_header_die_owner = NULL;
10584 /* Process a die and its children. */
10587 process_die (struct die_info *die, struct dwarf2_cu *cu)
10589 process_die_scope scope (die, cu);
10593 case DW_TAG_padding:
10595 case DW_TAG_compile_unit:
10596 case DW_TAG_partial_unit:
10597 read_file_scope (die, cu);
10599 case DW_TAG_type_unit:
10600 read_type_unit_scope (die, cu);
10602 case DW_TAG_subprogram:
10603 case DW_TAG_inlined_subroutine:
10604 read_func_scope (die, cu);
10606 case DW_TAG_lexical_block:
10607 case DW_TAG_try_block:
10608 case DW_TAG_catch_block:
10609 read_lexical_block_scope (die, cu);
10611 case DW_TAG_call_site:
10612 case DW_TAG_GNU_call_site:
10613 read_call_site_scope (die, cu);
10615 case DW_TAG_class_type:
10616 case DW_TAG_interface_type:
10617 case DW_TAG_structure_type:
10618 case DW_TAG_union_type:
10619 process_structure_scope (die, cu);
10621 case DW_TAG_enumeration_type:
10622 process_enumeration_scope (die, cu);
10625 /* These dies have a type, but processing them does not create
10626 a symbol or recurse to process the children. Therefore we can
10627 read them on-demand through read_type_die. */
10628 case DW_TAG_subroutine_type:
10629 case DW_TAG_set_type:
10630 case DW_TAG_array_type:
10631 case DW_TAG_pointer_type:
10632 case DW_TAG_ptr_to_member_type:
10633 case DW_TAG_reference_type:
10634 case DW_TAG_rvalue_reference_type:
10635 case DW_TAG_string_type:
10638 case DW_TAG_base_type:
10639 case DW_TAG_subrange_type:
10640 case DW_TAG_typedef:
10641 /* Add a typedef symbol for the type definition, if it has a
10643 new_symbol (die, read_type_die (die, cu), cu);
10645 case DW_TAG_common_block:
10646 read_common_block (die, cu);
10648 case DW_TAG_common_inclusion:
10650 case DW_TAG_namespace:
10651 cu->processing_has_namespace_info = true;
10652 read_namespace (die, cu);
10654 case DW_TAG_module:
10655 cu->processing_has_namespace_info = true;
10656 read_module (die, cu);
10658 case DW_TAG_imported_declaration:
10659 cu->processing_has_namespace_info = true;
10660 if (read_namespace_alias (die, cu))
10662 /* The declaration is not a global namespace alias. */
10663 /* Fall through. */
10664 case DW_TAG_imported_module:
10665 cu->processing_has_namespace_info = true;
10666 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
10667 || cu->language != language_fortran))
10668 complaint (_("Tag '%s' has unexpected children"),
10669 dwarf_tag_name (die->tag));
10670 read_import_statement (die, cu);
10673 case DW_TAG_imported_unit:
10674 process_imported_unit_die (die, cu);
10677 case DW_TAG_variable:
10678 read_variable (die, cu);
10682 new_symbol (die, NULL, cu);
10687 /* DWARF name computation. */
10689 /* A helper function for dwarf2_compute_name which determines whether DIE
10690 needs to have the name of the scope prepended to the name listed in the
10694 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
10696 struct attribute *attr;
10700 case DW_TAG_namespace:
10701 case DW_TAG_typedef:
10702 case DW_TAG_class_type:
10703 case DW_TAG_interface_type:
10704 case DW_TAG_structure_type:
10705 case DW_TAG_union_type:
10706 case DW_TAG_enumeration_type:
10707 case DW_TAG_enumerator:
10708 case DW_TAG_subprogram:
10709 case DW_TAG_inlined_subroutine:
10710 case DW_TAG_member:
10711 case DW_TAG_imported_declaration:
10714 case DW_TAG_variable:
10715 case DW_TAG_constant:
10716 /* We only need to prefix "globally" visible variables. These include
10717 any variable marked with DW_AT_external or any variable that
10718 lives in a namespace. [Variables in anonymous namespaces
10719 require prefixing, but they are not DW_AT_external.] */
10721 if (dwarf2_attr (die, DW_AT_specification, cu))
10723 struct dwarf2_cu *spec_cu = cu;
10725 return die_needs_namespace (die_specification (die, &spec_cu),
10729 attr = dwarf2_attr (die, DW_AT_external, cu);
10730 if (attr == NULL && die->parent->tag != DW_TAG_namespace
10731 && die->parent->tag != DW_TAG_module)
10733 /* A variable in a lexical block of some kind does not need a
10734 namespace, even though in C++ such variables may be external
10735 and have a mangled name. */
10736 if (die->parent->tag == DW_TAG_lexical_block
10737 || die->parent->tag == DW_TAG_try_block
10738 || die->parent->tag == DW_TAG_catch_block
10739 || die->parent->tag == DW_TAG_subprogram)
10748 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10749 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10750 defined for the given DIE. */
10752 static struct attribute *
10753 dw2_linkage_name_attr (struct die_info *die, struct dwarf2_cu *cu)
10755 struct attribute *attr;
10757 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
10759 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
10764 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10765 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10766 defined for the given DIE. */
10768 static const char *
10769 dw2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
10771 const char *linkage_name;
10773 linkage_name = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
10774 if (linkage_name == NULL)
10775 linkage_name = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
10777 return linkage_name;
10780 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10781 compute the physname for the object, which include a method's:
10782 - formal parameters (C++),
10783 - receiver type (Go),
10785 The term "physname" is a bit confusing.
10786 For C++, for example, it is the demangled name.
10787 For Go, for example, it's the mangled name.
10789 For Ada, return the DIE's linkage name rather than the fully qualified
10790 name. PHYSNAME is ignored..
10792 The result is allocated on the objfile_obstack and canonicalized. */
10794 static const char *
10795 dwarf2_compute_name (const char *name,
10796 struct die_info *die, struct dwarf2_cu *cu,
10799 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10802 name = dwarf2_name (die, cu);
10804 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10805 but otherwise compute it by typename_concat inside GDB.
10806 FIXME: Actually this is not really true, or at least not always true.
10807 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
10808 Fortran names because there is no mangling standard. So new_symbol
10809 will set the demangled name to the result of dwarf2_full_name, and it is
10810 the demangled name that GDB uses if it exists. */
10811 if (cu->language == language_ada
10812 || (cu->language == language_fortran && physname))
10814 /* For Ada unit, we prefer the linkage name over the name, as
10815 the former contains the exported name, which the user expects
10816 to be able to reference. Ideally, we want the user to be able
10817 to reference this entity using either natural or linkage name,
10818 but we haven't started looking at this enhancement yet. */
10819 const char *linkage_name = dw2_linkage_name (die, cu);
10821 if (linkage_name != NULL)
10822 return linkage_name;
10825 /* These are the only languages we know how to qualify names in. */
10827 && (cu->language == language_cplus
10828 || cu->language == language_fortran || cu->language == language_d
10829 || cu->language == language_rust))
10831 if (die_needs_namespace (die, cu))
10833 const char *prefix;
10834 const char *canonical_name = NULL;
10838 prefix = determine_prefix (die, cu);
10839 if (*prefix != '\0')
10841 char *prefixed_name = typename_concat (NULL, prefix, name,
10844 buf.puts (prefixed_name);
10845 xfree (prefixed_name);
10850 /* Template parameters may be specified in the DIE's DW_AT_name, or
10851 as children with DW_TAG_template_type_param or
10852 DW_TAG_value_type_param. If the latter, add them to the name
10853 here. If the name already has template parameters, then
10854 skip this step; some versions of GCC emit both, and
10855 it is more efficient to use the pre-computed name.
10857 Something to keep in mind about this process: it is very
10858 unlikely, or in some cases downright impossible, to produce
10859 something that will match the mangled name of a function.
10860 If the definition of the function has the same debug info,
10861 we should be able to match up with it anyway. But fallbacks
10862 using the minimal symbol, for instance to find a method
10863 implemented in a stripped copy of libstdc++, will not work.
10864 If we do not have debug info for the definition, we will have to
10865 match them up some other way.
10867 When we do name matching there is a related problem with function
10868 templates; two instantiated function templates are allowed to
10869 differ only by their return types, which we do not add here. */
10871 if (cu->language == language_cplus && strchr (name, '<') == NULL)
10873 struct attribute *attr;
10874 struct die_info *child;
10877 die->building_fullname = 1;
10879 for (child = die->child; child != NULL; child = child->sibling)
10883 const gdb_byte *bytes;
10884 struct dwarf2_locexpr_baton *baton;
10887 if (child->tag != DW_TAG_template_type_param
10888 && child->tag != DW_TAG_template_value_param)
10899 attr = dwarf2_attr (child, DW_AT_type, cu);
10902 complaint (_("template parameter missing DW_AT_type"));
10903 buf.puts ("UNKNOWN_TYPE");
10906 type = die_type (child, cu);
10908 if (child->tag == DW_TAG_template_type_param)
10910 c_print_type (type, "", &buf, -1, 0, cu->language,
10911 &type_print_raw_options);
10915 attr = dwarf2_attr (child, DW_AT_const_value, cu);
10918 complaint (_("template parameter missing "
10919 "DW_AT_const_value"));
10920 buf.puts ("UNKNOWN_VALUE");
10924 dwarf2_const_value_attr (attr, type, name,
10925 &cu->comp_unit_obstack, cu,
10926 &value, &bytes, &baton);
10928 if (TYPE_NOSIGN (type))
10929 /* GDB prints characters as NUMBER 'CHAR'. If that's
10930 changed, this can use value_print instead. */
10931 c_printchar (value, type, &buf);
10934 struct value_print_options opts;
10937 v = dwarf2_evaluate_loc_desc (type, NULL,
10941 else if (bytes != NULL)
10943 v = allocate_value (type);
10944 memcpy (value_contents_writeable (v), bytes,
10945 TYPE_LENGTH (type));
10948 v = value_from_longest (type, value);
10950 /* Specify decimal so that we do not depend on
10952 get_formatted_print_options (&opts, 'd');
10954 value_print (v, &buf, &opts);
10959 die->building_fullname = 0;
10963 /* Close the argument list, with a space if necessary
10964 (nested templates). */
10965 if (!buf.empty () && buf.string ().back () == '>')
10972 /* For C++ methods, append formal parameter type
10973 information, if PHYSNAME. */
10975 if (physname && die->tag == DW_TAG_subprogram
10976 && cu->language == language_cplus)
10978 struct type *type = read_type_die (die, cu);
10980 c_type_print_args (type, &buf, 1, cu->language,
10981 &type_print_raw_options);
10983 if (cu->language == language_cplus)
10985 /* Assume that an artificial first parameter is
10986 "this", but do not crash if it is not. RealView
10987 marks unnamed (and thus unused) parameters as
10988 artificial; there is no way to differentiate
10990 if (TYPE_NFIELDS (type) > 0
10991 && TYPE_FIELD_ARTIFICIAL (type, 0)
10992 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
10993 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
10995 buf.puts (" const");
10999 const std::string &intermediate_name = buf.string ();
11001 if (cu->language == language_cplus)
11003 = dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
11004 &objfile->per_bfd->storage_obstack);
11006 /* If we only computed INTERMEDIATE_NAME, or if
11007 INTERMEDIATE_NAME is already canonical, then we need to
11008 copy it to the appropriate obstack. */
11009 if (canonical_name == NULL || canonical_name == intermediate_name.c_str ())
11010 name = ((const char *)
11011 obstack_copy0 (&objfile->per_bfd->storage_obstack,
11012 intermediate_name.c_str (),
11013 intermediate_name.length ()));
11015 name = canonical_name;
11022 /* Return the fully qualified name of DIE, based on its DW_AT_name.
11023 If scope qualifiers are appropriate they will be added. The result
11024 will be allocated on the storage_obstack, or NULL if the DIE does
11025 not have a name. NAME may either be from a previous call to
11026 dwarf2_name or NULL.
11028 The output string will be canonicalized (if C++). */
11030 static const char *
11031 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11033 return dwarf2_compute_name (name, die, cu, 0);
11036 /* Construct a physname for the given DIE in CU. NAME may either be
11037 from a previous call to dwarf2_name or NULL. The result will be
11038 allocated on the objfile_objstack or NULL if the DIE does not have a
11041 The output string will be canonicalized (if C++). */
11043 static const char *
11044 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11046 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11047 const char *retval, *mangled = NULL, *canon = NULL;
11050 /* In this case dwarf2_compute_name is just a shortcut not building anything
11052 if (!die_needs_namespace (die, cu))
11053 return dwarf2_compute_name (name, die, cu, 1);
11055 mangled = dw2_linkage_name (die, cu);
11057 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
11058 See https://github.com/rust-lang/rust/issues/32925. */
11059 if (cu->language == language_rust && mangled != NULL
11060 && strchr (mangled, '{') != NULL)
11063 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11065 gdb::unique_xmalloc_ptr<char> demangled;
11066 if (mangled != NULL)
11069 if (language_def (cu->language)->la_store_sym_names_in_linkage_form_p)
11071 /* Do nothing (do not demangle the symbol name). */
11073 else if (cu->language == language_go)
11075 /* This is a lie, but we already lie to the caller new_symbol.
11076 new_symbol assumes we return the mangled name.
11077 This just undoes that lie until things are cleaned up. */
11081 /* Use DMGL_RET_DROP for C++ template functions to suppress
11082 their return type. It is easier for GDB users to search
11083 for such functions as `name(params)' than `long name(params)'.
11084 In such case the minimal symbol names do not match the full
11085 symbol names but for template functions there is never a need
11086 to look up their definition from their declaration so
11087 the only disadvantage remains the minimal symbol variant
11088 `long name(params)' does not have the proper inferior type. */
11089 demangled.reset (gdb_demangle (mangled,
11090 (DMGL_PARAMS | DMGL_ANSI
11091 | DMGL_RET_DROP)));
11094 canon = demangled.get ();
11102 if (canon == NULL || check_physname)
11104 const char *physname = dwarf2_compute_name (name, die, cu, 1);
11106 if (canon != NULL && strcmp (physname, canon) != 0)
11108 /* It may not mean a bug in GDB. The compiler could also
11109 compute DW_AT_linkage_name incorrectly. But in such case
11110 GDB would need to be bug-to-bug compatible. */
11112 complaint (_("Computed physname <%s> does not match demangled <%s> "
11113 "(from linkage <%s>) - DIE at %s [in module %s]"),
11114 physname, canon, mangled, sect_offset_str (die->sect_off),
11115 objfile_name (objfile));
11117 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11118 is available here - over computed PHYSNAME. It is safer
11119 against both buggy GDB and buggy compilers. */
11133 retval = ((const char *)
11134 obstack_copy0 (&objfile->per_bfd->storage_obstack,
11135 retval, strlen (retval)));
11140 /* Inspect DIE in CU for a namespace alias. If one exists, record
11141 a new symbol for it.
11143 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11146 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
11148 struct attribute *attr;
11150 /* If the die does not have a name, this is not a namespace
11152 attr = dwarf2_attr (die, DW_AT_name, cu);
11156 struct die_info *d = die;
11157 struct dwarf2_cu *imported_cu = cu;
11159 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11160 keep inspecting DIEs until we hit the underlying import. */
11161 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11162 for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
11164 attr = dwarf2_attr (d, DW_AT_import, cu);
11168 d = follow_die_ref (d, attr, &imported_cu);
11169 if (d->tag != DW_TAG_imported_declaration)
11173 if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
11175 complaint (_("DIE at %s has too many recursively imported "
11176 "declarations"), sect_offset_str (d->sect_off));
11183 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
11185 type = get_die_type_at_offset (sect_off, cu->per_cu);
11186 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
11188 /* This declaration is a global namespace alias. Add
11189 a symbol for it whose type is the aliased namespace. */
11190 new_symbol (die, type, cu);
11199 /* Return the using directives repository (global or local?) to use in the
11200 current context for CU.
11202 For Ada, imported declarations can materialize renamings, which *may* be
11203 global. However it is impossible (for now?) in DWARF to distinguish
11204 "external" imported declarations and "static" ones. As all imported
11205 declarations seem to be static in all other languages, make them all CU-wide
11206 global only in Ada. */
11208 static struct using_direct **
11209 using_directives (struct dwarf2_cu *cu)
11211 if (cu->language == language_ada && cu->builder->outermost_context_p ())
11212 return cu->builder->get_global_using_directives ();
11214 return cu->builder->get_local_using_directives ();
11217 /* Read the import statement specified by the given die and record it. */
11220 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
11222 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11223 struct attribute *import_attr;
11224 struct die_info *imported_die, *child_die;
11225 struct dwarf2_cu *imported_cu;
11226 const char *imported_name;
11227 const char *imported_name_prefix;
11228 const char *canonical_name;
11229 const char *import_alias;
11230 const char *imported_declaration = NULL;
11231 const char *import_prefix;
11232 std::vector<const char *> excludes;
11234 import_attr = dwarf2_attr (die, DW_AT_import, cu);
11235 if (import_attr == NULL)
11237 complaint (_("Tag '%s' has no DW_AT_import"),
11238 dwarf_tag_name (die->tag));
11243 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
11244 imported_name = dwarf2_name (imported_die, imported_cu);
11245 if (imported_name == NULL)
11247 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11249 The import in the following code:
11263 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11264 <52> DW_AT_decl_file : 1
11265 <53> DW_AT_decl_line : 6
11266 <54> DW_AT_import : <0x75>
11267 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11268 <59> DW_AT_name : B
11269 <5b> DW_AT_decl_file : 1
11270 <5c> DW_AT_decl_line : 2
11271 <5d> DW_AT_type : <0x6e>
11273 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11274 <76> DW_AT_byte_size : 4
11275 <77> DW_AT_encoding : 5 (signed)
11277 imports the wrong die ( 0x75 instead of 0x58 ).
11278 This case will be ignored until the gcc bug is fixed. */
11282 /* Figure out the local name after import. */
11283 import_alias = dwarf2_name (die, cu);
11285 /* Figure out where the statement is being imported to. */
11286 import_prefix = determine_prefix (die, cu);
11288 /* Figure out what the scope of the imported die is and prepend it
11289 to the name of the imported die. */
11290 imported_name_prefix = determine_prefix (imported_die, imported_cu);
11292 if (imported_die->tag != DW_TAG_namespace
11293 && imported_die->tag != DW_TAG_module)
11295 imported_declaration = imported_name;
11296 canonical_name = imported_name_prefix;
11298 else if (strlen (imported_name_prefix) > 0)
11299 canonical_name = obconcat (&objfile->objfile_obstack,
11300 imported_name_prefix,
11301 (cu->language == language_d ? "." : "::"),
11302 imported_name, (char *) NULL);
11304 canonical_name = imported_name;
11306 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
11307 for (child_die = die->child; child_die && child_die->tag;
11308 child_die = sibling_die (child_die))
11310 /* DWARF-4: A Fortran use statement with a “rename list” may be
11311 represented by an imported module entry with an import attribute
11312 referring to the module and owned entries corresponding to those
11313 entities that are renamed as part of being imported. */
11315 if (child_die->tag != DW_TAG_imported_declaration)
11317 complaint (_("child DW_TAG_imported_declaration expected "
11318 "- DIE at %s [in module %s]"),
11319 sect_offset_str (child_die->sect_off),
11320 objfile_name (objfile));
11324 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
11325 if (import_attr == NULL)
11327 complaint (_("Tag '%s' has no DW_AT_import"),
11328 dwarf_tag_name (child_die->tag));
11333 imported_die = follow_die_ref_or_sig (child_die, import_attr,
11335 imported_name = dwarf2_name (imported_die, imported_cu);
11336 if (imported_name == NULL)
11338 complaint (_("child DW_TAG_imported_declaration has unknown "
11339 "imported name - DIE at %s [in module %s]"),
11340 sect_offset_str (child_die->sect_off),
11341 objfile_name (objfile));
11345 excludes.push_back (imported_name);
11347 process_die (child_die, cu);
11350 add_using_directive (using_directives (cu),
11354 imported_declaration,
11357 &objfile->objfile_obstack);
11360 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11361 types, but gives them a size of zero. Starting with version 14,
11362 ICC is compatible with GCC. */
11365 producer_is_icc_lt_14 (struct dwarf2_cu *cu)
11367 if (!cu->checked_producer)
11368 check_producer (cu);
11370 return cu->producer_is_icc_lt_14;
11373 /* ICC generates a DW_AT_type for C void functions. This was observed on
11374 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11375 which says that void functions should not have a DW_AT_type. */
11378 producer_is_icc (struct dwarf2_cu *cu)
11380 if (!cu->checked_producer)
11381 check_producer (cu);
11383 return cu->producer_is_icc;
11386 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11387 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11388 this, it was first present in GCC release 4.3.0. */
11391 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
11393 if (!cu->checked_producer)
11394 check_producer (cu);
11396 return cu->producer_is_gcc_lt_4_3;
11399 static file_and_directory
11400 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu)
11402 file_and_directory res;
11404 /* Find the filename. Do not use dwarf2_name here, since the filename
11405 is not a source language identifier. */
11406 res.name = dwarf2_string_attr (die, DW_AT_name, cu);
11407 res.comp_dir = dwarf2_string_attr (die, DW_AT_comp_dir, cu);
11409 if (res.comp_dir == NULL
11410 && producer_is_gcc_lt_4_3 (cu) && res.name != NULL
11411 && IS_ABSOLUTE_PATH (res.name))
11413 res.comp_dir_storage = ldirname (res.name);
11414 if (!res.comp_dir_storage.empty ())
11415 res.comp_dir = res.comp_dir_storage.c_str ();
11417 if (res.comp_dir != NULL)
11419 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11420 directory, get rid of it. */
11421 const char *cp = strchr (res.comp_dir, ':');
11423 if (cp && cp != res.comp_dir && cp[-1] == '.' && cp[1] == '/')
11424 res.comp_dir = cp + 1;
11427 if (res.name == NULL)
11428 res.name = "<unknown>";
11433 /* Handle DW_AT_stmt_list for a compilation unit.
11434 DIE is the DW_TAG_compile_unit die for CU.
11435 COMP_DIR is the compilation directory. LOWPC is passed to
11436 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11439 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
11440 const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
11442 struct dwarf2_per_objfile *dwarf2_per_objfile
11443 = cu->per_cu->dwarf2_per_objfile;
11444 struct objfile *objfile = dwarf2_per_objfile->objfile;
11445 struct attribute *attr;
11446 struct line_header line_header_local;
11447 hashval_t line_header_local_hash;
11449 int decode_mapping;
11451 gdb_assert (! cu->per_cu->is_debug_types);
11453 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11457 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11459 /* The line header hash table is only created if needed (it exists to
11460 prevent redundant reading of the line table for partial_units).
11461 If we're given a partial_unit, we'll need it. If we're given a
11462 compile_unit, then use the line header hash table if it's already
11463 created, but don't create one just yet. */
11465 if (dwarf2_per_objfile->line_header_hash == NULL
11466 && die->tag == DW_TAG_partial_unit)
11468 dwarf2_per_objfile->line_header_hash
11469 = htab_create_alloc_ex (127, line_header_hash_voidp,
11470 line_header_eq_voidp,
11471 free_line_header_voidp,
11472 &objfile->objfile_obstack,
11473 hashtab_obstack_allocate,
11474 dummy_obstack_deallocate);
11477 line_header_local.sect_off = line_offset;
11478 line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
11479 line_header_local_hash = line_header_hash (&line_header_local);
11480 if (dwarf2_per_objfile->line_header_hash != NULL)
11482 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11483 &line_header_local,
11484 line_header_local_hash, NO_INSERT);
11486 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11487 is not present in *SLOT (since if there is something in *SLOT then
11488 it will be for a partial_unit). */
11489 if (die->tag == DW_TAG_partial_unit && slot != NULL)
11491 gdb_assert (*slot != NULL);
11492 cu->line_header = (struct line_header *) *slot;
11497 /* dwarf_decode_line_header does not yet provide sufficient information.
11498 We always have to call also dwarf_decode_lines for it. */
11499 line_header_up lh = dwarf_decode_line_header (line_offset, cu);
11503 cu->line_header = lh.release ();
11504 cu->line_header_die_owner = die;
11506 if (dwarf2_per_objfile->line_header_hash == NULL)
11510 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11511 &line_header_local,
11512 line_header_local_hash, INSERT);
11513 gdb_assert (slot != NULL);
11515 if (slot != NULL && *slot == NULL)
11517 /* This newly decoded line number information unit will be owned
11518 by line_header_hash hash table. */
11519 *slot = cu->line_header;
11520 cu->line_header_die_owner = NULL;
11524 /* We cannot free any current entry in (*slot) as that struct line_header
11525 may be already used by multiple CUs. Create only temporary decoded
11526 line_header for this CU - it may happen at most once for each line
11527 number information unit. And if we're not using line_header_hash
11528 then this is what we want as well. */
11529 gdb_assert (die->tag != DW_TAG_partial_unit);
11531 decode_mapping = (die->tag != DW_TAG_partial_unit);
11532 dwarf_decode_lines (cu->line_header, comp_dir, cu, NULL, lowpc,
11537 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11540 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
11542 struct dwarf2_per_objfile *dwarf2_per_objfile
11543 = cu->per_cu->dwarf2_per_objfile;
11544 struct objfile *objfile = dwarf2_per_objfile->objfile;
11545 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11546 CORE_ADDR lowpc = ((CORE_ADDR) -1);
11547 CORE_ADDR highpc = ((CORE_ADDR) 0);
11548 struct attribute *attr;
11549 struct die_info *child_die;
11550 CORE_ADDR baseaddr;
11552 prepare_one_comp_unit (cu, die, cu->language);
11553 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11555 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
11557 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11558 from finish_block. */
11559 if (lowpc == ((CORE_ADDR) -1))
11561 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11563 file_and_directory fnd = find_file_and_directory (die, cu);
11565 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11566 standardised yet. As a workaround for the language detection we fall
11567 back to the DW_AT_producer string. */
11568 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
11569 cu->language = language_opencl;
11571 /* Similar hack for Go. */
11572 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
11573 set_cu_language (DW_LANG_Go, cu);
11575 dwarf2_start_symtab (cu, fnd.name, fnd.comp_dir, lowpc);
11577 /* Decode line number information if present. We do this before
11578 processing child DIEs, so that the line header table is available
11579 for DW_AT_decl_file. */
11580 handle_DW_AT_stmt_list (die, cu, fnd.comp_dir, lowpc);
11582 /* Process all dies in compilation unit. */
11583 if (die->child != NULL)
11585 child_die = die->child;
11586 while (child_die && child_die->tag)
11588 process_die (child_die, cu);
11589 child_die = sibling_die (child_die);
11593 /* Decode macro information, if present. Dwarf 2 macro information
11594 refers to information in the line number info statement program
11595 header, so we can only read it if we've read the header
11597 attr = dwarf2_attr (die, DW_AT_macros, cu);
11599 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
11600 if (attr && cu->line_header)
11602 if (dwarf2_attr (die, DW_AT_macro_info, cu))
11603 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11605 dwarf_decode_macros (cu, DW_UNSND (attr), 1);
11609 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
11610 if (attr && cu->line_header)
11612 unsigned int macro_offset = DW_UNSND (attr);
11614 dwarf_decode_macros (cu, macro_offset, 0);
11619 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
11620 Create the set of symtabs used by this TU, or if this TU is sharing
11621 symtabs with another TU and the symtabs have already been created
11622 then restore those symtabs in the line header.
11623 We don't need the pc/line-number mapping for type units. */
11626 setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
11628 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
11629 struct type_unit_group *tu_group;
11631 struct attribute *attr;
11633 struct signatured_type *sig_type;
11635 gdb_assert (per_cu->is_debug_types);
11636 sig_type = (struct signatured_type *) per_cu;
11638 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11640 /* If we're using .gdb_index (includes -readnow) then
11641 per_cu->type_unit_group may not have been set up yet. */
11642 if (sig_type->type_unit_group == NULL)
11643 sig_type->type_unit_group = get_type_unit_group (cu, attr);
11644 tu_group = sig_type->type_unit_group;
11646 /* If we've already processed this stmt_list there's no real need to
11647 do it again, we could fake it and just recreate the part we need
11648 (file name,index -> symtab mapping). If data shows this optimization
11649 is useful we can do it then. */
11650 first_time = tu_group->compunit_symtab == NULL;
11652 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11657 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11658 lh = dwarf_decode_line_header (line_offset, cu);
11663 dwarf2_start_symtab (cu, "", NULL, 0);
11666 gdb_assert (tu_group->symtabs == NULL);
11667 gdb_assert (cu->builder == nullptr);
11668 struct compunit_symtab *cust = tu_group->compunit_symtab;
11669 cu->builder.reset (new struct buildsym_compunit
11670 (COMPUNIT_OBJFILE (cust), "",
11671 COMPUNIT_DIRNAME (cust),
11672 compunit_language (cust),
11678 cu->line_header = lh.release ();
11679 cu->line_header_die_owner = die;
11683 struct compunit_symtab *cust = dwarf2_start_symtab (cu, "", NULL, 0);
11685 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11686 still initializing it, and our caller (a few levels up)
11687 process_full_type_unit still needs to know if this is the first
11690 tu_group->num_symtabs = cu->line_header->file_names.size ();
11691 tu_group->symtabs = XNEWVEC (struct symtab *,
11692 cu->line_header->file_names.size ());
11694 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11696 file_entry &fe = cu->line_header->file_names[i];
11698 dwarf2_start_subfile (cu, fe.name, fe.include_dir (cu->line_header));
11700 if (cu->builder->get_current_subfile ()->symtab == NULL)
11702 /* NOTE: start_subfile will recognize when it's been
11703 passed a file it has already seen. So we can't
11704 assume there's a simple mapping from
11705 cu->line_header->file_names to subfiles, plus
11706 cu->line_header->file_names may contain dups. */
11707 cu->builder->get_current_subfile ()->symtab
11708 = allocate_symtab (cust,
11709 cu->builder->get_current_subfile ()->name);
11712 fe.symtab = cu->builder->get_current_subfile ()->symtab;
11713 tu_group->symtabs[i] = fe.symtab;
11718 gdb_assert (cu->builder == nullptr);
11719 struct compunit_symtab *cust = tu_group->compunit_symtab;
11720 cu->builder.reset (new struct buildsym_compunit
11721 (COMPUNIT_OBJFILE (cust), "",
11722 COMPUNIT_DIRNAME (cust),
11723 compunit_language (cust),
11726 for (i = 0; i < cu->line_header->file_names.size (); ++i)
11728 file_entry &fe = cu->line_header->file_names[i];
11730 fe.symtab = tu_group->symtabs[i];
11734 /* The main symtab is allocated last. Type units don't have DW_AT_name
11735 so they don't have a "real" (so to speak) symtab anyway.
11736 There is later code that will assign the main symtab to all symbols
11737 that don't have one. We need to handle the case of a symbol with a
11738 missing symtab (DW_AT_decl_file) anyway. */
11741 /* Process DW_TAG_type_unit.
11742 For TUs we want to skip the first top level sibling if it's not the
11743 actual type being defined by this TU. In this case the first top
11744 level sibling is there to provide context only. */
11747 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
11749 struct die_info *child_die;
11751 prepare_one_comp_unit (cu, die, language_minimal);
11753 /* Initialize (or reinitialize) the machinery for building symtabs.
11754 We do this before processing child DIEs, so that the line header table
11755 is available for DW_AT_decl_file. */
11756 setup_type_unit_groups (die, cu);
11758 if (die->child != NULL)
11760 child_die = die->child;
11761 while (child_die && child_die->tag)
11763 process_die (child_die, cu);
11764 child_die = sibling_die (child_die);
11771 http://gcc.gnu.org/wiki/DebugFission
11772 http://gcc.gnu.org/wiki/DebugFissionDWP
11774 To simplify handling of both DWO files ("object" files with the DWARF info)
11775 and DWP files (a file with the DWOs packaged up into one file), we treat
11776 DWP files as having a collection of virtual DWO files. */
11779 hash_dwo_file (const void *item)
11781 const struct dwo_file *dwo_file = (const struct dwo_file *) item;
11784 hash = htab_hash_string (dwo_file->dwo_name);
11785 if (dwo_file->comp_dir != NULL)
11786 hash += htab_hash_string (dwo_file->comp_dir);
11791 eq_dwo_file (const void *item_lhs, const void *item_rhs)
11793 const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
11794 const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
11796 if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
11798 if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
11799 return lhs->comp_dir == rhs->comp_dir;
11800 return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
11803 /* Allocate a hash table for DWO files. */
11806 allocate_dwo_file_hash_table (struct objfile *objfile)
11808 return htab_create_alloc_ex (41,
11812 &objfile->objfile_obstack,
11813 hashtab_obstack_allocate,
11814 dummy_obstack_deallocate);
11817 /* Lookup DWO file DWO_NAME. */
11820 lookup_dwo_file_slot (struct dwarf2_per_objfile *dwarf2_per_objfile,
11821 const char *dwo_name,
11822 const char *comp_dir)
11824 struct dwo_file find_entry;
11827 if (dwarf2_per_objfile->dwo_files == NULL)
11828 dwarf2_per_objfile->dwo_files
11829 = allocate_dwo_file_hash_table (dwarf2_per_objfile->objfile);
11831 memset (&find_entry, 0, sizeof (find_entry));
11832 find_entry.dwo_name = dwo_name;
11833 find_entry.comp_dir = comp_dir;
11834 slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
11840 hash_dwo_unit (const void *item)
11842 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
11844 /* This drops the top 32 bits of the id, but is ok for a hash. */
11845 return dwo_unit->signature;
11849 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
11851 const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
11852 const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
11854 /* The signature is assumed to be unique within the DWO file.
11855 So while object file CU dwo_id's always have the value zero,
11856 that's OK, assuming each object file DWO file has only one CU,
11857 and that's the rule for now. */
11858 return lhs->signature == rhs->signature;
11861 /* Allocate a hash table for DWO CUs,TUs.
11862 There is one of these tables for each of CUs,TUs for each DWO file. */
11865 allocate_dwo_unit_table (struct objfile *objfile)
11867 /* Start out with a pretty small number.
11868 Generally DWO files contain only one CU and maybe some TUs. */
11869 return htab_create_alloc_ex (3,
11873 &objfile->objfile_obstack,
11874 hashtab_obstack_allocate,
11875 dummy_obstack_deallocate);
11878 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11880 struct create_dwo_cu_data
11882 struct dwo_file *dwo_file;
11883 struct dwo_unit dwo_unit;
11886 /* die_reader_func for create_dwo_cu. */
11889 create_dwo_cu_reader (const struct die_reader_specs *reader,
11890 const gdb_byte *info_ptr,
11891 struct die_info *comp_unit_die,
11895 struct dwarf2_cu *cu = reader->cu;
11896 sect_offset sect_off = cu->per_cu->sect_off;
11897 struct dwarf2_section_info *section = cu->per_cu->section;
11898 struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
11899 struct dwo_file *dwo_file = data->dwo_file;
11900 struct dwo_unit *dwo_unit = &data->dwo_unit;
11901 struct attribute *attr;
11903 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
11906 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11907 " its dwo_id [in module %s]"),
11908 sect_offset_str (sect_off), dwo_file->dwo_name);
11912 dwo_unit->dwo_file = dwo_file;
11913 dwo_unit->signature = DW_UNSND (attr);
11914 dwo_unit->section = section;
11915 dwo_unit->sect_off = sect_off;
11916 dwo_unit->length = cu->per_cu->length;
11918 if (dwarf_read_debug)
11919 fprintf_unfiltered (gdb_stdlog, " offset %s, dwo_id %s\n",
11920 sect_offset_str (sect_off),
11921 hex_string (dwo_unit->signature));
11924 /* Create the dwo_units for the CUs in a DWO_FILE.
11925 Note: This function processes DWO files only, not DWP files. */
11928 create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
11929 struct dwo_file &dwo_file, dwarf2_section_info §ion,
11932 struct objfile *objfile = dwarf2_per_objfile->objfile;
11933 const gdb_byte *info_ptr, *end_ptr;
11935 dwarf2_read_section (objfile, §ion);
11936 info_ptr = section.buffer;
11938 if (info_ptr == NULL)
11941 if (dwarf_read_debug)
11943 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
11944 get_section_name (§ion),
11945 get_section_file_name (§ion));
11948 end_ptr = info_ptr + section.size;
11949 while (info_ptr < end_ptr)
11951 struct dwarf2_per_cu_data per_cu;
11952 struct create_dwo_cu_data create_dwo_cu_data;
11953 struct dwo_unit *dwo_unit;
11955 sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
11957 memset (&create_dwo_cu_data.dwo_unit, 0,
11958 sizeof (create_dwo_cu_data.dwo_unit));
11959 memset (&per_cu, 0, sizeof (per_cu));
11960 per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
11961 per_cu.is_debug_types = 0;
11962 per_cu.sect_off = sect_offset (info_ptr - section.buffer);
11963 per_cu.section = §ion;
11964 create_dwo_cu_data.dwo_file = &dwo_file;
11966 init_cutu_and_read_dies_no_follow (
11967 &per_cu, &dwo_file, create_dwo_cu_reader, &create_dwo_cu_data);
11968 info_ptr += per_cu.length;
11970 // If the unit could not be parsed, skip it.
11971 if (create_dwo_cu_data.dwo_unit.dwo_file == NULL)
11974 if (cus_htab == NULL)
11975 cus_htab = allocate_dwo_unit_table (objfile);
11977 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
11978 *dwo_unit = create_dwo_cu_data.dwo_unit;
11979 slot = htab_find_slot (cus_htab, dwo_unit, INSERT);
11980 gdb_assert (slot != NULL);
11983 const struct dwo_unit *dup_cu = (const struct dwo_unit *)*slot;
11984 sect_offset dup_sect_off = dup_cu->sect_off;
11986 complaint (_("debug cu entry at offset %s is duplicate to"
11987 " the entry at offset %s, signature %s"),
11988 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
11989 hex_string (dwo_unit->signature));
11991 *slot = (void *)dwo_unit;
11995 /* DWP file .debug_{cu,tu}_index section format:
11996 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
12000 Both index sections have the same format, and serve to map a 64-bit
12001 signature to a set of section numbers. Each section begins with a header,
12002 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
12003 indexes, and a pool of 32-bit section numbers. The index sections will be
12004 aligned at 8-byte boundaries in the file.
12006 The index section header consists of:
12008 V, 32 bit version number
12010 N, 32 bit number of compilation units or type units in the index
12011 M, 32 bit number of slots in the hash table
12013 Numbers are recorded using the byte order of the application binary.
12015 The hash table begins at offset 16 in the section, and consists of an array
12016 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
12017 order of the application binary). Unused slots in the hash table are 0.
12018 (We rely on the extreme unlikeliness of a signature being exactly 0.)
12020 The parallel table begins immediately after the hash table
12021 (at offset 16 + 8 * M from the beginning of the section), and consists of an
12022 array of 32-bit indexes (using the byte order of the application binary),
12023 corresponding 1-1 with slots in the hash table. Each entry in the parallel
12024 table contains a 32-bit index into the pool of section numbers. For unused
12025 hash table slots, the corresponding entry in the parallel table will be 0.
12027 The pool of section numbers begins immediately following the hash table
12028 (at offset 16 + 12 * M from the beginning of the section). The pool of
12029 section numbers consists of an array of 32-bit words (using the byte order
12030 of the application binary). Each item in the array is indexed starting
12031 from 0. The hash table entry provides the index of the first section
12032 number in the set. Additional section numbers in the set follow, and the
12033 set is terminated by a 0 entry (section number 0 is not used in ELF).
12035 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12036 section must be the first entry in the set, and the .debug_abbrev.dwo must
12037 be the second entry. Other members of the set may follow in any order.
12043 DWP Version 2 combines all the .debug_info, etc. sections into one,
12044 and the entries in the index tables are now offsets into these sections.
12045 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
12048 Index Section Contents:
12050 Hash Table of Signatures dwp_hash_table.hash_table
12051 Parallel Table of Indices dwp_hash_table.unit_table
12052 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
12053 Table of Section Sizes dwp_hash_table.v2.sizes
12055 The index section header consists of:
12057 V, 32 bit version number
12058 L, 32 bit number of columns in the table of section offsets
12059 N, 32 bit number of compilation units or type units in the index
12060 M, 32 bit number of slots in the hash table
12062 Numbers are recorded using the byte order of the application binary.
12064 The hash table has the same format as version 1.
12065 The parallel table of indices has the same format as version 1,
12066 except that the entries are origin-1 indices into the table of sections
12067 offsets and the table of section sizes.
12069 The table of offsets begins immediately following the parallel table
12070 (at offset 16 + 12 * M from the beginning of the section). The table is
12071 a two-dimensional array of 32-bit words (using the byte order of the
12072 application binary), with L columns and N+1 rows, in row-major order.
12073 Each row in the array is indexed starting from 0. The first row provides
12074 a key to the remaining rows: each column in this row provides an identifier
12075 for a debug section, and the offsets in the same column of subsequent rows
12076 refer to that section. The section identifiers are:
12078 DW_SECT_INFO 1 .debug_info.dwo
12079 DW_SECT_TYPES 2 .debug_types.dwo
12080 DW_SECT_ABBREV 3 .debug_abbrev.dwo
12081 DW_SECT_LINE 4 .debug_line.dwo
12082 DW_SECT_LOC 5 .debug_loc.dwo
12083 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
12084 DW_SECT_MACINFO 7 .debug_macinfo.dwo
12085 DW_SECT_MACRO 8 .debug_macro.dwo
12087 The offsets provided by the CU and TU index sections are the base offsets
12088 for the contributions made by each CU or TU to the corresponding section
12089 in the package file. Each CU and TU header contains an abbrev_offset
12090 field, used to find the abbreviations table for that CU or TU within the
12091 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12092 be interpreted as relative to the base offset given in the index section.
12093 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12094 should be interpreted as relative to the base offset for .debug_line.dwo,
12095 and offsets into other debug sections obtained from DWARF attributes should
12096 also be interpreted as relative to the corresponding base offset.
12098 The table of sizes begins immediately following the table of offsets.
12099 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12100 with L columns and N rows, in row-major order. Each row in the array is
12101 indexed starting from 1 (row 0 is shared by the two tables).
12105 Hash table lookup is handled the same in version 1 and 2:
12107 We assume that N and M will not exceed 2^32 - 1.
12108 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12110 Given a 64-bit compilation unit signature or a type signature S, an entry
12111 in the hash table is located as follows:
12113 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12114 the low-order k bits all set to 1.
12116 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12118 3) If the hash table entry at index H matches the signature, use that
12119 entry. If the hash table entry at index H is unused (all zeroes),
12120 terminate the search: the signature is not present in the table.
12122 4) Let H = (H + H') modulo M. Repeat at Step 3.
12124 Because M > N and H' and M are relatively prime, the search is guaranteed
12125 to stop at an unused slot or find the match. */
12127 /* Create a hash table to map DWO IDs to their CU/TU entry in
12128 .debug_{info,types}.dwo in DWP_FILE.
12129 Returns NULL if there isn't one.
12130 Note: This function processes DWP files only, not DWO files. */
12132 static struct dwp_hash_table *
12133 create_dwp_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
12134 struct dwp_file *dwp_file, int is_debug_types)
12136 struct objfile *objfile = dwarf2_per_objfile->objfile;
12137 bfd *dbfd = dwp_file->dbfd.get ();
12138 const gdb_byte *index_ptr, *index_end;
12139 struct dwarf2_section_info *index;
12140 uint32_t version, nr_columns, nr_units, nr_slots;
12141 struct dwp_hash_table *htab;
12143 if (is_debug_types)
12144 index = &dwp_file->sections.tu_index;
12146 index = &dwp_file->sections.cu_index;
12148 if (dwarf2_section_empty_p (index))
12150 dwarf2_read_section (objfile, index);
12152 index_ptr = index->buffer;
12153 index_end = index_ptr + index->size;
12155 version = read_4_bytes (dbfd, index_ptr);
12158 nr_columns = read_4_bytes (dbfd, index_ptr);
12162 nr_units = read_4_bytes (dbfd, index_ptr);
12164 nr_slots = read_4_bytes (dbfd, index_ptr);
12167 if (version != 1 && version != 2)
12169 error (_("Dwarf Error: unsupported DWP file version (%s)"
12170 " [in module %s]"),
12171 pulongest (version), dwp_file->name);
12173 if (nr_slots != (nr_slots & -nr_slots))
12175 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12176 " is not power of 2 [in module %s]"),
12177 pulongest (nr_slots), dwp_file->name);
12180 htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
12181 htab->version = version;
12182 htab->nr_columns = nr_columns;
12183 htab->nr_units = nr_units;
12184 htab->nr_slots = nr_slots;
12185 htab->hash_table = index_ptr;
12186 htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
12188 /* Exit early if the table is empty. */
12189 if (nr_slots == 0 || nr_units == 0
12190 || (version == 2 && nr_columns == 0))
12192 /* All must be zero. */
12193 if (nr_slots != 0 || nr_units != 0
12194 || (version == 2 && nr_columns != 0))
12196 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12197 " all zero [in modules %s]"),
12205 htab->section_pool.v1.indices =
12206 htab->unit_table + sizeof (uint32_t) * nr_slots;
12207 /* It's harder to decide whether the section is too small in v1.
12208 V1 is deprecated anyway so we punt. */
12212 const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
12213 int *ids = htab->section_pool.v2.section_ids;
12214 size_t sizeof_ids = sizeof (htab->section_pool.v2.section_ids);
12215 /* Reverse map for error checking. */
12216 int ids_seen[DW_SECT_MAX + 1];
12219 if (nr_columns < 2)
12221 error (_("Dwarf Error: bad DWP hash table, too few columns"
12222 " in section table [in module %s]"),
12225 if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
12227 error (_("Dwarf Error: bad DWP hash table, too many columns"
12228 " in section table [in module %s]"),
12231 memset (ids, 255, sizeof_ids);
12232 memset (ids_seen, 255, sizeof (ids_seen));
12233 for (i = 0; i < nr_columns; ++i)
12235 int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
12237 if (id < DW_SECT_MIN || id > DW_SECT_MAX)
12239 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12240 " in section table [in module %s]"),
12241 id, dwp_file->name);
12243 if (ids_seen[id] != -1)
12245 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12246 " id %d in section table [in module %s]"),
12247 id, dwp_file->name);
12252 /* Must have exactly one info or types section. */
12253 if (((ids_seen[DW_SECT_INFO] != -1)
12254 + (ids_seen[DW_SECT_TYPES] != -1))
12257 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12258 " DWO info/types section [in module %s]"),
12261 /* Must have an abbrev section. */
12262 if (ids_seen[DW_SECT_ABBREV] == -1)
12264 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12265 " section [in module %s]"),
12268 htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
12269 htab->section_pool.v2.sizes =
12270 htab->section_pool.v2.offsets + (sizeof (uint32_t)
12271 * nr_units * nr_columns);
12272 if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
12273 * nr_units * nr_columns))
12276 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12277 " [in module %s]"),
12285 /* Update SECTIONS with the data from SECTP.
12287 This function is like the other "locate" section routines that are
12288 passed to bfd_map_over_sections, but in this context the sections to
12289 read comes from the DWP V1 hash table, not the full ELF section table.
12291 The result is non-zero for success, or zero if an error was found. */
12294 locate_v1_virtual_dwo_sections (asection *sectp,
12295 struct virtual_v1_dwo_sections *sections)
12297 const struct dwop_section_names *names = &dwop_section_names;
12299 if (section_is_p (sectp->name, &names->abbrev_dwo))
12301 /* There can be only one. */
12302 if (sections->abbrev.s.section != NULL)
12304 sections->abbrev.s.section = sectp;
12305 sections->abbrev.size = bfd_get_section_size (sectp);
12307 else if (section_is_p (sectp->name, &names->info_dwo)
12308 || section_is_p (sectp->name, &names->types_dwo))
12310 /* There can be only one. */
12311 if (sections->info_or_types.s.section != NULL)
12313 sections->info_or_types.s.section = sectp;
12314 sections->info_or_types.size = bfd_get_section_size (sectp);
12316 else if (section_is_p (sectp->name, &names->line_dwo))
12318 /* There can be only one. */
12319 if (sections->line.s.section != NULL)
12321 sections->line.s.section = sectp;
12322 sections->line.size = bfd_get_section_size (sectp);
12324 else if (section_is_p (sectp->name, &names->loc_dwo))
12326 /* There can be only one. */
12327 if (sections->loc.s.section != NULL)
12329 sections->loc.s.section = sectp;
12330 sections->loc.size = bfd_get_section_size (sectp);
12332 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12334 /* There can be only one. */
12335 if (sections->macinfo.s.section != NULL)
12337 sections->macinfo.s.section = sectp;
12338 sections->macinfo.size = bfd_get_section_size (sectp);
12340 else if (section_is_p (sectp->name, &names->macro_dwo))
12342 /* There can be only one. */
12343 if (sections->macro.s.section != NULL)
12345 sections->macro.s.section = sectp;
12346 sections->macro.size = bfd_get_section_size (sectp);
12348 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12350 /* There can be only one. */
12351 if (sections->str_offsets.s.section != NULL)
12353 sections->str_offsets.s.section = sectp;
12354 sections->str_offsets.size = bfd_get_section_size (sectp);
12358 /* No other kind of section is valid. */
12365 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12366 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12367 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12368 This is for DWP version 1 files. */
12370 static struct dwo_unit *
12371 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12372 struct dwp_file *dwp_file,
12373 uint32_t unit_index,
12374 const char *comp_dir,
12375 ULONGEST signature, int is_debug_types)
12377 struct objfile *objfile = dwarf2_per_objfile->objfile;
12378 const struct dwp_hash_table *dwp_htab =
12379 is_debug_types ? dwp_file->tus : dwp_file->cus;
12380 bfd *dbfd = dwp_file->dbfd.get ();
12381 const char *kind = is_debug_types ? "TU" : "CU";
12382 struct dwo_file *dwo_file;
12383 struct dwo_unit *dwo_unit;
12384 struct virtual_v1_dwo_sections sections;
12385 void **dwo_file_slot;
12388 gdb_assert (dwp_file->version == 1);
12390 if (dwarf_read_debug)
12392 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
12394 pulongest (unit_index), hex_string (signature),
12398 /* Fetch the sections of this DWO unit.
12399 Put a limit on the number of sections we look for so that bad data
12400 doesn't cause us to loop forever. */
12402 #define MAX_NR_V1_DWO_SECTIONS \
12403 (1 /* .debug_info or .debug_types */ \
12404 + 1 /* .debug_abbrev */ \
12405 + 1 /* .debug_line */ \
12406 + 1 /* .debug_loc */ \
12407 + 1 /* .debug_str_offsets */ \
12408 + 1 /* .debug_macro or .debug_macinfo */ \
12409 + 1 /* trailing zero */)
12411 memset (§ions, 0, sizeof (sections));
12413 for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
12416 uint32_t section_nr =
12417 read_4_bytes (dbfd,
12418 dwp_htab->section_pool.v1.indices
12419 + (unit_index + i) * sizeof (uint32_t));
12421 if (section_nr == 0)
12423 if (section_nr >= dwp_file->num_sections)
12425 error (_("Dwarf Error: bad DWP hash table, section number too large"
12426 " [in module %s]"),
12430 sectp = dwp_file->elf_sections[section_nr];
12431 if (! locate_v1_virtual_dwo_sections (sectp, §ions))
12433 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12434 " [in module %s]"),
12440 || dwarf2_section_empty_p (§ions.info_or_types)
12441 || dwarf2_section_empty_p (§ions.abbrev))
12443 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12444 " [in module %s]"),
12447 if (i == MAX_NR_V1_DWO_SECTIONS)
12449 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12450 " [in module %s]"),
12454 /* It's easier for the rest of the code if we fake a struct dwo_file and
12455 have dwo_unit "live" in that. At least for now.
12457 The DWP file can be made up of a random collection of CUs and TUs.
12458 However, for each CU + set of TUs that came from the same original DWO
12459 file, we can combine them back into a virtual DWO file to save space
12460 (fewer struct dwo_file objects to allocate). Remember that for really
12461 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12463 std::string virtual_dwo_name =
12464 string_printf ("virtual-dwo/%d-%d-%d-%d",
12465 get_section_id (§ions.abbrev),
12466 get_section_id (§ions.line),
12467 get_section_id (§ions.loc),
12468 get_section_id (§ions.str_offsets));
12469 /* Can we use an existing virtual DWO file? */
12470 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12471 virtual_dwo_name.c_str (),
12473 /* Create one if necessary. */
12474 if (*dwo_file_slot == NULL)
12476 if (dwarf_read_debug)
12478 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12479 virtual_dwo_name.c_str ());
12481 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12483 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12484 virtual_dwo_name.c_str (),
12485 virtual_dwo_name.size ());
12486 dwo_file->comp_dir = comp_dir;
12487 dwo_file->sections.abbrev = sections.abbrev;
12488 dwo_file->sections.line = sections.line;
12489 dwo_file->sections.loc = sections.loc;
12490 dwo_file->sections.macinfo = sections.macinfo;
12491 dwo_file->sections.macro = sections.macro;
12492 dwo_file->sections.str_offsets = sections.str_offsets;
12493 /* The "str" section is global to the entire DWP file. */
12494 dwo_file->sections.str = dwp_file->sections.str;
12495 /* The info or types section is assigned below to dwo_unit,
12496 there's no need to record it in dwo_file.
12497 Also, we can't simply record type sections in dwo_file because
12498 we record a pointer into the vector in dwo_unit. As we collect more
12499 types we'll grow the vector and eventually have to reallocate space
12500 for it, invalidating all copies of pointers into the previous
12502 *dwo_file_slot = dwo_file;
12506 if (dwarf_read_debug)
12508 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12509 virtual_dwo_name.c_str ());
12511 dwo_file = (struct dwo_file *) *dwo_file_slot;
12514 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12515 dwo_unit->dwo_file = dwo_file;
12516 dwo_unit->signature = signature;
12517 dwo_unit->section =
12518 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12519 *dwo_unit->section = sections.info_or_types;
12520 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12525 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12526 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12527 piece within that section used by a TU/CU, return a virtual section
12528 of just that piece. */
12530 static struct dwarf2_section_info
12531 create_dwp_v2_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
12532 struct dwarf2_section_info *section,
12533 bfd_size_type offset, bfd_size_type size)
12535 struct dwarf2_section_info result;
12538 gdb_assert (section != NULL);
12539 gdb_assert (!section->is_virtual);
12541 memset (&result, 0, sizeof (result));
12542 result.s.containing_section = section;
12543 result.is_virtual = 1;
12548 sectp = get_section_bfd_section (section);
12550 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12551 bounds of the real section. This is a pretty-rare event, so just
12552 flag an error (easier) instead of a warning and trying to cope. */
12554 || offset + size > bfd_get_section_size (sectp))
12556 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12557 " in section %s [in module %s]"),
12558 sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
12559 objfile_name (dwarf2_per_objfile->objfile));
12562 result.virtual_offset = offset;
12563 result.size = size;
12567 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12568 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12569 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12570 This is for DWP version 2 files. */
12572 static struct dwo_unit *
12573 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12574 struct dwp_file *dwp_file,
12575 uint32_t unit_index,
12576 const char *comp_dir,
12577 ULONGEST signature, int is_debug_types)
12579 struct objfile *objfile = dwarf2_per_objfile->objfile;
12580 const struct dwp_hash_table *dwp_htab =
12581 is_debug_types ? dwp_file->tus : dwp_file->cus;
12582 bfd *dbfd = dwp_file->dbfd.get ();
12583 const char *kind = is_debug_types ? "TU" : "CU";
12584 struct dwo_file *dwo_file;
12585 struct dwo_unit *dwo_unit;
12586 struct virtual_v2_dwo_sections sections;
12587 void **dwo_file_slot;
12590 gdb_assert (dwp_file->version == 2);
12592 if (dwarf_read_debug)
12594 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
12596 pulongest (unit_index), hex_string (signature),
12600 /* Fetch the section offsets of this DWO unit. */
12602 memset (§ions, 0, sizeof (sections));
12604 for (i = 0; i < dwp_htab->nr_columns; ++i)
12606 uint32_t offset = read_4_bytes (dbfd,
12607 dwp_htab->section_pool.v2.offsets
12608 + (((unit_index - 1) * dwp_htab->nr_columns
12610 * sizeof (uint32_t)));
12611 uint32_t size = read_4_bytes (dbfd,
12612 dwp_htab->section_pool.v2.sizes
12613 + (((unit_index - 1) * dwp_htab->nr_columns
12615 * sizeof (uint32_t)));
12617 switch (dwp_htab->section_pool.v2.section_ids[i])
12620 case DW_SECT_TYPES:
12621 sections.info_or_types_offset = offset;
12622 sections.info_or_types_size = size;
12624 case DW_SECT_ABBREV:
12625 sections.abbrev_offset = offset;
12626 sections.abbrev_size = size;
12629 sections.line_offset = offset;
12630 sections.line_size = size;
12633 sections.loc_offset = offset;
12634 sections.loc_size = size;
12636 case DW_SECT_STR_OFFSETS:
12637 sections.str_offsets_offset = offset;
12638 sections.str_offsets_size = size;
12640 case DW_SECT_MACINFO:
12641 sections.macinfo_offset = offset;
12642 sections.macinfo_size = size;
12644 case DW_SECT_MACRO:
12645 sections.macro_offset = offset;
12646 sections.macro_size = size;
12651 /* It's easier for the rest of the code if we fake a struct dwo_file and
12652 have dwo_unit "live" in that. At least for now.
12654 The DWP file can be made up of a random collection of CUs and TUs.
12655 However, for each CU + set of TUs that came from the same original DWO
12656 file, we can combine them back into a virtual DWO file to save space
12657 (fewer struct dwo_file objects to allocate). Remember that for really
12658 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12660 std::string virtual_dwo_name =
12661 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12662 (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
12663 (long) (sections.line_size ? sections.line_offset : 0),
12664 (long) (sections.loc_size ? sections.loc_offset : 0),
12665 (long) (sections.str_offsets_size
12666 ? sections.str_offsets_offset : 0));
12667 /* Can we use an existing virtual DWO file? */
12668 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12669 virtual_dwo_name.c_str (),
12671 /* Create one if necessary. */
12672 if (*dwo_file_slot == NULL)
12674 if (dwarf_read_debug)
12676 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12677 virtual_dwo_name.c_str ());
12679 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12681 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12682 virtual_dwo_name.c_str (),
12683 virtual_dwo_name.size ());
12684 dwo_file->comp_dir = comp_dir;
12685 dwo_file->sections.abbrev =
12686 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,
12687 sections.abbrev_offset, sections.abbrev_size);
12688 dwo_file->sections.line =
12689 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.line,
12690 sections.line_offset, sections.line_size);
12691 dwo_file->sections.loc =
12692 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.loc,
12693 sections.loc_offset, sections.loc_size);
12694 dwo_file->sections.macinfo =
12695 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macinfo,
12696 sections.macinfo_offset, sections.macinfo_size);
12697 dwo_file->sections.macro =
12698 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macro,
12699 sections.macro_offset, sections.macro_size);
12700 dwo_file->sections.str_offsets =
12701 create_dwp_v2_section (dwarf2_per_objfile,
12702 &dwp_file->sections.str_offsets,
12703 sections.str_offsets_offset,
12704 sections.str_offsets_size);
12705 /* The "str" section is global to the entire DWP file. */
12706 dwo_file->sections.str = dwp_file->sections.str;
12707 /* The info or types section is assigned below to dwo_unit,
12708 there's no need to record it in dwo_file.
12709 Also, we can't simply record type sections in dwo_file because
12710 we record a pointer into the vector in dwo_unit. As we collect more
12711 types we'll grow the vector and eventually have to reallocate space
12712 for it, invalidating all copies of pointers into the previous
12714 *dwo_file_slot = dwo_file;
12718 if (dwarf_read_debug)
12720 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12721 virtual_dwo_name.c_str ());
12723 dwo_file = (struct dwo_file *) *dwo_file_slot;
12726 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12727 dwo_unit->dwo_file = dwo_file;
12728 dwo_unit->signature = signature;
12729 dwo_unit->section =
12730 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12731 *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
12733 ? &dwp_file->sections.types
12734 : &dwp_file->sections.info,
12735 sections.info_or_types_offset,
12736 sections.info_or_types_size);
12737 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12742 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12743 Returns NULL if the signature isn't found. */
12745 static struct dwo_unit *
12746 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile *dwarf2_per_objfile,
12747 struct dwp_file *dwp_file, const char *comp_dir,
12748 ULONGEST signature, int is_debug_types)
12750 const struct dwp_hash_table *dwp_htab =
12751 is_debug_types ? dwp_file->tus : dwp_file->cus;
12752 bfd *dbfd = dwp_file->dbfd.get ();
12753 uint32_t mask = dwp_htab->nr_slots - 1;
12754 uint32_t hash = signature & mask;
12755 uint32_t hash2 = ((signature >> 32) & mask) | 1;
12758 struct dwo_unit find_dwo_cu;
12760 memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
12761 find_dwo_cu.signature = signature;
12762 slot = htab_find_slot (is_debug_types
12763 ? dwp_file->loaded_tus
12764 : dwp_file->loaded_cus,
12765 &find_dwo_cu, INSERT);
12768 return (struct dwo_unit *) *slot;
12770 /* Use a for loop so that we don't loop forever on bad debug info. */
12771 for (i = 0; i < dwp_htab->nr_slots; ++i)
12773 ULONGEST signature_in_table;
12775 signature_in_table =
12776 read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
12777 if (signature_in_table == signature)
12779 uint32_t unit_index =
12780 read_4_bytes (dbfd,
12781 dwp_htab->unit_table + hash * sizeof (uint32_t));
12783 if (dwp_file->version == 1)
12785 *slot = create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile,
12786 dwp_file, unit_index,
12787 comp_dir, signature,
12792 *slot = create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile,
12793 dwp_file, unit_index,
12794 comp_dir, signature,
12797 return (struct dwo_unit *) *slot;
12799 if (signature_in_table == 0)
12801 hash = (hash + hash2) & mask;
12804 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12805 " [in module %s]"),
12809 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12810 Open the file specified by FILE_NAME and hand it off to BFD for
12811 preliminary analysis. Return a newly initialized bfd *, which
12812 includes a canonicalized copy of FILE_NAME.
12813 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12814 SEARCH_CWD is true if the current directory is to be searched.
12815 It will be searched before debug-file-directory.
12816 If successful, the file is added to the bfd include table of the
12817 objfile's bfd (see gdb_bfd_record_inclusion).
12818 If unable to find/open the file, return NULL.
12819 NOTE: This function is derived from symfile_bfd_open. */
12821 static gdb_bfd_ref_ptr
12822 try_open_dwop_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12823 const char *file_name, int is_dwp, int search_cwd)
12826 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12827 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12828 to debug_file_directory. */
12829 const char *search_path;
12830 static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
12832 gdb::unique_xmalloc_ptr<char> search_path_holder;
12835 if (*debug_file_directory != '\0')
12837 search_path_holder.reset (concat (".", dirname_separator_string,
12838 debug_file_directory,
12840 search_path = search_path_holder.get ();
12846 search_path = debug_file_directory;
12848 openp_flags flags = OPF_RETURN_REALPATH;
12850 flags |= OPF_SEARCH_IN_PATH;
12852 gdb::unique_xmalloc_ptr<char> absolute_name;
12853 desc = openp (search_path, flags, file_name,
12854 O_RDONLY | O_BINARY, &absolute_name);
12858 gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (absolute_name.get (),
12860 if (sym_bfd == NULL)
12862 bfd_set_cacheable (sym_bfd.get (), 1);
12864 if (!bfd_check_format (sym_bfd.get (), bfd_object))
12867 /* Success. Record the bfd as having been included by the objfile's bfd.
12868 This is important because things like demangled_names_hash lives in the
12869 objfile's per_bfd space and may have references to things like symbol
12870 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12871 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd.get ());
12876 /* Try to open DWO file FILE_NAME.
12877 COMP_DIR is the DW_AT_comp_dir attribute.
12878 The result is the bfd handle of the file.
12879 If there is a problem finding or opening the file, return NULL.
12880 Upon success, the canonicalized path of the file is stored in the bfd,
12881 same as symfile_bfd_open. */
12883 static gdb_bfd_ref_ptr
12884 open_dwo_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12885 const char *file_name, const char *comp_dir)
12887 if (IS_ABSOLUTE_PATH (file_name))
12888 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12889 0 /*is_dwp*/, 0 /*search_cwd*/);
12891 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12893 if (comp_dir != NULL)
12895 char *path_to_try = concat (comp_dir, SLASH_STRING,
12896 file_name, (char *) NULL);
12898 /* NOTE: If comp_dir is a relative path, this will also try the
12899 search path, which seems useful. */
12900 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile,
12903 1 /*search_cwd*/));
12904 xfree (path_to_try);
12909 /* That didn't work, try debug-file-directory, which, despite its name,
12910 is a list of paths. */
12912 if (*debug_file_directory == '\0')
12915 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12916 0 /*is_dwp*/, 1 /*search_cwd*/);
12919 /* This function is mapped across the sections and remembers the offset and
12920 size of each of the DWO debugging sections we are interested in. */
12923 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
12925 struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
12926 const struct dwop_section_names *names = &dwop_section_names;
12928 if (section_is_p (sectp->name, &names->abbrev_dwo))
12930 dwo_sections->abbrev.s.section = sectp;
12931 dwo_sections->abbrev.size = bfd_get_section_size (sectp);
12933 else if (section_is_p (sectp->name, &names->info_dwo))
12935 dwo_sections->info.s.section = sectp;
12936 dwo_sections->info.size = bfd_get_section_size (sectp);
12938 else if (section_is_p (sectp->name, &names->line_dwo))
12940 dwo_sections->line.s.section = sectp;
12941 dwo_sections->line.size = bfd_get_section_size (sectp);
12943 else if (section_is_p (sectp->name, &names->loc_dwo))
12945 dwo_sections->loc.s.section = sectp;
12946 dwo_sections->loc.size = bfd_get_section_size (sectp);
12948 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12950 dwo_sections->macinfo.s.section = sectp;
12951 dwo_sections->macinfo.size = bfd_get_section_size (sectp);
12953 else if (section_is_p (sectp->name, &names->macro_dwo))
12955 dwo_sections->macro.s.section = sectp;
12956 dwo_sections->macro.size = bfd_get_section_size (sectp);
12958 else if (section_is_p (sectp->name, &names->str_dwo))
12960 dwo_sections->str.s.section = sectp;
12961 dwo_sections->str.size = bfd_get_section_size (sectp);
12963 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12965 dwo_sections->str_offsets.s.section = sectp;
12966 dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
12968 else if (section_is_p (sectp->name, &names->types_dwo))
12970 struct dwarf2_section_info type_section;
12972 memset (&type_section, 0, sizeof (type_section));
12973 type_section.s.section = sectp;
12974 type_section.size = bfd_get_section_size (sectp);
12975 VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
12980 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12981 by PER_CU. This is for the non-DWP case.
12982 The result is NULL if DWO_NAME can't be found. */
12984 static struct dwo_file *
12985 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
12986 const char *dwo_name, const char *comp_dir)
12988 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
12989 struct objfile *objfile = dwarf2_per_objfile->objfile;
12991 gdb_bfd_ref_ptr dbfd (open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir));
12994 if (dwarf_read_debug)
12995 fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
12999 /* We use a unique pointer here, despite the obstack allocation,
13000 because a dwo_file needs some cleanup if it is abandoned. */
13001 dwo_file_up dwo_file (OBSTACK_ZALLOC (&objfile->objfile_obstack,
13003 dwo_file->dwo_name = dwo_name;
13004 dwo_file->comp_dir = comp_dir;
13005 dwo_file->dbfd = dbfd.release ();
13007 bfd_map_over_sections (dwo_file->dbfd, dwarf2_locate_dwo_sections,
13008 &dwo_file->sections);
13010 create_cus_hash_table (dwarf2_per_objfile, *dwo_file, dwo_file->sections.info,
13013 create_debug_types_hash_table (dwarf2_per_objfile, dwo_file.get (),
13014 dwo_file->sections.types, dwo_file->tus);
13016 if (dwarf_read_debug)
13017 fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
13019 return dwo_file.release ();
13022 /* This function is mapped across the sections and remembers the offset and
13023 size of each of the DWP debugging sections common to version 1 and 2 that
13024 we are interested in. */
13027 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
13028 void *dwp_file_ptr)
13030 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13031 const struct dwop_section_names *names = &dwop_section_names;
13032 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13034 /* Record the ELF section number for later lookup: this is what the
13035 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13036 gdb_assert (elf_section_nr < dwp_file->num_sections);
13037 dwp_file->elf_sections[elf_section_nr] = sectp;
13039 /* Look for specific sections that we need. */
13040 if (section_is_p (sectp->name, &names->str_dwo))
13042 dwp_file->sections.str.s.section = sectp;
13043 dwp_file->sections.str.size = bfd_get_section_size (sectp);
13045 else if (section_is_p (sectp->name, &names->cu_index))
13047 dwp_file->sections.cu_index.s.section = sectp;
13048 dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
13050 else if (section_is_p (sectp->name, &names->tu_index))
13052 dwp_file->sections.tu_index.s.section = sectp;
13053 dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
13057 /* This function is mapped across the sections and remembers the offset and
13058 size of each of the DWP version 2 debugging sections that we are interested
13059 in. This is split into a separate function because we don't know if we
13060 have version 1 or 2 until we parse the cu_index/tu_index sections. */
13063 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
13065 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13066 const struct dwop_section_names *names = &dwop_section_names;
13067 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13069 /* Record the ELF section number for later lookup: this is what the
13070 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13071 gdb_assert (elf_section_nr < dwp_file->num_sections);
13072 dwp_file->elf_sections[elf_section_nr] = sectp;
13074 /* Look for specific sections that we need. */
13075 if (section_is_p (sectp->name, &names->abbrev_dwo))
13077 dwp_file->sections.abbrev.s.section = sectp;
13078 dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
13080 else if (section_is_p (sectp->name, &names->info_dwo))
13082 dwp_file->sections.info.s.section = sectp;
13083 dwp_file->sections.info.size = bfd_get_section_size (sectp);
13085 else if (section_is_p (sectp->name, &names->line_dwo))
13087 dwp_file->sections.line.s.section = sectp;
13088 dwp_file->sections.line.size = bfd_get_section_size (sectp);
13090 else if (section_is_p (sectp->name, &names->loc_dwo))
13092 dwp_file->sections.loc.s.section = sectp;
13093 dwp_file->sections.loc.size = bfd_get_section_size (sectp);
13095 else if (section_is_p (sectp->name, &names->macinfo_dwo))
13097 dwp_file->sections.macinfo.s.section = sectp;
13098 dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
13100 else if (section_is_p (sectp->name, &names->macro_dwo))
13102 dwp_file->sections.macro.s.section = sectp;
13103 dwp_file->sections.macro.size = bfd_get_section_size (sectp);
13105 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
13107 dwp_file->sections.str_offsets.s.section = sectp;
13108 dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
13110 else if (section_is_p (sectp->name, &names->types_dwo))
13112 dwp_file->sections.types.s.section = sectp;
13113 dwp_file->sections.types.size = bfd_get_section_size (sectp);
13117 /* Hash function for dwp_file loaded CUs/TUs. */
13120 hash_dwp_loaded_cutus (const void *item)
13122 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
13124 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13125 return dwo_unit->signature;
13128 /* Equality function for dwp_file loaded CUs/TUs. */
13131 eq_dwp_loaded_cutus (const void *a, const void *b)
13133 const struct dwo_unit *dua = (const struct dwo_unit *) a;
13134 const struct dwo_unit *dub = (const struct dwo_unit *) b;
13136 return dua->signature == dub->signature;
13139 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13142 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
13144 return htab_create_alloc_ex (3,
13145 hash_dwp_loaded_cutus,
13146 eq_dwp_loaded_cutus,
13148 &objfile->objfile_obstack,
13149 hashtab_obstack_allocate,
13150 dummy_obstack_deallocate);
13153 /* Try to open DWP file FILE_NAME.
13154 The result is the bfd handle of the file.
13155 If there is a problem finding or opening the file, return NULL.
13156 Upon success, the canonicalized path of the file is stored in the bfd,
13157 same as symfile_bfd_open. */
13159 static gdb_bfd_ref_ptr
13160 open_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
13161 const char *file_name)
13163 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile, file_name,
13165 1 /*search_cwd*/));
13169 /* Work around upstream bug 15652.
13170 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13171 [Whether that's a "bug" is debatable, but it is getting in our way.]
13172 We have no real idea where the dwp file is, because gdb's realpath-ing
13173 of the executable's path may have discarded the needed info.
13174 [IWBN if the dwp file name was recorded in the executable, akin to
13175 .gnu_debuglink, but that doesn't exist yet.]
13176 Strip the directory from FILE_NAME and search again. */
13177 if (*debug_file_directory != '\0')
13179 /* Don't implicitly search the current directory here.
13180 If the user wants to search "." to handle this case,
13181 it must be added to debug-file-directory. */
13182 return try_open_dwop_file (dwarf2_per_objfile,
13183 lbasename (file_name), 1 /*is_dwp*/,
13190 /* Initialize the use of the DWP file for the current objfile.
13191 By convention the name of the DWP file is ${objfile}.dwp.
13192 The result is NULL if it can't be found. */
13194 static std::unique_ptr<struct dwp_file>
13195 open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13197 struct objfile *objfile = dwarf2_per_objfile->objfile;
13199 /* Try to find first .dwp for the binary file before any symbolic links
13202 /* If the objfile is a debug file, find the name of the real binary
13203 file and get the name of dwp file from there. */
13204 std::string dwp_name;
13205 if (objfile->separate_debug_objfile_backlink != NULL)
13207 struct objfile *backlink = objfile->separate_debug_objfile_backlink;
13208 const char *backlink_basename = lbasename (backlink->original_name);
13210 dwp_name = ldirname (objfile->original_name) + SLASH_STRING + backlink_basename;
13213 dwp_name = objfile->original_name;
13215 dwp_name += ".dwp";
13217 gdb_bfd_ref_ptr dbfd (open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ()));
13219 && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
13221 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13222 dwp_name = objfile_name (objfile);
13223 dwp_name += ".dwp";
13224 dbfd = open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ());
13229 if (dwarf_read_debug)
13230 fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name.c_str ());
13231 return std::unique_ptr<dwp_file> ();
13234 const char *name = bfd_get_filename (dbfd.get ());
13235 std::unique_ptr<struct dwp_file> dwp_file
13236 (new struct dwp_file (name, std::move (dbfd)));
13238 /* +1: section 0 is unused */
13239 dwp_file->num_sections = bfd_count_sections (dwp_file->dbfd) + 1;
13240 dwp_file->elf_sections =
13241 OBSTACK_CALLOC (&objfile->objfile_obstack,
13242 dwp_file->num_sections, asection *);
13244 bfd_map_over_sections (dwp_file->dbfd.get (),
13245 dwarf2_locate_common_dwp_sections,
13248 dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13251 dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13254 /* The DWP file version is stored in the hash table. Oh well. */
13255 if (dwp_file->cus && dwp_file->tus
13256 && dwp_file->cus->version != dwp_file->tus->version)
13258 /* Technically speaking, we should try to limp along, but this is
13259 pretty bizarre. We use pulongest here because that's the established
13260 portability solution (e.g, we cannot use %u for uint32_t). */
13261 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13262 " TU version %s [in DWP file %s]"),
13263 pulongest (dwp_file->cus->version),
13264 pulongest (dwp_file->tus->version), dwp_name.c_str ());
13268 dwp_file->version = dwp_file->cus->version;
13269 else if (dwp_file->tus)
13270 dwp_file->version = dwp_file->tus->version;
13272 dwp_file->version = 2;
13274 if (dwp_file->version == 2)
13275 bfd_map_over_sections (dwp_file->dbfd.get (),
13276 dwarf2_locate_v2_dwp_sections,
13279 dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
13280 dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
13282 if (dwarf_read_debug)
13284 fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
13285 fprintf_unfiltered (gdb_stdlog,
13286 " %s CUs, %s TUs\n",
13287 pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
13288 pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
13294 /* Wrapper around open_and_init_dwp_file, only open it once. */
13296 static struct dwp_file *
13297 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13299 if (! dwarf2_per_objfile->dwp_checked)
13301 dwarf2_per_objfile->dwp_file
13302 = open_and_init_dwp_file (dwarf2_per_objfile);
13303 dwarf2_per_objfile->dwp_checked = 1;
13305 return dwarf2_per_objfile->dwp_file.get ();
13308 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13309 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13310 or in the DWP file for the objfile, referenced by THIS_UNIT.
13311 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13312 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13314 This is called, for example, when wanting to read a variable with a
13315 complex location. Therefore we don't want to do file i/o for every call.
13316 Therefore we don't want to look for a DWO file on every call.
13317 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13318 then we check if we've already seen DWO_NAME, and only THEN do we check
13321 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13322 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13324 static struct dwo_unit *
13325 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
13326 const char *dwo_name, const char *comp_dir,
13327 ULONGEST signature, int is_debug_types)
13329 struct dwarf2_per_objfile *dwarf2_per_objfile = this_unit->dwarf2_per_objfile;
13330 struct objfile *objfile = dwarf2_per_objfile->objfile;
13331 const char *kind = is_debug_types ? "TU" : "CU";
13332 void **dwo_file_slot;
13333 struct dwo_file *dwo_file;
13334 struct dwp_file *dwp_file;
13336 /* First see if there's a DWP file.
13337 If we have a DWP file but didn't find the DWO inside it, don't
13338 look for the original DWO file. It makes gdb behave differently
13339 depending on whether one is debugging in the build tree. */
13341 dwp_file = get_dwp_file (dwarf2_per_objfile);
13342 if (dwp_file != NULL)
13344 const struct dwp_hash_table *dwp_htab =
13345 is_debug_types ? dwp_file->tus : dwp_file->cus;
13347 if (dwp_htab != NULL)
13349 struct dwo_unit *dwo_cutu =
13350 lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, comp_dir,
13351 signature, is_debug_types);
13353 if (dwo_cutu != NULL)
13355 if (dwarf_read_debug)
13357 fprintf_unfiltered (gdb_stdlog,
13358 "Virtual DWO %s %s found: @%s\n",
13359 kind, hex_string (signature),
13360 host_address_to_string (dwo_cutu));
13368 /* No DWP file, look for the DWO file. */
13370 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
13371 dwo_name, comp_dir);
13372 if (*dwo_file_slot == NULL)
13374 /* Read in the file and build a table of the CUs/TUs it contains. */
13375 *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
13377 /* NOTE: This will be NULL if unable to open the file. */
13378 dwo_file = (struct dwo_file *) *dwo_file_slot;
13380 if (dwo_file != NULL)
13382 struct dwo_unit *dwo_cutu = NULL;
13384 if (is_debug_types && dwo_file->tus)
13386 struct dwo_unit find_dwo_cutu;
13388 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13389 find_dwo_cutu.signature = signature;
13391 = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
13393 else if (!is_debug_types && dwo_file->cus)
13395 struct dwo_unit find_dwo_cutu;
13397 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13398 find_dwo_cutu.signature = signature;
13399 dwo_cutu = (struct dwo_unit *)htab_find (dwo_file->cus,
13403 if (dwo_cutu != NULL)
13405 if (dwarf_read_debug)
13407 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
13408 kind, dwo_name, hex_string (signature),
13409 host_address_to_string (dwo_cutu));
13416 /* We didn't find it. This could mean a dwo_id mismatch, or
13417 someone deleted the DWO/DWP file, or the search path isn't set up
13418 correctly to find the file. */
13420 if (dwarf_read_debug)
13422 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
13423 kind, dwo_name, hex_string (signature));
13426 /* This is a warning and not a complaint because it can be caused by
13427 pilot error (e.g., user accidentally deleting the DWO). */
13429 /* Print the name of the DWP file if we looked there, helps the user
13430 better diagnose the problem. */
13431 std::string dwp_text;
13433 if (dwp_file != NULL)
13434 dwp_text = string_printf (" [in DWP file %s]",
13435 lbasename (dwp_file->name));
13437 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13438 " [in module %s]"),
13439 kind, dwo_name, hex_string (signature),
13441 this_unit->is_debug_types ? "TU" : "CU",
13442 sect_offset_str (this_unit->sect_off), objfile_name (objfile));
13447 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13448 See lookup_dwo_cutu_unit for details. */
13450 static struct dwo_unit *
13451 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
13452 const char *dwo_name, const char *comp_dir,
13453 ULONGEST signature)
13455 return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
13458 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13459 See lookup_dwo_cutu_unit for details. */
13461 static struct dwo_unit *
13462 lookup_dwo_type_unit (struct signatured_type *this_tu,
13463 const char *dwo_name, const char *comp_dir)
13465 return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
13468 /* Traversal function for queue_and_load_all_dwo_tus. */
13471 queue_and_load_dwo_tu (void **slot, void *info)
13473 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
13474 struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
13475 ULONGEST signature = dwo_unit->signature;
13476 struct signatured_type *sig_type =
13477 lookup_dwo_signatured_type (per_cu->cu, signature);
13479 if (sig_type != NULL)
13481 struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
13483 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13484 a real dependency of PER_CU on SIG_TYPE. That is detected later
13485 while processing PER_CU. */
13486 if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
13487 load_full_type_unit (sig_cu);
13488 VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
13494 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13495 The DWO may have the only definition of the type, though it may not be
13496 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13497 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13500 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
13502 struct dwo_unit *dwo_unit;
13503 struct dwo_file *dwo_file;
13505 gdb_assert (!per_cu->is_debug_types);
13506 gdb_assert (get_dwp_file (per_cu->dwarf2_per_objfile) == NULL);
13507 gdb_assert (per_cu->cu != NULL);
13509 dwo_unit = per_cu->cu->dwo_unit;
13510 gdb_assert (dwo_unit != NULL);
13512 dwo_file = dwo_unit->dwo_file;
13513 if (dwo_file->tus != NULL)
13514 htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
13517 /* Free all resources associated with DWO_FILE.
13518 Close the DWO file and munmap the sections. */
13521 free_dwo_file (struct dwo_file *dwo_file)
13523 /* Note: dbfd is NULL for virtual DWO files. */
13524 gdb_bfd_unref (dwo_file->dbfd);
13526 VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
13529 /* Traversal function for free_dwo_files. */
13532 free_dwo_file_from_slot (void **slot, void *info)
13534 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
13536 free_dwo_file (dwo_file);
13541 /* Free all resources associated with DWO_FILES. */
13544 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
13546 htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
13549 /* Read in various DIEs. */
13551 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13552 Inherit only the children of the DW_AT_abstract_origin DIE not being
13553 already referenced by DW_AT_abstract_origin from the children of the
13557 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
13559 struct die_info *child_die;
13560 sect_offset *offsetp;
13561 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13562 struct die_info *origin_die;
13563 /* Iterator of the ORIGIN_DIE children. */
13564 struct die_info *origin_child_die;
13565 struct attribute *attr;
13566 struct dwarf2_cu *origin_cu;
13567 struct pending **origin_previous_list_in_scope;
13569 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13573 /* Note that following die references may follow to a die in a
13577 origin_die = follow_die_ref (die, attr, &origin_cu);
13579 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13581 origin_previous_list_in_scope = origin_cu->list_in_scope;
13582 origin_cu->list_in_scope = cu->list_in_scope;
13584 if (die->tag != origin_die->tag
13585 && !(die->tag == DW_TAG_inlined_subroutine
13586 && origin_die->tag == DW_TAG_subprogram))
13587 complaint (_("DIE %s and its abstract origin %s have different tags"),
13588 sect_offset_str (die->sect_off),
13589 sect_offset_str (origin_die->sect_off));
13591 std::vector<sect_offset> offsets;
13593 for (child_die = die->child;
13594 child_die && child_die->tag;
13595 child_die = sibling_die (child_die))
13597 struct die_info *child_origin_die;
13598 struct dwarf2_cu *child_origin_cu;
13600 /* We are trying to process concrete instance entries:
13601 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13602 it's not relevant to our analysis here. i.e. detecting DIEs that are
13603 present in the abstract instance but not referenced in the concrete
13605 if (child_die->tag == DW_TAG_call_site
13606 || child_die->tag == DW_TAG_GNU_call_site)
13609 /* For each CHILD_DIE, find the corresponding child of
13610 ORIGIN_DIE. If there is more than one layer of
13611 DW_AT_abstract_origin, follow them all; there shouldn't be,
13612 but GCC versions at least through 4.4 generate this (GCC PR
13614 child_origin_die = child_die;
13615 child_origin_cu = cu;
13618 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
13622 child_origin_die = follow_die_ref (child_origin_die, attr,
13626 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13627 counterpart may exist. */
13628 if (child_origin_die != child_die)
13630 if (child_die->tag != child_origin_die->tag
13631 && !(child_die->tag == DW_TAG_inlined_subroutine
13632 && child_origin_die->tag == DW_TAG_subprogram))
13633 complaint (_("Child DIE %s and its abstract origin %s have "
13635 sect_offset_str (child_die->sect_off),
13636 sect_offset_str (child_origin_die->sect_off));
13637 if (child_origin_die->parent != origin_die)
13638 complaint (_("Child DIE %s and its abstract origin %s have "
13639 "different parents"),
13640 sect_offset_str (child_die->sect_off),
13641 sect_offset_str (child_origin_die->sect_off));
13643 offsets.push_back (child_origin_die->sect_off);
13646 std::sort (offsets.begin (), offsets.end ());
13647 sect_offset *offsets_end = offsets.data () + offsets.size ();
13648 for (offsetp = offsets.data () + 1; offsetp < offsets_end; offsetp++)
13649 if (offsetp[-1] == *offsetp)
13650 complaint (_("Multiple children of DIE %s refer "
13651 "to DIE %s as their abstract origin"),
13652 sect_offset_str (die->sect_off), sect_offset_str (*offsetp));
13654 offsetp = offsets.data ();
13655 origin_child_die = origin_die->child;
13656 while (origin_child_die && origin_child_die->tag)
13658 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13659 while (offsetp < offsets_end
13660 && *offsetp < origin_child_die->sect_off)
13662 if (offsetp >= offsets_end
13663 || *offsetp > origin_child_die->sect_off)
13665 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13666 Check whether we're already processing ORIGIN_CHILD_DIE.
13667 This can happen with mutually referenced abstract_origins.
13669 if (!origin_child_die->in_process)
13670 process_die (origin_child_die, origin_cu);
13672 origin_child_die = sibling_die (origin_child_die);
13674 origin_cu->list_in_scope = origin_previous_list_in_scope;
13678 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
13680 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13681 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13682 struct context_stack *newobj;
13685 struct die_info *child_die;
13686 struct attribute *attr, *call_line, *call_file;
13688 CORE_ADDR baseaddr;
13689 struct block *block;
13690 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
13691 std::vector<struct symbol *> template_args;
13692 struct template_symbol *templ_func = NULL;
13696 /* If we do not have call site information, we can't show the
13697 caller of this inlined function. That's too confusing, so
13698 only use the scope for local variables. */
13699 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
13700 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
13701 if (call_line == NULL || call_file == NULL)
13703 read_lexical_block_scope (die, cu);
13708 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13710 name = dwarf2_name (die, cu);
13712 /* Ignore functions with missing or empty names. These are actually
13713 illegal according to the DWARF standard. */
13716 complaint (_("missing name for subprogram DIE at %s"),
13717 sect_offset_str (die->sect_off));
13721 /* Ignore functions with missing or invalid low and high pc attributes. */
13722 if (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL)
13723 <= PC_BOUNDS_INVALID)
13725 attr = dwarf2_attr (die, DW_AT_external, cu);
13726 if (!attr || !DW_UNSND (attr))
13727 complaint (_("cannot get low and high bounds "
13728 "for subprogram DIE at %s"),
13729 sect_offset_str (die->sect_off));
13733 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13734 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13736 /* If we have any template arguments, then we must allocate a
13737 different sort of symbol. */
13738 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
13740 if (child_die->tag == DW_TAG_template_type_param
13741 || child_die->tag == DW_TAG_template_value_param)
13743 templ_func = allocate_template_symbol (objfile);
13744 templ_func->subclass = SYMBOL_TEMPLATE;
13749 newobj = cu->builder->push_context (0, lowpc);
13750 newobj->name = new_symbol (die, read_type_die (die, cu), cu,
13751 (struct symbol *) templ_func);
13753 /* If there is a location expression for DW_AT_frame_base, record
13755 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
13757 dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
13759 /* If there is a location for the static link, record it. */
13760 newobj->static_link = NULL;
13761 attr = dwarf2_attr (die, DW_AT_static_link, cu);
13764 newobj->static_link
13765 = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
13766 attr_to_dynamic_prop (attr, die, cu, newobj->static_link);
13769 cu->list_in_scope = cu->builder->get_local_symbols ();
13771 if (die->child != NULL)
13773 child_die = die->child;
13774 while (child_die && child_die->tag)
13776 if (child_die->tag == DW_TAG_template_type_param
13777 || child_die->tag == DW_TAG_template_value_param)
13779 struct symbol *arg = new_symbol (child_die, NULL, cu);
13782 template_args.push_back (arg);
13785 process_die (child_die, cu);
13786 child_die = sibling_die (child_die);
13790 inherit_abstract_dies (die, cu);
13792 /* If we have a DW_AT_specification, we might need to import using
13793 directives from the context of the specification DIE. See the
13794 comment in determine_prefix. */
13795 if (cu->language == language_cplus
13796 && dwarf2_attr (die, DW_AT_specification, cu))
13798 struct dwarf2_cu *spec_cu = cu;
13799 struct die_info *spec_die = die_specification (die, &spec_cu);
13803 child_die = spec_die->child;
13804 while (child_die && child_die->tag)
13806 if (child_die->tag == DW_TAG_imported_module)
13807 process_die (child_die, spec_cu);
13808 child_die = sibling_die (child_die);
13811 /* In some cases, GCC generates specification DIEs that
13812 themselves contain DW_AT_specification attributes. */
13813 spec_die = die_specification (spec_die, &spec_cu);
13817 struct context_stack cstk = cu->builder->pop_context ();
13818 /* Make a block for the local symbols within. */
13819 block = cu->builder->finish_block (cstk.name, cstk.old_blocks,
13820 cstk.static_link, lowpc, highpc);
13822 /* For C++, set the block's scope. */
13823 if ((cu->language == language_cplus
13824 || cu->language == language_fortran
13825 || cu->language == language_d
13826 || cu->language == language_rust)
13827 && cu->processing_has_namespace_info)
13828 block_set_scope (block, determine_prefix (die, cu),
13829 &objfile->objfile_obstack);
13831 /* If we have address ranges, record them. */
13832 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13834 gdbarch_make_symbol_special (gdbarch, cstk.name, objfile);
13836 /* Attach template arguments to function. */
13837 if (!template_args.empty ())
13839 gdb_assert (templ_func != NULL);
13841 templ_func->n_template_arguments = template_args.size ();
13842 templ_func->template_arguments
13843 = XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
13844 templ_func->n_template_arguments);
13845 memcpy (templ_func->template_arguments,
13846 template_args.data (),
13847 (templ_func->n_template_arguments * sizeof (struct symbol *)));
13849 /* Make sure that the symtab is set on the new symbols. Even
13850 though they don't appear in this symtab directly, other parts
13851 of gdb assume that symbols do, and this is reasonably
13853 for (symbol *sym : template_args)
13854 symbol_set_symtab (sym, symbol_symtab (templ_func));
13857 /* In C++, we can have functions nested inside functions (e.g., when
13858 a function declares a class that has methods). This means that
13859 when we finish processing a function scope, we may need to go
13860 back to building a containing block's symbol lists. */
13861 *cu->builder->get_local_symbols () = cstk.locals;
13862 cu->builder->set_local_using_directives (cstk.local_using_directives);
13864 /* If we've finished processing a top-level function, subsequent
13865 symbols go in the file symbol list. */
13866 if (cu->builder->outermost_context_p ())
13867 cu->list_in_scope = cu->builder->get_file_symbols ();
13870 /* Process all the DIES contained within a lexical block scope. Start
13871 a new scope, process the dies, and then close the scope. */
13874 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
13876 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13877 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13878 CORE_ADDR lowpc, highpc;
13879 struct die_info *child_die;
13880 CORE_ADDR baseaddr;
13882 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13884 /* Ignore blocks with missing or invalid low and high pc attributes. */
13885 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13886 as multiple lexical blocks? Handling children in a sane way would
13887 be nasty. Might be easier to properly extend generic blocks to
13888 describe ranges. */
13889 switch (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
13891 case PC_BOUNDS_NOT_PRESENT:
13892 /* DW_TAG_lexical_block has no attributes, process its children as if
13893 there was no wrapping by that DW_TAG_lexical_block.
13894 GCC does no longer produces such DWARF since GCC r224161. */
13895 for (child_die = die->child;
13896 child_die != NULL && child_die->tag;
13897 child_die = sibling_die (child_die))
13898 process_die (child_die, cu);
13900 case PC_BOUNDS_INVALID:
13903 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13904 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13906 cu->builder->push_context (0, lowpc);
13907 if (die->child != NULL)
13909 child_die = die->child;
13910 while (child_die && child_die->tag)
13912 process_die (child_die, cu);
13913 child_die = sibling_die (child_die);
13916 inherit_abstract_dies (die, cu);
13917 struct context_stack cstk = cu->builder->pop_context ();
13919 if (*cu->builder->get_local_symbols () != NULL
13920 || (*cu->builder->get_local_using_directives ()) != NULL)
13922 struct block *block
13923 = cu->builder->finish_block (0, cstk.old_blocks, NULL,
13924 cstk.start_addr, highpc);
13926 /* Note that recording ranges after traversing children, as we
13927 do here, means that recording a parent's ranges entails
13928 walking across all its children's ranges as they appear in
13929 the address map, which is quadratic behavior.
13931 It would be nicer to record the parent's ranges before
13932 traversing its children, simply overriding whatever you find
13933 there. But since we don't even decide whether to create a
13934 block until after we've traversed its children, that's hard
13936 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13938 *cu->builder->get_local_symbols () = cstk.locals;
13939 cu->builder->set_local_using_directives (cstk.local_using_directives);
13942 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13945 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
13947 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13948 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13949 CORE_ADDR pc, baseaddr;
13950 struct attribute *attr;
13951 struct call_site *call_site, call_site_local;
13954 struct die_info *child_die;
13956 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13958 attr = dwarf2_attr (die, DW_AT_call_return_pc, cu);
13961 /* This was a pre-DWARF-5 GNU extension alias
13962 for DW_AT_call_return_pc. */
13963 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
13967 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13968 "DIE %s [in module %s]"),
13969 sect_offset_str (die->sect_off), objfile_name (objfile));
13972 pc = attr_value_as_address (attr) + baseaddr;
13973 pc = gdbarch_adjust_dwarf2_addr (gdbarch, pc);
13975 if (cu->call_site_htab == NULL)
13976 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
13977 NULL, &objfile->objfile_obstack,
13978 hashtab_obstack_allocate, NULL);
13979 call_site_local.pc = pc;
13980 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
13983 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13984 "DIE %s [in module %s]"),
13985 paddress (gdbarch, pc), sect_offset_str (die->sect_off),
13986 objfile_name (objfile));
13990 /* Count parameters at the caller. */
13993 for (child_die = die->child; child_die && child_die->tag;
13994 child_die = sibling_die (child_die))
13996 if (child_die->tag != DW_TAG_call_site_parameter
13997 && child_die->tag != DW_TAG_GNU_call_site_parameter)
13999 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
14000 "DW_TAG_call_site child DIE %s [in module %s]"),
14001 child_die->tag, sect_offset_str (child_die->sect_off),
14002 objfile_name (objfile));
14010 = ((struct call_site *)
14011 obstack_alloc (&objfile->objfile_obstack,
14012 sizeof (*call_site)
14013 + (sizeof (*call_site->parameter) * (nparams - 1))));
14015 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
14016 call_site->pc = pc;
14018 if (dwarf2_flag_true_p (die, DW_AT_call_tail_call, cu)
14019 || dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
14021 struct die_info *func_die;
14023 /* Skip also over DW_TAG_inlined_subroutine. */
14024 for (func_die = die->parent;
14025 func_die && func_die->tag != DW_TAG_subprogram
14026 && func_die->tag != DW_TAG_subroutine_type;
14027 func_die = func_die->parent);
14029 /* DW_AT_call_all_calls is a superset
14030 of DW_AT_call_all_tail_calls. */
14032 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_calls, cu)
14033 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
14034 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_tail_calls, cu)
14035 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
14037 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
14038 not complete. But keep CALL_SITE for look ups via call_site_htab,
14039 both the initial caller containing the real return address PC and
14040 the final callee containing the current PC of a chain of tail
14041 calls do not need to have the tail call list complete. But any
14042 function candidate for a virtual tail call frame searched via
14043 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14044 determined unambiguously. */
14048 struct type *func_type = NULL;
14051 func_type = get_die_type (func_die, cu);
14052 if (func_type != NULL)
14054 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
14056 /* Enlist this call site to the function. */
14057 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
14058 TYPE_TAIL_CALL_LIST (func_type) = call_site;
14061 complaint (_("Cannot find function owning DW_TAG_call_site "
14062 "DIE %s [in module %s]"),
14063 sect_offset_str (die->sect_off), objfile_name (objfile));
14067 attr = dwarf2_attr (die, DW_AT_call_target, cu);
14069 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
14071 attr = dwarf2_attr (die, DW_AT_call_origin, cu);
14074 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
14075 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14077 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
14078 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
14079 /* Keep NULL DWARF_BLOCK. */;
14080 else if (attr_form_is_block (attr))
14082 struct dwarf2_locexpr_baton *dlbaton;
14084 dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
14085 dlbaton->data = DW_BLOCK (attr)->data;
14086 dlbaton->size = DW_BLOCK (attr)->size;
14087 dlbaton->per_cu = cu->per_cu;
14089 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
14091 else if (attr_form_is_ref (attr))
14093 struct dwarf2_cu *target_cu = cu;
14094 struct die_info *target_die;
14096 target_die = follow_die_ref (die, attr, &target_cu);
14097 gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
14098 if (die_is_declaration (target_die, target_cu))
14100 const char *target_physname;
14102 /* Prefer the mangled name; otherwise compute the demangled one. */
14103 target_physname = dw2_linkage_name (target_die, target_cu);
14104 if (target_physname == NULL)
14105 target_physname = dwarf2_physname (NULL, target_die, target_cu);
14106 if (target_physname == NULL)
14107 complaint (_("DW_AT_call_target target DIE has invalid "
14108 "physname, for referencing DIE %s [in module %s]"),
14109 sect_offset_str (die->sect_off), objfile_name (objfile));
14111 SET_FIELD_PHYSNAME (call_site->target, target_physname);
14117 /* DW_AT_entry_pc should be preferred. */
14118 if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
14119 <= PC_BOUNDS_INVALID)
14120 complaint (_("DW_AT_call_target target DIE has invalid "
14121 "low pc, for referencing DIE %s [in module %s]"),
14122 sect_offset_str (die->sect_off), objfile_name (objfile));
14125 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
14126 SET_FIELD_PHYSADDR (call_site->target, lowpc);
14131 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14132 "block nor reference, for DIE %s [in module %s]"),
14133 sect_offset_str (die->sect_off), objfile_name (objfile));
14135 call_site->per_cu = cu->per_cu;
14137 for (child_die = die->child;
14138 child_die && child_die->tag;
14139 child_die = sibling_die (child_die))
14141 struct call_site_parameter *parameter;
14142 struct attribute *loc, *origin;
14144 if (child_die->tag != DW_TAG_call_site_parameter
14145 && child_die->tag != DW_TAG_GNU_call_site_parameter)
14147 /* Already printed the complaint above. */
14151 gdb_assert (call_site->parameter_count < nparams);
14152 parameter = &call_site->parameter[call_site->parameter_count];
14154 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14155 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14156 register is contained in DW_AT_call_value. */
14158 loc = dwarf2_attr (child_die, DW_AT_location, cu);
14159 origin = dwarf2_attr (child_die, DW_AT_call_parameter, cu);
14160 if (origin == NULL)
14162 /* This was a pre-DWARF-5 GNU extension alias
14163 for DW_AT_call_parameter. */
14164 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
14166 if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
14168 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
14170 sect_offset sect_off
14171 = (sect_offset) dwarf2_get_ref_die_offset (origin);
14172 if (!offset_in_cu_p (&cu->header, sect_off))
14174 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14175 binding can be done only inside one CU. Such referenced DIE
14176 therefore cannot be even moved to DW_TAG_partial_unit. */
14177 complaint (_("DW_AT_call_parameter offset is not in CU for "
14178 "DW_TAG_call_site child DIE %s [in module %s]"),
14179 sect_offset_str (child_die->sect_off),
14180 objfile_name (objfile));
14183 parameter->u.param_cu_off
14184 = (cu_offset) (sect_off - cu->header.sect_off);
14186 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
14188 complaint (_("No DW_FORM_block* DW_AT_location for "
14189 "DW_TAG_call_site child DIE %s [in module %s]"),
14190 sect_offset_str (child_die->sect_off), objfile_name (objfile));
14195 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
14196 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
14197 if (parameter->u.dwarf_reg != -1)
14198 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
14199 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
14200 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
14201 ¶meter->u.fb_offset))
14202 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
14205 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14206 "for DW_FORM_block* DW_AT_location is supported for "
14207 "DW_TAG_call_site child DIE %s "
14209 sect_offset_str (child_die->sect_off),
14210 objfile_name (objfile));
14215 attr = dwarf2_attr (child_die, DW_AT_call_value, cu);
14217 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
14218 if (!attr_form_is_block (attr))
14220 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14221 "DW_TAG_call_site child DIE %s [in module %s]"),
14222 sect_offset_str (child_die->sect_off),
14223 objfile_name (objfile));
14226 parameter->value = DW_BLOCK (attr)->data;
14227 parameter->value_size = DW_BLOCK (attr)->size;
14229 /* Parameters are not pre-cleared by memset above. */
14230 parameter->data_value = NULL;
14231 parameter->data_value_size = 0;
14232 call_site->parameter_count++;
14234 attr = dwarf2_attr (child_die, DW_AT_call_data_value, cu);
14236 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
14239 if (!attr_form_is_block (attr))
14240 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14241 "DW_TAG_call_site child DIE %s [in module %s]"),
14242 sect_offset_str (child_die->sect_off),
14243 objfile_name (objfile));
14246 parameter->data_value = DW_BLOCK (attr)->data;
14247 parameter->data_value_size = DW_BLOCK (attr)->size;
14253 /* Helper function for read_variable. If DIE represents a virtual
14254 table, then return the type of the concrete object that is
14255 associated with the virtual table. Otherwise, return NULL. */
14257 static struct type *
14258 rust_containing_type (struct die_info *die, struct dwarf2_cu *cu)
14260 struct attribute *attr = dwarf2_attr (die, DW_AT_type, cu);
14264 /* Find the type DIE. */
14265 struct die_info *type_die = NULL;
14266 struct dwarf2_cu *type_cu = cu;
14268 if (attr_form_is_ref (attr))
14269 type_die = follow_die_ref (die, attr, &type_cu);
14270 if (type_die == NULL)
14273 if (dwarf2_attr (type_die, DW_AT_containing_type, type_cu) == NULL)
14275 return die_containing_type (type_die, type_cu);
14278 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14281 read_variable (struct die_info *die, struct dwarf2_cu *cu)
14283 struct rust_vtable_symbol *storage = NULL;
14285 if (cu->language == language_rust)
14287 struct type *containing_type = rust_containing_type (die, cu);
14289 if (containing_type != NULL)
14291 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14293 storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
14294 struct rust_vtable_symbol);
14295 initialize_objfile_symbol (storage);
14296 storage->concrete_type = containing_type;
14297 storage->subclass = SYMBOL_RUST_VTABLE;
14301 struct symbol *res = new_symbol (die, NULL, cu, storage);
14302 struct attribute *abstract_origin
14303 = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14304 struct attribute *loc = dwarf2_attr (die, DW_AT_location, cu);
14305 if (res == NULL && loc && abstract_origin)
14307 /* We have a variable without a name, but with a location and an abstract
14308 origin. This may be a concrete instance of an abstract variable
14309 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14311 struct dwarf2_cu *origin_cu = cu;
14312 struct die_info *origin_die
14313 = follow_die_ref (die, abstract_origin, &origin_cu);
14314 dwarf2_per_objfile *dpo = cu->per_cu->dwarf2_per_objfile;
14315 dpo->abstract_to_concrete[origin_die].push_back (die);
14319 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14320 reading .debug_rnglists.
14321 Callback's type should be:
14322 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14323 Return true if the attributes are present and valid, otherwise,
14326 template <typename Callback>
14328 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
14329 Callback &&callback)
14331 struct dwarf2_per_objfile *dwarf2_per_objfile
14332 = cu->per_cu->dwarf2_per_objfile;
14333 struct objfile *objfile = dwarf2_per_objfile->objfile;
14334 bfd *obfd = objfile->obfd;
14335 /* Base address selection entry. */
14338 const gdb_byte *buffer;
14339 CORE_ADDR baseaddr;
14340 bool overflow = false;
14342 found_base = cu->base_known;
14343 base = cu->base_address;
14345 dwarf2_read_section (objfile, &dwarf2_per_objfile->rnglists);
14346 if (offset >= dwarf2_per_objfile->rnglists.size)
14348 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14352 buffer = dwarf2_per_objfile->rnglists.buffer + offset;
14354 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14358 /* Initialize it due to a false compiler warning. */
14359 CORE_ADDR range_beginning = 0, range_end = 0;
14360 const gdb_byte *buf_end = (dwarf2_per_objfile->rnglists.buffer
14361 + dwarf2_per_objfile->rnglists.size);
14362 unsigned int bytes_read;
14364 if (buffer == buf_end)
14369 const auto rlet = static_cast<enum dwarf_range_list_entry>(*buffer++);
14372 case DW_RLE_end_of_list:
14374 case DW_RLE_base_address:
14375 if (buffer + cu->header.addr_size > buf_end)
14380 base = read_address (obfd, buffer, cu, &bytes_read);
14382 buffer += bytes_read;
14384 case DW_RLE_start_length:
14385 if (buffer + cu->header.addr_size > buf_end)
14390 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14391 buffer += bytes_read;
14392 range_end = (range_beginning
14393 + read_unsigned_leb128 (obfd, buffer, &bytes_read));
14394 buffer += bytes_read;
14395 if (buffer > buf_end)
14401 case DW_RLE_offset_pair:
14402 range_beginning = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14403 buffer += bytes_read;
14404 if (buffer > buf_end)
14409 range_end = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14410 buffer += bytes_read;
14411 if (buffer > buf_end)
14417 case DW_RLE_start_end:
14418 if (buffer + 2 * cu->header.addr_size > buf_end)
14423 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14424 buffer += bytes_read;
14425 range_end = read_address (obfd, buffer, cu, &bytes_read);
14426 buffer += bytes_read;
14429 complaint (_("Invalid .debug_rnglists data (no base address)"));
14432 if (rlet == DW_RLE_end_of_list || overflow)
14434 if (rlet == DW_RLE_base_address)
14439 /* We have no valid base address for the ranges
14441 complaint (_("Invalid .debug_rnglists data (no base address)"));
14445 if (range_beginning > range_end)
14447 /* Inverted range entries are invalid. */
14448 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14452 /* Empty range entries have no effect. */
14453 if (range_beginning == range_end)
14456 range_beginning += base;
14459 /* A not-uncommon case of bad debug info.
14460 Don't pollute the addrmap with bad data. */
14461 if (range_beginning + baseaddr == 0
14462 && !dwarf2_per_objfile->has_section_at_zero)
14464 complaint (_(".debug_rnglists entry has start address of zero"
14465 " [in module %s]"), objfile_name (objfile));
14469 callback (range_beginning, range_end);
14474 complaint (_("Offset %d is not terminated "
14475 "for DW_AT_ranges attribute"),
14483 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14484 Callback's type should be:
14485 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14486 Return 1 if the attributes are present and valid, otherwise, return 0. */
14488 template <typename Callback>
14490 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
14491 Callback &&callback)
14493 struct dwarf2_per_objfile *dwarf2_per_objfile
14494 = cu->per_cu->dwarf2_per_objfile;
14495 struct objfile *objfile = dwarf2_per_objfile->objfile;
14496 struct comp_unit_head *cu_header = &cu->header;
14497 bfd *obfd = objfile->obfd;
14498 unsigned int addr_size = cu_header->addr_size;
14499 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
14500 /* Base address selection entry. */
14503 unsigned int dummy;
14504 const gdb_byte *buffer;
14505 CORE_ADDR baseaddr;
14507 if (cu_header->version >= 5)
14508 return dwarf2_rnglists_process (offset, cu, callback);
14510 found_base = cu->base_known;
14511 base = cu->base_address;
14513 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
14514 if (offset >= dwarf2_per_objfile->ranges.size)
14516 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14520 buffer = dwarf2_per_objfile->ranges.buffer + offset;
14522 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14526 CORE_ADDR range_beginning, range_end;
14528 range_beginning = read_address (obfd, buffer, cu, &dummy);
14529 buffer += addr_size;
14530 range_end = read_address (obfd, buffer, cu, &dummy);
14531 buffer += addr_size;
14532 offset += 2 * addr_size;
14534 /* An end of list marker is a pair of zero addresses. */
14535 if (range_beginning == 0 && range_end == 0)
14536 /* Found the end of list entry. */
14539 /* Each base address selection entry is a pair of 2 values.
14540 The first is the largest possible address, the second is
14541 the base address. Check for a base address here. */
14542 if ((range_beginning & mask) == mask)
14544 /* If we found the largest possible address, then we already
14545 have the base address in range_end. */
14553 /* We have no valid base address for the ranges
14555 complaint (_("Invalid .debug_ranges data (no base address)"));
14559 if (range_beginning > range_end)
14561 /* Inverted range entries are invalid. */
14562 complaint (_("Invalid .debug_ranges data (inverted range)"));
14566 /* Empty range entries have no effect. */
14567 if (range_beginning == range_end)
14570 range_beginning += base;
14573 /* A not-uncommon case of bad debug info.
14574 Don't pollute the addrmap with bad data. */
14575 if (range_beginning + baseaddr == 0
14576 && !dwarf2_per_objfile->has_section_at_zero)
14578 complaint (_(".debug_ranges entry has start address of zero"
14579 " [in module %s]"), objfile_name (objfile));
14583 callback (range_beginning, range_end);
14589 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14590 Return 1 if the attributes are present and valid, otherwise, return 0.
14591 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14594 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
14595 CORE_ADDR *high_return, struct dwarf2_cu *cu,
14596 struct partial_symtab *ranges_pst)
14598 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14599 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14600 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
14601 SECT_OFF_TEXT (objfile));
14604 CORE_ADDR high = 0;
14607 retval = dwarf2_ranges_process (offset, cu,
14608 [&] (CORE_ADDR range_beginning, CORE_ADDR range_end)
14610 if (ranges_pst != NULL)
14615 lowpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14616 range_beginning + baseaddr)
14618 highpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14619 range_end + baseaddr)
14621 addrmap_set_empty (objfile->psymtabs_addrmap, lowpc, highpc - 1,
14625 /* FIXME: This is recording everything as a low-high
14626 segment of consecutive addresses. We should have a
14627 data structure for discontiguous block ranges
14631 low = range_beginning;
14637 if (range_beginning < low)
14638 low = range_beginning;
14639 if (range_end > high)
14647 /* If the first entry is an end-of-list marker, the range
14648 describes an empty scope, i.e. no instructions. */
14654 *high_return = high;
14658 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14659 definition for the return value. *LOWPC and *HIGHPC are set iff
14660 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14662 static enum pc_bounds_kind
14663 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
14664 CORE_ADDR *highpc, struct dwarf2_cu *cu,
14665 struct partial_symtab *pst)
14667 struct dwarf2_per_objfile *dwarf2_per_objfile
14668 = cu->per_cu->dwarf2_per_objfile;
14669 struct attribute *attr;
14670 struct attribute *attr_high;
14672 CORE_ADDR high = 0;
14673 enum pc_bounds_kind ret;
14675 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14678 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14681 low = attr_value_as_address (attr);
14682 high = attr_value_as_address (attr_high);
14683 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14687 /* Found high w/o low attribute. */
14688 return PC_BOUNDS_INVALID;
14690 /* Found consecutive range of addresses. */
14691 ret = PC_BOUNDS_HIGH_LOW;
14695 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14698 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14699 We take advantage of the fact that DW_AT_ranges does not appear
14700 in DW_TAG_compile_unit of DWO files. */
14701 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14702 unsigned int ranges_offset = (DW_UNSND (attr)
14703 + (need_ranges_base
14707 /* Value of the DW_AT_ranges attribute is the offset in the
14708 .debug_ranges section. */
14709 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
14710 return PC_BOUNDS_INVALID;
14711 /* Found discontinuous range of addresses. */
14712 ret = PC_BOUNDS_RANGES;
14715 return PC_BOUNDS_NOT_PRESENT;
14718 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14720 return PC_BOUNDS_INVALID;
14722 /* When using the GNU linker, .gnu.linkonce. sections are used to
14723 eliminate duplicate copies of functions and vtables and such.
14724 The linker will arbitrarily choose one and discard the others.
14725 The AT_*_pc values for such functions refer to local labels in
14726 these sections. If the section from that file was discarded, the
14727 labels are not in the output, so the relocs get a value of 0.
14728 If this is a discarded function, mark the pc bounds as invalid,
14729 so that GDB will ignore it. */
14730 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
14731 return PC_BOUNDS_INVALID;
14739 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14740 its low and high PC addresses. Do nothing if these addresses could not
14741 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14742 and HIGHPC to the high address if greater than HIGHPC. */
14745 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
14746 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14747 struct dwarf2_cu *cu)
14749 CORE_ADDR low, high;
14750 struct die_info *child = die->child;
14752 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL) >= PC_BOUNDS_RANGES)
14754 *lowpc = std::min (*lowpc, low);
14755 *highpc = std::max (*highpc, high);
14758 /* If the language does not allow nested subprograms (either inside
14759 subprograms or lexical blocks), we're done. */
14760 if (cu->language != language_ada)
14763 /* Check all the children of the given DIE. If it contains nested
14764 subprograms, then check their pc bounds. Likewise, we need to
14765 check lexical blocks as well, as they may also contain subprogram
14767 while (child && child->tag)
14769 if (child->tag == DW_TAG_subprogram
14770 || child->tag == DW_TAG_lexical_block)
14771 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
14772 child = sibling_die (child);
14776 /* Get the low and high pc's represented by the scope DIE, and store
14777 them in *LOWPC and *HIGHPC. If the correct values can't be
14778 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14781 get_scope_pc_bounds (struct die_info *die,
14782 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14783 struct dwarf2_cu *cu)
14785 CORE_ADDR best_low = (CORE_ADDR) -1;
14786 CORE_ADDR best_high = (CORE_ADDR) 0;
14787 CORE_ADDR current_low, current_high;
14789 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL)
14790 >= PC_BOUNDS_RANGES)
14792 best_low = current_low;
14793 best_high = current_high;
14797 struct die_info *child = die->child;
14799 while (child && child->tag)
14801 switch (child->tag) {
14802 case DW_TAG_subprogram:
14803 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
14805 case DW_TAG_namespace:
14806 case DW_TAG_module:
14807 /* FIXME: carlton/2004-01-16: Should we do this for
14808 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14809 that current GCC's always emit the DIEs corresponding
14810 to definitions of methods of classes as children of a
14811 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14812 the DIEs giving the declarations, which could be
14813 anywhere). But I don't see any reason why the
14814 standards says that they have to be there. */
14815 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
14817 if (current_low != ((CORE_ADDR) -1))
14819 best_low = std::min (best_low, current_low);
14820 best_high = std::max (best_high, current_high);
14828 child = sibling_die (child);
14833 *highpc = best_high;
14836 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14840 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
14841 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
14843 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14844 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14845 struct attribute *attr;
14846 struct attribute *attr_high;
14848 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14851 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14854 CORE_ADDR low = attr_value_as_address (attr);
14855 CORE_ADDR high = attr_value_as_address (attr_high);
14857 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14860 low = gdbarch_adjust_dwarf2_addr (gdbarch, low + baseaddr);
14861 high = gdbarch_adjust_dwarf2_addr (gdbarch, high + baseaddr);
14862 cu->builder->record_block_range (block, low, high - 1);
14866 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14869 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14870 We take advantage of the fact that DW_AT_ranges does not appear
14871 in DW_TAG_compile_unit of DWO files. */
14872 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14874 /* The value of the DW_AT_ranges attribute is the offset of the
14875 address range list in the .debug_ranges section. */
14876 unsigned long offset = (DW_UNSND (attr)
14877 + (need_ranges_base ? cu->ranges_base : 0));
14879 std::vector<blockrange> blockvec;
14880 dwarf2_ranges_process (offset, cu,
14881 [&] (CORE_ADDR start, CORE_ADDR end)
14885 start = gdbarch_adjust_dwarf2_addr (gdbarch, start);
14886 end = gdbarch_adjust_dwarf2_addr (gdbarch, end);
14887 cu->builder->record_block_range (block, start, end - 1);
14888 blockvec.emplace_back (start, end);
14891 BLOCK_RANGES(block) = make_blockranges (objfile, blockvec);
14895 /* Check whether the producer field indicates either of GCC < 4.6, or the
14896 Intel C/C++ compiler, and cache the result in CU. */
14899 check_producer (struct dwarf2_cu *cu)
14903 if (cu->producer == NULL)
14905 /* For unknown compilers expect their behavior is DWARF version
14908 GCC started to support .debug_types sections by -gdwarf-4 since
14909 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14910 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14911 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14912 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14914 else if (producer_is_gcc (cu->producer, &major, &minor))
14916 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
14917 cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
14919 else if (producer_is_icc (cu->producer, &major, &minor))
14921 cu->producer_is_icc = true;
14922 cu->producer_is_icc_lt_14 = major < 14;
14924 else if (startswith (cu->producer, "CodeWarrior S12/L-ISA"))
14925 cu->producer_is_codewarrior = true;
14928 /* For other non-GCC compilers, expect their behavior is DWARF version
14932 cu->checked_producer = true;
14935 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14936 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14937 during 4.6.0 experimental. */
14940 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
14942 if (!cu->checked_producer)
14943 check_producer (cu);
14945 return cu->producer_is_gxx_lt_4_6;
14949 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14950 with incorrect is_stmt attributes. */
14953 producer_is_codewarrior (struct dwarf2_cu *cu)
14955 if (!cu->checked_producer)
14956 check_producer (cu);
14958 return cu->producer_is_codewarrior;
14961 /* Return the default accessibility type if it is not overriden by
14962 DW_AT_accessibility. */
14964 static enum dwarf_access_attribute
14965 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
14967 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
14969 /* The default DWARF 2 accessibility for members is public, the default
14970 accessibility for inheritance is private. */
14972 if (die->tag != DW_TAG_inheritance)
14973 return DW_ACCESS_public;
14975 return DW_ACCESS_private;
14979 /* DWARF 3+ defines the default accessibility a different way. The same
14980 rules apply now for DW_TAG_inheritance as for the members and it only
14981 depends on the container kind. */
14983 if (die->parent->tag == DW_TAG_class_type)
14984 return DW_ACCESS_private;
14986 return DW_ACCESS_public;
14990 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14991 offset. If the attribute was not found return 0, otherwise return
14992 1. If it was found but could not properly be handled, set *OFFSET
14996 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
14999 struct attribute *attr;
15001 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
15006 /* Note that we do not check for a section offset first here.
15007 This is because DW_AT_data_member_location is new in DWARF 4,
15008 so if we see it, we can assume that a constant form is really
15009 a constant and not a section offset. */
15010 if (attr_form_is_constant (attr))
15011 *offset = dwarf2_get_attr_constant_value (attr, 0);
15012 else if (attr_form_is_section_offset (attr))
15013 dwarf2_complex_location_expr_complaint ();
15014 else if (attr_form_is_block (attr))
15015 *offset = decode_locdesc (DW_BLOCK (attr), cu);
15017 dwarf2_complex_location_expr_complaint ();
15025 /* Add an aggregate field to the field list. */
15028 dwarf2_add_field (struct field_info *fip, struct die_info *die,
15029 struct dwarf2_cu *cu)
15031 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15032 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15033 struct nextfield *new_field;
15034 struct attribute *attr;
15036 const char *fieldname = "";
15038 if (die->tag == DW_TAG_inheritance)
15040 fip->baseclasses.emplace_back ();
15041 new_field = &fip->baseclasses.back ();
15045 fip->fields.emplace_back ();
15046 new_field = &fip->fields.back ();
15051 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15053 new_field->accessibility = DW_UNSND (attr);
15055 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
15056 if (new_field->accessibility != DW_ACCESS_public)
15057 fip->non_public_fields = 1;
15059 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15061 new_field->virtuality = DW_UNSND (attr);
15063 new_field->virtuality = DW_VIRTUALITY_none;
15065 fp = &new_field->field;
15067 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
15071 /* Data member other than a C++ static data member. */
15073 /* Get type of field. */
15074 fp->type = die_type (die, cu);
15076 SET_FIELD_BITPOS (*fp, 0);
15078 /* Get bit size of field (zero if none). */
15079 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
15082 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
15086 FIELD_BITSIZE (*fp) = 0;
15089 /* Get bit offset of field. */
15090 if (handle_data_member_location (die, cu, &offset))
15091 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15092 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
15095 if (gdbarch_bits_big_endian (gdbarch))
15097 /* For big endian bits, the DW_AT_bit_offset gives the
15098 additional bit offset from the MSB of the containing
15099 anonymous object to the MSB of the field. We don't
15100 have to do anything special since we don't need to
15101 know the size of the anonymous object. */
15102 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
15106 /* For little endian bits, compute the bit offset to the
15107 MSB of the anonymous object, subtract off the number of
15108 bits from the MSB of the field to the MSB of the
15109 object, and then subtract off the number of bits of
15110 the field itself. The result is the bit offset of
15111 the LSB of the field. */
15112 int anonymous_size;
15113 int bit_offset = DW_UNSND (attr);
15115 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15118 /* The size of the anonymous object containing
15119 the bit field is explicit, so use the
15120 indicated size (in bytes). */
15121 anonymous_size = DW_UNSND (attr);
15125 /* The size of the anonymous object containing
15126 the bit field must be inferred from the type
15127 attribute of the data member containing the
15129 anonymous_size = TYPE_LENGTH (fp->type);
15131 SET_FIELD_BITPOS (*fp,
15132 (FIELD_BITPOS (*fp)
15133 + anonymous_size * bits_per_byte
15134 - bit_offset - FIELD_BITSIZE (*fp)));
15137 attr = dwarf2_attr (die, DW_AT_data_bit_offset, cu);
15139 SET_FIELD_BITPOS (*fp, (FIELD_BITPOS (*fp)
15140 + dwarf2_get_attr_constant_value (attr, 0)));
15142 /* Get name of field. */
15143 fieldname = dwarf2_name (die, cu);
15144 if (fieldname == NULL)
15147 /* The name is already allocated along with this objfile, so we don't
15148 need to duplicate it for the type. */
15149 fp->name = fieldname;
15151 /* Change accessibility for artificial fields (e.g. virtual table
15152 pointer or virtual base class pointer) to private. */
15153 if (dwarf2_attr (die, DW_AT_artificial, cu))
15155 FIELD_ARTIFICIAL (*fp) = 1;
15156 new_field->accessibility = DW_ACCESS_private;
15157 fip->non_public_fields = 1;
15160 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
15162 /* C++ static member. */
15164 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15165 is a declaration, but all versions of G++ as of this writing
15166 (so through at least 3.2.1) incorrectly generate
15167 DW_TAG_variable tags. */
15169 const char *physname;
15171 /* Get name of field. */
15172 fieldname = dwarf2_name (die, cu);
15173 if (fieldname == NULL)
15176 attr = dwarf2_attr (die, DW_AT_const_value, cu);
15178 /* Only create a symbol if this is an external value.
15179 new_symbol checks this and puts the value in the global symbol
15180 table, which we want. If it is not external, new_symbol
15181 will try to put the value in cu->list_in_scope which is wrong. */
15182 && dwarf2_flag_true_p (die, DW_AT_external, cu))
15184 /* A static const member, not much different than an enum as far as
15185 we're concerned, except that we can support more types. */
15186 new_symbol (die, NULL, cu);
15189 /* Get physical name. */
15190 physname = dwarf2_physname (fieldname, die, cu);
15192 /* The name is already allocated along with this objfile, so we don't
15193 need to duplicate it for the type. */
15194 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
15195 FIELD_TYPE (*fp) = die_type (die, cu);
15196 FIELD_NAME (*fp) = fieldname;
15198 else if (die->tag == DW_TAG_inheritance)
15202 /* C++ base class field. */
15203 if (handle_data_member_location (die, cu, &offset))
15204 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15205 FIELD_BITSIZE (*fp) = 0;
15206 FIELD_TYPE (*fp) = die_type (die, cu);
15207 FIELD_NAME (*fp) = TYPE_NAME (fp->type);
15209 else if (die->tag == DW_TAG_variant_part)
15211 /* process_structure_scope will treat this DIE as a union. */
15212 process_structure_scope (die, cu);
15214 /* The variant part is relative to the start of the enclosing
15216 SET_FIELD_BITPOS (*fp, 0);
15217 fp->type = get_die_type (die, cu);
15218 fp->artificial = 1;
15219 fp->name = "<<variant>>";
15221 /* Normally a DW_TAG_variant_part won't have a size, but our
15222 representation requires one, so set it to the maximum of the
15224 if (TYPE_LENGTH (fp->type) == 0)
15227 for (int i = 0; i < TYPE_NFIELDS (fp->type); ++i)
15228 if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i)) > max)
15229 max = TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i));
15230 TYPE_LENGTH (fp->type) = max;
15234 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15237 /* Can the type given by DIE define another type? */
15240 type_can_define_types (const struct die_info *die)
15244 case DW_TAG_typedef:
15245 case DW_TAG_class_type:
15246 case DW_TAG_structure_type:
15247 case DW_TAG_union_type:
15248 case DW_TAG_enumeration_type:
15256 /* Add a type definition defined in the scope of the FIP's class. */
15259 dwarf2_add_type_defn (struct field_info *fip, struct die_info *die,
15260 struct dwarf2_cu *cu)
15262 struct decl_field fp;
15263 memset (&fp, 0, sizeof (fp));
15265 gdb_assert (type_can_define_types (die));
15267 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15268 fp.name = dwarf2_name (die, cu);
15269 fp.type = read_type_die (die, cu);
15271 /* Save accessibility. */
15272 enum dwarf_access_attribute accessibility;
15273 struct attribute *attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15275 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15277 accessibility = dwarf2_default_access_attribute (die, cu);
15278 switch (accessibility)
15280 case DW_ACCESS_public:
15281 /* The assumed value if neither private nor protected. */
15283 case DW_ACCESS_private:
15286 case DW_ACCESS_protected:
15287 fp.is_protected = 1;
15290 complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility);
15293 if (die->tag == DW_TAG_typedef)
15294 fip->typedef_field_list.push_back (fp);
15296 fip->nested_types_list.push_back (fp);
15299 /* Create the vector of fields, and attach it to the type. */
15302 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
15303 struct dwarf2_cu *cu)
15305 int nfields = fip->nfields;
15307 /* Record the field count, allocate space for the array of fields,
15308 and create blank accessibility bitfields if necessary. */
15309 TYPE_NFIELDS (type) = nfields;
15310 TYPE_FIELDS (type) = (struct field *)
15311 TYPE_ZALLOC (type, sizeof (struct field) * nfields);
15313 if (fip->non_public_fields && cu->language != language_ada)
15315 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15317 TYPE_FIELD_PRIVATE_BITS (type) =
15318 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15319 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
15321 TYPE_FIELD_PROTECTED_BITS (type) =
15322 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15323 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
15325 TYPE_FIELD_IGNORE_BITS (type) =
15326 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15327 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
15330 /* If the type has baseclasses, allocate and clear a bit vector for
15331 TYPE_FIELD_VIRTUAL_BITS. */
15332 if (!fip->baseclasses.empty () && cu->language != language_ada)
15334 int num_bytes = B_BYTES (fip->baseclasses.size ());
15335 unsigned char *pointer;
15337 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15338 pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes);
15339 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
15340 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->baseclasses.size ());
15341 TYPE_N_BASECLASSES (type) = fip->baseclasses.size ();
15344 if (TYPE_FLAG_DISCRIMINATED_UNION (type))
15346 struct discriminant_info *di = alloc_discriminant_info (type, -1, -1);
15348 for (int index = 0; index < nfields; ++index)
15350 struct nextfield &field = fip->fields[index];
15352 if (field.variant.is_discriminant)
15353 di->discriminant_index = index;
15354 else if (field.variant.default_branch)
15355 di->default_index = index;
15357 di->discriminants[index] = field.variant.discriminant_value;
15361 /* Copy the saved-up fields into the field vector. */
15362 for (int i = 0; i < nfields; ++i)
15364 struct nextfield &field
15365 = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i]
15366 : fip->fields[i - fip->baseclasses.size ()]);
15368 TYPE_FIELD (type, i) = field.field;
15369 switch (field.accessibility)
15371 case DW_ACCESS_private:
15372 if (cu->language != language_ada)
15373 SET_TYPE_FIELD_PRIVATE (type, i);
15376 case DW_ACCESS_protected:
15377 if (cu->language != language_ada)
15378 SET_TYPE_FIELD_PROTECTED (type, i);
15381 case DW_ACCESS_public:
15385 /* Unknown accessibility. Complain and treat it as public. */
15387 complaint (_("unsupported accessibility %d"),
15388 field.accessibility);
15392 if (i < fip->baseclasses.size ())
15394 switch (field.virtuality)
15396 case DW_VIRTUALITY_virtual:
15397 case DW_VIRTUALITY_pure_virtual:
15398 if (cu->language == language_ada)
15399 error (_("unexpected virtuality in component of Ada type"));
15400 SET_TYPE_FIELD_VIRTUAL (type, i);
15407 /* Return true if this member function is a constructor, false
15411 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
15413 const char *fieldname;
15414 const char *type_name;
15417 if (die->parent == NULL)
15420 if (die->parent->tag != DW_TAG_structure_type
15421 && die->parent->tag != DW_TAG_union_type
15422 && die->parent->tag != DW_TAG_class_type)
15425 fieldname = dwarf2_name (die, cu);
15426 type_name = dwarf2_name (die->parent, cu);
15427 if (fieldname == NULL || type_name == NULL)
15430 len = strlen (fieldname);
15431 return (strncmp (fieldname, type_name, len) == 0
15432 && (type_name[len] == '\0' || type_name[len] == '<'));
15435 /* Add a member function to the proper fieldlist. */
15438 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
15439 struct type *type, struct dwarf2_cu *cu)
15441 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15442 struct attribute *attr;
15444 struct fnfieldlist *flp = nullptr;
15445 struct fn_field *fnp;
15446 const char *fieldname;
15447 struct type *this_type;
15448 enum dwarf_access_attribute accessibility;
15450 if (cu->language == language_ada)
15451 error (_("unexpected member function in Ada type"));
15453 /* Get name of member function. */
15454 fieldname = dwarf2_name (die, cu);
15455 if (fieldname == NULL)
15458 /* Look up member function name in fieldlist. */
15459 for (i = 0; i < fip->fnfieldlists.size (); i++)
15461 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
15463 flp = &fip->fnfieldlists[i];
15468 /* Create a new fnfieldlist if necessary. */
15469 if (flp == nullptr)
15471 fip->fnfieldlists.emplace_back ();
15472 flp = &fip->fnfieldlists.back ();
15473 flp->name = fieldname;
15474 i = fip->fnfieldlists.size () - 1;
15477 /* Create a new member function field and add it to the vector of
15479 flp->fnfields.emplace_back ();
15480 fnp = &flp->fnfields.back ();
15482 /* Delay processing of the physname until later. */
15483 if (cu->language == language_cplus)
15484 add_to_method_list (type, i, flp->fnfields.size () - 1, fieldname,
15488 const char *physname = dwarf2_physname (fieldname, die, cu);
15489 fnp->physname = physname ? physname : "";
15492 fnp->type = alloc_type (objfile);
15493 this_type = read_type_die (die, cu);
15494 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
15496 int nparams = TYPE_NFIELDS (this_type);
15498 /* TYPE is the domain of this method, and THIS_TYPE is the type
15499 of the method itself (TYPE_CODE_METHOD). */
15500 smash_to_method_type (fnp->type, type,
15501 TYPE_TARGET_TYPE (this_type),
15502 TYPE_FIELDS (this_type),
15503 TYPE_NFIELDS (this_type),
15504 TYPE_VARARGS (this_type));
15506 /* Handle static member functions.
15507 Dwarf2 has no clean way to discern C++ static and non-static
15508 member functions. G++ helps GDB by marking the first
15509 parameter for non-static member functions (which is the this
15510 pointer) as artificial. We obtain this information from
15511 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15512 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
15513 fnp->voffset = VOFFSET_STATIC;
15516 complaint (_("member function type missing for '%s'"),
15517 dwarf2_full_name (fieldname, die, cu));
15519 /* Get fcontext from DW_AT_containing_type if present. */
15520 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
15521 fnp->fcontext = die_containing_type (die, cu);
15523 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15524 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15526 /* Get accessibility. */
15527 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15529 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15531 accessibility = dwarf2_default_access_attribute (die, cu);
15532 switch (accessibility)
15534 case DW_ACCESS_private:
15535 fnp->is_private = 1;
15537 case DW_ACCESS_protected:
15538 fnp->is_protected = 1;
15542 /* Check for artificial methods. */
15543 attr = dwarf2_attr (die, DW_AT_artificial, cu);
15544 if (attr && DW_UNSND (attr) != 0)
15545 fnp->is_artificial = 1;
15547 fnp->is_constructor = dwarf2_is_constructor (die, cu);
15549 /* Get index in virtual function table if it is a virtual member
15550 function. For older versions of GCC, this is an offset in the
15551 appropriate virtual table, as specified by DW_AT_containing_type.
15552 For everyone else, it is an expression to be evaluated relative
15553 to the object address. */
15555 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
15558 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
15560 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
15562 /* Old-style GCC. */
15563 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
15565 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
15566 || (DW_BLOCK (attr)->size > 1
15567 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
15568 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
15570 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
15571 if ((fnp->voffset % cu->header.addr_size) != 0)
15572 dwarf2_complex_location_expr_complaint ();
15574 fnp->voffset /= cu->header.addr_size;
15578 dwarf2_complex_location_expr_complaint ();
15580 if (!fnp->fcontext)
15582 /* If there is no `this' field and no DW_AT_containing_type,
15583 we cannot actually find a base class context for the
15585 if (TYPE_NFIELDS (this_type) == 0
15586 || !TYPE_FIELD_ARTIFICIAL (this_type, 0))
15588 complaint (_("cannot determine context for virtual member "
15589 "function \"%s\" (offset %s)"),
15590 fieldname, sect_offset_str (die->sect_off));
15595 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
15599 else if (attr_form_is_section_offset (attr))
15601 dwarf2_complex_location_expr_complaint ();
15605 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15611 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15612 if (attr && DW_UNSND (attr))
15614 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15615 complaint (_("Member function \"%s\" (offset %s) is virtual "
15616 "but the vtable offset is not specified"),
15617 fieldname, sect_offset_str (die->sect_off));
15618 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15619 TYPE_CPLUS_DYNAMIC (type) = 1;
15624 /* Create the vector of member function fields, and attach it to the type. */
15627 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
15628 struct dwarf2_cu *cu)
15630 if (cu->language == language_ada)
15631 error (_("unexpected member functions in Ada type"));
15633 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15634 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
15636 sizeof (struct fn_fieldlist) * fip->fnfieldlists.size ());
15638 for (int i = 0; i < fip->fnfieldlists.size (); i++)
15640 struct fnfieldlist &nf = fip->fnfieldlists[i];
15641 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
15643 TYPE_FN_FIELDLIST_NAME (type, i) = nf.name;
15644 TYPE_FN_FIELDLIST_LENGTH (type, i) = nf.fnfields.size ();
15645 fn_flp->fn_fields = (struct fn_field *)
15646 TYPE_ALLOC (type, sizeof (struct fn_field) * nf.fnfields.size ());
15648 for (int k = 0; k < nf.fnfields.size (); ++k)
15649 fn_flp->fn_fields[k] = nf.fnfields[k];
15652 TYPE_NFN_FIELDS (type) = fip->fnfieldlists.size ();
15655 /* Returns non-zero if NAME is the name of a vtable member in CU's
15656 language, zero otherwise. */
15658 is_vtable_name (const char *name, struct dwarf2_cu *cu)
15660 static const char vptr[] = "_vptr";
15662 /* Look for the C++ form of the vtable. */
15663 if (startswith (name, vptr) && is_cplus_marker (name[sizeof (vptr) - 1]))
15669 /* GCC outputs unnamed structures that are really pointers to member
15670 functions, with the ABI-specified layout. If TYPE describes
15671 such a structure, smash it into a member function type.
15673 GCC shouldn't do this; it should just output pointer to member DIEs.
15674 This is GCC PR debug/28767. */
15677 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
15679 struct type *pfn_type, *self_type, *new_type;
15681 /* Check for a structure with no name and two children. */
15682 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
15685 /* Check for __pfn and __delta members. */
15686 if (TYPE_FIELD_NAME (type, 0) == NULL
15687 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
15688 || TYPE_FIELD_NAME (type, 1) == NULL
15689 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
15692 /* Find the type of the method. */
15693 pfn_type = TYPE_FIELD_TYPE (type, 0);
15694 if (pfn_type == NULL
15695 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
15696 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
15699 /* Look for the "this" argument. */
15700 pfn_type = TYPE_TARGET_TYPE (pfn_type);
15701 if (TYPE_NFIELDS (pfn_type) == 0
15702 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15703 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
15706 self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
15707 new_type = alloc_type (objfile);
15708 smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
15709 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
15710 TYPE_VARARGS (pfn_type));
15711 smash_to_methodptr_type (type, new_type);
15714 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15715 appropriate error checking and issuing complaints if there is a
15719 get_alignment (struct dwarf2_cu *cu, struct die_info *die)
15721 struct attribute *attr = dwarf2_attr (die, DW_AT_alignment, cu);
15723 if (attr == nullptr)
15726 if (!attr_form_is_constant (attr))
15728 complaint (_("DW_AT_alignment must have constant form"
15729 " - DIE at %s [in module %s]"),
15730 sect_offset_str (die->sect_off),
15731 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15736 if (attr->form == DW_FORM_sdata)
15738 LONGEST val = DW_SND (attr);
15741 complaint (_("DW_AT_alignment value must not be negative"
15742 " - DIE at %s [in module %s]"),
15743 sect_offset_str (die->sect_off),
15744 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15750 align = DW_UNSND (attr);
15754 complaint (_("DW_AT_alignment value must not be zero"
15755 " - DIE at %s [in module %s]"),
15756 sect_offset_str (die->sect_off),
15757 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15760 if ((align & (align - 1)) != 0)
15762 complaint (_("DW_AT_alignment value must be a power of 2"
15763 " - DIE at %s [in module %s]"),
15764 sect_offset_str (die->sect_off),
15765 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15772 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15773 the alignment for TYPE. */
15776 maybe_set_alignment (struct dwarf2_cu *cu, struct die_info *die,
15779 if (!set_type_align (type, get_alignment (cu, die)))
15780 complaint (_("DW_AT_alignment value too large"
15781 " - DIE at %s [in module %s]"),
15782 sect_offset_str (die->sect_off),
15783 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15786 /* Called when we find the DIE that starts a structure or union scope
15787 (definition) to create a type for the structure or union. Fill in
15788 the type's name and general properties; the members will not be
15789 processed until process_structure_scope. A symbol table entry for
15790 the type will also not be done until process_structure_scope (assuming
15791 the type has a name).
15793 NOTE: we need to call these functions regardless of whether or not the
15794 DIE has a DW_AT_name attribute, since it might be an anonymous
15795 structure or union. This gets the type entered into our set of
15796 user defined types. */
15798 static struct type *
15799 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
15801 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15803 struct attribute *attr;
15806 /* If the definition of this type lives in .debug_types, read that type.
15807 Don't follow DW_AT_specification though, that will take us back up
15808 the chain and we want to go down. */
15809 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
15812 type = get_DW_AT_signature_type (die, attr, cu);
15814 /* The type's CU may not be the same as CU.
15815 Ensure TYPE is recorded with CU in die_type_hash. */
15816 return set_die_type (die, type, cu);
15819 type = alloc_type (objfile);
15820 INIT_CPLUS_SPECIFIC (type);
15822 name = dwarf2_name (die, cu);
15825 if (cu->language == language_cplus
15826 || cu->language == language_d
15827 || cu->language == language_rust)
15829 const char *full_name = dwarf2_full_name (name, die, cu);
15831 /* dwarf2_full_name might have already finished building the DIE's
15832 type. If so, there is no need to continue. */
15833 if (get_die_type (die, cu) != NULL)
15834 return get_die_type (die, cu);
15836 TYPE_NAME (type) = full_name;
15840 /* The name is already allocated along with this objfile, so
15841 we don't need to duplicate it for the type. */
15842 TYPE_NAME (type) = name;
15846 if (die->tag == DW_TAG_structure_type)
15848 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15850 else if (die->tag == DW_TAG_union_type)
15852 TYPE_CODE (type) = TYPE_CODE_UNION;
15854 else if (die->tag == DW_TAG_variant_part)
15856 TYPE_CODE (type) = TYPE_CODE_UNION;
15857 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
15861 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15864 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
15865 TYPE_DECLARED_CLASS (type) = 1;
15867 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15870 if (attr_form_is_constant (attr))
15871 TYPE_LENGTH (type) = DW_UNSND (attr);
15874 /* For the moment, dynamic type sizes are not supported
15875 by GDB's struct type. The actual size is determined
15876 on-demand when resolving the type of a given object,
15877 so set the type's length to zero for now. Otherwise,
15878 we record an expression as the length, and that expression
15879 could lead to a very large value, which could eventually
15880 lead to us trying to allocate that much memory when creating
15881 a value of that type. */
15882 TYPE_LENGTH (type) = 0;
15887 TYPE_LENGTH (type) = 0;
15890 maybe_set_alignment (cu, die, type);
15892 if (producer_is_icc_lt_14 (cu) && (TYPE_LENGTH (type) == 0))
15894 /* ICC<14 does not output the required DW_AT_declaration on
15895 incomplete types, but gives them a size of zero. */
15896 TYPE_STUB (type) = 1;
15899 TYPE_STUB_SUPPORTED (type) = 1;
15901 if (die_is_declaration (die, cu))
15902 TYPE_STUB (type) = 1;
15903 else if (attr == NULL && die->child == NULL
15904 && producer_is_realview (cu->producer))
15905 /* RealView does not output the required DW_AT_declaration
15906 on incomplete types. */
15907 TYPE_STUB (type) = 1;
15909 /* We need to add the type field to the die immediately so we don't
15910 infinitely recurse when dealing with pointers to the structure
15911 type within the structure itself. */
15912 set_die_type (die, type, cu);
15914 /* set_die_type should be already done. */
15915 set_descriptive_type (type, die, cu);
15920 /* A helper for process_structure_scope that handles a single member
15924 handle_struct_member_die (struct die_info *child_die, struct type *type,
15925 struct field_info *fi,
15926 std::vector<struct symbol *> *template_args,
15927 struct dwarf2_cu *cu)
15929 if (child_die->tag == DW_TAG_member
15930 || child_die->tag == DW_TAG_variable
15931 || child_die->tag == DW_TAG_variant_part)
15933 /* NOTE: carlton/2002-11-05: A C++ static data member
15934 should be a DW_TAG_member that is a declaration, but
15935 all versions of G++ as of this writing (so through at
15936 least 3.2.1) incorrectly generate DW_TAG_variable
15937 tags for them instead. */
15938 dwarf2_add_field (fi, child_die, cu);
15940 else if (child_die->tag == DW_TAG_subprogram)
15942 /* Rust doesn't have member functions in the C++ sense.
15943 However, it does emit ordinary functions as children
15944 of a struct DIE. */
15945 if (cu->language == language_rust)
15946 read_func_scope (child_die, cu);
15949 /* C++ member function. */
15950 dwarf2_add_member_fn (fi, child_die, type, cu);
15953 else if (child_die->tag == DW_TAG_inheritance)
15955 /* C++ base class field. */
15956 dwarf2_add_field (fi, child_die, cu);
15958 else if (type_can_define_types (child_die))
15959 dwarf2_add_type_defn (fi, child_die, cu);
15960 else if (child_die->tag == DW_TAG_template_type_param
15961 || child_die->tag == DW_TAG_template_value_param)
15963 struct symbol *arg = new_symbol (child_die, NULL, cu);
15966 template_args->push_back (arg);
15968 else if (child_die->tag == DW_TAG_variant)
15970 /* In a variant we want to get the discriminant and also add a
15971 field for our sole member child. */
15972 struct attribute *discr = dwarf2_attr (child_die, DW_AT_discr_value, cu);
15974 for (struct die_info *variant_child = child_die->child;
15975 variant_child != NULL;
15976 variant_child = sibling_die (variant_child))
15978 if (variant_child->tag == DW_TAG_member)
15980 handle_struct_member_die (variant_child, type, fi,
15981 template_args, cu);
15982 /* Only handle the one. */
15987 /* We don't handle this but we might as well report it if we see
15989 if (dwarf2_attr (child_die, DW_AT_discr_list, cu) != nullptr)
15990 complaint (_("DW_AT_discr_list is not supported yet"
15991 " - DIE at %s [in module %s]"),
15992 sect_offset_str (child_die->sect_off),
15993 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15995 /* The first field was just added, so we can stash the
15996 discriminant there. */
15997 gdb_assert (!fi->fields.empty ());
15999 fi->fields.back ().variant.default_branch = true;
16001 fi->fields.back ().variant.discriminant_value = DW_UNSND (discr);
16005 /* Finish creating a structure or union type, including filling in
16006 its members and creating a symbol for it. */
16009 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
16011 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16012 struct die_info *child_die;
16015 type = get_die_type (die, cu);
16017 type = read_structure_type (die, cu);
16019 /* When reading a DW_TAG_variant_part, we need to notice when we
16020 read the discriminant member, so we can record it later in the
16021 discriminant_info. */
16022 bool is_variant_part = TYPE_FLAG_DISCRIMINATED_UNION (type);
16023 sect_offset discr_offset;
16024 bool has_template_parameters = false;
16026 if (is_variant_part)
16028 struct attribute *discr = dwarf2_attr (die, DW_AT_discr, cu);
16031 /* Maybe it's a univariant form, an extension we support.
16032 In this case arrange not to check the offset. */
16033 is_variant_part = false;
16035 else if (attr_form_is_ref (discr))
16037 struct dwarf2_cu *target_cu = cu;
16038 struct die_info *target_die = follow_die_ref (die, discr, &target_cu);
16040 discr_offset = target_die->sect_off;
16044 complaint (_("DW_AT_discr does not have DIE reference form"
16045 " - DIE at %s [in module %s]"),
16046 sect_offset_str (die->sect_off),
16047 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16048 is_variant_part = false;
16052 if (die->child != NULL && ! die_is_declaration (die, cu))
16054 struct field_info fi;
16055 std::vector<struct symbol *> template_args;
16057 child_die = die->child;
16059 while (child_die && child_die->tag)
16061 handle_struct_member_die (child_die, type, &fi, &template_args, cu);
16063 if (is_variant_part && discr_offset == child_die->sect_off)
16064 fi.fields.back ().variant.is_discriminant = true;
16066 child_die = sibling_die (child_die);
16069 /* Attach template arguments to type. */
16070 if (!template_args.empty ())
16072 has_template_parameters = true;
16073 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16074 TYPE_N_TEMPLATE_ARGUMENTS (type) = template_args.size ();
16075 TYPE_TEMPLATE_ARGUMENTS (type)
16076 = XOBNEWVEC (&objfile->objfile_obstack,
16078 TYPE_N_TEMPLATE_ARGUMENTS (type));
16079 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
16080 template_args.data (),
16081 (TYPE_N_TEMPLATE_ARGUMENTS (type)
16082 * sizeof (struct symbol *)));
16085 /* Attach fields and member functions to the type. */
16087 dwarf2_attach_fields_to_type (&fi, type, cu);
16088 if (!fi.fnfieldlists.empty ())
16090 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
16092 /* Get the type which refers to the base class (possibly this
16093 class itself) which contains the vtable pointer for the current
16094 class from the DW_AT_containing_type attribute. This use of
16095 DW_AT_containing_type is a GNU extension. */
16097 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
16099 struct type *t = die_containing_type (die, cu);
16101 set_type_vptr_basetype (type, t);
16106 /* Our own class provides vtbl ptr. */
16107 for (i = TYPE_NFIELDS (t) - 1;
16108 i >= TYPE_N_BASECLASSES (t);
16111 const char *fieldname = TYPE_FIELD_NAME (t, i);
16113 if (is_vtable_name (fieldname, cu))
16115 set_type_vptr_fieldno (type, i);
16120 /* Complain if virtual function table field not found. */
16121 if (i < TYPE_N_BASECLASSES (t))
16122 complaint (_("virtual function table pointer "
16123 "not found when defining class '%s'"),
16124 TYPE_NAME (type) ? TYPE_NAME (type) : "");
16128 set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
16131 else if (cu->producer
16132 && startswith (cu->producer, "IBM(R) XL C/C++ Advanced Edition"))
16134 /* The IBM XLC compiler does not provide direct indication
16135 of the containing type, but the vtable pointer is
16136 always named __vfp. */
16140 for (i = TYPE_NFIELDS (type) - 1;
16141 i >= TYPE_N_BASECLASSES (type);
16144 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
16146 set_type_vptr_fieldno (type, i);
16147 set_type_vptr_basetype (type, type);
16154 /* Copy fi.typedef_field_list linked list elements content into the
16155 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16156 if (!fi.typedef_field_list.empty ())
16158 int count = fi.typedef_field_list.size ();
16160 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16161 TYPE_TYPEDEF_FIELD_ARRAY (type)
16162 = ((struct decl_field *)
16164 sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * count));
16165 TYPE_TYPEDEF_FIELD_COUNT (type) = count;
16167 for (int i = 0; i < fi.typedef_field_list.size (); ++i)
16168 TYPE_TYPEDEF_FIELD (type, i) = fi.typedef_field_list[i];
16171 /* Copy fi.nested_types_list linked list elements content into the
16172 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16173 if (!fi.nested_types_list.empty () && cu->language != language_ada)
16175 int count = fi.nested_types_list.size ();
16177 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16178 TYPE_NESTED_TYPES_ARRAY (type)
16179 = ((struct decl_field *)
16180 TYPE_ALLOC (type, sizeof (struct decl_field) * count));
16181 TYPE_NESTED_TYPES_COUNT (type) = count;
16183 for (int i = 0; i < fi.nested_types_list.size (); ++i)
16184 TYPE_NESTED_TYPES_FIELD (type, i) = fi.nested_types_list[i];
16188 quirk_gcc_member_function_pointer (type, objfile);
16189 if (cu->language == language_rust && die->tag == DW_TAG_union_type)
16190 cu->rust_unions.push_back (type);
16192 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16193 snapshots) has been known to create a die giving a declaration
16194 for a class that has, as a child, a die giving a definition for a
16195 nested class. So we have to process our children even if the
16196 current die is a declaration. Normally, of course, a declaration
16197 won't have any children at all. */
16199 child_die = die->child;
16201 while (child_die != NULL && child_die->tag)
16203 if (child_die->tag == DW_TAG_member
16204 || child_die->tag == DW_TAG_variable
16205 || child_die->tag == DW_TAG_inheritance
16206 || child_die->tag == DW_TAG_template_value_param
16207 || child_die->tag == DW_TAG_template_type_param)
16212 process_die (child_die, cu);
16214 child_die = sibling_die (child_die);
16217 /* Do not consider external references. According to the DWARF standard,
16218 these DIEs are identified by the fact that they have no byte_size
16219 attribute, and a declaration attribute. */
16220 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
16221 || !die_is_declaration (die, cu))
16223 struct symbol *sym = new_symbol (die, type, cu);
16225 if (has_template_parameters)
16227 /* Make sure that the symtab is set on the new symbols.
16228 Even though they don't appear in this symtab directly,
16229 other parts of gdb assume that symbols do, and this is
16230 reasonably true. */
16231 for (int i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
16232 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type, i),
16233 symbol_symtab (sym));
16238 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16239 update TYPE using some information only available in DIE's children. */
16242 update_enumeration_type_from_children (struct die_info *die,
16244 struct dwarf2_cu *cu)
16246 struct die_info *child_die;
16247 int unsigned_enum = 1;
16251 auto_obstack obstack;
16253 for (child_die = die->child;
16254 child_die != NULL && child_die->tag;
16255 child_die = sibling_die (child_die))
16257 struct attribute *attr;
16259 const gdb_byte *bytes;
16260 struct dwarf2_locexpr_baton *baton;
16263 if (child_die->tag != DW_TAG_enumerator)
16266 attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
16270 name = dwarf2_name (child_die, cu);
16272 name = "<anonymous enumerator>";
16274 dwarf2_const_value_attr (attr, type, name, &obstack, cu,
16275 &value, &bytes, &baton);
16281 else if ((mask & value) != 0)
16286 /* If we already know that the enum type is neither unsigned, nor
16287 a flag type, no need to look at the rest of the enumerates. */
16288 if (!unsigned_enum && !flag_enum)
16293 TYPE_UNSIGNED (type) = 1;
16295 TYPE_FLAG_ENUM (type) = 1;
16298 /* Given a DW_AT_enumeration_type die, set its type. We do not
16299 complete the type's fields yet, or create any symbols. */
16301 static struct type *
16302 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
16304 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16306 struct attribute *attr;
16309 /* If the definition of this type lives in .debug_types, read that type.
16310 Don't follow DW_AT_specification though, that will take us back up
16311 the chain and we want to go down. */
16312 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
16315 type = get_DW_AT_signature_type (die, attr, cu);
16317 /* The type's CU may not be the same as CU.
16318 Ensure TYPE is recorded with CU in die_type_hash. */
16319 return set_die_type (die, type, cu);
16322 type = alloc_type (objfile);
16324 TYPE_CODE (type) = TYPE_CODE_ENUM;
16325 name = dwarf2_full_name (NULL, die, cu);
16327 TYPE_NAME (type) = name;
16329 attr = dwarf2_attr (die, DW_AT_type, cu);
16332 struct type *underlying_type = die_type (die, cu);
16334 TYPE_TARGET_TYPE (type) = underlying_type;
16337 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16340 TYPE_LENGTH (type) = DW_UNSND (attr);
16344 TYPE_LENGTH (type) = 0;
16347 maybe_set_alignment (cu, die, type);
16349 /* The enumeration DIE can be incomplete. In Ada, any type can be
16350 declared as private in the package spec, and then defined only
16351 inside the package body. Such types are known as Taft Amendment
16352 Types. When another package uses such a type, an incomplete DIE
16353 may be generated by the compiler. */
16354 if (die_is_declaration (die, cu))
16355 TYPE_STUB (type) = 1;
16357 /* Finish the creation of this type by using the enum's children.
16358 We must call this even when the underlying type has been provided
16359 so that we can determine if we're looking at a "flag" enum. */
16360 update_enumeration_type_from_children (die, type, cu);
16362 /* If this type has an underlying type that is not a stub, then we
16363 may use its attributes. We always use the "unsigned" attribute
16364 in this situation, because ordinarily we guess whether the type
16365 is unsigned -- but the guess can be wrong and the underlying type
16366 can tell us the reality. However, we defer to a local size
16367 attribute if one exists, because this lets the compiler override
16368 the underlying type if needed. */
16369 if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
16371 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
16372 if (TYPE_LENGTH (type) == 0)
16373 TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
16374 if (TYPE_RAW_ALIGN (type) == 0
16375 && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)) != 0)
16376 set_type_align (type, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)));
16379 TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
16381 return set_die_type (die, type, cu);
16384 /* Given a pointer to a die which begins an enumeration, process all
16385 the dies that define the members of the enumeration, and create the
16386 symbol for the enumeration type.
16388 NOTE: We reverse the order of the element list. */
16391 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
16393 struct type *this_type;
16395 this_type = get_die_type (die, cu);
16396 if (this_type == NULL)
16397 this_type = read_enumeration_type (die, cu);
16399 if (die->child != NULL)
16401 struct die_info *child_die;
16402 struct symbol *sym;
16403 struct field *fields = NULL;
16404 int num_fields = 0;
16407 child_die = die->child;
16408 while (child_die && child_die->tag)
16410 if (child_die->tag != DW_TAG_enumerator)
16412 process_die (child_die, cu);
16416 name = dwarf2_name (child_die, cu);
16419 sym = new_symbol (child_die, this_type, cu);
16421 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
16423 fields = (struct field *)
16425 (num_fields + DW_FIELD_ALLOC_CHUNK)
16426 * sizeof (struct field));
16429 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
16430 FIELD_TYPE (fields[num_fields]) = NULL;
16431 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
16432 FIELD_BITSIZE (fields[num_fields]) = 0;
16438 child_die = sibling_die (child_die);
16443 TYPE_NFIELDS (this_type) = num_fields;
16444 TYPE_FIELDS (this_type) = (struct field *)
16445 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
16446 memcpy (TYPE_FIELDS (this_type), fields,
16447 sizeof (struct field) * num_fields);
16452 /* If we are reading an enum from a .debug_types unit, and the enum
16453 is a declaration, and the enum is not the signatured type in the
16454 unit, then we do not want to add a symbol for it. Adding a
16455 symbol would in some cases obscure the true definition of the
16456 enum, giving users an incomplete type when the definition is
16457 actually available. Note that we do not want to do this for all
16458 enums which are just declarations, because C++0x allows forward
16459 enum declarations. */
16460 if (cu->per_cu->is_debug_types
16461 && die_is_declaration (die, cu))
16463 struct signatured_type *sig_type;
16465 sig_type = (struct signatured_type *) cu->per_cu;
16466 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
16467 if (sig_type->type_offset_in_section != die->sect_off)
16471 new_symbol (die, this_type, cu);
16474 /* Extract all information from a DW_TAG_array_type DIE and put it in
16475 the DIE's type field. For now, this only handles one dimensional
16478 static struct type *
16479 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
16481 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16482 struct die_info *child_die;
16484 struct type *element_type, *range_type, *index_type;
16485 struct attribute *attr;
16487 struct dynamic_prop *byte_stride_prop = NULL;
16488 unsigned int bit_stride = 0;
16490 element_type = die_type (die, cu);
16492 /* The die_type call above may have already set the type for this DIE. */
16493 type = get_die_type (die, cu);
16497 attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
16503 = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
16504 stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop);
16507 complaint (_("unable to read array DW_AT_byte_stride "
16508 " - DIE at %s [in module %s]"),
16509 sect_offset_str (die->sect_off),
16510 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16511 /* Ignore this attribute. We will likely not be able to print
16512 arrays of this type correctly, but there is little we can do
16513 to help if we cannot read the attribute's value. */
16514 byte_stride_prop = NULL;
16518 attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
16520 bit_stride = DW_UNSND (attr);
16522 /* Irix 6.2 native cc creates array types without children for
16523 arrays with unspecified length. */
16524 if (die->child == NULL)
16526 index_type = objfile_type (objfile)->builtin_int;
16527 range_type = create_static_range_type (NULL, index_type, 0, -1);
16528 type = create_array_type_with_stride (NULL, element_type, range_type,
16529 byte_stride_prop, bit_stride);
16530 return set_die_type (die, type, cu);
16533 std::vector<struct type *> range_types;
16534 child_die = die->child;
16535 while (child_die && child_die->tag)
16537 if (child_die->tag == DW_TAG_subrange_type)
16539 struct type *child_type = read_type_die (child_die, cu);
16541 if (child_type != NULL)
16543 /* The range type was succesfully read. Save it for the
16544 array type creation. */
16545 range_types.push_back (child_type);
16548 child_die = sibling_die (child_die);
16551 /* Dwarf2 dimensions are output from left to right, create the
16552 necessary array types in backwards order. */
16554 type = element_type;
16556 if (read_array_order (die, cu) == DW_ORD_col_major)
16560 while (i < range_types.size ())
16561 type = create_array_type_with_stride (NULL, type, range_types[i++],
16562 byte_stride_prop, bit_stride);
16566 size_t ndim = range_types.size ();
16568 type = create_array_type_with_stride (NULL, type, range_types[ndim],
16569 byte_stride_prop, bit_stride);
16572 /* Understand Dwarf2 support for vector types (like they occur on
16573 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16574 array type. This is not part of the Dwarf2/3 standard yet, but a
16575 custom vendor extension. The main difference between a regular
16576 array and the vector variant is that vectors are passed by value
16578 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
16580 make_vector_type (type);
16582 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16583 implementation may choose to implement triple vectors using this
16585 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16588 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
16589 TYPE_LENGTH (type) = DW_UNSND (attr);
16591 complaint (_("DW_AT_byte_size for array type smaller "
16592 "than the total size of elements"));
16595 name = dwarf2_name (die, cu);
16597 TYPE_NAME (type) = name;
16599 maybe_set_alignment (cu, die, type);
16601 /* Install the type in the die. */
16602 set_die_type (die, type, cu);
16604 /* set_die_type should be already done. */
16605 set_descriptive_type (type, die, cu);
16610 static enum dwarf_array_dim_ordering
16611 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
16613 struct attribute *attr;
16615 attr = dwarf2_attr (die, DW_AT_ordering, cu);
16618 return (enum dwarf_array_dim_ordering) DW_SND (attr);
16620 /* GNU F77 is a special case, as at 08/2004 array type info is the
16621 opposite order to the dwarf2 specification, but data is still
16622 laid out as per normal fortran.
16624 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16625 version checking. */
16627 if (cu->language == language_fortran
16628 && cu->producer && strstr (cu->producer, "GNU F77"))
16630 return DW_ORD_row_major;
16633 switch (cu->language_defn->la_array_ordering)
16635 case array_column_major:
16636 return DW_ORD_col_major;
16637 case array_row_major:
16639 return DW_ORD_row_major;
16643 /* Extract all information from a DW_TAG_set_type DIE and put it in
16644 the DIE's type field. */
16646 static struct type *
16647 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
16649 struct type *domain_type, *set_type;
16650 struct attribute *attr;
16652 domain_type = die_type (die, cu);
16654 /* The die_type call above may have already set the type for this DIE. */
16655 set_type = get_die_type (die, cu);
16659 set_type = create_set_type (NULL, domain_type);
16661 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16663 TYPE_LENGTH (set_type) = DW_UNSND (attr);
16665 maybe_set_alignment (cu, die, set_type);
16667 return set_die_type (die, set_type, cu);
16670 /* A helper for read_common_block that creates a locexpr baton.
16671 SYM is the symbol which we are marking as computed.
16672 COMMON_DIE is the DIE for the common block.
16673 COMMON_LOC is the location expression attribute for the common
16675 MEMBER_LOC is the location expression attribute for the particular
16676 member of the common block that we are processing.
16677 CU is the CU from which the above come. */
16680 mark_common_block_symbol_computed (struct symbol *sym,
16681 struct die_info *common_die,
16682 struct attribute *common_loc,
16683 struct attribute *member_loc,
16684 struct dwarf2_cu *cu)
16686 struct dwarf2_per_objfile *dwarf2_per_objfile
16687 = cu->per_cu->dwarf2_per_objfile;
16688 struct objfile *objfile = dwarf2_per_objfile->objfile;
16689 struct dwarf2_locexpr_baton *baton;
16691 unsigned int cu_off;
16692 enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
16693 LONGEST offset = 0;
16695 gdb_assert (common_loc && member_loc);
16696 gdb_assert (attr_form_is_block (common_loc));
16697 gdb_assert (attr_form_is_block (member_loc)
16698 || attr_form_is_constant (member_loc));
16700 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
16701 baton->per_cu = cu->per_cu;
16702 gdb_assert (baton->per_cu);
16704 baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16706 if (attr_form_is_constant (member_loc))
16708 offset = dwarf2_get_attr_constant_value (member_loc, 0);
16709 baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
16712 baton->size += DW_BLOCK (member_loc)->size;
16714 ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
16717 *ptr++ = DW_OP_call4;
16718 cu_off = common_die->sect_off - cu->per_cu->sect_off;
16719 store_unsigned_integer (ptr, 4, byte_order, cu_off);
16722 if (attr_form_is_constant (member_loc))
16724 *ptr++ = DW_OP_addr;
16725 store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
16726 ptr += cu->header.addr_size;
16730 /* We have to copy the data here, because DW_OP_call4 will only
16731 use a DW_AT_location attribute. */
16732 memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
16733 ptr += DW_BLOCK (member_loc)->size;
16736 *ptr++ = DW_OP_plus;
16737 gdb_assert (ptr - baton->data == baton->size);
16739 SYMBOL_LOCATION_BATON (sym) = baton;
16740 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
16743 /* Create appropriate locally-scoped variables for all the
16744 DW_TAG_common_block entries. Also create a struct common_block
16745 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16746 is used to sepate the common blocks name namespace from regular
16750 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
16752 struct attribute *attr;
16754 attr = dwarf2_attr (die, DW_AT_location, cu);
16757 /* Support the .debug_loc offsets. */
16758 if (attr_form_is_block (attr))
16762 else if (attr_form_is_section_offset (attr))
16764 dwarf2_complex_location_expr_complaint ();
16769 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16770 "common block member");
16775 if (die->child != NULL)
16777 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16778 struct die_info *child_die;
16779 size_t n_entries = 0, size;
16780 struct common_block *common_block;
16781 struct symbol *sym;
16783 for (child_die = die->child;
16784 child_die && child_die->tag;
16785 child_die = sibling_die (child_die))
16788 size = (sizeof (struct common_block)
16789 + (n_entries - 1) * sizeof (struct symbol *));
16791 = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
16793 memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
16794 common_block->n_entries = 0;
16796 for (child_die = die->child;
16797 child_die && child_die->tag;
16798 child_die = sibling_die (child_die))
16800 /* Create the symbol in the DW_TAG_common_block block in the current
16802 sym = new_symbol (child_die, NULL, cu);
16805 struct attribute *member_loc;
16807 common_block->contents[common_block->n_entries++] = sym;
16809 member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
16813 /* GDB has handled this for a long time, but it is
16814 not specified by DWARF. It seems to have been
16815 emitted by gfortran at least as recently as:
16816 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16817 complaint (_("Variable in common block has "
16818 "DW_AT_data_member_location "
16819 "- DIE at %s [in module %s]"),
16820 sect_offset_str (child_die->sect_off),
16821 objfile_name (objfile));
16823 if (attr_form_is_section_offset (member_loc))
16824 dwarf2_complex_location_expr_complaint ();
16825 else if (attr_form_is_constant (member_loc)
16826 || attr_form_is_block (member_loc))
16829 mark_common_block_symbol_computed (sym, die, attr,
16833 dwarf2_complex_location_expr_complaint ();
16838 sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
16839 SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
16843 /* Create a type for a C++ namespace. */
16845 static struct type *
16846 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
16848 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16849 const char *previous_prefix, *name;
16853 /* For extensions, reuse the type of the original namespace. */
16854 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
16856 struct die_info *ext_die;
16857 struct dwarf2_cu *ext_cu = cu;
16859 ext_die = dwarf2_extension (die, &ext_cu);
16860 type = read_type_die (ext_die, ext_cu);
16862 /* EXT_CU may not be the same as CU.
16863 Ensure TYPE is recorded with CU in die_type_hash. */
16864 return set_die_type (die, type, cu);
16867 name = namespace_name (die, &is_anonymous, cu);
16869 /* Now build the name of the current namespace. */
16871 previous_prefix = determine_prefix (die, cu);
16872 if (previous_prefix[0] != '\0')
16873 name = typename_concat (&objfile->objfile_obstack,
16874 previous_prefix, name, 0, cu);
16876 /* Create the type. */
16877 type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
16879 return set_die_type (die, type, cu);
16882 /* Read a namespace scope. */
16885 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
16887 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16890 /* Add a symbol associated to this if we haven't seen the namespace
16891 before. Also, add a using directive if it's an anonymous
16894 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
16898 type = read_type_die (die, cu);
16899 new_symbol (die, type, cu);
16901 namespace_name (die, &is_anonymous, cu);
16904 const char *previous_prefix = determine_prefix (die, cu);
16906 std::vector<const char *> excludes;
16907 add_using_directive (using_directives (cu),
16908 previous_prefix, TYPE_NAME (type), NULL,
16909 NULL, excludes, 0, &objfile->objfile_obstack);
16913 if (die->child != NULL)
16915 struct die_info *child_die = die->child;
16917 while (child_die && child_die->tag)
16919 process_die (child_die, cu);
16920 child_die = sibling_die (child_die);
16925 /* Read a Fortran module as type. This DIE can be only a declaration used for
16926 imported module. Still we need that type as local Fortran "use ... only"
16927 declaration imports depend on the created type in determine_prefix. */
16929 static struct type *
16930 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
16932 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16933 const char *module_name;
16936 module_name = dwarf2_name (die, cu);
16938 complaint (_("DW_TAG_module has no name, offset %s"),
16939 sect_offset_str (die->sect_off));
16940 type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
16942 return set_die_type (die, type, cu);
16945 /* Read a Fortran module. */
16948 read_module (struct die_info *die, struct dwarf2_cu *cu)
16950 struct die_info *child_die = die->child;
16953 type = read_type_die (die, cu);
16954 new_symbol (die, type, cu);
16956 while (child_die && child_die->tag)
16958 process_die (child_die, cu);
16959 child_die = sibling_die (child_die);
16963 /* Return the name of the namespace represented by DIE. Set
16964 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16967 static const char *
16968 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
16970 struct die_info *current_die;
16971 const char *name = NULL;
16973 /* Loop through the extensions until we find a name. */
16975 for (current_die = die;
16976 current_die != NULL;
16977 current_die = dwarf2_extension (die, &cu))
16979 /* We don't use dwarf2_name here so that we can detect the absence
16980 of a name -> anonymous namespace. */
16981 name = dwarf2_string_attr (die, DW_AT_name, cu);
16987 /* Is it an anonymous namespace? */
16989 *is_anonymous = (name == NULL);
16991 name = CP_ANONYMOUS_NAMESPACE_STR;
16996 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16997 the user defined type vector. */
16999 static struct type *
17000 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
17002 struct gdbarch *gdbarch
17003 = get_objfile_arch (cu->per_cu->dwarf2_per_objfile->objfile);
17004 struct comp_unit_head *cu_header = &cu->header;
17006 struct attribute *attr_byte_size;
17007 struct attribute *attr_address_class;
17008 int byte_size, addr_class;
17009 struct type *target_type;
17011 target_type = die_type (die, cu);
17013 /* The die_type call above may have already set the type for this DIE. */
17014 type = get_die_type (die, cu);
17018 type = lookup_pointer_type (target_type);
17020 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
17021 if (attr_byte_size)
17022 byte_size = DW_UNSND (attr_byte_size);
17024 byte_size = cu_header->addr_size;
17026 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
17027 if (attr_address_class)
17028 addr_class = DW_UNSND (attr_address_class);
17030 addr_class = DW_ADDR_none;
17032 ULONGEST alignment = get_alignment (cu, die);
17034 /* If the pointer size, alignment, or address class is different
17035 than the default, create a type variant marked as such and set
17036 the length accordingly. */
17037 if (TYPE_LENGTH (type) != byte_size
17038 || (alignment != 0 && TYPE_RAW_ALIGN (type) != 0
17039 && alignment != TYPE_RAW_ALIGN (type))
17040 || addr_class != DW_ADDR_none)
17042 if (gdbarch_address_class_type_flags_p (gdbarch))
17046 type_flags = gdbarch_address_class_type_flags
17047 (gdbarch, byte_size, addr_class);
17048 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
17050 type = make_type_with_address_space (type, type_flags);
17052 else if (TYPE_LENGTH (type) != byte_size)
17054 complaint (_("invalid pointer size %d"), byte_size);
17056 else if (TYPE_RAW_ALIGN (type) != alignment)
17058 complaint (_("Invalid DW_AT_alignment"
17059 " - DIE at %s [in module %s]"),
17060 sect_offset_str (die->sect_off),
17061 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17065 /* Should we also complain about unhandled address classes? */
17069 TYPE_LENGTH (type) = byte_size;
17070 set_type_align (type, alignment);
17071 return set_die_type (die, type, cu);
17074 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17075 the user defined type vector. */
17077 static struct type *
17078 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
17081 struct type *to_type;
17082 struct type *domain;
17084 to_type = die_type (die, cu);
17085 domain = die_containing_type (die, cu);
17087 /* The calls above may have already set the type for this DIE. */
17088 type = get_die_type (die, cu);
17092 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
17093 type = lookup_methodptr_type (to_type);
17094 else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
17096 struct type *new_type
17097 = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
17099 smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
17100 TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
17101 TYPE_VARARGS (to_type));
17102 type = lookup_methodptr_type (new_type);
17105 type = lookup_memberptr_type (to_type, domain);
17107 return set_die_type (die, type, cu);
17110 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17111 the user defined type vector. */
17113 static struct type *
17114 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
17115 enum type_code refcode)
17117 struct comp_unit_head *cu_header = &cu->header;
17118 struct type *type, *target_type;
17119 struct attribute *attr;
17121 gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
17123 target_type = die_type (die, cu);
17125 /* The die_type call above may have already set the type for this DIE. */
17126 type = get_die_type (die, cu);
17130 type = lookup_reference_type (target_type, refcode);
17131 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17134 TYPE_LENGTH (type) = DW_UNSND (attr);
17138 TYPE_LENGTH (type) = cu_header->addr_size;
17140 maybe_set_alignment (cu, die, type);
17141 return set_die_type (die, type, cu);
17144 /* Add the given cv-qualifiers to the element type of the array. GCC
17145 outputs DWARF type qualifiers that apply to an array, not the
17146 element type. But GDB relies on the array element type to carry
17147 the cv-qualifiers. This mimics section 6.7.3 of the C99
17150 static struct type *
17151 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
17152 struct type *base_type, int cnst, int voltl)
17154 struct type *el_type, *inner_array;
17156 base_type = copy_type (base_type);
17157 inner_array = base_type;
17159 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
17161 TYPE_TARGET_TYPE (inner_array) =
17162 copy_type (TYPE_TARGET_TYPE (inner_array));
17163 inner_array = TYPE_TARGET_TYPE (inner_array);
17166 el_type = TYPE_TARGET_TYPE (inner_array);
17167 cnst |= TYPE_CONST (el_type);
17168 voltl |= TYPE_VOLATILE (el_type);
17169 TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
17171 return set_die_type (die, base_type, cu);
17174 static struct type *
17175 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
17177 struct type *base_type, *cv_type;
17179 base_type = die_type (die, cu);
17181 /* The die_type call above may have already set the type for this DIE. */
17182 cv_type = get_die_type (die, cu);
17186 /* In case the const qualifier is applied to an array type, the element type
17187 is so qualified, not the array type (section 6.7.3 of C99). */
17188 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17189 return add_array_cv_type (die, cu, base_type, 1, 0);
17191 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
17192 return set_die_type (die, cv_type, cu);
17195 static struct type *
17196 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
17198 struct type *base_type, *cv_type;
17200 base_type = die_type (die, cu);
17202 /* The die_type call above may have already set the type for this DIE. */
17203 cv_type = get_die_type (die, cu);
17207 /* In case the volatile qualifier is applied to an array type, the
17208 element type is so qualified, not the array type (section 6.7.3
17210 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17211 return add_array_cv_type (die, cu, base_type, 0, 1);
17213 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
17214 return set_die_type (die, cv_type, cu);
17217 /* Handle DW_TAG_restrict_type. */
17219 static struct type *
17220 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
17222 struct type *base_type, *cv_type;
17224 base_type = die_type (die, cu);
17226 /* The die_type call above may have already set the type for this DIE. */
17227 cv_type = get_die_type (die, cu);
17231 cv_type = make_restrict_type (base_type);
17232 return set_die_type (die, cv_type, cu);
17235 /* Handle DW_TAG_atomic_type. */
17237 static struct type *
17238 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
17240 struct type *base_type, *cv_type;
17242 base_type = die_type (die, cu);
17244 /* The die_type call above may have already set the type for this DIE. */
17245 cv_type = get_die_type (die, cu);
17249 cv_type = make_atomic_type (base_type);
17250 return set_die_type (die, cv_type, cu);
17253 /* Extract all information from a DW_TAG_string_type DIE and add to
17254 the user defined type vector. It isn't really a user defined type,
17255 but it behaves like one, with other DIE's using an AT_user_def_type
17256 attribute to reference it. */
17258 static struct type *
17259 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
17261 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17262 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17263 struct type *type, *range_type, *index_type, *char_type;
17264 struct attribute *attr;
17265 unsigned int length;
17267 attr = dwarf2_attr (die, DW_AT_string_length, cu);
17270 length = DW_UNSND (attr);
17274 /* Check for the DW_AT_byte_size attribute. */
17275 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17278 length = DW_UNSND (attr);
17286 index_type = objfile_type (objfile)->builtin_int;
17287 range_type = create_static_range_type (NULL, index_type, 1, length);
17288 char_type = language_string_char_type (cu->language_defn, gdbarch);
17289 type = create_string_type (NULL, char_type, range_type);
17291 return set_die_type (die, type, cu);
17294 /* Assuming that DIE corresponds to a function, returns nonzero
17295 if the function is prototyped. */
17298 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
17300 struct attribute *attr;
17302 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
17303 if (attr && (DW_UNSND (attr) != 0))
17306 /* The DWARF standard implies that the DW_AT_prototyped attribute
17307 is only meaninful for C, but the concept also extends to other
17308 languages that allow unprototyped functions (Eg: Objective C).
17309 For all other languages, assume that functions are always
17311 if (cu->language != language_c
17312 && cu->language != language_objc
17313 && cu->language != language_opencl)
17316 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17317 prototyped and unprototyped functions; default to prototyped,
17318 since that is more common in modern code (and RealView warns
17319 about unprototyped functions). */
17320 if (producer_is_realview (cu->producer))
17326 /* Handle DIES due to C code like:
17330 int (*funcp)(int a, long l);
17334 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17336 static struct type *
17337 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
17339 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17340 struct type *type; /* Type that this function returns. */
17341 struct type *ftype; /* Function that returns above type. */
17342 struct attribute *attr;
17344 type = die_type (die, cu);
17346 /* The die_type call above may have already set the type for this DIE. */
17347 ftype = get_die_type (die, cu);
17351 ftype = lookup_function_type (type);
17353 if (prototyped_function_p (die, cu))
17354 TYPE_PROTOTYPED (ftype) = 1;
17356 /* Store the calling convention in the type if it's available in
17357 the subroutine die. Otherwise set the calling convention to
17358 the default value DW_CC_normal. */
17359 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
17361 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
17362 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
17363 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
17365 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
17367 /* Record whether the function returns normally to its caller or not
17368 if the DWARF producer set that information. */
17369 attr = dwarf2_attr (die, DW_AT_noreturn, cu);
17370 if (attr && (DW_UNSND (attr) != 0))
17371 TYPE_NO_RETURN (ftype) = 1;
17373 /* We need to add the subroutine type to the die immediately so
17374 we don't infinitely recurse when dealing with parameters
17375 declared as the same subroutine type. */
17376 set_die_type (die, ftype, cu);
17378 if (die->child != NULL)
17380 struct type *void_type = objfile_type (objfile)->builtin_void;
17381 struct die_info *child_die;
17382 int nparams, iparams;
17384 /* Count the number of parameters.
17385 FIXME: GDB currently ignores vararg functions, but knows about
17386 vararg member functions. */
17388 child_die = die->child;
17389 while (child_die && child_die->tag)
17391 if (child_die->tag == DW_TAG_formal_parameter)
17393 else if (child_die->tag == DW_TAG_unspecified_parameters)
17394 TYPE_VARARGS (ftype) = 1;
17395 child_die = sibling_die (child_die);
17398 /* Allocate storage for parameters and fill them in. */
17399 TYPE_NFIELDS (ftype) = nparams;
17400 TYPE_FIELDS (ftype) = (struct field *)
17401 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
17403 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17404 even if we error out during the parameters reading below. */
17405 for (iparams = 0; iparams < nparams; iparams++)
17406 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
17409 child_die = die->child;
17410 while (child_die && child_die->tag)
17412 if (child_die->tag == DW_TAG_formal_parameter)
17414 struct type *arg_type;
17416 /* DWARF version 2 has no clean way to discern C++
17417 static and non-static member functions. G++ helps
17418 GDB by marking the first parameter for non-static
17419 member functions (which is the this pointer) as
17420 artificial. We pass this information to
17421 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17423 DWARF version 3 added DW_AT_object_pointer, which GCC
17424 4.5 does not yet generate. */
17425 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
17427 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
17429 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
17430 arg_type = die_type (child_die, cu);
17432 /* RealView does not mark THIS as const, which the testsuite
17433 expects. GCC marks THIS as const in method definitions,
17434 but not in the class specifications (GCC PR 43053). */
17435 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
17436 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
17439 struct dwarf2_cu *arg_cu = cu;
17440 const char *name = dwarf2_name (child_die, cu);
17442 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
17445 /* If the compiler emits this, use it. */
17446 if (follow_die_ref (die, attr, &arg_cu) == child_die)
17449 else if (name && strcmp (name, "this") == 0)
17450 /* Function definitions will have the argument names. */
17452 else if (name == NULL && iparams == 0)
17453 /* Declarations may not have the names, so like
17454 elsewhere in GDB, assume an artificial first
17455 argument is "this". */
17459 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
17463 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
17466 child_die = sibling_die (child_die);
17473 static struct type *
17474 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
17476 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17477 const char *name = NULL;
17478 struct type *this_type, *target_type;
17480 name = dwarf2_full_name (NULL, die, cu);
17481 this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
17482 TYPE_TARGET_STUB (this_type) = 1;
17483 set_die_type (die, this_type, cu);
17484 target_type = die_type (die, cu);
17485 if (target_type != this_type)
17486 TYPE_TARGET_TYPE (this_type) = target_type;
17489 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17490 spec and cause infinite loops in GDB. */
17491 complaint (_("Self-referential DW_TAG_typedef "
17492 "- DIE at %s [in module %s]"),
17493 sect_offset_str (die->sect_off), objfile_name (objfile));
17494 TYPE_TARGET_TYPE (this_type) = NULL;
17499 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17500 (which may be different from NAME) to the architecture back-end to allow
17501 it to guess the correct format if necessary. */
17503 static struct type *
17504 dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
17505 const char *name_hint)
17507 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17508 const struct floatformat **format;
17511 format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
17513 type = init_float_type (objfile, bits, name, format);
17515 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17520 /* Allocate an integer type of size BITS and name NAME. */
17522 static struct type *
17523 dwarf2_init_integer_type (struct dwarf2_cu *cu, struct objfile *objfile,
17524 int bits, int unsigned_p, const char *name)
17528 /* Versions of Intel's C Compiler generate an integer type called "void"
17529 instead of using DW_TAG_unspecified_type. This has been seen on
17530 at least versions 14, 17, and 18. */
17531 if (bits == 0 && producer_is_icc (cu) && name != nullptr
17532 && strcmp (name, "void") == 0)
17533 type = objfile_type (objfile)->builtin_void;
17535 type = init_integer_type (objfile, bits, unsigned_p, name);
17540 /* Find a representation of a given base type and install
17541 it in the TYPE field of the die. */
17543 static struct type *
17544 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
17546 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17548 struct attribute *attr;
17549 int encoding = 0, bits = 0;
17552 attr = dwarf2_attr (die, DW_AT_encoding, cu);
17555 encoding = DW_UNSND (attr);
17557 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17560 bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
17562 name = dwarf2_name (die, cu);
17565 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17570 case DW_ATE_address:
17571 /* Turn DW_ATE_address into a void * pointer. */
17572 type = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
17573 type = init_pointer_type (objfile, bits, name, type);
17575 case DW_ATE_boolean:
17576 type = init_boolean_type (objfile, bits, 1, name);
17578 case DW_ATE_complex_float:
17579 type = dwarf2_init_float_type (objfile, bits / 2, NULL, name);
17580 type = init_complex_type (objfile, name, type);
17582 case DW_ATE_decimal_float:
17583 type = init_decfloat_type (objfile, bits, name);
17586 type = dwarf2_init_float_type (objfile, bits, name, name);
17588 case DW_ATE_signed:
17589 type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17591 case DW_ATE_unsigned:
17592 if (cu->language == language_fortran
17594 && startswith (name, "character("))
17595 type = init_character_type (objfile, bits, 1, name);
17597 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17599 case DW_ATE_signed_char:
17600 if (cu->language == language_ada || cu->language == language_m2
17601 || cu->language == language_pascal
17602 || cu->language == language_fortran)
17603 type = init_character_type (objfile, bits, 0, name);
17605 type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17607 case DW_ATE_unsigned_char:
17608 if (cu->language == language_ada || cu->language == language_m2
17609 || cu->language == language_pascal
17610 || cu->language == language_fortran
17611 || cu->language == language_rust)
17612 type = init_character_type (objfile, bits, 1, name);
17614 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17618 gdbarch *arch = get_objfile_arch (objfile);
17621 type = builtin_type (arch)->builtin_char16;
17622 else if (bits == 32)
17623 type = builtin_type (arch)->builtin_char32;
17626 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17628 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17630 return set_die_type (die, type, cu);
17635 complaint (_("unsupported DW_AT_encoding: '%s'"),
17636 dwarf_type_encoding_name (encoding));
17637 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17641 if (name && strcmp (name, "char") == 0)
17642 TYPE_NOSIGN (type) = 1;
17644 maybe_set_alignment (cu, die, type);
17646 return set_die_type (die, type, cu);
17649 /* Parse dwarf attribute if it's a block, reference or constant and put the
17650 resulting value of the attribute into struct bound_prop.
17651 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17654 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
17655 struct dwarf2_cu *cu, struct dynamic_prop *prop)
17657 struct dwarf2_property_baton *baton;
17658 struct obstack *obstack
17659 = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
17661 if (attr == NULL || prop == NULL)
17664 if (attr_form_is_block (attr))
17666 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17667 baton->referenced_type = NULL;
17668 baton->locexpr.per_cu = cu->per_cu;
17669 baton->locexpr.size = DW_BLOCK (attr)->size;
17670 baton->locexpr.data = DW_BLOCK (attr)->data;
17671 prop->data.baton = baton;
17672 prop->kind = PROP_LOCEXPR;
17673 gdb_assert (prop->data.baton != NULL);
17675 else if (attr_form_is_ref (attr))
17677 struct dwarf2_cu *target_cu = cu;
17678 struct die_info *target_die;
17679 struct attribute *target_attr;
17681 target_die = follow_die_ref (die, attr, &target_cu);
17682 target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
17683 if (target_attr == NULL)
17684 target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
17686 if (target_attr == NULL)
17689 switch (target_attr->name)
17691 case DW_AT_location:
17692 if (attr_form_is_section_offset (target_attr))
17694 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17695 baton->referenced_type = die_type (target_die, target_cu);
17696 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
17697 prop->data.baton = baton;
17698 prop->kind = PROP_LOCLIST;
17699 gdb_assert (prop->data.baton != NULL);
17701 else if (attr_form_is_block (target_attr))
17703 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17704 baton->referenced_type = die_type (target_die, target_cu);
17705 baton->locexpr.per_cu = cu->per_cu;
17706 baton->locexpr.size = DW_BLOCK (target_attr)->size;
17707 baton->locexpr.data = DW_BLOCK (target_attr)->data;
17708 prop->data.baton = baton;
17709 prop->kind = PROP_LOCEXPR;
17710 gdb_assert (prop->data.baton != NULL);
17714 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17715 "dynamic property");
17719 case DW_AT_data_member_location:
17723 if (!handle_data_member_location (target_die, target_cu,
17727 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17728 baton->referenced_type = read_type_die (target_die->parent,
17730 baton->offset_info.offset = offset;
17731 baton->offset_info.type = die_type (target_die, target_cu);
17732 prop->data.baton = baton;
17733 prop->kind = PROP_ADDR_OFFSET;
17738 else if (attr_form_is_constant (attr))
17740 prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
17741 prop->kind = PROP_CONST;
17745 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
17746 dwarf2_name (die, cu));
17753 /* Read the given DW_AT_subrange DIE. */
17755 static struct type *
17756 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
17758 struct type *base_type, *orig_base_type;
17759 struct type *range_type;
17760 struct attribute *attr;
17761 struct dynamic_prop low, high;
17762 int low_default_is_valid;
17763 int high_bound_is_count = 0;
17765 ULONGEST negative_mask;
17767 orig_base_type = die_type (die, cu);
17768 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17769 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17770 creating the range type, but we use the result of check_typedef
17771 when examining properties of the type. */
17772 base_type = check_typedef (orig_base_type);
17774 /* The die_type call above may have already set the type for this DIE. */
17775 range_type = get_die_type (die, cu);
17779 low.kind = PROP_CONST;
17780 high.kind = PROP_CONST;
17781 high.data.const_val = 0;
17783 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17784 omitting DW_AT_lower_bound. */
17785 switch (cu->language)
17788 case language_cplus:
17789 low.data.const_val = 0;
17790 low_default_is_valid = 1;
17792 case language_fortran:
17793 low.data.const_val = 1;
17794 low_default_is_valid = 1;
17797 case language_objc:
17798 case language_rust:
17799 low.data.const_val = 0;
17800 low_default_is_valid = (cu->header.version >= 4);
17804 case language_pascal:
17805 low.data.const_val = 1;
17806 low_default_is_valid = (cu->header.version >= 4);
17809 low.data.const_val = 0;
17810 low_default_is_valid = 0;
17814 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
17816 attr_to_dynamic_prop (attr, die, cu, &low);
17817 else if (!low_default_is_valid)
17818 complaint (_("Missing DW_AT_lower_bound "
17819 "- DIE at %s [in module %s]"),
17820 sect_offset_str (die->sect_off),
17821 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17823 struct attribute *attr_ub, *attr_count;
17824 attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);
17825 if (!attr_to_dynamic_prop (attr, die, cu, &high))
17827 attr = attr_count = dwarf2_attr (die, DW_AT_count, cu);
17828 if (attr_to_dynamic_prop (attr, die, cu, &high))
17830 /* If bounds are constant do the final calculation here. */
17831 if (low.kind == PROP_CONST && high.kind == PROP_CONST)
17832 high.data.const_val = low.data.const_val + high.data.const_val - 1;
17834 high_bound_is_count = 1;
17838 if (attr_ub != NULL)
17839 complaint (_("Unresolved DW_AT_upper_bound "
17840 "- DIE at %s [in module %s]"),
17841 sect_offset_str (die->sect_off),
17842 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17843 if (attr_count != NULL)
17844 complaint (_("Unresolved DW_AT_count "
17845 "- DIE at %s [in module %s]"),
17846 sect_offset_str (die->sect_off),
17847 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17852 /* Dwarf-2 specifications explicitly allows to create subrange types
17853 without specifying a base type.
17854 In that case, the base type must be set to the type of
17855 the lower bound, upper bound or count, in that order, if any of these
17856 three attributes references an object that has a type.
17857 If no base type is found, the Dwarf-2 specifications say that
17858 a signed integer type of size equal to the size of an address should
17860 For the following C code: `extern char gdb_int [];'
17861 GCC produces an empty range DIE.
17862 FIXME: muller/2010-05-28: Possible references to object for low bound,
17863 high bound or count are not yet handled by this code. */
17864 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
17866 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17867 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17868 int addr_size = gdbarch_addr_bit (gdbarch) /8;
17869 struct type *int_type = objfile_type (objfile)->builtin_int;
17871 /* Test "int", "long int", and "long long int" objfile types,
17872 and select the first one having a size above or equal to the
17873 architecture address size. */
17874 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17875 base_type = int_type;
17878 int_type = objfile_type (objfile)->builtin_long;
17879 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17880 base_type = int_type;
17883 int_type = objfile_type (objfile)->builtin_long_long;
17884 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17885 base_type = int_type;
17890 /* Normally, the DWARF producers are expected to use a signed
17891 constant form (Eg. DW_FORM_sdata) to express negative bounds.
17892 But this is unfortunately not always the case, as witnessed
17893 with GCC, for instance, where the ambiguous DW_FORM_dataN form
17894 is used instead. To work around that ambiguity, we treat
17895 the bounds as signed, and thus sign-extend their values, when
17896 the base type is signed. */
17898 -((ULONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
17899 if (low.kind == PROP_CONST
17900 && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
17901 low.data.const_val |= negative_mask;
17902 if (high.kind == PROP_CONST
17903 && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
17904 high.data.const_val |= negative_mask;
17906 range_type = create_range_type (NULL, orig_base_type, &low, &high);
17908 if (high_bound_is_count)
17909 TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
17911 /* Ada expects an empty array on no boundary attributes. */
17912 if (attr == NULL && cu->language != language_ada)
17913 TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
17915 name = dwarf2_name (die, cu);
17917 TYPE_NAME (range_type) = name;
17919 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17921 TYPE_LENGTH (range_type) = DW_UNSND (attr);
17923 maybe_set_alignment (cu, die, range_type);
17925 set_die_type (die, range_type, cu);
17927 /* set_die_type should be already done. */
17928 set_descriptive_type (range_type, die, cu);
17933 static struct type *
17934 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
17938 type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
17940 TYPE_NAME (type) = dwarf2_name (die, cu);
17942 /* In Ada, an unspecified type is typically used when the description
17943 of the type is defered to a different unit. When encountering
17944 such a type, we treat it as a stub, and try to resolve it later on,
17946 if (cu->language == language_ada)
17947 TYPE_STUB (type) = 1;
17949 return set_die_type (die, type, cu);
17952 /* Read a single die and all its descendents. Set the die's sibling
17953 field to NULL; set other fields in the die correctly, and set all
17954 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
17955 location of the info_ptr after reading all of those dies. PARENT
17956 is the parent of the die in question. */
17958 static struct die_info *
17959 read_die_and_children (const struct die_reader_specs *reader,
17960 const gdb_byte *info_ptr,
17961 const gdb_byte **new_info_ptr,
17962 struct die_info *parent)
17964 struct die_info *die;
17965 const gdb_byte *cur_ptr;
17968 cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
17971 *new_info_ptr = cur_ptr;
17974 store_in_ref_table (die, reader->cu);
17977 die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
17981 *new_info_ptr = cur_ptr;
17984 die->sibling = NULL;
17985 die->parent = parent;
17989 /* Read a die, all of its descendents, and all of its siblings; set
17990 all of the fields of all of the dies correctly. Arguments are as
17991 in read_die_and_children. */
17993 static struct die_info *
17994 read_die_and_siblings_1 (const struct die_reader_specs *reader,
17995 const gdb_byte *info_ptr,
17996 const gdb_byte **new_info_ptr,
17997 struct die_info *parent)
17999 struct die_info *first_die, *last_sibling;
18000 const gdb_byte *cur_ptr;
18002 cur_ptr = info_ptr;
18003 first_die = last_sibling = NULL;
18007 struct die_info *die
18008 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
18012 *new_info_ptr = cur_ptr;
18019 last_sibling->sibling = die;
18021 last_sibling = die;
18025 /* Read a die, all of its descendents, and all of its siblings; set
18026 all of the fields of all of the dies correctly. Arguments are as
18027 in read_die_and_children.
18028 This the main entry point for reading a DIE and all its children. */
18030 static struct die_info *
18031 read_die_and_siblings (const struct die_reader_specs *reader,
18032 const gdb_byte *info_ptr,
18033 const gdb_byte **new_info_ptr,
18034 struct die_info *parent)
18036 struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
18037 new_info_ptr, parent);
18039 if (dwarf_die_debug)
18041 fprintf_unfiltered (gdb_stdlog,
18042 "Read die from %s@0x%x of %s:\n",
18043 get_section_name (reader->die_section),
18044 (unsigned) (info_ptr - reader->die_section->buffer),
18045 bfd_get_filename (reader->abfd));
18046 dump_die (die, dwarf_die_debug);
18052 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18054 The caller is responsible for filling in the extra attributes
18055 and updating (*DIEP)->num_attrs.
18056 Set DIEP to point to a newly allocated die with its information,
18057 except for its child, sibling, and parent fields.
18058 Set HAS_CHILDREN to tell whether the die has children or not. */
18060 static const gdb_byte *
18061 read_full_die_1 (const struct die_reader_specs *reader,
18062 struct die_info **diep, const gdb_byte *info_ptr,
18063 int *has_children, int num_extra_attrs)
18065 unsigned int abbrev_number, bytes_read, i;
18066 struct abbrev_info *abbrev;
18067 struct die_info *die;
18068 struct dwarf2_cu *cu = reader->cu;
18069 bfd *abfd = reader->abfd;
18071 sect_offset sect_off = (sect_offset) (info_ptr - reader->buffer);
18072 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
18073 info_ptr += bytes_read;
18074 if (!abbrev_number)
18081 abbrev = reader->abbrev_table->lookup_abbrev (abbrev_number);
18083 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18085 bfd_get_filename (abfd));
18087 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
18088 die->sect_off = sect_off;
18089 die->tag = abbrev->tag;
18090 die->abbrev = abbrev_number;
18092 /* Make the result usable.
18093 The caller needs to update num_attrs after adding the extra
18095 die->num_attrs = abbrev->num_attrs;
18097 for (i = 0; i < abbrev->num_attrs; ++i)
18098 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
18102 *has_children = abbrev->has_children;
18106 /* Read a die and all its attributes.
18107 Set DIEP to point to a newly allocated die with its information,
18108 except for its child, sibling, and parent fields.
18109 Set HAS_CHILDREN to tell whether the die has children or not. */
18111 static const gdb_byte *
18112 read_full_die (const struct die_reader_specs *reader,
18113 struct die_info **diep, const gdb_byte *info_ptr,
18116 const gdb_byte *result;
18118 result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
18120 if (dwarf_die_debug)
18122 fprintf_unfiltered (gdb_stdlog,
18123 "Read die from %s@0x%x of %s:\n",
18124 get_section_name (reader->die_section),
18125 (unsigned) (info_ptr - reader->die_section->buffer),
18126 bfd_get_filename (reader->abfd));
18127 dump_die (*diep, dwarf_die_debug);
18133 /* Abbreviation tables.
18135 In DWARF version 2, the description of the debugging information is
18136 stored in a separate .debug_abbrev section. Before we read any
18137 dies from a section we read in all abbreviations and install them
18138 in a hash table. */
18140 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18142 struct abbrev_info *
18143 abbrev_table::alloc_abbrev ()
18145 struct abbrev_info *abbrev;
18147 abbrev = XOBNEW (&abbrev_obstack, struct abbrev_info);
18148 memset (abbrev, 0, sizeof (struct abbrev_info));
18153 /* Add an abbreviation to the table. */
18156 abbrev_table::add_abbrev (unsigned int abbrev_number,
18157 struct abbrev_info *abbrev)
18159 unsigned int hash_number;
18161 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18162 abbrev->next = m_abbrevs[hash_number];
18163 m_abbrevs[hash_number] = abbrev;
18166 /* Look up an abbrev in the table.
18167 Returns NULL if the abbrev is not found. */
18169 struct abbrev_info *
18170 abbrev_table::lookup_abbrev (unsigned int abbrev_number)
18172 unsigned int hash_number;
18173 struct abbrev_info *abbrev;
18175 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18176 abbrev = m_abbrevs[hash_number];
18180 if (abbrev->number == abbrev_number)
18182 abbrev = abbrev->next;
18187 /* Read in an abbrev table. */
18189 static abbrev_table_up
18190 abbrev_table_read_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
18191 struct dwarf2_section_info *section,
18192 sect_offset sect_off)
18194 struct objfile *objfile = dwarf2_per_objfile->objfile;
18195 bfd *abfd = get_section_bfd_owner (section);
18196 const gdb_byte *abbrev_ptr;
18197 struct abbrev_info *cur_abbrev;
18198 unsigned int abbrev_number, bytes_read, abbrev_name;
18199 unsigned int abbrev_form;
18200 struct attr_abbrev *cur_attrs;
18201 unsigned int allocated_attrs;
18203 abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
18205 dwarf2_read_section (objfile, section);
18206 abbrev_ptr = section->buffer + to_underlying (sect_off);
18207 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18208 abbrev_ptr += bytes_read;
18210 allocated_attrs = ATTR_ALLOC_CHUNK;
18211 cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
18213 /* Loop until we reach an abbrev number of 0. */
18214 while (abbrev_number)
18216 cur_abbrev = abbrev_table->alloc_abbrev ();
18218 /* read in abbrev header */
18219 cur_abbrev->number = abbrev_number;
18221 = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18222 abbrev_ptr += bytes_read;
18223 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
18226 /* now read in declarations */
18229 LONGEST implicit_const;
18231 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18232 abbrev_ptr += bytes_read;
18233 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18234 abbrev_ptr += bytes_read;
18235 if (abbrev_form == DW_FORM_implicit_const)
18237 implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
18239 abbrev_ptr += bytes_read;
18243 /* Initialize it due to a false compiler warning. */
18244 implicit_const = -1;
18247 if (abbrev_name == 0)
18250 if (cur_abbrev->num_attrs == allocated_attrs)
18252 allocated_attrs += ATTR_ALLOC_CHUNK;
18254 = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
18257 cur_attrs[cur_abbrev->num_attrs].name
18258 = (enum dwarf_attribute) abbrev_name;
18259 cur_attrs[cur_abbrev->num_attrs].form
18260 = (enum dwarf_form) abbrev_form;
18261 cur_attrs[cur_abbrev->num_attrs].implicit_const = implicit_const;
18262 ++cur_abbrev->num_attrs;
18265 cur_abbrev->attrs =
18266 XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
18267 cur_abbrev->num_attrs);
18268 memcpy (cur_abbrev->attrs, cur_attrs,
18269 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
18271 abbrev_table->add_abbrev (abbrev_number, cur_abbrev);
18273 /* Get next abbreviation.
18274 Under Irix6 the abbreviations for a compilation unit are not
18275 always properly terminated with an abbrev number of 0.
18276 Exit loop if we encounter an abbreviation which we have
18277 already read (which means we are about to read the abbreviations
18278 for the next compile unit) or if the end of the abbreviation
18279 table is reached. */
18280 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
18282 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18283 abbrev_ptr += bytes_read;
18284 if (abbrev_table->lookup_abbrev (abbrev_number) != NULL)
18289 return abbrev_table;
18292 /* Returns nonzero if TAG represents a type that we might generate a partial
18296 is_type_tag_for_partial (int tag)
18301 /* Some types that would be reasonable to generate partial symbols for,
18302 that we don't at present. */
18303 case DW_TAG_array_type:
18304 case DW_TAG_file_type:
18305 case DW_TAG_ptr_to_member_type:
18306 case DW_TAG_set_type:
18307 case DW_TAG_string_type:
18308 case DW_TAG_subroutine_type:
18310 case DW_TAG_base_type:
18311 case DW_TAG_class_type:
18312 case DW_TAG_interface_type:
18313 case DW_TAG_enumeration_type:
18314 case DW_TAG_structure_type:
18315 case DW_TAG_subrange_type:
18316 case DW_TAG_typedef:
18317 case DW_TAG_union_type:
18324 /* Load all DIEs that are interesting for partial symbols into memory. */
18326 static struct partial_die_info *
18327 load_partial_dies (const struct die_reader_specs *reader,
18328 const gdb_byte *info_ptr, int building_psymtab)
18330 struct dwarf2_cu *cu = reader->cu;
18331 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18332 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
18333 unsigned int bytes_read;
18334 unsigned int load_all = 0;
18335 int nesting_level = 1;
18340 gdb_assert (cu->per_cu != NULL);
18341 if (cu->per_cu->load_all_dies)
18345 = htab_create_alloc_ex (cu->header.length / 12,
18349 &cu->comp_unit_obstack,
18350 hashtab_obstack_allocate,
18351 dummy_obstack_deallocate);
18355 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
18357 /* A NULL abbrev means the end of a series of children. */
18358 if (abbrev == NULL)
18360 if (--nesting_level == 0)
18363 info_ptr += bytes_read;
18364 last_die = parent_die;
18365 parent_die = parent_die->die_parent;
18369 /* Check for template arguments. We never save these; if
18370 they're seen, we just mark the parent, and go on our way. */
18371 if (parent_die != NULL
18372 && cu->language == language_cplus
18373 && (abbrev->tag == DW_TAG_template_type_param
18374 || abbrev->tag == DW_TAG_template_value_param))
18376 parent_die->has_template_arguments = 1;
18380 /* We don't need a partial DIE for the template argument. */
18381 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18386 /* We only recurse into c++ subprograms looking for template arguments.
18387 Skip their other children. */
18389 && cu->language == language_cplus
18390 && parent_die != NULL
18391 && parent_die->tag == DW_TAG_subprogram)
18393 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18397 /* Check whether this DIE is interesting enough to save. Normally
18398 we would not be interested in members here, but there may be
18399 later variables referencing them via DW_AT_specification (for
18400 static members). */
18402 && !is_type_tag_for_partial (abbrev->tag)
18403 && abbrev->tag != DW_TAG_constant
18404 && abbrev->tag != DW_TAG_enumerator
18405 && abbrev->tag != DW_TAG_subprogram
18406 && abbrev->tag != DW_TAG_inlined_subroutine
18407 && abbrev->tag != DW_TAG_lexical_block
18408 && abbrev->tag != DW_TAG_variable
18409 && abbrev->tag != DW_TAG_namespace
18410 && abbrev->tag != DW_TAG_module
18411 && abbrev->tag != DW_TAG_member
18412 && abbrev->tag != DW_TAG_imported_unit
18413 && abbrev->tag != DW_TAG_imported_declaration)
18415 /* Otherwise we skip to the next sibling, if any. */
18416 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18420 struct partial_die_info pdi ((sect_offset) (info_ptr - reader->buffer),
18423 info_ptr = pdi.read (reader, *abbrev, info_ptr + bytes_read);
18425 /* This two-pass algorithm for processing partial symbols has a
18426 high cost in cache pressure. Thus, handle some simple cases
18427 here which cover the majority of C partial symbols. DIEs
18428 which neither have specification tags in them, nor could have
18429 specification tags elsewhere pointing at them, can simply be
18430 processed and discarded.
18432 This segment is also optional; scan_partial_symbols and
18433 add_partial_symbol will handle these DIEs if we chain
18434 them in normally. When compilers which do not emit large
18435 quantities of duplicate debug information are more common,
18436 this code can probably be removed. */
18438 /* Any complete simple types at the top level (pretty much all
18439 of them, for a language without namespaces), can be processed
18441 if (parent_die == NULL
18442 && pdi.has_specification == 0
18443 && pdi.is_declaration == 0
18444 && ((pdi.tag == DW_TAG_typedef && !pdi.has_children)
18445 || pdi.tag == DW_TAG_base_type
18446 || pdi.tag == DW_TAG_subrange_type))
18448 if (building_psymtab && pdi.name != NULL)
18449 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18450 VAR_DOMAIN, LOC_TYPEDEF, -1,
18451 &objfile->static_psymbols,
18452 0, cu->language, objfile);
18453 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18457 /* The exception for DW_TAG_typedef with has_children above is
18458 a workaround of GCC PR debug/47510. In the case of this complaint
18459 type_name_or_error will error on such types later.
18461 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18462 it could not find the child DIEs referenced later, this is checked
18463 above. In correct DWARF DW_TAG_typedef should have no children. */
18465 if (pdi.tag == DW_TAG_typedef && pdi.has_children)
18466 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18467 "- DIE at %s [in module %s]"),
18468 sect_offset_str (pdi.sect_off), objfile_name (objfile));
18470 /* If we're at the second level, and we're an enumerator, and
18471 our parent has no specification (meaning possibly lives in a
18472 namespace elsewhere), then we can add the partial symbol now
18473 instead of queueing it. */
18474 if (pdi.tag == DW_TAG_enumerator
18475 && parent_die != NULL
18476 && parent_die->die_parent == NULL
18477 && parent_die->tag == DW_TAG_enumeration_type
18478 && parent_die->has_specification == 0)
18480 if (pdi.name == NULL)
18481 complaint (_("malformed enumerator DIE ignored"));
18482 else if (building_psymtab)
18483 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18484 VAR_DOMAIN, LOC_CONST, -1,
18485 cu->language == language_cplus
18486 ? &objfile->global_psymbols
18487 : &objfile->static_psymbols,
18488 0, cu->language, objfile);
18490 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18494 struct partial_die_info *part_die
18495 = new (&cu->comp_unit_obstack) partial_die_info (pdi);
18497 /* We'll save this DIE so link it in. */
18498 part_die->die_parent = parent_die;
18499 part_die->die_sibling = NULL;
18500 part_die->die_child = NULL;
18502 if (last_die && last_die == parent_die)
18503 last_die->die_child = part_die;
18505 last_die->die_sibling = part_die;
18507 last_die = part_die;
18509 if (first_die == NULL)
18510 first_die = part_die;
18512 /* Maybe add the DIE to the hash table. Not all DIEs that we
18513 find interesting need to be in the hash table, because we
18514 also have the parent/sibling/child chains; only those that we
18515 might refer to by offset later during partial symbol reading.
18517 For now this means things that might have be the target of a
18518 DW_AT_specification, DW_AT_abstract_origin, or
18519 DW_AT_extension. DW_AT_extension will refer only to
18520 namespaces; DW_AT_abstract_origin refers to functions (and
18521 many things under the function DIE, but we do not recurse
18522 into function DIEs during partial symbol reading) and
18523 possibly variables as well; DW_AT_specification refers to
18524 declarations. Declarations ought to have the DW_AT_declaration
18525 flag. It happens that GCC forgets to put it in sometimes, but
18526 only for functions, not for types.
18528 Adding more things than necessary to the hash table is harmless
18529 except for the performance cost. Adding too few will result in
18530 wasted time in find_partial_die, when we reread the compilation
18531 unit with load_all_dies set. */
18534 || abbrev->tag == DW_TAG_constant
18535 || abbrev->tag == DW_TAG_subprogram
18536 || abbrev->tag == DW_TAG_variable
18537 || abbrev->tag == DW_TAG_namespace
18538 || part_die->is_declaration)
18542 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
18543 to_underlying (part_die->sect_off),
18548 /* For some DIEs we want to follow their children (if any). For C
18549 we have no reason to follow the children of structures; for other
18550 languages we have to, so that we can get at method physnames
18551 to infer fully qualified class names, for DW_AT_specification,
18552 and for C++ template arguments. For C++, we also look one level
18553 inside functions to find template arguments (if the name of the
18554 function does not already contain the template arguments).
18556 For Ada, we need to scan the children of subprograms and lexical
18557 blocks as well because Ada allows the definition of nested
18558 entities that could be interesting for the debugger, such as
18559 nested subprograms for instance. */
18560 if (last_die->has_children
18562 || last_die->tag == DW_TAG_namespace
18563 || last_die->tag == DW_TAG_module
18564 || last_die->tag == DW_TAG_enumeration_type
18565 || (cu->language == language_cplus
18566 && last_die->tag == DW_TAG_subprogram
18567 && (last_die->name == NULL
18568 || strchr (last_die->name, '<') == NULL))
18569 || (cu->language != language_c
18570 && (last_die->tag == DW_TAG_class_type
18571 || last_die->tag == DW_TAG_interface_type
18572 || last_die->tag == DW_TAG_structure_type
18573 || last_die->tag == DW_TAG_union_type))
18574 || (cu->language == language_ada
18575 && (last_die->tag == DW_TAG_subprogram
18576 || last_die->tag == DW_TAG_lexical_block))))
18579 parent_die = last_die;
18583 /* Otherwise we skip to the next sibling, if any. */
18584 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
18586 /* Back to the top, do it again. */
18590 partial_die_info::partial_die_info (sect_offset sect_off_,
18591 struct abbrev_info *abbrev)
18592 : partial_die_info (sect_off_, abbrev->tag, abbrev->has_children)
18596 /* Read a minimal amount of information into the minimal die structure.
18597 INFO_PTR should point just after the initial uleb128 of a DIE. */
18600 partial_die_info::read (const struct die_reader_specs *reader,
18601 const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
18603 struct dwarf2_cu *cu = reader->cu;
18604 struct dwarf2_per_objfile *dwarf2_per_objfile
18605 = cu->per_cu->dwarf2_per_objfile;
18607 int has_low_pc_attr = 0;
18608 int has_high_pc_attr = 0;
18609 int high_pc_relative = 0;
18611 for (i = 0; i < abbrev.num_attrs; ++i)
18613 struct attribute attr;
18615 info_ptr = read_attribute (reader, &attr, &abbrev.attrs[i], info_ptr);
18617 /* Store the data if it is of an attribute we want to keep in a
18618 partial symbol table. */
18624 case DW_TAG_compile_unit:
18625 case DW_TAG_partial_unit:
18626 case DW_TAG_type_unit:
18627 /* Compilation units have a DW_AT_name that is a filename, not
18628 a source language identifier. */
18629 case DW_TAG_enumeration_type:
18630 case DW_TAG_enumerator:
18631 /* These tags always have simple identifiers already; no need
18632 to canonicalize them. */
18633 name = DW_STRING (&attr);
18637 struct objfile *objfile = dwarf2_per_objfile->objfile;
18640 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
18641 &objfile->per_bfd->storage_obstack);
18646 case DW_AT_linkage_name:
18647 case DW_AT_MIPS_linkage_name:
18648 /* Note that both forms of linkage name might appear. We
18649 assume they will be the same, and we only store the last
18651 if (cu->language == language_ada)
18652 name = DW_STRING (&attr);
18653 linkage_name = DW_STRING (&attr);
18656 has_low_pc_attr = 1;
18657 lowpc = attr_value_as_address (&attr);
18659 case DW_AT_high_pc:
18660 has_high_pc_attr = 1;
18661 highpc = attr_value_as_address (&attr);
18662 if (cu->header.version >= 4 && attr_form_is_constant (&attr))
18663 high_pc_relative = 1;
18665 case DW_AT_location:
18666 /* Support the .debug_loc offsets. */
18667 if (attr_form_is_block (&attr))
18669 d.locdesc = DW_BLOCK (&attr);
18671 else if (attr_form_is_section_offset (&attr))
18673 dwarf2_complex_location_expr_complaint ();
18677 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18678 "partial symbol information");
18681 case DW_AT_external:
18682 is_external = DW_UNSND (&attr);
18684 case DW_AT_declaration:
18685 is_declaration = DW_UNSND (&attr);
18690 case DW_AT_abstract_origin:
18691 case DW_AT_specification:
18692 case DW_AT_extension:
18693 has_specification = 1;
18694 spec_offset = dwarf2_get_ref_die_offset (&attr);
18695 spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18696 || cu->per_cu->is_dwz);
18698 case DW_AT_sibling:
18699 /* Ignore absolute siblings, they might point outside of
18700 the current compile unit. */
18701 if (attr.form == DW_FORM_ref_addr)
18702 complaint (_("ignoring absolute DW_AT_sibling"));
18705 const gdb_byte *buffer = reader->buffer;
18706 sect_offset off = dwarf2_get_ref_die_offset (&attr);
18707 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
18709 if (sibling_ptr < info_ptr)
18710 complaint (_("DW_AT_sibling points backwards"));
18711 else if (sibling_ptr > reader->buffer_end)
18712 dwarf2_section_buffer_overflow_complaint (reader->die_section);
18714 sibling = sibling_ptr;
18717 case DW_AT_byte_size:
18720 case DW_AT_const_value:
18721 has_const_value = 1;
18723 case DW_AT_calling_convention:
18724 /* DWARF doesn't provide a way to identify a program's source-level
18725 entry point. DW_AT_calling_convention attributes are only meant
18726 to describe functions' calling conventions.
18728 However, because it's a necessary piece of information in
18729 Fortran, and before DWARF 4 DW_CC_program was the only
18730 piece of debugging information whose definition refers to
18731 a 'main program' at all, several compilers marked Fortran
18732 main programs with DW_CC_program --- even when those
18733 functions use the standard calling conventions.
18735 Although DWARF now specifies a way to provide this
18736 information, we support this practice for backward
18738 if (DW_UNSND (&attr) == DW_CC_program
18739 && cu->language == language_fortran)
18740 main_subprogram = 1;
18743 if (DW_UNSND (&attr) == DW_INL_inlined
18744 || DW_UNSND (&attr) == DW_INL_declared_inlined)
18745 may_be_inlined = 1;
18749 if (tag == DW_TAG_imported_unit)
18751 d.sect_off = dwarf2_get_ref_die_offset (&attr);
18752 is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18753 || cu->per_cu->is_dwz);
18757 case DW_AT_main_subprogram:
18758 main_subprogram = DW_UNSND (&attr);
18766 if (high_pc_relative)
18769 if (has_low_pc_attr && has_high_pc_attr)
18771 /* When using the GNU linker, .gnu.linkonce. sections are used to
18772 eliminate duplicate copies of functions and vtables and such.
18773 The linker will arbitrarily choose one and discard the others.
18774 The AT_*_pc values for such functions refer to local labels in
18775 these sections. If the section from that file was discarded, the
18776 labels are not in the output, so the relocs get a value of 0.
18777 If this is a discarded function, mark the pc bounds as invalid,
18778 so that GDB will ignore it. */
18779 if (lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
18781 struct objfile *objfile = dwarf2_per_objfile->objfile;
18782 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18784 complaint (_("DW_AT_low_pc %s is zero "
18785 "for DIE at %s [in module %s]"),
18786 paddress (gdbarch, lowpc),
18787 sect_offset_str (sect_off),
18788 objfile_name (objfile));
18790 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18791 else if (lowpc >= highpc)
18793 struct objfile *objfile = dwarf2_per_objfile->objfile;
18794 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18796 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18797 "for DIE at %s [in module %s]"),
18798 paddress (gdbarch, lowpc),
18799 paddress (gdbarch, highpc),
18800 sect_offset_str (sect_off),
18801 objfile_name (objfile));
18810 /* Find a cached partial DIE at OFFSET in CU. */
18812 struct partial_die_info *
18813 dwarf2_cu::find_partial_die (sect_offset sect_off)
18815 struct partial_die_info *lookup_die = NULL;
18816 struct partial_die_info part_die (sect_off);
18818 lookup_die = ((struct partial_die_info *)
18819 htab_find_with_hash (partial_dies, &part_die,
18820 to_underlying (sect_off)));
18825 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18826 except in the case of .debug_types DIEs which do not reference
18827 outside their CU (they do however referencing other types via
18828 DW_FORM_ref_sig8). */
18830 static struct partial_die_info *
18831 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
18833 struct dwarf2_per_objfile *dwarf2_per_objfile
18834 = cu->per_cu->dwarf2_per_objfile;
18835 struct objfile *objfile = dwarf2_per_objfile->objfile;
18836 struct dwarf2_per_cu_data *per_cu = NULL;
18837 struct partial_die_info *pd = NULL;
18839 if (offset_in_dwz == cu->per_cu->is_dwz
18840 && offset_in_cu_p (&cu->header, sect_off))
18842 pd = cu->find_partial_die (sect_off);
18845 /* We missed recording what we needed.
18846 Load all dies and try again. */
18847 per_cu = cu->per_cu;
18851 /* TUs don't reference other CUs/TUs (except via type signatures). */
18852 if (cu->per_cu->is_debug_types)
18854 error (_("Dwarf Error: Type Unit at offset %s contains"
18855 " external reference to offset %s [in module %s].\n"),
18856 sect_offset_str (cu->header.sect_off), sect_offset_str (sect_off),
18857 bfd_get_filename (objfile->obfd));
18859 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
18860 dwarf2_per_objfile);
18862 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
18863 load_partial_comp_unit (per_cu);
18865 per_cu->cu->last_used = 0;
18866 pd = per_cu->cu->find_partial_die (sect_off);
18869 /* If we didn't find it, and not all dies have been loaded,
18870 load them all and try again. */
18872 if (pd == NULL && per_cu->load_all_dies == 0)
18874 per_cu->load_all_dies = 1;
18876 /* This is nasty. When we reread the DIEs, somewhere up the call chain
18877 THIS_CU->cu may already be in use. So we can't just free it and
18878 replace its DIEs with the ones we read in. Instead, we leave those
18879 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18880 and clobber THIS_CU->cu->partial_dies with the hash table for the new
18882 load_partial_comp_unit (per_cu);
18884 pd = per_cu->cu->find_partial_die (sect_off);
18888 internal_error (__FILE__, __LINE__,
18889 _("could not find partial DIE %s "
18890 "in cache [from module %s]\n"),
18891 sect_offset_str (sect_off), bfd_get_filename (objfile->obfd));
18895 /* See if we can figure out if the class lives in a namespace. We do
18896 this by looking for a member function; its demangled name will
18897 contain namespace info, if there is any. */
18900 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
18901 struct dwarf2_cu *cu)
18903 /* NOTE: carlton/2003-10-07: Getting the info this way changes
18904 what template types look like, because the demangler
18905 frequently doesn't give the same name as the debug info. We
18906 could fix this by only using the demangled name to get the
18907 prefix (but see comment in read_structure_type). */
18909 struct partial_die_info *real_pdi;
18910 struct partial_die_info *child_pdi;
18912 /* If this DIE (this DIE's specification, if any) has a parent, then
18913 we should not do this. We'll prepend the parent's fully qualified
18914 name when we create the partial symbol. */
18916 real_pdi = struct_pdi;
18917 while (real_pdi->has_specification)
18918 real_pdi = find_partial_die (real_pdi->spec_offset,
18919 real_pdi->spec_is_dwz, cu);
18921 if (real_pdi->die_parent != NULL)
18924 for (child_pdi = struct_pdi->die_child;
18926 child_pdi = child_pdi->die_sibling)
18928 if (child_pdi->tag == DW_TAG_subprogram
18929 && child_pdi->linkage_name != NULL)
18931 char *actual_class_name
18932 = language_class_name_from_physname (cu->language_defn,
18933 child_pdi->linkage_name);
18934 if (actual_class_name != NULL)
18936 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18939 obstack_copy0 (&objfile->per_bfd->storage_obstack,
18941 strlen (actual_class_name)));
18942 xfree (actual_class_name);
18950 partial_die_info::fixup (struct dwarf2_cu *cu)
18952 /* Once we've fixed up a die, there's no point in doing so again.
18953 This also avoids a memory leak if we were to call
18954 guess_partial_die_structure_name multiple times. */
18958 /* If we found a reference attribute and the DIE has no name, try
18959 to find a name in the referred to DIE. */
18961 if (name == NULL && has_specification)
18963 struct partial_die_info *spec_die;
18965 spec_die = find_partial_die (spec_offset, spec_is_dwz, cu);
18967 spec_die->fixup (cu);
18969 if (spec_die->name)
18971 name = spec_die->name;
18973 /* Copy DW_AT_external attribute if it is set. */
18974 if (spec_die->is_external)
18975 is_external = spec_die->is_external;
18979 /* Set default names for some unnamed DIEs. */
18981 if (name == NULL && tag == DW_TAG_namespace)
18982 name = CP_ANONYMOUS_NAMESPACE_STR;
18984 /* If there is no parent die to provide a namespace, and there are
18985 children, see if we can determine the namespace from their linkage
18987 if (cu->language == language_cplus
18988 && !VEC_empty (dwarf2_section_info_def,
18989 cu->per_cu->dwarf2_per_objfile->types)
18990 && die_parent == NULL
18992 && (tag == DW_TAG_class_type
18993 || tag == DW_TAG_structure_type
18994 || tag == DW_TAG_union_type))
18995 guess_partial_die_structure_name (this, cu);
18997 /* GCC might emit a nameless struct or union that has a linkage
18998 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19000 && (tag == DW_TAG_class_type
19001 || tag == DW_TAG_interface_type
19002 || tag == DW_TAG_structure_type
19003 || tag == DW_TAG_union_type)
19004 && linkage_name != NULL)
19008 demangled = gdb_demangle (linkage_name, DMGL_TYPES);
19013 /* Strip any leading namespaces/classes, keep only the base name.
19014 DW_AT_name for named DIEs does not contain the prefixes. */
19015 base = strrchr (demangled, ':');
19016 if (base && base > demangled && base[-1] == ':')
19021 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
19024 obstack_copy0 (&objfile->per_bfd->storage_obstack,
19025 base, strlen (base)));
19033 /* Read an attribute value described by an attribute form. */
19035 static const gdb_byte *
19036 read_attribute_value (const struct die_reader_specs *reader,
19037 struct attribute *attr, unsigned form,
19038 LONGEST implicit_const, const gdb_byte *info_ptr)
19040 struct dwarf2_cu *cu = reader->cu;
19041 struct dwarf2_per_objfile *dwarf2_per_objfile
19042 = cu->per_cu->dwarf2_per_objfile;
19043 struct objfile *objfile = dwarf2_per_objfile->objfile;
19044 struct gdbarch *gdbarch = get_objfile_arch (objfile);
19045 bfd *abfd = reader->abfd;
19046 struct comp_unit_head *cu_header = &cu->header;
19047 unsigned int bytes_read;
19048 struct dwarf_block *blk;
19050 attr->form = (enum dwarf_form) form;
19053 case DW_FORM_ref_addr:
19054 if (cu->header.version == 2)
19055 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19057 DW_UNSND (attr) = read_offset (abfd, info_ptr,
19058 &cu->header, &bytes_read);
19059 info_ptr += bytes_read;
19061 case DW_FORM_GNU_ref_alt:
19062 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19063 info_ptr += bytes_read;
19066 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19067 DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
19068 info_ptr += bytes_read;
19070 case DW_FORM_block2:
19071 blk = dwarf_alloc_block (cu);
19072 blk->size = read_2_bytes (abfd, info_ptr);
19074 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19075 info_ptr += blk->size;
19076 DW_BLOCK (attr) = blk;
19078 case DW_FORM_block4:
19079 blk = dwarf_alloc_block (cu);
19080 blk->size = read_4_bytes (abfd, info_ptr);
19082 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19083 info_ptr += blk->size;
19084 DW_BLOCK (attr) = blk;
19086 case DW_FORM_data2:
19087 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
19090 case DW_FORM_data4:
19091 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
19094 case DW_FORM_data8:
19095 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
19098 case DW_FORM_data16:
19099 blk = dwarf_alloc_block (cu);
19101 blk->data = read_n_bytes (abfd, info_ptr, 16);
19103 DW_BLOCK (attr) = blk;
19105 case DW_FORM_sec_offset:
19106 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19107 info_ptr += bytes_read;
19109 case DW_FORM_string:
19110 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
19111 DW_STRING_IS_CANONICAL (attr) = 0;
19112 info_ptr += bytes_read;
19115 if (!cu->per_cu->is_dwz)
19117 DW_STRING (attr) = read_indirect_string (dwarf2_per_objfile,
19118 abfd, info_ptr, cu_header,
19120 DW_STRING_IS_CANONICAL (attr) = 0;
19121 info_ptr += bytes_read;
19125 case DW_FORM_line_strp:
19126 if (!cu->per_cu->is_dwz)
19128 DW_STRING (attr) = read_indirect_line_string (dwarf2_per_objfile,
19130 cu_header, &bytes_read);
19131 DW_STRING_IS_CANONICAL (attr) = 0;
19132 info_ptr += bytes_read;
19136 case DW_FORM_GNU_strp_alt:
19138 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19139 LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
19142 DW_STRING (attr) = read_indirect_string_from_dwz (objfile,
19144 DW_STRING_IS_CANONICAL (attr) = 0;
19145 info_ptr += bytes_read;
19148 case DW_FORM_exprloc:
19149 case DW_FORM_block:
19150 blk = dwarf_alloc_block (cu);
19151 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19152 info_ptr += bytes_read;
19153 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19154 info_ptr += blk->size;
19155 DW_BLOCK (attr) = blk;
19157 case DW_FORM_block1:
19158 blk = dwarf_alloc_block (cu);
19159 blk->size = read_1_byte (abfd, info_ptr);
19161 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19162 info_ptr += blk->size;
19163 DW_BLOCK (attr) = blk;
19165 case DW_FORM_data1:
19166 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19170 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19173 case DW_FORM_flag_present:
19174 DW_UNSND (attr) = 1;
19176 case DW_FORM_sdata:
19177 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19178 info_ptr += bytes_read;
19180 case DW_FORM_udata:
19181 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19182 info_ptr += bytes_read;
19185 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19186 + read_1_byte (abfd, info_ptr));
19190 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19191 + read_2_bytes (abfd, info_ptr));
19195 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19196 + read_4_bytes (abfd, info_ptr));
19200 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19201 + read_8_bytes (abfd, info_ptr));
19204 case DW_FORM_ref_sig8:
19205 DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
19208 case DW_FORM_ref_udata:
19209 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19210 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
19211 info_ptr += bytes_read;
19213 case DW_FORM_indirect:
19214 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19215 info_ptr += bytes_read;
19216 if (form == DW_FORM_implicit_const)
19218 implicit_const = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19219 info_ptr += bytes_read;
19221 info_ptr = read_attribute_value (reader, attr, form, implicit_const,
19224 case DW_FORM_implicit_const:
19225 DW_SND (attr) = implicit_const;
19227 case DW_FORM_GNU_addr_index:
19228 if (reader->dwo_file == NULL)
19230 /* For now flag a hard error.
19231 Later we can turn this into a complaint. */
19232 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19233 dwarf_form_name (form),
19234 bfd_get_filename (abfd));
19236 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
19237 info_ptr += bytes_read;
19239 case DW_FORM_GNU_str_index:
19240 if (reader->dwo_file == NULL)
19242 /* For now flag a hard error.
19243 Later we can turn this into a complaint if warranted. */
19244 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19245 dwarf_form_name (form),
19246 bfd_get_filename (abfd));
19249 ULONGEST str_index =
19250 read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19252 DW_STRING (attr) = read_str_index (reader, str_index);
19253 DW_STRING_IS_CANONICAL (attr) = 0;
19254 info_ptr += bytes_read;
19258 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19259 dwarf_form_name (form),
19260 bfd_get_filename (abfd));
19264 if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
19265 attr->form = DW_FORM_GNU_ref_alt;
19267 /* We have seen instances where the compiler tried to emit a byte
19268 size attribute of -1 which ended up being encoded as an unsigned
19269 0xffffffff. Although 0xffffffff is technically a valid size value,
19270 an object of this size seems pretty unlikely so we can relatively
19271 safely treat these cases as if the size attribute was invalid and
19272 treat them as zero by default. */
19273 if (attr->name == DW_AT_byte_size
19274 && form == DW_FORM_data4
19275 && DW_UNSND (attr) >= 0xffffffff)
19278 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19279 hex_string (DW_UNSND (attr)));
19280 DW_UNSND (attr) = 0;
19286 /* Read an attribute described by an abbreviated attribute. */
19288 static const gdb_byte *
19289 read_attribute (const struct die_reader_specs *reader,
19290 struct attribute *attr, struct attr_abbrev *abbrev,
19291 const gdb_byte *info_ptr)
19293 attr->name = abbrev->name;
19294 return read_attribute_value (reader, attr, abbrev->form,
19295 abbrev->implicit_const, info_ptr);
19298 /* Read dwarf information from a buffer. */
19300 static unsigned int
19301 read_1_byte (bfd *abfd, const gdb_byte *buf)
19303 return bfd_get_8 (abfd, buf);
19307 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
19309 return bfd_get_signed_8 (abfd, buf);
19312 static unsigned int
19313 read_2_bytes (bfd *abfd, const gdb_byte *buf)
19315 return bfd_get_16 (abfd, buf);
19319 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
19321 return bfd_get_signed_16 (abfd, buf);
19324 static unsigned int
19325 read_4_bytes (bfd *abfd, const gdb_byte *buf)
19327 return bfd_get_32 (abfd, buf);
19331 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
19333 return bfd_get_signed_32 (abfd, buf);
19337 read_8_bytes (bfd *abfd, const gdb_byte *buf)
19339 return bfd_get_64 (abfd, buf);
19343 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
19344 unsigned int *bytes_read)
19346 struct comp_unit_head *cu_header = &cu->header;
19347 CORE_ADDR retval = 0;
19349 if (cu_header->signed_addr_p)
19351 switch (cu_header->addr_size)
19354 retval = bfd_get_signed_16 (abfd, buf);
19357 retval = bfd_get_signed_32 (abfd, buf);
19360 retval = bfd_get_signed_64 (abfd, buf);
19363 internal_error (__FILE__, __LINE__,
19364 _("read_address: bad switch, signed [in module %s]"),
19365 bfd_get_filename (abfd));
19370 switch (cu_header->addr_size)
19373 retval = bfd_get_16 (abfd, buf);
19376 retval = bfd_get_32 (abfd, buf);
19379 retval = bfd_get_64 (abfd, buf);
19382 internal_error (__FILE__, __LINE__,
19383 _("read_address: bad switch, "
19384 "unsigned [in module %s]"),
19385 bfd_get_filename (abfd));
19389 *bytes_read = cu_header->addr_size;
19393 /* Read the initial length from a section. The (draft) DWARF 3
19394 specification allows the initial length to take up either 4 bytes
19395 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19396 bytes describe the length and all offsets will be 8 bytes in length
19399 An older, non-standard 64-bit format is also handled by this
19400 function. The older format in question stores the initial length
19401 as an 8-byte quantity without an escape value. Lengths greater
19402 than 2^32 aren't very common which means that the initial 4 bytes
19403 is almost always zero. Since a length value of zero doesn't make
19404 sense for the 32-bit format, this initial zero can be considered to
19405 be an escape value which indicates the presence of the older 64-bit
19406 format. As written, the code can't detect (old format) lengths
19407 greater than 4GB. If it becomes necessary to handle lengths
19408 somewhat larger than 4GB, we could allow other small values (such
19409 as the non-sensical values of 1, 2, and 3) to also be used as
19410 escape values indicating the presence of the old format.
19412 The value returned via bytes_read should be used to increment the
19413 relevant pointer after calling read_initial_length().
19415 [ Note: read_initial_length() and read_offset() are based on the
19416 document entitled "DWARF Debugging Information Format", revision
19417 3, draft 8, dated November 19, 2001. This document was obtained
19420 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19422 This document is only a draft and is subject to change. (So beware.)
19424 Details regarding the older, non-standard 64-bit format were
19425 determined empirically by examining 64-bit ELF files produced by
19426 the SGI toolchain on an IRIX 6.5 machine.
19428 - Kevin, July 16, 2002
19432 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
19434 LONGEST length = bfd_get_32 (abfd, buf);
19436 if (length == 0xffffffff)
19438 length = bfd_get_64 (abfd, buf + 4);
19441 else if (length == 0)
19443 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19444 length = bfd_get_64 (abfd, buf);
19455 /* Cover function for read_initial_length.
19456 Returns the length of the object at BUF, and stores the size of the
19457 initial length in *BYTES_READ and stores the size that offsets will be in
19459 If the initial length size is not equivalent to that specified in
19460 CU_HEADER then issue a complaint.
19461 This is useful when reading non-comp-unit headers. */
19464 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
19465 const struct comp_unit_head *cu_header,
19466 unsigned int *bytes_read,
19467 unsigned int *offset_size)
19469 LONGEST length = read_initial_length (abfd, buf, bytes_read);
19471 gdb_assert (cu_header->initial_length_size == 4
19472 || cu_header->initial_length_size == 8
19473 || cu_header->initial_length_size == 12);
19475 if (cu_header->initial_length_size != *bytes_read)
19476 complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19478 *offset_size = (*bytes_read == 4) ? 4 : 8;
19482 /* Read an offset from the data stream. The size of the offset is
19483 given by cu_header->offset_size. */
19486 read_offset (bfd *abfd, const gdb_byte *buf,
19487 const struct comp_unit_head *cu_header,
19488 unsigned int *bytes_read)
19490 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
19492 *bytes_read = cu_header->offset_size;
19496 /* Read an offset from the data stream. */
19499 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
19501 LONGEST retval = 0;
19503 switch (offset_size)
19506 retval = bfd_get_32 (abfd, buf);
19509 retval = bfd_get_64 (abfd, buf);
19512 internal_error (__FILE__, __LINE__,
19513 _("read_offset_1: bad switch [in module %s]"),
19514 bfd_get_filename (abfd));
19520 static const gdb_byte *
19521 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
19523 /* If the size of a host char is 8 bits, we can return a pointer
19524 to the buffer, otherwise we have to copy the data to a buffer
19525 allocated on the temporary obstack. */
19526 gdb_assert (HOST_CHAR_BIT == 8);
19530 static const char *
19531 read_direct_string (bfd *abfd, const gdb_byte *buf,
19532 unsigned int *bytes_read_ptr)
19534 /* If the size of a host char is 8 bits, we can return a pointer
19535 to the string, otherwise we have to copy the string to a buffer
19536 allocated on the temporary obstack. */
19537 gdb_assert (HOST_CHAR_BIT == 8);
19540 *bytes_read_ptr = 1;
19543 *bytes_read_ptr = strlen ((const char *) buf) + 1;
19544 return (const char *) buf;
19547 /* Return pointer to string at section SECT offset STR_OFFSET with error
19548 reporting strings FORM_NAME and SECT_NAME. */
19550 static const char *
19551 read_indirect_string_at_offset_from (struct objfile *objfile,
19552 bfd *abfd, LONGEST str_offset,
19553 struct dwarf2_section_info *sect,
19554 const char *form_name,
19555 const char *sect_name)
19557 dwarf2_read_section (objfile, sect);
19558 if (sect->buffer == NULL)
19559 error (_("%s used without %s section [in module %s]"),
19560 form_name, sect_name, bfd_get_filename (abfd));
19561 if (str_offset >= sect->size)
19562 error (_("%s pointing outside of %s section [in module %s]"),
19563 form_name, sect_name, bfd_get_filename (abfd));
19564 gdb_assert (HOST_CHAR_BIT == 8);
19565 if (sect->buffer[str_offset] == '\0')
19567 return (const char *) (sect->buffer + str_offset);
19570 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19572 static const char *
19573 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19574 bfd *abfd, LONGEST str_offset)
19576 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19578 &dwarf2_per_objfile->str,
19579 "DW_FORM_strp", ".debug_str");
19582 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
19584 static const char *
19585 read_indirect_line_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19586 bfd *abfd, LONGEST str_offset)
19588 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19590 &dwarf2_per_objfile->line_str,
19591 "DW_FORM_line_strp",
19592 ".debug_line_str");
19595 /* Read a string at offset STR_OFFSET in the .debug_str section from
19596 the .dwz file DWZ. Throw an error if the offset is too large. If
19597 the string consists of a single NUL byte, return NULL; otherwise
19598 return a pointer to the string. */
19600 static const char *
19601 read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz,
19602 LONGEST str_offset)
19604 dwarf2_read_section (objfile, &dwz->str);
19606 if (dwz->str.buffer == NULL)
19607 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19608 "section [in module %s]"),
19609 bfd_get_filename (dwz->dwz_bfd));
19610 if (str_offset >= dwz->str.size)
19611 error (_("DW_FORM_GNU_strp_alt pointing outside of "
19612 ".debug_str section [in module %s]"),
19613 bfd_get_filename (dwz->dwz_bfd));
19614 gdb_assert (HOST_CHAR_BIT == 8);
19615 if (dwz->str.buffer[str_offset] == '\0')
19617 return (const char *) (dwz->str.buffer + str_offset);
19620 /* Return pointer to string at .debug_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_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
19626 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_string_at_offset (dwarf2_per_objfile, abfd, str_offset);
19635 /* Return pointer to string at .debug_line_str offset as read from BUF.
19636 BUF is assumed to be in a compilation unit described by CU_HEADER.
19637 Return *BYTES_READ_PTR count of bytes read from BUF. */
19639 static const char *
19640 read_indirect_line_string (struct dwarf2_per_objfile *dwarf2_per_objfile,
19641 bfd *abfd, const gdb_byte *buf,
19642 const struct comp_unit_head *cu_header,
19643 unsigned int *bytes_read_ptr)
19645 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19647 return read_indirect_line_string_at_offset (dwarf2_per_objfile, abfd,
19652 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
19653 unsigned int *bytes_read_ptr)
19656 unsigned int num_read;
19658 unsigned char byte;
19665 byte = bfd_get_8 (abfd, buf);
19668 result |= ((ULONGEST) (byte & 127) << shift);
19669 if ((byte & 128) == 0)
19675 *bytes_read_ptr = num_read;
19680 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
19681 unsigned int *bytes_read_ptr)
19684 int shift, num_read;
19685 unsigned char byte;
19692 byte = bfd_get_8 (abfd, buf);
19695 result |= ((ULONGEST) (byte & 127) << shift);
19697 if ((byte & 128) == 0)
19702 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
19703 result |= -(((ULONGEST) 1) << shift);
19704 *bytes_read_ptr = num_read;
19708 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19709 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19710 ADDR_SIZE is the size of addresses from the CU header. */
19713 read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
19714 unsigned int addr_index, ULONGEST addr_base, int addr_size)
19716 struct objfile *objfile = dwarf2_per_objfile->objfile;
19717 bfd *abfd = objfile->obfd;
19718 const gdb_byte *info_ptr;
19720 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
19721 if (dwarf2_per_objfile->addr.buffer == NULL)
19722 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19723 objfile_name (objfile));
19724 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
19725 error (_("DW_FORM_addr_index pointing outside of "
19726 ".debug_addr section [in module %s]"),
19727 objfile_name (objfile));
19728 info_ptr = (dwarf2_per_objfile->addr.buffer
19729 + addr_base + addr_index * addr_size);
19730 if (addr_size == 4)
19731 return bfd_get_32 (abfd, info_ptr);
19733 return bfd_get_64 (abfd, info_ptr);
19736 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
19739 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
19741 return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
19742 cu->addr_base, cu->header.addr_size);
19745 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
19748 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
19749 unsigned int *bytes_read)
19751 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
19752 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
19754 return read_addr_index (cu, addr_index);
19757 /* Data structure to pass results from dwarf2_read_addr_index_reader
19758 back to dwarf2_read_addr_index. */
19760 struct dwarf2_read_addr_index_data
19762 ULONGEST addr_base;
19766 /* die_reader_func for dwarf2_read_addr_index. */
19769 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
19770 const gdb_byte *info_ptr,
19771 struct die_info *comp_unit_die,
19775 struct dwarf2_cu *cu = reader->cu;
19776 struct dwarf2_read_addr_index_data *aidata =
19777 (struct dwarf2_read_addr_index_data *) data;
19779 aidata->addr_base = cu->addr_base;
19780 aidata->addr_size = cu->header.addr_size;
19783 /* Given an index in .debug_addr, fetch the value.
19784 NOTE: This can be called during dwarf expression evaluation,
19785 long after the debug information has been read, and thus per_cu->cu
19786 may no longer exist. */
19789 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
19790 unsigned int addr_index)
19792 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
19793 struct dwarf2_cu *cu = per_cu->cu;
19794 ULONGEST addr_base;
19797 /* We need addr_base and addr_size.
19798 If we don't have PER_CU->cu, we have to get it.
19799 Nasty, but the alternative is storing the needed info in PER_CU,
19800 which at this point doesn't seem justified: it's not clear how frequently
19801 it would get used and it would increase the size of every PER_CU.
19802 Entry points like dwarf2_per_cu_addr_size do a similar thing
19803 so we're not in uncharted territory here.
19804 Alas we need to be a bit more complicated as addr_base is contained
19807 We don't need to read the entire CU(/TU).
19808 We just need the header and top level die.
19810 IWBN to use the aging mechanism to let us lazily later discard the CU.
19811 For now we skip this optimization. */
19815 addr_base = cu->addr_base;
19816 addr_size = cu->header.addr_size;
19820 struct dwarf2_read_addr_index_data aidata;
19822 /* Note: We can't use init_cutu_and_read_dies_simple here,
19823 we need addr_base. */
19824 init_cutu_and_read_dies (per_cu, NULL, 0, 0, false,
19825 dwarf2_read_addr_index_reader, &aidata);
19826 addr_base = aidata.addr_base;
19827 addr_size = aidata.addr_size;
19830 return read_addr_index_1 (dwarf2_per_objfile, addr_index, addr_base,
19834 /* Given a DW_FORM_GNU_str_index, fetch the string.
19835 This is only used by the Fission support. */
19837 static const char *
19838 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
19840 struct dwarf2_cu *cu = reader->cu;
19841 struct dwarf2_per_objfile *dwarf2_per_objfile
19842 = cu->per_cu->dwarf2_per_objfile;
19843 struct objfile *objfile = dwarf2_per_objfile->objfile;
19844 const char *objf_name = objfile_name (objfile);
19845 bfd *abfd = objfile->obfd;
19846 struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
19847 struct dwarf2_section_info *str_offsets_section =
19848 &reader->dwo_file->sections.str_offsets;
19849 const gdb_byte *info_ptr;
19850 ULONGEST str_offset;
19851 static const char form_name[] = "DW_FORM_GNU_str_index";
19853 dwarf2_read_section (objfile, str_section);
19854 dwarf2_read_section (objfile, str_offsets_section);
19855 if (str_section->buffer == NULL)
19856 error (_("%s used without .debug_str.dwo section"
19857 " in CU at offset %s [in module %s]"),
19858 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19859 if (str_offsets_section->buffer == NULL)
19860 error (_("%s used without .debug_str_offsets.dwo section"
19861 " in CU at offset %s [in module %s]"),
19862 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19863 if (str_index * cu->header.offset_size >= str_offsets_section->size)
19864 error (_("%s pointing outside of .debug_str_offsets.dwo"
19865 " section in CU at offset %s [in module %s]"),
19866 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19867 info_ptr = (str_offsets_section->buffer
19868 + str_index * cu->header.offset_size);
19869 if (cu->header.offset_size == 4)
19870 str_offset = bfd_get_32 (abfd, info_ptr);
19872 str_offset = bfd_get_64 (abfd, info_ptr);
19873 if (str_offset >= str_section->size)
19874 error (_("Offset from %s pointing outside of"
19875 " .debug_str.dwo section in CU at offset %s [in module %s]"),
19876 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19877 return (const char *) (str_section->buffer + str_offset);
19880 /* Return the length of an LEB128 number in BUF. */
19883 leb128_size (const gdb_byte *buf)
19885 const gdb_byte *begin = buf;
19891 if ((byte & 128) == 0)
19892 return buf - begin;
19897 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
19906 cu->language = language_c;
19909 case DW_LANG_C_plus_plus:
19910 case DW_LANG_C_plus_plus_11:
19911 case DW_LANG_C_plus_plus_14:
19912 cu->language = language_cplus;
19915 cu->language = language_d;
19917 case DW_LANG_Fortran77:
19918 case DW_LANG_Fortran90:
19919 case DW_LANG_Fortran95:
19920 case DW_LANG_Fortran03:
19921 case DW_LANG_Fortran08:
19922 cu->language = language_fortran;
19925 cu->language = language_go;
19927 case DW_LANG_Mips_Assembler:
19928 cu->language = language_asm;
19930 case DW_LANG_Ada83:
19931 case DW_LANG_Ada95:
19932 cu->language = language_ada;
19934 case DW_LANG_Modula2:
19935 cu->language = language_m2;
19937 case DW_LANG_Pascal83:
19938 cu->language = language_pascal;
19941 cu->language = language_objc;
19944 case DW_LANG_Rust_old:
19945 cu->language = language_rust;
19947 case DW_LANG_Cobol74:
19948 case DW_LANG_Cobol85:
19950 cu->language = language_minimal;
19953 cu->language_defn = language_def (cu->language);
19956 /* Return the named attribute or NULL if not there. */
19958 static struct attribute *
19959 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
19964 struct attribute *spec = NULL;
19966 for (i = 0; i < die->num_attrs; ++i)
19968 if (die->attrs[i].name == name)
19969 return &die->attrs[i];
19970 if (die->attrs[i].name == DW_AT_specification
19971 || die->attrs[i].name == DW_AT_abstract_origin)
19972 spec = &die->attrs[i];
19978 die = follow_die_ref (die, spec, &cu);
19984 /* Return the named attribute or NULL if not there,
19985 but do not follow DW_AT_specification, etc.
19986 This is for use in contexts where we're reading .debug_types dies.
19987 Following DW_AT_specification, DW_AT_abstract_origin will take us
19988 back up the chain, and we want to go down. */
19990 static struct attribute *
19991 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
19995 for (i = 0; i < die->num_attrs; ++i)
19996 if (die->attrs[i].name == name)
19997 return &die->attrs[i];
20002 /* Return the string associated with a string-typed attribute, or NULL if it
20003 is either not found or is of an incorrect type. */
20005 static const char *
20006 dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
20008 struct attribute *attr;
20009 const char *str = NULL;
20011 attr = dwarf2_attr (die, name, cu);
20015 if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp
20016 || attr->form == DW_FORM_string
20017 || attr->form == DW_FORM_GNU_str_index
20018 || attr->form == DW_FORM_GNU_strp_alt)
20019 str = DW_STRING (attr);
20021 complaint (_("string type expected for attribute %s for "
20022 "DIE at %s in module %s"),
20023 dwarf_attr_name (name), sect_offset_str (die->sect_off),
20024 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
20030 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20031 and holds a non-zero value. This function should only be used for
20032 DW_FORM_flag or DW_FORM_flag_present attributes. */
20035 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
20037 struct attribute *attr = dwarf2_attr (die, name, cu);
20039 return (attr && DW_UNSND (attr));
20043 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
20045 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20046 which value is non-zero. However, we have to be careful with
20047 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20048 (via dwarf2_flag_true_p) follows this attribute. So we may
20049 end up accidently finding a declaration attribute that belongs
20050 to a different DIE referenced by the specification attribute,
20051 even though the given DIE does not have a declaration attribute. */
20052 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
20053 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
20056 /* Return the die giving the specification for DIE, if there is
20057 one. *SPEC_CU is the CU containing DIE on input, and the CU
20058 containing the return value on output. If there is no
20059 specification, but there is an abstract origin, that is
20062 static struct die_info *
20063 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
20065 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
20068 if (spec_attr == NULL)
20069 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
20071 if (spec_attr == NULL)
20074 return follow_die_ref (die, spec_attr, spec_cu);
20077 /* Stub for free_line_header to match void * callback types. */
20080 free_line_header_voidp (void *arg)
20082 struct line_header *lh = (struct line_header *) arg;
20088 line_header::add_include_dir (const char *include_dir)
20090 if (dwarf_line_debug >= 2)
20091 fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
20092 include_dirs.size () + 1, include_dir);
20094 include_dirs.push_back (include_dir);
20098 line_header::add_file_name (const char *name,
20100 unsigned int mod_time,
20101 unsigned int length)
20103 if (dwarf_line_debug >= 2)
20104 fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
20105 (unsigned) file_names.size () + 1, name);
20107 file_names.emplace_back (name, d_index, mod_time, length);
20110 /* A convenience function to find the proper .debug_line section for a CU. */
20112 static struct dwarf2_section_info *
20113 get_debug_line_section (struct dwarf2_cu *cu)
20115 struct dwarf2_section_info *section;
20116 struct dwarf2_per_objfile *dwarf2_per_objfile
20117 = cu->per_cu->dwarf2_per_objfile;
20119 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20121 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20122 section = &cu->dwo_unit->dwo_file->sections.line;
20123 else if (cu->per_cu->is_dwz)
20125 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
20127 section = &dwz->line;
20130 section = &dwarf2_per_objfile->line;
20135 /* Read directory or file name entry format, starting with byte of
20136 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20137 entries count and the entries themselves in the described entry
20141 read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
20142 bfd *abfd, const gdb_byte **bufp,
20143 struct line_header *lh,
20144 const struct comp_unit_head *cu_header,
20145 void (*callback) (struct line_header *lh,
20148 unsigned int mod_time,
20149 unsigned int length))
20151 gdb_byte format_count, formati;
20152 ULONGEST data_count, datai;
20153 const gdb_byte *buf = *bufp;
20154 const gdb_byte *format_header_data;
20155 unsigned int bytes_read;
20157 format_count = read_1_byte (abfd, buf);
20159 format_header_data = buf;
20160 for (formati = 0; formati < format_count; formati++)
20162 read_unsigned_leb128 (abfd, buf, &bytes_read);
20164 read_unsigned_leb128 (abfd, buf, &bytes_read);
20168 data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
20170 for (datai = 0; datai < data_count; datai++)
20172 const gdb_byte *format = format_header_data;
20173 struct file_entry fe;
20175 for (formati = 0; formati < format_count; formati++)
20177 ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
20178 format += bytes_read;
20180 ULONGEST form = read_unsigned_leb128 (abfd, format, &bytes_read);
20181 format += bytes_read;
20183 gdb::optional<const char *> string;
20184 gdb::optional<unsigned int> uint;
20188 case DW_FORM_string:
20189 string.emplace (read_direct_string (abfd, buf, &bytes_read));
20193 case DW_FORM_line_strp:
20194 string.emplace (read_indirect_line_string (dwarf2_per_objfile,
20201 case DW_FORM_data1:
20202 uint.emplace (read_1_byte (abfd, buf));
20206 case DW_FORM_data2:
20207 uint.emplace (read_2_bytes (abfd, buf));
20211 case DW_FORM_data4:
20212 uint.emplace (read_4_bytes (abfd, buf));
20216 case DW_FORM_data8:
20217 uint.emplace (read_8_bytes (abfd, buf));
20221 case DW_FORM_udata:
20222 uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
20226 case DW_FORM_block:
20227 /* It is valid only for DW_LNCT_timestamp which is ignored by
20232 switch (content_type)
20235 if (string.has_value ())
20238 case DW_LNCT_directory_index:
20239 if (uint.has_value ())
20240 fe.d_index = (dir_index) *uint;
20242 case DW_LNCT_timestamp:
20243 if (uint.has_value ())
20244 fe.mod_time = *uint;
20247 if (uint.has_value ())
20253 complaint (_("Unknown format content type %s"),
20254 pulongest (content_type));
20258 callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
20264 /* Read the statement program header starting at OFFSET in
20265 .debug_line, or .debug_line.dwo. Return a pointer
20266 to a struct line_header, allocated using xmalloc.
20267 Returns NULL if there is a problem reading the header, e.g., if it
20268 has a version we don't understand.
20270 NOTE: the strings in the include directory and file name tables of
20271 the returned object point into the dwarf line section buffer,
20272 and must not be freed. */
20274 static line_header_up
20275 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
20277 const gdb_byte *line_ptr;
20278 unsigned int bytes_read, offset_size;
20280 const char *cur_dir, *cur_file;
20281 struct dwarf2_section_info *section;
20283 struct dwarf2_per_objfile *dwarf2_per_objfile
20284 = cu->per_cu->dwarf2_per_objfile;
20286 section = get_debug_line_section (cu);
20287 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20288 if (section->buffer == NULL)
20290 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20291 complaint (_("missing .debug_line.dwo section"));
20293 complaint (_("missing .debug_line section"));
20297 /* We can't do this until we know the section is non-empty.
20298 Only then do we know we have such a section. */
20299 abfd = get_section_bfd_owner (section);
20301 /* Make sure that at least there's room for the total_length field.
20302 That could be 12 bytes long, but we're just going to fudge that. */
20303 if (to_underlying (sect_off) + 4 >= section->size)
20305 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20309 line_header_up lh (new line_header ());
20311 lh->sect_off = sect_off;
20312 lh->offset_in_dwz = cu->per_cu->is_dwz;
20314 line_ptr = section->buffer + to_underlying (sect_off);
20316 /* Read in the header. */
20318 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
20319 &bytes_read, &offset_size);
20320 line_ptr += bytes_read;
20321 if (line_ptr + lh->total_length > (section->buffer + section->size))
20323 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20326 lh->statement_program_end = line_ptr + lh->total_length;
20327 lh->version = read_2_bytes (abfd, line_ptr);
20329 if (lh->version > 5)
20331 /* This is a version we don't understand. The format could have
20332 changed in ways we don't handle properly so just punt. */
20333 complaint (_("unsupported version in .debug_line section"));
20336 if (lh->version >= 5)
20338 gdb_byte segment_selector_size;
20340 /* Skip address size. */
20341 read_1_byte (abfd, line_ptr);
20344 segment_selector_size = read_1_byte (abfd, line_ptr);
20346 if (segment_selector_size != 0)
20348 complaint (_("unsupported segment selector size %u "
20349 "in .debug_line section"),
20350 segment_selector_size);
20354 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
20355 line_ptr += offset_size;
20356 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
20358 if (lh->version >= 4)
20360 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
20364 lh->maximum_ops_per_instruction = 1;
20366 if (lh->maximum_ops_per_instruction == 0)
20368 lh->maximum_ops_per_instruction = 1;
20369 complaint (_("invalid maximum_ops_per_instruction "
20370 "in `.debug_line' section"));
20373 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
20375 lh->line_base = read_1_signed_byte (abfd, line_ptr);
20377 lh->line_range = read_1_byte (abfd, line_ptr);
20379 lh->opcode_base = read_1_byte (abfd, line_ptr);
20381 lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
20383 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
20384 for (i = 1; i < lh->opcode_base; ++i)
20386 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
20390 if (lh->version >= 5)
20392 /* Read directory table. */
20393 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20395 [] (struct line_header *header, const char *name,
20396 dir_index d_index, unsigned int mod_time,
20397 unsigned int length)
20399 header->add_include_dir (name);
20402 /* Read file name table. */
20403 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20405 [] (struct line_header *header, const char *name,
20406 dir_index d_index, unsigned int mod_time,
20407 unsigned int length)
20409 header->add_file_name (name, d_index, mod_time, length);
20414 /* Read directory table. */
20415 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20417 line_ptr += bytes_read;
20418 lh->add_include_dir (cur_dir);
20420 line_ptr += bytes_read;
20422 /* Read file name table. */
20423 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20425 unsigned int mod_time, length;
20428 line_ptr += bytes_read;
20429 d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20430 line_ptr += bytes_read;
20431 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20432 line_ptr += bytes_read;
20433 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20434 line_ptr += bytes_read;
20436 lh->add_file_name (cur_file, d_index, mod_time, length);
20438 line_ptr += bytes_read;
20440 lh->statement_program_start = line_ptr;
20442 if (line_ptr > (section->buffer + section->size))
20443 complaint (_("line number info header doesn't "
20444 "fit in `.debug_line' section"));
20449 /* Subroutine of dwarf_decode_lines to simplify it.
20450 Return the file name of the psymtab for included file FILE_INDEX
20451 in line header LH of PST.
20452 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20453 If space for the result is malloc'd, *NAME_HOLDER will be set.
20454 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20456 static const char *
20457 psymtab_include_file_name (const struct line_header *lh, int file_index,
20458 const struct partial_symtab *pst,
20459 const char *comp_dir,
20460 gdb::unique_xmalloc_ptr<char> *name_holder)
20462 const file_entry &fe = lh->file_names[file_index];
20463 const char *include_name = fe.name;
20464 const char *include_name_to_compare = include_name;
20465 const char *pst_filename;
20468 const char *dir_name = fe.include_dir (lh);
20470 gdb::unique_xmalloc_ptr<char> hold_compare;
20471 if (!IS_ABSOLUTE_PATH (include_name)
20472 && (dir_name != NULL || comp_dir != NULL))
20474 /* Avoid creating a duplicate psymtab for PST.
20475 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20476 Before we do the comparison, however, we need to account
20477 for DIR_NAME and COMP_DIR.
20478 First prepend dir_name (if non-NULL). If we still don't
20479 have an absolute path prepend comp_dir (if non-NULL).
20480 However, the directory we record in the include-file's
20481 psymtab does not contain COMP_DIR (to match the
20482 corresponding symtab(s)).
20487 bash$ gcc -g ./hello.c
20488 include_name = "hello.c"
20490 DW_AT_comp_dir = comp_dir = "/tmp"
20491 DW_AT_name = "./hello.c"
20495 if (dir_name != NULL)
20497 name_holder->reset (concat (dir_name, SLASH_STRING,
20498 include_name, (char *) NULL));
20499 include_name = name_holder->get ();
20500 include_name_to_compare = include_name;
20502 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
20504 hold_compare.reset (concat (comp_dir, SLASH_STRING,
20505 include_name, (char *) NULL));
20506 include_name_to_compare = hold_compare.get ();
20510 pst_filename = pst->filename;
20511 gdb::unique_xmalloc_ptr<char> copied_name;
20512 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
20514 copied_name.reset (concat (pst->dirname, SLASH_STRING,
20515 pst_filename, (char *) NULL));
20516 pst_filename = copied_name.get ();
20519 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
20523 return include_name;
20526 /* State machine to track the state of the line number program. */
20528 class lnp_state_machine
20531 /* Initialize a machine state for the start of a line number
20533 lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch, line_header *lh,
20534 bool record_lines_p);
20536 file_entry *current_file ()
20538 /* lh->file_names is 0-based, but the file name numbers in the
20539 statement program are 1-based. */
20540 return m_line_header->file_name_at (m_file);
20543 /* Record the line in the state machine. END_SEQUENCE is true if
20544 we're processing the end of a sequence. */
20545 void record_line (bool end_sequence);
20547 /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20548 nop-out rest of the lines in this sequence. */
20549 void check_line_address (struct dwarf2_cu *cu,
20550 const gdb_byte *line_ptr,
20551 CORE_ADDR unrelocated_lowpc, CORE_ADDR address);
20553 void handle_set_discriminator (unsigned int discriminator)
20555 m_discriminator = discriminator;
20556 m_line_has_non_zero_discriminator |= discriminator != 0;
20559 /* Handle DW_LNE_set_address. */
20560 void handle_set_address (CORE_ADDR baseaddr, CORE_ADDR address)
20563 address += baseaddr;
20564 m_address = gdbarch_adjust_dwarf2_line (m_gdbarch, address, false);
20567 /* Handle DW_LNS_advance_pc. */
20568 void handle_advance_pc (CORE_ADDR adjust);
20570 /* Handle a special opcode. */
20571 void handle_special_opcode (unsigned char op_code);
20573 /* Handle DW_LNS_advance_line. */
20574 void handle_advance_line (int line_delta)
20576 advance_line (line_delta);
20579 /* Handle DW_LNS_set_file. */
20580 void handle_set_file (file_name_index file);
20582 /* Handle DW_LNS_negate_stmt. */
20583 void handle_negate_stmt ()
20585 m_is_stmt = !m_is_stmt;
20588 /* Handle DW_LNS_const_add_pc. */
20589 void handle_const_add_pc ();
20591 /* Handle DW_LNS_fixed_advance_pc. */
20592 void handle_fixed_advance_pc (CORE_ADDR addr_adj)
20594 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20598 /* Handle DW_LNS_copy. */
20599 void handle_copy ()
20601 record_line (false);
20602 m_discriminator = 0;
20605 /* Handle DW_LNE_end_sequence. */
20606 void handle_end_sequence ()
20608 m_currently_recording_lines = true;
20612 /* Advance the line by LINE_DELTA. */
20613 void advance_line (int line_delta)
20615 m_line += line_delta;
20617 if (line_delta != 0)
20618 m_line_has_non_zero_discriminator = m_discriminator != 0;
20621 struct dwarf2_cu *m_cu;
20623 gdbarch *m_gdbarch;
20625 /* True if we're recording lines.
20626 Otherwise we're building partial symtabs and are just interested in
20627 finding include files mentioned by the line number program. */
20628 bool m_record_lines_p;
20630 /* The line number header. */
20631 line_header *m_line_header;
20633 /* These are part of the standard DWARF line number state machine,
20634 and initialized according to the DWARF spec. */
20636 unsigned char m_op_index = 0;
20637 /* The line table index (1-based) of the current file. */
20638 file_name_index m_file = (file_name_index) 1;
20639 unsigned int m_line = 1;
20641 /* These are initialized in the constructor. */
20643 CORE_ADDR m_address;
20645 unsigned int m_discriminator;
20647 /* Additional bits of state we need to track. */
20649 /* The last file that we called dwarf2_start_subfile for.
20650 This is only used for TLLs. */
20651 unsigned int m_last_file = 0;
20652 /* The last file a line number was recorded for. */
20653 struct subfile *m_last_subfile = NULL;
20655 /* When true, record the lines we decode. */
20656 bool m_currently_recording_lines = false;
20658 /* The last line number that was recorded, used to coalesce
20659 consecutive entries for the same line. This can happen, for
20660 example, when discriminators are present. PR 17276. */
20661 unsigned int m_last_line = 0;
20662 bool m_line_has_non_zero_discriminator = false;
20666 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust)
20668 CORE_ADDR addr_adj = (((m_op_index + adjust)
20669 / m_line_header->maximum_ops_per_instruction)
20670 * m_line_header->minimum_instruction_length);
20671 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20672 m_op_index = ((m_op_index + adjust)
20673 % m_line_header->maximum_ops_per_instruction);
20677 lnp_state_machine::handle_special_opcode (unsigned char op_code)
20679 unsigned char adj_opcode = op_code - m_line_header->opcode_base;
20680 CORE_ADDR addr_adj = (((m_op_index
20681 + (adj_opcode / m_line_header->line_range))
20682 / m_line_header->maximum_ops_per_instruction)
20683 * m_line_header->minimum_instruction_length);
20684 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20685 m_op_index = ((m_op_index + (adj_opcode / m_line_header->line_range))
20686 % m_line_header->maximum_ops_per_instruction);
20688 int line_delta = (m_line_header->line_base
20689 + (adj_opcode % m_line_header->line_range));
20690 advance_line (line_delta);
20691 record_line (false);
20692 m_discriminator = 0;
20696 lnp_state_machine::handle_set_file (file_name_index file)
20700 const file_entry *fe = current_file ();
20702 dwarf2_debug_line_missing_file_complaint ();
20703 else if (m_record_lines_p)
20705 const char *dir = fe->include_dir (m_line_header);
20707 m_last_subfile = m_cu->builder->get_current_subfile ();
20708 m_line_has_non_zero_discriminator = m_discriminator != 0;
20709 dwarf2_start_subfile (m_cu, fe->name, dir);
20714 lnp_state_machine::handle_const_add_pc ()
20717 = (255 - m_line_header->opcode_base) / m_line_header->line_range;
20720 = (((m_op_index + adjust)
20721 / m_line_header->maximum_ops_per_instruction)
20722 * m_line_header->minimum_instruction_length);
20724 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20725 m_op_index = ((m_op_index + adjust)
20726 % m_line_header->maximum_ops_per_instruction);
20729 /* Return non-zero if we should add LINE to the line number table.
20730 LINE is the line to add, LAST_LINE is the last line that was added,
20731 LAST_SUBFILE is the subfile for LAST_LINE.
20732 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20733 had a non-zero discriminator.
20735 We have to be careful in the presence of discriminators.
20736 E.g., for this line:
20738 for (i = 0; i < 100000; i++);
20740 clang can emit four line number entries for that one line,
20741 each with a different discriminator.
20742 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20744 However, we want gdb to coalesce all four entries into one.
20745 Otherwise the user could stepi into the middle of the line and
20746 gdb would get confused about whether the pc really was in the
20747 middle of the line.
20749 Things are further complicated by the fact that two consecutive
20750 line number entries for the same line is a heuristic used by gcc
20751 to denote the end of the prologue. So we can't just discard duplicate
20752 entries, we have to be selective about it. The heuristic we use is
20753 that we only collapse consecutive entries for the same line if at least
20754 one of those entries has a non-zero discriminator. PR 17276.
20756 Note: Addresses in the line number state machine can never go backwards
20757 within one sequence, thus this coalescing is ok. */
20760 dwarf_record_line_p (struct dwarf2_cu *cu,
20761 unsigned int line, unsigned int last_line,
20762 int line_has_non_zero_discriminator,
20763 struct subfile *last_subfile)
20765 if (cu->builder->get_current_subfile () != last_subfile)
20767 if (line != last_line)
20769 /* Same line for the same file that we've seen already.
20770 As a last check, for pr 17276, only record the line if the line
20771 has never had a non-zero discriminator. */
20772 if (!line_has_non_zero_discriminator)
20777 /* Use the CU's builder to record line number LINE beginning at
20778 address ADDRESS in the line table of subfile SUBFILE. */
20781 dwarf_record_line_1 (struct gdbarch *gdbarch, struct subfile *subfile,
20782 unsigned int line, CORE_ADDR address,
20783 struct dwarf2_cu *cu)
20785 CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
20787 if (dwarf_line_debug)
20789 fprintf_unfiltered (gdb_stdlog,
20790 "Recording line %u, file %s, address %s\n",
20791 line, lbasename (subfile->name),
20792 paddress (gdbarch, address));
20796 cu->builder->record_line (subfile, line, addr);
20799 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20800 Mark the end of a set of line number records.
20801 The arguments are the same as for dwarf_record_line_1.
20802 If SUBFILE is NULL the request is ignored. */
20805 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
20806 CORE_ADDR address, struct dwarf2_cu *cu)
20808 if (subfile == NULL)
20811 if (dwarf_line_debug)
20813 fprintf_unfiltered (gdb_stdlog,
20814 "Finishing current line, file %s, address %s\n",
20815 lbasename (subfile->name),
20816 paddress (gdbarch, address));
20819 dwarf_record_line_1 (gdbarch, subfile, 0, address, cu);
20823 lnp_state_machine::record_line (bool end_sequence)
20825 if (dwarf_line_debug)
20827 fprintf_unfiltered (gdb_stdlog,
20828 "Processing actual line %u: file %u,"
20829 " address %s, is_stmt %u, discrim %u\n",
20830 m_line, to_underlying (m_file),
20831 paddress (m_gdbarch, m_address),
20832 m_is_stmt, m_discriminator);
20835 file_entry *fe = current_file ();
20838 dwarf2_debug_line_missing_file_complaint ();
20839 /* For now we ignore lines not starting on an instruction boundary.
20840 But not when processing end_sequence for compatibility with the
20841 previous version of the code. */
20842 else if (m_op_index == 0 || end_sequence)
20844 fe->included_p = 1;
20845 if (m_record_lines_p && (producer_is_codewarrior (m_cu) || m_is_stmt))
20847 if (m_last_subfile != m_cu->builder->get_current_subfile ()
20850 dwarf_finish_line (m_gdbarch, m_last_subfile, m_address,
20851 m_currently_recording_lines ? m_cu : nullptr);
20856 if (dwarf_record_line_p (m_cu, m_line, m_last_line,
20857 m_line_has_non_zero_discriminator,
20860 dwarf_record_line_1 (m_gdbarch,
20861 m_cu->builder->get_current_subfile (),
20863 m_currently_recording_lines ? m_cu : nullptr);
20865 m_last_subfile = m_cu->builder->get_current_subfile ();
20866 m_last_line = m_line;
20872 lnp_state_machine::lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch,
20873 line_header *lh, bool record_lines_p)
20877 m_record_lines_p = record_lines_p;
20878 m_line_header = lh;
20880 m_currently_recording_lines = true;
20882 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20883 was a line entry for it so that the backend has a chance to adjust it
20884 and also record it in case it needs it. This is currently used by MIPS
20885 code, cf. `mips_adjust_dwarf2_line'. */
20886 m_address = gdbarch_adjust_dwarf2_line (arch, 0, 0);
20887 m_is_stmt = lh->default_is_stmt;
20888 m_discriminator = 0;
20892 lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
20893 const gdb_byte *line_ptr,
20894 CORE_ADDR unrelocated_lowpc, CORE_ADDR address)
20896 /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
20897 the pc range of the CU. However, we restrict the test to only ADDRESS
20898 values of zero to preserve GDB's previous behaviour which is to handle
20899 the specific case of a function being GC'd by the linker. */
20901 if (address == 0 && address < unrelocated_lowpc)
20903 /* This line table is for a function which has been
20904 GCd by the linker. Ignore it. PR gdb/12528 */
20906 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20907 long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
20909 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20910 line_offset, objfile_name (objfile));
20911 m_currently_recording_lines = false;
20912 /* Note: m_currently_recording_lines is left as false until we see
20913 DW_LNE_end_sequence. */
20917 /* Subroutine of dwarf_decode_lines to simplify it.
20918 Process the line number information in LH.
20919 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20920 program in order to set included_p for every referenced header. */
20923 dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
20924 const int decode_for_pst_p, CORE_ADDR lowpc)
20926 const gdb_byte *line_ptr, *extended_end;
20927 const gdb_byte *line_end;
20928 unsigned int bytes_read, extended_len;
20929 unsigned char op_code, extended_op;
20930 CORE_ADDR baseaddr;
20931 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20932 bfd *abfd = objfile->obfd;
20933 struct gdbarch *gdbarch = get_objfile_arch (objfile);
20934 /* True if we're recording line info (as opposed to building partial
20935 symtabs and just interested in finding include files mentioned by
20936 the line number program). */
20937 bool record_lines_p = !decode_for_pst_p;
20939 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
20941 line_ptr = lh->statement_program_start;
20942 line_end = lh->statement_program_end;
20944 /* Read the statement sequences until there's nothing left. */
20945 while (line_ptr < line_end)
20947 /* The DWARF line number program state machine. Reset the state
20948 machine at the start of each sequence. */
20949 lnp_state_machine state_machine (cu, gdbarch, lh, record_lines_p);
20950 bool end_sequence = false;
20952 if (record_lines_p)
20954 /* Start a subfile for the current file of the state
20956 const file_entry *fe = state_machine.current_file ();
20959 dwarf2_start_subfile (cu, fe->name, fe->include_dir (lh));
20962 /* Decode the table. */
20963 while (line_ptr < line_end && !end_sequence)
20965 op_code = read_1_byte (abfd, line_ptr);
20968 if (op_code >= lh->opcode_base)
20970 /* Special opcode. */
20971 state_machine.handle_special_opcode (op_code);
20973 else switch (op_code)
20975 case DW_LNS_extended_op:
20976 extended_len = read_unsigned_leb128 (abfd, line_ptr,
20978 line_ptr += bytes_read;
20979 extended_end = line_ptr + extended_len;
20980 extended_op = read_1_byte (abfd, line_ptr);
20982 switch (extended_op)
20984 case DW_LNE_end_sequence:
20985 state_machine.handle_end_sequence ();
20986 end_sequence = true;
20988 case DW_LNE_set_address:
20991 = read_address (abfd, line_ptr, cu, &bytes_read);
20992 line_ptr += bytes_read;
20994 state_machine.check_line_address (cu, line_ptr,
20995 lowpc - baseaddr, address);
20996 state_machine.handle_set_address (baseaddr, address);
20999 case DW_LNE_define_file:
21001 const char *cur_file;
21002 unsigned int mod_time, length;
21005 cur_file = read_direct_string (abfd, line_ptr,
21007 line_ptr += bytes_read;
21008 dindex = (dir_index)
21009 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21010 line_ptr += bytes_read;
21012 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21013 line_ptr += bytes_read;
21015 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21016 line_ptr += bytes_read;
21017 lh->add_file_name (cur_file, dindex, mod_time, length);
21020 case DW_LNE_set_discriminator:
21022 /* The discriminator is not interesting to the
21023 debugger; just ignore it. We still need to
21024 check its value though:
21025 if there are consecutive entries for the same
21026 (non-prologue) line we want to coalesce them.
21029 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21030 line_ptr += bytes_read;
21032 state_machine.handle_set_discriminator (discr);
21036 complaint (_("mangled .debug_line section"));
21039 /* Make sure that we parsed the extended op correctly. If e.g.
21040 we expected a different address size than the producer used,
21041 we may have read the wrong number of bytes. */
21042 if (line_ptr != extended_end)
21044 complaint (_("mangled .debug_line section"));
21049 state_machine.handle_copy ();
21051 case DW_LNS_advance_pc:
21054 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21055 line_ptr += bytes_read;
21057 state_machine.handle_advance_pc (adjust);
21060 case DW_LNS_advance_line:
21063 = read_signed_leb128 (abfd, line_ptr, &bytes_read);
21064 line_ptr += bytes_read;
21066 state_machine.handle_advance_line (line_delta);
21069 case DW_LNS_set_file:
21071 file_name_index file
21072 = (file_name_index) read_unsigned_leb128 (abfd, line_ptr,
21074 line_ptr += bytes_read;
21076 state_machine.handle_set_file (file);
21079 case DW_LNS_set_column:
21080 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21081 line_ptr += bytes_read;
21083 case DW_LNS_negate_stmt:
21084 state_machine.handle_negate_stmt ();
21086 case DW_LNS_set_basic_block:
21088 /* Add to the address register of the state machine the
21089 address increment value corresponding to special opcode
21090 255. I.e., this value is scaled by the minimum
21091 instruction length since special opcode 255 would have
21092 scaled the increment. */
21093 case DW_LNS_const_add_pc:
21094 state_machine.handle_const_add_pc ();
21096 case DW_LNS_fixed_advance_pc:
21098 CORE_ADDR addr_adj = read_2_bytes (abfd, line_ptr);
21101 state_machine.handle_fixed_advance_pc (addr_adj);
21106 /* Unknown standard opcode, ignore it. */
21109 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
21111 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21112 line_ptr += bytes_read;
21119 dwarf2_debug_line_missing_end_sequence_complaint ();
21121 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21122 in which case we still finish recording the last line). */
21123 state_machine.record_line (true);
21127 /* Decode the Line Number Program (LNP) for the given line_header
21128 structure and CU. The actual information extracted and the type
21129 of structures created from the LNP depends on the value of PST.
21131 1. If PST is NULL, then this procedure uses the data from the program
21132 to create all necessary symbol tables, and their linetables.
21134 2. If PST is not NULL, this procedure reads the program to determine
21135 the list of files included by the unit represented by PST, and
21136 builds all the associated partial symbol tables.
21138 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21139 It is used for relative paths in the line table.
21140 NOTE: When processing partial symtabs (pst != NULL),
21141 comp_dir == pst->dirname.
21143 NOTE: It is important that psymtabs have the same file name (via strcmp)
21144 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21145 symtab we don't use it in the name of the psymtabs we create.
21146 E.g. expand_line_sal requires this when finding psymtabs to expand.
21147 A good testcase for this is mb-inline.exp.
21149 LOWPC is the lowest address in CU (or 0 if not known).
21151 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21152 for its PC<->lines mapping information. Otherwise only the filename
21153 table is read in. */
21156 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
21157 struct dwarf2_cu *cu, struct partial_symtab *pst,
21158 CORE_ADDR lowpc, int decode_mapping)
21160 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21161 const int decode_for_pst_p = (pst != NULL);
21163 if (decode_mapping)
21164 dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
21166 if (decode_for_pst_p)
21170 /* Now that we're done scanning the Line Header Program, we can
21171 create the psymtab of each included file. */
21172 for (file_index = 0; file_index < lh->file_names.size (); file_index++)
21173 if (lh->file_names[file_index].included_p == 1)
21175 gdb::unique_xmalloc_ptr<char> name_holder;
21176 const char *include_name =
21177 psymtab_include_file_name (lh, file_index, pst, comp_dir,
21179 if (include_name != NULL)
21180 dwarf2_create_include_psymtab (include_name, pst, objfile);
21185 /* Make sure a symtab is created for every file, even files
21186 which contain only variables (i.e. no code with associated
21188 struct compunit_symtab *cust = cu->builder->get_compunit_symtab ();
21191 for (i = 0; i < lh->file_names.size (); i++)
21193 file_entry &fe = lh->file_names[i];
21195 dwarf2_start_subfile (cu, fe.name, fe.include_dir (lh));
21197 if (cu->builder->get_current_subfile ()->symtab == NULL)
21199 cu->builder->get_current_subfile ()->symtab
21200 = allocate_symtab (cust,
21201 cu->builder->get_current_subfile ()->name);
21203 fe.symtab = cu->builder->get_current_subfile ()->symtab;
21208 /* Start a subfile for DWARF. FILENAME is the name of the file and
21209 DIRNAME the name of the source directory which contains FILENAME
21210 or NULL if not known.
21211 This routine tries to keep line numbers from identical absolute and
21212 relative file names in a common subfile.
21214 Using the `list' example from the GDB testsuite, which resides in
21215 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21216 of /srcdir/list0.c yields the following debugging information for list0.c:
21218 DW_AT_name: /srcdir/list0.c
21219 DW_AT_comp_dir: /compdir
21220 files.files[0].name: list0.h
21221 files.files[0].dir: /srcdir
21222 files.files[1].name: list0.c
21223 files.files[1].dir: /srcdir
21225 The line number information for list0.c has to end up in a single
21226 subfile, so that `break /srcdir/list0.c:1' works as expected.
21227 start_subfile will ensure that this happens provided that we pass the
21228 concatenation of files.files[1].dir and files.files[1].name as the
21232 dwarf2_start_subfile (struct dwarf2_cu *cu, const char *filename,
21233 const char *dirname)
21237 /* In order not to lose the line information directory,
21238 we concatenate it to the filename when it makes sense.
21239 Note that the Dwarf3 standard says (speaking of filenames in line
21240 information): ``The directory index is ignored for file names
21241 that represent full path names''. Thus ignoring dirname in the
21242 `else' branch below isn't an issue. */
21244 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
21246 copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
21250 cu->builder->start_subfile (filename);
21256 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21257 buildsym_compunit constructor. */
21259 static struct compunit_symtab *
21260 dwarf2_start_symtab (struct dwarf2_cu *cu,
21261 const char *name, const char *comp_dir, CORE_ADDR low_pc)
21263 gdb_assert (cu->builder == nullptr);
21265 cu->builder.reset (new struct buildsym_compunit
21266 (cu->per_cu->dwarf2_per_objfile->objfile,
21267 name, comp_dir, cu->language, low_pc));
21269 cu->list_in_scope = cu->builder->get_file_symbols ();
21271 cu->builder->record_debugformat ("DWARF 2");
21272 cu->builder->record_producer (cu->producer);
21274 cu->processing_has_namespace_info = false;
21276 return cu->builder->get_compunit_symtab ();
21280 var_decode_location (struct attribute *attr, struct symbol *sym,
21281 struct dwarf2_cu *cu)
21283 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21284 struct comp_unit_head *cu_header = &cu->header;
21286 /* NOTE drow/2003-01-30: There used to be a comment and some special
21287 code here to turn a symbol with DW_AT_external and a
21288 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21289 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21290 with some versions of binutils) where shared libraries could have
21291 relocations against symbols in their debug information - the
21292 minimal symbol would have the right address, but the debug info
21293 would not. It's no longer necessary, because we will explicitly
21294 apply relocations when we read in the debug information now. */
21296 /* A DW_AT_location attribute with no contents indicates that a
21297 variable has been optimized away. */
21298 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
21300 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21304 /* Handle one degenerate form of location expression specially, to
21305 preserve GDB's previous behavior when section offsets are
21306 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
21307 then mark this symbol as LOC_STATIC. */
21309 if (attr_form_is_block (attr)
21310 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
21311 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
21312 || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
21313 && (DW_BLOCK (attr)->size
21314 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
21316 unsigned int dummy;
21318 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
21319 SYMBOL_VALUE_ADDRESS (sym) =
21320 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
21322 SYMBOL_VALUE_ADDRESS (sym) =
21323 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
21324 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
21325 fixup_symbol_section (sym, objfile);
21326 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
21327 SYMBOL_SECTION (sym));
21331 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21332 expression evaluator, and use LOC_COMPUTED only when necessary
21333 (i.e. when the value of a register or memory location is
21334 referenced, or a thread-local block, etc.). Then again, it might
21335 not be worthwhile. I'm assuming that it isn't unless performance
21336 or memory numbers show me otherwise. */
21338 dwarf2_symbol_mark_computed (attr, sym, cu, 0);
21340 if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
21341 cu->has_loclist = true;
21344 /* Given a pointer to a DWARF information entry, figure out if we need
21345 to make a symbol table entry for it, and if so, create a new entry
21346 and return a pointer to it.
21347 If TYPE is NULL, determine symbol type from the die, otherwise
21348 used the passed type.
21349 If SPACE is not NULL, use it to hold the new symbol. If it is
21350 NULL, allocate a new symbol on the objfile's obstack. */
21352 static struct symbol *
21353 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
21354 struct symbol *space)
21356 struct dwarf2_per_objfile *dwarf2_per_objfile
21357 = cu->per_cu->dwarf2_per_objfile;
21358 struct objfile *objfile = dwarf2_per_objfile->objfile;
21359 struct gdbarch *gdbarch = get_objfile_arch (objfile);
21360 struct symbol *sym = NULL;
21362 struct attribute *attr = NULL;
21363 struct attribute *attr2 = NULL;
21364 CORE_ADDR baseaddr;
21365 struct pending **list_to_add = NULL;
21367 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
21369 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21371 name = dwarf2_name (die, cu);
21374 const char *linkagename;
21375 int suppress_add = 0;
21380 sym = allocate_symbol (objfile);
21381 OBJSTAT (objfile, n_syms++);
21383 /* Cache this symbol's name and the name's demangled form (if any). */
21384 SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
21385 linkagename = dwarf2_physname (name, die, cu);
21386 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
21388 /* Fortran does not have mangling standard and the mangling does differ
21389 between gfortran, iFort etc. */
21390 if (cu->language == language_fortran
21391 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
21392 symbol_set_demangled_name (&(sym->ginfo),
21393 dwarf2_full_name (name, die, cu),
21396 /* Default assumptions.
21397 Use the passed type or decode it from the die. */
21398 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21399 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21401 SYMBOL_TYPE (sym) = type;
21403 SYMBOL_TYPE (sym) = die_type (die, cu);
21404 attr = dwarf2_attr (die,
21405 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
21409 SYMBOL_LINE (sym) = DW_UNSND (attr);
21412 attr = dwarf2_attr (die,
21413 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
21417 file_name_index file_index = (file_name_index) DW_UNSND (attr);
21418 struct file_entry *fe;
21420 if (cu->line_header != NULL)
21421 fe = cu->line_header->file_name_at (file_index);
21426 complaint (_("file index out of range"));
21428 symbol_set_symtab (sym, fe->symtab);
21434 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
21439 addr = attr_value_as_address (attr);
21440 addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
21441 SYMBOL_VALUE_ADDRESS (sym) = addr;
21443 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
21444 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
21445 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
21446 dw2_add_symbol_to_list (sym, cu->list_in_scope);
21448 case DW_TAG_subprogram:
21449 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21451 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21452 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21453 if ((attr2 && (DW_UNSND (attr2) != 0))
21454 || cu->language == language_ada)
21456 /* Subprograms marked external are stored as a global symbol.
21457 Ada subprograms, whether marked external or not, are always
21458 stored as a global symbol, because we want to be able to
21459 access them globally. For instance, we want to be able
21460 to break on a nested subprogram without having to
21461 specify the context. */
21462 list_to_add = cu->builder->get_global_symbols ();
21466 list_to_add = cu->list_in_scope;
21469 case DW_TAG_inlined_subroutine:
21470 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21472 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21473 SYMBOL_INLINED (sym) = 1;
21474 list_to_add = cu->list_in_scope;
21476 case DW_TAG_template_value_param:
21478 /* Fall through. */
21479 case DW_TAG_constant:
21480 case DW_TAG_variable:
21481 case DW_TAG_member:
21482 /* Compilation with minimal debug info may result in
21483 variables with missing type entries. Change the
21484 misleading `void' type to something sensible. */
21485 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
21486 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
21488 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21489 /* In the case of DW_TAG_member, we should only be called for
21490 static const members. */
21491 if (die->tag == DW_TAG_member)
21493 /* dwarf2_add_field uses die_is_declaration,
21494 so we do the same. */
21495 gdb_assert (die_is_declaration (die, cu));
21500 dwarf2_const_value (attr, sym, cu);
21501 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21504 if (attr2 && (DW_UNSND (attr2) != 0))
21505 list_to_add = cu->builder->get_global_symbols ();
21507 list_to_add = cu->list_in_scope;
21511 attr = dwarf2_attr (die, DW_AT_location, cu);
21514 var_decode_location (attr, sym, cu);
21515 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21517 /* Fortran explicitly imports any global symbols to the local
21518 scope by DW_TAG_common_block. */
21519 if (cu->language == language_fortran && die->parent
21520 && die->parent->tag == DW_TAG_common_block)
21523 if (SYMBOL_CLASS (sym) == LOC_STATIC
21524 && SYMBOL_VALUE_ADDRESS (sym) == 0
21525 && !dwarf2_per_objfile->has_section_at_zero)
21527 /* When a static variable is eliminated by the linker,
21528 the corresponding debug information is not stripped
21529 out, but the variable address is set to null;
21530 do not add such variables into symbol table. */
21532 else if (attr2 && (DW_UNSND (attr2) != 0))
21534 /* Workaround gfortran PR debug/40040 - it uses
21535 DW_AT_location for variables in -fPIC libraries which may
21536 get overriden by other libraries/executable and get
21537 a different address. Resolve it by the minimal symbol
21538 which may come from inferior's executable using copy
21539 relocation. Make this workaround only for gfortran as for
21540 other compilers GDB cannot guess the minimal symbol
21541 Fortran mangling kind. */
21542 if (cu->language == language_fortran && die->parent
21543 && die->parent->tag == DW_TAG_module
21545 && startswith (cu->producer, "GNU Fortran"))
21546 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21548 /* A variable with DW_AT_external is never static,
21549 but it may be block-scoped. */
21551 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21552 ? cu->builder->get_global_symbols ()
21553 : cu->list_in_scope);
21556 list_to_add = cu->list_in_scope;
21560 /* We do not know the address of this symbol.
21561 If it is an external symbol and we have type information
21562 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21563 The address of the variable will then be determined from
21564 the minimal symbol table whenever the variable is
21566 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21568 /* Fortran explicitly imports any global symbols to the local
21569 scope by DW_TAG_common_block. */
21570 if (cu->language == language_fortran && die->parent
21571 && die->parent->tag == DW_TAG_common_block)
21573 /* SYMBOL_CLASS doesn't matter here because
21574 read_common_block is going to reset it. */
21576 list_to_add = cu->list_in_scope;
21578 else if (attr2 && (DW_UNSND (attr2) != 0)
21579 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
21581 /* A variable with DW_AT_external is never static, but it
21582 may be block-scoped. */
21584 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21585 ? cu->builder->get_global_symbols ()
21586 : cu->list_in_scope);
21588 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21590 else if (!die_is_declaration (die, cu))
21592 /* Use the default LOC_OPTIMIZED_OUT class. */
21593 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
21595 list_to_add = cu->list_in_scope;
21599 case DW_TAG_formal_parameter:
21601 /* If we are inside a function, mark this as an argument. If
21602 not, we might be looking at an argument to an inlined function
21603 when we do not have enough information to show inlined frames;
21604 pretend it's a local variable in that case so that the user can
21606 struct context_stack *curr
21607 = cu->builder->get_current_context_stack ();
21608 if (curr != nullptr && curr->name != nullptr)
21609 SYMBOL_IS_ARGUMENT (sym) = 1;
21610 attr = dwarf2_attr (die, DW_AT_location, cu);
21613 var_decode_location (attr, sym, cu);
21615 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21618 dwarf2_const_value (attr, sym, cu);
21621 list_to_add = cu->list_in_scope;
21624 case DW_TAG_unspecified_parameters:
21625 /* From varargs functions; gdb doesn't seem to have any
21626 interest in this information, so just ignore it for now.
21629 case DW_TAG_template_type_param:
21631 /* Fall through. */
21632 case DW_TAG_class_type:
21633 case DW_TAG_interface_type:
21634 case DW_TAG_structure_type:
21635 case DW_TAG_union_type:
21636 case DW_TAG_set_type:
21637 case DW_TAG_enumeration_type:
21638 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21639 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
21642 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21643 really ever be static objects: otherwise, if you try
21644 to, say, break of a class's method and you're in a file
21645 which doesn't mention that class, it won't work unless
21646 the check for all static symbols in lookup_symbol_aux
21647 saves you. See the OtherFileClass tests in
21648 gdb.c++/namespace.exp. */
21653 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21654 && cu->language == language_cplus
21655 ? cu->builder->get_global_symbols ()
21656 : cu->list_in_scope);
21658 /* The semantics of C++ state that "struct foo {
21659 ... }" also defines a typedef for "foo". */
21660 if (cu->language == language_cplus
21661 || cu->language == language_ada
21662 || cu->language == language_d
21663 || cu->language == language_rust)
21665 /* The symbol's name is already allocated along
21666 with this objfile, so we don't need to
21667 duplicate it for the type. */
21668 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
21669 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
21674 case DW_TAG_typedef:
21675 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21676 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21677 list_to_add = cu->list_in_scope;
21679 case DW_TAG_base_type:
21680 case DW_TAG_subrange_type:
21681 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21682 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21683 list_to_add = cu->list_in_scope;
21685 case DW_TAG_enumerator:
21686 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21689 dwarf2_const_value (attr, sym, cu);
21692 /* NOTE: carlton/2003-11-10: See comment above in the
21693 DW_TAG_class_type, etc. block. */
21696 = (cu->list_in_scope == cu->builder->get_file_symbols ()
21697 && cu->language == language_cplus
21698 ? cu->builder->get_global_symbols ()
21699 : cu->list_in_scope);
21702 case DW_TAG_imported_declaration:
21703 case DW_TAG_namespace:
21704 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21705 list_to_add = cu->builder->get_global_symbols ();
21707 case DW_TAG_module:
21708 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21709 SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
21710 list_to_add = cu->builder->get_global_symbols ();
21712 case DW_TAG_common_block:
21713 SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
21714 SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
21715 dw2_add_symbol_to_list (sym, cu->list_in_scope);
21718 /* Not a tag we recognize. Hopefully we aren't processing
21719 trash data, but since we must specifically ignore things
21720 we don't recognize, there is nothing else we should do at
21722 complaint (_("unsupported tag: '%s'"),
21723 dwarf_tag_name (die->tag));
21729 sym->hash_next = objfile->template_symbols;
21730 objfile->template_symbols = sym;
21731 list_to_add = NULL;
21734 if (list_to_add != NULL)
21735 dw2_add_symbol_to_list (sym, list_to_add);
21737 /* For the benefit of old versions of GCC, check for anonymous
21738 namespaces based on the demangled name. */
21739 if (!cu->processing_has_namespace_info
21740 && cu->language == language_cplus)
21741 cp_scan_for_anonymous_namespaces (cu->builder.get (), sym, objfile);
21746 /* Given an attr with a DW_FORM_dataN value in host byte order,
21747 zero-extend it as appropriate for the symbol's type. The DWARF
21748 standard (v4) is not entirely clear about the meaning of using
21749 DW_FORM_dataN for a constant with a signed type, where the type is
21750 wider than the data. The conclusion of a discussion on the DWARF
21751 list was that this is unspecified. We choose to always zero-extend
21752 because that is the interpretation long in use by GCC. */
21755 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
21756 struct dwarf2_cu *cu, LONGEST *value, int bits)
21758 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21759 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
21760 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
21761 LONGEST l = DW_UNSND (attr);
21763 if (bits < sizeof (*value) * 8)
21765 l &= ((LONGEST) 1 << bits) - 1;
21768 else if (bits == sizeof (*value) * 8)
21772 gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
21773 store_unsigned_integer (bytes, bits / 8, byte_order, l);
21780 /* Read a constant value from an attribute. Either set *VALUE, or if
21781 the value does not fit in *VALUE, set *BYTES - either already
21782 allocated on the objfile obstack, or newly allocated on OBSTACK,
21783 or, set *BATON, if we translated the constant to a location
21787 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
21788 const char *name, struct obstack *obstack,
21789 struct dwarf2_cu *cu,
21790 LONGEST *value, const gdb_byte **bytes,
21791 struct dwarf2_locexpr_baton **baton)
21793 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21794 struct comp_unit_head *cu_header = &cu->header;
21795 struct dwarf_block *blk;
21796 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
21797 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
21803 switch (attr->form)
21806 case DW_FORM_GNU_addr_index:
21810 if (TYPE_LENGTH (type) != cu_header->addr_size)
21811 dwarf2_const_value_length_mismatch_complaint (name,
21812 cu_header->addr_size,
21813 TYPE_LENGTH (type));
21814 /* Symbols of this form are reasonably rare, so we just
21815 piggyback on the existing location code rather than writing
21816 a new implementation of symbol_computed_ops. */
21817 *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
21818 (*baton)->per_cu = cu->per_cu;
21819 gdb_assert ((*baton)->per_cu);
21821 (*baton)->size = 2 + cu_header->addr_size;
21822 data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
21823 (*baton)->data = data;
21825 data[0] = DW_OP_addr;
21826 store_unsigned_integer (&data[1], cu_header->addr_size,
21827 byte_order, DW_ADDR (attr));
21828 data[cu_header->addr_size + 1] = DW_OP_stack_value;
21831 case DW_FORM_string:
21833 case DW_FORM_GNU_str_index:
21834 case DW_FORM_GNU_strp_alt:
21835 /* DW_STRING is already allocated on the objfile obstack, point
21837 *bytes = (const gdb_byte *) DW_STRING (attr);
21839 case DW_FORM_block1:
21840 case DW_FORM_block2:
21841 case DW_FORM_block4:
21842 case DW_FORM_block:
21843 case DW_FORM_exprloc:
21844 case DW_FORM_data16:
21845 blk = DW_BLOCK (attr);
21846 if (TYPE_LENGTH (type) != blk->size)
21847 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
21848 TYPE_LENGTH (type));
21849 *bytes = blk->data;
21852 /* The DW_AT_const_value attributes are supposed to carry the
21853 symbol's value "represented as it would be on the target
21854 architecture." By the time we get here, it's already been
21855 converted to host endianness, so we just need to sign- or
21856 zero-extend it as appropriate. */
21857 case DW_FORM_data1:
21858 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
21860 case DW_FORM_data2:
21861 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
21863 case DW_FORM_data4:
21864 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
21866 case DW_FORM_data8:
21867 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
21870 case DW_FORM_sdata:
21871 case DW_FORM_implicit_const:
21872 *value = DW_SND (attr);
21875 case DW_FORM_udata:
21876 *value = DW_UNSND (attr);
21880 complaint (_("unsupported const value attribute form: '%s'"),
21881 dwarf_form_name (attr->form));
21888 /* Copy constant value from an attribute to a symbol. */
21891 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
21892 struct dwarf2_cu *cu)
21894 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21896 const gdb_byte *bytes;
21897 struct dwarf2_locexpr_baton *baton;
21899 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
21900 SYMBOL_PRINT_NAME (sym),
21901 &objfile->objfile_obstack, cu,
21902 &value, &bytes, &baton);
21906 SYMBOL_LOCATION_BATON (sym) = baton;
21907 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
21909 else if (bytes != NULL)
21911 SYMBOL_VALUE_BYTES (sym) = bytes;
21912 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
21916 SYMBOL_VALUE (sym) = value;
21917 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
21921 /* Return the type of the die in question using its DW_AT_type attribute. */
21923 static struct type *
21924 die_type (struct die_info *die, struct dwarf2_cu *cu)
21926 struct attribute *type_attr;
21928 type_attr = dwarf2_attr (die, DW_AT_type, cu);
21931 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21932 /* A missing DW_AT_type represents a void type. */
21933 return objfile_type (objfile)->builtin_void;
21936 return lookup_die_type (die, type_attr, cu);
21939 /* True iff CU's producer generates GNAT Ada auxiliary information
21940 that allows to find parallel types through that information instead
21941 of having to do expensive parallel lookups by type name. */
21944 need_gnat_info (struct dwarf2_cu *cu)
21946 /* Assume that the Ada compiler was GNAT, which always produces
21947 the auxiliary information. */
21948 return (cu->language == language_ada);
21951 /* Return the auxiliary type of the die in question using its
21952 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
21953 attribute is not present. */
21955 static struct type *
21956 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
21958 struct attribute *type_attr;
21960 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
21964 return lookup_die_type (die, type_attr, cu);
21967 /* If DIE has a descriptive_type attribute, then set the TYPE's
21968 descriptive type accordingly. */
21971 set_descriptive_type (struct type *type, struct die_info *die,
21972 struct dwarf2_cu *cu)
21974 struct type *descriptive_type = die_descriptive_type (die, cu);
21976 if (descriptive_type)
21978 ALLOCATE_GNAT_AUX_TYPE (type);
21979 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
21983 /* Return the containing type of the die in question using its
21984 DW_AT_containing_type attribute. */
21986 static struct type *
21987 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
21989 struct attribute *type_attr;
21990 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21992 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
21994 error (_("Dwarf Error: Problem turning containing type into gdb type "
21995 "[in module %s]"), objfile_name (objfile));
21997 return lookup_die_type (die, type_attr, cu);
22000 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22002 static struct type *
22003 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
22005 struct dwarf2_per_objfile *dwarf2_per_objfile
22006 = cu->per_cu->dwarf2_per_objfile;
22007 struct objfile *objfile = dwarf2_per_objfile->objfile;
22010 std::string message
22011 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22012 objfile_name (objfile),
22013 sect_offset_str (cu->header.sect_off),
22014 sect_offset_str (die->sect_off));
22015 saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
22016 message.c_str (), message.length ());
22018 return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
22021 /* Look up the type of DIE in CU using its type attribute ATTR.
22022 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22023 DW_AT_containing_type.
22024 If there is no type substitute an error marker. */
22026 static struct type *
22027 lookup_die_type (struct die_info *die, const struct attribute *attr,
22028 struct dwarf2_cu *cu)
22030 struct dwarf2_per_objfile *dwarf2_per_objfile
22031 = cu->per_cu->dwarf2_per_objfile;
22032 struct objfile *objfile = dwarf2_per_objfile->objfile;
22033 struct type *this_type;
22035 gdb_assert (attr->name == DW_AT_type
22036 || attr->name == DW_AT_GNAT_descriptive_type
22037 || attr->name == DW_AT_containing_type);
22039 /* First see if we have it cached. */
22041 if (attr->form == DW_FORM_GNU_ref_alt)
22043 struct dwarf2_per_cu_data *per_cu;
22044 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22046 per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
22047 dwarf2_per_objfile);
22048 this_type = get_die_type_at_offset (sect_off, per_cu);
22050 else if (attr_form_is_ref (attr))
22052 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22054 this_type = get_die_type_at_offset (sect_off, cu->per_cu);
22056 else if (attr->form == DW_FORM_ref_sig8)
22058 ULONGEST signature = DW_SIGNATURE (attr);
22060 return get_signatured_type (die, signature, cu);
22064 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22065 " at %s [in module %s]"),
22066 dwarf_attr_name (attr->name), sect_offset_str (die->sect_off),
22067 objfile_name (objfile));
22068 return build_error_marker_type (cu, die);
22071 /* If not cached we need to read it in. */
22073 if (this_type == NULL)
22075 struct die_info *type_die = NULL;
22076 struct dwarf2_cu *type_cu = cu;
22078 if (attr_form_is_ref (attr))
22079 type_die = follow_die_ref (die, attr, &type_cu);
22080 if (type_die == NULL)
22081 return build_error_marker_type (cu, die);
22082 /* If we find the type now, it's probably because the type came
22083 from an inter-CU reference and the type's CU got expanded before
22085 this_type = read_type_die (type_die, type_cu);
22088 /* If we still don't have a type use an error marker. */
22090 if (this_type == NULL)
22091 return build_error_marker_type (cu, die);
22096 /* Return the type in DIE, CU.
22097 Returns NULL for invalid types.
22099 This first does a lookup in die_type_hash,
22100 and only reads the die in if necessary.
22102 NOTE: This can be called when reading in partial or full symbols. */
22104 static struct type *
22105 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
22107 struct type *this_type;
22109 this_type = get_die_type (die, cu);
22113 return read_type_die_1 (die, cu);
22116 /* Read the type in DIE, CU.
22117 Returns NULL for invalid types. */
22119 static struct type *
22120 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
22122 struct type *this_type = NULL;
22126 case DW_TAG_class_type:
22127 case DW_TAG_interface_type:
22128 case DW_TAG_structure_type:
22129 case DW_TAG_union_type:
22130 this_type = read_structure_type (die, cu);
22132 case DW_TAG_enumeration_type:
22133 this_type = read_enumeration_type (die, cu);
22135 case DW_TAG_subprogram:
22136 case DW_TAG_subroutine_type:
22137 case DW_TAG_inlined_subroutine:
22138 this_type = read_subroutine_type (die, cu);
22140 case DW_TAG_array_type:
22141 this_type = read_array_type (die, cu);
22143 case DW_TAG_set_type:
22144 this_type = read_set_type (die, cu);
22146 case DW_TAG_pointer_type:
22147 this_type = read_tag_pointer_type (die, cu);
22149 case DW_TAG_ptr_to_member_type:
22150 this_type = read_tag_ptr_to_member_type (die, cu);
22152 case DW_TAG_reference_type:
22153 this_type = read_tag_reference_type (die, cu, TYPE_CODE_REF);
22155 case DW_TAG_rvalue_reference_type:
22156 this_type = read_tag_reference_type (die, cu, TYPE_CODE_RVALUE_REF);
22158 case DW_TAG_const_type:
22159 this_type = read_tag_const_type (die, cu);
22161 case DW_TAG_volatile_type:
22162 this_type = read_tag_volatile_type (die, cu);
22164 case DW_TAG_restrict_type:
22165 this_type = read_tag_restrict_type (die, cu);
22167 case DW_TAG_string_type:
22168 this_type = read_tag_string_type (die, cu);
22170 case DW_TAG_typedef:
22171 this_type = read_typedef (die, cu);
22173 case DW_TAG_subrange_type:
22174 this_type = read_subrange_type (die, cu);
22176 case DW_TAG_base_type:
22177 this_type = read_base_type (die, cu);
22179 case DW_TAG_unspecified_type:
22180 this_type = read_unspecified_type (die, cu);
22182 case DW_TAG_namespace:
22183 this_type = read_namespace_type (die, cu);
22185 case DW_TAG_module:
22186 this_type = read_module_type (die, cu);
22188 case DW_TAG_atomic_type:
22189 this_type = read_tag_atomic_type (die, cu);
22192 complaint (_("unexpected tag in read_type_die: '%s'"),
22193 dwarf_tag_name (die->tag));
22200 /* See if we can figure out if the class lives in a namespace. We do
22201 this by looking for a member function; its demangled name will
22202 contain namespace info, if there is any.
22203 Return the computed name or NULL.
22204 Space for the result is allocated on the objfile's obstack.
22205 This is the full-die version of guess_partial_die_structure_name.
22206 In this case we know DIE has no useful parent. */
22209 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
22211 struct die_info *spec_die;
22212 struct dwarf2_cu *spec_cu;
22213 struct die_info *child;
22214 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22217 spec_die = die_specification (die, &spec_cu);
22218 if (spec_die != NULL)
22224 for (child = die->child;
22226 child = child->sibling)
22228 if (child->tag == DW_TAG_subprogram)
22230 const char *linkage_name = dw2_linkage_name (child, cu);
22232 if (linkage_name != NULL)
22235 = language_class_name_from_physname (cu->language_defn,
22239 if (actual_name != NULL)
22241 const char *die_name = dwarf2_name (die, cu);
22243 if (die_name != NULL
22244 && strcmp (die_name, actual_name) != 0)
22246 /* Strip off the class name from the full name.
22247 We want the prefix. */
22248 int die_name_len = strlen (die_name);
22249 int actual_name_len = strlen (actual_name);
22251 /* Test for '::' as a sanity check. */
22252 if (actual_name_len > die_name_len + 2
22253 && actual_name[actual_name_len
22254 - die_name_len - 1] == ':')
22255 name = (char *) obstack_copy0 (
22256 &objfile->per_bfd->storage_obstack,
22257 actual_name, actual_name_len - die_name_len - 2);
22260 xfree (actual_name);
22269 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22270 prefix part in such case. See
22271 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22273 static const char *
22274 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
22276 struct attribute *attr;
22279 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
22280 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
22283 if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
22286 attr = dw2_linkage_name_attr (die, cu);
22287 if (attr == NULL || DW_STRING (attr) == NULL)
22290 /* dwarf2_name had to be already called. */
22291 gdb_assert (DW_STRING_IS_CANONICAL (attr));
22293 /* Strip the base name, keep any leading namespaces/classes. */
22294 base = strrchr (DW_STRING (attr), ':');
22295 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
22298 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22299 return (char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
22301 &base[-1] - DW_STRING (attr));
22304 /* Return the name of the namespace/class that DIE is defined within,
22305 or "" if we can't tell. The caller should not xfree the result.
22307 For example, if we're within the method foo() in the following
22317 then determine_prefix on foo's die will return "N::C". */
22319 static const char *
22320 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
22322 struct dwarf2_per_objfile *dwarf2_per_objfile
22323 = cu->per_cu->dwarf2_per_objfile;
22324 struct die_info *parent, *spec_die;
22325 struct dwarf2_cu *spec_cu;
22326 struct type *parent_type;
22327 const char *retval;
22329 if (cu->language != language_cplus
22330 && cu->language != language_fortran && cu->language != language_d
22331 && cu->language != language_rust)
22334 retval = anonymous_struct_prefix (die, cu);
22338 /* We have to be careful in the presence of DW_AT_specification.
22339 For example, with GCC 3.4, given the code
22343 // Definition of N::foo.
22347 then we'll have a tree of DIEs like this:
22349 1: DW_TAG_compile_unit
22350 2: DW_TAG_namespace // N
22351 3: DW_TAG_subprogram // declaration of N::foo
22352 4: DW_TAG_subprogram // definition of N::foo
22353 DW_AT_specification // refers to die #3
22355 Thus, when processing die #4, we have to pretend that we're in
22356 the context of its DW_AT_specification, namely the contex of die
22359 spec_die = die_specification (die, &spec_cu);
22360 if (spec_die == NULL)
22361 parent = die->parent;
22364 parent = spec_die->parent;
22368 if (parent == NULL)
22370 else if (parent->building_fullname)
22373 const char *parent_name;
22375 /* It has been seen on RealView 2.2 built binaries,
22376 DW_TAG_template_type_param types actually _defined_ as
22377 children of the parent class:
22380 template class <class Enum> Class{};
22381 Class<enum E> class_e;
22383 1: DW_TAG_class_type (Class)
22384 2: DW_TAG_enumeration_type (E)
22385 3: DW_TAG_enumerator (enum1:0)
22386 3: DW_TAG_enumerator (enum2:1)
22388 2: DW_TAG_template_type_param
22389 DW_AT_type DW_FORM_ref_udata (E)
22391 Besides being broken debug info, it can put GDB into an
22392 infinite loop. Consider:
22394 When we're building the full name for Class<E>, we'll start
22395 at Class, and go look over its template type parameters,
22396 finding E. We'll then try to build the full name of E, and
22397 reach here. We're now trying to build the full name of E,
22398 and look over the parent DIE for containing scope. In the
22399 broken case, if we followed the parent DIE of E, we'd again
22400 find Class, and once again go look at its template type
22401 arguments, etc., etc. Simply don't consider such parent die
22402 as source-level parent of this die (it can't be, the language
22403 doesn't allow it), and break the loop here. */
22404 name = dwarf2_name (die, cu);
22405 parent_name = dwarf2_name (parent, cu);
22406 complaint (_("template param type '%s' defined within parent '%s'"),
22407 name ? name : "<unknown>",
22408 parent_name ? parent_name : "<unknown>");
22412 switch (parent->tag)
22414 case DW_TAG_namespace:
22415 parent_type = read_type_die (parent, cu);
22416 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22417 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22418 Work around this problem here. */
22419 if (cu->language == language_cplus
22420 && strcmp (TYPE_NAME (parent_type), "::") == 0)
22422 /* We give a name to even anonymous namespaces. */
22423 return TYPE_NAME (parent_type);
22424 case DW_TAG_class_type:
22425 case DW_TAG_interface_type:
22426 case DW_TAG_structure_type:
22427 case DW_TAG_union_type:
22428 case DW_TAG_module:
22429 parent_type = read_type_die (parent, cu);
22430 if (TYPE_NAME (parent_type) != NULL)
22431 return TYPE_NAME (parent_type);
22433 /* An anonymous structure is only allowed non-static data
22434 members; no typedefs, no member functions, et cetera.
22435 So it does not need a prefix. */
22437 case DW_TAG_compile_unit:
22438 case DW_TAG_partial_unit:
22439 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22440 if (cu->language == language_cplus
22441 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
22442 && die->child != NULL
22443 && (die->tag == DW_TAG_class_type
22444 || die->tag == DW_TAG_structure_type
22445 || die->tag == DW_TAG_union_type))
22447 char *name = guess_full_die_structure_name (die, cu);
22452 case DW_TAG_enumeration_type:
22453 parent_type = read_type_die (parent, cu);
22454 if (TYPE_DECLARED_CLASS (parent_type))
22456 if (TYPE_NAME (parent_type) != NULL)
22457 return TYPE_NAME (parent_type);
22460 /* Fall through. */
22462 return determine_prefix (parent, cu);
22466 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22467 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22468 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22469 an obconcat, otherwise allocate storage for the result. The CU argument is
22470 used to determine the language and hence, the appropriate separator. */
22472 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22475 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
22476 int physname, struct dwarf2_cu *cu)
22478 const char *lead = "";
22481 if (suffix == NULL || suffix[0] == '\0'
22482 || prefix == NULL || prefix[0] == '\0')
22484 else if (cu->language == language_d)
22486 /* For D, the 'main' function could be defined in any module, but it
22487 should never be prefixed. */
22488 if (strcmp (suffix, "D main") == 0)
22496 else if (cu->language == language_fortran && physname)
22498 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22499 DW_AT_MIPS_linkage_name is preferred and used instead. */
22507 if (prefix == NULL)
22509 if (suffix == NULL)
22516 xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
22518 strcpy (retval, lead);
22519 strcat (retval, prefix);
22520 strcat (retval, sep);
22521 strcat (retval, suffix);
22526 /* We have an obstack. */
22527 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
22531 /* Return sibling of die, NULL if no sibling. */
22533 static struct die_info *
22534 sibling_die (struct die_info *die)
22536 return die->sibling;
22539 /* Get name of a die, return NULL if not found. */
22541 static const char *
22542 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
22543 struct obstack *obstack)
22545 if (name && cu->language == language_cplus)
22547 std::string canon_name = cp_canonicalize_string (name);
22549 if (!canon_name.empty ())
22551 if (canon_name != name)
22552 name = (const char *) obstack_copy0 (obstack,
22553 canon_name.c_str (),
22554 canon_name.length ());
22561 /* Get name of a die, return NULL if not found.
22562 Anonymous namespaces are converted to their magic string. */
22564 static const char *
22565 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
22567 struct attribute *attr;
22568 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22570 attr = dwarf2_attr (die, DW_AT_name, cu);
22571 if ((!attr || !DW_STRING (attr))
22572 && die->tag != DW_TAG_namespace
22573 && die->tag != DW_TAG_class_type
22574 && die->tag != DW_TAG_interface_type
22575 && die->tag != DW_TAG_structure_type
22576 && die->tag != DW_TAG_union_type)
22581 case DW_TAG_compile_unit:
22582 case DW_TAG_partial_unit:
22583 /* Compilation units have a DW_AT_name that is a filename, not
22584 a source language identifier. */
22585 case DW_TAG_enumeration_type:
22586 case DW_TAG_enumerator:
22587 /* These tags always have simple identifiers already; no need
22588 to canonicalize them. */
22589 return DW_STRING (attr);
22591 case DW_TAG_namespace:
22592 if (attr != NULL && DW_STRING (attr) != NULL)
22593 return DW_STRING (attr);
22594 return CP_ANONYMOUS_NAMESPACE_STR;
22596 case DW_TAG_class_type:
22597 case DW_TAG_interface_type:
22598 case DW_TAG_structure_type:
22599 case DW_TAG_union_type:
22600 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22601 structures or unions. These were of the form "._%d" in GCC 4.1,
22602 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22603 and GCC 4.4. We work around this problem by ignoring these. */
22604 if (attr && DW_STRING (attr)
22605 && (startswith (DW_STRING (attr), "._")
22606 || startswith (DW_STRING (attr), "<anonymous")))
22609 /* GCC might emit a nameless typedef that has a linkage name. See
22610 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22611 if (!attr || DW_STRING (attr) == NULL)
22613 char *demangled = NULL;
22615 attr = dw2_linkage_name_attr (die, cu);
22616 if (attr == NULL || DW_STRING (attr) == NULL)
22619 /* Avoid demangling DW_STRING (attr) the second time on a second
22620 call for the same DIE. */
22621 if (!DW_STRING_IS_CANONICAL (attr))
22622 demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
22628 /* FIXME: we already did this for the partial symbol... */
22631 obstack_copy0 (&objfile->per_bfd->storage_obstack,
22632 demangled, strlen (demangled)));
22633 DW_STRING_IS_CANONICAL (attr) = 1;
22636 /* Strip any leading namespaces/classes, keep only the base name.
22637 DW_AT_name for named DIEs does not contain the prefixes. */
22638 base = strrchr (DW_STRING (attr), ':');
22639 if (base && base > DW_STRING (attr) && base[-1] == ':')
22642 return DW_STRING (attr);
22651 if (!DW_STRING_IS_CANONICAL (attr))
22654 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
22655 &objfile->per_bfd->storage_obstack);
22656 DW_STRING_IS_CANONICAL (attr) = 1;
22658 return DW_STRING (attr);
22661 /* Return the die that this die in an extension of, or NULL if there
22662 is none. *EXT_CU is the CU containing DIE on input, and the CU
22663 containing the return value on output. */
22665 static struct die_info *
22666 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
22668 struct attribute *attr;
22670 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
22674 return follow_die_ref (die, attr, ext_cu);
22677 /* Convert a DIE tag into its string name. */
22679 static const char *
22680 dwarf_tag_name (unsigned tag)
22682 const char *name = get_DW_TAG_name (tag);
22685 return "DW_TAG_<unknown>";
22690 /* Convert a DWARF attribute code into its string name. */
22692 static const char *
22693 dwarf_attr_name (unsigned attr)
22697 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22698 if (attr == DW_AT_MIPS_fde)
22699 return "DW_AT_MIPS_fde";
22701 if (attr == DW_AT_HP_block_index)
22702 return "DW_AT_HP_block_index";
22705 name = get_DW_AT_name (attr);
22708 return "DW_AT_<unknown>";
22713 /* Convert a DWARF value form code into its string name. */
22715 static const char *
22716 dwarf_form_name (unsigned form)
22718 const char *name = get_DW_FORM_name (form);
22721 return "DW_FORM_<unknown>";
22726 static const char *
22727 dwarf_bool_name (unsigned mybool)
22735 /* Convert a DWARF type code into its string name. */
22737 static const char *
22738 dwarf_type_encoding_name (unsigned enc)
22740 const char *name = get_DW_ATE_name (enc);
22743 return "DW_ATE_<unknown>";
22749 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
22753 print_spaces (indent, f);
22754 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset %s)\n",
22755 dwarf_tag_name (die->tag), die->abbrev,
22756 sect_offset_str (die->sect_off));
22758 if (die->parent != NULL)
22760 print_spaces (indent, f);
22761 fprintf_unfiltered (f, " parent at offset: %s\n",
22762 sect_offset_str (die->parent->sect_off));
22765 print_spaces (indent, f);
22766 fprintf_unfiltered (f, " has children: %s\n",
22767 dwarf_bool_name (die->child != NULL));
22769 print_spaces (indent, f);
22770 fprintf_unfiltered (f, " attributes:\n");
22772 for (i = 0; i < die->num_attrs; ++i)
22774 print_spaces (indent, f);
22775 fprintf_unfiltered (f, " %s (%s) ",
22776 dwarf_attr_name (die->attrs[i].name),
22777 dwarf_form_name (die->attrs[i].form));
22779 switch (die->attrs[i].form)
22782 case DW_FORM_GNU_addr_index:
22783 fprintf_unfiltered (f, "address: ");
22784 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
22786 case DW_FORM_block2:
22787 case DW_FORM_block4:
22788 case DW_FORM_block:
22789 case DW_FORM_block1:
22790 fprintf_unfiltered (f, "block: size %s",
22791 pulongest (DW_BLOCK (&die->attrs[i])->size));
22793 case DW_FORM_exprloc:
22794 fprintf_unfiltered (f, "expression: size %s",
22795 pulongest (DW_BLOCK (&die->attrs[i])->size));
22797 case DW_FORM_data16:
22798 fprintf_unfiltered (f, "constant of 16 bytes");
22800 case DW_FORM_ref_addr:
22801 fprintf_unfiltered (f, "ref address: ");
22802 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22804 case DW_FORM_GNU_ref_alt:
22805 fprintf_unfiltered (f, "alt ref address: ");
22806 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22812 case DW_FORM_ref_udata:
22813 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
22814 (long) (DW_UNSND (&die->attrs[i])));
22816 case DW_FORM_data1:
22817 case DW_FORM_data2:
22818 case DW_FORM_data4:
22819 case DW_FORM_data8:
22820 case DW_FORM_udata:
22821 case DW_FORM_sdata:
22822 fprintf_unfiltered (f, "constant: %s",
22823 pulongest (DW_UNSND (&die->attrs[i])));
22825 case DW_FORM_sec_offset:
22826 fprintf_unfiltered (f, "section offset: %s",
22827 pulongest (DW_UNSND (&die->attrs[i])));
22829 case DW_FORM_ref_sig8:
22830 fprintf_unfiltered (f, "signature: %s",
22831 hex_string (DW_SIGNATURE (&die->attrs[i])));
22833 case DW_FORM_string:
22835 case DW_FORM_line_strp:
22836 case DW_FORM_GNU_str_index:
22837 case DW_FORM_GNU_strp_alt:
22838 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
22839 DW_STRING (&die->attrs[i])
22840 ? DW_STRING (&die->attrs[i]) : "",
22841 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
22844 if (DW_UNSND (&die->attrs[i]))
22845 fprintf_unfiltered (f, "flag: TRUE");
22847 fprintf_unfiltered (f, "flag: FALSE");
22849 case DW_FORM_flag_present:
22850 fprintf_unfiltered (f, "flag: TRUE");
22852 case DW_FORM_indirect:
22853 /* The reader will have reduced the indirect form to
22854 the "base form" so this form should not occur. */
22855 fprintf_unfiltered (f,
22856 "unexpected attribute form: DW_FORM_indirect");
22858 case DW_FORM_implicit_const:
22859 fprintf_unfiltered (f, "constant: %s",
22860 plongest (DW_SND (&die->attrs[i])));
22863 fprintf_unfiltered (f, "unsupported attribute form: %d.",
22864 die->attrs[i].form);
22867 fprintf_unfiltered (f, "\n");
22872 dump_die_for_error (struct die_info *die)
22874 dump_die_shallow (gdb_stderr, 0, die);
22878 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
22880 int indent = level * 4;
22882 gdb_assert (die != NULL);
22884 if (level >= max_level)
22887 dump_die_shallow (f, indent, die);
22889 if (die->child != NULL)
22891 print_spaces (indent, f);
22892 fprintf_unfiltered (f, " Children:");
22893 if (level + 1 < max_level)
22895 fprintf_unfiltered (f, "\n");
22896 dump_die_1 (f, level + 1, max_level, die->child);
22900 fprintf_unfiltered (f,
22901 " [not printed, max nesting level reached]\n");
22905 if (die->sibling != NULL && level > 0)
22907 dump_die_1 (f, level, max_level, die->sibling);
22911 /* This is called from the pdie macro in gdbinit.in.
22912 It's not static so gcc will keep a copy callable from gdb. */
22915 dump_die (struct die_info *die, int max_level)
22917 dump_die_1 (gdb_stdlog, 0, max_level, die);
22921 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
22925 slot = htab_find_slot_with_hash (cu->die_hash, die,
22926 to_underlying (die->sect_off),
22932 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
22936 dwarf2_get_ref_die_offset (const struct attribute *attr)
22938 if (attr_form_is_ref (attr))
22939 return (sect_offset) DW_UNSND (attr);
22941 complaint (_("unsupported die ref attribute form: '%s'"),
22942 dwarf_form_name (attr->form));
22946 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
22947 * the value held by the attribute is not constant. */
22950 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
22952 if (attr->form == DW_FORM_sdata || attr->form == DW_FORM_implicit_const)
22953 return DW_SND (attr);
22954 else if (attr->form == DW_FORM_udata
22955 || attr->form == DW_FORM_data1
22956 || attr->form == DW_FORM_data2
22957 || attr->form == DW_FORM_data4
22958 || attr->form == DW_FORM_data8)
22959 return DW_UNSND (attr);
22962 /* For DW_FORM_data16 see attr_form_is_constant. */
22963 complaint (_("Attribute value is not a constant (%s)"),
22964 dwarf_form_name (attr->form));
22965 return default_value;
22969 /* Follow reference or signature attribute ATTR of SRC_DIE.
22970 On entry *REF_CU is the CU of SRC_DIE.
22971 On exit *REF_CU is the CU of the result. */
22973 static struct die_info *
22974 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
22975 struct dwarf2_cu **ref_cu)
22977 struct die_info *die;
22979 if (attr_form_is_ref (attr))
22980 die = follow_die_ref (src_die, attr, ref_cu);
22981 else if (attr->form == DW_FORM_ref_sig8)
22982 die = follow_die_sig (src_die, attr, ref_cu);
22985 dump_die_for_error (src_die);
22986 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
22987 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
22993 /* Follow reference OFFSET.
22994 On entry *REF_CU is the CU of the source die referencing OFFSET.
22995 On exit *REF_CU is the CU of the result.
22996 Returns NULL if OFFSET is invalid. */
22998 static struct die_info *
22999 follow_die_offset (sect_offset sect_off, int offset_in_dwz,
23000 struct dwarf2_cu **ref_cu)
23002 struct die_info temp_die;
23003 struct dwarf2_cu *target_cu, *cu = *ref_cu;
23004 struct dwarf2_per_objfile *dwarf2_per_objfile
23005 = cu->per_cu->dwarf2_per_objfile;
23007 gdb_assert (cu->per_cu != NULL);
23011 if (cu->per_cu->is_debug_types)
23013 /* .debug_types CUs cannot reference anything outside their CU.
23014 If they need to, they have to reference a signatured type via
23015 DW_FORM_ref_sig8. */
23016 if (!offset_in_cu_p (&cu->header, sect_off))
23019 else if (offset_in_dwz != cu->per_cu->is_dwz
23020 || !offset_in_cu_p (&cu->header, sect_off))
23022 struct dwarf2_per_cu_data *per_cu;
23024 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
23025 dwarf2_per_objfile);
23027 /* If necessary, add it to the queue and load its DIEs. */
23028 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
23029 load_full_comp_unit (per_cu, false, cu->language);
23031 target_cu = per_cu->cu;
23033 else if (cu->dies == NULL)
23035 /* We're loading full DIEs during partial symbol reading. */
23036 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
23037 load_full_comp_unit (cu->per_cu, false, language_minimal);
23040 *ref_cu = target_cu;
23041 temp_die.sect_off = sect_off;
23042 return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
23044 to_underlying (sect_off));
23047 /* Follow reference attribute ATTR of SRC_DIE.
23048 On entry *REF_CU is the CU of SRC_DIE.
23049 On exit *REF_CU is the CU of the result. */
23051 static struct die_info *
23052 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
23053 struct dwarf2_cu **ref_cu)
23055 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
23056 struct dwarf2_cu *cu = *ref_cu;
23057 struct die_info *die;
23059 die = follow_die_offset (sect_off,
23060 (attr->form == DW_FORM_GNU_ref_alt
23061 || cu->per_cu->is_dwz),
23064 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23065 "at %s [in module %s]"),
23066 sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
23067 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
23072 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23073 Returned value is intended for DW_OP_call*. Returned
23074 dwarf2_locexpr_baton->data has lifetime of
23075 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
23077 struct dwarf2_locexpr_baton
23078 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
23079 struct dwarf2_per_cu_data *per_cu,
23080 CORE_ADDR (*get_frame_pc) (void *baton),
23081 void *baton, bool resolve_abstract_p)
23083 struct dwarf2_cu *cu;
23084 struct die_info *die;
23085 struct attribute *attr;
23086 struct dwarf2_locexpr_baton retval;
23087 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
23088 struct objfile *objfile = dwarf2_per_objfile->objfile;
23090 if (per_cu->cu == NULL)
23091 load_cu (per_cu, false);
23095 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23096 Instead just throw an error, not much else we can do. */
23097 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23098 sect_offset_str (sect_off), objfile_name (objfile));
23101 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23103 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23104 sect_offset_str (sect_off), objfile_name (objfile));
23106 attr = dwarf2_attr (die, DW_AT_location, cu);
23107 if (!attr && resolve_abstract_p
23108 && (dwarf2_per_objfile->abstract_to_concrete.find (die)
23109 != dwarf2_per_objfile->abstract_to_concrete.end ()))
23111 CORE_ADDR pc = (*get_frame_pc) (baton);
23113 for (const auto &cand : dwarf2_per_objfile->abstract_to_concrete[die])
23116 || cand->parent->tag != DW_TAG_subprogram)
23119 CORE_ADDR pc_low, pc_high;
23120 get_scope_pc_bounds (cand->parent, &pc_low, &pc_high, cu);
23121 if (pc_low == ((CORE_ADDR) -1)
23122 || !(pc_low <= pc && pc < pc_high))
23126 attr = dwarf2_attr (die, DW_AT_location, cu);
23133 /* DWARF: "If there is no such attribute, then there is no effect.".
23134 DATA is ignored if SIZE is 0. */
23136 retval.data = NULL;
23139 else if (attr_form_is_section_offset (attr))
23141 struct dwarf2_loclist_baton loclist_baton;
23142 CORE_ADDR pc = (*get_frame_pc) (baton);
23145 fill_in_loclist_baton (cu, &loclist_baton, attr);
23147 retval.data = dwarf2_find_location_expression (&loclist_baton,
23149 retval.size = size;
23153 if (!attr_form_is_block (attr))
23154 error (_("Dwarf Error: DIE at %s referenced in module %s "
23155 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23156 sect_offset_str (sect_off), objfile_name (objfile));
23158 retval.data = DW_BLOCK (attr)->data;
23159 retval.size = DW_BLOCK (attr)->size;
23161 retval.per_cu = cu->per_cu;
23163 age_cached_comp_units (dwarf2_per_objfile);
23168 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23171 struct dwarf2_locexpr_baton
23172 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
23173 struct dwarf2_per_cu_data *per_cu,
23174 CORE_ADDR (*get_frame_pc) (void *baton),
23177 sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
23179 return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
23182 /* Write a constant of a given type as target-ordered bytes into
23185 static const gdb_byte *
23186 write_constant_as_bytes (struct obstack *obstack,
23187 enum bfd_endian byte_order,
23194 *len = TYPE_LENGTH (type);
23195 result = (gdb_byte *) obstack_alloc (obstack, *len);
23196 store_unsigned_integer (result, *len, byte_order, value);
23201 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23202 pointer to the constant bytes and set LEN to the length of the
23203 data. If memory is needed, allocate it on OBSTACK. If the DIE
23204 does not have a DW_AT_const_value, return NULL. */
23207 dwarf2_fetch_constant_bytes (sect_offset sect_off,
23208 struct dwarf2_per_cu_data *per_cu,
23209 struct obstack *obstack,
23212 struct dwarf2_cu *cu;
23213 struct die_info *die;
23214 struct attribute *attr;
23215 const gdb_byte *result = NULL;
23218 enum bfd_endian byte_order;
23219 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23221 if (per_cu->cu == NULL)
23222 load_cu (per_cu, false);
23226 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23227 Instead just throw an error, not much else we can do. */
23228 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23229 sect_offset_str (sect_off), objfile_name (objfile));
23232 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23234 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23235 sect_offset_str (sect_off), objfile_name (objfile));
23237 attr = dwarf2_attr (die, DW_AT_const_value, cu);
23241 byte_order = (bfd_big_endian (objfile->obfd)
23242 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
23244 switch (attr->form)
23247 case DW_FORM_GNU_addr_index:
23251 *len = cu->header.addr_size;
23252 tem = (gdb_byte *) obstack_alloc (obstack, *len);
23253 store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
23257 case DW_FORM_string:
23259 case DW_FORM_GNU_str_index:
23260 case DW_FORM_GNU_strp_alt:
23261 /* DW_STRING is already allocated on the objfile obstack, point
23263 result = (const gdb_byte *) DW_STRING (attr);
23264 *len = strlen (DW_STRING (attr));
23266 case DW_FORM_block1:
23267 case DW_FORM_block2:
23268 case DW_FORM_block4:
23269 case DW_FORM_block:
23270 case DW_FORM_exprloc:
23271 case DW_FORM_data16:
23272 result = DW_BLOCK (attr)->data;
23273 *len = DW_BLOCK (attr)->size;
23276 /* The DW_AT_const_value attributes are supposed to carry the
23277 symbol's value "represented as it would be on the target
23278 architecture." By the time we get here, it's already been
23279 converted to host endianness, so we just need to sign- or
23280 zero-extend it as appropriate. */
23281 case DW_FORM_data1:
23282 type = die_type (die, cu);
23283 result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
23284 if (result == NULL)
23285 result = write_constant_as_bytes (obstack, byte_order,
23288 case DW_FORM_data2:
23289 type = die_type (die, cu);
23290 result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
23291 if (result == NULL)
23292 result = write_constant_as_bytes (obstack, byte_order,
23295 case DW_FORM_data4:
23296 type = die_type (die, cu);
23297 result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
23298 if (result == NULL)
23299 result = write_constant_as_bytes (obstack, byte_order,
23302 case DW_FORM_data8:
23303 type = die_type (die, cu);
23304 result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
23305 if (result == NULL)
23306 result = write_constant_as_bytes (obstack, byte_order,
23310 case DW_FORM_sdata:
23311 case DW_FORM_implicit_const:
23312 type = die_type (die, cu);
23313 result = write_constant_as_bytes (obstack, byte_order,
23314 type, DW_SND (attr), len);
23317 case DW_FORM_udata:
23318 type = die_type (die, cu);
23319 result = write_constant_as_bytes (obstack, byte_order,
23320 type, DW_UNSND (attr), len);
23324 complaint (_("unsupported const value attribute form: '%s'"),
23325 dwarf_form_name (attr->form));
23332 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23333 valid type for this die is found. */
23336 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
23337 struct dwarf2_per_cu_data *per_cu)
23339 struct dwarf2_cu *cu;
23340 struct die_info *die;
23342 if (per_cu->cu == NULL)
23343 load_cu (per_cu, false);
23348 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23352 return die_type (die, cu);
23355 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23359 dwarf2_get_die_type (cu_offset die_offset,
23360 struct dwarf2_per_cu_data *per_cu)
23362 sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
23363 return get_die_type_at_offset (die_offset_sect, per_cu);
23366 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23367 On entry *REF_CU is the CU of SRC_DIE.
23368 On exit *REF_CU is the CU of the result.
23369 Returns NULL if the referenced DIE isn't found. */
23371 static struct die_info *
23372 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
23373 struct dwarf2_cu **ref_cu)
23375 struct die_info temp_die;
23376 struct dwarf2_cu *sig_cu;
23377 struct die_info *die;
23379 /* While it might be nice to assert sig_type->type == NULL here,
23380 we can get here for DW_AT_imported_declaration where we need
23381 the DIE not the type. */
23383 /* If necessary, add it to the queue and load its DIEs. */
23385 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
23386 read_signatured_type (sig_type);
23388 sig_cu = sig_type->per_cu.cu;
23389 gdb_assert (sig_cu != NULL);
23390 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
23391 temp_die.sect_off = sig_type->type_offset_in_section;
23392 die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
23393 to_underlying (temp_die.sect_off));
23396 struct dwarf2_per_objfile *dwarf2_per_objfile
23397 = (*ref_cu)->per_cu->dwarf2_per_objfile;
23399 /* For .gdb_index version 7 keep track of included TUs.
23400 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23401 if (dwarf2_per_objfile->index_table != NULL
23402 && dwarf2_per_objfile->index_table->version <= 7)
23404 VEC_safe_push (dwarf2_per_cu_ptr,
23405 (*ref_cu)->per_cu->imported_symtabs,
23416 /* Follow signatured type referenced by ATTR in SRC_DIE.
23417 On entry *REF_CU is the CU of SRC_DIE.
23418 On exit *REF_CU is the CU of the result.
23419 The result is the DIE of the type.
23420 If the referenced type cannot be found an error is thrown. */
23422 static struct die_info *
23423 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
23424 struct dwarf2_cu **ref_cu)
23426 ULONGEST signature = DW_SIGNATURE (attr);
23427 struct signatured_type *sig_type;
23428 struct die_info *die;
23430 gdb_assert (attr->form == DW_FORM_ref_sig8);
23432 sig_type = lookup_signatured_type (*ref_cu, signature);
23433 /* sig_type will be NULL if the signatured type is missing from
23435 if (sig_type == NULL)
23437 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23438 " from DIE at %s [in module %s]"),
23439 hex_string (signature), sect_offset_str (src_die->sect_off),
23440 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23443 die = follow_die_sig_1 (src_die, sig_type, ref_cu);
23446 dump_die_for_error (src_die);
23447 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23448 " from DIE at %s [in module %s]"),
23449 hex_string (signature), sect_offset_str (src_die->sect_off),
23450 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23456 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23457 reading in and processing the type unit if necessary. */
23459 static struct type *
23460 get_signatured_type (struct die_info *die, ULONGEST signature,
23461 struct dwarf2_cu *cu)
23463 struct dwarf2_per_objfile *dwarf2_per_objfile
23464 = cu->per_cu->dwarf2_per_objfile;
23465 struct signatured_type *sig_type;
23466 struct dwarf2_cu *type_cu;
23467 struct die_info *type_die;
23470 sig_type = lookup_signatured_type (cu, signature);
23471 /* sig_type will be NULL if the signatured type is missing from
23473 if (sig_type == NULL)
23475 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23476 " from DIE at %s [in module %s]"),
23477 hex_string (signature), sect_offset_str (die->sect_off),
23478 objfile_name (dwarf2_per_objfile->objfile));
23479 return build_error_marker_type (cu, die);
23482 /* If we already know the type we're done. */
23483 if (sig_type->type != NULL)
23484 return sig_type->type;
23487 type_die = follow_die_sig_1 (die, sig_type, &type_cu);
23488 if (type_die != NULL)
23490 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23491 is created. This is important, for example, because for c++ classes
23492 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23493 type = read_type_die (type_die, type_cu);
23496 complaint (_("Dwarf Error: Cannot build signatured type %s"
23497 " referenced from DIE at %s [in module %s]"),
23498 hex_string (signature), sect_offset_str (die->sect_off),
23499 objfile_name (dwarf2_per_objfile->objfile));
23500 type = build_error_marker_type (cu, die);
23505 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23506 " from DIE at %s [in module %s]"),
23507 hex_string (signature), sect_offset_str (die->sect_off),
23508 objfile_name (dwarf2_per_objfile->objfile));
23509 type = build_error_marker_type (cu, die);
23511 sig_type->type = type;
23516 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23517 reading in and processing the type unit if necessary. */
23519 static struct type *
23520 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
23521 struct dwarf2_cu *cu) /* ARI: editCase function */
23523 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23524 if (attr_form_is_ref (attr))
23526 struct dwarf2_cu *type_cu = cu;
23527 struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
23529 return read_type_die (type_die, type_cu);
23531 else if (attr->form == DW_FORM_ref_sig8)
23533 return get_signatured_type (die, DW_SIGNATURE (attr), cu);
23537 struct dwarf2_per_objfile *dwarf2_per_objfile
23538 = cu->per_cu->dwarf2_per_objfile;
23540 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23541 " at %s [in module %s]"),
23542 dwarf_form_name (attr->form), sect_offset_str (die->sect_off),
23543 objfile_name (dwarf2_per_objfile->objfile));
23544 return build_error_marker_type (cu, die);
23548 /* Load the DIEs associated with type unit PER_CU into memory. */
23551 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
23553 struct signatured_type *sig_type;
23555 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23556 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
23558 /* We have the per_cu, but we need the signatured_type.
23559 Fortunately this is an easy translation. */
23560 gdb_assert (per_cu->is_debug_types);
23561 sig_type = (struct signatured_type *) per_cu;
23563 gdb_assert (per_cu->cu == NULL);
23565 read_signatured_type (sig_type);
23567 gdb_assert (per_cu->cu != NULL);
23570 /* die_reader_func for read_signatured_type.
23571 This is identical to load_full_comp_unit_reader,
23572 but is kept separate for now. */
23575 read_signatured_type_reader (const struct die_reader_specs *reader,
23576 const gdb_byte *info_ptr,
23577 struct die_info *comp_unit_die,
23581 struct dwarf2_cu *cu = reader->cu;
23583 gdb_assert (cu->die_hash == NULL);
23585 htab_create_alloc_ex (cu->header.length / 12,
23589 &cu->comp_unit_obstack,
23590 hashtab_obstack_allocate,
23591 dummy_obstack_deallocate);
23594 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
23595 &info_ptr, comp_unit_die);
23596 cu->dies = comp_unit_die;
23597 /* comp_unit_die is not stored in die_hash, no need. */
23599 /* We try not to read any attributes in this function, because not
23600 all CUs needed for references have been loaded yet, and symbol
23601 table processing isn't initialized. But we have to set the CU language,
23602 or we won't be able to build types correctly.
23603 Similarly, if we do not read the producer, we can not apply
23604 producer-specific interpretation. */
23605 prepare_one_comp_unit (cu, cu->dies, language_minimal);
23608 /* Read in a signatured type and build its CU and DIEs.
23609 If the type is a stub for the real type in a DWO file,
23610 read in the real type from the DWO file as well. */
23613 read_signatured_type (struct signatured_type *sig_type)
23615 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
23617 gdb_assert (per_cu->is_debug_types);
23618 gdb_assert (per_cu->cu == NULL);
23620 init_cutu_and_read_dies (per_cu, NULL, 0, 1, false,
23621 read_signatured_type_reader, NULL);
23622 sig_type->per_cu.tu_read = 1;
23625 /* Decode simple location descriptions.
23626 Given a pointer to a dwarf block that defines a location, compute
23627 the location and return the value.
23629 NOTE drow/2003-11-18: This function is called in two situations
23630 now: for the address of static or global variables (partial symbols
23631 only) and for offsets into structures which are expected to be
23632 (more or less) constant. The partial symbol case should go away,
23633 and only the constant case should remain. That will let this
23634 function complain more accurately. A few special modes are allowed
23635 without complaint for global variables (for instance, global
23636 register values and thread-local values).
23638 A location description containing no operations indicates that the
23639 object is optimized out. The return value is 0 for that case.
23640 FIXME drow/2003-11-16: No callers check for this case any more; soon all
23641 callers will only want a very basic result and this can become a
23644 Note that stack[0] is unused except as a default error return. */
23647 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
23649 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
23651 size_t size = blk->size;
23652 const gdb_byte *data = blk->data;
23653 CORE_ADDR stack[64];
23655 unsigned int bytes_read, unsnd;
23661 stack[++stacki] = 0;
23700 stack[++stacki] = op - DW_OP_lit0;
23735 stack[++stacki] = op - DW_OP_reg0;
23737 dwarf2_complex_location_expr_complaint ();
23741 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
23743 stack[++stacki] = unsnd;
23745 dwarf2_complex_location_expr_complaint ();
23749 stack[++stacki] = read_address (objfile->obfd, &data[i],
23754 case DW_OP_const1u:
23755 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
23759 case DW_OP_const1s:
23760 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
23764 case DW_OP_const2u:
23765 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
23769 case DW_OP_const2s:
23770 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
23774 case DW_OP_const4u:
23775 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
23779 case DW_OP_const4s:
23780 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
23784 case DW_OP_const8u:
23785 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
23790 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
23796 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
23801 stack[stacki + 1] = stack[stacki];
23806 stack[stacki - 1] += stack[stacki];
23810 case DW_OP_plus_uconst:
23811 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
23817 stack[stacki - 1] -= stack[stacki];
23822 /* If we're not the last op, then we definitely can't encode
23823 this using GDB's address_class enum. This is valid for partial
23824 global symbols, although the variable's address will be bogus
23827 dwarf2_complex_location_expr_complaint ();
23830 case DW_OP_GNU_push_tls_address:
23831 case DW_OP_form_tls_address:
23832 /* The top of the stack has the offset from the beginning
23833 of the thread control block at which the variable is located. */
23834 /* Nothing should follow this operator, so the top of stack would
23836 /* This is valid for partial global symbols, but the variable's
23837 address will be bogus in the psymtab. Make it always at least
23838 non-zero to not look as a variable garbage collected by linker
23839 which have DW_OP_addr 0. */
23841 dwarf2_complex_location_expr_complaint ();
23845 case DW_OP_GNU_uninit:
23848 case DW_OP_GNU_addr_index:
23849 case DW_OP_GNU_const_index:
23850 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
23857 const char *name = get_DW_OP_name (op);
23860 complaint (_("unsupported stack op: '%s'"),
23863 complaint (_("unsupported stack op: '%02x'"),
23867 return (stack[stacki]);
23870 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23871 outside of the allocated space. Also enforce minimum>0. */
23872 if (stacki >= ARRAY_SIZE (stack) - 1)
23874 complaint (_("location description stack overflow"));
23880 complaint (_("location description stack underflow"));
23884 return (stack[stacki]);
23887 /* memory allocation interface */
23889 static struct dwarf_block *
23890 dwarf_alloc_block (struct dwarf2_cu *cu)
23892 return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
23895 static struct die_info *
23896 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
23898 struct die_info *die;
23899 size_t size = sizeof (struct die_info);
23902 size += (num_attrs - 1) * sizeof (struct attribute);
23904 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
23905 memset (die, 0, sizeof (struct die_info));
23910 /* Macro support. */
23912 /* Return file name relative to the compilation directory of file number I in
23913 *LH's file name table. The result is allocated using xmalloc; the caller is
23914 responsible for freeing it. */
23917 file_file_name (int file, struct line_header *lh)
23919 /* Is the file number a valid index into the line header's file name
23920 table? Remember that file numbers start with one, not zero. */
23921 if (1 <= file && file <= lh->file_names.size ())
23923 const file_entry &fe = lh->file_names[file - 1];
23925 if (!IS_ABSOLUTE_PATH (fe.name))
23927 const char *dir = fe.include_dir (lh);
23929 return concat (dir, SLASH_STRING, fe.name, (char *) NULL);
23931 return xstrdup (fe.name);
23935 /* The compiler produced a bogus file number. We can at least
23936 record the macro definitions made in the file, even if we
23937 won't be able to find the file by name. */
23938 char fake_name[80];
23940 xsnprintf (fake_name, sizeof (fake_name),
23941 "<bad macro file number %d>", file);
23943 complaint (_("bad file number in macro information (%d)"),
23946 return xstrdup (fake_name);
23950 /* Return the full name of file number I in *LH's file name table.
23951 Use COMP_DIR as the name of the current directory of the
23952 compilation. The result is allocated using xmalloc; the caller is
23953 responsible for freeing it. */
23955 file_full_name (int file, struct line_header *lh, const char *comp_dir)
23957 /* Is the file number a valid index into the line header's file name
23958 table? Remember that file numbers start with one, not zero. */
23959 if (1 <= file && file <= lh->file_names.size ())
23961 char *relative = file_file_name (file, lh);
23963 if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
23965 return reconcat (relative, comp_dir, SLASH_STRING,
23966 relative, (char *) NULL);
23969 return file_file_name (file, lh);
23973 static struct macro_source_file *
23974 macro_start_file (struct dwarf2_cu *cu,
23975 int file, int line,
23976 struct macro_source_file *current_file,
23977 struct line_header *lh)
23979 /* File name relative to the compilation directory of this source file. */
23980 char *file_name = file_file_name (file, lh);
23982 if (! current_file)
23984 /* Note: We don't create a macro table for this compilation unit
23985 at all until we actually get a filename. */
23986 struct macro_table *macro_table = cu->builder->get_macro_table ();
23988 /* If we have no current file, then this must be the start_file
23989 directive for the compilation unit's main source file. */
23990 current_file = macro_set_main (macro_table, file_name);
23991 macro_define_special (macro_table);
23994 current_file = macro_include (current_file, line, file_name);
23998 return current_file;
24001 static const char *
24002 consume_improper_spaces (const char *p, const char *body)
24006 complaint (_("macro definition contains spaces "
24007 "in formal argument list:\n`%s'"),
24019 parse_macro_definition (struct macro_source_file *file, int line,
24024 /* The body string takes one of two forms. For object-like macro
24025 definitions, it should be:
24027 <macro name> " " <definition>
24029 For function-like macro definitions, it should be:
24031 <macro name> "() " <definition>
24033 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24035 Spaces may appear only where explicitly indicated, and in the
24038 The Dwarf 2 spec says that an object-like macro's name is always
24039 followed by a space, but versions of GCC around March 2002 omit
24040 the space when the macro's definition is the empty string.
24042 The Dwarf 2 spec says that there should be no spaces between the
24043 formal arguments in a function-like macro's formal argument list,
24044 but versions of GCC around March 2002 include spaces after the
24048 /* Find the extent of the macro name. The macro name is terminated
24049 by either a space or null character (for an object-like macro) or
24050 an opening paren (for a function-like macro). */
24051 for (p = body; *p; p++)
24052 if (*p == ' ' || *p == '(')
24055 if (*p == ' ' || *p == '\0')
24057 /* It's an object-like macro. */
24058 int name_len = p - body;
24059 char *name = savestring (body, name_len);
24060 const char *replacement;
24063 replacement = body + name_len + 1;
24066 dwarf2_macro_malformed_definition_complaint (body);
24067 replacement = body + name_len;
24070 macro_define_object (file, line, name, replacement);
24074 else if (*p == '(')
24076 /* It's a function-like macro. */
24077 char *name = savestring (body, p - body);
24080 char **argv = XNEWVEC (char *, argv_size);
24084 p = consume_improper_spaces (p, body);
24086 /* Parse the formal argument list. */
24087 while (*p && *p != ')')
24089 /* Find the extent of the current argument name. */
24090 const char *arg_start = p;
24092 while (*p && *p != ',' && *p != ')' && *p != ' ')
24095 if (! *p || p == arg_start)
24096 dwarf2_macro_malformed_definition_complaint (body);
24099 /* Make sure argv has room for the new argument. */
24100 if (argc >= argv_size)
24103 argv = XRESIZEVEC (char *, argv, argv_size);
24106 argv[argc++] = savestring (arg_start, p - arg_start);
24109 p = consume_improper_spaces (p, body);
24111 /* Consume the comma, if present. */
24116 p = consume_improper_spaces (p, body);
24125 /* Perfectly formed definition, no complaints. */
24126 macro_define_function (file, line, name,
24127 argc, (const char **) argv,
24129 else if (*p == '\0')
24131 /* Complain, but do define it. */
24132 dwarf2_macro_malformed_definition_complaint (body);
24133 macro_define_function (file, line, name,
24134 argc, (const char **) argv,
24138 /* Just complain. */
24139 dwarf2_macro_malformed_definition_complaint (body);
24142 /* Just complain. */
24143 dwarf2_macro_malformed_definition_complaint (body);
24149 for (i = 0; i < argc; i++)
24155 dwarf2_macro_malformed_definition_complaint (body);
24158 /* Skip some bytes from BYTES according to the form given in FORM.
24159 Returns the new pointer. */
24161 static const gdb_byte *
24162 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
24163 enum dwarf_form form,
24164 unsigned int offset_size,
24165 struct dwarf2_section_info *section)
24167 unsigned int bytes_read;
24171 case DW_FORM_data1:
24176 case DW_FORM_data2:
24180 case DW_FORM_data4:
24184 case DW_FORM_data8:
24188 case DW_FORM_data16:
24192 case DW_FORM_string:
24193 read_direct_string (abfd, bytes, &bytes_read);
24194 bytes += bytes_read;
24197 case DW_FORM_sec_offset:
24199 case DW_FORM_GNU_strp_alt:
24200 bytes += offset_size;
24203 case DW_FORM_block:
24204 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
24205 bytes += bytes_read;
24208 case DW_FORM_block1:
24209 bytes += 1 + read_1_byte (abfd, bytes);
24211 case DW_FORM_block2:
24212 bytes += 2 + read_2_bytes (abfd, bytes);
24214 case DW_FORM_block4:
24215 bytes += 4 + read_4_bytes (abfd, bytes);
24218 case DW_FORM_sdata:
24219 case DW_FORM_udata:
24220 case DW_FORM_GNU_addr_index:
24221 case DW_FORM_GNU_str_index:
24222 bytes = gdb_skip_leb128 (bytes, buffer_end);
24225 dwarf2_section_buffer_overflow_complaint (section);
24230 case DW_FORM_implicit_const:
24235 complaint (_("invalid form 0x%x in `%s'"),
24236 form, get_section_name (section));
24244 /* A helper for dwarf_decode_macros that handles skipping an unknown
24245 opcode. Returns an updated pointer to the macro data buffer; or,
24246 on error, issues a complaint and returns NULL. */
24248 static const gdb_byte *
24249 skip_unknown_opcode (unsigned int opcode,
24250 const gdb_byte **opcode_definitions,
24251 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24253 unsigned int offset_size,
24254 struct dwarf2_section_info *section)
24256 unsigned int bytes_read, i;
24258 const gdb_byte *defn;
24260 if (opcode_definitions[opcode] == NULL)
24262 complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24267 defn = opcode_definitions[opcode];
24268 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
24269 defn += bytes_read;
24271 for (i = 0; i < arg; ++i)
24273 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end,
24274 (enum dwarf_form) defn[i], offset_size,
24276 if (mac_ptr == NULL)
24278 /* skip_form_bytes already issued the complaint. */
24286 /* A helper function which parses the header of a macro section.
24287 If the macro section is the extended (for now called "GNU") type,
24288 then this updates *OFFSET_SIZE. Returns a pointer to just after
24289 the header, or issues a complaint and returns NULL on error. */
24291 static const gdb_byte *
24292 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
24294 const gdb_byte *mac_ptr,
24295 unsigned int *offset_size,
24296 int section_is_gnu)
24298 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
24300 if (section_is_gnu)
24302 unsigned int version, flags;
24304 version = read_2_bytes (abfd, mac_ptr);
24305 if (version != 4 && version != 5)
24307 complaint (_("unrecognized version `%d' in .debug_macro section"),
24313 flags = read_1_byte (abfd, mac_ptr);
24315 *offset_size = (flags & 1) ? 8 : 4;
24317 if ((flags & 2) != 0)
24318 /* We don't need the line table offset. */
24319 mac_ptr += *offset_size;
24321 /* Vendor opcode descriptions. */
24322 if ((flags & 4) != 0)
24324 unsigned int i, count;
24326 count = read_1_byte (abfd, mac_ptr);
24328 for (i = 0; i < count; ++i)
24330 unsigned int opcode, bytes_read;
24333 opcode = read_1_byte (abfd, mac_ptr);
24335 opcode_definitions[opcode] = mac_ptr;
24336 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24337 mac_ptr += bytes_read;
24346 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24347 including DW_MACRO_import. */
24350 dwarf_decode_macro_bytes (struct dwarf2_cu *cu,
24352 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24353 struct macro_source_file *current_file,
24354 struct line_header *lh,
24355 struct dwarf2_section_info *section,
24356 int section_is_gnu, int section_is_dwz,
24357 unsigned int offset_size,
24358 htab_t include_hash)
24360 struct dwarf2_per_objfile *dwarf2_per_objfile
24361 = cu->per_cu->dwarf2_per_objfile;
24362 struct objfile *objfile = dwarf2_per_objfile->objfile;
24363 enum dwarf_macro_record_type macinfo_type;
24364 int at_commandline;
24365 const gdb_byte *opcode_definitions[256];
24367 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24368 &offset_size, section_is_gnu);
24369 if (mac_ptr == NULL)
24371 /* We already issued a complaint. */
24375 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24376 GDB is still reading the definitions from command line. First
24377 DW_MACINFO_start_file will need to be ignored as it was already executed
24378 to create CURRENT_FILE for the main source holding also the command line
24379 definitions. On first met DW_MACINFO_start_file this flag is reset to
24380 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24382 at_commandline = 1;
24386 /* Do we at least have room for a macinfo type byte? */
24387 if (mac_ptr >= mac_end)
24389 dwarf2_section_buffer_overflow_complaint (section);
24393 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24396 /* Note that we rely on the fact that the corresponding GNU and
24397 DWARF constants are the same. */
24399 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24400 switch (macinfo_type)
24402 /* A zero macinfo type indicates the end of the macro
24407 case DW_MACRO_define:
24408 case DW_MACRO_undef:
24409 case DW_MACRO_define_strp:
24410 case DW_MACRO_undef_strp:
24411 case DW_MACRO_define_sup:
24412 case DW_MACRO_undef_sup:
24414 unsigned int bytes_read;
24419 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24420 mac_ptr += bytes_read;
24422 if (macinfo_type == DW_MACRO_define
24423 || macinfo_type == DW_MACRO_undef)
24425 body = read_direct_string (abfd, mac_ptr, &bytes_read);
24426 mac_ptr += bytes_read;
24430 LONGEST str_offset;
24432 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
24433 mac_ptr += offset_size;
24435 if (macinfo_type == DW_MACRO_define_sup
24436 || macinfo_type == DW_MACRO_undef_sup
24439 struct dwz_file *dwz
24440 = dwarf2_get_dwz_file (dwarf2_per_objfile);
24442 body = read_indirect_string_from_dwz (objfile,
24446 body = read_indirect_string_at_offset (dwarf2_per_objfile,
24450 is_define = (macinfo_type == DW_MACRO_define
24451 || macinfo_type == DW_MACRO_define_strp
24452 || macinfo_type == DW_MACRO_define_sup);
24453 if (! current_file)
24455 /* DWARF violation as no main source is present. */
24456 complaint (_("debug info with no main source gives macro %s "
24458 is_define ? _("definition") : _("undefinition"),
24462 if ((line == 0 && !at_commandline)
24463 || (line != 0 && at_commandline))
24464 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24465 at_commandline ? _("command-line") : _("in-file"),
24466 is_define ? _("definition") : _("undefinition"),
24467 line == 0 ? _("zero") : _("non-zero"), line, body);
24470 parse_macro_definition (current_file, line, body);
24473 gdb_assert (macinfo_type == DW_MACRO_undef
24474 || macinfo_type == DW_MACRO_undef_strp
24475 || macinfo_type == DW_MACRO_undef_sup);
24476 macro_undef (current_file, line, body);
24481 case DW_MACRO_start_file:
24483 unsigned int bytes_read;
24486 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24487 mac_ptr += bytes_read;
24488 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24489 mac_ptr += bytes_read;
24491 if ((line == 0 && !at_commandline)
24492 || (line != 0 && at_commandline))
24493 complaint (_("debug info gives source %d included "
24494 "from %s at %s line %d"),
24495 file, at_commandline ? _("command-line") : _("file"),
24496 line == 0 ? _("zero") : _("non-zero"), line);
24498 if (at_commandline)
24500 /* This DW_MACRO_start_file was executed in the
24502 at_commandline = 0;
24505 current_file = macro_start_file (cu, file, line, current_file,
24510 case DW_MACRO_end_file:
24511 if (! current_file)
24512 complaint (_("macro debug info has an unmatched "
24513 "`close_file' directive"));
24516 current_file = current_file->included_by;
24517 if (! current_file)
24519 enum dwarf_macro_record_type next_type;
24521 /* GCC circa March 2002 doesn't produce the zero
24522 type byte marking the end of the compilation
24523 unit. Complain if it's not there, but exit no
24526 /* Do we at least have room for a macinfo type byte? */
24527 if (mac_ptr >= mac_end)
24529 dwarf2_section_buffer_overflow_complaint (section);
24533 /* We don't increment mac_ptr here, so this is just
24536 = (enum dwarf_macro_record_type) read_1_byte (abfd,
24538 if (next_type != 0)
24539 complaint (_("no terminating 0-type entry for "
24540 "macros in `.debug_macinfo' section"));
24547 case DW_MACRO_import:
24548 case DW_MACRO_import_sup:
24552 bfd *include_bfd = abfd;
24553 struct dwarf2_section_info *include_section = section;
24554 const gdb_byte *include_mac_end = mac_end;
24555 int is_dwz = section_is_dwz;
24556 const gdb_byte *new_mac_ptr;
24558 offset = read_offset_1 (abfd, mac_ptr, offset_size);
24559 mac_ptr += offset_size;
24561 if (macinfo_type == DW_MACRO_import_sup)
24563 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
24565 dwarf2_read_section (objfile, &dwz->macro);
24567 include_section = &dwz->macro;
24568 include_bfd = get_section_bfd_owner (include_section);
24569 include_mac_end = dwz->macro.buffer + dwz->macro.size;
24573 new_mac_ptr = include_section->buffer + offset;
24574 slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
24578 /* This has actually happened; see
24579 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
24580 complaint (_("recursive DW_MACRO_import in "
24581 ".debug_macro section"));
24585 *slot = (void *) new_mac_ptr;
24587 dwarf_decode_macro_bytes (cu, include_bfd, new_mac_ptr,
24588 include_mac_end, current_file, lh,
24589 section, section_is_gnu, is_dwz,
24590 offset_size, include_hash);
24592 htab_remove_elt (include_hash, (void *) new_mac_ptr);
24597 case DW_MACINFO_vendor_ext:
24598 if (!section_is_gnu)
24600 unsigned int bytes_read;
24602 /* This reads the constant, but since we don't recognize
24603 any vendor extensions, we ignore it. */
24604 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24605 mac_ptr += bytes_read;
24606 read_direct_string (abfd, mac_ptr, &bytes_read);
24607 mac_ptr += bytes_read;
24609 /* We don't recognize any vendor extensions. */
24615 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24616 mac_ptr, mac_end, abfd, offset_size,
24618 if (mac_ptr == NULL)
24623 } while (macinfo_type != 0);
24627 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
24628 int section_is_gnu)
24630 struct dwarf2_per_objfile *dwarf2_per_objfile
24631 = cu->per_cu->dwarf2_per_objfile;
24632 struct objfile *objfile = dwarf2_per_objfile->objfile;
24633 struct line_header *lh = cu->line_header;
24635 const gdb_byte *mac_ptr, *mac_end;
24636 struct macro_source_file *current_file = 0;
24637 enum dwarf_macro_record_type macinfo_type;
24638 unsigned int offset_size = cu->header.offset_size;
24639 const gdb_byte *opcode_definitions[256];
24641 struct dwarf2_section_info *section;
24642 const char *section_name;
24644 if (cu->dwo_unit != NULL)
24646 if (section_is_gnu)
24648 section = &cu->dwo_unit->dwo_file->sections.macro;
24649 section_name = ".debug_macro.dwo";
24653 section = &cu->dwo_unit->dwo_file->sections.macinfo;
24654 section_name = ".debug_macinfo.dwo";
24659 if (section_is_gnu)
24661 section = &dwarf2_per_objfile->macro;
24662 section_name = ".debug_macro";
24666 section = &dwarf2_per_objfile->macinfo;
24667 section_name = ".debug_macinfo";
24671 dwarf2_read_section (objfile, section);
24672 if (section->buffer == NULL)
24674 complaint (_("missing %s section"), section_name);
24677 abfd = get_section_bfd_owner (section);
24679 /* First pass: Find the name of the base filename.
24680 This filename is needed in order to process all macros whose definition
24681 (or undefinition) comes from the command line. These macros are defined
24682 before the first DW_MACINFO_start_file entry, and yet still need to be
24683 associated to the base file.
24685 To determine the base file name, we scan the macro definitions until we
24686 reach the first DW_MACINFO_start_file entry. We then initialize
24687 CURRENT_FILE accordingly so that any macro definition found before the
24688 first DW_MACINFO_start_file can still be associated to the base file. */
24690 mac_ptr = section->buffer + offset;
24691 mac_end = section->buffer + section->size;
24693 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24694 &offset_size, section_is_gnu);
24695 if (mac_ptr == NULL)
24697 /* We already issued a complaint. */
24703 /* Do we at least have room for a macinfo type byte? */
24704 if (mac_ptr >= mac_end)
24706 /* Complaint is printed during the second pass as GDB will probably
24707 stop the first pass earlier upon finding
24708 DW_MACINFO_start_file. */
24712 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24715 /* Note that we rely on the fact that the corresponding GNU and
24716 DWARF constants are the same. */
24718 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24719 switch (macinfo_type)
24721 /* A zero macinfo type indicates the end of the macro
24726 case DW_MACRO_define:
24727 case DW_MACRO_undef:
24728 /* Only skip the data by MAC_PTR. */
24730 unsigned int bytes_read;
24732 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24733 mac_ptr += bytes_read;
24734 read_direct_string (abfd, mac_ptr, &bytes_read);
24735 mac_ptr += bytes_read;
24739 case DW_MACRO_start_file:
24741 unsigned int bytes_read;
24744 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24745 mac_ptr += bytes_read;
24746 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24747 mac_ptr += bytes_read;
24749 current_file = macro_start_file (cu, file, line, current_file, lh);
24753 case DW_MACRO_end_file:
24754 /* No data to skip by MAC_PTR. */
24757 case DW_MACRO_define_strp:
24758 case DW_MACRO_undef_strp:
24759 case DW_MACRO_define_sup:
24760 case DW_MACRO_undef_sup:
24762 unsigned int bytes_read;
24764 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24765 mac_ptr += bytes_read;
24766 mac_ptr += offset_size;
24770 case DW_MACRO_import:
24771 case DW_MACRO_import_sup:
24772 /* Note that, according to the spec, a transparent include
24773 chain cannot call DW_MACRO_start_file. So, we can just
24774 skip this opcode. */
24775 mac_ptr += offset_size;
24778 case DW_MACINFO_vendor_ext:
24779 /* Only skip the data by MAC_PTR. */
24780 if (!section_is_gnu)
24782 unsigned int bytes_read;
24784 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24785 mac_ptr += bytes_read;
24786 read_direct_string (abfd, mac_ptr, &bytes_read);
24787 mac_ptr += bytes_read;
24792 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24793 mac_ptr, mac_end, abfd, offset_size,
24795 if (mac_ptr == NULL)
24800 } while (macinfo_type != 0 && current_file == NULL);
24802 /* Second pass: Process all entries.
24804 Use the AT_COMMAND_LINE flag to determine whether we are still processing
24805 command-line macro definitions/undefinitions. This flag is unset when we
24806 reach the first DW_MACINFO_start_file entry. */
24808 htab_up include_hash (htab_create_alloc (1, htab_hash_pointer,
24810 NULL, xcalloc, xfree));
24811 mac_ptr = section->buffer + offset;
24812 slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT);
24813 *slot = (void *) mac_ptr;
24814 dwarf_decode_macro_bytes (cu, abfd, mac_ptr, mac_end,
24815 current_file, lh, section,
24816 section_is_gnu, 0, offset_size,
24817 include_hash.get ());
24820 /* Check if the attribute's form is a DW_FORM_block*
24821 if so return true else false. */
24824 attr_form_is_block (const struct attribute *attr)
24826 return (attr == NULL ? 0 :
24827 attr->form == DW_FORM_block1
24828 || attr->form == DW_FORM_block2
24829 || attr->form == DW_FORM_block4
24830 || attr->form == DW_FORM_block
24831 || attr->form == DW_FORM_exprloc);
24834 /* Return non-zero if ATTR's value is a section offset --- classes
24835 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24836 You may use DW_UNSND (attr) to retrieve such offsets.
24838 Section 7.5.4, "Attribute Encodings", explains that no attribute
24839 may have a value that belongs to more than one of these classes; it
24840 would be ambiguous if we did, because we use the same forms for all
24844 attr_form_is_section_offset (const struct attribute *attr)
24846 return (attr->form == DW_FORM_data4
24847 || attr->form == DW_FORM_data8
24848 || attr->form == DW_FORM_sec_offset);
24851 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24852 zero otherwise. When this function returns true, you can apply
24853 dwarf2_get_attr_constant_value to it.
24855 However, note that for some attributes you must check
24856 attr_form_is_section_offset before using this test. DW_FORM_data4
24857 and DW_FORM_data8 are members of both the constant class, and of
24858 the classes that contain offsets into other debug sections
24859 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
24860 that, if an attribute's can be either a constant or one of the
24861 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
24862 taken as section offsets, not constants.
24864 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
24865 cannot handle that. */
24868 attr_form_is_constant (const struct attribute *attr)
24870 switch (attr->form)
24872 case DW_FORM_sdata:
24873 case DW_FORM_udata:
24874 case DW_FORM_data1:
24875 case DW_FORM_data2:
24876 case DW_FORM_data4:
24877 case DW_FORM_data8:
24878 case DW_FORM_implicit_const:
24886 /* DW_ADDR is always stored already as sect_offset; despite for the forms
24887 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
24890 attr_form_is_ref (const struct attribute *attr)
24892 switch (attr->form)
24894 case DW_FORM_ref_addr:
24899 case DW_FORM_ref_udata:
24900 case DW_FORM_GNU_ref_alt:
24907 /* Return the .debug_loc section to use for CU.
24908 For DWO files use .debug_loc.dwo. */
24910 static struct dwarf2_section_info *
24911 cu_debug_loc_section (struct dwarf2_cu *cu)
24913 struct dwarf2_per_objfile *dwarf2_per_objfile
24914 = cu->per_cu->dwarf2_per_objfile;
24918 struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections;
24920 return cu->header.version >= 5 ? §ions->loclists : §ions->loc;
24922 return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
24923 : &dwarf2_per_objfile->loc);
24926 /* A helper function that fills in a dwarf2_loclist_baton. */
24929 fill_in_loclist_baton (struct dwarf2_cu *cu,
24930 struct dwarf2_loclist_baton *baton,
24931 const struct attribute *attr)
24933 struct dwarf2_per_objfile *dwarf2_per_objfile
24934 = cu->per_cu->dwarf2_per_objfile;
24935 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24937 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
24939 baton->per_cu = cu->per_cu;
24940 gdb_assert (baton->per_cu);
24941 /* We don't know how long the location list is, but make sure we
24942 don't run off the edge of the section. */
24943 baton->size = section->size - DW_UNSND (attr);
24944 baton->data = section->buffer + DW_UNSND (attr);
24945 baton->base_address = cu->base_address;
24946 baton->from_dwo = cu->dwo_unit != NULL;
24950 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
24951 struct dwarf2_cu *cu, int is_block)
24953 struct dwarf2_per_objfile *dwarf2_per_objfile
24954 = cu->per_cu->dwarf2_per_objfile;
24955 struct objfile *objfile = dwarf2_per_objfile->objfile;
24956 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24958 if (attr_form_is_section_offset (attr)
24959 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24960 the section. If so, fall through to the complaint in the
24962 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
24964 struct dwarf2_loclist_baton *baton;
24966 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
24968 fill_in_loclist_baton (cu, baton, attr);
24970 if (cu->base_known == 0)
24971 complaint (_("Location list used without "
24972 "specifying the CU base address."));
24974 SYMBOL_ACLASS_INDEX (sym) = (is_block
24975 ? dwarf2_loclist_block_index
24976 : dwarf2_loclist_index);
24977 SYMBOL_LOCATION_BATON (sym) = baton;
24981 struct dwarf2_locexpr_baton *baton;
24983 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
24984 baton->per_cu = cu->per_cu;
24985 gdb_assert (baton->per_cu);
24987 if (attr_form_is_block (attr))
24989 /* Note that we're just copying the block's data pointer
24990 here, not the actual data. We're still pointing into the
24991 info_buffer for SYM's objfile; right now we never release
24992 that buffer, but when we do clean up properly this may
24994 baton->size = DW_BLOCK (attr)->size;
24995 baton->data = DW_BLOCK (attr)->data;
24999 dwarf2_invalid_attrib_class_complaint ("location description",
25000 SYMBOL_NATURAL_NAME (sym));
25004 SYMBOL_ACLASS_INDEX (sym) = (is_block
25005 ? dwarf2_locexpr_block_index
25006 : dwarf2_locexpr_index);
25007 SYMBOL_LOCATION_BATON (sym) = baton;
25011 /* Return the OBJFILE associated with the compilation unit CU. If CU
25012 came from a separate debuginfo file, then the master objfile is
25016 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
25018 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25020 /* Return the master objfile, so that we can report and look up the
25021 correct file containing this variable. */
25022 if (objfile->separate_debug_objfile_backlink)
25023 objfile = objfile->separate_debug_objfile_backlink;
25028 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25029 (CU_HEADERP is unused in such case) or prepare a temporary copy at
25030 CU_HEADERP first. */
25032 static const struct comp_unit_head *
25033 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
25034 struct dwarf2_per_cu_data *per_cu)
25036 const gdb_byte *info_ptr;
25039 return &per_cu->cu->header;
25041 info_ptr = per_cu->section->buffer + to_underlying (per_cu->sect_off);
25043 memset (cu_headerp, 0, sizeof (*cu_headerp));
25044 read_comp_unit_head (cu_headerp, info_ptr, per_cu->section,
25045 rcuh_kind::COMPILE);
25050 /* Return the address size given in the compilation unit header for CU. */
25053 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
25055 struct comp_unit_head cu_header_local;
25056 const struct comp_unit_head *cu_headerp;
25058 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25060 return cu_headerp->addr_size;
25063 /* Return the offset size given in the compilation unit header for CU. */
25066 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
25068 struct comp_unit_head cu_header_local;
25069 const struct comp_unit_head *cu_headerp;
25071 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25073 return cu_headerp->offset_size;
25076 /* See its dwarf2loc.h declaration. */
25079 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
25081 struct comp_unit_head cu_header_local;
25082 const struct comp_unit_head *cu_headerp;
25084 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25086 if (cu_headerp->version == 2)
25087 return cu_headerp->addr_size;
25089 return cu_headerp->offset_size;
25092 /* Return the text offset of the CU. The returned offset comes from
25093 this CU's objfile. If this objfile came from a separate debuginfo
25094 file, then the offset may be different from the corresponding
25095 offset in the parent objfile. */
25098 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
25100 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25102 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
25105 /* Return DWARF version number of PER_CU. */
25108 dwarf2_version (struct dwarf2_per_cu_data *per_cu)
25110 return per_cu->dwarf_version;
25113 /* Locate the .debug_info compilation unit from CU's objfile which contains
25114 the DIE at OFFSET. Raises an error on failure. */
25116 static struct dwarf2_per_cu_data *
25117 dwarf2_find_containing_comp_unit (sect_offset sect_off,
25118 unsigned int offset_in_dwz,
25119 struct dwarf2_per_objfile *dwarf2_per_objfile)
25121 struct dwarf2_per_cu_data *this_cu;
25123 const sect_offset *cu_off;
25126 high = dwarf2_per_objfile->all_comp_units.size () - 1;
25129 struct dwarf2_per_cu_data *mid_cu;
25130 int mid = low + (high - low) / 2;
25132 mid_cu = dwarf2_per_objfile->all_comp_units[mid];
25133 cu_off = &mid_cu->sect_off;
25134 if (mid_cu->is_dwz > offset_in_dwz
25135 || (mid_cu->is_dwz == offset_in_dwz
25136 && *cu_off + mid_cu->length >= sect_off))
25141 gdb_assert (low == high);
25142 this_cu = dwarf2_per_objfile->all_comp_units[low];
25143 cu_off = &this_cu->sect_off;
25144 if (this_cu->is_dwz != offset_in_dwz || *cu_off > sect_off)
25146 if (low == 0 || this_cu->is_dwz != offset_in_dwz)
25147 error (_("Dwarf Error: could not find partial DIE containing "
25148 "offset %s [in module %s]"),
25149 sect_offset_str (sect_off),
25150 bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
25152 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
25154 return dwarf2_per_objfile->all_comp_units[low-1];
25158 this_cu = dwarf2_per_objfile->all_comp_units[low];
25159 if (low == dwarf2_per_objfile->all_comp_units.size () - 1
25160 && sect_off >= this_cu->sect_off + this_cu->length)
25161 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
25162 gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
25167 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25169 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data *per_cu_)
25170 : per_cu (per_cu_),
25172 has_loclist (false),
25173 checked_producer (false),
25174 producer_is_gxx_lt_4_6 (false),
25175 producer_is_gcc_lt_4_3 (false),
25176 producer_is_icc (false),
25177 producer_is_icc_lt_14 (false),
25178 producer_is_codewarrior (false),
25179 processing_has_namespace_info (false)
25184 /* Destroy a dwarf2_cu. */
25186 dwarf2_cu::~dwarf2_cu ()
25191 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25194 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
25195 enum language pretend_language)
25197 struct attribute *attr;
25199 /* Set the language we're debugging. */
25200 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
25202 set_cu_language (DW_UNSND (attr), cu);
25205 cu->language = pretend_language;
25206 cu->language_defn = language_def (cu->language);
25209 cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
25212 /* Increase the age counter on each cached compilation unit, and free
25213 any that are too old. */
25216 age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
25218 struct dwarf2_per_cu_data *per_cu, **last_chain;
25220 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
25221 per_cu = dwarf2_per_objfile->read_in_chain;
25222 while (per_cu != NULL)
25224 per_cu->cu->last_used ++;
25225 if (per_cu->cu->last_used <= dwarf_max_cache_age)
25226 dwarf2_mark (per_cu->cu);
25227 per_cu = per_cu->cu->read_in_chain;
25230 per_cu = dwarf2_per_objfile->read_in_chain;
25231 last_chain = &dwarf2_per_objfile->read_in_chain;
25232 while (per_cu != NULL)
25234 struct dwarf2_per_cu_data *next_cu;
25236 next_cu = per_cu->cu->read_in_chain;
25238 if (!per_cu->cu->mark)
25241 *last_chain = next_cu;
25244 last_chain = &per_cu->cu->read_in_chain;
25250 /* Remove a single compilation unit from the cache. */
25253 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
25255 struct dwarf2_per_cu_data *per_cu, **last_chain;
25256 struct dwarf2_per_objfile *dwarf2_per_objfile
25257 = target_per_cu->dwarf2_per_objfile;
25259 per_cu = dwarf2_per_objfile->read_in_chain;
25260 last_chain = &dwarf2_per_objfile->read_in_chain;
25261 while (per_cu != NULL)
25263 struct dwarf2_per_cu_data *next_cu;
25265 next_cu = per_cu->cu->read_in_chain;
25267 if (per_cu == target_per_cu)
25271 *last_chain = next_cu;
25275 last_chain = &per_cu->cu->read_in_chain;
25281 /* Cleanup function for the dwarf2_per_objfile data. */
25284 dwarf2_free_objfile (struct objfile *objfile, void *datum)
25286 struct dwarf2_per_objfile *dwarf2_per_objfile
25287 = static_cast<struct dwarf2_per_objfile *> (datum);
25289 delete dwarf2_per_objfile;
25292 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25293 We store these in a hash table separate from the DIEs, and preserve them
25294 when the DIEs are flushed out of cache.
25296 The CU "per_cu" pointer is needed because offset alone is not enough to
25297 uniquely identify the type. A file may have multiple .debug_types sections,
25298 or the type may come from a DWO file. Furthermore, while it's more logical
25299 to use per_cu->section+offset, with Fission the section with the data is in
25300 the DWO file but we don't know that section at the point we need it.
25301 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25302 because we can enter the lookup routine, get_die_type_at_offset, from
25303 outside this file, and thus won't necessarily have PER_CU->cu.
25304 Fortunately, PER_CU is stable for the life of the objfile. */
25306 struct dwarf2_per_cu_offset_and_type
25308 const struct dwarf2_per_cu_data *per_cu;
25309 sect_offset sect_off;
25313 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25316 per_cu_offset_and_type_hash (const void *item)
25318 const struct dwarf2_per_cu_offset_and_type *ofs
25319 = (const struct dwarf2_per_cu_offset_and_type *) item;
25321 return (uintptr_t) ofs->per_cu + to_underlying (ofs->sect_off);
25324 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25327 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
25329 const struct dwarf2_per_cu_offset_and_type *ofs_lhs
25330 = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
25331 const struct dwarf2_per_cu_offset_and_type *ofs_rhs
25332 = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
25334 return (ofs_lhs->per_cu == ofs_rhs->per_cu
25335 && ofs_lhs->sect_off == ofs_rhs->sect_off);
25338 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25339 table if necessary. For convenience, return TYPE.
25341 The DIEs reading must have careful ordering to:
25342 * Not cause infite loops trying to read in DIEs as a prerequisite for
25343 reading current DIE.
25344 * Not trying to dereference contents of still incompletely read in types
25345 while reading in other DIEs.
25346 * Enable referencing still incompletely read in types just by a pointer to
25347 the type without accessing its fields.
25349 Therefore caller should follow these rules:
25350 * Try to fetch any prerequisite types we may need to build this DIE type
25351 before building the type and calling set_die_type.
25352 * After building type call set_die_type for current DIE as soon as
25353 possible before fetching more types to complete the current type.
25354 * Make the type as complete as possible before fetching more types. */
25356 static struct type *
25357 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
25359 struct dwarf2_per_objfile *dwarf2_per_objfile
25360 = cu->per_cu->dwarf2_per_objfile;
25361 struct dwarf2_per_cu_offset_and_type **slot, ofs;
25362 struct objfile *objfile = dwarf2_per_objfile->objfile;
25363 struct attribute *attr;
25364 struct dynamic_prop prop;
25366 /* For Ada types, make sure that the gnat-specific data is always
25367 initialized (if not already set). There are a few types where
25368 we should not be doing so, because the type-specific area is
25369 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25370 where the type-specific area is used to store the floatformat).
25371 But this is not a problem, because the gnat-specific information
25372 is actually not needed for these types. */
25373 if (need_gnat_info (cu)
25374 && TYPE_CODE (type) != TYPE_CODE_FUNC
25375 && TYPE_CODE (type) != TYPE_CODE_FLT
25376 && TYPE_CODE (type) != TYPE_CODE_METHODPTR
25377 && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
25378 && TYPE_CODE (type) != TYPE_CODE_METHOD
25379 && !HAVE_GNAT_AUX_INFO (type))
25380 INIT_GNAT_SPECIFIC (type);
25382 /* Read DW_AT_allocated and set in type. */
25383 attr = dwarf2_attr (die, DW_AT_allocated, cu);
25384 if (attr_form_is_block (attr))
25386 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25387 add_dyn_prop (DYN_PROP_ALLOCATED, prop, type);
25389 else if (attr != NULL)
25391 complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25392 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25393 sect_offset_str (die->sect_off));
25396 /* Read DW_AT_associated and set in type. */
25397 attr = dwarf2_attr (die, DW_AT_associated, cu);
25398 if (attr_form_is_block (attr))
25400 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25401 add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type);
25403 else if (attr != NULL)
25405 complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25406 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25407 sect_offset_str (die->sect_off));
25410 /* Read DW_AT_data_location and set in type. */
25411 attr = dwarf2_attr (die, DW_AT_data_location, cu);
25412 if (attr_to_dynamic_prop (attr, die, cu, &prop))
25413 add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type);
25415 if (dwarf2_per_objfile->die_type_hash == NULL)
25417 dwarf2_per_objfile->die_type_hash =
25418 htab_create_alloc_ex (127,
25419 per_cu_offset_and_type_hash,
25420 per_cu_offset_and_type_eq,
25422 &objfile->objfile_obstack,
25423 hashtab_obstack_allocate,
25424 dummy_obstack_deallocate);
25427 ofs.per_cu = cu->per_cu;
25428 ofs.sect_off = die->sect_off;
25430 slot = (struct dwarf2_per_cu_offset_and_type **)
25431 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
25433 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25434 sect_offset_str (die->sect_off));
25435 *slot = XOBNEW (&objfile->objfile_obstack,
25436 struct dwarf2_per_cu_offset_and_type);
25441 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25442 or return NULL if the die does not have a saved type. */
25444 static struct type *
25445 get_die_type_at_offset (sect_offset sect_off,
25446 struct dwarf2_per_cu_data *per_cu)
25448 struct dwarf2_per_cu_offset_and_type *slot, ofs;
25449 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
25451 if (dwarf2_per_objfile->die_type_hash == NULL)
25454 ofs.per_cu = per_cu;
25455 ofs.sect_off = sect_off;
25456 slot = ((struct dwarf2_per_cu_offset_and_type *)
25457 htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
25464 /* Look up the type for DIE in CU in die_type_hash,
25465 or return NULL if DIE does not have a saved type. */
25467 static struct type *
25468 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
25470 return get_die_type_at_offset (die->sect_off, cu->per_cu);
25473 /* Add a dependence relationship from CU to REF_PER_CU. */
25476 dwarf2_add_dependence (struct dwarf2_cu *cu,
25477 struct dwarf2_per_cu_data *ref_per_cu)
25481 if (cu->dependencies == NULL)
25483 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
25484 NULL, &cu->comp_unit_obstack,
25485 hashtab_obstack_allocate,
25486 dummy_obstack_deallocate);
25488 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
25490 *slot = ref_per_cu;
25493 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25494 Set the mark field in every compilation unit in the
25495 cache that we must keep because we are keeping CU. */
25498 dwarf2_mark_helper (void **slot, void *data)
25500 struct dwarf2_per_cu_data *per_cu;
25502 per_cu = (struct dwarf2_per_cu_data *) *slot;
25504 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25505 reading of the chain. As such dependencies remain valid it is not much
25506 useful to track and undo them during QUIT cleanups. */
25507 if (per_cu->cu == NULL)
25510 if (per_cu->cu->mark)
25512 per_cu->cu->mark = true;
25514 if (per_cu->cu->dependencies != NULL)
25515 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
25520 /* Set the mark field in CU and in every other compilation unit in the
25521 cache that we must keep because we are keeping CU. */
25524 dwarf2_mark (struct dwarf2_cu *cu)
25529 if (cu->dependencies != NULL)
25530 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
25534 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
25538 per_cu->cu->mark = false;
25539 per_cu = per_cu->cu->read_in_chain;
25543 /* Trivial hash function for partial_die_info: the hash value of a DIE
25544 is its offset in .debug_info for this objfile. */
25547 partial_die_hash (const void *item)
25549 const struct partial_die_info *part_die
25550 = (const struct partial_die_info *) item;
25552 return to_underlying (part_die->sect_off);
25555 /* Trivial comparison function for partial_die_info structures: two DIEs
25556 are equal if they have the same offset. */
25559 partial_die_eq (const void *item_lhs, const void *item_rhs)
25561 const struct partial_die_info *part_die_lhs
25562 = (const struct partial_die_info *) item_lhs;
25563 const struct partial_die_info *part_die_rhs
25564 = (const struct partial_die_info *) item_rhs;
25566 return part_die_lhs->sect_off == part_die_rhs->sect_off;
25569 struct cmd_list_element *set_dwarf_cmdlist;
25570 struct cmd_list_element *show_dwarf_cmdlist;
25573 set_dwarf_cmd (const char *args, int from_tty)
25575 help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
25580 show_dwarf_cmd (const char *args, int from_tty)
25582 cmd_show_list (show_dwarf_cmdlist, from_tty, "");
25585 int dwarf_always_disassemble;
25588 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
25589 struct cmd_list_element *c, const char *value)
25591 fprintf_filtered (file,
25592 _("Whether to always disassemble "
25593 "DWARF expressions is %s.\n"),
25598 show_check_physname (struct ui_file *file, int from_tty,
25599 struct cmd_list_element *c, const char *value)
25601 fprintf_filtered (file,
25602 _("Whether to check \"physname\" is %s.\n"),
25607 _initialize_dwarf2_read (void)
25609 dwarf2_objfile_data_key
25610 = register_objfile_data_with_cleanup (nullptr, dwarf2_free_objfile);
25612 add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
25613 Set DWARF specific variables.\n\
25614 Configure DWARF variables such as the cache size"),
25615 &set_dwarf_cmdlist, "maintenance set dwarf ",
25616 0/*allow-unknown*/, &maintenance_set_cmdlist);
25618 add_prefix_cmd ("dwarf", class_maintenance, show_dwarf_cmd, _("\
25619 Show DWARF specific variables\n\
25620 Show DWARF variables such as the cache size"),
25621 &show_dwarf_cmdlist, "maintenance show dwarf ",
25622 0/*allow-unknown*/, &maintenance_show_cmdlist);
25624 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
25625 &dwarf_max_cache_age, _("\
25626 Set the upper bound on the age of cached DWARF compilation units."), _("\
25627 Show the upper bound on the age of cached DWARF compilation units."), _("\
25628 A higher limit means that cached compilation units will be stored\n\
25629 in memory longer, and more total memory will be used. Zero disables\n\
25630 caching, which can slow down startup."),
25632 show_dwarf_max_cache_age,
25633 &set_dwarf_cmdlist,
25634 &show_dwarf_cmdlist);
25636 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
25637 &dwarf_always_disassemble, _("\
25638 Set whether `info address' always disassembles DWARF expressions."), _("\
25639 Show whether `info address' always disassembles DWARF expressions."), _("\
25640 When enabled, DWARF expressions are always printed in an assembly-like\n\
25641 syntax. When disabled, expressions will be printed in a more\n\
25642 conversational style, when possible."),
25644 show_dwarf_always_disassemble,
25645 &set_dwarf_cmdlist,
25646 &show_dwarf_cmdlist);
25648 add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
25649 Set debugging of the DWARF reader."), _("\
25650 Show debugging of the DWARF reader."), _("\
25651 When enabled (non-zero), debugging messages are printed during DWARF\n\
25652 reading and symtab expansion. A value of 1 (one) provides basic\n\
25653 information. A value greater than 1 provides more verbose information."),
25656 &setdebuglist, &showdebuglist);
25658 add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
25659 Set debugging of the DWARF DIE reader."), _("\
25660 Show debugging of the DWARF DIE reader."), _("\
25661 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25662 The value is the maximum depth to print."),
25665 &setdebuglist, &showdebuglist);
25667 add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
25668 Set debugging of the dwarf line reader."), _("\
25669 Show debugging of the dwarf line reader."), _("\
25670 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25671 A value of 1 (one) provides basic information.\n\
25672 A value greater than 1 provides more verbose information."),
25675 &setdebuglist, &showdebuglist);
25677 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
25678 Set cross-checking of \"physname\" code against demangler."), _("\
25679 Show cross-checking of \"physname\" code against demangler."), _("\
25680 When enabled, GDB's internal \"physname\" code is checked against\n\
25682 NULL, show_check_physname,
25683 &setdebuglist, &showdebuglist);
25685 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25686 no_class, &use_deprecated_index_sections, _("\
25687 Set whether to use deprecated gdb_index sections."), _("\
25688 Show whether to use deprecated gdb_index sections."), _("\
25689 When enabled, deprecated .gdb_index sections are used anyway.\n\
25690 Normally they are ignored either because of a missing feature or\n\
25691 performance issue.\n\
25692 Warning: This option must be enabled before gdb reads the file."),
25695 &setlist, &showlist);
25697 dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
25698 &dwarf2_locexpr_funcs);
25699 dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
25700 &dwarf2_loclist_funcs);
25702 dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
25703 &dwarf2_block_frame_base_locexpr_funcs);
25704 dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
25705 &dwarf2_block_frame_base_loclist_funcs);
25708 selftests::register_test ("dw2_expand_symtabs_matching",
25709 selftests::dw2_expand_symtabs_matching::run_test);