1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2019 Free Software Foundation, Inc.
5 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
6 Inc. with support from Florida State University (under contract
7 with the Ada Joint Program Office), and Silicon Graphics, Inc.
8 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
9 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
12 This file is part of GDB.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 /* FIXME: Various die-reading functions need to be more careful with
28 reading off the end of the section.
29 E.g., load_partial_dies, read_partial_die. */
32 #include "dwarf2read.h"
33 #include "dwarf-index-cache.h"
34 #include "dwarf-index-common.h"
43 #include "gdb-demangle.h"
44 #include "expression.h"
45 #include "filenames.h" /* for DOSish file names */
48 #include "complaints.h"
49 #include "dwarf2expr.h"
50 #include "dwarf2loc.h"
51 #include "cp-support.h"
57 #include "typeprint.h"
60 #include "completer.h"
61 #include "gdbsupport/vec.h"
65 #include "gdbcore.h" /* for gnutarget */
66 #include "gdb/gdb-index.h"
71 #include "gdbsupport/filestuff.h"
73 #include "namespace.h"
74 #include "gdbsupport/gdb_unlinker.h"
75 #include "gdbsupport/function-view.h"
76 #include "gdbsupport/gdb_optional.h"
77 #include "gdbsupport/underlying.h"
78 #include "gdbsupport/byte-vector.h"
79 #include "gdbsupport/hash_enum.h"
80 #include "filename-seen-cache.h"
83 #include <sys/types.h>
85 #include <unordered_set>
86 #include <unordered_map>
87 #include "gdbsupport/selftest.h"
90 #include <forward_list>
91 #include "rust-lang.h"
92 #include "gdbsupport/pathstuff.h"
94 /* When == 1, print basic high level tracing messages.
95 When > 1, be more verbose.
96 This is in contrast to the low level DIE reading of dwarf_die_debug. */
97 static unsigned int dwarf_read_debug = 0;
99 /* When non-zero, dump DIEs after they are read in. */
100 static unsigned int dwarf_die_debug = 0;
102 /* When non-zero, dump line number entries as they are read in. */
103 static unsigned int dwarf_line_debug = 0;
105 /* When non-zero, cross-check physname against demangler. */
106 static int check_physname = 0;
108 /* When non-zero, do not reject deprecated .gdb_index sections. */
109 static int use_deprecated_index_sections = 0;
111 static const struct objfile_key<dwarf2_per_objfile> dwarf2_objfile_data_key;
113 /* The "aclass" indices for various kinds of computed DWARF symbols. */
115 static int dwarf2_locexpr_index;
116 static int dwarf2_loclist_index;
117 static int dwarf2_locexpr_block_index;
118 static int dwarf2_loclist_block_index;
120 /* An index into a (C++) symbol name component in a symbol name as
121 recorded in the mapped_index's symbol table. For each C++ symbol
122 in the symbol table, we record one entry for the start of each
123 component in the symbol in a table of name components, and then
124 sort the table, in order to be able to binary search symbol names,
125 ignoring leading namespaces, both completion and regular look up.
126 For example, for symbol "A::B::C", we'll have an entry that points
127 to "A::B::C", another that points to "B::C", and another for "C".
128 Note that function symbols in GDB index have no parameter
129 information, just the function/method names. You can convert a
130 name_component to a "const char *" using the
131 'mapped_index::symbol_name_at(offset_type)' method. */
133 struct name_component
135 /* Offset in the symbol name where the component starts. Stored as
136 a (32-bit) offset instead of a pointer to save memory and improve
137 locality on 64-bit architectures. */
138 offset_type name_offset;
140 /* The symbol's index in the symbol and constant pool tables of a
145 /* Base class containing bits shared by both .gdb_index and
146 .debug_name indexes. */
148 struct mapped_index_base
150 mapped_index_base () = default;
151 DISABLE_COPY_AND_ASSIGN (mapped_index_base);
153 /* The name_component table (a sorted vector). See name_component's
154 description above. */
155 std::vector<name_component> name_components;
157 /* How NAME_COMPONENTS is sorted. */
158 enum case_sensitivity name_components_casing;
160 /* Return the number of names in the symbol table. */
161 virtual size_t symbol_name_count () const = 0;
163 /* Get the name of the symbol at IDX in the symbol table. */
164 virtual const char *symbol_name_at (offset_type idx) const = 0;
166 /* Return whether the name at IDX in the symbol table should be
168 virtual bool symbol_name_slot_invalid (offset_type idx) const
173 /* Build the symbol name component sorted vector, if we haven't
175 void build_name_components ();
177 /* Returns the lower (inclusive) and upper (exclusive) bounds of the
178 possible matches for LN_NO_PARAMS in the name component
180 std::pair<std::vector<name_component>::const_iterator,
181 std::vector<name_component>::const_iterator>
182 find_name_components_bounds (const lookup_name_info &ln_no_params) const;
184 /* Prevent deleting/destroying via a base class pointer. */
186 ~mapped_index_base() = default;
189 /* A description of the mapped index. The file format is described in
190 a comment by the code that writes the index. */
191 struct mapped_index final : public mapped_index_base
193 /* A slot/bucket in the symbol table hash. */
194 struct symbol_table_slot
196 const offset_type name;
197 const offset_type vec;
200 /* Index data format version. */
203 /* The address table data. */
204 gdb::array_view<const gdb_byte> address_table;
206 /* The symbol table, implemented as a hash table. */
207 gdb::array_view<symbol_table_slot> symbol_table;
209 /* A pointer to the constant pool. */
210 const char *constant_pool = nullptr;
212 bool symbol_name_slot_invalid (offset_type idx) const override
214 const auto &bucket = this->symbol_table[idx];
215 return bucket.name == 0 && bucket.vec == 0;
218 /* Convenience method to get at the name of the symbol at IDX in the
220 const char *symbol_name_at (offset_type idx) const override
221 { return this->constant_pool + MAYBE_SWAP (this->symbol_table[idx].name); }
223 size_t symbol_name_count () const override
224 { return this->symbol_table.size (); }
227 /* A description of the mapped .debug_names.
228 Uninitialized map has CU_COUNT 0. */
229 struct mapped_debug_names final : public mapped_index_base
231 mapped_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile_)
232 : dwarf2_per_objfile (dwarf2_per_objfile_)
235 struct dwarf2_per_objfile *dwarf2_per_objfile;
236 bfd_endian dwarf5_byte_order;
237 bool dwarf5_is_dwarf64;
238 bool augmentation_is_gdb;
240 uint32_t cu_count = 0;
241 uint32_t tu_count, bucket_count, name_count;
242 const gdb_byte *cu_table_reordered, *tu_table_reordered;
243 const uint32_t *bucket_table_reordered, *hash_table_reordered;
244 const gdb_byte *name_table_string_offs_reordered;
245 const gdb_byte *name_table_entry_offs_reordered;
246 const gdb_byte *entry_pool;
253 /* Attribute name DW_IDX_*. */
256 /* Attribute form DW_FORM_*. */
259 /* Value if FORM is DW_FORM_implicit_const. */
260 LONGEST implicit_const;
262 std::vector<attr> attr_vec;
265 std::unordered_map<ULONGEST, index_val> abbrev_map;
267 const char *namei_to_name (uint32_t namei) const;
269 /* Implementation of the mapped_index_base virtual interface, for
270 the name_components cache. */
272 const char *symbol_name_at (offset_type idx) const override
273 { return namei_to_name (idx); }
275 size_t symbol_name_count () const override
276 { return this->name_count; }
279 /* See dwarf2read.h. */
282 get_dwarf2_per_objfile (struct objfile *objfile)
284 return dwarf2_objfile_data_key.get (objfile);
287 /* Default names of the debugging sections. */
289 /* Note that if the debugging section has been compressed, it might
290 have a name like .zdebug_info. */
292 static const struct dwarf2_debug_sections dwarf2_elf_names =
294 { ".debug_info", ".zdebug_info" },
295 { ".debug_abbrev", ".zdebug_abbrev" },
296 { ".debug_line", ".zdebug_line" },
297 { ".debug_loc", ".zdebug_loc" },
298 { ".debug_loclists", ".zdebug_loclists" },
299 { ".debug_macinfo", ".zdebug_macinfo" },
300 { ".debug_macro", ".zdebug_macro" },
301 { ".debug_str", ".zdebug_str" },
302 { ".debug_line_str", ".zdebug_line_str" },
303 { ".debug_ranges", ".zdebug_ranges" },
304 { ".debug_rnglists", ".zdebug_rnglists" },
305 { ".debug_types", ".zdebug_types" },
306 { ".debug_addr", ".zdebug_addr" },
307 { ".debug_frame", ".zdebug_frame" },
308 { ".eh_frame", NULL },
309 { ".gdb_index", ".zgdb_index" },
310 { ".debug_names", ".zdebug_names" },
311 { ".debug_aranges", ".zdebug_aranges" },
315 /* List of DWO/DWP sections. */
317 static const struct dwop_section_names
319 struct dwarf2_section_names abbrev_dwo;
320 struct dwarf2_section_names info_dwo;
321 struct dwarf2_section_names line_dwo;
322 struct dwarf2_section_names loc_dwo;
323 struct dwarf2_section_names loclists_dwo;
324 struct dwarf2_section_names macinfo_dwo;
325 struct dwarf2_section_names macro_dwo;
326 struct dwarf2_section_names str_dwo;
327 struct dwarf2_section_names str_offsets_dwo;
328 struct dwarf2_section_names types_dwo;
329 struct dwarf2_section_names cu_index;
330 struct dwarf2_section_names tu_index;
334 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
335 { ".debug_info.dwo", ".zdebug_info.dwo" },
336 { ".debug_line.dwo", ".zdebug_line.dwo" },
337 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
338 { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
339 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
340 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
341 { ".debug_str.dwo", ".zdebug_str.dwo" },
342 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
343 { ".debug_types.dwo", ".zdebug_types.dwo" },
344 { ".debug_cu_index", ".zdebug_cu_index" },
345 { ".debug_tu_index", ".zdebug_tu_index" },
348 /* local data types */
350 /* The data in a compilation unit header, after target2host
351 translation, looks like this. */
352 struct comp_unit_head
356 unsigned char addr_size;
357 unsigned char signed_addr_p;
358 sect_offset abbrev_sect_off;
360 /* Size of file offsets; either 4 or 8. */
361 unsigned int offset_size;
363 /* Size of the length field; either 4 or 12. */
364 unsigned int initial_length_size;
366 enum dwarf_unit_type unit_type;
368 /* Offset to the first byte of this compilation unit header in the
369 .debug_info section, for resolving relative reference dies. */
370 sect_offset sect_off;
372 /* Offset to first die in this cu from the start of the cu.
373 This will be the first byte following the compilation unit header. */
374 cu_offset first_die_cu_offset;
376 /* 64-bit signature of this type unit - it is valid only for
377 UNIT_TYPE DW_UT_type. */
380 /* For types, offset in the type's DIE of the type defined by this TU. */
381 cu_offset type_cu_offset_in_tu;
384 /* Type used for delaying computation of method physnames.
385 See comments for compute_delayed_physnames. */
386 struct delayed_method_info
388 /* The type to which the method is attached, i.e., its parent class. */
391 /* The index of the method in the type's function fieldlists. */
394 /* The index of the method in the fieldlist. */
397 /* The name of the DIE. */
400 /* The DIE associated with this method. */
401 struct die_info *die;
404 /* Internal state when decoding a particular compilation unit. */
407 explicit dwarf2_cu (struct dwarf2_per_cu_data *per_cu);
410 DISABLE_COPY_AND_ASSIGN (dwarf2_cu);
412 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
413 Create the set of symtabs used by this TU, or if this TU is sharing
414 symtabs with another TU and the symtabs have already been created
415 then restore those symtabs in the line header.
416 We don't need the pc/line-number mapping for type units. */
417 void setup_type_unit_groups (struct die_info *die);
419 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
420 buildsym_compunit constructor. */
421 struct compunit_symtab *start_symtab (const char *name,
422 const char *comp_dir,
425 /* Reset the builder. */
426 void reset_builder () { m_builder.reset (); }
428 /* The header of the compilation unit. */
429 struct comp_unit_head header {};
431 /* Base address of this compilation unit. */
432 CORE_ADDR base_address = 0;
434 /* Non-zero if base_address has been set. */
437 /* The language we are debugging. */
438 enum language language = language_unknown;
439 const struct language_defn *language_defn = nullptr;
441 const char *producer = nullptr;
444 /* The symtab builder for this CU. This is only non-NULL when full
445 symbols are being read. */
446 std::unique_ptr<buildsym_compunit> m_builder;
449 /* The generic symbol table building routines have separate lists for
450 file scope symbols and all all other scopes (local scopes). So
451 we need to select the right one to pass to add_symbol_to_list().
452 We do it by keeping a pointer to the correct list in list_in_scope.
454 FIXME: The original dwarf code just treated the file scope as the
455 first local scope, and all other local scopes as nested local
456 scopes, and worked fine. Check to see if we really need to
457 distinguish these in buildsym.c. */
458 struct pending **list_in_scope = nullptr;
460 /* Hash table holding all the loaded partial DIEs
461 with partial_die->offset.SECT_OFF as hash. */
462 htab_t partial_dies = nullptr;
464 /* Storage for things with the same lifetime as this read-in compilation
465 unit, including partial DIEs. */
466 auto_obstack comp_unit_obstack;
468 /* When multiple dwarf2_cu structures are living in memory, this field
469 chains them all together, so that they can be released efficiently.
470 We will probably also want a generation counter so that most-recently-used
471 compilation units are cached... */
472 struct dwarf2_per_cu_data *read_in_chain = nullptr;
474 /* Backlink to our per_cu entry. */
475 struct dwarf2_per_cu_data *per_cu;
477 /* How many compilation units ago was this CU last referenced? */
480 /* A hash table of DIE cu_offset for following references with
481 die_info->offset.sect_off as hash. */
482 htab_t die_hash = nullptr;
484 /* Full DIEs if read in. */
485 struct die_info *dies = nullptr;
487 /* A set of pointers to dwarf2_per_cu_data objects for compilation
488 units referenced by this one. Only set during full symbol processing;
489 partial symbol tables do not have dependencies. */
490 htab_t dependencies = nullptr;
492 /* Header data from the line table, during full symbol processing. */
493 struct line_header *line_header = nullptr;
494 /* Non-NULL if LINE_HEADER is owned by this DWARF_CU. Otherwise,
495 it's owned by dwarf2_per_objfile::line_header_hash. If non-NULL,
496 this is the DW_TAG_compile_unit die for this CU. We'll hold on
497 to the line header as long as this DIE is being processed. See
498 process_die_scope. */
499 die_info *line_header_die_owner = nullptr;
501 /* A list of methods which need to have physnames computed
502 after all type information has been read. */
503 std::vector<delayed_method_info> method_list;
505 /* To be copied to symtab->call_site_htab. */
506 htab_t call_site_htab = nullptr;
508 /* Non-NULL if this CU came from a DWO file.
509 There is an invariant here that is important to remember:
510 Except for attributes copied from the top level DIE in the "main"
511 (or "stub") file in preparation for reading the DWO file
512 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
513 Either there isn't a DWO file (in which case this is NULL and the point
514 is moot), or there is and either we're not going to read it (in which
515 case this is NULL) or there is and we are reading it (in which case this
517 struct dwo_unit *dwo_unit = nullptr;
519 /* The DW_AT_addr_base attribute if present, zero otherwise
520 (zero is a valid value though).
521 Note this value comes from the Fission stub CU/TU's DIE. */
522 ULONGEST addr_base = 0;
524 /* The DW_AT_ranges_base attribute if present, zero otherwise
525 (zero is a valid value though).
526 Note this value comes from the Fission stub CU/TU's DIE.
527 Also note that the value is zero in the non-DWO case so this value can
528 be used without needing to know whether DWO files are in use or not.
529 N.B. This does not apply to DW_AT_ranges appearing in
530 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
531 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
532 DW_AT_ranges_base *would* have to be applied, and we'd have to care
533 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
534 ULONGEST ranges_base = 0;
536 /* When reading debug info generated by older versions of rustc, we
537 have to rewrite some union types to be struct types with a
538 variant part. This rewriting must be done after the CU is fully
539 read in, because otherwise at the point of rewriting some struct
540 type might not have been fully processed. So, we keep a list of
541 all such types here and process them after expansion. */
542 std::vector<struct type *> rust_unions;
544 /* Mark used when releasing cached dies. */
547 /* This CU references .debug_loc. See the symtab->locations_valid field.
548 This test is imperfect as there may exist optimized debug code not using
549 any location list and still facing inlining issues if handled as
550 unoptimized code. For a future better test see GCC PR other/32998. */
551 bool has_loclist : 1;
553 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is true
554 if all the producer_is_* fields are valid. This information is cached
555 because profiling CU expansion showed excessive time spent in
556 producer_is_gxx_lt_4_6. */
557 bool checked_producer : 1;
558 bool producer_is_gxx_lt_4_6 : 1;
559 bool producer_is_gcc_lt_4_3 : 1;
560 bool producer_is_icc : 1;
561 bool producer_is_icc_lt_14 : 1;
562 bool producer_is_codewarrior : 1;
564 /* When true, the file that we're processing is known to have
565 debugging info for C++ namespaces. GCC 3.3.x did not produce
566 this information, but later versions do. */
568 bool processing_has_namespace_info : 1;
570 struct partial_die_info *find_partial_die (sect_offset sect_off);
572 /* If this CU was inherited by another CU (via specification,
573 abstract_origin, etc), this is the ancestor CU. */
576 /* Get the buildsym_compunit for this CU. */
577 buildsym_compunit *get_builder ()
579 /* If this CU has a builder associated with it, use that. */
580 if (m_builder != nullptr)
581 return m_builder.get ();
583 /* Otherwise, search ancestors for a valid builder. */
584 if (ancestor != nullptr)
585 return ancestor->get_builder ();
591 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
592 This includes type_unit_group and quick_file_names. */
594 struct stmt_list_hash
596 /* The DWO unit this table is from or NULL if there is none. */
597 struct dwo_unit *dwo_unit;
599 /* Offset in .debug_line or .debug_line.dwo. */
600 sect_offset line_sect_off;
603 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
604 an object of this type. */
606 struct type_unit_group
608 /* dwarf2read.c's main "handle" on a TU symtab.
609 To simplify things we create an artificial CU that "includes" all the
610 type units using this stmt_list so that the rest of the code still has
611 a "per_cu" handle on the symtab.
612 This PER_CU is recognized by having no section. */
613 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
614 struct dwarf2_per_cu_data per_cu;
616 /* The TUs that share this DW_AT_stmt_list entry.
617 This is added to while parsing type units to build partial symtabs,
618 and is deleted afterwards and not used again. */
619 VEC (sig_type_ptr) *tus;
621 /* The compunit symtab.
622 Type units in a group needn't all be defined in the same source file,
623 so we create an essentially anonymous symtab as the compunit symtab. */
624 struct compunit_symtab *compunit_symtab;
626 /* The data used to construct the hash key. */
627 struct stmt_list_hash hash;
629 /* The number of symtabs from the line header.
630 The value here must match line_header.num_file_names. */
631 unsigned int num_symtabs;
633 /* The symbol tables for this TU (obtained from the files listed in
635 WARNING: The order of entries here must match the order of entries
636 in the line header. After the first TU using this type_unit_group, the
637 line header for the subsequent TUs is recreated from this. This is done
638 because we need to use the same symtabs for each TU using the same
639 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
640 there's no guarantee the line header doesn't have duplicate entries. */
641 struct symtab **symtabs;
644 /* These sections are what may appear in a (real or virtual) DWO file. */
648 struct dwarf2_section_info abbrev;
649 struct dwarf2_section_info line;
650 struct dwarf2_section_info loc;
651 struct dwarf2_section_info loclists;
652 struct dwarf2_section_info macinfo;
653 struct dwarf2_section_info macro;
654 struct dwarf2_section_info str;
655 struct dwarf2_section_info str_offsets;
656 /* In the case of a virtual DWO file, these two are unused. */
657 struct dwarf2_section_info info;
658 std::vector<dwarf2_section_info> types;
661 /* CUs/TUs in DWP/DWO files. */
665 /* Backlink to the containing struct dwo_file. */
666 struct dwo_file *dwo_file;
668 /* The "id" that distinguishes this CU/TU.
669 .debug_info calls this "dwo_id", .debug_types calls this "signature".
670 Since signatures came first, we stick with it for consistency. */
673 /* The section this CU/TU lives in, in the DWO file. */
674 struct dwarf2_section_info *section;
676 /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section. */
677 sect_offset sect_off;
680 /* For types, offset in the type's DIE of the type defined by this TU. */
681 cu_offset type_offset_in_tu;
684 /* include/dwarf2.h defines the DWP section codes.
685 It defines a max value but it doesn't define a min value, which we
686 use for error checking, so provide one. */
688 enum dwp_v2_section_ids
693 /* Data for one DWO file.
695 This includes virtual DWO files (a virtual DWO file is a DWO file as it
696 appears in a DWP file). DWP files don't really have DWO files per se -
697 comdat folding of types "loses" the DWO file they came from, and from
698 a high level view DWP files appear to contain a mass of random types.
699 However, to maintain consistency with the non-DWP case we pretend DWP
700 files contain virtual DWO files, and we assign each TU with one virtual
701 DWO file (generally based on the line and abbrev section offsets -
702 a heuristic that seems to work in practice). */
706 dwo_file () = default;
707 DISABLE_COPY_AND_ASSIGN (dwo_file);
709 /* The DW_AT_GNU_dwo_name attribute.
710 For virtual DWO files the name is constructed from the section offsets
711 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
712 from related CU+TUs. */
713 const char *dwo_name = nullptr;
715 /* The DW_AT_comp_dir attribute. */
716 const char *comp_dir = nullptr;
718 /* The bfd, when the file is open. Otherwise this is NULL.
719 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
720 gdb_bfd_ref_ptr dbfd;
722 /* The sections that make up this DWO file.
723 Remember that for virtual DWO files in DWP V2, these are virtual
724 sections (for lack of a better name). */
725 struct dwo_sections sections {};
727 /* The CUs in the file.
728 Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
729 an extension to handle LLVM's Link Time Optimization output (where
730 multiple source files may be compiled into a single object/dwo pair). */
733 /* Table of TUs in the file.
734 Each element is a struct dwo_unit. */
738 /* These sections are what may appear in a DWP file. */
742 /* These are used by both DWP version 1 and 2. */
743 struct dwarf2_section_info str;
744 struct dwarf2_section_info cu_index;
745 struct dwarf2_section_info tu_index;
747 /* These are only used by DWP version 2 files.
748 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
749 sections are referenced by section number, and are not recorded here.
750 In DWP version 2 there is at most one copy of all these sections, each
751 section being (effectively) comprised of the concatenation of all of the
752 individual sections that exist in the version 1 format.
753 To keep the code simple we treat each of these concatenated pieces as a
754 section itself (a virtual section?). */
755 struct dwarf2_section_info abbrev;
756 struct dwarf2_section_info info;
757 struct dwarf2_section_info line;
758 struct dwarf2_section_info loc;
759 struct dwarf2_section_info macinfo;
760 struct dwarf2_section_info macro;
761 struct dwarf2_section_info str_offsets;
762 struct dwarf2_section_info types;
765 /* These sections are what may appear in a virtual DWO file in DWP version 1.
766 A virtual DWO file is a DWO file as it appears in a DWP file. */
768 struct virtual_v1_dwo_sections
770 struct dwarf2_section_info abbrev;
771 struct dwarf2_section_info line;
772 struct dwarf2_section_info loc;
773 struct dwarf2_section_info macinfo;
774 struct dwarf2_section_info macro;
775 struct dwarf2_section_info str_offsets;
776 /* Each DWP hash table entry records one CU or one TU.
777 That is recorded here, and copied to dwo_unit.section. */
778 struct dwarf2_section_info info_or_types;
781 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
782 In version 2, the sections of the DWO files are concatenated together
783 and stored in one section of that name. Thus each ELF section contains
784 several "virtual" sections. */
786 struct virtual_v2_dwo_sections
788 bfd_size_type abbrev_offset;
789 bfd_size_type abbrev_size;
791 bfd_size_type line_offset;
792 bfd_size_type line_size;
794 bfd_size_type loc_offset;
795 bfd_size_type loc_size;
797 bfd_size_type macinfo_offset;
798 bfd_size_type macinfo_size;
800 bfd_size_type macro_offset;
801 bfd_size_type macro_size;
803 bfd_size_type str_offsets_offset;
804 bfd_size_type str_offsets_size;
806 /* Each DWP hash table entry records one CU or one TU.
807 That is recorded here, and copied to dwo_unit.section. */
808 bfd_size_type info_or_types_offset;
809 bfd_size_type info_or_types_size;
812 /* Contents of DWP hash tables. */
814 struct dwp_hash_table
816 uint32_t version, nr_columns;
817 uint32_t nr_units, nr_slots;
818 const gdb_byte *hash_table, *unit_table;
823 const gdb_byte *indices;
827 /* This is indexed by column number and gives the id of the section
829 #define MAX_NR_V2_DWO_SECTIONS \
830 (1 /* .debug_info or .debug_types */ \
831 + 1 /* .debug_abbrev */ \
832 + 1 /* .debug_line */ \
833 + 1 /* .debug_loc */ \
834 + 1 /* .debug_str_offsets */ \
835 + 1 /* .debug_macro or .debug_macinfo */)
836 int section_ids[MAX_NR_V2_DWO_SECTIONS];
837 const gdb_byte *offsets;
838 const gdb_byte *sizes;
843 /* Data for one DWP file. */
847 dwp_file (const char *name_, gdb_bfd_ref_ptr &&abfd)
849 dbfd (std::move (abfd))
853 /* Name of the file. */
856 /* File format version. */
860 gdb_bfd_ref_ptr dbfd;
862 /* Section info for this file. */
863 struct dwp_sections sections {};
865 /* Table of CUs in the file. */
866 const struct dwp_hash_table *cus = nullptr;
868 /* Table of TUs in the file. */
869 const struct dwp_hash_table *tus = nullptr;
871 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
872 htab_t loaded_cus {};
873 htab_t loaded_tus {};
875 /* Table to map ELF section numbers to their sections.
876 This is only needed for the DWP V1 file format. */
877 unsigned int num_sections = 0;
878 asection **elf_sections = nullptr;
881 /* Struct used to pass misc. parameters to read_die_and_children, et
882 al. which are used for both .debug_info and .debug_types dies.
883 All parameters here are unchanging for the life of the call. This
884 struct exists to abstract away the constant parameters of die reading. */
886 struct die_reader_specs
888 /* The bfd of die_section. */
891 /* The CU of the DIE we are parsing. */
892 struct dwarf2_cu *cu;
894 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
895 struct dwo_file *dwo_file;
897 /* The section the die comes from.
898 This is either .debug_info or .debug_types, or the .dwo variants. */
899 struct dwarf2_section_info *die_section;
901 /* die_section->buffer. */
902 const gdb_byte *buffer;
904 /* The end of the buffer. */
905 const gdb_byte *buffer_end;
907 /* The value of the DW_AT_comp_dir attribute. */
908 const char *comp_dir;
910 /* The abbreviation table to use when reading the DIEs. */
911 struct abbrev_table *abbrev_table;
914 /* Type of function passed to init_cutu_and_read_dies, et.al. */
915 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
916 const gdb_byte *info_ptr,
917 struct die_info *comp_unit_die,
921 /* A 1-based directory index. This is a strong typedef to prevent
922 accidentally using a directory index as a 0-based index into an
924 enum class dir_index : unsigned int {};
926 /* Likewise, a 1-based file name index. */
927 enum class file_name_index : unsigned int {};
931 file_entry () = default;
933 file_entry (const char *name_, dir_index d_index_,
934 unsigned int mod_time_, unsigned int length_)
937 mod_time (mod_time_),
941 /* Return the include directory at D_INDEX stored in LH. Returns
942 NULL if D_INDEX is out of bounds. */
943 const char *include_dir (const line_header *lh) const;
945 /* The file name. Note this is an observing pointer. The memory is
946 owned by debug_line_buffer. */
949 /* The directory index (1-based). */
950 dir_index d_index {};
952 unsigned int mod_time {};
954 unsigned int length {};
956 /* True if referenced by the Line Number Program. */
959 /* The associated symbol table, if any. */
960 struct symtab *symtab {};
963 /* The line number information for a compilation unit (found in the
964 .debug_line section) begins with a "statement program header",
965 which contains the following information. */
972 /* Add an entry to the include directory table. */
973 void add_include_dir (const char *include_dir);
975 /* Add an entry to the file name table. */
976 void add_file_name (const char *name, dir_index d_index,
977 unsigned int mod_time, unsigned int length);
979 /* Return the include dir at INDEX (1-based). Returns NULL if INDEX
981 const char *include_dir_at (dir_index index) const
983 /* Convert directory index number (1-based) to vector index
985 size_t vec_index = to_underlying (index) - 1;
987 if (vec_index >= include_dirs.size ())
989 return include_dirs[vec_index];
992 /* Return the file name at INDEX (1-based). Returns NULL if INDEX
994 file_entry *file_name_at (file_name_index index)
996 /* Convert file name index number (1-based) to vector index
998 size_t vec_index = to_underlying (index) - 1;
1000 if (vec_index >= file_names.size ())
1002 return &file_names[vec_index];
1005 /* Offset of line number information in .debug_line section. */
1006 sect_offset sect_off {};
1008 /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1009 unsigned offset_in_dwz : 1; /* Can't initialize bitfields in-class. */
1011 unsigned int total_length {};
1012 unsigned short version {};
1013 unsigned int header_length {};
1014 unsigned char minimum_instruction_length {};
1015 unsigned char maximum_ops_per_instruction {};
1016 unsigned char default_is_stmt {};
1018 unsigned char line_range {};
1019 unsigned char opcode_base {};
1021 /* standard_opcode_lengths[i] is the number of operands for the
1022 standard opcode whose value is i. This means that
1023 standard_opcode_lengths[0] is unused, and the last meaningful
1024 element is standard_opcode_lengths[opcode_base - 1]. */
1025 std::unique_ptr<unsigned char[]> standard_opcode_lengths;
1027 /* The include_directories table. Note these are observing
1028 pointers. The memory is owned by debug_line_buffer. */
1029 std::vector<const char *> include_dirs;
1031 /* The file_names table. */
1032 std::vector<file_entry> file_names;
1034 /* The start and end of the statement program following this
1035 header. These point into dwarf2_per_objfile->line_buffer. */
1036 const gdb_byte *statement_program_start {}, *statement_program_end {};
1039 typedef std::unique_ptr<line_header> line_header_up;
1042 file_entry::include_dir (const line_header *lh) const
1044 return lh->include_dir_at (d_index);
1047 /* When we construct a partial symbol table entry we only
1048 need this much information. */
1049 struct partial_die_info : public allocate_on_obstack
1051 partial_die_info (sect_offset sect_off, struct abbrev_info *abbrev);
1053 /* Disable assign but still keep copy ctor, which is needed
1054 load_partial_dies. */
1055 partial_die_info& operator=(const partial_die_info& rhs) = delete;
1057 /* Adjust the partial die before generating a symbol for it. This
1058 function may set the is_external flag or change the DIE's
1060 void fixup (struct dwarf2_cu *cu);
1062 /* Read a minimal amount of information into the minimal die
1064 const gdb_byte *read (const struct die_reader_specs *reader,
1065 const struct abbrev_info &abbrev,
1066 const gdb_byte *info_ptr);
1068 /* Offset of this DIE. */
1069 const sect_offset sect_off;
1071 /* DWARF-2 tag for this DIE. */
1072 const ENUM_BITFIELD(dwarf_tag) tag : 16;
1074 /* Assorted flags describing the data found in this DIE. */
1075 const unsigned int has_children : 1;
1077 unsigned int is_external : 1;
1078 unsigned int is_declaration : 1;
1079 unsigned int has_type : 1;
1080 unsigned int has_specification : 1;
1081 unsigned int has_pc_info : 1;
1082 unsigned int may_be_inlined : 1;
1084 /* This DIE has been marked DW_AT_main_subprogram. */
1085 unsigned int main_subprogram : 1;
1087 /* Flag set if the SCOPE field of this structure has been
1089 unsigned int scope_set : 1;
1091 /* Flag set if the DIE has a byte_size attribute. */
1092 unsigned int has_byte_size : 1;
1094 /* Flag set if the DIE has a DW_AT_const_value attribute. */
1095 unsigned int has_const_value : 1;
1097 /* Flag set if any of the DIE's children are template arguments. */
1098 unsigned int has_template_arguments : 1;
1100 /* Flag set if fixup has been called on this die. */
1101 unsigned int fixup_called : 1;
1103 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1104 unsigned int is_dwz : 1;
1106 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1107 unsigned int spec_is_dwz : 1;
1109 /* The name of this DIE. Normally the value of DW_AT_name, but
1110 sometimes a default name for unnamed DIEs. */
1111 const char *name = nullptr;
1113 /* The linkage name, if present. */
1114 const char *linkage_name = nullptr;
1116 /* The scope to prepend to our children. This is generally
1117 allocated on the comp_unit_obstack, so will disappear
1118 when this compilation unit leaves the cache. */
1119 const char *scope = nullptr;
1121 /* Some data associated with the partial DIE. The tag determines
1122 which field is live. */
1125 /* The location description associated with this DIE, if any. */
1126 struct dwarf_block *locdesc;
1127 /* The offset of an import, for DW_TAG_imported_unit. */
1128 sect_offset sect_off;
1131 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1132 CORE_ADDR lowpc = 0;
1133 CORE_ADDR highpc = 0;
1135 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1136 DW_AT_sibling, if any. */
1137 /* NOTE: This member isn't strictly necessary, partial_die_info::read
1138 could return DW_AT_sibling values to its caller load_partial_dies. */
1139 const gdb_byte *sibling = nullptr;
1141 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1142 DW_AT_specification (or DW_AT_abstract_origin or
1143 DW_AT_extension). */
1144 sect_offset spec_offset {};
1146 /* Pointers to this DIE's parent, first child, and next sibling,
1148 struct partial_die_info *die_parent = nullptr;
1149 struct partial_die_info *die_child = nullptr;
1150 struct partial_die_info *die_sibling = nullptr;
1152 friend struct partial_die_info *
1153 dwarf2_cu::find_partial_die (sect_offset sect_off);
1156 /* Only need to do look up in dwarf2_cu::find_partial_die. */
1157 partial_die_info (sect_offset sect_off)
1158 : partial_die_info (sect_off, DW_TAG_padding, 0)
1162 partial_die_info (sect_offset sect_off_, enum dwarf_tag tag_,
1164 : sect_off (sect_off_), tag (tag_), has_children (has_children_)
1169 has_specification = 0;
1172 main_subprogram = 0;
1175 has_const_value = 0;
1176 has_template_arguments = 0;
1183 /* This data structure holds the information of an abbrev. */
1186 unsigned int number; /* number identifying abbrev */
1187 enum dwarf_tag tag; /* dwarf tag */
1188 unsigned short has_children; /* boolean */
1189 unsigned short num_attrs; /* number of attributes */
1190 struct attr_abbrev *attrs; /* an array of attribute descriptions */
1191 struct abbrev_info *next; /* next in chain */
1196 ENUM_BITFIELD(dwarf_attribute) name : 16;
1197 ENUM_BITFIELD(dwarf_form) form : 16;
1199 /* It is valid only if FORM is DW_FORM_implicit_const. */
1200 LONGEST implicit_const;
1203 /* Size of abbrev_table.abbrev_hash_table. */
1204 #define ABBREV_HASH_SIZE 121
1206 /* Top level data structure to contain an abbreviation table. */
1210 explicit abbrev_table (sect_offset off)
1214 XOBNEWVEC (&abbrev_obstack, struct abbrev_info *, ABBREV_HASH_SIZE);
1215 memset (m_abbrevs, 0, ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
1218 DISABLE_COPY_AND_ASSIGN (abbrev_table);
1220 /* Allocate space for a struct abbrev_info object in
1222 struct abbrev_info *alloc_abbrev ();
1224 /* Add an abbreviation to the table. */
1225 void add_abbrev (unsigned int abbrev_number, struct abbrev_info *abbrev);
1227 /* Look up an abbrev in the table.
1228 Returns NULL if the abbrev is not found. */
1230 struct abbrev_info *lookup_abbrev (unsigned int abbrev_number);
1233 /* Where the abbrev table came from.
1234 This is used as a sanity check when the table is used. */
1235 const sect_offset sect_off;
1237 /* Storage for the abbrev table. */
1238 auto_obstack abbrev_obstack;
1242 /* Hash table of abbrevs.
1243 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1244 It could be statically allocated, but the previous code didn't so we
1246 struct abbrev_info **m_abbrevs;
1249 typedef std::unique_ptr<struct abbrev_table> abbrev_table_up;
1251 /* Attributes have a name and a value. */
1254 ENUM_BITFIELD(dwarf_attribute) name : 16;
1255 ENUM_BITFIELD(dwarf_form) form : 15;
1257 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1258 field should be in u.str (existing only for DW_STRING) but it is kept
1259 here for better struct attribute alignment. */
1260 unsigned int string_is_canonical : 1;
1265 struct dwarf_block *blk;
1274 /* This data structure holds a complete die structure. */
1277 /* DWARF-2 tag for this DIE. */
1278 ENUM_BITFIELD(dwarf_tag) tag : 16;
1280 /* Number of attributes */
1281 unsigned char num_attrs;
1283 /* True if we're presently building the full type name for the
1284 type derived from this DIE. */
1285 unsigned char building_fullname : 1;
1287 /* True if this die is in process. PR 16581. */
1288 unsigned char in_process : 1;
1291 unsigned int abbrev;
1293 /* Offset in .debug_info or .debug_types section. */
1294 sect_offset sect_off;
1296 /* The dies in a compilation unit form an n-ary tree. PARENT
1297 points to this die's parent; CHILD points to the first child of
1298 this node; and all the children of a given node are chained
1299 together via their SIBLING fields. */
1300 struct die_info *child; /* Its first child, if any. */
1301 struct die_info *sibling; /* Its next sibling, if any. */
1302 struct die_info *parent; /* Its parent, if any. */
1304 /* An array of attributes, with NUM_ATTRS elements. There may be
1305 zero, but it's not common and zero-sized arrays are not
1306 sufficiently portable C. */
1307 struct attribute attrs[1];
1310 /* Get at parts of an attribute structure. */
1312 #define DW_STRING(attr) ((attr)->u.str)
1313 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1314 #define DW_UNSND(attr) ((attr)->u.unsnd)
1315 #define DW_BLOCK(attr) ((attr)->u.blk)
1316 #define DW_SND(attr) ((attr)->u.snd)
1317 #define DW_ADDR(attr) ((attr)->u.addr)
1318 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1320 /* Blocks are a bunch of untyped bytes. */
1325 /* Valid only if SIZE is not zero. */
1326 const gdb_byte *data;
1329 #ifndef ATTR_ALLOC_CHUNK
1330 #define ATTR_ALLOC_CHUNK 4
1333 /* Allocate fields for structs, unions and enums in this size. */
1334 #ifndef DW_FIELD_ALLOC_CHUNK
1335 #define DW_FIELD_ALLOC_CHUNK 4
1338 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1339 but this would require a corresponding change in unpack_field_as_long
1341 static int bits_per_byte = 8;
1343 /* When reading a variant or variant part, we track a bit more
1344 information about the field, and store it in an object of this
1347 struct variant_field
1349 /* If we see a DW_TAG_variant, then this will be the discriminant
1351 ULONGEST discriminant_value;
1352 /* If we see a DW_TAG_variant, then this will be set if this is the
1354 bool default_branch;
1355 /* While reading a DW_TAG_variant_part, this will be set if this
1356 field is the discriminant. */
1357 bool is_discriminant;
1362 int accessibility = 0;
1364 /* Extra information to describe a variant or variant part. */
1365 struct variant_field variant {};
1366 struct field field {};
1371 const char *name = nullptr;
1372 std::vector<struct fn_field> fnfields;
1375 /* The routines that read and process dies for a C struct or C++ class
1376 pass lists of data member fields and lists of member function fields
1377 in an instance of a field_info structure, as defined below. */
1380 /* List of data member and baseclasses fields. */
1381 std::vector<struct nextfield> fields;
1382 std::vector<struct nextfield> baseclasses;
1384 /* Number of fields (including baseclasses). */
1387 /* Set if the accesibility of one of the fields is not public. */
1388 int non_public_fields = 0;
1390 /* Member function fieldlist array, contains name of possibly overloaded
1391 member function, number of overloaded member functions and a pointer
1392 to the head of the member function field chain. */
1393 std::vector<struct fnfieldlist> fnfieldlists;
1395 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1396 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1397 std::vector<struct decl_field> typedef_field_list;
1399 /* Nested types defined by this class and the number of elements in this
1401 std::vector<struct decl_field> nested_types_list;
1404 /* One item on the queue of compilation units to read in full symbols
1406 struct dwarf2_queue_item
1408 struct dwarf2_per_cu_data *per_cu;
1409 enum language pretend_language;
1410 struct dwarf2_queue_item *next;
1413 /* The current queue. */
1414 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1416 /* Loaded secondary compilation units are kept in memory until they
1417 have not been referenced for the processing of this many
1418 compilation units. Set this to zero to disable caching. Cache
1419 sizes of up to at least twenty will improve startup time for
1420 typical inter-CU-reference binaries, at an obvious memory cost. */
1421 static int dwarf_max_cache_age = 5;
1423 show_dwarf_max_cache_age (struct ui_file *file, int from_tty,
1424 struct cmd_list_element *c, const char *value)
1426 fprintf_filtered (file, _("The upper bound on the age of cached "
1427 "DWARF compilation units is %s.\n"),
1431 /* local function prototypes */
1433 static const char *get_section_name (const struct dwarf2_section_info *);
1435 static const char *get_section_file_name (const struct dwarf2_section_info *);
1437 static void dwarf2_find_base_address (struct die_info *die,
1438 struct dwarf2_cu *cu);
1440 static struct partial_symtab *create_partial_symtab
1441 (struct dwarf2_per_cu_data *per_cu, const char *name);
1443 static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
1444 const gdb_byte *info_ptr,
1445 struct die_info *type_unit_die,
1446 int has_children, void *data);
1448 static void dwarf2_build_psymtabs_hard
1449 (struct dwarf2_per_objfile *dwarf2_per_objfile);
1451 static void scan_partial_symbols (struct partial_die_info *,
1452 CORE_ADDR *, CORE_ADDR *,
1453 int, struct dwarf2_cu *);
1455 static void add_partial_symbol (struct partial_die_info *,
1456 struct dwarf2_cu *);
1458 static void add_partial_namespace (struct partial_die_info *pdi,
1459 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1460 int set_addrmap, struct dwarf2_cu *cu);
1462 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1463 CORE_ADDR *highpc, int set_addrmap,
1464 struct dwarf2_cu *cu);
1466 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1467 struct dwarf2_cu *cu);
1469 static void add_partial_subprogram (struct partial_die_info *pdi,
1470 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1471 int need_pc, struct dwarf2_cu *cu);
1473 static void dwarf2_read_symtab (struct partial_symtab *,
1476 static void psymtab_to_symtab_1 (struct partial_symtab *);
1478 static abbrev_table_up abbrev_table_read_table
1479 (struct dwarf2_per_objfile *dwarf2_per_objfile, struct dwarf2_section_info *,
1482 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1484 static struct partial_die_info *load_partial_dies
1485 (const struct die_reader_specs *, const gdb_byte *, int);
1487 /* A pair of partial_die_info and compilation unit. */
1488 struct cu_partial_die_info
1490 /* The compilation unit of the partial_die_info. */
1491 struct dwarf2_cu *cu;
1492 /* A partial_die_info. */
1493 struct partial_die_info *pdi;
1495 cu_partial_die_info (struct dwarf2_cu *cu, struct partial_die_info *pdi)
1501 cu_partial_die_info () = delete;
1504 static const struct cu_partial_die_info find_partial_die (sect_offset, int,
1505 struct dwarf2_cu *);
1507 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1508 struct attribute *, struct attr_abbrev *,
1511 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1513 static int read_1_signed_byte (bfd *, const gdb_byte *);
1515 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1517 /* Read the next three bytes (little-endian order) as an unsigned integer. */
1518 static unsigned int read_3_bytes (bfd *, const gdb_byte *);
1520 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1522 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1524 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1527 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1529 static LONGEST read_checked_initial_length_and_offset
1530 (bfd *, const gdb_byte *, const struct comp_unit_head *,
1531 unsigned int *, unsigned int *);
1533 static LONGEST read_offset (bfd *, const gdb_byte *,
1534 const struct comp_unit_head *,
1537 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1539 static sect_offset read_abbrev_offset
1540 (struct dwarf2_per_objfile *dwarf2_per_objfile,
1541 struct dwarf2_section_info *, sect_offset);
1543 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1545 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1547 static const char *read_indirect_string
1548 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1549 const struct comp_unit_head *, unsigned int *);
1551 static const char *read_indirect_line_string
1552 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1553 const struct comp_unit_head *, unsigned int *);
1555 static const char *read_indirect_string_at_offset
1556 (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
1557 LONGEST str_offset);
1559 static const char *read_indirect_string_from_dwz
1560 (struct objfile *objfile, struct dwz_file *, LONGEST);
1562 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1564 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1568 static const char *read_str_index (const struct die_reader_specs *reader,
1569 ULONGEST str_index);
1571 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1573 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1574 struct dwarf2_cu *);
1576 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1579 static const char *dwarf2_string_attr (struct die_info *die, unsigned int name,
1580 struct dwarf2_cu *cu);
1582 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1583 struct dwarf2_cu *cu);
1585 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1587 static struct die_info *die_specification (struct die_info *die,
1588 struct dwarf2_cu **);
1590 static line_header_up dwarf_decode_line_header (sect_offset sect_off,
1591 struct dwarf2_cu *cu);
1593 static void dwarf_decode_lines (struct line_header *, const char *,
1594 struct dwarf2_cu *, struct partial_symtab *,
1595 CORE_ADDR, int decode_mapping);
1597 static void dwarf2_start_subfile (struct dwarf2_cu *, const char *,
1600 static struct symbol *new_symbol (struct die_info *, struct type *,
1601 struct dwarf2_cu *, struct symbol * = NULL);
1603 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1604 struct dwarf2_cu *);
1606 static void dwarf2_const_value_attr (const struct attribute *attr,
1609 struct obstack *obstack,
1610 struct dwarf2_cu *cu, LONGEST *value,
1611 const gdb_byte **bytes,
1612 struct dwarf2_locexpr_baton **baton);
1614 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1616 static int need_gnat_info (struct dwarf2_cu *);
1618 static struct type *die_descriptive_type (struct die_info *,
1619 struct dwarf2_cu *);
1621 static void set_descriptive_type (struct type *, struct die_info *,
1622 struct dwarf2_cu *);
1624 static struct type *die_containing_type (struct die_info *,
1625 struct dwarf2_cu *);
1627 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1628 struct dwarf2_cu *);
1630 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1632 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1634 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1636 static char *typename_concat (struct obstack *obs, const char *prefix,
1637 const char *suffix, int physname,
1638 struct dwarf2_cu *cu);
1640 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1642 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1644 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1646 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1648 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1650 static void read_variable (struct die_info *die, struct dwarf2_cu *cu);
1652 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1653 struct dwarf2_cu *, struct partial_symtab *);
1655 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1656 values. Keep the items ordered with increasing constraints compliance. */
1659 /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
1660 PC_BOUNDS_NOT_PRESENT,
1662 /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1663 were present but they do not form a valid range of PC addresses. */
1666 /* Discontiguous range was found - that is DW_AT_ranges was found. */
1669 /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
1673 static enum pc_bounds_kind dwarf2_get_pc_bounds (struct die_info *,
1674 CORE_ADDR *, CORE_ADDR *,
1676 struct partial_symtab *);
1678 static void get_scope_pc_bounds (struct die_info *,
1679 CORE_ADDR *, CORE_ADDR *,
1680 struct dwarf2_cu *);
1682 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1683 CORE_ADDR, struct dwarf2_cu *);
1685 static void dwarf2_add_field (struct field_info *, struct die_info *,
1686 struct dwarf2_cu *);
1688 static void dwarf2_attach_fields_to_type (struct field_info *,
1689 struct type *, struct dwarf2_cu *);
1691 static void dwarf2_add_member_fn (struct field_info *,
1692 struct die_info *, struct type *,
1693 struct dwarf2_cu *);
1695 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1697 struct dwarf2_cu *);
1699 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1701 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1703 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1705 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1707 static struct using_direct **using_directives (struct dwarf2_cu *cu);
1709 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1711 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1713 static struct type *read_module_type (struct die_info *die,
1714 struct dwarf2_cu *cu);
1716 static const char *namespace_name (struct die_info *die,
1717 int *is_anonymous, struct dwarf2_cu *);
1719 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1721 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1723 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1724 struct dwarf2_cu *);
1726 static struct die_info *read_die_and_siblings_1
1727 (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1730 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1731 const gdb_byte *info_ptr,
1732 const gdb_byte **new_info_ptr,
1733 struct die_info *parent);
1735 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1736 struct die_info **, const gdb_byte *,
1739 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1740 struct die_info **, const gdb_byte *,
1743 static void process_die (struct die_info *, struct dwarf2_cu *);
1745 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1748 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1750 static const char *dwarf2_full_name (const char *name,
1751 struct die_info *die,
1752 struct dwarf2_cu *cu);
1754 static const char *dwarf2_physname (const char *name, struct die_info *die,
1755 struct dwarf2_cu *cu);
1757 static struct die_info *dwarf2_extension (struct die_info *die,
1758 struct dwarf2_cu **);
1760 static const char *dwarf_tag_name (unsigned int);
1762 static const char *dwarf_attr_name (unsigned int);
1764 static const char *dwarf_form_name (unsigned int);
1766 static const char *dwarf_bool_name (unsigned int);
1768 static const char *dwarf_type_encoding_name (unsigned int);
1770 static struct die_info *sibling_die (struct die_info *);
1772 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1774 static void dump_die_for_error (struct die_info *);
1776 static void dump_die_1 (struct ui_file *, int level, int max_level,
1779 /*static*/ void dump_die (struct die_info *, int max_level);
1781 static void store_in_ref_table (struct die_info *,
1782 struct dwarf2_cu *);
1784 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1786 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1788 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1789 const struct attribute *,
1790 struct dwarf2_cu **);
1792 static struct die_info *follow_die_ref (struct die_info *,
1793 const struct attribute *,
1794 struct dwarf2_cu **);
1796 static struct die_info *follow_die_sig (struct die_info *,
1797 const struct attribute *,
1798 struct dwarf2_cu **);
1800 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1801 struct dwarf2_cu *);
1803 static struct type *get_DW_AT_signature_type (struct die_info *,
1804 const struct attribute *,
1805 struct dwarf2_cu *);
1807 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1809 static void read_signatured_type (struct signatured_type *);
1811 static int attr_to_dynamic_prop (const struct attribute *attr,
1812 struct die_info *die, struct dwarf2_cu *cu,
1813 struct dynamic_prop *prop, struct type *type);
1815 /* memory allocation interface */
1817 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1819 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1821 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int, int);
1823 static int attr_form_is_block (const struct attribute *);
1825 static int attr_form_is_section_offset (const struct attribute *);
1827 static int attr_form_is_constant (const struct attribute *);
1829 static int attr_form_is_ref (const struct attribute *);
1831 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1832 struct dwarf2_loclist_baton *baton,
1833 const struct attribute *attr);
1835 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1837 struct dwarf2_cu *cu,
1840 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1841 const gdb_byte *info_ptr,
1842 struct abbrev_info *abbrev);
1844 static hashval_t partial_die_hash (const void *item);
1846 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1848 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1849 (sect_offset sect_off, unsigned int offset_in_dwz,
1850 struct dwarf2_per_objfile *dwarf2_per_objfile);
1852 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1853 struct die_info *comp_unit_die,
1854 enum language pretend_language);
1856 static void age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1858 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1860 static struct type *set_die_type (struct die_info *, struct type *,
1861 struct dwarf2_cu *);
1863 static void create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1865 static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1867 static void load_full_comp_unit (struct dwarf2_per_cu_data *, bool,
1870 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1873 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1876 static void dwarf2_add_dependence (struct dwarf2_cu *,
1877 struct dwarf2_per_cu_data *);
1879 static void dwarf2_mark (struct dwarf2_cu *);
1881 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1883 static struct type *get_die_type_at_offset (sect_offset,
1884 struct dwarf2_per_cu_data *);
1886 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1888 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1889 enum language pretend_language);
1891 static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile);
1893 static struct type *dwarf2_per_cu_addr_type (struct dwarf2_per_cu_data *per_cu);
1894 static struct type *dwarf2_per_cu_addr_sized_int_type
1895 (struct dwarf2_per_cu_data *per_cu, bool unsigned_p);
1897 /* Class, the destructor of which frees all allocated queue entries. This
1898 will only have work to do if an error was thrown while processing the
1899 dwarf. If no error was thrown then the queue entries should have all
1900 been processed, and freed, as we went along. */
1902 class dwarf2_queue_guard
1905 dwarf2_queue_guard () = default;
1907 /* Free any entries remaining on the queue. There should only be
1908 entries left if we hit an error while processing the dwarf. */
1909 ~dwarf2_queue_guard ()
1911 struct dwarf2_queue_item *item, *last;
1913 item = dwarf2_queue;
1916 /* Anything still marked queued is likely to be in an
1917 inconsistent state, so discard it. */
1918 if (item->per_cu->queued)
1920 if (item->per_cu->cu != NULL)
1921 free_one_cached_comp_unit (item->per_cu);
1922 item->per_cu->queued = 0;
1930 dwarf2_queue = dwarf2_queue_tail = NULL;
1934 /* The return type of find_file_and_directory. Note, the enclosed
1935 string pointers are only valid while this object is valid. */
1937 struct file_and_directory
1939 /* The filename. This is never NULL. */
1942 /* The compilation directory. NULL if not known. If we needed to
1943 compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1944 points directly to the DW_AT_comp_dir string attribute owned by
1945 the obstack that owns the DIE. */
1946 const char *comp_dir;
1948 /* If we needed to build a new string for comp_dir, this is what
1949 owns the storage. */
1950 std::string comp_dir_storage;
1953 static file_and_directory find_file_and_directory (struct die_info *die,
1954 struct dwarf2_cu *cu);
1956 static char *file_full_name (int file, struct line_header *lh,
1957 const char *comp_dir);
1959 /* Expected enum dwarf_unit_type for read_comp_unit_head. */
1960 enum class rcuh_kind { COMPILE, TYPE };
1962 static const gdb_byte *read_and_check_comp_unit_head
1963 (struct dwarf2_per_objfile* dwarf2_per_objfile,
1964 struct comp_unit_head *header,
1965 struct dwarf2_section_info *section,
1966 struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1967 rcuh_kind section_kind);
1969 static void init_cutu_and_read_dies
1970 (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1971 int use_existing_cu, int keep, bool skip_partial,
1972 die_reader_func_ftype *die_reader_func, void *data);
1974 static void init_cutu_and_read_dies_simple
1975 (struct dwarf2_per_cu_data *this_cu,
1976 die_reader_func_ftype *die_reader_func, void *data);
1978 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1980 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1982 static struct dwo_unit *lookup_dwo_unit_in_dwp
1983 (struct dwarf2_per_objfile *dwarf2_per_objfile,
1984 struct dwp_file *dwp_file, const char *comp_dir,
1985 ULONGEST signature, int is_debug_types);
1987 static struct dwp_file *get_dwp_file
1988 (struct dwarf2_per_objfile *dwarf2_per_objfile);
1990 static struct dwo_unit *lookup_dwo_comp_unit
1991 (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
1993 static struct dwo_unit *lookup_dwo_type_unit
1994 (struct signatured_type *, const char *, const char *);
1996 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
1998 /* A unique pointer to a dwo_file. */
2000 typedef std::unique_ptr<struct dwo_file> dwo_file_up;
2002 static void process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile);
2004 static void check_producer (struct dwarf2_cu *cu);
2006 static void free_line_header_voidp (void *arg);
2008 /* Various complaints about symbol reading that don't abort the process. */
2011 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2013 complaint (_("statement list doesn't fit in .debug_line section"));
2017 dwarf2_debug_line_missing_file_complaint (void)
2019 complaint (_(".debug_line section has line data without a file"));
2023 dwarf2_debug_line_missing_end_sequence_complaint (void)
2025 complaint (_(".debug_line section has line "
2026 "program sequence without an end"));
2030 dwarf2_complex_location_expr_complaint (void)
2032 complaint (_("location expression too complex"));
2036 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
2039 complaint (_("const value length mismatch for '%s', got %d, expected %d"),
2044 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
2046 complaint (_("debug info runs off end of %s section"
2048 get_section_name (section),
2049 get_section_file_name (section));
2053 dwarf2_macro_malformed_definition_complaint (const char *arg1)
2055 complaint (_("macro debug info contains a "
2056 "malformed macro definition:\n`%s'"),
2061 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
2063 complaint (_("invalid attribute class or form for '%s' in '%s'"),
2067 /* Hash function for line_header_hash. */
2070 line_header_hash (const struct line_header *ofs)
2072 return to_underlying (ofs->sect_off) ^ ofs->offset_in_dwz;
2075 /* Hash function for htab_create_alloc_ex for line_header_hash. */
2078 line_header_hash_voidp (const void *item)
2080 const struct line_header *ofs = (const struct line_header *) item;
2082 return line_header_hash (ofs);
2085 /* Equality function for line_header_hash. */
2088 line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
2090 const struct line_header *ofs_lhs = (const struct line_header *) item_lhs;
2091 const struct line_header *ofs_rhs = (const struct line_header *) item_rhs;
2093 return (ofs_lhs->sect_off == ofs_rhs->sect_off
2094 && ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
2099 /* Read the given attribute value as an address, taking the attribute's
2100 form into account. */
2103 attr_value_as_address (struct attribute *attr)
2107 if (attr->form != DW_FORM_addr && attr->form != DW_FORM_addrx
2108 && attr->form != DW_FORM_GNU_addr_index)
2110 /* Aside from a few clearly defined exceptions, attributes that
2111 contain an address must always be in DW_FORM_addr form.
2112 Unfortunately, some compilers happen to be violating this
2113 requirement by encoding addresses using other forms, such
2114 as DW_FORM_data4 for example. For those broken compilers,
2115 we try to do our best, without any guarantee of success,
2116 to interpret the address correctly. It would also be nice
2117 to generate a complaint, but that would require us to maintain
2118 a list of legitimate cases where a non-address form is allowed,
2119 as well as update callers to pass in at least the CU's DWARF
2120 version. This is more overhead than what we're willing to
2121 expand for a pretty rare case. */
2122 addr = DW_UNSND (attr);
2125 addr = DW_ADDR (attr);
2130 /* See declaration. */
2132 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_,
2133 const dwarf2_debug_sections *names)
2134 : objfile (objfile_)
2137 names = &dwarf2_elf_names;
2139 bfd *obfd = objfile->obfd;
2141 for (asection *sec = obfd->sections; sec != NULL; sec = sec->next)
2142 locate_sections (obfd, sec, *names);
2145 dwarf2_per_objfile::~dwarf2_per_objfile ()
2147 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
2148 free_cached_comp_units ();
2150 if (quick_file_names_table)
2151 htab_delete (quick_file_names_table);
2153 if (line_header_hash)
2154 htab_delete (line_header_hash);
2156 for (dwarf2_per_cu_data *per_cu : all_comp_units)
2157 VEC_free (dwarf2_per_cu_ptr, per_cu->imported_symtabs);
2159 for (signatured_type *sig_type : all_type_units)
2160 VEC_free (dwarf2_per_cu_ptr, sig_type->per_cu.imported_symtabs);
2162 /* Everything else should be on the objfile obstack. */
2165 /* See declaration. */
2168 dwarf2_per_objfile::free_cached_comp_units ()
2170 dwarf2_per_cu_data *per_cu = read_in_chain;
2171 dwarf2_per_cu_data **last_chain = &read_in_chain;
2172 while (per_cu != NULL)
2174 dwarf2_per_cu_data *next_cu = per_cu->cu->read_in_chain;
2177 *last_chain = next_cu;
2182 /* A helper class that calls free_cached_comp_units on
2185 class free_cached_comp_units
2189 explicit free_cached_comp_units (dwarf2_per_objfile *per_objfile)
2190 : m_per_objfile (per_objfile)
2194 ~free_cached_comp_units ()
2196 m_per_objfile->free_cached_comp_units ();
2199 DISABLE_COPY_AND_ASSIGN (free_cached_comp_units);
2203 dwarf2_per_objfile *m_per_objfile;
2206 /* Try to locate the sections we need for DWARF 2 debugging
2207 information and return true if we have enough to do something.
2208 NAMES points to the dwarf2 section names, or is NULL if the standard
2209 ELF names are used. */
2212 dwarf2_has_info (struct objfile *objfile,
2213 const struct dwarf2_debug_sections *names)
2215 if (objfile->flags & OBJF_READNEVER)
2218 struct dwarf2_per_objfile *dwarf2_per_objfile
2219 = get_dwarf2_per_objfile (objfile);
2221 if (dwarf2_per_objfile == NULL)
2222 dwarf2_per_objfile = dwarf2_objfile_data_key.emplace (objfile, objfile,
2225 return (!dwarf2_per_objfile->info.is_virtual
2226 && dwarf2_per_objfile->info.s.section != NULL
2227 && !dwarf2_per_objfile->abbrev.is_virtual
2228 && dwarf2_per_objfile->abbrev.s.section != NULL);
2231 /* Return the containing section of virtual section SECTION. */
2233 static struct dwarf2_section_info *
2234 get_containing_section (const struct dwarf2_section_info *section)
2236 gdb_assert (section->is_virtual);
2237 return section->s.containing_section;
2240 /* Return the bfd owner of SECTION. */
2243 get_section_bfd_owner (const struct dwarf2_section_info *section)
2245 if (section->is_virtual)
2247 section = get_containing_section (section);
2248 gdb_assert (!section->is_virtual);
2250 return section->s.section->owner;
2253 /* Return the bfd section of SECTION.
2254 Returns NULL if the section is not present. */
2257 get_section_bfd_section (const struct dwarf2_section_info *section)
2259 if (section->is_virtual)
2261 section = get_containing_section (section);
2262 gdb_assert (!section->is_virtual);
2264 return section->s.section;
2267 /* Return the name of SECTION. */
2270 get_section_name (const struct dwarf2_section_info *section)
2272 asection *sectp = get_section_bfd_section (section);
2274 gdb_assert (sectp != NULL);
2275 return bfd_section_name (get_section_bfd_owner (section), sectp);
2278 /* Return the name of the file SECTION is in. */
2281 get_section_file_name (const struct dwarf2_section_info *section)
2283 bfd *abfd = get_section_bfd_owner (section);
2285 return bfd_get_filename (abfd);
2288 /* Return the id of SECTION.
2289 Returns 0 if SECTION doesn't exist. */
2292 get_section_id (const struct dwarf2_section_info *section)
2294 asection *sectp = get_section_bfd_section (section);
2301 /* Return the flags of SECTION.
2302 SECTION (or containing section if this is a virtual section) must exist. */
2305 get_section_flags (const struct dwarf2_section_info *section)
2307 asection *sectp = get_section_bfd_section (section);
2309 gdb_assert (sectp != NULL);
2310 return bfd_get_section_flags (sectp->owner, sectp);
2313 /* When loading sections, we look either for uncompressed section or for
2314 compressed section names. */
2317 section_is_p (const char *section_name,
2318 const struct dwarf2_section_names *names)
2320 if (names->normal != NULL
2321 && strcmp (section_name, names->normal) == 0)
2323 if (names->compressed != NULL
2324 && strcmp (section_name, names->compressed) == 0)
2329 /* See declaration. */
2332 dwarf2_per_objfile::locate_sections (bfd *abfd, asection *sectp,
2333 const dwarf2_debug_sections &names)
2335 flagword aflag = bfd_get_section_flags (abfd, sectp);
2337 if ((aflag & SEC_HAS_CONTENTS) == 0)
2340 else if (section_is_p (sectp->name, &names.info))
2342 this->info.s.section = sectp;
2343 this->info.size = bfd_get_section_size (sectp);
2345 else if (section_is_p (sectp->name, &names.abbrev))
2347 this->abbrev.s.section = sectp;
2348 this->abbrev.size = bfd_get_section_size (sectp);
2350 else if (section_is_p (sectp->name, &names.line))
2352 this->line.s.section = sectp;
2353 this->line.size = bfd_get_section_size (sectp);
2355 else if (section_is_p (sectp->name, &names.loc))
2357 this->loc.s.section = sectp;
2358 this->loc.size = bfd_get_section_size (sectp);
2360 else if (section_is_p (sectp->name, &names.loclists))
2362 this->loclists.s.section = sectp;
2363 this->loclists.size = bfd_get_section_size (sectp);
2365 else if (section_is_p (sectp->name, &names.macinfo))
2367 this->macinfo.s.section = sectp;
2368 this->macinfo.size = bfd_get_section_size (sectp);
2370 else if (section_is_p (sectp->name, &names.macro))
2372 this->macro.s.section = sectp;
2373 this->macro.size = bfd_get_section_size (sectp);
2375 else if (section_is_p (sectp->name, &names.str))
2377 this->str.s.section = sectp;
2378 this->str.size = bfd_get_section_size (sectp);
2380 else if (section_is_p (sectp->name, &names.line_str))
2382 this->line_str.s.section = sectp;
2383 this->line_str.size = bfd_get_section_size (sectp);
2385 else if (section_is_p (sectp->name, &names.addr))
2387 this->addr.s.section = sectp;
2388 this->addr.size = bfd_get_section_size (sectp);
2390 else if (section_is_p (sectp->name, &names.frame))
2392 this->frame.s.section = sectp;
2393 this->frame.size = bfd_get_section_size (sectp);
2395 else if (section_is_p (sectp->name, &names.eh_frame))
2397 this->eh_frame.s.section = sectp;
2398 this->eh_frame.size = bfd_get_section_size (sectp);
2400 else if (section_is_p (sectp->name, &names.ranges))
2402 this->ranges.s.section = sectp;
2403 this->ranges.size = bfd_get_section_size (sectp);
2405 else if (section_is_p (sectp->name, &names.rnglists))
2407 this->rnglists.s.section = sectp;
2408 this->rnglists.size = bfd_get_section_size (sectp);
2410 else if (section_is_p (sectp->name, &names.types))
2412 struct dwarf2_section_info type_section;
2414 memset (&type_section, 0, sizeof (type_section));
2415 type_section.s.section = sectp;
2416 type_section.size = bfd_get_section_size (sectp);
2418 this->types.push_back (type_section);
2420 else if (section_is_p (sectp->name, &names.gdb_index))
2422 this->gdb_index.s.section = sectp;
2423 this->gdb_index.size = bfd_get_section_size (sectp);
2425 else if (section_is_p (sectp->name, &names.debug_names))
2427 this->debug_names.s.section = sectp;
2428 this->debug_names.size = bfd_get_section_size (sectp);
2430 else if (section_is_p (sectp->name, &names.debug_aranges))
2432 this->debug_aranges.s.section = sectp;
2433 this->debug_aranges.size = bfd_get_section_size (sectp);
2436 if ((bfd_get_section_flags (abfd, sectp) & (SEC_LOAD | SEC_ALLOC))
2437 && bfd_section_vma (abfd, sectp) == 0)
2438 this->has_section_at_zero = true;
2441 /* A helper function that decides whether a section is empty,
2445 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2447 if (section->is_virtual)
2448 return section->size == 0;
2449 return section->s.section == NULL || section->size == 0;
2452 /* See dwarf2read.h. */
2455 dwarf2_read_section (struct objfile *objfile, dwarf2_section_info *info)
2459 gdb_byte *buf, *retbuf;
2463 info->buffer = NULL;
2464 info->readin = true;
2466 if (dwarf2_section_empty_p (info))
2469 sectp = get_section_bfd_section (info);
2471 /* If this is a virtual section we need to read in the real one first. */
2472 if (info->is_virtual)
2474 struct dwarf2_section_info *containing_section =
2475 get_containing_section (info);
2477 gdb_assert (sectp != NULL);
2478 if ((sectp->flags & SEC_RELOC) != 0)
2480 error (_("Dwarf Error: DWP format V2 with relocations is not"
2481 " supported in section %s [in module %s]"),
2482 get_section_name (info), get_section_file_name (info));
2484 dwarf2_read_section (objfile, containing_section);
2485 /* Other code should have already caught virtual sections that don't
2487 gdb_assert (info->virtual_offset + info->size
2488 <= containing_section->size);
2489 /* If the real section is empty or there was a problem reading the
2490 section we shouldn't get here. */
2491 gdb_assert (containing_section->buffer != NULL);
2492 info->buffer = containing_section->buffer + info->virtual_offset;
2496 /* If the section has relocations, we must read it ourselves.
2497 Otherwise we attach it to the BFD. */
2498 if ((sectp->flags & SEC_RELOC) == 0)
2500 info->buffer = gdb_bfd_map_section (sectp, &info->size);
2504 buf = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, info->size);
2507 /* When debugging .o files, we may need to apply relocations; see
2508 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2509 We never compress sections in .o files, so we only need to
2510 try this when the section is not compressed. */
2511 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2514 info->buffer = retbuf;
2518 abfd = get_section_bfd_owner (info);
2519 gdb_assert (abfd != NULL);
2521 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2522 || bfd_bread (buf, info->size, abfd) != info->size)
2524 error (_("Dwarf Error: Can't read DWARF data"
2525 " in section %s [in module %s]"),
2526 bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2530 /* A helper function that returns the size of a section in a safe way.
2531 If you are positive that the section has been read before using the
2532 size, then it is safe to refer to the dwarf2_section_info object's
2533 "size" field directly. In other cases, you must call this
2534 function, because for compressed sections the size field is not set
2535 correctly until the section has been read. */
2537 static bfd_size_type
2538 dwarf2_section_size (struct objfile *objfile,
2539 struct dwarf2_section_info *info)
2542 dwarf2_read_section (objfile, info);
2546 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2550 dwarf2_get_section_info (struct objfile *objfile,
2551 enum dwarf2_section_enum sect,
2552 asection **sectp, const gdb_byte **bufp,
2553 bfd_size_type *sizep)
2555 struct dwarf2_per_objfile *data = dwarf2_objfile_data_key.get (objfile);
2556 struct dwarf2_section_info *info;
2558 /* We may see an objfile without any DWARF, in which case we just
2569 case DWARF2_DEBUG_FRAME:
2570 info = &data->frame;
2572 case DWARF2_EH_FRAME:
2573 info = &data->eh_frame;
2576 gdb_assert_not_reached ("unexpected section");
2579 dwarf2_read_section (objfile, info);
2581 *sectp = get_section_bfd_section (info);
2582 *bufp = info->buffer;
2583 *sizep = info->size;
2586 /* A helper function to find the sections for a .dwz file. */
2589 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2591 struct dwz_file *dwz_file = (struct dwz_file *) arg;
2593 /* Note that we only support the standard ELF names, because .dwz
2594 is ELF-only (at the time of writing). */
2595 if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2597 dwz_file->abbrev.s.section = sectp;
2598 dwz_file->abbrev.size = bfd_get_section_size (sectp);
2600 else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2602 dwz_file->info.s.section = sectp;
2603 dwz_file->info.size = bfd_get_section_size (sectp);
2605 else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2607 dwz_file->str.s.section = sectp;
2608 dwz_file->str.size = bfd_get_section_size (sectp);
2610 else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2612 dwz_file->line.s.section = sectp;
2613 dwz_file->line.size = bfd_get_section_size (sectp);
2615 else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2617 dwz_file->macro.s.section = sectp;
2618 dwz_file->macro.size = bfd_get_section_size (sectp);
2620 else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2622 dwz_file->gdb_index.s.section = sectp;
2623 dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2625 else if (section_is_p (sectp->name, &dwarf2_elf_names.debug_names))
2627 dwz_file->debug_names.s.section = sectp;
2628 dwz_file->debug_names.size = bfd_get_section_size (sectp);
2632 /* See dwarf2read.h. */
2635 dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
2637 const char *filename;
2638 bfd_size_type buildid_len_arg;
2642 if (dwarf2_per_objfile->dwz_file != NULL)
2643 return dwarf2_per_objfile->dwz_file.get ();
2645 bfd_set_error (bfd_error_no_error);
2646 gdb::unique_xmalloc_ptr<char> data
2647 (bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2648 &buildid_len_arg, &buildid));
2651 if (bfd_get_error () == bfd_error_no_error)
2653 error (_("could not read '.gnu_debugaltlink' section: %s"),
2654 bfd_errmsg (bfd_get_error ()));
2657 gdb::unique_xmalloc_ptr<bfd_byte> buildid_holder (buildid);
2659 buildid_len = (size_t) buildid_len_arg;
2661 filename = data.get ();
2663 std::string abs_storage;
2664 if (!IS_ABSOLUTE_PATH (filename))
2666 gdb::unique_xmalloc_ptr<char> abs
2667 = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2669 abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
2670 filename = abs_storage.c_str ();
2673 /* First try the file name given in the section. If that doesn't
2674 work, try to use the build-id instead. */
2675 gdb_bfd_ref_ptr dwz_bfd (gdb_bfd_open (filename, gnutarget, -1));
2676 if (dwz_bfd != NULL)
2678 if (!build_id_verify (dwz_bfd.get (), buildid_len, buildid))
2679 dwz_bfd.reset (nullptr);
2682 if (dwz_bfd == NULL)
2683 dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2685 if (dwz_bfd == NULL)
2686 error (_("could not find '.gnu_debugaltlink' file for %s"),
2687 objfile_name (dwarf2_per_objfile->objfile));
2689 std::unique_ptr<struct dwz_file> result
2690 (new struct dwz_file (std::move (dwz_bfd)));
2692 bfd_map_over_sections (result->dwz_bfd.get (), locate_dwz_sections,
2695 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd,
2696 result->dwz_bfd.get ());
2697 dwarf2_per_objfile->dwz_file = std::move (result);
2698 return dwarf2_per_objfile->dwz_file.get ();
2701 /* DWARF quick_symbols_functions support. */
2703 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2704 unique line tables, so we maintain a separate table of all .debug_line
2705 derived entries to support the sharing.
2706 All the quick functions need is the list of file names. We discard the
2707 line_header when we're done and don't need to record it here. */
2708 struct quick_file_names
2710 /* The data used to construct the hash key. */
2711 struct stmt_list_hash hash;
2713 /* The number of entries in file_names, real_names. */
2714 unsigned int num_file_names;
2716 /* The file names from the line table, after being run through
2718 const char **file_names;
2720 /* The file names from the line table after being run through
2721 gdb_realpath. These are computed lazily. */
2722 const char **real_names;
2725 /* When using the index (and thus not using psymtabs), each CU has an
2726 object of this type. This is used to hold information needed by
2727 the various "quick" methods. */
2728 struct dwarf2_per_cu_quick_data
2730 /* The file table. This can be NULL if there was no file table
2731 or it's currently not read in.
2732 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2733 struct quick_file_names *file_names;
2735 /* The corresponding symbol table. This is NULL if symbols for this
2736 CU have not yet been read. */
2737 struct compunit_symtab *compunit_symtab;
2739 /* A temporary mark bit used when iterating over all CUs in
2740 expand_symtabs_matching. */
2741 unsigned int mark : 1;
2743 /* True if we've tried to read the file table and found there isn't one.
2744 There will be no point in trying to read it again next time. */
2745 unsigned int no_file_data : 1;
2748 /* Utility hash function for a stmt_list_hash. */
2751 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2755 if (stmt_list_hash->dwo_unit != NULL)
2756 v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2757 v += to_underlying (stmt_list_hash->line_sect_off);
2761 /* Utility equality function for a stmt_list_hash. */
2764 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2765 const struct stmt_list_hash *rhs)
2767 if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2769 if (lhs->dwo_unit != NULL
2770 && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2773 return lhs->line_sect_off == rhs->line_sect_off;
2776 /* Hash function for a quick_file_names. */
2779 hash_file_name_entry (const void *e)
2781 const struct quick_file_names *file_data
2782 = (const struct quick_file_names *) e;
2784 return hash_stmt_list_entry (&file_data->hash);
2787 /* Equality function for a quick_file_names. */
2790 eq_file_name_entry (const void *a, const void *b)
2792 const struct quick_file_names *ea = (const struct quick_file_names *) a;
2793 const struct quick_file_names *eb = (const struct quick_file_names *) b;
2795 return eq_stmt_list_entry (&ea->hash, &eb->hash);
2798 /* Delete function for a quick_file_names. */
2801 delete_file_name_entry (void *e)
2803 struct quick_file_names *file_data = (struct quick_file_names *) e;
2806 for (i = 0; i < file_data->num_file_names; ++i)
2808 xfree ((void*) file_data->file_names[i]);
2809 if (file_data->real_names)
2810 xfree ((void*) file_data->real_names[i]);
2813 /* The space for the struct itself lives on objfile_obstack,
2814 so we don't free it here. */
2817 /* Create a quick_file_names hash table. */
2820 create_quick_file_names_table (unsigned int nr_initial_entries)
2822 return htab_create_alloc (nr_initial_entries,
2823 hash_file_name_entry, eq_file_name_entry,
2824 delete_file_name_entry, xcalloc, xfree);
2827 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2828 have to be created afterwards. You should call age_cached_comp_units after
2829 processing PER_CU->CU. dw2_setup must have been already called. */
2832 load_cu (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2834 if (per_cu->is_debug_types)
2835 load_full_type_unit (per_cu);
2837 load_full_comp_unit (per_cu, skip_partial, language_minimal);
2839 if (per_cu->cu == NULL)
2840 return; /* Dummy CU. */
2842 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2845 /* Read in the symbols for PER_CU. */
2848 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2850 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2852 /* Skip type_unit_groups, reading the type units they contain
2853 is handled elsewhere. */
2854 if (IS_TYPE_UNIT_GROUP (per_cu))
2857 /* The destructor of dwarf2_queue_guard frees any entries left on
2858 the queue. After this point we're guaranteed to leave this function
2859 with the dwarf queue empty. */
2860 dwarf2_queue_guard q_guard;
2862 if (dwarf2_per_objfile->using_index
2863 ? per_cu->v.quick->compunit_symtab == NULL
2864 : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2866 queue_comp_unit (per_cu, language_minimal);
2867 load_cu (per_cu, skip_partial);
2869 /* If we just loaded a CU from a DWO, and we're working with an index
2870 that may badly handle TUs, load all the TUs in that DWO as well.
2871 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2872 if (!per_cu->is_debug_types
2873 && per_cu->cu != NULL
2874 && per_cu->cu->dwo_unit != NULL
2875 && dwarf2_per_objfile->index_table != NULL
2876 && dwarf2_per_objfile->index_table->version <= 7
2877 /* DWP files aren't supported yet. */
2878 && get_dwp_file (dwarf2_per_objfile) == NULL)
2879 queue_and_load_all_dwo_tus (per_cu);
2882 process_queue (dwarf2_per_objfile);
2884 /* Age the cache, releasing compilation units that have not
2885 been used recently. */
2886 age_cached_comp_units (dwarf2_per_objfile);
2889 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2890 the objfile from which this CU came. Returns the resulting symbol
2893 static struct compunit_symtab *
2894 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2896 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2898 gdb_assert (dwarf2_per_objfile->using_index);
2899 if (!per_cu->v.quick->compunit_symtab)
2901 free_cached_comp_units freer (dwarf2_per_objfile);
2902 scoped_restore decrementer = increment_reading_symtab ();
2903 dw2_do_instantiate_symtab (per_cu, skip_partial);
2904 process_cu_includes (dwarf2_per_objfile);
2907 return per_cu->v.quick->compunit_symtab;
2910 /* See declaration. */
2912 dwarf2_per_cu_data *
2913 dwarf2_per_objfile::get_cutu (int index)
2915 if (index >= this->all_comp_units.size ())
2917 index -= this->all_comp_units.size ();
2918 gdb_assert (index < this->all_type_units.size ());
2919 return &this->all_type_units[index]->per_cu;
2922 return this->all_comp_units[index];
2925 /* See declaration. */
2927 dwarf2_per_cu_data *
2928 dwarf2_per_objfile::get_cu (int index)
2930 gdb_assert (index >= 0 && index < this->all_comp_units.size ());
2932 return this->all_comp_units[index];
2935 /* See declaration. */
2938 dwarf2_per_objfile::get_tu (int index)
2940 gdb_assert (index >= 0 && index < this->all_type_units.size ());
2942 return this->all_type_units[index];
2945 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2946 objfile_obstack, and constructed with the specified field
2949 static dwarf2_per_cu_data *
2950 create_cu_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2951 struct dwarf2_section_info *section,
2953 sect_offset sect_off, ULONGEST length)
2955 struct objfile *objfile = dwarf2_per_objfile->objfile;
2956 dwarf2_per_cu_data *the_cu
2957 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2958 struct dwarf2_per_cu_data);
2959 the_cu->sect_off = sect_off;
2960 the_cu->length = length;
2961 the_cu->dwarf2_per_objfile = dwarf2_per_objfile;
2962 the_cu->section = section;
2963 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2964 struct dwarf2_per_cu_quick_data);
2965 the_cu->is_dwz = is_dwz;
2969 /* A helper for create_cus_from_index that handles a given list of
2973 create_cus_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2974 const gdb_byte *cu_list, offset_type n_elements,
2975 struct dwarf2_section_info *section,
2978 for (offset_type i = 0; i < n_elements; i += 2)
2980 gdb_static_assert (sizeof (ULONGEST) >= 8);
2982 sect_offset sect_off
2983 = (sect_offset) extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
2984 ULONGEST length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
2987 dwarf2_per_cu_data *per_cu
2988 = create_cu_from_index_list (dwarf2_per_objfile, section, is_dwz,
2990 dwarf2_per_objfile->all_comp_units.push_back (per_cu);
2994 /* Read the CU list from the mapped index, and use it to create all
2995 the CU objects for this objfile. */
2998 create_cus_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
2999 const gdb_byte *cu_list, offset_type cu_list_elements,
3000 const gdb_byte *dwz_list, offset_type dwz_elements)
3002 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
3003 dwarf2_per_objfile->all_comp_units.reserve
3004 ((cu_list_elements + dwz_elements) / 2);
3006 create_cus_from_index_list (dwarf2_per_objfile, cu_list, cu_list_elements,
3007 &dwarf2_per_objfile->info, 0);
3009 if (dwz_elements == 0)
3012 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3013 create_cus_from_index_list (dwarf2_per_objfile, dwz_list, dwz_elements,
3017 /* Create the signatured type hash table from the index. */
3020 create_signatured_type_table_from_index
3021 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3022 struct dwarf2_section_info *section,
3023 const gdb_byte *bytes,
3024 offset_type elements)
3026 struct objfile *objfile = dwarf2_per_objfile->objfile;
3028 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3029 dwarf2_per_objfile->all_type_units.reserve (elements / 3);
3031 htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3033 for (offset_type i = 0; i < elements; i += 3)
3035 struct signatured_type *sig_type;
3038 cu_offset type_offset_in_tu;
3040 gdb_static_assert (sizeof (ULONGEST) >= 8);
3041 sect_offset sect_off
3042 = (sect_offset) extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
3044 = (cu_offset) extract_unsigned_integer (bytes + 8, 8,
3046 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
3049 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3050 struct signatured_type);
3051 sig_type->signature = signature;
3052 sig_type->type_offset_in_tu = type_offset_in_tu;
3053 sig_type->per_cu.is_debug_types = 1;
3054 sig_type->per_cu.section = section;
3055 sig_type->per_cu.sect_off = sect_off;
3056 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3057 sig_type->per_cu.v.quick
3058 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3059 struct dwarf2_per_cu_quick_data);
3061 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3064 dwarf2_per_objfile->all_type_units.push_back (sig_type);
3067 dwarf2_per_objfile->signatured_types = sig_types_hash;
3070 /* Create the signatured type hash table from .debug_names. */
3073 create_signatured_type_table_from_debug_names
3074 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3075 const mapped_debug_names &map,
3076 struct dwarf2_section_info *section,
3077 struct dwarf2_section_info *abbrev_section)
3079 struct objfile *objfile = dwarf2_per_objfile->objfile;
3081 dwarf2_read_section (objfile, section);
3082 dwarf2_read_section (objfile, abbrev_section);
3084 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3085 dwarf2_per_objfile->all_type_units.reserve (map.tu_count);
3087 htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3089 for (uint32_t i = 0; i < map.tu_count; ++i)
3091 struct signatured_type *sig_type;
3094 sect_offset sect_off
3095 = (sect_offset) (extract_unsigned_integer
3096 (map.tu_table_reordered + i * map.offset_size,
3098 map.dwarf5_byte_order));
3100 comp_unit_head cu_header;
3101 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
3103 section->buffer + to_underlying (sect_off),
3106 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3107 struct signatured_type);
3108 sig_type->signature = cu_header.signature;
3109 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
3110 sig_type->per_cu.is_debug_types = 1;
3111 sig_type->per_cu.section = section;
3112 sig_type->per_cu.sect_off = sect_off;
3113 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3114 sig_type->per_cu.v.quick
3115 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3116 struct dwarf2_per_cu_quick_data);
3118 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3121 dwarf2_per_objfile->all_type_units.push_back (sig_type);
3124 dwarf2_per_objfile->signatured_types = sig_types_hash;
3127 /* Read the address map data from the mapped index, and use it to
3128 populate the objfile's psymtabs_addrmap. */
3131 create_addrmap_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3132 struct mapped_index *index)
3134 struct objfile *objfile = dwarf2_per_objfile->objfile;
3135 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3136 const gdb_byte *iter, *end;
3137 struct addrmap *mutable_map;
3140 auto_obstack temp_obstack;
3142 mutable_map = addrmap_create_mutable (&temp_obstack);
3144 iter = index->address_table.data ();
3145 end = iter + index->address_table.size ();
3147 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3151 ULONGEST hi, lo, cu_index;
3152 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3154 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3156 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
3161 complaint (_(".gdb_index address table has invalid range (%s - %s)"),
3162 hex_string (lo), hex_string (hi));
3166 if (cu_index >= dwarf2_per_objfile->all_comp_units.size ())
3168 complaint (_(".gdb_index address table has invalid CU number %u"),
3169 (unsigned) cu_index);
3173 lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr) - baseaddr;
3174 hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr) - baseaddr;
3175 addrmap_set_empty (mutable_map, lo, hi - 1,
3176 dwarf2_per_objfile->get_cu (cu_index));
3179 objfile->partial_symtabs->psymtabs_addrmap
3180 = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3183 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3184 populate the objfile's psymtabs_addrmap. */
3187 create_addrmap_from_aranges (struct dwarf2_per_objfile *dwarf2_per_objfile,
3188 struct dwarf2_section_info *section)
3190 struct objfile *objfile = dwarf2_per_objfile->objfile;
3191 bfd *abfd = objfile->obfd;
3192 struct gdbarch *gdbarch = get_objfile_arch (objfile);
3193 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
3194 SECT_OFF_TEXT (objfile));
3196 auto_obstack temp_obstack;
3197 addrmap *mutable_map = addrmap_create_mutable (&temp_obstack);
3199 std::unordered_map<sect_offset,
3200 dwarf2_per_cu_data *,
3201 gdb::hash_enum<sect_offset>>
3202 debug_info_offset_to_per_cu;
3203 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3205 const auto insertpair
3206 = debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);
3207 if (!insertpair.second)
3209 warning (_("Section .debug_aranges in %s has duplicate "
3210 "debug_info_offset %s, ignoring .debug_aranges."),
3211 objfile_name (objfile), sect_offset_str (per_cu->sect_off));
3216 dwarf2_read_section (objfile, section);
3218 const bfd_endian dwarf5_byte_order = gdbarch_byte_order (gdbarch);
3220 const gdb_byte *addr = section->buffer;
3222 while (addr < section->buffer + section->size)
3224 const gdb_byte *const entry_addr = addr;
3225 unsigned int bytes_read;
3227 const LONGEST entry_length = read_initial_length (abfd, addr,
3231 const gdb_byte *const entry_end = addr + entry_length;
3232 const bool dwarf5_is_dwarf64 = bytes_read != 4;
3233 const uint8_t offset_size = dwarf5_is_dwarf64 ? 8 : 4;
3234 if (addr + entry_length > section->buffer + section->size)
3236 warning (_("Section .debug_aranges in %s entry at offset %s "
3237 "length %s exceeds section length %s, "
3238 "ignoring .debug_aranges."),
3239 objfile_name (objfile),
3240 plongest (entry_addr - section->buffer),
3241 plongest (bytes_read + entry_length),
3242 pulongest (section->size));
3246 /* The version number. */
3247 const uint16_t version = read_2_bytes (abfd, addr);
3251 warning (_("Section .debug_aranges in %s entry at offset %s "
3252 "has unsupported version %d, ignoring .debug_aranges."),
3253 objfile_name (objfile),
3254 plongest (entry_addr - section->buffer), version);
3258 const uint64_t debug_info_offset
3259 = extract_unsigned_integer (addr, offset_size, dwarf5_byte_order);
3260 addr += offset_size;
3261 const auto per_cu_it
3262 = debug_info_offset_to_per_cu.find (sect_offset (debug_info_offset));
3263 if (per_cu_it == debug_info_offset_to_per_cu.cend ())
3265 warning (_("Section .debug_aranges in %s entry at offset %s "
3266 "debug_info_offset %s does not exists, "
3267 "ignoring .debug_aranges."),
3268 objfile_name (objfile),
3269 plongest (entry_addr - section->buffer),
3270 pulongest (debug_info_offset));
3273 dwarf2_per_cu_data *const per_cu = per_cu_it->second;
3275 const uint8_t address_size = *addr++;
3276 if (address_size < 1 || address_size > 8)
3278 warning (_("Section .debug_aranges in %s entry at offset %s "
3279 "address_size %u is invalid, ignoring .debug_aranges."),
3280 objfile_name (objfile),
3281 plongest (entry_addr - section->buffer), address_size);
3285 const uint8_t segment_selector_size = *addr++;
3286 if (segment_selector_size != 0)
3288 warning (_("Section .debug_aranges in %s entry at offset %s "
3289 "segment_selector_size %u is not supported, "
3290 "ignoring .debug_aranges."),
3291 objfile_name (objfile),
3292 plongest (entry_addr - section->buffer),
3293 segment_selector_size);
3297 /* Must pad to an alignment boundary that is twice the address
3298 size. It is undocumented by the DWARF standard but GCC does
3300 for (size_t padding = ((-(addr - section->buffer))
3301 & (2 * address_size - 1));
3302 padding > 0; padding--)
3305 warning (_("Section .debug_aranges in %s entry at offset %s "
3306 "padding is not zero, ignoring .debug_aranges."),
3307 objfile_name (objfile),
3308 plongest (entry_addr - section->buffer));
3314 if (addr + 2 * address_size > entry_end)
3316 warning (_("Section .debug_aranges in %s entry at offset %s "
3317 "address list is not properly terminated, "
3318 "ignoring .debug_aranges."),
3319 objfile_name (objfile),
3320 plongest (entry_addr - section->buffer));
3323 ULONGEST start = extract_unsigned_integer (addr, address_size,
3325 addr += address_size;
3326 ULONGEST length = extract_unsigned_integer (addr, address_size,
3328 addr += address_size;
3329 if (start == 0 && length == 0)
3331 if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
3333 /* Symbol was eliminated due to a COMDAT group. */
3336 ULONGEST end = start + length;
3337 start = (gdbarch_adjust_dwarf2_addr (gdbarch, start + baseaddr)
3339 end = (gdbarch_adjust_dwarf2_addr (gdbarch, end + baseaddr)
3341 addrmap_set_empty (mutable_map, start, end - 1, per_cu);
3345 objfile->partial_symtabs->psymtabs_addrmap
3346 = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3349 /* Find a slot in the mapped index INDEX for the object named NAME.
3350 If NAME is found, set *VEC_OUT to point to the CU vector in the
3351 constant pool and return true. If NAME cannot be found, return
3355 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
3356 offset_type **vec_out)
3359 offset_type slot, step;
3360 int (*cmp) (const char *, const char *);
3362 gdb::unique_xmalloc_ptr<char> without_params;
3363 if (current_language->la_language == language_cplus
3364 || current_language->la_language == language_fortran
3365 || current_language->la_language == language_d)
3367 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
3370 if (strchr (name, '(') != NULL)
3372 without_params = cp_remove_params (name);
3374 if (without_params != NULL)
3375 name = without_params.get ();
3379 /* Index version 4 did not support case insensitive searches. But the
3380 indices for case insensitive languages are built in lowercase, therefore
3381 simulate our NAME being searched is also lowercased. */
3382 hash = mapped_index_string_hash ((index->version == 4
3383 && case_sensitivity == case_sensitive_off
3384 ? 5 : index->version),
3387 slot = hash & (index->symbol_table.size () - 1);
3388 step = ((hash * 17) & (index->symbol_table.size () - 1)) | 1;
3389 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
3395 const auto &bucket = index->symbol_table[slot];
3396 if (bucket.name == 0 && bucket.vec == 0)
3399 str = index->constant_pool + MAYBE_SWAP (bucket.name);
3400 if (!cmp (name, str))
3402 *vec_out = (offset_type *) (index->constant_pool
3403 + MAYBE_SWAP (bucket.vec));
3407 slot = (slot + step) & (index->symbol_table.size () - 1);
3411 /* A helper function that reads the .gdb_index from BUFFER and fills
3412 in MAP. FILENAME is the name of the file containing the data;
3413 it is used for error reporting. DEPRECATED_OK is true if it is
3414 ok to use deprecated sections.
3416 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3417 out parameters that are filled in with information about the CU and
3418 TU lists in the section.
3420 Returns true if all went well, false otherwise. */
3423 read_gdb_index_from_buffer (struct objfile *objfile,
3424 const char *filename,
3426 gdb::array_view<const gdb_byte> buffer,
3427 struct mapped_index *map,
3428 const gdb_byte **cu_list,
3429 offset_type *cu_list_elements,
3430 const gdb_byte **types_list,
3431 offset_type *types_list_elements)
3433 const gdb_byte *addr = &buffer[0];
3435 /* Version check. */
3436 offset_type version = MAYBE_SWAP (*(offset_type *) addr);
3437 /* Versions earlier than 3 emitted every copy of a psymbol. This
3438 causes the index to behave very poorly for certain requests. Version 3
3439 contained incomplete addrmap. So, it seems better to just ignore such
3443 static int warning_printed = 0;
3444 if (!warning_printed)
3446 warning (_("Skipping obsolete .gdb_index section in %s."),
3448 warning_printed = 1;
3452 /* Index version 4 uses a different hash function than index version
3455 Versions earlier than 6 did not emit psymbols for inlined
3456 functions. Using these files will cause GDB not to be able to
3457 set breakpoints on inlined functions by name, so we ignore these
3458 indices unless the user has done
3459 "set use-deprecated-index-sections on". */
3460 if (version < 6 && !deprecated_ok)
3462 static int warning_printed = 0;
3463 if (!warning_printed)
3466 Skipping deprecated .gdb_index section in %s.\n\
3467 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3468 to use the section anyway."),
3470 warning_printed = 1;
3474 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3475 of the TU (for symbols coming from TUs),
3476 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3477 Plus gold-generated indices can have duplicate entries for global symbols,
3478 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3479 These are just performance bugs, and we can't distinguish gdb-generated
3480 indices from gold-generated ones, so issue no warning here. */
3482 /* Indexes with higher version than the one supported by GDB may be no
3483 longer backward compatible. */
3487 map->version = version;
3489 offset_type *metadata = (offset_type *) (addr + sizeof (offset_type));
3492 *cu_list = addr + MAYBE_SWAP (metadata[i]);
3493 *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3497 *types_list = addr + MAYBE_SWAP (metadata[i]);
3498 *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3499 - MAYBE_SWAP (metadata[i]))
3503 const gdb_byte *address_table = addr + MAYBE_SWAP (metadata[i]);
3504 const gdb_byte *address_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3506 = gdb::array_view<const gdb_byte> (address_table, address_table_end);
3509 const gdb_byte *symbol_table = addr + MAYBE_SWAP (metadata[i]);
3510 const gdb_byte *symbol_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3512 = gdb::array_view<mapped_index::symbol_table_slot>
3513 ((mapped_index::symbol_table_slot *) symbol_table,
3514 (mapped_index::symbol_table_slot *) symbol_table_end);
3517 map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3522 /* Callback types for dwarf2_read_gdb_index. */
3524 typedef gdb::function_view
3525 <gdb::array_view<const gdb_byte>(objfile *, dwarf2_per_objfile *)>
3526 get_gdb_index_contents_ftype;
3527 typedef gdb::function_view
3528 <gdb::array_view<const gdb_byte>(objfile *, dwz_file *)>
3529 get_gdb_index_contents_dwz_ftype;
3531 /* Read .gdb_index. If everything went ok, initialize the "quick"
3532 elements of all the CUs and return 1. Otherwise, return 0. */
3535 dwarf2_read_gdb_index
3536 (struct dwarf2_per_objfile *dwarf2_per_objfile,
3537 get_gdb_index_contents_ftype get_gdb_index_contents,
3538 get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz)
3540 const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3541 offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3542 struct dwz_file *dwz;
3543 struct objfile *objfile = dwarf2_per_objfile->objfile;
3545 gdb::array_view<const gdb_byte> main_index_contents
3546 = get_gdb_index_contents (objfile, dwarf2_per_objfile);
3548 if (main_index_contents.empty ())
3551 std::unique_ptr<struct mapped_index> map (new struct mapped_index);
3552 if (!read_gdb_index_from_buffer (objfile, objfile_name (objfile),
3553 use_deprecated_index_sections,
3554 main_index_contents, map.get (), &cu_list,
3555 &cu_list_elements, &types_list,
3556 &types_list_elements))
3559 /* Don't use the index if it's empty. */
3560 if (map->symbol_table.empty ())
3563 /* If there is a .dwz file, read it so we can get its CU list as
3565 dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3568 struct mapped_index dwz_map;
3569 const gdb_byte *dwz_types_ignore;
3570 offset_type dwz_types_elements_ignore;
3572 gdb::array_view<const gdb_byte> dwz_index_content
3573 = get_gdb_index_contents_dwz (objfile, dwz);
3575 if (dwz_index_content.empty ())
3578 if (!read_gdb_index_from_buffer (objfile,
3579 bfd_get_filename (dwz->dwz_bfd), 1,
3580 dwz_index_content, &dwz_map,
3581 &dwz_list, &dwz_list_elements,
3583 &dwz_types_elements_ignore))
3585 warning (_("could not read '.gdb_index' section from %s; skipping"),
3586 bfd_get_filename (dwz->dwz_bfd));
3591 create_cus_from_index (dwarf2_per_objfile, cu_list, cu_list_elements,
3592 dwz_list, dwz_list_elements);
3594 if (types_list_elements)
3596 /* We can only handle a single .debug_types when we have an
3598 if (dwarf2_per_objfile->types.size () != 1)
3601 dwarf2_section_info *section = &dwarf2_per_objfile->types[0];
3603 create_signatured_type_table_from_index (dwarf2_per_objfile, section,
3604 types_list, types_list_elements);
3607 create_addrmap_from_index (dwarf2_per_objfile, map.get ());
3609 dwarf2_per_objfile->index_table = std::move (map);
3610 dwarf2_per_objfile->using_index = 1;
3611 dwarf2_per_objfile->quick_file_names_table =
3612 create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
3617 /* die_reader_func for dw2_get_file_names. */
3620 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3621 const gdb_byte *info_ptr,
3622 struct die_info *comp_unit_die,
3626 struct dwarf2_cu *cu = reader->cu;
3627 struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3628 struct dwarf2_per_objfile *dwarf2_per_objfile
3629 = cu->per_cu->dwarf2_per_objfile;
3630 struct objfile *objfile = dwarf2_per_objfile->objfile;
3631 struct dwarf2_per_cu_data *lh_cu;
3632 struct attribute *attr;
3635 struct quick_file_names *qfn;
3637 gdb_assert (! this_cu->is_debug_types);
3639 /* Our callers never want to match partial units -- instead they
3640 will match the enclosing full CU. */
3641 if (comp_unit_die->tag == DW_TAG_partial_unit)
3643 this_cu->v.quick->no_file_data = 1;
3651 sect_offset line_offset {};
3653 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3656 struct quick_file_names find_entry;
3658 line_offset = (sect_offset) DW_UNSND (attr);
3660 /* We may have already read in this line header (TU line header sharing).
3661 If we have we're done. */
3662 find_entry.hash.dwo_unit = cu->dwo_unit;
3663 find_entry.hash.line_sect_off = line_offset;
3664 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3665 &find_entry, INSERT);
3668 lh_cu->v.quick->file_names = (struct quick_file_names *) *slot;
3672 lh = dwarf_decode_line_header (line_offset, cu);
3676 lh_cu->v.quick->no_file_data = 1;
3680 qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
3681 qfn->hash.dwo_unit = cu->dwo_unit;
3682 qfn->hash.line_sect_off = line_offset;
3683 gdb_assert (slot != NULL);
3686 file_and_directory fnd = find_file_and_directory (comp_unit_die, cu);
3688 qfn->num_file_names = lh->file_names.size ();
3690 XOBNEWVEC (&objfile->objfile_obstack, const char *, lh->file_names.size ());
3691 for (i = 0; i < lh->file_names.size (); ++i)
3692 qfn->file_names[i] = file_full_name (i + 1, lh.get (), fnd.comp_dir);
3693 qfn->real_names = NULL;
3695 lh_cu->v.quick->file_names = qfn;
3698 /* A helper for the "quick" functions which attempts to read the line
3699 table for THIS_CU. */
3701 static struct quick_file_names *
3702 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3704 /* This should never be called for TUs. */
3705 gdb_assert (! this_cu->is_debug_types);
3706 /* Nor type unit groups. */
3707 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3709 if (this_cu->v.quick->file_names != NULL)
3710 return this_cu->v.quick->file_names;
3711 /* If we know there is no line data, no point in looking again. */
3712 if (this_cu->v.quick->no_file_data)
3715 init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3717 if (this_cu->v.quick->no_file_data)
3719 return this_cu->v.quick->file_names;
3722 /* A helper for the "quick" functions which computes and caches the
3723 real path for a given file name from the line table. */
3726 dw2_get_real_path (struct objfile *objfile,
3727 struct quick_file_names *qfn, int index)
3729 if (qfn->real_names == NULL)
3730 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3731 qfn->num_file_names, const char *);
3733 if (qfn->real_names[index] == NULL)
3734 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]).release ();
3736 return qfn->real_names[index];
3739 static struct symtab *
3740 dw2_find_last_source_symtab (struct objfile *objfile)
3742 struct dwarf2_per_objfile *dwarf2_per_objfile
3743 = get_dwarf2_per_objfile (objfile);
3744 dwarf2_per_cu_data *dwarf_cu = dwarf2_per_objfile->all_comp_units.back ();
3745 compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu, false);
3750 return compunit_primary_filetab (cust);
3753 /* Traversal function for dw2_forget_cached_source_info. */
3756 dw2_free_cached_file_names (void **slot, void *info)
3758 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3760 if (file_data->real_names)
3764 for (i = 0; i < file_data->num_file_names; ++i)
3766 xfree ((void*) file_data->real_names[i]);
3767 file_data->real_names[i] = NULL;
3775 dw2_forget_cached_source_info (struct objfile *objfile)
3777 struct dwarf2_per_objfile *dwarf2_per_objfile
3778 = get_dwarf2_per_objfile (objfile);
3780 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3781 dw2_free_cached_file_names, NULL);
3784 /* Helper function for dw2_map_symtabs_matching_filename that expands
3785 the symtabs and calls the iterator. */
3788 dw2_map_expand_apply (struct objfile *objfile,
3789 struct dwarf2_per_cu_data *per_cu,
3790 const char *name, const char *real_path,
3791 gdb::function_view<bool (symtab *)> callback)
3793 struct compunit_symtab *last_made = objfile->compunit_symtabs;
3795 /* Don't visit already-expanded CUs. */
3796 if (per_cu->v.quick->compunit_symtab)
3799 /* This may expand more than one symtab, and we want to iterate over
3801 dw2_instantiate_symtab (per_cu, false);
3803 return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
3804 last_made, callback);
3807 /* Implementation of the map_symtabs_matching_filename method. */
3810 dw2_map_symtabs_matching_filename
3811 (struct objfile *objfile, const char *name, const char *real_path,
3812 gdb::function_view<bool (symtab *)> callback)
3814 const char *name_basename = lbasename (name);
3815 struct dwarf2_per_objfile *dwarf2_per_objfile
3816 = get_dwarf2_per_objfile (objfile);
3818 /* The rule is CUs specify all the files, including those used by
3819 any TU, so there's no need to scan TUs here. */
3821 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3823 /* We only need to look at symtabs not already expanded. */
3824 if (per_cu->v.quick->compunit_symtab)
3827 quick_file_names *file_data = dw2_get_file_names (per_cu);
3828 if (file_data == NULL)
3831 for (int j = 0; j < file_data->num_file_names; ++j)
3833 const char *this_name = file_data->file_names[j];
3834 const char *this_real_name;
3836 if (compare_filenames_for_search (this_name, name))
3838 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3844 /* Before we invoke realpath, which can get expensive when many
3845 files are involved, do a quick comparison of the basenames. */
3846 if (! basenames_may_differ
3847 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3850 this_real_name = dw2_get_real_path (objfile, file_data, j);
3851 if (compare_filenames_for_search (this_real_name, name))
3853 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3859 if (real_path != NULL)
3861 gdb_assert (IS_ABSOLUTE_PATH (real_path));
3862 gdb_assert (IS_ABSOLUTE_PATH (name));
3863 if (this_real_name != NULL
3864 && FILENAME_CMP (real_path, this_real_name) == 0)
3866 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3878 /* Struct used to manage iterating over all CUs looking for a symbol. */
3880 struct dw2_symtab_iterator
3882 /* The dwarf2_per_objfile owning the CUs we are iterating on. */
3883 struct dwarf2_per_objfile *dwarf2_per_objfile;
3884 /* If set, only look for symbols that match that block. Valid values are
3885 GLOBAL_BLOCK and STATIC_BLOCK. */
3886 gdb::optional<int> block_index;
3887 /* The kind of symbol we're looking for. */
3889 /* The list of CUs from the index entry of the symbol,
3890 or NULL if not found. */
3892 /* The next element in VEC to look at. */
3894 /* The number of elements in VEC, or zero if there is no match. */
3896 /* Have we seen a global version of the symbol?
3897 If so we can ignore all further global instances.
3898 This is to work around gold/15646, inefficient gold-generated
3903 /* Initialize the index symtab iterator ITER. */
3906 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3907 struct dwarf2_per_objfile *dwarf2_per_objfile,
3908 gdb::optional<int> block_index,
3912 iter->dwarf2_per_objfile = dwarf2_per_objfile;
3913 iter->block_index = block_index;
3914 iter->domain = domain;
3916 iter->global_seen = 0;
3918 mapped_index *index = dwarf2_per_objfile->index_table.get ();
3920 /* index is NULL if OBJF_READNOW. */
3921 if (index != NULL && find_slot_in_mapped_hash (index, name, &iter->vec))
3922 iter->length = MAYBE_SWAP (*iter->vec);
3930 /* Return the next matching CU or NULL if there are no more. */
3932 static struct dwarf2_per_cu_data *
3933 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
3935 struct dwarf2_per_objfile *dwarf2_per_objfile = iter->dwarf2_per_objfile;
3937 for ( ; iter->next < iter->length; ++iter->next)
3939 offset_type cu_index_and_attrs =
3940 MAYBE_SWAP (iter->vec[iter->next + 1]);
3941 offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3942 gdb_index_symbol_kind symbol_kind =
3943 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3944 /* Only check the symbol attributes if they're present.
3945 Indices prior to version 7 don't record them,
3946 and indices >= 7 may elide them for certain symbols
3947 (gold does this). */
3949 (dwarf2_per_objfile->index_table->version >= 7
3950 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3952 /* Don't crash on bad data. */
3953 if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
3954 + dwarf2_per_objfile->all_type_units.size ()))
3956 complaint (_(".gdb_index entry has bad CU index"
3958 objfile_name (dwarf2_per_objfile->objfile));
3962 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
3964 /* Skip if already read in. */
3965 if (per_cu->v.quick->compunit_symtab)
3968 /* Check static vs global. */
3971 bool is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3973 if (iter->block_index.has_value ())
3975 bool want_static = *iter->block_index == STATIC_BLOCK;
3977 if (is_static != want_static)
3981 /* Work around gold/15646. */
3982 if (!is_static && iter->global_seen)
3985 iter->global_seen = 1;
3988 /* Only check the symbol's kind if it has one. */
3991 switch (iter->domain)
3994 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
3995 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
3996 /* Some types are also in VAR_DOMAIN. */
3997 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4001 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4005 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
4020 static struct compunit_symtab *
4021 dw2_lookup_symbol (struct objfile *objfile, int block_index,
4022 const char *name, domain_enum domain)
4024 struct compunit_symtab *stab_best = NULL;
4025 struct dwarf2_per_objfile *dwarf2_per_objfile
4026 = get_dwarf2_per_objfile (objfile);
4028 lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
4030 struct dw2_symtab_iterator iter;
4031 struct dwarf2_per_cu_data *per_cu;
4033 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, block_index, domain, name);
4035 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4037 struct symbol *sym, *with_opaque = NULL;
4038 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
4039 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
4040 const struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
4042 sym = block_find_symbol (block, name, domain,
4043 block_find_non_opaque_type_preferred,
4046 /* Some caution must be observed with overloaded functions
4047 and methods, since the index will not contain any overload
4048 information (but NAME might contain it). */
4051 && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
4053 if (with_opaque != NULL
4054 && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
4057 /* Keep looking through other CUs. */
4064 dw2_print_stats (struct objfile *objfile)
4066 struct dwarf2_per_objfile *dwarf2_per_objfile
4067 = get_dwarf2_per_objfile (objfile);
4068 int total = (dwarf2_per_objfile->all_comp_units.size ()
4069 + dwarf2_per_objfile->all_type_units.size ());
4072 for (int i = 0; i < total; ++i)
4074 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4076 if (!per_cu->v.quick->compunit_symtab)
4079 printf_filtered (_(" Number of read CUs: %d\n"), total - count);
4080 printf_filtered (_(" Number of unread CUs: %d\n"), count);
4083 /* This dumps minimal information about the index.
4084 It is called via "mt print objfiles".
4085 One use is to verify .gdb_index has been loaded by the
4086 gdb.dwarf2/gdb-index.exp testcase. */
4089 dw2_dump (struct objfile *objfile)
4091 struct dwarf2_per_objfile *dwarf2_per_objfile
4092 = get_dwarf2_per_objfile (objfile);
4094 gdb_assert (dwarf2_per_objfile->using_index);
4095 printf_filtered (".gdb_index:");
4096 if (dwarf2_per_objfile->index_table != NULL)
4098 printf_filtered (" version %d\n",
4099 dwarf2_per_objfile->index_table->version);
4102 printf_filtered (" faked for \"readnow\"\n");
4103 printf_filtered ("\n");
4107 dw2_expand_symtabs_for_function (struct objfile *objfile,
4108 const char *func_name)
4110 struct dwarf2_per_objfile *dwarf2_per_objfile
4111 = get_dwarf2_per_objfile (objfile);
4113 struct dw2_symtab_iterator iter;
4114 struct dwarf2_per_cu_data *per_cu;
4116 dw2_symtab_iter_init (&iter, dwarf2_per_objfile, {}, VAR_DOMAIN, func_name);
4118 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4119 dw2_instantiate_symtab (per_cu, false);
4124 dw2_expand_all_symtabs (struct objfile *objfile)
4126 struct dwarf2_per_objfile *dwarf2_per_objfile
4127 = get_dwarf2_per_objfile (objfile);
4128 int total_units = (dwarf2_per_objfile->all_comp_units.size ()
4129 + dwarf2_per_objfile->all_type_units.size ());
4131 for (int i = 0; i < total_units; ++i)
4133 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4135 /* We don't want to directly expand a partial CU, because if we
4136 read it with the wrong language, then assertion failures can
4137 be triggered later on. See PR symtab/23010. So, tell
4138 dw2_instantiate_symtab to skip partial CUs -- any important
4139 partial CU will be read via DW_TAG_imported_unit anyway. */
4140 dw2_instantiate_symtab (per_cu, true);
4145 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
4146 const char *fullname)
4148 struct dwarf2_per_objfile *dwarf2_per_objfile
4149 = get_dwarf2_per_objfile (objfile);
4151 /* We don't need to consider type units here.
4152 This is only called for examining code, e.g. expand_line_sal.
4153 There can be an order of magnitude (or more) more type units
4154 than comp units, and we avoid them if we can. */
4156 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
4158 /* We only need to look at symtabs not already expanded. */
4159 if (per_cu->v.quick->compunit_symtab)
4162 quick_file_names *file_data = dw2_get_file_names (per_cu);
4163 if (file_data == NULL)
4166 for (int j = 0; j < file_data->num_file_names; ++j)
4168 const char *this_fullname = file_data->file_names[j];
4170 if (filename_cmp (this_fullname, fullname) == 0)
4172 dw2_instantiate_symtab (per_cu, false);
4180 dw2_map_matching_symbols (struct objfile *objfile,
4181 const char * name, domain_enum domain,
4183 int (*callback) (const struct block *,
4184 struct symbol *, void *),
4185 void *data, symbol_name_match_type match,
4186 symbol_compare_ftype *ordered_compare)
4188 /* Currently unimplemented; used for Ada. The function can be called if the
4189 current language is Ada for a non-Ada objfile using GNU index. As Ada
4190 does not look for non-Ada symbols this function should just return. */
4193 /* Symbol name matcher for .gdb_index names.
4195 Symbol names in .gdb_index have a few particularities:
4197 - There's no indication of which is the language of each symbol.
4199 Since each language has its own symbol name matching algorithm,
4200 and we don't know which language is the right one, we must match
4201 each symbol against all languages. This would be a potential
4202 performance problem if it were not mitigated by the
4203 mapped_index::name_components lookup table, which significantly
4204 reduces the number of times we need to call into this matcher,
4205 making it a non-issue.
4207 - Symbol names in the index have no overload (parameter)
4208 information. I.e., in C++, "foo(int)" and "foo(long)" both
4209 appear as "foo" in the index, for example.
4211 This means that the lookup names passed to the symbol name
4212 matcher functions must have no parameter information either
4213 because (e.g.) symbol search name "foo" does not match
4214 lookup-name "foo(int)" [while swapping search name for lookup
4217 class gdb_index_symbol_name_matcher
4220 /* Prepares the vector of comparison functions for LOOKUP_NAME. */
4221 gdb_index_symbol_name_matcher (const lookup_name_info &lookup_name);
4223 /* Walk all the matcher routines and match SYMBOL_NAME against them.
4224 Returns true if any matcher matches. */
4225 bool matches (const char *symbol_name);
4228 /* A reference to the lookup name we're matching against. */
4229 const lookup_name_info &m_lookup_name;
4231 /* A vector holding all the different symbol name matchers, for all
4233 std::vector<symbol_name_matcher_ftype *> m_symbol_name_matcher_funcs;
4236 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4237 (const lookup_name_info &lookup_name)
4238 : m_lookup_name (lookup_name)
4240 /* Prepare the vector of comparison functions upfront, to avoid
4241 doing the same work for each symbol. Care is taken to avoid
4242 matching with the same matcher more than once if/when multiple
4243 languages use the same matcher function. */
4244 auto &matchers = m_symbol_name_matcher_funcs;
4245 matchers.reserve (nr_languages);
4247 matchers.push_back (default_symbol_name_matcher);
4249 for (int i = 0; i < nr_languages; i++)
4251 const language_defn *lang = language_def ((enum language) i);
4252 symbol_name_matcher_ftype *name_matcher
4253 = get_symbol_name_matcher (lang, m_lookup_name);
4255 /* Don't insert the same comparison routine more than once.
4256 Note that we do this linear walk instead of a seemingly
4257 cheaper sorted insert, or use a std::set or something like
4258 that, because relative order of function addresses is not
4259 stable. This is not a problem in practice because the number
4260 of supported languages is low, and the cost here is tiny
4261 compared to the number of searches we'll do afterwards using
4263 if (name_matcher != default_symbol_name_matcher
4264 && (std::find (matchers.begin (), matchers.end (), name_matcher)
4265 == matchers.end ()))
4266 matchers.push_back (name_matcher);
4271 gdb_index_symbol_name_matcher::matches (const char *symbol_name)
4273 for (auto matches_name : m_symbol_name_matcher_funcs)
4274 if (matches_name (symbol_name, m_lookup_name, NULL))
4280 /* Starting from a search name, return the string that finds the upper
4281 bound of all strings that start with SEARCH_NAME in a sorted name
4282 list. Returns the empty string to indicate that the upper bound is
4283 the end of the list. */
4286 make_sort_after_prefix_name (const char *search_name)
4288 /* When looking to complete "func", we find the upper bound of all
4289 symbols that start with "func" by looking for where we'd insert
4290 the closest string that would follow "func" in lexicographical
4291 order. Usually, that's "func"-with-last-character-incremented,
4292 i.e. "fund". Mind non-ASCII characters, though. Usually those
4293 will be UTF-8 multi-byte sequences, but we can't be certain.
4294 Especially mind the 0xff character, which is a valid character in
4295 non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4296 rule out compilers allowing it in identifiers. Note that
4297 conveniently, strcmp/strcasecmp are specified to compare
4298 characters interpreted as unsigned char. So what we do is treat
4299 the whole string as a base 256 number composed of a sequence of
4300 base 256 "digits" and add 1 to it. I.e., adding 1 to 0xff wraps
4301 to 0, and carries 1 to the following more-significant position.
4302 If the very first character in SEARCH_NAME ends up incremented
4303 and carries/overflows, then the upper bound is the end of the
4304 list. The string after the empty string is also the empty
4307 Some examples of this operation:
4309 SEARCH_NAME => "+1" RESULT
4313 "\xff" "a" "\xff" => "\xff" "b"
4318 Then, with these symbols for example:
4324 completing "func" looks for symbols between "func" and
4325 "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4326 which finds "func" and "func1", but not "fund".
4330 funcÿ (Latin1 'ÿ' [0xff])
4334 completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4335 (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4339 ÿÿ (Latin1 'ÿ' [0xff])
4342 completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4343 the end of the list.
4345 std::string after = search_name;
4346 while (!after.empty () && (unsigned char) after.back () == 0xff)
4348 if (!after.empty ())
4349 after.back () = (unsigned char) after.back () + 1;
4353 /* See declaration. */
4355 std::pair<std::vector<name_component>::const_iterator,
4356 std::vector<name_component>::const_iterator>
4357 mapped_index_base::find_name_components_bounds
4358 (const lookup_name_info &lookup_name_without_params) const
4361 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4364 = lookup_name_without_params.cplus ().lookup_name ().c_str ();
4366 /* Comparison function object for lower_bound that matches against a
4367 given symbol name. */
4368 auto lookup_compare_lower = [&] (const name_component &elem,
4371 const char *elem_qualified = this->symbol_name_at (elem.idx);
4372 const char *elem_name = elem_qualified + elem.name_offset;
4373 return name_cmp (elem_name, name) < 0;
4376 /* Comparison function object for upper_bound that matches against a
4377 given symbol name. */
4378 auto lookup_compare_upper = [&] (const char *name,
4379 const name_component &elem)
4381 const char *elem_qualified = this->symbol_name_at (elem.idx);
4382 const char *elem_name = elem_qualified + elem.name_offset;
4383 return name_cmp (name, elem_name) < 0;
4386 auto begin = this->name_components.begin ();
4387 auto end = this->name_components.end ();
4389 /* Find the lower bound. */
4392 if (lookup_name_without_params.completion_mode () && cplus[0] == '\0')
4395 return std::lower_bound (begin, end, cplus, lookup_compare_lower);
4398 /* Find the upper bound. */
4401 if (lookup_name_without_params.completion_mode ())
4403 /* In completion mode, we want UPPER to point past all
4404 symbols names that have the same prefix. I.e., with
4405 these symbols, and completing "func":
4407 function << lower bound
4409 other_function << upper bound
4411 We find the upper bound by looking for the insertion
4412 point of "func"-with-last-character-incremented,
4414 std::string after = make_sort_after_prefix_name (cplus);
4417 return std::lower_bound (lower, end, after.c_str (),
4418 lookup_compare_lower);
4421 return std::upper_bound (lower, end, cplus, lookup_compare_upper);
4424 return {lower, upper};
4427 /* See declaration. */
4430 mapped_index_base::build_name_components ()
4432 if (!this->name_components.empty ())
4435 this->name_components_casing = case_sensitivity;
4437 = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4439 /* The code below only knows how to break apart components of C++
4440 symbol names (and other languages that use '::' as
4441 namespace/module separator). If we add support for wild matching
4442 to some language that uses some other operator (E.g., Ada, Go and
4443 D use '.'), then we'll need to try splitting the symbol name
4444 according to that language too. Note that Ada does support wild
4445 matching, but doesn't currently support .gdb_index. */
4446 auto count = this->symbol_name_count ();
4447 for (offset_type idx = 0; idx < count; idx++)
4449 if (this->symbol_name_slot_invalid (idx))
4452 const char *name = this->symbol_name_at (idx);
4454 /* Add each name component to the name component table. */
4455 unsigned int previous_len = 0;
4456 for (unsigned int current_len = cp_find_first_component (name);
4457 name[current_len] != '\0';
4458 current_len += cp_find_first_component (name + current_len))
4460 gdb_assert (name[current_len] == ':');
4461 this->name_components.push_back ({previous_len, idx});
4462 /* Skip the '::'. */
4464 previous_len = current_len;
4466 this->name_components.push_back ({previous_len, idx});
4469 /* Sort name_components elements by name. */
4470 auto name_comp_compare = [&] (const name_component &left,
4471 const name_component &right)
4473 const char *left_qualified = this->symbol_name_at (left.idx);
4474 const char *right_qualified = this->symbol_name_at (right.idx);
4476 const char *left_name = left_qualified + left.name_offset;
4477 const char *right_name = right_qualified + right.name_offset;
4479 return name_cmp (left_name, right_name) < 0;
4482 std::sort (this->name_components.begin (),
4483 this->name_components.end (),
4487 /* Helper for dw2_expand_symtabs_matching that works with a
4488 mapped_index_base instead of the containing objfile. This is split
4489 to a separate function in order to be able to unit test the
4490 name_components matching using a mock mapped_index_base. For each
4491 symbol name that matches, calls MATCH_CALLBACK, passing it the
4492 symbol's index in the mapped_index_base symbol table. */
4495 dw2_expand_symtabs_matching_symbol
4496 (mapped_index_base &index,
4497 const lookup_name_info &lookup_name_in,
4498 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
4499 enum search_domain kind,
4500 gdb::function_view<void (offset_type)> match_callback)
4502 lookup_name_info lookup_name_without_params
4503 = lookup_name_in.make_ignore_params ();
4504 gdb_index_symbol_name_matcher lookup_name_matcher
4505 (lookup_name_without_params);
4507 /* Build the symbol name component sorted vector, if we haven't
4509 index.build_name_components ();
4511 auto bounds = index.find_name_components_bounds (lookup_name_without_params);
4513 /* Now for each symbol name in range, check to see if we have a name
4514 match, and if so, call the MATCH_CALLBACK callback. */
4516 /* The same symbol may appear more than once in the range though.
4517 E.g., if we're looking for symbols that complete "w", and we have
4518 a symbol named "w1::w2", we'll find the two name components for
4519 that same symbol in the range. To be sure we only call the
4520 callback once per symbol, we first collect the symbol name
4521 indexes that matched in a temporary vector and ignore
4523 std::vector<offset_type> matches;
4524 matches.reserve (std::distance (bounds.first, bounds.second));
4526 for (; bounds.first != bounds.second; ++bounds.first)
4528 const char *qualified = index.symbol_name_at (bounds.first->idx);
4530 if (!lookup_name_matcher.matches (qualified)
4531 || (symbol_matcher != NULL && !symbol_matcher (qualified)))
4534 matches.push_back (bounds.first->idx);
4537 std::sort (matches.begin (), matches.end ());
4539 /* Finally call the callback, once per match. */
4541 for (offset_type idx : matches)
4545 match_callback (idx);
4550 /* Above we use a type wider than idx's for 'prev', since 0 and
4551 (offset_type)-1 are both possible values. */
4552 static_assert (sizeof (prev) > sizeof (offset_type), "");
4557 namespace selftests { namespace dw2_expand_symtabs_matching {
4559 /* A mock .gdb_index/.debug_names-like name index table, enough to
4560 exercise dw2_expand_symtabs_matching_symbol, which works with the
4561 mapped_index_base interface. Builds an index from the symbol list
4562 passed as parameter to the constructor. */
4563 class mock_mapped_index : public mapped_index_base
4566 mock_mapped_index (gdb::array_view<const char *> symbols)
4567 : m_symbol_table (symbols)
4570 DISABLE_COPY_AND_ASSIGN (mock_mapped_index);
4572 /* Return the number of names in the symbol table. */
4573 size_t symbol_name_count () const override
4575 return m_symbol_table.size ();
4578 /* Get the name of the symbol at IDX in the symbol table. */
4579 const char *symbol_name_at (offset_type idx) const override
4581 return m_symbol_table[idx];
4585 gdb::array_view<const char *> m_symbol_table;
4588 /* Convenience function that converts a NULL pointer to a "<null>"
4589 string, to pass to print routines. */
4592 string_or_null (const char *str)
4594 return str != NULL ? str : "<null>";
4597 /* Check if a lookup_name_info built from
4598 NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4599 index. EXPECTED_LIST is the list of expected matches, in expected
4600 matching order. If no match expected, then an empty list is
4601 specified. Returns true on success. On failure prints a warning
4602 indicating the file:line that failed, and returns false. */
4605 check_match (const char *file, int line,
4606 mock_mapped_index &mock_index,
4607 const char *name, symbol_name_match_type match_type,
4608 bool completion_mode,
4609 std::initializer_list<const char *> expected_list)
4611 lookup_name_info lookup_name (name, match_type, completion_mode);
4613 bool matched = true;
4615 auto mismatch = [&] (const char *expected_str,
4618 warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4619 "expected=\"%s\", got=\"%s\"\n"),
4621 (match_type == symbol_name_match_type::FULL
4623 name, string_or_null (expected_str), string_or_null (got));
4627 auto expected_it = expected_list.begin ();
4628 auto expected_end = expected_list.end ();
4630 dw2_expand_symtabs_matching_symbol (mock_index, lookup_name,
4632 [&] (offset_type idx)
4634 const char *matched_name = mock_index.symbol_name_at (idx);
4635 const char *expected_str
4636 = expected_it == expected_end ? NULL : *expected_it++;
4638 if (expected_str == NULL || strcmp (expected_str, matched_name) != 0)
4639 mismatch (expected_str, matched_name);
4642 const char *expected_str
4643 = expected_it == expected_end ? NULL : *expected_it++;
4644 if (expected_str != NULL)
4645 mismatch (expected_str, NULL);
4650 /* The symbols added to the mock mapped_index for testing (in
4652 static const char *test_symbols[] = {
4661 "ns2::tmpl<int>::foo2",
4662 "(anonymous namespace)::A::B::C",
4664 /* These are used to check that the increment-last-char in the
4665 matching algorithm for completion doesn't match "t1_fund" when
4666 completing "t1_func". */
4672 /* A UTF-8 name with multi-byte sequences to make sure that
4673 cp-name-parser understands this as a single identifier ("função"
4674 is "function" in PT). */
4677 /* \377 (0xff) is Latin1 'ÿ'. */
4680 /* \377 (0xff) is Latin1 'ÿ'. */
4684 /* A name with all sorts of complications. Starts with "z" to make
4685 it easier for the completion tests below. */
4686 #define Z_SYM_NAME \
4687 "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4688 "::tuple<(anonymous namespace)::ui*, " \
4689 "std::default_delete<(anonymous namespace)::ui>, void>"
4694 /* Returns true if the mapped_index_base::find_name_component_bounds
4695 method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4696 in completion mode. */
4699 check_find_bounds_finds (mapped_index_base &index,
4700 const char *search_name,
4701 gdb::array_view<const char *> expected_syms)
4703 lookup_name_info lookup_name (search_name,
4704 symbol_name_match_type::FULL, true);
4706 auto bounds = index.find_name_components_bounds (lookup_name);
4708 size_t distance = std::distance (bounds.first, bounds.second);
4709 if (distance != expected_syms.size ())
4712 for (size_t exp_elem = 0; exp_elem < distance; exp_elem++)
4714 auto nc_elem = bounds.first + exp_elem;
4715 const char *qualified = index.symbol_name_at (nc_elem->idx);
4716 if (strcmp (qualified, expected_syms[exp_elem]) != 0)
4723 /* Test the lower-level mapped_index::find_name_component_bounds
4727 test_mapped_index_find_name_component_bounds ()
4729 mock_mapped_index mock_index (test_symbols);
4731 mock_index.build_name_components ();
4733 /* Test the lower-level mapped_index::find_name_component_bounds
4734 method in completion mode. */
4736 static const char *expected_syms[] = {
4741 SELF_CHECK (check_find_bounds_finds (mock_index,
4742 "t1_func", expected_syms));
4745 /* Check that the increment-last-char in the name matching algorithm
4746 for completion doesn't get confused with Ansi1 'ÿ' / 0xff. */
4748 static const char *expected_syms1[] = {
4752 SELF_CHECK (check_find_bounds_finds (mock_index,
4753 "\377", expected_syms1));
4755 static const char *expected_syms2[] = {
4758 SELF_CHECK (check_find_bounds_finds (mock_index,
4759 "\377\377", expected_syms2));
4763 /* Test dw2_expand_symtabs_matching_symbol. */
4766 test_dw2_expand_symtabs_matching_symbol ()
4768 mock_mapped_index mock_index (test_symbols);
4770 /* We let all tests run until the end even if some fails, for debug
4772 bool any_mismatch = false;
4774 /* Create the expected symbols list (an initializer_list). Needed
4775 because lists have commas, and we need to pass them to CHECK,
4776 which is a macro. */
4777 #define EXPECT(...) { __VA_ARGS__ }
4779 /* Wrapper for check_match that passes down the current
4780 __FILE__/__LINE__. */
4781 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST) \
4782 any_mismatch |= !check_match (__FILE__, __LINE__, \
4784 NAME, MATCH_TYPE, COMPLETION_MODE, \
4787 /* Identity checks. */
4788 for (const char *sym : test_symbols)
4790 /* Should be able to match all existing symbols. */
4791 CHECK_MATCH (sym, symbol_name_match_type::FULL, false,
4794 /* Should be able to match all existing symbols with
4796 std::string with_params = std::string (sym) + "(int)";
4797 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4800 /* Should be able to match all existing symbols with
4801 parameters and qualifiers. */
4802 with_params = std::string (sym) + " ( int ) const";
4803 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4806 /* This should really find sym, but cp-name-parser.y doesn't
4807 know about lvalue/rvalue qualifiers yet. */
4808 with_params = std::string (sym) + " ( int ) &&";
4809 CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4813 /* Check that the name matching algorithm for completion doesn't get
4814 confused with Latin1 'ÿ' / 0xff. */
4816 static const char str[] = "\377";
4817 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4818 EXPECT ("\377", "\377\377123"));
4821 /* Check that the increment-last-char in the matching algorithm for
4822 completion doesn't match "t1_fund" when completing "t1_func". */
4824 static const char str[] = "t1_func";
4825 CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4826 EXPECT ("t1_func", "t1_func1"));
4829 /* Check that completion mode works at each prefix of the expected
4832 static const char str[] = "function(int)";
4833 size_t len = strlen (str);
4836 for (size_t i = 1; i < len; i++)
4838 lookup.assign (str, i);
4839 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4840 EXPECT ("function"));
4844 /* While "w" is a prefix of both components, the match function
4845 should still only be called once. */
4847 CHECK_MATCH ("w", symbol_name_match_type::FULL, true,
4849 CHECK_MATCH ("w", symbol_name_match_type::WILD, true,
4853 /* Same, with a "complicated" symbol. */
4855 static const char str[] = Z_SYM_NAME;
4856 size_t len = strlen (str);
4859 for (size_t i = 1; i < len; i++)
4861 lookup.assign (str, i);
4862 CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4863 EXPECT (Z_SYM_NAME));
4867 /* In FULL mode, an incomplete symbol doesn't match. */
4869 CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL, false,
4873 /* A complete symbol with parameters matches any overload, since the
4874 index has no overload info. */
4876 CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL, true,
4877 EXPECT ("std::zfunction", "std::zfunction2"));
4878 CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD, true,
4879 EXPECT ("std::zfunction", "std::zfunction2"));
4880 CHECK_MATCH ("zfunc", symbol_name_match_type::WILD, true,
4881 EXPECT ("std::zfunction", "std::zfunction2"));
4884 /* Check that whitespace is ignored appropriately. A symbol with a
4885 template argument list. */
4887 static const char expected[] = "ns::foo<int>";
4888 CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL, false,
4890 CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD, false,
4894 /* Check that whitespace is ignored appropriately. A symbol with a
4895 template argument list that includes a pointer. */
4897 static const char expected[] = "ns::foo<char*>";
4898 /* Try both completion and non-completion modes. */
4899 static const bool completion_mode[2] = {false, true};
4900 for (size_t i = 0; i < 2; i++)
4902 CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL,
4903 completion_mode[i], EXPECT (expected));
4904 CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD,
4905 completion_mode[i], EXPECT (expected));
4907 CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL,
4908 completion_mode[i], EXPECT (expected));
4909 CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD,
4910 completion_mode[i], EXPECT (expected));
4915 /* Check method qualifiers are ignored. */
4916 static const char expected[] = "ns::foo<char*>";
4917 CHECK_MATCH ("ns :: foo < char * > ( int ) const",
4918 symbol_name_match_type::FULL, true, EXPECT (expected));
4919 CHECK_MATCH ("ns :: foo < char * > ( int ) &&",
4920 symbol_name_match_type::FULL, true, EXPECT (expected));
4921 CHECK_MATCH ("foo < char * > ( int ) const",
4922 symbol_name_match_type::WILD, true, EXPECT (expected));
4923 CHECK_MATCH ("foo < char * > ( int ) &&",
4924 symbol_name_match_type::WILD, true, EXPECT (expected));
4927 /* Test lookup names that don't match anything. */
4929 CHECK_MATCH ("bar2", symbol_name_match_type::WILD, false,
4932 CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL, false,
4936 /* Some wild matching tests, exercising "(anonymous namespace)",
4937 which should not be confused with a parameter list. */
4939 static const char *syms[] = {
4943 "A :: B :: C ( int )",
4948 for (const char *s : syms)
4950 CHECK_MATCH (s, symbol_name_match_type::WILD, false,
4951 EXPECT ("(anonymous namespace)::A::B::C"));
4956 static const char expected[] = "ns2::tmpl<int>::foo2";
4957 CHECK_MATCH ("tmp", symbol_name_match_type::WILD, true,
4959 CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD, true,
4963 SELF_CHECK (!any_mismatch);
4972 test_mapped_index_find_name_component_bounds ();
4973 test_dw2_expand_symtabs_matching_symbol ();
4976 }} // namespace selftests::dw2_expand_symtabs_matching
4978 #endif /* GDB_SELF_TEST */
4980 /* If FILE_MATCHER is NULL or if PER_CU has
4981 dwarf2_per_cu_quick_data::MARK set (see
4982 dw_expand_symtabs_matching_file_matcher), expand the CU and call
4983 EXPANSION_NOTIFY on it. */
4986 dw2_expand_symtabs_matching_one
4987 (struct dwarf2_per_cu_data *per_cu,
4988 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
4989 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify)
4991 if (file_matcher == NULL || per_cu->v.quick->mark)
4993 bool symtab_was_null
4994 = (per_cu->v.quick->compunit_symtab == NULL);
4996 dw2_instantiate_symtab (per_cu, false);
4998 if (expansion_notify != NULL
5000 && per_cu->v.quick->compunit_symtab != NULL)
5001 expansion_notify (per_cu->v.quick->compunit_symtab);
5005 /* Helper for dw2_expand_matching symtabs. Called on each symbol
5006 matched, to expand corresponding CUs that were marked. IDX is the
5007 index of the symbol name that matched. */
5010 dw2_expand_marked_cus
5011 (struct dwarf2_per_objfile *dwarf2_per_objfile, offset_type idx,
5012 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5013 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5016 offset_type *vec, vec_len, vec_idx;
5017 bool global_seen = false;
5018 mapped_index &index = *dwarf2_per_objfile->index_table;
5020 vec = (offset_type *) (index.constant_pool
5021 + MAYBE_SWAP (index.symbol_table[idx].vec));
5022 vec_len = MAYBE_SWAP (vec[0]);
5023 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
5025 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
5026 /* This value is only valid for index versions >= 7. */
5027 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
5028 gdb_index_symbol_kind symbol_kind =
5029 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
5030 int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
5031 /* Only check the symbol attributes if they're present.
5032 Indices prior to version 7 don't record them,
5033 and indices >= 7 may elide them for certain symbols
5034 (gold does this). */
5037 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
5039 /* Work around gold/15646. */
5042 if (!is_static && global_seen)
5048 /* Only check the symbol's kind if it has one. */
5053 case VARIABLES_DOMAIN:
5054 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
5057 case FUNCTIONS_DOMAIN:
5058 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
5062 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
5070 /* Don't crash on bad data. */
5071 if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
5072 + dwarf2_per_objfile->all_type_units.size ()))
5074 complaint (_(".gdb_index entry has bad CU index"
5076 objfile_name (dwarf2_per_objfile->objfile));
5080 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
5081 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
5086 /* If FILE_MATCHER is non-NULL, set all the
5087 dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5088 that match FILE_MATCHER. */
5091 dw_expand_symtabs_matching_file_matcher
5092 (struct dwarf2_per_objfile *dwarf2_per_objfile,
5093 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher)
5095 if (file_matcher == NULL)
5098 objfile *const objfile = dwarf2_per_objfile->objfile;
5100 htab_up visited_found (htab_create_alloc (10, htab_hash_pointer,
5102 NULL, xcalloc, xfree));
5103 htab_up visited_not_found (htab_create_alloc (10, htab_hash_pointer,
5105 NULL, xcalloc, xfree));
5107 /* The rule is CUs specify all the files, including those used by
5108 any TU, so there's no need to scan TUs here. */
5110 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5114 per_cu->v.quick->mark = 0;
5116 /* We only need to look at symtabs not already expanded. */
5117 if (per_cu->v.quick->compunit_symtab)
5120 quick_file_names *file_data = dw2_get_file_names (per_cu);
5121 if (file_data == NULL)
5124 if (htab_find (visited_not_found.get (), file_data) != NULL)
5126 else if (htab_find (visited_found.get (), file_data) != NULL)
5128 per_cu->v.quick->mark = 1;
5132 for (int j = 0; j < file_data->num_file_names; ++j)
5134 const char *this_real_name;
5136 if (file_matcher (file_data->file_names[j], false))
5138 per_cu->v.quick->mark = 1;
5142 /* Before we invoke realpath, which can get expensive when many
5143 files are involved, do a quick comparison of the basenames. */
5144 if (!basenames_may_differ
5145 && !file_matcher (lbasename (file_data->file_names[j]),
5149 this_real_name = dw2_get_real_path (objfile, file_data, j);
5150 if (file_matcher (this_real_name, false))
5152 per_cu->v.quick->mark = 1;
5157 void **slot = htab_find_slot (per_cu->v.quick->mark
5158 ? visited_found.get ()
5159 : visited_not_found.get (),
5166 dw2_expand_symtabs_matching
5167 (struct objfile *objfile,
5168 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5169 const lookup_name_info &lookup_name,
5170 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
5171 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5172 enum search_domain kind)
5174 struct dwarf2_per_objfile *dwarf2_per_objfile
5175 = get_dwarf2_per_objfile (objfile);
5177 /* index_table is NULL if OBJF_READNOW. */
5178 if (!dwarf2_per_objfile->index_table)
5181 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
5183 mapped_index &index = *dwarf2_per_objfile->index_table;
5185 dw2_expand_symtabs_matching_symbol (index, lookup_name,
5187 kind, [&] (offset_type idx)
5189 dw2_expand_marked_cus (dwarf2_per_objfile, idx, file_matcher,
5190 expansion_notify, kind);
5194 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5197 static struct compunit_symtab *
5198 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab *cust,
5203 if (COMPUNIT_BLOCKVECTOR (cust) != NULL
5204 && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust), pc))
5207 if (cust->includes == NULL)
5210 for (i = 0; cust->includes[i]; ++i)
5212 struct compunit_symtab *s = cust->includes[i];
5214 s = recursively_find_pc_sect_compunit_symtab (s, pc);
5222 static struct compunit_symtab *
5223 dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
5224 struct bound_minimal_symbol msymbol,
5226 struct obj_section *section,
5229 struct dwarf2_per_cu_data *data;
5230 struct compunit_symtab *result;
5232 if (!objfile->partial_symtabs->psymtabs_addrmap)
5235 CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
5236 SECT_OFF_TEXT (objfile));
5237 data = (struct dwarf2_per_cu_data *) addrmap_find
5238 (objfile->partial_symtabs->psymtabs_addrmap, pc - baseaddr);
5242 if (warn_if_readin && data->v.quick->compunit_symtab)
5243 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5244 paddress (get_objfile_arch (objfile), pc));
5247 = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data,
5250 gdb_assert (result != NULL);
5255 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
5256 void *data, int need_fullname)
5258 struct dwarf2_per_objfile *dwarf2_per_objfile
5259 = get_dwarf2_per_objfile (objfile);
5261 if (!dwarf2_per_objfile->filenames_cache)
5263 dwarf2_per_objfile->filenames_cache.emplace ();
5265 htab_up visited (htab_create_alloc (10,
5266 htab_hash_pointer, htab_eq_pointer,
5267 NULL, xcalloc, xfree));
5269 /* The rule is CUs specify all the files, including those used
5270 by any TU, so there's no need to scan TUs here. We can
5271 ignore file names coming from already-expanded CUs. */
5273 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5275 if (per_cu->v.quick->compunit_symtab)
5277 void **slot = htab_find_slot (visited.get (),
5278 per_cu->v.quick->file_names,
5281 *slot = per_cu->v.quick->file_names;
5285 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5287 /* We only need to look at symtabs not already expanded. */
5288 if (per_cu->v.quick->compunit_symtab)
5291 quick_file_names *file_data = dw2_get_file_names (per_cu);
5292 if (file_data == NULL)
5295 void **slot = htab_find_slot (visited.get (), file_data, INSERT);
5298 /* Already visited. */
5303 for (int j = 0; j < file_data->num_file_names; ++j)
5305 const char *filename = file_data->file_names[j];
5306 dwarf2_per_objfile->filenames_cache->seen (filename);
5311 dwarf2_per_objfile->filenames_cache->traverse ([&] (const char *filename)
5313 gdb::unique_xmalloc_ptr<char> this_real_name;
5316 this_real_name = gdb_realpath (filename);
5317 (*fun) (filename, this_real_name.get (), data);
5322 dw2_has_symbols (struct objfile *objfile)
5327 const struct quick_symbol_functions dwarf2_gdb_index_functions =
5330 dw2_find_last_source_symtab,
5331 dw2_forget_cached_source_info,
5332 dw2_map_symtabs_matching_filename,
5336 dw2_expand_symtabs_for_function,
5337 dw2_expand_all_symtabs,
5338 dw2_expand_symtabs_with_fullname,
5339 dw2_map_matching_symbols,
5340 dw2_expand_symtabs_matching,
5341 dw2_find_pc_sect_compunit_symtab,
5343 dw2_map_symbol_filenames
5346 /* DWARF-5 debug_names reader. */
5348 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
5349 static const gdb_byte dwarf5_augmentation[] = { 'G', 'D', 'B', 0 };
5351 /* A helper function that reads the .debug_names section in SECTION
5352 and fills in MAP. FILENAME is the name of the file containing the
5353 section; it is used for error reporting.
5355 Returns true if all went well, false otherwise. */
5358 read_debug_names_from_section (struct objfile *objfile,
5359 const char *filename,
5360 struct dwarf2_section_info *section,
5361 mapped_debug_names &map)
5363 if (dwarf2_section_empty_p (section))
5366 /* Older elfutils strip versions could keep the section in the main
5367 executable while splitting it for the separate debug info file. */
5368 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
5371 dwarf2_read_section (objfile, section);
5373 map.dwarf5_byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
5375 const gdb_byte *addr = section->buffer;
5377 bfd *const abfd = get_section_bfd_owner (section);
5379 unsigned int bytes_read;
5380 LONGEST length = read_initial_length (abfd, addr, &bytes_read);
5383 map.dwarf5_is_dwarf64 = bytes_read != 4;
5384 map.offset_size = map.dwarf5_is_dwarf64 ? 8 : 4;
5385 if (bytes_read + length != section->size)
5387 /* There may be multiple per-CU indices. */
5388 warning (_("Section .debug_names in %s length %s does not match "
5389 "section length %s, ignoring .debug_names."),
5390 filename, plongest (bytes_read + length),
5391 pulongest (section->size));
5395 /* The version number. */
5396 uint16_t version = read_2_bytes (abfd, addr);
5400 warning (_("Section .debug_names in %s has unsupported version %d, "
5401 "ignoring .debug_names."),
5407 uint16_t padding = read_2_bytes (abfd, addr);
5411 warning (_("Section .debug_names in %s has unsupported padding %d, "
5412 "ignoring .debug_names."),
5417 /* comp_unit_count - The number of CUs in the CU list. */
5418 map.cu_count = read_4_bytes (abfd, addr);
5421 /* local_type_unit_count - The number of TUs in the local TU
5423 map.tu_count = read_4_bytes (abfd, addr);
5426 /* foreign_type_unit_count - The number of TUs in the foreign TU
5428 uint32_t foreign_tu_count = read_4_bytes (abfd, addr);
5430 if (foreign_tu_count != 0)
5432 warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5433 "ignoring .debug_names."),
5434 filename, static_cast<unsigned long> (foreign_tu_count));
5438 /* bucket_count - The number of hash buckets in the hash lookup
5440 map.bucket_count = read_4_bytes (abfd, addr);
5443 /* name_count - The number of unique names in the index. */
5444 map.name_count = read_4_bytes (abfd, addr);
5447 /* abbrev_table_size - The size in bytes of the abbreviations
5449 uint32_t abbrev_table_size = read_4_bytes (abfd, addr);
5452 /* augmentation_string_size - The size in bytes of the augmentation
5453 string. This value is rounded up to a multiple of 4. */
5454 uint32_t augmentation_string_size = read_4_bytes (abfd, addr);
5456 map.augmentation_is_gdb = ((augmentation_string_size
5457 == sizeof (dwarf5_augmentation))
5458 && memcmp (addr, dwarf5_augmentation,
5459 sizeof (dwarf5_augmentation)) == 0);
5460 augmentation_string_size += (-augmentation_string_size) & 3;
5461 addr += augmentation_string_size;
5464 map.cu_table_reordered = addr;
5465 addr += map.cu_count * map.offset_size;
5467 /* List of Local TUs */
5468 map.tu_table_reordered = addr;
5469 addr += map.tu_count * map.offset_size;
5471 /* Hash Lookup Table */
5472 map.bucket_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5473 addr += map.bucket_count * 4;
5474 map.hash_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5475 addr += map.name_count * 4;
5478 map.name_table_string_offs_reordered = addr;
5479 addr += map.name_count * map.offset_size;
5480 map.name_table_entry_offs_reordered = addr;
5481 addr += map.name_count * map.offset_size;
5483 const gdb_byte *abbrev_table_start = addr;
5486 const ULONGEST index_num = read_unsigned_leb128 (abfd, addr, &bytes_read);
5491 const auto insertpair
5492 = map.abbrev_map.emplace (index_num, mapped_debug_names::index_val ());
5493 if (!insertpair.second)
5495 warning (_("Section .debug_names in %s has duplicate index %s, "
5496 "ignoring .debug_names."),
5497 filename, pulongest (index_num));
5500 mapped_debug_names::index_val &indexval = insertpair.first->second;
5501 indexval.dwarf_tag = read_unsigned_leb128 (abfd, addr, &bytes_read);
5506 mapped_debug_names::index_val::attr attr;
5507 attr.dw_idx = read_unsigned_leb128 (abfd, addr, &bytes_read);
5509 attr.form = read_unsigned_leb128 (abfd, addr, &bytes_read);
5511 if (attr.form == DW_FORM_implicit_const)
5513 attr.implicit_const = read_signed_leb128 (abfd, addr,
5517 if (attr.dw_idx == 0 && attr.form == 0)
5519 indexval.attr_vec.push_back (std::move (attr));
5522 if (addr != abbrev_table_start + abbrev_table_size)
5524 warning (_("Section .debug_names in %s has abbreviation_table "
5525 "of size %s vs. written as %u, ignoring .debug_names."),
5526 filename, plongest (addr - abbrev_table_start),
5530 map.entry_pool = addr;
5535 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5539 create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
5540 const mapped_debug_names &map,
5541 dwarf2_section_info §ion,
5544 sect_offset sect_off_prev;
5545 for (uint32_t i = 0; i <= map.cu_count; ++i)
5547 sect_offset sect_off_next;
5548 if (i < map.cu_count)
5551 = (sect_offset) (extract_unsigned_integer
5552 (map.cu_table_reordered + i * map.offset_size,
5554 map.dwarf5_byte_order));
5557 sect_off_next = (sect_offset) section.size;
5560 const ULONGEST length = sect_off_next - sect_off_prev;
5561 dwarf2_per_cu_data *per_cu
5562 = create_cu_from_index_list (dwarf2_per_objfile, §ion, is_dwz,
5563 sect_off_prev, length);
5564 dwarf2_per_objfile->all_comp_units.push_back (per_cu);
5566 sect_off_prev = sect_off_next;
5570 /* Read the CU list from the mapped index, and use it to create all
5571 the CU objects for this dwarf2_per_objfile. */
5574 create_cus_from_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
5575 const mapped_debug_names &map,
5576 const mapped_debug_names &dwz_map)
5578 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
5579 dwarf2_per_objfile->all_comp_units.reserve (map.cu_count + dwz_map.cu_count);
5581 create_cus_from_debug_names_list (dwarf2_per_objfile, map,
5582 dwarf2_per_objfile->info,
5583 false /* is_dwz */);
5585 if (dwz_map.cu_count == 0)
5588 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5589 create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
5593 /* Read .debug_names. If everything went ok, initialize the "quick"
5594 elements of all the CUs and return true. Otherwise, return false. */
5597 dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
5599 std::unique_ptr<mapped_debug_names> map
5600 (new mapped_debug_names (dwarf2_per_objfile));
5601 mapped_debug_names dwz_map (dwarf2_per_objfile);
5602 struct objfile *objfile = dwarf2_per_objfile->objfile;
5604 if (!read_debug_names_from_section (objfile, objfile_name (objfile),
5605 &dwarf2_per_objfile->debug_names,
5609 /* Don't use the index if it's empty. */
5610 if (map->name_count == 0)
5613 /* If there is a .dwz file, read it so we can get its CU list as
5615 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5618 if (!read_debug_names_from_section (objfile,
5619 bfd_get_filename (dwz->dwz_bfd),
5620 &dwz->debug_names, dwz_map))
5622 warning (_("could not read '.debug_names' section from %s; skipping"),
5623 bfd_get_filename (dwz->dwz_bfd));
5628 create_cus_from_debug_names (dwarf2_per_objfile, *map, dwz_map);
5630 if (map->tu_count != 0)
5632 /* We can only handle a single .debug_types when we have an
5634 if (dwarf2_per_objfile->types.size () != 1)
5637 dwarf2_section_info *section = &dwarf2_per_objfile->types[0];
5639 create_signatured_type_table_from_debug_names
5640 (dwarf2_per_objfile, *map, section, &dwarf2_per_objfile->abbrev);
5643 create_addrmap_from_aranges (dwarf2_per_objfile,
5644 &dwarf2_per_objfile->debug_aranges);
5646 dwarf2_per_objfile->debug_names_table = std::move (map);
5647 dwarf2_per_objfile->using_index = 1;
5648 dwarf2_per_objfile->quick_file_names_table =
5649 create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
5654 /* Type used to manage iterating over all CUs looking for a symbol for
5657 class dw2_debug_names_iterator
5660 dw2_debug_names_iterator (const mapped_debug_names &map,
5661 gdb::optional<block_enum> block_index,
5664 : m_map (map), m_block_index (block_index), m_domain (domain),
5665 m_addr (find_vec_in_debug_names (map, name))
5668 dw2_debug_names_iterator (const mapped_debug_names &map,
5669 search_domain search, uint32_t namei)
5672 m_addr (find_vec_in_debug_names (map, namei))
5675 /* Return the next matching CU or NULL if there are no more. */
5676 dwarf2_per_cu_data *next ();
5679 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5681 static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5684 /* The internalized form of .debug_names. */
5685 const mapped_debug_names &m_map;
5687 /* If set, only look for symbols that match that block. Valid values are
5688 GLOBAL_BLOCK and STATIC_BLOCK. */
5689 const gdb::optional<block_enum> m_block_index;
5691 /* The kind of symbol we're looking for. */
5692 const domain_enum m_domain = UNDEF_DOMAIN;
5693 const search_domain m_search = ALL_DOMAIN;
5695 /* The list of CUs from the index entry of the symbol, or NULL if
5697 const gdb_byte *m_addr;
5701 mapped_debug_names::namei_to_name (uint32_t namei) const
5703 const ULONGEST namei_string_offs
5704 = extract_unsigned_integer ((name_table_string_offs_reordered
5705 + namei * offset_size),
5708 return read_indirect_string_at_offset
5709 (dwarf2_per_objfile, dwarf2_per_objfile->objfile->obfd, namei_string_offs);
5712 /* Find a slot in .debug_names for the object named NAME. If NAME is
5713 found, return pointer to its pool data. If NAME cannot be found,
5717 dw2_debug_names_iterator::find_vec_in_debug_names
5718 (const mapped_debug_names &map, const char *name)
5720 int (*cmp) (const char *, const char *);
5722 gdb::unique_xmalloc_ptr<char> without_params;
5723 if (current_language->la_language == language_cplus
5724 || current_language->la_language == language_fortran
5725 || current_language->la_language == language_d)
5727 /* NAME is already canonical. Drop any qualifiers as
5728 .debug_names does not contain any. */
5730 if (strchr (name, '(') != NULL)
5732 without_params = cp_remove_params (name);
5733 if (without_params != NULL)
5734 name = without_params.get ();
5738 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
5740 const uint32_t full_hash = dwarf5_djb_hash (name);
5742 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5743 (map.bucket_table_reordered
5744 + (full_hash % map.bucket_count)), 4,
5745 map.dwarf5_byte_order);
5749 if (namei >= map.name_count)
5751 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5753 namei, map.name_count,
5754 objfile_name (map.dwarf2_per_objfile->objfile));
5760 const uint32_t namei_full_hash
5761 = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5762 (map.hash_table_reordered + namei), 4,
5763 map.dwarf5_byte_order);
5764 if (full_hash % map.bucket_count != namei_full_hash % map.bucket_count)
5767 if (full_hash == namei_full_hash)
5769 const char *const namei_string = map.namei_to_name (namei);
5771 #if 0 /* An expensive sanity check. */
5772 if (namei_full_hash != dwarf5_djb_hash (namei_string))
5774 complaint (_("Wrong .debug_names hash for string at index %u "
5776 namei, objfile_name (dwarf2_per_objfile->objfile));
5781 if (cmp (namei_string, name) == 0)
5783 const ULONGEST namei_entry_offs
5784 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5785 + namei * map.offset_size),
5786 map.offset_size, map.dwarf5_byte_order);
5787 return map.entry_pool + namei_entry_offs;
5792 if (namei >= map.name_count)
5798 dw2_debug_names_iterator::find_vec_in_debug_names
5799 (const mapped_debug_names &map, uint32_t namei)
5801 if (namei >= map.name_count)
5803 complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5805 namei, map.name_count,
5806 objfile_name (map.dwarf2_per_objfile->objfile));
5810 const ULONGEST namei_entry_offs
5811 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5812 + namei * map.offset_size),
5813 map.offset_size, map.dwarf5_byte_order);
5814 return map.entry_pool + namei_entry_offs;
5817 /* See dw2_debug_names_iterator. */
5819 dwarf2_per_cu_data *
5820 dw2_debug_names_iterator::next ()
5825 struct dwarf2_per_objfile *dwarf2_per_objfile = m_map.dwarf2_per_objfile;
5826 struct objfile *objfile = dwarf2_per_objfile->objfile;
5827 bfd *const abfd = objfile->obfd;
5831 unsigned int bytes_read;
5832 const ULONGEST abbrev = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5833 m_addr += bytes_read;
5837 const auto indexval_it = m_map.abbrev_map.find (abbrev);
5838 if (indexval_it == m_map.abbrev_map.cend ())
5840 complaint (_("Wrong .debug_names undefined abbrev code %s "
5842 pulongest (abbrev), objfile_name (objfile));
5845 const mapped_debug_names::index_val &indexval = indexval_it->second;
5846 gdb::optional<bool> is_static;
5847 dwarf2_per_cu_data *per_cu = NULL;
5848 for (const mapped_debug_names::index_val::attr &attr : indexval.attr_vec)
5853 case DW_FORM_implicit_const:
5854 ull = attr.implicit_const;
5856 case DW_FORM_flag_present:
5860 ull = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5861 m_addr += bytes_read;
5864 complaint (_("Unsupported .debug_names form %s [in module %s]"),
5865 dwarf_form_name (attr.form),
5866 objfile_name (objfile));
5869 switch (attr.dw_idx)
5871 case DW_IDX_compile_unit:
5872 /* Don't crash on bad data. */
5873 if (ull >= dwarf2_per_objfile->all_comp_units.size ())
5875 complaint (_(".debug_names entry has bad CU index %s"
5878 objfile_name (dwarf2_per_objfile->objfile));
5881 per_cu = dwarf2_per_objfile->get_cutu (ull);
5883 case DW_IDX_type_unit:
5884 /* Don't crash on bad data. */
5885 if (ull >= dwarf2_per_objfile->all_type_units.size ())
5887 complaint (_(".debug_names entry has bad TU index %s"
5890 objfile_name (dwarf2_per_objfile->objfile));
5893 per_cu = &dwarf2_per_objfile->get_tu (ull)->per_cu;
5895 case DW_IDX_GNU_internal:
5896 if (!m_map.augmentation_is_gdb)
5900 case DW_IDX_GNU_external:
5901 if (!m_map.augmentation_is_gdb)
5908 /* Skip if already read in. */
5909 if (per_cu->v.quick->compunit_symtab)
5912 /* Check static vs global. */
5913 if (is_static.has_value () && m_block_index.has_value ())
5915 const bool want_static = *m_block_index == STATIC_BLOCK;
5916 if (want_static != *is_static)
5920 /* Match dw2_symtab_iter_next, symbol_kind
5921 and debug_names::psymbol_tag. */
5925 switch (indexval.dwarf_tag)
5927 case DW_TAG_variable:
5928 case DW_TAG_subprogram:
5929 /* Some types are also in VAR_DOMAIN. */
5930 case DW_TAG_typedef:
5931 case DW_TAG_structure_type:
5938 switch (indexval.dwarf_tag)
5940 case DW_TAG_typedef:
5941 case DW_TAG_structure_type:
5948 switch (indexval.dwarf_tag)
5951 case DW_TAG_variable:
5961 /* Match dw2_expand_symtabs_matching, symbol_kind and
5962 debug_names::psymbol_tag. */
5965 case VARIABLES_DOMAIN:
5966 switch (indexval.dwarf_tag)
5968 case DW_TAG_variable:
5974 case FUNCTIONS_DOMAIN:
5975 switch (indexval.dwarf_tag)
5977 case DW_TAG_subprogram:
5984 switch (indexval.dwarf_tag)
5986 case DW_TAG_typedef:
5987 case DW_TAG_structure_type:
6000 static struct compunit_symtab *
6001 dw2_debug_names_lookup_symbol (struct objfile *objfile, int block_index_int,
6002 const char *name, domain_enum domain)
6004 const block_enum block_index = static_cast<block_enum> (block_index_int);
6005 struct dwarf2_per_objfile *dwarf2_per_objfile
6006 = get_dwarf2_per_objfile (objfile);
6008 const auto &mapp = dwarf2_per_objfile->debug_names_table;
6011 /* index is NULL if OBJF_READNOW. */
6014 const auto &map = *mapp;
6016 dw2_debug_names_iterator iter (map, block_index, domain, name);
6018 struct compunit_symtab *stab_best = NULL;
6019 struct dwarf2_per_cu_data *per_cu;
6020 while ((per_cu = iter.next ()) != NULL)
6022 struct symbol *sym, *with_opaque = NULL;
6023 struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
6024 const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
6025 const struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
6027 sym = block_find_symbol (block, name, domain,
6028 block_find_non_opaque_type_preferred,
6031 /* Some caution must be observed with overloaded functions and
6032 methods, since the index will not contain any overload
6033 information (but NAME might contain it). */
6036 && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
6038 if (with_opaque != NULL
6039 && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
6042 /* Keep looking through other CUs. */
6048 /* This dumps minimal information about .debug_names. It is called
6049 via "mt print objfiles". The gdb.dwarf2/gdb-index.exp testcase
6050 uses this to verify that .debug_names has been loaded. */
6053 dw2_debug_names_dump (struct objfile *objfile)
6055 struct dwarf2_per_objfile *dwarf2_per_objfile
6056 = get_dwarf2_per_objfile (objfile);
6058 gdb_assert (dwarf2_per_objfile->using_index);
6059 printf_filtered (".debug_names:");
6060 if (dwarf2_per_objfile->debug_names_table)
6061 printf_filtered (" exists\n");
6063 printf_filtered (" faked for \"readnow\"\n");
6064 printf_filtered ("\n");
6068 dw2_debug_names_expand_symtabs_for_function (struct objfile *objfile,
6069 const char *func_name)
6071 struct dwarf2_per_objfile *dwarf2_per_objfile
6072 = get_dwarf2_per_objfile (objfile);
6074 /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW. */
6075 if (dwarf2_per_objfile->debug_names_table)
6077 const mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6079 dw2_debug_names_iterator iter (map, {}, VAR_DOMAIN, func_name);
6081 struct dwarf2_per_cu_data *per_cu;
6082 while ((per_cu = iter.next ()) != NULL)
6083 dw2_instantiate_symtab (per_cu, false);
6088 dw2_debug_names_expand_symtabs_matching
6089 (struct objfile *objfile,
6090 gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
6091 const lookup_name_info &lookup_name,
6092 gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
6093 gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
6094 enum search_domain kind)
6096 struct dwarf2_per_objfile *dwarf2_per_objfile
6097 = get_dwarf2_per_objfile (objfile);
6099 /* debug_names_table is NULL if OBJF_READNOW. */
6100 if (!dwarf2_per_objfile->debug_names_table)
6103 dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
6105 mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6107 dw2_expand_symtabs_matching_symbol (map, lookup_name,
6109 kind, [&] (offset_type namei)
6111 /* The name was matched, now expand corresponding CUs that were
6113 dw2_debug_names_iterator iter (map, kind, namei);
6115 struct dwarf2_per_cu_data *per_cu;
6116 while ((per_cu = iter.next ()) != NULL)
6117 dw2_expand_symtabs_matching_one (per_cu, file_matcher,
6122 const struct quick_symbol_functions dwarf2_debug_names_functions =
6125 dw2_find_last_source_symtab,
6126 dw2_forget_cached_source_info,
6127 dw2_map_symtabs_matching_filename,
6128 dw2_debug_names_lookup_symbol,
6130 dw2_debug_names_dump,
6131 dw2_debug_names_expand_symtabs_for_function,
6132 dw2_expand_all_symtabs,
6133 dw2_expand_symtabs_with_fullname,
6134 dw2_map_matching_symbols,
6135 dw2_debug_names_expand_symtabs_matching,
6136 dw2_find_pc_sect_compunit_symtab,
6138 dw2_map_symbol_filenames
6141 /* Get the content of the .gdb_index section of OBJ. SECTION_OWNER should point
6142 to either a dwarf2_per_objfile or dwz_file object. */
6144 template <typename T>
6145 static gdb::array_view<const gdb_byte>
6146 get_gdb_index_contents_from_section (objfile *obj, T *section_owner)
6148 dwarf2_section_info *section = §ion_owner->gdb_index;
6150 if (dwarf2_section_empty_p (section))
6153 /* Older elfutils strip versions could keep the section in the main
6154 executable while splitting it for the separate debug info file. */
6155 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
6158 dwarf2_read_section (obj, section);
6160 /* dwarf2_section_info::size is a bfd_size_type, while
6161 gdb::array_view works with size_t. On 32-bit hosts, with
6162 --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6163 is 32-bit. So we need an explicit narrowing conversion here.
6164 This is fine, because it's impossible to allocate or mmap an
6165 array/buffer larger than what size_t can represent. */
6166 return gdb::make_array_view (section->buffer, section->size);
6169 /* Lookup the index cache for the contents of the index associated to
6172 static gdb::array_view<const gdb_byte>
6173 get_gdb_index_contents_from_cache (objfile *obj, dwarf2_per_objfile *dwarf2_obj)
6175 const bfd_build_id *build_id = build_id_bfd_get (obj->obfd);
6176 if (build_id == nullptr)
6179 return global_index_cache.lookup_gdb_index (build_id,
6180 &dwarf2_obj->index_cache_res);
6183 /* Same as the above, but for DWZ. */
6185 static gdb::array_view<const gdb_byte>
6186 get_gdb_index_contents_from_cache_dwz (objfile *obj, dwz_file *dwz)
6188 const bfd_build_id *build_id = build_id_bfd_get (dwz->dwz_bfd.get ());
6189 if (build_id == nullptr)
6192 return global_index_cache.lookup_gdb_index (build_id, &dwz->index_cache_res);
6195 /* See symfile.h. */
6198 dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
6200 struct dwarf2_per_objfile *dwarf2_per_objfile
6201 = get_dwarf2_per_objfile (objfile);
6203 /* If we're about to read full symbols, don't bother with the
6204 indices. In this case we also don't care if some other debug
6205 format is making psymtabs, because they are all about to be
6207 if ((objfile->flags & OBJF_READNOW))
6209 dwarf2_per_objfile->using_index = 1;
6210 create_all_comp_units (dwarf2_per_objfile);
6211 create_all_type_units (dwarf2_per_objfile);
6212 dwarf2_per_objfile->quick_file_names_table
6213 = create_quick_file_names_table
6214 (dwarf2_per_objfile->all_comp_units.size ());
6216 for (int i = 0; i < (dwarf2_per_objfile->all_comp_units.size ()
6217 + dwarf2_per_objfile->all_type_units.size ()); ++i)
6219 dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
6221 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6222 struct dwarf2_per_cu_quick_data);
6225 /* Return 1 so that gdb sees the "quick" functions. However,
6226 these functions will be no-ops because we will have expanded
6228 *index_kind = dw_index_kind::GDB_INDEX;
6232 if (dwarf2_read_debug_names (dwarf2_per_objfile))
6234 *index_kind = dw_index_kind::DEBUG_NAMES;
6238 if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6239 get_gdb_index_contents_from_section<struct dwarf2_per_objfile>,
6240 get_gdb_index_contents_from_section<dwz_file>))
6242 *index_kind = dw_index_kind::GDB_INDEX;
6246 /* ... otherwise, try to find the index in the index cache. */
6247 if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6248 get_gdb_index_contents_from_cache,
6249 get_gdb_index_contents_from_cache_dwz))
6251 global_index_cache.hit ();
6252 *index_kind = dw_index_kind::GDB_INDEX;
6256 global_index_cache.miss ();
6262 /* Build a partial symbol table. */
6265 dwarf2_build_psymtabs (struct objfile *objfile)
6267 struct dwarf2_per_objfile *dwarf2_per_objfile
6268 = get_dwarf2_per_objfile (objfile);
6270 init_psymbol_list (objfile, 1024);
6274 /* This isn't really ideal: all the data we allocate on the
6275 objfile's obstack is still uselessly kept around. However,
6276 freeing it seems unsafe. */
6277 psymtab_discarder psymtabs (objfile);
6278 dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
6281 /* (maybe) store an index in the cache. */
6282 global_index_cache.store (dwarf2_per_objfile);
6284 catch (const gdb_exception_error &except)
6286 exception_print (gdb_stderr, except);
6290 /* Return the total length of the CU described by HEADER. */
6293 get_cu_length (const struct comp_unit_head *header)
6295 return header->initial_length_size + header->length;
6298 /* Return TRUE if SECT_OFF is within CU_HEADER. */
6301 offset_in_cu_p (const comp_unit_head *cu_header, sect_offset sect_off)
6303 sect_offset bottom = cu_header->sect_off;
6304 sect_offset top = cu_header->sect_off + get_cu_length (cu_header);
6306 return sect_off >= bottom && sect_off < top;
6309 /* Find the base address of the compilation unit for range lists and
6310 location lists. It will normally be specified by DW_AT_low_pc.
6311 In DWARF-3 draft 4, the base address could be overridden by
6312 DW_AT_entry_pc. It's been removed, but GCC still uses this for
6313 compilation units with discontinuous ranges. */
6316 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
6318 struct attribute *attr;
6321 cu->base_address = 0;
6323 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
6326 cu->base_address = attr_value_as_address (attr);
6331 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6334 cu->base_address = attr_value_as_address (attr);
6340 /* Read in the comp unit header information from the debug_info at info_ptr.
6341 Use rcuh_kind::COMPILE as the default type if not known by the caller.
6342 NOTE: This leaves members offset, first_die_offset to be filled in
6345 static const gdb_byte *
6346 read_comp_unit_head (struct comp_unit_head *cu_header,
6347 const gdb_byte *info_ptr,
6348 struct dwarf2_section_info *section,
6349 rcuh_kind section_kind)
6352 unsigned int bytes_read;
6353 const char *filename = get_section_file_name (section);
6354 bfd *abfd = get_section_bfd_owner (section);
6356 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
6357 cu_header->initial_length_size = bytes_read;
6358 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
6359 info_ptr += bytes_read;
6360 cu_header->version = read_2_bytes (abfd, info_ptr);
6361 if (cu_header->version < 2 || cu_header->version > 5)
6362 error (_("Dwarf Error: wrong version in compilation unit header "
6363 "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6364 cu_header->version, filename);
6366 if (cu_header->version < 5)
6367 switch (section_kind)
6369 case rcuh_kind::COMPILE:
6370 cu_header->unit_type = DW_UT_compile;
6372 case rcuh_kind::TYPE:
6373 cu_header->unit_type = DW_UT_type;
6376 internal_error (__FILE__, __LINE__,
6377 _("read_comp_unit_head: invalid section_kind"));
6381 cu_header->unit_type = static_cast<enum dwarf_unit_type>
6382 (read_1_byte (abfd, info_ptr));
6384 switch (cu_header->unit_type)
6387 if (section_kind != rcuh_kind::COMPILE)
6388 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6389 "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6393 section_kind = rcuh_kind::TYPE;
6396 error (_("Dwarf Error: wrong unit_type in compilation unit header "
6397 "(is %d, should be %d or %d) [in module %s]"),
6398 cu_header->unit_type, DW_UT_compile, DW_UT_type, filename);
6401 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6404 cu_header->abbrev_sect_off = (sect_offset) read_offset (abfd, info_ptr,
6407 info_ptr += bytes_read;
6408 if (cu_header->version < 5)
6410 cu_header->addr_size = read_1_byte (abfd, info_ptr);
6413 signed_addr = bfd_get_sign_extend_vma (abfd);
6414 if (signed_addr < 0)
6415 internal_error (__FILE__, __LINE__,
6416 _("read_comp_unit_head: dwarf from non elf file"));
6417 cu_header->signed_addr_p = signed_addr;
6419 if (section_kind == rcuh_kind::TYPE)
6421 LONGEST type_offset;
6423 cu_header->signature = read_8_bytes (abfd, info_ptr);
6426 type_offset = read_offset (abfd, info_ptr, cu_header, &bytes_read);
6427 info_ptr += bytes_read;
6428 cu_header->type_cu_offset_in_tu = (cu_offset) type_offset;
6429 if (to_underlying (cu_header->type_cu_offset_in_tu) != type_offset)
6430 error (_("Dwarf Error: Too big type_offset in compilation unit "
6431 "header (is %s) [in module %s]"), plongest (type_offset),
6438 /* Helper function that returns the proper abbrev section for
6441 static struct dwarf2_section_info *
6442 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
6444 struct dwarf2_section_info *abbrev;
6445 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
6447 if (this_cu->is_dwz)
6448 abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
6450 abbrev = &dwarf2_per_objfile->abbrev;
6455 /* Subroutine of read_and_check_comp_unit_head and
6456 read_and_check_type_unit_head to simplify them.
6457 Perform various error checking on the header. */
6460 error_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6461 struct comp_unit_head *header,
6462 struct dwarf2_section_info *section,
6463 struct dwarf2_section_info *abbrev_section)
6465 const char *filename = get_section_file_name (section);
6467 if (to_underlying (header->abbrev_sect_off)
6468 >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
6469 error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6470 "(offset %s + 6) [in module %s]"),
6471 sect_offset_str (header->abbrev_sect_off),
6472 sect_offset_str (header->sect_off),
6475 /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6476 avoid potential 32-bit overflow. */
6477 if (((ULONGEST) header->sect_off + get_cu_length (header))
6479 error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6480 "(offset %s + 0) [in module %s]"),
6481 header->length, sect_offset_str (header->sect_off),
6485 /* Read in a CU/TU header and perform some basic error checking.
6486 The contents of the header are stored in HEADER.
6487 The result is a pointer to the start of the first DIE. */
6489 static const gdb_byte *
6490 read_and_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6491 struct comp_unit_head *header,
6492 struct dwarf2_section_info *section,
6493 struct dwarf2_section_info *abbrev_section,
6494 const gdb_byte *info_ptr,
6495 rcuh_kind section_kind)
6497 const gdb_byte *beg_of_comp_unit = info_ptr;
6499 header->sect_off = (sect_offset) (beg_of_comp_unit - section->buffer);
6501 info_ptr = read_comp_unit_head (header, info_ptr, section, section_kind);
6503 header->first_die_cu_offset = (cu_offset) (info_ptr - beg_of_comp_unit);
6505 error_check_comp_unit_head (dwarf2_per_objfile, header, section,
6511 /* Fetch the abbreviation table offset from a comp or type unit header. */
6514 read_abbrev_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
6515 struct dwarf2_section_info *section,
6516 sect_offset sect_off)
6518 bfd *abfd = get_section_bfd_owner (section);
6519 const gdb_byte *info_ptr;
6520 unsigned int initial_length_size, offset_size;
6523 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
6524 info_ptr = section->buffer + to_underlying (sect_off);
6525 read_initial_length (abfd, info_ptr, &initial_length_size);
6526 offset_size = initial_length_size == 4 ? 4 : 8;
6527 info_ptr += initial_length_size;
6529 version = read_2_bytes (abfd, info_ptr);
6533 /* Skip unit type and address size. */
6537 return (sect_offset) read_offset_1 (abfd, info_ptr, offset_size);
6540 /* Allocate a new partial symtab for file named NAME and mark this new
6541 partial symtab as being an include of PST. */
6544 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
6545 struct objfile *objfile)
6547 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
6549 if (!IS_ABSOLUTE_PATH (subpst->filename))
6551 /* It shares objfile->objfile_obstack. */
6552 subpst->dirname = pst->dirname;
6555 subpst->dependencies = objfile->partial_symtabs->allocate_dependencies (1);
6556 subpst->dependencies[0] = pst;
6557 subpst->number_of_dependencies = 1;
6559 subpst->read_symtab = pst->read_symtab;
6561 /* No private part is necessary for include psymtabs. This property
6562 can be used to differentiate between such include psymtabs and
6563 the regular ones. */
6564 subpst->read_symtab_private = NULL;
6567 /* Read the Line Number Program data and extract the list of files
6568 included by the source file represented by PST. Build an include
6569 partial symtab for each of these included files. */
6572 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
6573 struct die_info *die,
6574 struct partial_symtab *pst)
6577 struct attribute *attr;
6579 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
6581 lh = dwarf_decode_line_header ((sect_offset) DW_UNSND (attr), cu);
6583 return; /* No linetable, so no includes. */
6585 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). Also note
6586 that we pass in the raw text_low here; that is ok because we're
6587 only decoding the line table to make include partial symtabs, and
6588 so the addresses aren't really used. */
6589 dwarf_decode_lines (lh.get (), pst->dirname, cu, pst,
6590 pst->raw_text_low (), 1);
6594 hash_signatured_type (const void *item)
6596 const struct signatured_type *sig_type
6597 = (const struct signatured_type *) item;
6599 /* This drops the top 32 bits of the signature, but is ok for a hash. */
6600 return sig_type->signature;
6604 eq_signatured_type (const void *item_lhs, const void *item_rhs)
6606 const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
6607 const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
6609 return lhs->signature == rhs->signature;
6612 /* Allocate a hash table for signatured types. */
6615 allocate_signatured_type_table (struct objfile *objfile)
6617 return htab_create_alloc_ex (41,
6618 hash_signatured_type,
6621 &objfile->objfile_obstack,
6622 hashtab_obstack_allocate,
6623 dummy_obstack_deallocate);
6626 /* A helper function to add a signatured type CU to a table. */
6629 add_signatured_type_cu_to_table (void **slot, void *datum)
6631 struct signatured_type *sigt = (struct signatured_type *) *slot;
6632 std::vector<signatured_type *> *all_type_units
6633 = (std::vector<signatured_type *> *) datum;
6635 all_type_units->push_back (sigt);
6640 /* A helper for create_debug_types_hash_table. Read types from SECTION
6641 and fill them into TYPES_HTAB. It will process only type units,
6642 therefore DW_UT_type. */
6645 create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6646 struct dwo_file *dwo_file,
6647 dwarf2_section_info *section, htab_t &types_htab,
6648 rcuh_kind section_kind)
6650 struct objfile *objfile = dwarf2_per_objfile->objfile;
6651 struct dwarf2_section_info *abbrev_section;
6653 const gdb_byte *info_ptr, *end_ptr;
6655 abbrev_section = (dwo_file != NULL
6656 ? &dwo_file->sections.abbrev
6657 : &dwarf2_per_objfile->abbrev);
6659 if (dwarf_read_debug)
6660 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
6661 get_section_name (section),
6662 get_section_file_name (abbrev_section));
6664 dwarf2_read_section (objfile, section);
6665 info_ptr = section->buffer;
6667 if (info_ptr == NULL)
6670 /* We can't set abfd until now because the section may be empty or
6671 not present, in which case the bfd is unknown. */
6672 abfd = get_section_bfd_owner (section);
6674 /* We don't use init_cutu_and_read_dies_simple, or some such, here
6675 because we don't need to read any dies: the signature is in the
6678 end_ptr = info_ptr + section->size;
6679 while (info_ptr < end_ptr)
6681 struct signatured_type *sig_type;
6682 struct dwo_unit *dwo_tu;
6684 const gdb_byte *ptr = info_ptr;
6685 struct comp_unit_head header;
6686 unsigned int length;
6688 sect_offset sect_off = (sect_offset) (ptr - section->buffer);
6690 /* Initialize it due to a false compiler warning. */
6691 header.signature = -1;
6692 header.type_cu_offset_in_tu = (cu_offset) -1;
6694 /* We need to read the type's signature in order to build the hash
6695 table, but we don't need anything else just yet. */
6697 ptr = read_and_check_comp_unit_head (dwarf2_per_objfile, &header, section,
6698 abbrev_section, ptr, section_kind);
6700 length = get_cu_length (&header);
6702 /* Skip dummy type units. */
6703 if (ptr >= info_ptr + length
6704 || peek_abbrev_code (abfd, ptr) == 0
6705 || header.unit_type != DW_UT_type)
6711 if (types_htab == NULL)
6714 types_htab = allocate_dwo_unit_table (objfile);
6716 types_htab = allocate_signatured_type_table (objfile);
6722 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6724 dwo_tu->dwo_file = dwo_file;
6725 dwo_tu->signature = header.signature;
6726 dwo_tu->type_offset_in_tu = header.type_cu_offset_in_tu;
6727 dwo_tu->section = section;
6728 dwo_tu->sect_off = sect_off;
6729 dwo_tu->length = length;
6733 /* N.B.: type_offset is not usable if this type uses a DWO file.
6734 The real type_offset is in the DWO file. */
6736 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6737 struct signatured_type);
6738 sig_type->signature = header.signature;
6739 sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;
6740 sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6741 sig_type->per_cu.is_debug_types = 1;
6742 sig_type->per_cu.section = section;
6743 sig_type->per_cu.sect_off = sect_off;
6744 sig_type->per_cu.length = length;
6747 slot = htab_find_slot (types_htab,
6748 dwo_file ? (void*) dwo_tu : (void *) sig_type,
6750 gdb_assert (slot != NULL);
6753 sect_offset dup_sect_off;
6757 const struct dwo_unit *dup_tu
6758 = (const struct dwo_unit *) *slot;
6760 dup_sect_off = dup_tu->sect_off;
6764 const struct signatured_type *dup_tu
6765 = (const struct signatured_type *) *slot;
6767 dup_sect_off = dup_tu->per_cu.sect_off;
6770 complaint (_("debug type entry at offset %s is duplicate to"
6771 " the entry at offset %s, signature %s"),
6772 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
6773 hex_string (header.signature));
6775 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
6777 if (dwarf_read_debug > 1)
6778 fprintf_unfiltered (gdb_stdlog, " offset %s, signature %s\n",
6779 sect_offset_str (sect_off),
6780 hex_string (header.signature));
6786 /* Create the hash table of all entries in the .debug_types
6787 (or .debug_types.dwo) section(s).
6788 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6789 otherwise it is NULL.
6791 The result is a pointer to the hash table or NULL if there are no types.
6793 Note: This function processes DWO files only, not DWP files. */
6796 create_debug_types_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6797 struct dwo_file *dwo_file,
6798 gdb::array_view<dwarf2_section_info> type_sections,
6801 for (dwarf2_section_info §ion : type_sections)
6802 create_debug_type_hash_table (dwarf2_per_objfile, dwo_file, §ion,
6803 types_htab, rcuh_kind::TYPE);
6806 /* Create the hash table of all entries in the .debug_types section,
6807 and initialize all_type_units.
6808 The result is zero if there is an error (e.g. missing .debug_types section),
6809 otherwise non-zero. */
6812 create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
6814 htab_t types_htab = NULL;
6816 create_debug_type_hash_table (dwarf2_per_objfile, NULL,
6817 &dwarf2_per_objfile->info, types_htab,
6818 rcuh_kind::COMPILE);
6819 create_debug_types_hash_table (dwarf2_per_objfile, NULL,
6820 dwarf2_per_objfile->types, types_htab);
6821 if (types_htab == NULL)
6823 dwarf2_per_objfile->signatured_types = NULL;
6827 dwarf2_per_objfile->signatured_types = types_htab;
6829 gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
6830 dwarf2_per_objfile->all_type_units.reserve (htab_elements (types_htab));
6832 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table,
6833 &dwarf2_per_objfile->all_type_units);
6838 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6839 If SLOT is non-NULL, it is the entry to use in the hash table.
6840 Otherwise we find one. */
6842 static struct signatured_type *
6843 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
6846 struct objfile *objfile = dwarf2_per_objfile->objfile;
6848 if (dwarf2_per_objfile->all_type_units.size ()
6849 == dwarf2_per_objfile->all_type_units.capacity ())
6850 ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
6852 signatured_type *sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6853 struct signatured_type);
6855 dwarf2_per_objfile->all_type_units.push_back (sig_type);
6856 sig_type->signature = sig;
6857 sig_type->per_cu.is_debug_types = 1;
6858 if (dwarf2_per_objfile->using_index)
6860 sig_type->per_cu.v.quick =
6861 OBSTACK_ZALLOC (&objfile->objfile_obstack,
6862 struct dwarf2_per_cu_quick_data);
6867 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6870 gdb_assert (*slot == NULL);
6872 /* The rest of sig_type must be filled in by the caller. */
6876 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6877 Fill in SIG_ENTRY with DWO_ENTRY. */
6880 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
6881 struct signatured_type *sig_entry,
6882 struct dwo_unit *dwo_entry)
6884 /* Make sure we're not clobbering something we don't expect to. */
6885 gdb_assert (! sig_entry->per_cu.queued);
6886 gdb_assert (sig_entry->per_cu.cu == NULL);
6887 if (dwarf2_per_objfile->using_index)
6889 gdb_assert (sig_entry->per_cu.v.quick != NULL);
6890 gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
6893 gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
6894 gdb_assert (sig_entry->signature == dwo_entry->signature);
6895 gdb_assert (to_underlying (sig_entry->type_offset_in_section) == 0);
6896 gdb_assert (sig_entry->type_unit_group == NULL);
6897 gdb_assert (sig_entry->dwo_unit == NULL);
6899 sig_entry->per_cu.section = dwo_entry->section;
6900 sig_entry->per_cu.sect_off = dwo_entry->sect_off;
6901 sig_entry->per_cu.length = dwo_entry->length;
6902 sig_entry->per_cu.reading_dwo_directly = 1;
6903 sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6904 sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
6905 sig_entry->dwo_unit = dwo_entry;
6908 /* Subroutine of lookup_signatured_type.
6909 If we haven't read the TU yet, create the signatured_type data structure
6910 for a TU to be read in directly from a DWO file, bypassing the stub.
6911 This is the "Stay in DWO Optimization": When there is no DWP file and we're
6912 using .gdb_index, then when reading a CU we want to stay in the DWO file
6913 containing that CU. Otherwise we could end up reading several other DWO
6914 files (due to comdat folding) to process the transitive closure of all the
6915 mentioned TUs, and that can be slow. The current DWO file will have every
6916 type signature that it needs.
6917 We only do this for .gdb_index because in the psymtab case we already have
6918 to read all the DWOs to build the type unit groups. */
6920 static struct signatured_type *
6921 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
6923 struct dwarf2_per_objfile *dwarf2_per_objfile
6924 = cu->per_cu->dwarf2_per_objfile;
6925 struct objfile *objfile = dwarf2_per_objfile->objfile;
6926 struct dwo_file *dwo_file;
6927 struct dwo_unit find_dwo_entry, *dwo_entry;
6928 struct signatured_type find_sig_entry, *sig_entry;
6931 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
6933 /* If TU skeletons have been removed then we may not have read in any
6935 if (dwarf2_per_objfile->signatured_types == NULL)
6937 dwarf2_per_objfile->signatured_types
6938 = allocate_signatured_type_table (objfile);
6941 /* We only ever need to read in one copy of a signatured type.
6942 Use the global signatured_types array to do our own comdat-folding
6943 of types. If this is the first time we're reading this TU, and
6944 the TU has an entry in .gdb_index, replace the recorded data from
6945 .gdb_index with this TU. */
6947 find_sig_entry.signature = sig;
6948 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6949 &find_sig_entry, INSERT);
6950 sig_entry = (struct signatured_type *) *slot;
6952 /* We can get here with the TU already read, *or* in the process of being
6953 read. Don't reassign the global entry to point to this DWO if that's
6954 the case. Also note that if the TU is already being read, it may not
6955 have come from a DWO, the program may be a mix of Fission-compiled
6956 code and non-Fission-compiled code. */
6958 /* Have we already tried to read this TU?
6959 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
6960 needn't exist in the global table yet). */
6961 if (sig_entry != NULL && sig_entry->per_cu.tu_read)
6964 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
6965 dwo_unit of the TU itself. */
6966 dwo_file = cu->dwo_unit->dwo_file;
6968 /* Ok, this is the first time we're reading this TU. */
6969 if (dwo_file->tus == NULL)
6971 find_dwo_entry.signature = sig;
6972 dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
6973 if (dwo_entry == NULL)
6976 /* If the global table doesn't have an entry for this TU, add one. */
6977 if (sig_entry == NULL)
6978 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
6980 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
6981 sig_entry->per_cu.tu_read = 1;
6985 /* Subroutine of lookup_signatured_type.
6986 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
6987 then try the DWP file. If the TU stub (skeleton) has been removed then
6988 it won't be in .gdb_index. */
6990 static struct signatured_type *
6991 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
6993 struct dwarf2_per_objfile *dwarf2_per_objfile
6994 = cu->per_cu->dwarf2_per_objfile;
6995 struct objfile *objfile = dwarf2_per_objfile->objfile;
6996 struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
6997 struct dwo_unit *dwo_entry;
6998 struct signatured_type find_sig_entry, *sig_entry;
7001 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7002 gdb_assert (dwp_file != NULL);
7004 /* If TU skeletons have been removed then we may not have read in any
7006 if (dwarf2_per_objfile->signatured_types == NULL)
7008 dwarf2_per_objfile->signatured_types
7009 = allocate_signatured_type_table (objfile);
7012 find_sig_entry.signature = sig;
7013 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7014 &find_sig_entry, INSERT);
7015 sig_entry = (struct signatured_type *) *slot;
7017 /* Have we already tried to read this TU?
7018 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7019 needn't exist in the global table yet). */
7020 if (sig_entry != NULL)
7023 if (dwp_file->tus == NULL)
7025 dwo_entry = lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, NULL,
7026 sig, 1 /* is_debug_types */);
7027 if (dwo_entry == NULL)
7030 sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7031 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7036 /* Lookup a signature based type for DW_FORM_ref_sig8.
7037 Returns NULL if signature SIG is not present in the table.
7038 It is up to the caller to complain about this. */
7040 static struct signatured_type *
7041 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7043 struct dwarf2_per_objfile *dwarf2_per_objfile
7044 = cu->per_cu->dwarf2_per_objfile;
7047 && dwarf2_per_objfile->using_index)
7049 /* We're in a DWO/DWP file, and we're using .gdb_index.
7050 These cases require special processing. */
7051 if (get_dwp_file (dwarf2_per_objfile) == NULL)
7052 return lookup_dwo_signatured_type (cu, sig);
7054 return lookup_dwp_signatured_type (cu, sig);
7058 struct signatured_type find_entry, *entry;
7060 if (dwarf2_per_objfile->signatured_types == NULL)
7062 find_entry.signature = sig;
7063 entry = ((struct signatured_type *)
7064 htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
7069 /* Low level DIE reading support. */
7071 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
7074 init_cu_die_reader (struct die_reader_specs *reader,
7075 struct dwarf2_cu *cu,
7076 struct dwarf2_section_info *section,
7077 struct dwo_file *dwo_file,
7078 struct abbrev_table *abbrev_table)
7080 gdb_assert (section->readin && section->buffer != NULL);
7081 reader->abfd = get_section_bfd_owner (section);
7083 reader->dwo_file = dwo_file;
7084 reader->die_section = section;
7085 reader->buffer = section->buffer;
7086 reader->buffer_end = section->buffer + section->size;
7087 reader->comp_dir = NULL;
7088 reader->abbrev_table = abbrev_table;
7091 /* Subroutine of init_cutu_and_read_dies to simplify it.
7092 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7093 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7096 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7097 from it to the DIE in the DWO. If NULL we are skipping the stub.
7098 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7099 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7100 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
7101 STUB_COMP_DIR may be non-NULL.
7102 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7103 are filled in with the info of the DIE from the DWO file.
7104 *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7105 from the dwo. Since *RESULT_READER references this abbrev table, it must be
7106 kept around for at least as long as *RESULT_READER.
7108 The result is non-zero if a valid (non-dummy) DIE was found. */
7111 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
7112 struct dwo_unit *dwo_unit,
7113 struct die_info *stub_comp_unit_die,
7114 const char *stub_comp_dir,
7115 struct die_reader_specs *result_reader,
7116 const gdb_byte **result_info_ptr,
7117 struct die_info **result_comp_unit_die,
7118 int *result_has_children,
7119 abbrev_table_up *result_dwo_abbrev_table)
7121 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7122 struct objfile *objfile = dwarf2_per_objfile->objfile;
7123 struct dwarf2_cu *cu = this_cu->cu;
7125 const gdb_byte *begin_info_ptr, *info_ptr;
7126 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
7127 int i,num_extra_attrs;
7128 struct dwarf2_section_info *dwo_abbrev_section;
7129 struct attribute *attr;
7130 struct die_info *comp_unit_die;
7132 /* At most one of these may be provided. */
7133 gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
7135 /* These attributes aren't processed until later:
7136 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7137 DW_AT_comp_dir is used now, to find the DWO file, but it is also
7138 referenced later. However, these attributes are found in the stub
7139 which we won't have later. In order to not impose this complication
7140 on the rest of the code, we read them here and copy them to the
7149 if (stub_comp_unit_die != NULL)
7151 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7153 if (! this_cu->is_debug_types)
7154 stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
7155 low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
7156 high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
7157 ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
7158 comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
7160 /* There should be a DW_AT_addr_base attribute here (if needed).
7161 We need the value before we can process DW_FORM_GNU_addr_index
7162 or DW_FORM_addrx. */
7164 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
7166 cu->addr_base = DW_UNSND (attr);
7168 /* There should be a DW_AT_ranges_base attribute here (if needed).
7169 We need the value before we can process DW_AT_ranges. */
7170 cu->ranges_base = 0;
7171 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
7173 cu->ranges_base = DW_UNSND (attr);
7175 else if (stub_comp_dir != NULL)
7177 /* Reconstruct the comp_dir attribute to simplify the code below. */
7178 comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
7179 comp_dir->name = DW_AT_comp_dir;
7180 comp_dir->form = DW_FORM_string;
7181 DW_STRING_IS_CANONICAL (comp_dir) = 0;
7182 DW_STRING (comp_dir) = stub_comp_dir;
7185 /* Set up for reading the DWO CU/TU. */
7186 cu->dwo_unit = dwo_unit;
7187 dwarf2_section_info *section = dwo_unit->section;
7188 dwarf2_read_section (objfile, section);
7189 abfd = get_section_bfd_owner (section);
7190 begin_info_ptr = info_ptr = (section->buffer
7191 + to_underlying (dwo_unit->sect_off));
7192 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
7194 if (this_cu->is_debug_types)
7196 struct signatured_type *sig_type = (struct signatured_type *) this_cu;
7198 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7199 &cu->header, section,
7201 info_ptr, rcuh_kind::TYPE);
7202 /* This is not an assert because it can be caused by bad debug info. */
7203 if (sig_type->signature != cu->header.signature)
7205 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7206 " TU at offset %s [in module %s]"),
7207 hex_string (sig_type->signature),
7208 hex_string (cu->header.signature),
7209 sect_offset_str (dwo_unit->sect_off),
7210 bfd_get_filename (abfd));
7212 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7213 /* For DWOs coming from DWP files, we don't know the CU length
7214 nor the type's offset in the TU until now. */
7215 dwo_unit->length = get_cu_length (&cu->header);
7216 dwo_unit->type_offset_in_tu = cu->header.type_cu_offset_in_tu;
7218 /* Establish the type offset that can be used to lookup the type.
7219 For DWO files, we don't know it until now. */
7220 sig_type->type_offset_in_section
7221 = dwo_unit->sect_off + to_underlying (dwo_unit->type_offset_in_tu);
7225 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7226 &cu->header, section,
7228 info_ptr, rcuh_kind::COMPILE);
7229 gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7230 /* For DWOs coming from DWP files, we don't know the CU length
7232 dwo_unit->length = get_cu_length (&cu->header);
7235 *result_dwo_abbrev_table
7236 = abbrev_table_read_table (dwarf2_per_objfile, dwo_abbrev_section,
7237 cu->header.abbrev_sect_off);
7238 init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file,
7239 result_dwo_abbrev_table->get ());
7241 /* Read in the die, but leave space to copy over the attributes
7242 from the stub. This has the benefit of simplifying the rest of
7243 the code - all the work to maintain the illusion of a single
7244 DW_TAG_{compile,type}_unit DIE is done here. */
7245 num_extra_attrs = ((stmt_list != NULL)
7249 + (comp_dir != NULL));
7250 info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
7251 result_has_children, num_extra_attrs);
7253 /* Copy over the attributes from the stub to the DIE we just read in. */
7254 comp_unit_die = *result_comp_unit_die;
7255 i = comp_unit_die->num_attrs;
7256 if (stmt_list != NULL)
7257 comp_unit_die->attrs[i++] = *stmt_list;
7259 comp_unit_die->attrs[i++] = *low_pc;
7260 if (high_pc != NULL)
7261 comp_unit_die->attrs[i++] = *high_pc;
7263 comp_unit_die->attrs[i++] = *ranges;
7264 if (comp_dir != NULL)
7265 comp_unit_die->attrs[i++] = *comp_dir;
7266 comp_unit_die->num_attrs += num_extra_attrs;
7268 if (dwarf_die_debug)
7270 fprintf_unfiltered (gdb_stdlog,
7271 "Read die from %s@0x%x of %s:\n",
7272 get_section_name (section),
7273 (unsigned) (begin_info_ptr - section->buffer),
7274 bfd_get_filename (abfd));
7275 dump_die (comp_unit_die, dwarf_die_debug);
7278 /* Save the comp_dir attribute. If there is no DWP file then we'll read
7279 TUs by skipping the stub and going directly to the entry in the DWO file.
7280 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7281 to get it via circuitous means. Blech. */
7282 if (comp_dir != NULL)
7283 result_reader->comp_dir = DW_STRING (comp_dir);
7285 /* Skip dummy compilation units. */
7286 if (info_ptr >= begin_info_ptr + dwo_unit->length
7287 || peek_abbrev_code (abfd, info_ptr) == 0)
7290 *result_info_ptr = info_ptr;
7294 /* Subroutine of init_cutu_and_read_dies to simplify it.
7295 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7296 Returns NULL if the specified DWO unit cannot be found. */
7298 static struct dwo_unit *
7299 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
7300 struct die_info *comp_unit_die)
7302 struct dwarf2_cu *cu = this_cu->cu;
7304 struct dwo_unit *dwo_unit;
7305 const char *comp_dir, *dwo_name;
7307 gdb_assert (cu != NULL);
7309 /* Yeah, we look dwo_name up again, but it simplifies the code. */
7310 dwo_name = dwarf2_string_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7311 comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7313 if (this_cu->is_debug_types)
7315 struct signatured_type *sig_type;
7317 /* Since this_cu is the first member of struct signatured_type,
7318 we can go from a pointer to one to a pointer to the other. */
7319 sig_type = (struct signatured_type *) this_cu;
7320 signature = sig_type->signature;
7321 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
7325 struct attribute *attr;
7327 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
7329 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7331 dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
7332 signature = DW_UNSND (attr);
7333 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
7340 /* Subroutine of init_cutu_and_read_dies to simplify it.
7341 See it for a description of the parameters.
7342 Read a TU directly from a DWO file, bypassing the stub. */
7345 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
7346 int use_existing_cu, int keep,
7347 die_reader_func_ftype *die_reader_func,
7350 std::unique_ptr<dwarf2_cu> new_cu;
7351 struct signatured_type *sig_type;
7352 struct die_reader_specs reader;
7353 const gdb_byte *info_ptr;
7354 struct die_info *comp_unit_die;
7356 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7358 /* Verify we can do the following downcast, and that we have the
7360 gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
7361 sig_type = (struct signatured_type *) this_cu;
7362 gdb_assert (sig_type->dwo_unit != NULL);
7364 if (use_existing_cu && this_cu->cu != NULL)
7366 gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
7367 /* There's no need to do the rereading_dwo_cu handling that
7368 init_cutu_and_read_dies does since we don't read the stub. */
7372 /* If !use_existing_cu, this_cu->cu must be NULL. */
7373 gdb_assert (this_cu->cu == NULL);
7374 new_cu.reset (new dwarf2_cu (this_cu));
7377 /* A future optimization, if needed, would be to use an existing
7378 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
7379 could share abbrev tables. */
7381 /* The abbreviation table used by READER, this must live at least as long as
7383 abbrev_table_up dwo_abbrev_table;
7385 if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
7386 NULL /* stub_comp_unit_die */,
7387 sig_type->dwo_unit->dwo_file->comp_dir,
7389 &comp_unit_die, &has_children,
7390 &dwo_abbrev_table) == 0)
7396 /* All the "real" work is done here. */
7397 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7399 /* This duplicates the code in init_cutu_and_read_dies,
7400 but the alternative is making the latter more complex.
7401 This function is only for the special case of using DWO files directly:
7402 no point in overly complicating the general case just to handle this. */
7403 if (new_cu != NULL && keep)
7405 /* Link this CU into read_in_chain. */
7406 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7407 dwarf2_per_objfile->read_in_chain = this_cu;
7408 /* The chain owns it now. */
7413 /* Initialize a CU (or TU) and read its DIEs.
7414 If the CU defers to a DWO file, read the DWO file as well.
7416 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7417 Otherwise the table specified in the comp unit header is read in and used.
7418 This is an optimization for when we already have the abbrev table.
7420 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7421 Otherwise, a new CU is allocated with xmalloc.
7423 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7424 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
7426 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7427 linker) then DIE_READER_FUNC will not get called. */
7430 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
7431 struct abbrev_table *abbrev_table,
7432 int use_existing_cu, int keep,
7434 die_reader_func_ftype *die_reader_func,
7437 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7438 struct objfile *objfile = dwarf2_per_objfile->objfile;
7439 struct dwarf2_section_info *section = this_cu->section;
7440 bfd *abfd = get_section_bfd_owner (section);
7441 struct dwarf2_cu *cu;
7442 const gdb_byte *begin_info_ptr, *info_ptr;
7443 struct die_reader_specs reader;
7444 struct die_info *comp_unit_die;
7446 struct attribute *attr;
7447 struct signatured_type *sig_type = NULL;
7448 struct dwarf2_section_info *abbrev_section;
7449 /* Non-zero if CU currently points to a DWO file and we need to
7450 reread it. When this happens we need to reread the skeleton die
7451 before we can reread the DWO file (this only applies to CUs, not TUs). */
7452 int rereading_dwo_cu = 0;
7454 if (dwarf_die_debug)
7455 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7456 this_cu->is_debug_types ? "type" : "comp",
7457 sect_offset_str (this_cu->sect_off));
7459 if (use_existing_cu)
7462 /* If we're reading a TU directly from a DWO file, including a virtual DWO
7463 file (instead of going through the stub), short-circuit all of this. */
7464 if (this_cu->reading_dwo_directly)
7466 /* Narrow down the scope of possibilities to have to understand. */
7467 gdb_assert (this_cu->is_debug_types);
7468 gdb_assert (abbrev_table == NULL);
7469 init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
7470 die_reader_func, data);
7474 /* This is cheap if the section is already read in. */
7475 dwarf2_read_section (objfile, section);
7477 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7479 abbrev_section = get_abbrev_section_for_cu (this_cu);
7481 std::unique_ptr<dwarf2_cu> new_cu;
7482 if (use_existing_cu && this_cu->cu != NULL)
7485 /* If this CU is from a DWO file we need to start over, we need to
7486 refetch the attributes from the skeleton CU.
7487 This could be optimized by retrieving those attributes from when we
7488 were here the first time: the previous comp_unit_die was stored in
7489 comp_unit_obstack. But there's no data yet that we need this
7491 if (cu->dwo_unit != NULL)
7492 rereading_dwo_cu = 1;
7496 /* If !use_existing_cu, this_cu->cu must be NULL. */
7497 gdb_assert (this_cu->cu == NULL);
7498 new_cu.reset (new dwarf2_cu (this_cu));
7502 /* Get the header. */
7503 if (to_underlying (cu->header.first_die_cu_offset) != 0 && !rereading_dwo_cu)
7505 /* We already have the header, there's no need to read it in again. */
7506 info_ptr += to_underlying (cu->header.first_die_cu_offset);
7510 if (this_cu->is_debug_types)
7512 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7513 &cu->header, section,
7514 abbrev_section, info_ptr,
7517 /* Since per_cu is the first member of struct signatured_type,
7518 we can go from a pointer to one to a pointer to the other. */
7519 sig_type = (struct signatured_type *) this_cu;
7520 gdb_assert (sig_type->signature == cu->header.signature);
7521 gdb_assert (sig_type->type_offset_in_tu
7522 == cu->header.type_cu_offset_in_tu);
7523 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7525 /* LENGTH has not been set yet for type units if we're
7526 using .gdb_index. */
7527 this_cu->length = get_cu_length (&cu->header);
7529 /* Establish the type offset that can be used to lookup the type. */
7530 sig_type->type_offset_in_section =
7531 this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu);
7533 this_cu->dwarf_version = cu->header.version;
7537 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7538 &cu->header, section,
7541 rcuh_kind::COMPILE);
7543 gdb_assert (this_cu->sect_off == cu->header.sect_off);
7544 gdb_assert (this_cu->length == get_cu_length (&cu->header));
7545 this_cu->dwarf_version = cu->header.version;
7549 /* Skip dummy compilation units. */
7550 if (info_ptr >= begin_info_ptr + this_cu->length
7551 || peek_abbrev_code (abfd, info_ptr) == 0)
7554 /* If we don't have them yet, read the abbrevs for this compilation unit.
7555 And if we need to read them now, make sure they're freed when we're
7556 done (own the table through ABBREV_TABLE_HOLDER). */
7557 abbrev_table_up abbrev_table_holder;
7558 if (abbrev_table != NULL)
7559 gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off);
7563 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7564 cu->header.abbrev_sect_off);
7565 abbrev_table = abbrev_table_holder.get ();
7568 /* Read the top level CU/TU die. */
7569 init_cu_die_reader (&reader, cu, section, NULL, abbrev_table);
7570 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7572 if (skip_partial && comp_unit_die->tag == DW_TAG_partial_unit)
7575 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7576 from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
7577 table from the DWO file and pass the ownership over to us. It will be
7578 referenced from READER, so we must make sure to free it after we're done
7581 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7582 DWO CU, that this test will fail (the attribute will not be present). */
7583 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7584 abbrev_table_up dwo_abbrev_table;
7587 struct dwo_unit *dwo_unit;
7588 struct die_info *dwo_comp_unit_die;
7592 complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7593 " has children (offset %s) [in module %s]"),
7594 sect_offset_str (this_cu->sect_off),
7595 bfd_get_filename (abfd));
7597 dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
7598 if (dwo_unit != NULL)
7600 if (read_cutu_die_from_dwo (this_cu, dwo_unit,
7601 comp_unit_die, NULL,
7603 &dwo_comp_unit_die, &has_children,
7604 &dwo_abbrev_table) == 0)
7609 comp_unit_die = dwo_comp_unit_die;
7613 /* Yikes, we couldn't find the rest of the DIE, we only have
7614 the stub. A complaint has already been logged. There's
7615 not much more we can do except pass on the stub DIE to
7616 die_reader_func. We don't want to throw an error on bad
7621 /* All of the above is setup for this call. Yikes. */
7622 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7624 /* Done, clean up. */
7625 if (new_cu != NULL && keep)
7627 /* Link this CU into read_in_chain. */
7628 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7629 dwarf2_per_objfile->read_in_chain = this_cu;
7630 /* The chain owns it now. */
7635 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7636 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7637 to have already done the lookup to find the DWO file).
7639 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7640 THIS_CU->is_debug_types, but nothing else.
7642 We fill in THIS_CU->length.
7644 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7645 linker) then DIE_READER_FUNC will not get called.
7647 THIS_CU->cu is always freed when done.
7648 This is done in order to not leave THIS_CU->cu in a state where we have
7649 to care whether it refers to the "main" CU or the DWO CU. */
7652 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
7653 struct dwo_file *dwo_file,
7654 die_reader_func_ftype *die_reader_func,
7657 struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7658 struct objfile *objfile = dwarf2_per_objfile->objfile;
7659 struct dwarf2_section_info *section = this_cu->section;
7660 bfd *abfd = get_section_bfd_owner (section);
7661 struct dwarf2_section_info *abbrev_section;
7662 const gdb_byte *begin_info_ptr, *info_ptr;
7663 struct die_reader_specs reader;
7664 struct die_info *comp_unit_die;
7667 if (dwarf_die_debug)
7668 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7669 this_cu->is_debug_types ? "type" : "comp",
7670 sect_offset_str (this_cu->sect_off));
7672 gdb_assert (this_cu->cu == NULL);
7674 abbrev_section = (dwo_file != NULL
7675 ? &dwo_file->sections.abbrev
7676 : get_abbrev_section_for_cu (this_cu));
7678 /* This is cheap if the section is already read in. */
7679 dwarf2_read_section (objfile, section);
7681 struct dwarf2_cu cu (this_cu);
7683 begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7684 info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7685 &cu.header, section,
7686 abbrev_section, info_ptr,
7687 (this_cu->is_debug_types
7689 : rcuh_kind::COMPILE));
7691 this_cu->length = get_cu_length (&cu.header);
7693 /* Skip dummy compilation units. */
7694 if (info_ptr >= begin_info_ptr + this_cu->length
7695 || peek_abbrev_code (abfd, info_ptr) == 0)
7698 abbrev_table_up abbrev_table
7699 = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7700 cu.header.abbrev_sect_off);
7702 init_cu_die_reader (&reader, &cu, section, dwo_file, abbrev_table.get ());
7703 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7705 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7708 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7709 does not lookup the specified DWO file.
7710 This cannot be used to read DWO files.
7712 THIS_CU->cu is always freed when done.
7713 This is done in order to not leave THIS_CU->cu in a state where we have
7714 to care whether it refers to the "main" CU or the DWO CU.
7715 We can revisit this if the data shows there's a performance issue. */
7718 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
7719 die_reader_func_ftype *die_reader_func,
7722 init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
7725 /* Type Unit Groups.
7727 Type Unit Groups are a way to collapse the set of all TUs (type units) into
7728 a more manageable set. The grouping is done by DW_AT_stmt_list entry
7729 so that all types coming from the same compilation (.o file) are grouped
7730 together. A future step could be to put the types in the same symtab as
7731 the CU the types ultimately came from. */
7734 hash_type_unit_group (const void *item)
7736 const struct type_unit_group *tu_group
7737 = (const struct type_unit_group *) item;
7739 return hash_stmt_list_entry (&tu_group->hash);
7743 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
7745 const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
7746 const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
7748 return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
7751 /* Allocate a hash table for type unit groups. */
7754 allocate_type_unit_groups_table (struct objfile *objfile)
7756 return htab_create_alloc_ex (3,
7757 hash_type_unit_group,
7760 &objfile->objfile_obstack,
7761 hashtab_obstack_allocate,
7762 dummy_obstack_deallocate);
7765 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7766 partial symtabs. We combine several TUs per psymtab to not let the size
7767 of any one psymtab grow too big. */
7768 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7769 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7771 /* Helper routine for get_type_unit_group.
7772 Create the type_unit_group object used to hold one or more TUs. */
7774 static struct type_unit_group *
7775 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
7777 struct dwarf2_per_objfile *dwarf2_per_objfile
7778 = cu->per_cu->dwarf2_per_objfile;
7779 struct objfile *objfile = dwarf2_per_objfile->objfile;
7780 struct dwarf2_per_cu_data *per_cu;
7781 struct type_unit_group *tu_group;
7783 tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7784 struct type_unit_group);
7785 per_cu = &tu_group->per_cu;
7786 per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
7788 if (dwarf2_per_objfile->using_index)
7790 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7791 struct dwarf2_per_cu_quick_data);
7795 unsigned int line_offset = to_underlying (line_offset_struct);
7796 struct partial_symtab *pst;
7799 /* Give the symtab a useful name for debug purposes. */
7800 if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
7801 name = string_printf ("<type_units_%d>",
7802 (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
7804 name = string_printf ("<type_units_at_0x%x>", line_offset);
7806 pst = create_partial_symtab (per_cu, name.c_str ());
7810 tu_group->hash.dwo_unit = cu->dwo_unit;
7811 tu_group->hash.line_sect_off = line_offset_struct;
7816 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7817 STMT_LIST is a DW_AT_stmt_list attribute. */
7819 static struct type_unit_group *
7820 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
7822 struct dwarf2_per_objfile *dwarf2_per_objfile
7823 = cu->per_cu->dwarf2_per_objfile;
7824 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
7825 struct type_unit_group *tu_group;
7827 unsigned int line_offset;
7828 struct type_unit_group type_unit_group_for_lookup;
7830 if (dwarf2_per_objfile->type_unit_groups == NULL)
7832 dwarf2_per_objfile->type_unit_groups =
7833 allocate_type_unit_groups_table (dwarf2_per_objfile->objfile);
7836 /* Do we need to create a new group, or can we use an existing one? */
7840 line_offset = DW_UNSND (stmt_list);
7841 ++tu_stats->nr_symtab_sharers;
7845 /* Ugh, no stmt_list. Rare, but we have to handle it.
7846 We can do various things here like create one group per TU or
7847 spread them over multiple groups to split up the expansion work.
7848 To avoid worst case scenarios (too many groups or too large groups)
7849 we, umm, group them in bunches. */
7850 line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7851 | (tu_stats->nr_stmt_less_type_units
7852 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
7853 ++tu_stats->nr_stmt_less_type_units;
7856 type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
7857 type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;
7858 slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
7859 &type_unit_group_for_lookup, INSERT);
7862 tu_group = (struct type_unit_group *) *slot;
7863 gdb_assert (tu_group != NULL);
7867 sect_offset line_offset_struct = (sect_offset) line_offset;
7868 tu_group = create_type_unit_group (cu, line_offset_struct);
7870 ++tu_stats->nr_symtabs;
7876 /* Partial symbol tables. */
7878 /* Create a psymtab named NAME and assign it to PER_CU.
7880 The caller must fill in the following details:
7881 dirname, textlow, texthigh. */
7883 static struct partial_symtab *
7884 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
7886 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
7887 struct partial_symtab *pst;
7889 pst = start_psymtab_common (objfile, name, 0);
7891 pst->psymtabs_addrmap_supported = 1;
7893 /* This is the glue that links PST into GDB's symbol API. */
7894 pst->read_symtab_private = per_cu;
7895 pst->read_symtab = dwarf2_read_symtab;
7896 per_cu->v.psymtab = pst;
7901 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7904 struct process_psymtab_comp_unit_data
7906 /* True if we are reading a DW_TAG_partial_unit. */
7908 int want_partial_unit;
7910 /* The "pretend" language that is used if the CU doesn't declare a
7913 enum language pretend_language;
7916 /* die_reader_func for process_psymtab_comp_unit. */
7919 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
7920 const gdb_byte *info_ptr,
7921 struct die_info *comp_unit_die,
7925 struct dwarf2_cu *cu = reader->cu;
7926 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
7927 struct gdbarch *gdbarch = get_objfile_arch (objfile);
7928 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
7930 CORE_ADDR best_lowpc = 0, best_highpc = 0;
7931 struct partial_symtab *pst;
7932 enum pc_bounds_kind cu_bounds_kind;
7933 const char *filename;
7934 struct process_psymtab_comp_unit_data *info
7935 = (struct process_psymtab_comp_unit_data *) data;
7937 if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
7940 gdb_assert (! per_cu->is_debug_types);
7942 prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
7944 /* Allocate a new partial symbol table structure. */
7945 filename = dwarf2_string_attr (comp_unit_die, DW_AT_name, cu);
7946 if (filename == NULL)
7949 pst = create_partial_symtab (per_cu, filename);
7951 /* This must be done before calling dwarf2_build_include_psymtabs. */
7952 pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7954 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7956 dwarf2_find_base_address (comp_unit_die, cu);
7958 /* Possibly set the default values of LOWPC and HIGHPC from
7960 cu_bounds_kind = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
7961 &best_highpc, cu, pst);
7962 if (cu_bounds_kind == PC_BOUNDS_HIGH_LOW && best_lowpc < best_highpc)
7965 = (gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr)
7968 = (gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr)
7970 /* Store the contiguous range if it is not empty; it can be
7971 empty for CUs with no code. */
7972 addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
7976 /* Check if comp unit has_children.
7977 If so, read the rest of the partial symbols from this comp unit.
7978 If not, there's no more debug_info for this comp unit. */
7981 struct partial_die_info *first_die;
7982 CORE_ADDR lowpc, highpc;
7984 lowpc = ((CORE_ADDR) -1);
7985 highpc = ((CORE_ADDR) 0);
7987 first_die = load_partial_dies (reader, info_ptr, 1);
7989 scan_partial_symbols (first_die, &lowpc, &highpc,
7990 cu_bounds_kind <= PC_BOUNDS_INVALID, cu);
7992 /* If we didn't find a lowpc, set it to highpc to avoid
7993 complaints from `maint check'. */
7994 if (lowpc == ((CORE_ADDR) -1))
7997 /* If the compilation unit didn't have an explicit address range,
7998 then use the information extracted from its child dies. */
7999 if (cu_bounds_kind <= PC_BOUNDS_INVALID)
8002 best_highpc = highpc;
8005 pst->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch,
8006 best_lowpc + baseaddr)
8008 pst->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch,
8009 best_highpc + baseaddr)
8012 end_psymtab_common (objfile, pst);
8014 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
8017 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8018 struct dwarf2_per_cu_data *iter;
8020 /* Fill in 'dependencies' here; we fill in 'users' in a
8022 pst->number_of_dependencies = len;
8024 = objfile->partial_symtabs->allocate_dependencies (len);
8026 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8029 pst->dependencies[i] = iter->v.psymtab;
8031 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8034 /* Get the list of files included in the current compilation unit,
8035 and build a psymtab for each of them. */
8036 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
8038 if (dwarf_read_debug)
8039 fprintf_unfiltered (gdb_stdlog,
8040 "Psymtab for %s unit @%s: %s - %s"
8041 ", %d global, %d static syms\n",
8042 per_cu->is_debug_types ? "type" : "comp",
8043 sect_offset_str (per_cu->sect_off),
8044 paddress (gdbarch, pst->text_low (objfile)),
8045 paddress (gdbarch, pst->text_high (objfile)),
8046 pst->n_global_syms, pst->n_static_syms);
8049 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8050 Process compilation unit THIS_CU for a psymtab. */
8053 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
8054 int want_partial_unit,
8055 enum language pretend_language)
8057 /* If this compilation unit was already read in, free the
8058 cached copy in order to read it in again. This is
8059 necessary because we skipped some symbols when we first
8060 read in the compilation unit (see load_partial_dies).
8061 This problem could be avoided, but the benefit is unclear. */
8062 if (this_cu->cu != NULL)
8063 free_one_cached_comp_unit (this_cu);
8065 if (this_cu->is_debug_types)
8066 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8067 build_type_psymtabs_reader, NULL);
8070 process_psymtab_comp_unit_data info;
8071 info.want_partial_unit = want_partial_unit;
8072 info.pretend_language = pretend_language;
8073 init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8074 process_psymtab_comp_unit_reader, &info);
8077 /* Age out any secondary CUs. */
8078 age_cached_comp_units (this_cu->dwarf2_per_objfile);
8081 /* Reader function for build_type_psymtabs. */
8084 build_type_psymtabs_reader (const struct die_reader_specs *reader,
8085 const gdb_byte *info_ptr,
8086 struct die_info *type_unit_die,
8090 struct dwarf2_per_objfile *dwarf2_per_objfile
8091 = reader->cu->per_cu->dwarf2_per_objfile;
8092 struct objfile *objfile = dwarf2_per_objfile->objfile;
8093 struct dwarf2_cu *cu = reader->cu;
8094 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8095 struct signatured_type *sig_type;
8096 struct type_unit_group *tu_group;
8097 struct attribute *attr;
8098 struct partial_die_info *first_die;
8099 CORE_ADDR lowpc, highpc;
8100 struct partial_symtab *pst;
8102 gdb_assert (data == NULL);
8103 gdb_assert (per_cu->is_debug_types);
8104 sig_type = (struct signatured_type *) per_cu;
8109 attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
8110 tu_group = get_type_unit_group (cu, attr);
8112 VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
8114 prepare_one_comp_unit (cu, type_unit_die, language_minimal);
8115 pst = create_partial_symtab (per_cu, "");
8118 first_die = load_partial_dies (reader, info_ptr, 1);
8120 lowpc = (CORE_ADDR) -1;
8121 highpc = (CORE_ADDR) 0;
8122 scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
8124 end_psymtab_common (objfile, pst);
8127 /* Struct used to sort TUs by their abbreviation table offset. */
8129 struct tu_abbrev_offset
8131 tu_abbrev_offset (signatured_type *sig_type_, sect_offset abbrev_offset_)
8132 : sig_type (sig_type_), abbrev_offset (abbrev_offset_)
8135 signatured_type *sig_type;
8136 sect_offset abbrev_offset;
8139 /* Helper routine for build_type_psymtabs_1, passed to std::sort. */
8142 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset &a,
8143 const struct tu_abbrev_offset &b)
8145 return a.abbrev_offset < b.abbrev_offset;
8148 /* Efficiently read all the type units.
8149 This does the bulk of the work for build_type_psymtabs.
8151 The efficiency is because we sort TUs by the abbrev table they use and
8152 only read each abbrev table once. In one program there are 200K TUs
8153 sharing 8K abbrev tables.
8155 The main purpose of this function is to support building the
8156 dwarf2_per_objfile->type_unit_groups table.
8157 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8158 can collapse the search space by grouping them by stmt_list.
8159 The savings can be significant, in the same program from above the 200K TUs
8160 share 8K stmt_list tables.
8162 FUNC is expected to call get_type_unit_group, which will create the
8163 struct type_unit_group if necessary and add it to
8164 dwarf2_per_objfile->type_unit_groups. */
8167 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
8169 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8170 abbrev_table_up abbrev_table;
8171 sect_offset abbrev_offset;
8173 /* It's up to the caller to not call us multiple times. */
8174 gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
8176 if (dwarf2_per_objfile->all_type_units.empty ())
8179 /* TUs typically share abbrev tables, and there can be way more TUs than
8180 abbrev tables. Sort by abbrev table to reduce the number of times we
8181 read each abbrev table in.
8182 Alternatives are to punt or to maintain a cache of abbrev tables.
8183 This is simpler and efficient enough for now.
8185 Later we group TUs by their DW_AT_stmt_list value (as this defines the
8186 symtab to use). Typically TUs with the same abbrev offset have the same
8187 stmt_list value too so in practice this should work well.
8189 The basic algorithm here is:
8191 sort TUs by abbrev table
8192 for each TU with same abbrev table:
8193 read abbrev table if first user
8194 read TU top level DIE
8195 [IWBN if DWO skeletons had DW_AT_stmt_list]
8198 if (dwarf_read_debug)
8199 fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
8201 /* Sort in a separate table to maintain the order of all_type_units
8202 for .gdb_index: TU indices directly index all_type_units. */
8203 std::vector<tu_abbrev_offset> sorted_by_abbrev;
8204 sorted_by_abbrev.reserve (dwarf2_per_objfile->all_type_units.size ());
8206 for (signatured_type *sig_type : dwarf2_per_objfile->all_type_units)
8207 sorted_by_abbrev.emplace_back
8208 (sig_type, read_abbrev_offset (dwarf2_per_objfile,
8209 sig_type->per_cu.section,
8210 sig_type->per_cu.sect_off));
8212 std::sort (sorted_by_abbrev.begin (), sorted_by_abbrev.end (),
8213 sort_tu_by_abbrev_offset);
8215 abbrev_offset = (sect_offset) ~(unsigned) 0;
8217 for (const tu_abbrev_offset &tu : sorted_by_abbrev)
8219 /* Switch to the next abbrev table if necessary. */
8220 if (abbrev_table == NULL
8221 || tu.abbrev_offset != abbrev_offset)
8223 abbrev_offset = tu.abbrev_offset;
8225 abbrev_table_read_table (dwarf2_per_objfile,
8226 &dwarf2_per_objfile->abbrev,
8228 ++tu_stats->nr_uniq_abbrev_tables;
8231 init_cutu_and_read_dies (&tu.sig_type->per_cu, abbrev_table.get (),
8232 0, 0, false, build_type_psymtabs_reader, NULL);
8236 /* Print collected type unit statistics. */
8239 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
8241 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8243 fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
8244 fprintf_unfiltered (gdb_stdlog, " %zu TUs\n",
8245 dwarf2_per_objfile->all_type_units.size ());
8246 fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
8247 tu_stats->nr_uniq_abbrev_tables);
8248 fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
8249 tu_stats->nr_symtabs);
8250 fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
8251 tu_stats->nr_symtab_sharers);
8252 fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
8253 tu_stats->nr_stmt_less_type_units);
8254 fprintf_unfiltered (gdb_stdlog, " %d all_type_units reallocs\n",
8255 tu_stats->nr_all_type_units_reallocs);
8258 /* Traversal function for build_type_psymtabs. */
8261 build_type_psymtab_dependencies (void **slot, void *info)
8263 struct dwarf2_per_objfile *dwarf2_per_objfile
8264 = (struct dwarf2_per_objfile *) info;
8265 struct objfile *objfile = dwarf2_per_objfile->objfile;
8266 struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
8267 struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
8268 struct partial_symtab *pst = per_cu->v.psymtab;
8269 int len = VEC_length (sig_type_ptr, tu_group->tus);
8270 struct signatured_type *iter;
8273 gdb_assert (len > 0);
8274 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
8276 pst->number_of_dependencies = len;
8277 pst->dependencies = objfile->partial_symtabs->allocate_dependencies (len);
8279 VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
8282 gdb_assert (iter->per_cu.is_debug_types);
8283 pst->dependencies[i] = iter->per_cu.v.psymtab;
8284 iter->type_unit_group = tu_group;
8287 VEC_free (sig_type_ptr, tu_group->tus);
8292 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8293 Build partial symbol tables for the .debug_types comp-units. */
8296 build_type_psymtabs (struct dwarf2_per_objfile *dwarf2_per_objfile)
8298 if (! create_all_type_units (dwarf2_per_objfile))
8301 build_type_psymtabs_1 (dwarf2_per_objfile);
8304 /* Traversal function for process_skeletonless_type_unit.
8305 Read a TU in a DWO file and build partial symbols for it. */
8308 process_skeletonless_type_unit (void **slot, void *info)
8310 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
8311 struct dwarf2_per_objfile *dwarf2_per_objfile
8312 = (struct dwarf2_per_objfile *) info;
8313 struct signatured_type find_entry, *entry;
8315 /* If this TU doesn't exist in the global table, add it and read it in. */
8317 if (dwarf2_per_objfile->signatured_types == NULL)
8319 dwarf2_per_objfile->signatured_types
8320 = allocate_signatured_type_table (dwarf2_per_objfile->objfile);
8323 find_entry.signature = dwo_unit->signature;
8324 slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
8326 /* If we've already seen this type there's nothing to do. What's happening
8327 is we're doing our own version of comdat-folding here. */
8331 /* This does the job that create_all_type_units would have done for
8333 entry = add_type_unit (dwarf2_per_objfile, dwo_unit->signature, slot);
8334 fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, entry, dwo_unit);
8337 /* This does the job that build_type_psymtabs_1 would have done. */
8338 init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0, false,
8339 build_type_psymtabs_reader, NULL);
8344 /* Traversal function for process_skeletonless_type_units. */
8347 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
8349 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
8351 if (dwo_file->tus != NULL)
8353 htab_traverse_noresize (dwo_file->tus,
8354 process_skeletonless_type_unit, info);
8360 /* Scan all TUs of DWO files, verifying we've processed them.
8361 This is needed in case a TU was emitted without its skeleton.
8362 Note: This can't be done until we know what all the DWO files are. */
8365 process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8367 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
8368 if (get_dwp_file (dwarf2_per_objfile) == NULL
8369 && dwarf2_per_objfile->dwo_files != NULL)
8371 htab_traverse_noresize (dwarf2_per_objfile->dwo_files.get (),
8372 process_dwo_file_for_skeletonless_type_units,
8373 dwarf2_per_objfile);
8377 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE. */
8380 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
8382 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8384 struct partial_symtab *pst = per_cu->v.psymtab;
8389 for (int j = 0; j < pst->number_of_dependencies; ++j)
8391 /* Set the 'user' field only if it is not already set. */
8392 if (pst->dependencies[j]->user == NULL)
8393 pst->dependencies[j]->user = pst;
8398 /* Build the partial symbol table by doing a quick pass through the
8399 .debug_info and .debug_abbrev sections. */
8402 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
8404 struct objfile *objfile = dwarf2_per_objfile->objfile;
8406 if (dwarf_read_debug)
8408 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
8409 objfile_name (objfile));
8412 dwarf2_per_objfile->reading_partial_symbols = 1;
8414 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
8416 /* Any cached compilation units will be linked by the per-objfile
8417 read_in_chain. Make sure to free them when we're done. */
8418 free_cached_comp_units freer (dwarf2_per_objfile);
8420 build_type_psymtabs (dwarf2_per_objfile);
8422 create_all_comp_units (dwarf2_per_objfile);
8424 /* Create a temporary address map on a temporary obstack. We later
8425 copy this to the final obstack. */
8426 auto_obstack temp_obstack;
8428 scoped_restore save_psymtabs_addrmap
8429 = make_scoped_restore (&objfile->partial_symtabs->psymtabs_addrmap,
8430 addrmap_create_mutable (&temp_obstack));
8432 for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8433 process_psymtab_comp_unit (per_cu, 0, language_minimal);
8435 /* This has to wait until we read the CUs, we need the list of DWOs. */
8436 process_skeletonless_type_units (dwarf2_per_objfile);
8438 /* Now that all TUs have been processed we can fill in the dependencies. */
8439 if (dwarf2_per_objfile->type_unit_groups != NULL)
8441 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
8442 build_type_psymtab_dependencies, dwarf2_per_objfile);
8445 if (dwarf_read_debug)
8446 print_tu_stats (dwarf2_per_objfile);
8448 set_partial_user (dwarf2_per_objfile);
8450 objfile->partial_symtabs->psymtabs_addrmap
8451 = addrmap_create_fixed (objfile->partial_symtabs->psymtabs_addrmap,
8452 objfile->partial_symtabs->obstack ());
8453 /* At this point we want to keep the address map. */
8454 save_psymtabs_addrmap.release ();
8456 if (dwarf_read_debug)
8457 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
8458 objfile_name (objfile));
8461 /* die_reader_func for load_partial_comp_unit. */
8464 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
8465 const gdb_byte *info_ptr,
8466 struct die_info *comp_unit_die,
8470 struct dwarf2_cu *cu = reader->cu;
8472 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
8474 /* Check if comp unit has_children.
8475 If so, read the rest of the partial symbols from this comp unit.
8476 If not, there's no more debug_info for this comp unit. */
8478 load_partial_dies (reader, info_ptr, 0);
8481 /* Load the partial DIEs for a secondary CU into memory.
8482 This is also used when rereading a primary CU with load_all_dies. */
8485 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
8487 init_cutu_and_read_dies (this_cu, NULL, 1, 1, false,
8488 load_partial_comp_unit_reader, NULL);
8492 read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
8493 struct dwarf2_section_info *section,
8494 struct dwarf2_section_info *abbrev_section,
8495 unsigned int is_dwz)
8497 const gdb_byte *info_ptr;
8498 struct objfile *objfile = dwarf2_per_objfile->objfile;
8500 if (dwarf_read_debug)
8501 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
8502 get_section_name (section),
8503 get_section_file_name (section));
8505 dwarf2_read_section (objfile, section);
8507 info_ptr = section->buffer;
8509 while (info_ptr < section->buffer + section->size)
8511 struct dwarf2_per_cu_data *this_cu;
8513 sect_offset sect_off = (sect_offset) (info_ptr - section->buffer);
8515 comp_unit_head cu_header;
8516 read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
8517 abbrev_section, info_ptr,
8518 rcuh_kind::COMPILE);
8520 /* Save the compilation unit for later lookup. */
8521 if (cu_header.unit_type != DW_UT_type)
8523 this_cu = XOBNEW (&objfile->objfile_obstack,
8524 struct dwarf2_per_cu_data);
8525 memset (this_cu, 0, sizeof (*this_cu));
8529 auto sig_type = XOBNEW (&objfile->objfile_obstack,
8530 struct signatured_type);
8531 memset (sig_type, 0, sizeof (*sig_type));
8532 sig_type->signature = cu_header.signature;
8533 sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
8534 this_cu = &sig_type->per_cu;
8536 this_cu->is_debug_types = (cu_header.unit_type == DW_UT_type);
8537 this_cu->sect_off = sect_off;
8538 this_cu->length = cu_header.length + cu_header.initial_length_size;
8539 this_cu->is_dwz = is_dwz;
8540 this_cu->dwarf2_per_objfile = dwarf2_per_objfile;
8541 this_cu->section = section;
8543 dwarf2_per_objfile->all_comp_units.push_back (this_cu);
8545 info_ptr = info_ptr + this_cu->length;
8549 /* Create a list of all compilation units in OBJFILE.
8550 This is only done for -readnow and building partial symtabs. */
8553 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8555 gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
8556 read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
8557 &dwarf2_per_objfile->abbrev, 0);
8559 dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
8561 read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
8565 /* Process all loaded DIEs for compilation unit CU, starting at
8566 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
8567 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8568 DW_AT_ranges). See the comments of add_partial_subprogram on how
8569 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
8572 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
8573 CORE_ADDR *highpc, int set_addrmap,
8574 struct dwarf2_cu *cu)
8576 struct partial_die_info *pdi;
8578 /* Now, march along the PDI's, descending into ones which have
8579 interesting children but skipping the children of the other ones,
8580 until we reach the end of the compilation unit. */
8588 /* Anonymous namespaces or modules have no name but have interesting
8589 children, so we need to look at them. Ditto for anonymous
8592 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
8593 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
8594 || pdi->tag == DW_TAG_imported_unit
8595 || pdi->tag == DW_TAG_inlined_subroutine)
8599 case DW_TAG_subprogram:
8600 case DW_TAG_inlined_subroutine:
8601 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
8603 case DW_TAG_constant:
8604 case DW_TAG_variable:
8605 case DW_TAG_typedef:
8606 case DW_TAG_union_type:
8607 if (!pdi->is_declaration)
8609 add_partial_symbol (pdi, cu);
8612 case DW_TAG_class_type:
8613 case DW_TAG_interface_type:
8614 case DW_TAG_structure_type:
8615 if (!pdi->is_declaration)
8617 add_partial_symbol (pdi, cu);
8619 if ((cu->language == language_rust
8620 || cu->language == language_cplus) && pdi->has_children)
8621 scan_partial_symbols (pdi->die_child, lowpc, highpc,
8624 case DW_TAG_enumeration_type:
8625 if (!pdi->is_declaration)
8626 add_partial_enumeration (pdi, cu);
8628 case DW_TAG_base_type:
8629 case DW_TAG_subrange_type:
8630 /* File scope base type definitions are added to the partial
8632 add_partial_symbol (pdi, cu);
8634 case DW_TAG_namespace:
8635 add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
8638 add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
8640 case DW_TAG_imported_unit:
8642 struct dwarf2_per_cu_data *per_cu;
8644 /* For now we don't handle imported units in type units. */
8645 if (cu->per_cu->is_debug_types)
8647 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8648 " supported in type units [in module %s]"),
8649 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
8652 per_cu = dwarf2_find_containing_comp_unit
8653 (pdi->d.sect_off, pdi->is_dwz,
8654 cu->per_cu->dwarf2_per_objfile);
8656 /* Go read the partial unit, if needed. */
8657 if (per_cu->v.psymtab == NULL)
8658 process_psymtab_comp_unit (per_cu, 1, cu->language);
8660 VEC_safe_push (dwarf2_per_cu_ptr,
8661 cu->per_cu->imported_symtabs, per_cu);
8664 case DW_TAG_imported_declaration:
8665 add_partial_symbol (pdi, cu);
8672 /* If the die has a sibling, skip to the sibling. */
8674 pdi = pdi->die_sibling;
8678 /* Functions used to compute the fully scoped name of a partial DIE.
8680 Normally, this is simple. For C++, the parent DIE's fully scoped
8681 name is concatenated with "::" and the partial DIE's name.
8682 Enumerators are an exception; they use the scope of their parent
8683 enumeration type, i.e. the name of the enumeration type is not
8684 prepended to the enumerator.
8686 There are two complexities. One is DW_AT_specification; in this
8687 case "parent" means the parent of the target of the specification,
8688 instead of the direct parent of the DIE. The other is compilers
8689 which do not emit DW_TAG_namespace; in this case we try to guess
8690 the fully qualified name of structure types from their members'
8691 linkage names. This must be done using the DIE's children rather
8692 than the children of any DW_AT_specification target. We only need
8693 to do this for structures at the top level, i.e. if the target of
8694 any DW_AT_specification (if any; otherwise the DIE itself) does not
8697 /* Compute the scope prefix associated with PDI's parent, in
8698 compilation unit CU. The result will be allocated on CU's
8699 comp_unit_obstack, or a copy of the already allocated PDI->NAME
8700 field. NULL is returned if no prefix is necessary. */
8702 partial_die_parent_scope (struct partial_die_info *pdi,
8703 struct dwarf2_cu *cu)
8705 const char *grandparent_scope;
8706 struct partial_die_info *parent, *real_pdi;
8708 /* We need to look at our parent DIE; if we have a DW_AT_specification,
8709 then this means the parent of the specification DIE. */
8712 while (real_pdi->has_specification)
8714 auto res = find_partial_die (real_pdi->spec_offset,
8715 real_pdi->spec_is_dwz, cu);
8720 parent = real_pdi->die_parent;
8724 if (parent->scope_set)
8725 return parent->scope;
8729 grandparent_scope = partial_die_parent_scope (parent, cu);
8731 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8732 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8733 Work around this problem here. */
8734 if (cu->language == language_cplus
8735 && parent->tag == DW_TAG_namespace
8736 && strcmp (parent->name, "::") == 0
8737 && grandparent_scope == NULL)
8739 parent->scope = NULL;
8740 parent->scope_set = 1;
8744 if (pdi->tag == DW_TAG_enumerator)
8745 /* Enumerators should not get the name of the enumeration as a prefix. */
8746 parent->scope = grandparent_scope;
8747 else if (parent->tag == DW_TAG_namespace
8748 || parent->tag == DW_TAG_module
8749 || parent->tag == DW_TAG_structure_type
8750 || parent->tag == DW_TAG_class_type
8751 || parent->tag == DW_TAG_interface_type
8752 || parent->tag == DW_TAG_union_type
8753 || parent->tag == DW_TAG_enumeration_type)
8755 if (grandparent_scope == NULL)
8756 parent->scope = parent->name;
8758 parent->scope = typename_concat (&cu->comp_unit_obstack,
8760 parent->name, 0, cu);
8764 /* FIXME drow/2004-04-01: What should we be doing with
8765 function-local names? For partial symbols, we should probably be
8767 complaint (_("unhandled containing DIE tag %s for DIE at %s"),
8768 dwarf_tag_name (parent->tag),
8769 sect_offset_str (pdi->sect_off));
8770 parent->scope = grandparent_scope;
8773 parent->scope_set = 1;
8774 return parent->scope;
8777 /* Return the fully scoped name associated with PDI, from compilation unit
8778 CU. The result will be allocated with malloc. */
8781 partial_die_full_name (struct partial_die_info *pdi,
8782 struct dwarf2_cu *cu)
8784 const char *parent_scope;
8786 /* If this is a template instantiation, we can not work out the
8787 template arguments from partial DIEs. So, unfortunately, we have
8788 to go through the full DIEs. At least any work we do building
8789 types here will be reused if full symbols are loaded later. */
8790 if (pdi->has_template_arguments)
8794 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
8796 struct die_info *die;
8797 struct attribute attr;
8798 struct dwarf2_cu *ref_cu = cu;
8800 /* DW_FORM_ref_addr is using section offset. */
8801 attr.name = (enum dwarf_attribute) 0;
8802 attr.form = DW_FORM_ref_addr;
8803 attr.u.unsnd = to_underlying (pdi->sect_off);
8804 die = follow_die_ref (NULL, &attr, &ref_cu);
8806 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
8810 parent_scope = partial_die_parent_scope (pdi, cu);
8811 if (parent_scope == NULL)
8814 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
8818 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
8820 struct dwarf2_per_objfile *dwarf2_per_objfile
8821 = cu->per_cu->dwarf2_per_objfile;
8822 struct objfile *objfile = dwarf2_per_objfile->objfile;
8823 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8825 const char *actual_name = NULL;
8827 char *built_actual_name;
8829 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8831 built_actual_name = partial_die_full_name (pdi, cu);
8832 if (built_actual_name != NULL)
8833 actual_name = built_actual_name;
8835 if (actual_name == NULL)
8836 actual_name = pdi->name;
8840 case DW_TAG_inlined_subroutine:
8841 case DW_TAG_subprogram:
8842 addr = (gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr)
8844 if (pdi->is_external || cu->language == language_ada)
8846 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8847 of the global scope. But in Ada, we want to be able to access
8848 nested procedures globally. So all Ada subprograms are stored
8849 in the global scope. */
8850 add_psymbol_to_list (actual_name, strlen (actual_name),
8851 built_actual_name != NULL,
8852 VAR_DOMAIN, LOC_BLOCK,
8853 SECT_OFF_TEXT (objfile),
8854 psymbol_placement::GLOBAL,
8856 cu->language, objfile);
8860 add_psymbol_to_list (actual_name, strlen (actual_name),
8861 built_actual_name != NULL,
8862 VAR_DOMAIN, LOC_BLOCK,
8863 SECT_OFF_TEXT (objfile),
8864 psymbol_placement::STATIC,
8865 addr, cu->language, objfile);
8868 if (pdi->main_subprogram && actual_name != NULL)
8869 set_objfile_main_name (objfile, actual_name, cu->language);
8871 case DW_TAG_constant:
8872 add_psymbol_to_list (actual_name, strlen (actual_name),
8873 built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
8874 -1, (pdi->is_external
8875 ? psymbol_placement::GLOBAL
8876 : psymbol_placement::STATIC),
8877 0, cu->language, objfile);
8879 case DW_TAG_variable:
8881 addr = decode_locdesc (pdi->d.locdesc, cu);
8885 && !dwarf2_per_objfile->has_section_at_zero)
8887 /* A global or static variable may also have been stripped
8888 out by the linker if unused, in which case its address
8889 will be nullified; do not add such variables into partial
8890 symbol table then. */
8892 else if (pdi->is_external)
8895 Don't enter into the minimal symbol tables as there is
8896 a minimal symbol table entry from the ELF symbols already.
8897 Enter into partial symbol table if it has a location
8898 descriptor or a type.
8899 If the location descriptor is missing, new_symbol will create
8900 a LOC_UNRESOLVED symbol, the address of the variable will then
8901 be determined from the minimal symbol table whenever the variable
8903 The address for the partial symbol table entry is not
8904 used by GDB, but it comes in handy for debugging partial symbol
8907 if (pdi->d.locdesc || pdi->has_type)
8908 add_psymbol_to_list (actual_name, strlen (actual_name),
8909 built_actual_name != NULL,
8910 VAR_DOMAIN, LOC_STATIC,
8911 SECT_OFF_TEXT (objfile),
8912 psymbol_placement::GLOBAL,
8913 addr, cu->language, objfile);
8917 int has_loc = pdi->d.locdesc != NULL;
8919 /* Static Variable. Skip symbols whose value we cannot know (those
8920 without location descriptors or constant values). */
8921 if (!has_loc && !pdi->has_const_value)
8923 xfree (built_actual_name);
8927 add_psymbol_to_list (actual_name, strlen (actual_name),
8928 built_actual_name != NULL,
8929 VAR_DOMAIN, LOC_STATIC,
8930 SECT_OFF_TEXT (objfile),
8931 psymbol_placement::STATIC,
8933 cu->language, objfile);
8936 case DW_TAG_typedef:
8937 case DW_TAG_base_type:
8938 case DW_TAG_subrange_type:
8939 add_psymbol_to_list (actual_name, strlen (actual_name),
8940 built_actual_name != NULL,
8941 VAR_DOMAIN, LOC_TYPEDEF, -1,
8942 psymbol_placement::STATIC,
8943 0, cu->language, objfile);
8945 case DW_TAG_imported_declaration:
8946 case DW_TAG_namespace:
8947 add_psymbol_to_list (actual_name, strlen (actual_name),
8948 built_actual_name != NULL,
8949 VAR_DOMAIN, LOC_TYPEDEF, -1,
8950 psymbol_placement::GLOBAL,
8951 0, cu->language, objfile);
8954 /* With Fortran 77 there might be a "BLOCK DATA" module
8955 available without any name. If so, we skip the module as it
8956 doesn't bring any value. */
8957 if (actual_name != nullptr)
8958 add_psymbol_to_list (actual_name, strlen (actual_name),
8959 built_actual_name != NULL,
8960 MODULE_DOMAIN, LOC_TYPEDEF, -1,
8961 psymbol_placement::GLOBAL,
8962 0, cu->language, objfile);
8964 case DW_TAG_class_type:
8965 case DW_TAG_interface_type:
8966 case DW_TAG_structure_type:
8967 case DW_TAG_union_type:
8968 case DW_TAG_enumeration_type:
8969 /* Skip external references. The DWARF standard says in the section
8970 about "Structure, Union, and Class Type Entries": "An incomplete
8971 structure, union or class type is represented by a structure,
8972 union or class entry that does not have a byte size attribute
8973 and that has a DW_AT_declaration attribute." */
8974 if (!pdi->has_byte_size && pdi->is_declaration)
8976 xfree (built_actual_name);
8980 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
8981 static vs. global. */
8982 add_psymbol_to_list (actual_name, strlen (actual_name),
8983 built_actual_name != NULL,
8984 STRUCT_DOMAIN, LOC_TYPEDEF, -1,
8985 cu->language == language_cplus
8986 ? psymbol_placement::GLOBAL
8987 : psymbol_placement::STATIC,
8988 0, cu->language, objfile);
8991 case DW_TAG_enumerator:
8992 add_psymbol_to_list (actual_name, strlen (actual_name),
8993 built_actual_name != NULL,
8994 VAR_DOMAIN, LOC_CONST, -1,
8995 cu->language == language_cplus
8996 ? psymbol_placement::GLOBAL
8997 : psymbol_placement::STATIC,
8998 0, cu->language, objfile);
9004 xfree (built_actual_name);
9007 /* Read a partial die corresponding to a namespace; also, add a symbol
9008 corresponding to that namespace to the symbol table. NAMESPACE is
9009 the name of the enclosing namespace. */
9012 add_partial_namespace (struct partial_die_info *pdi,
9013 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9014 int set_addrmap, struct dwarf2_cu *cu)
9016 /* Add a symbol for the namespace. */
9018 add_partial_symbol (pdi, cu);
9020 /* Now scan partial symbols in that namespace. */
9022 if (pdi->has_children)
9023 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9026 /* Read a partial die corresponding to a Fortran module. */
9029 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
9030 CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
9032 /* Add a symbol for the namespace. */
9034 add_partial_symbol (pdi, cu);
9036 /* Now scan partial symbols in that module. */
9038 if (pdi->has_children)
9039 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9042 /* Read a partial die corresponding to a subprogram or an inlined
9043 subprogram and create a partial symbol for that subprogram.
9044 When the CU language allows it, this routine also defines a partial
9045 symbol for each nested subprogram that this subprogram contains.
9046 If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9047 Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9049 PDI may also be a lexical block, in which case we simply search
9050 recursively for subprograms defined inside that lexical block.
9051 Again, this is only performed when the CU language allows this
9052 type of definitions. */
9055 add_partial_subprogram (struct partial_die_info *pdi,
9056 CORE_ADDR *lowpc, CORE_ADDR *highpc,
9057 int set_addrmap, struct dwarf2_cu *cu)
9059 if (pdi->tag == DW_TAG_subprogram || pdi->tag == DW_TAG_inlined_subroutine)
9061 if (pdi->has_pc_info)
9063 if (pdi->lowpc < *lowpc)
9064 *lowpc = pdi->lowpc;
9065 if (pdi->highpc > *highpc)
9066 *highpc = pdi->highpc;
9069 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9070 struct gdbarch *gdbarch = get_objfile_arch (objfile);
9072 CORE_ADDR this_highpc;
9073 CORE_ADDR this_lowpc;
9075 baseaddr = ANOFFSET (objfile->section_offsets,
9076 SECT_OFF_TEXT (objfile));
9078 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9079 pdi->lowpc + baseaddr)
9082 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9083 pdi->highpc + baseaddr)
9085 addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
9086 this_lowpc, this_highpc - 1,
9087 cu->per_cu->v.psymtab);
9091 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
9093 if (!pdi->is_declaration)
9094 /* Ignore subprogram DIEs that do not have a name, they are
9095 illegal. Do not emit a complaint at this point, we will
9096 do so when we convert this psymtab into a symtab. */
9098 add_partial_symbol (pdi, cu);
9102 if (! pdi->has_children)
9105 if (cu->language == language_ada)
9107 pdi = pdi->die_child;
9111 if (pdi->tag == DW_TAG_subprogram
9112 || pdi->tag == DW_TAG_inlined_subroutine
9113 || pdi->tag == DW_TAG_lexical_block)
9114 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
9115 pdi = pdi->die_sibling;
9120 /* Read a partial die corresponding to an enumeration type. */
9123 add_partial_enumeration (struct partial_die_info *enum_pdi,
9124 struct dwarf2_cu *cu)
9126 struct partial_die_info *pdi;
9128 if (enum_pdi->name != NULL)
9129 add_partial_symbol (enum_pdi, cu);
9131 pdi = enum_pdi->die_child;
9134 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
9135 complaint (_("malformed enumerator DIE ignored"));
9137 add_partial_symbol (pdi, cu);
9138 pdi = pdi->die_sibling;
9142 /* Return the initial uleb128 in the die at INFO_PTR. */
9145 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
9147 unsigned int bytes_read;
9149 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9152 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9153 READER::CU. Use READER::ABBREV_TABLE to lookup any abbreviation.
9155 Return the corresponding abbrev, or NULL if the number is zero (indicating
9156 an empty DIE). In either case *BYTES_READ will be set to the length of
9157 the initial number. */
9159 static struct abbrev_info *
9160 peek_die_abbrev (const die_reader_specs &reader,
9161 const gdb_byte *info_ptr, unsigned int *bytes_read)
9163 dwarf2_cu *cu = reader.cu;
9164 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
9165 unsigned int abbrev_number
9166 = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
9168 if (abbrev_number == 0)
9171 abbrev_info *abbrev = reader.abbrev_table->lookup_abbrev (abbrev_number);
9174 error (_("Dwarf Error: Could not find abbrev number %d in %s"
9175 " at offset %s [in module %s]"),
9176 abbrev_number, cu->per_cu->is_debug_types ? "TU" : "CU",
9177 sect_offset_str (cu->header.sect_off), bfd_get_filename (abfd));
9183 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9184 Returns a pointer to the end of a series of DIEs, terminated by an empty
9185 DIE. Any children of the skipped DIEs will also be skipped. */
9187 static const gdb_byte *
9188 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
9192 unsigned int bytes_read;
9193 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
9196 return info_ptr + bytes_read;
9198 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
9202 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9203 INFO_PTR should point just after the initial uleb128 of a DIE, and the
9204 abbrev corresponding to that skipped uleb128 should be passed in
9205 ABBREV. Returns a pointer to this DIE's sibling, skipping any
9208 static const gdb_byte *
9209 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
9210 struct abbrev_info *abbrev)
9212 unsigned int bytes_read;
9213 struct attribute attr;
9214 bfd *abfd = reader->abfd;
9215 struct dwarf2_cu *cu = reader->cu;
9216 const gdb_byte *buffer = reader->buffer;
9217 const gdb_byte *buffer_end = reader->buffer_end;
9218 unsigned int form, i;
9220 for (i = 0; i < abbrev->num_attrs; i++)
9222 /* The only abbrev we care about is DW_AT_sibling. */
9223 if (abbrev->attrs[i].name == DW_AT_sibling)
9225 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
9226 if (attr.form == DW_FORM_ref_addr)
9227 complaint (_("ignoring absolute DW_AT_sibling"));
9230 sect_offset off = dwarf2_get_ref_die_offset (&attr);
9231 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
9233 if (sibling_ptr < info_ptr)
9234 complaint (_("DW_AT_sibling points backwards"));
9235 else if (sibling_ptr > reader->buffer_end)
9236 dwarf2_section_buffer_overflow_complaint (reader->die_section);
9242 /* If it isn't DW_AT_sibling, skip this attribute. */
9243 form = abbrev->attrs[i].form;
9247 case DW_FORM_ref_addr:
9248 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9249 and later it is offset sized. */
9250 if (cu->header.version == 2)
9251 info_ptr += cu->header.addr_size;
9253 info_ptr += cu->header.offset_size;
9255 case DW_FORM_GNU_ref_alt:
9256 info_ptr += cu->header.offset_size;
9259 info_ptr += cu->header.addr_size;
9266 case DW_FORM_flag_present:
9267 case DW_FORM_implicit_const:
9279 case DW_FORM_ref_sig8:
9282 case DW_FORM_data16:
9285 case DW_FORM_string:
9286 read_direct_string (abfd, info_ptr, &bytes_read);
9287 info_ptr += bytes_read;
9289 case DW_FORM_sec_offset:
9291 case DW_FORM_GNU_strp_alt:
9292 info_ptr += cu->header.offset_size;
9294 case DW_FORM_exprloc:
9296 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9297 info_ptr += bytes_read;
9299 case DW_FORM_block1:
9300 info_ptr += 1 + read_1_byte (abfd, info_ptr);
9302 case DW_FORM_block2:
9303 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
9305 case DW_FORM_block4:
9306 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
9312 case DW_FORM_ref_udata:
9313 case DW_FORM_GNU_addr_index:
9314 case DW_FORM_GNU_str_index:
9315 info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
9317 case DW_FORM_indirect:
9318 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9319 info_ptr += bytes_read;
9320 /* We need to continue parsing from here, so just go back to
9322 goto skip_attribute;
9325 error (_("Dwarf Error: Cannot handle %s "
9326 "in DWARF reader [in module %s]"),
9327 dwarf_form_name (form),
9328 bfd_get_filename (abfd));
9332 if (abbrev->has_children)
9333 return skip_children (reader, info_ptr);
9338 /* Locate ORIG_PDI's sibling.
9339 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
9341 static const gdb_byte *
9342 locate_pdi_sibling (const struct die_reader_specs *reader,
9343 struct partial_die_info *orig_pdi,
9344 const gdb_byte *info_ptr)
9346 /* Do we know the sibling already? */
9348 if (orig_pdi->sibling)
9349 return orig_pdi->sibling;
9351 /* Are there any children to deal with? */
9353 if (!orig_pdi->has_children)
9356 /* Skip the children the long way. */
9358 return skip_children (reader, info_ptr);
9361 /* Expand this partial symbol table into a full symbol table. SELF is
9365 dwarf2_read_symtab (struct partial_symtab *self,
9366 struct objfile *objfile)
9368 struct dwarf2_per_objfile *dwarf2_per_objfile
9369 = get_dwarf2_per_objfile (objfile);
9373 warning (_("bug: psymtab for %s is already read in."),
9380 printf_filtered (_("Reading in symbols for %s..."),
9382 gdb_flush (gdb_stdout);
9385 /* If this psymtab is constructed from a debug-only objfile, the
9386 has_section_at_zero flag will not necessarily be correct. We
9387 can get the correct value for this flag by looking at the data
9388 associated with the (presumably stripped) associated objfile. */
9389 if (objfile->separate_debug_objfile_backlink)
9391 struct dwarf2_per_objfile *dpo_backlink
9392 = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
9394 dwarf2_per_objfile->has_section_at_zero
9395 = dpo_backlink->has_section_at_zero;
9398 dwarf2_per_objfile->reading_partial_symbols = 0;
9400 psymtab_to_symtab_1 (self);
9402 /* Finish up the debug error message. */
9404 printf_filtered (_("done.\n"));
9407 process_cu_includes (dwarf2_per_objfile);
9410 /* Reading in full CUs. */
9412 /* Add PER_CU to the queue. */
9415 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
9416 enum language pretend_language)
9418 struct dwarf2_queue_item *item;
9421 item = XNEW (struct dwarf2_queue_item);
9422 item->per_cu = per_cu;
9423 item->pretend_language = pretend_language;
9426 if (dwarf2_queue == NULL)
9427 dwarf2_queue = item;
9429 dwarf2_queue_tail->next = item;
9431 dwarf2_queue_tail = item;
9434 /* If PER_CU is not yet queued, add it to the queue.
9435 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9437 The result is non-zero if PER_CU was queued, otherwise the result is zero
9438 meaning either PER_CU is already queued or it is already loaded.
9440 N.B. There is an invariant here that if a CU is queued then it is loaded.
9441 The caller is required to load PER_CU if we return non-zero. */
9444 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
9445 struct dwarf2_per_cu_data *per_cu,
9446 enum language pretend_language)
9448 /* We may arrive here during partial symbol reading, if we need full
9449 DIEs to process an unusual case (e.g. template arguments). Do
9450 not queue PER_CU, just tell our caller to load its DIEs. */
9451 if (per_cu->dwarf2_per_objfile->reading_partial_symbols)
9453 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
9458 /* Mark the dependence relation so that we don't flush PER_CU
9460 if (dependent_cu != NULL)
9461 dwarf2_add_dependence (dependent_cu, per_cu);
9463 /* If it's already on the queue, we have nothing to do. */
9467 /* If the compilation unit is already loaded, just mark it as
9469 if (per_cu->cu != NULL)
9471 per_cu->cu->last_used = 0;
9475 /* Add it to the queue. */
9476 queue_comp_unit (per_cu, pretend_language);
9481 /* Process the queue. */
9484 process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
9486 struct dwarf2_queue_item *item, *next_item;
9488 if (dwarf_read_debug)
9490 fprintf_unfiltered (gdb_stdlog,
9491 "Expanding one or more symtabs of objfile %s ...\n",
9492 objfile_name (dwarf2_per_objfile->objfile));
9495 /* The queue starts out with one item, but following a DIE reference
9496 may load a new CU, adding it to the end of the queue. */
9497 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
9499 if ((dwarf2_per_objfile->using_index
9500 ? !item->per_cu->v.quick->compunit_symtab
9501 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
9502 /* Skip dummy CUs. */
9503 && item->per_cu->cu != NULL)
9505 struct dwarf2_per_cu_data *per_cu = item->per_cu;
9506 unsigned int debug_print_threshold;
9509 if (per_cu->is_debug_types)
9511 struct signatured_type *sig_type =
9512 (struct signatured_type *) per_cu;
9514 sprintf (buf, "TU %s at offset %s",
9515 hex_string (sig_type->signature),
9516 sect_offset_str (per_cu->sect_off));
9517 /* There can be 100s of TUs.
9518 Only print them in verbose mode. */
9519 debug_print_threshold = 2;
9523 sprintf (buf, "CU at offset %s",
9524 sect_offset_str (per_cu->sect_off));
9525 debug_print_threshold = 1;
9528 if (dwarf_read_debug >= debug_print_threshold)
9529 fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
9531 if (per_cu->is_debug_types)
9532 process_full_type_unit (per_cu, item->pretend_language);
9534 process_full_comp_unit (per_cu, item->pretend_language);
9536 if (dwarf_read_debug >= debug_print_threshold)
9537 fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
9540 item->per_cu->queued = 0;
9541 next_item = item->next;
9545 dwarf2_queue_tail = NULL;
9547 if (dwarf_read_debug)
9549 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
9550 objfile_name (dwarf2_per_objfile->objfile));
9554 /* Read in full symbols for PST, and anything it depends on. */
9557 psymtab_to_symtab_1 (struct partial_symtab *pst)
9559 struct dwarf2_per_cu_data *per_cu;
9565 for (i = 0; i < pst->number_of_dependencies; i++)
9566 if (!pst->dependencies[i]->readin
9567 && pst->dependencies[i]->user == NULL)
9569 /* Inform about additional files that need to be read in. */
9572 /* FIXME: i18n: Need to make this a single string. */
9573 fputs_filtered (" ", gdb_stdout);
9575 fputs_filtered ("and ", gdb_stdout);
9577 printf_filtered ("%s...", pst->dependencies[i]->filename);
9578 wrap_here (""); /* Flush output. */
9579 gdb_flush (gdb_stdout);
9581 psymtab_to_symtab_1 (pst->dependencies[i]);
9584 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
9588 /* It's an include file, no symbols to read for it.
9589 Everything is in the parent symtab. */
9594 dw2_do_instantiate_symtab (per_cu, false);
9597 /* Trivial hash function for die_info: the hash value of a DIE
9598 is its offset in .debug_info for this objfile. */
9601 die_hash (const void *item)
9603 const struct die_info *die = (const struct die_info *) item;
9605 return to_underlying (die->sect_off);
9608 /* Trivial comparison function for die_info structures: two DIEs
9609 are equal if they have the same offset. */
9612 die_eq (const void *item_lhs, const void *item_rhs)
9614 const struct die_info *die_lhs = (const struct die_info *) item_lhs;
9615 const struct die_info *die_rhs = (const struct die_info *) item_rhs;
9617 return die_lhs->sect_off == die_rhs->sect_off;
9620 /* die_reader_func for load_full_comp_unit.
9621 This is identical to read_signatured_type_reader,
9622 but is kept separate for now. */
9625 load_full_comp_unit_reader (const struct die_reader_specs *reader,
9626 const gdb_byte *info_ptr,
9627 struct die_info *comp_unit_die,
9631 struct dwarf2_cu *cu = reader->cu;
9632 enum language *language_ptr = (enum language *) data;
9634 gdb_assert (cu->die_hash == NULL);
9636 htab_create_alloc_ex (cu->header.length / 12,
9640 &cu->comp_unit_obstack,
9641 hashtab_obstack_allocate,
9642 dummy_obstack_deallocate);
9645 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
9646 &info_ptr, comp_unit_die);
9647 cu->dies = comp_unit_die;
9648 /* comp_unit_die is not stored in die_hash, no need. */
9650 /* We try not to read any attributes in this function, because not
9651 all CUs needed for references have been loaded yet, and symbol
9652 table processing isn't initialized. But we have to set the CU language,
9653 or we won't be able to build types correctly.
9654 Similarly, if we do not read the producer, we can not apply
9655 producer-specific interpretation. */
9656 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
9659 /* Load the DIEs associated with PER_CU into memory. */
9662 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
9664 enum language pretend_language)
9666 gdb_assert (! this_cu->is_debug_types);
9668 init_cutu_and_read_dies (this_cu, NULL, 1, 1, skip_partial,
9669 load_full_comp_unit_reader, &pretend_language);
9672 /* Add a DIE to the delayed physname list. */
9675 add_to_method_list (struct type *type, int fnfield_index, int index,
9676 const char *name, struct die_info *die,
9677 struct dwarf2_cu *cu)
9679 struct delayed_method_info mi;
9681 mi.fnfield_index = fnfield_index;
9685 cu->method_list.push_back (mi);
9688 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9689 "const" / "volatile". If so, decrements LEN by the length of the
9690 modifier and return true. Otherwise return false. */
9694 check_modifier (const char *physname, size_t &len, const char (&mod)[N])
9696 size_t mod_len = sizeof (mod) - 1;
9697 if (len > mod_len && startswith (physname + (len - mod_len), mod))
9705 /* Compute the physnames of any methods on the CU's method list.
9707 The computation of method physnames is delayed in order to avoid the
9708 (bad) condition that one of the method's formal parameters is of an as yet
9712 compute_delayed_physnames (struct dwarf2_cu *cu)
9714 /* Only C++ delays computing physnames. */
9715 if (cu->method_list.empty ())
9717 gdb_assert (cu->language == language_cplus);
9719 for (const delayed_method_info &mi : cu->method_list)
9721 const char *physname;
9722 struct fn_fieldlist *fn_flp
9723 = &TYPE_FN_FIELDLIST (mi.type, mi.fnfield_index);
9724 physname = dwarf2_physname (mi.name, mi.die, cu);
9725 TYPE_FN_FIELD_PHYSNAME (fn_flp->fn_fields, mi.index)
9726 = physname ? physname : "";
9728 /* Since there's no tag to indicate whether a method is a
9729 const/volatile overload, extract that information out of the
9731 if (physname != NULL)
9733 size_t len = strlen (physname);
9737 if (physname[len] == ')') /* shortcut */
9739 else if (check_modifier (physname, len, " const"))
9740 TYPE_FN_FIELD_CONST (fn_flp->fn_fields, mi.index) = 1;
9741 else if (check_modifier (physname, len, " volatile"))
9742 TYPE_FN_FIELD_VOLATILE (fn_flp->fn_fields, mi.index) = 1;
9749 /* The list is no longer needed. */
9750 cu->method_list.clear ();
9753 /* Go objects should be embedded in a DW_TAG_module DIE,
9754 and it's not clear if/how imported objects will appear.
9755 To keep Go support simple until that's worked out,
9756 go back through what we've read and create something usable.
9757 We could do this while processing each DIE, and feels kinda cleaner,
9758 but that way is more invasive.
9759 This is to, for example, allow the user to type "p var" or "b main"
9760 without having to specify the package name, and allow lookups
9761 of module.object to work in contexts that use the expression
9765 fixup_go_packaging (struct dwarf2_cu *cu)
9767 char *package_name = NULL;
9768 struct pending *list;
9771 for (list = *cu->get_builder ()->get_global_symbols ();
9775 for (i = 0; i < list->nsyms; ++i)
9777 struct symbol *sym = list->symbol[i];
9779 if (SYMBOL_LANGUAGE (sym) == language_go
9780 && SYMBOL_CLASS (sym) == LOC_BLOCK)
9782 char *this_package_name = go_symbol_package_name (sym);
9784 if (this_package_name == NULL)
9786 if (package_name == NULL)
9787 package_name = this_package_name;
9790 struct objfile *objfile
9791 = cu->per_cu->dwarf2_per_objfile->objfile;
9792 if (strcmp (package_name, this_package_name) != 0)
9793 complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9794 (symbol_symtab (sym) != NULL
9795 ? symtab_to_filename_for_display
9796 (symbol_symtab (sym))
9797 : objfile_name (objfile)),
9798 this_package_name, package_name);
9799 xfree (this_package_name);
9805 if (package_name != NULL)
9807 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9808 const char *saved_package_name
9809 = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
9811 strlen (package_name));
9812 struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
9813 saved_package_name);
9816 sym = allocate_symbol (objfile);
9817 SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
9818 SYMBOL_SET_NAMES (sym, saved_package_name,
9819 strlen (saved_package_name), 0, objfile);
9820 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9821 e.g., "main" finds the "main" module and not C's main(). */
9822 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
9823 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
9824 SYMBOL_TYPE (sym) = type;
9826 add_symbol_to_list (sym, cu->get_builder ()->get_global_symbols ());
9828 xfree (package_name);
9832 /* Allocate a fully-qualified name consisting of the two parts on the
9836 rust_fully_qualify (struct obstack *obstack, const char *p1, const char *p2)
9838 return obconcat (obstack, p1, "::", p2, (char *) NULL);
9841 /* A helper that allocates a struct discriminant_info to attach to a
9844 static struct discriminant_info *
9845 alloc_discriminant_info (struct type *type, int discriminant_index,
9848 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9849 gdb_assert (discriminant_index == -1
9850 || (discriminant_index >= 0
9851 && discriminant_index < TYPE_NFIELDS (type)));
9852 gdb_assert (default_index == -1
9853 || (default_index >= 0 && default_index < TYPE_NFIELDS (type)));
9855 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
9857 struct discriminant_info *disc
9858 = ((struct discriminant_info *)
9860 offsetof (struct discriminant_info, discriminants)
9861 + TYPE_NFIELDS (type) * sizeof (disc->discriminants[0])));
9862 disc->default_index = default_index;
9863 disc->discriminant_index = discriminant_index;
9865 struct dynamic_prop prop;
9866 prop.kind = PROP_UNDEFINED;
9867 prop.data.baton = disc;
9869 add_dyn_prop (DYN_PROP_DISCRIMINATED, prop, type);
9874 /* Some versions of rustc emitted enums in an unusual way.
9876 Ordinary enums were emitted as unions. The first element of each
9877 structure in the union was named "RUST$ENUM$DISR". This element
9878 held the discriminant.
9880 These versions of Rust also implemented the "non-zero"
9881 optimization. When the enum had two values, and one is empty and
9882 the other holds a pointer that cannot be zero, the pointer is used
9883 as the discriminant, with a zero value meaning the empty variant.
9884 Here, the union's first member is of the form
9885 RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9886 where the fieldnos are the indices of the fields that should be
9887 traversed in order to find the field (which may be several fields deep)
9888 and the variantname is the name of the variant of the case when the
9891 This function recognizes whether TYPE is of one of these forms,
9892 and, if so, smashes it to be a variant type. */
9895 quirk_rust_enum (struct type *type, struct objfile *objfile)
9897 gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9899 /* We don't need to deal with empty enums. */
9900 if (TYPE_NFIELDS (type) == 0)
9903 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9904 if (TYPE_NFIELDS (type) == 1
9905 && startswith (TYPE_FIELD_NAME (type, 0), RUST_ENUM_PREFIX))
9907 const char *name = TYPE_FIELD_NAME (type, 0) + strlen (RUST_ENUM_PREFIX);
9909 /* Decode the field name to find the offset of the
9911 ULONGEST bit_offset = 0;
9912 struct type *field_type = TYPE_FIELD_TYPE (type, 0);
9913 while (name[0] >= '0' && name[0] <= '9')
9916 unsigned long index = strtoul (name, &tail, 10);
9919 || index >= TYPE_NFIELDS (field_type)
9920 || (TYPE_FIELD_LOC_KIND (field_type, index)
9921 != FIELD_LOC_KIND_BITPOS))
9923 complaint (_("Could not parse Rust enum encoding string \"%s\""
9925 TYPE_FIELD_NAME (type, 0),
9926 objfile_name (objfile));
9931 bit_offset += TYPE_FIELD_BITPOS (field_type, index);
9932 field_type = TYPE_FIELD_TYPE (field_type, index);
9935 /* Make a union to hold the variants. */
9936 struct type *union_type = alloc_type (objfile);
9937 TYPE_CODE (union_type) = TYPE_CODE_UNION;
9938 TYPE_NFIELDS (union_type) = 3;
9939 TYPE_FIELDS (union_type)
9940 = (struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field));
9941 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
9942 set_type_align (union_type, TYPE_RAW_ALIGN (type));
9944 /* Put the discriminant must at index 0. */
9945 TYPE_FIELD_TYPE (union_type, 0) = field_type;
9946 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
9947 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
9948 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 0), bit_offset);
9950 /* The order of fields doesn't really matter, so put the real
9951 field at index 1 and the data-less field at index 2. */
9952 struct discriminant_info *disc
9953 = alloc_discriminant_info (union_type, 0, 1);
9954 TYPE_FIELD (union_type, 1) = TYPE_FIELD (type, 0);
9955 TYPE_FIELD_NAME (union_type, 1)
9956 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1)));
9957 TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1))
9958 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
9959 TYPE_FIELD_NAME (union_type, 1));
9961 const char *dataless_name
9962 = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
9964 struct type *dataless_type = init_type (objfile, TYPE_CODE_VOID, 0,
9966 TYPE_FIELD_TYPE (union_type, 2) = dataless_type;
9967 /* NAME points into the original discriminant name, which
9968 already has the correct lifetime. */
9969 TYPE_FIELD_NAME (union_type, 2) = name;
9970 SET_FIELD_BITPOS (TYPE_FIELD (union_type, 2), 0);
9971 disc->discriminants[2] = 0;
9973 /* Smash this type to be a structure type. We have to do this
9974 because the type has already been recorded. */
9975 TYPE_CODE (type) = TYPE_CODE_STRUCT;
9976 TYPE_NFIELDS (type) = 1;
9978 = (struct field *) TYPE_ZALLOC (type, sizeof (struct field));
9980 /* Install the variant part. */
9981 TYPE_FIELD_TYPE (type, 0) = union_type;
9982 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
9983 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
9985 else if (TYPE_NFIELDS (type) == 1)
9987 /* We assume that a union with a single field is a univariant
9989 /* Smash this type to be a structure type. We have to do this
9990 because the type has already been recorded. */
9991 TYPE_CODE (type) = TYPE_CODE_STRUCT;
9993 /* Make a union to hold the variants. */
9994 struct type *union_type = alloc_type (objfile);
9995 TYPE_CODE (union_type) = TYPE_CODE_UNION;
9996 TYPE_NFIELDS (union_type) = TYPE_NFIELDS (type);
9997 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
9998 set_type_align (union_type, TYPE_RAW_ALIGN (type));
9999 TYPE_FIELDS (union_type) = TYPE_FIELDS (type);
10001 struct type *field_type = TYPE_FIELD_TYPE (union_type, 0);
10002 const char *variant_name
10003 = rust_last_path_segment (TYPE_NAME (field_type));
10004 TYPE_FIELD_NAME (union_type, 0) = variant_name;
10005 TYPE_NAME (field_type)
10006 = rust_fully_qualify (&objfile->objfile_obstack,
10007 TYPE_NAME (type), variant_name);
10009 /* Install the union in the outer struct type. */
10010 TYPE_NFIELDS (type) = 1;
10012 = (struct field *) TYPE_ZALLOC (union_type, sizeof (struct field));
10013 TYPE_FIELD_TYPE (type, 0) = union_type;
10014 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10015 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10017 alloc_discriminant_info (union_type, -1, 0);
10021 struct type *disr_type = nullptr;
10022 for (int i = 0; i < TYPE_NFIELDS (type); ++i)
10024 disr_type = TYPE_FIELD_TYPE (type, i);
10026 if (TYPE_CODE (disr_type) != TYPE_CODE_STRUCT)
10028 /* All fields of a true enum will be structs. */
10031 else if (TYPE_NFIELDS (disr_type) == 0)
10033 /* Could be data-less variant, so keep going. */
10034 disr_type = nullptr;
10036 else if (strcmp (TYPE_FIELD_NAME (disr_type, 0),
10037 "RUST$ENUM$DISR") != 0)
10039 /* Not a Rust enum. */
10049 /* If we got here without a discriminant, then it's probably
10051 if (disr_type == nullptr)
10054 /* Smash this type to be a structure type. We have to do this
10055 because the type has already been recorded. */
10056 TYPE_CODE (type) = TYPE_CODE_STRUCT;
10058 /* Make a union to hold the variants. */
10059 struct field *disr_field = &TYPE_FIELD (disr_type, 0);
10060 struct type *union_type = alloc_type (objfile);
10061 TYPE_CODE (union_type) = TYPE_CODE_UNION;
10062 TYPE_NFIELDS (union_type) = 1 + TYPE_NFIELDS (type);
10063 TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10064 set_type_align (union_type, TYPE_RAW_ALIGN (type));
10065 TYPE_FIELDS (union_type)
10066 = (struct field *) TYPE_ZALLOC (union_type,
10067 (TYPE_NFIELDS (union_type)
10068 * sizeof (struct field)));
10070 memcpy (TYPE_FIELDS (union_type) + 1, TYPE_FIELDS (type),
10071 TYPE_NFIELDS (type) * sizeof (struct field));
10073 /* Install the discriminant at index 0 in the union. */
10074 TYPE_FIELD (union_type, 0) = *disr_field;
10075 TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10076 TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10078 /* Install the union in the outer struct type. */
10079 TYPE_FIELD_TYPE (type, 0) = union_type;
10080 TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10081 TYPE_NFIELDS (type) = 1;
10083 /* Set the size and offset of the union type. */
10084 SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10086 /* We need a way to find the correct discriminant given a
10087 variant name. For convenience we build a map here. */
10088 struct type *enum_type = FIELD_TYPE (*disr_field);
10089 std::unordered_map<std::string, ULONGEST> discriminant_map;
10090 for (int i = 0; i < TYPE_NFIELDS (enum_type); ++i)
10092 if (TYPE_FIELD_LOC_KIND (enum_type, i) == FIELD_LOC_KIND_ENUMVAL)
10095 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type, i));
10096 discriminant_map[name] = TYPE_FIELD_ENUMVAL (enum_type, i);
10100 int n_fields = TYPE_NFIELDS (union_type);
10101 struct discriminant_info *disc
10102 = alloc_discriminant_info (union_type, 0, -1);
10103 /* Skip the discriminant here. */
10104 for (int i = 1; i < n_fields; ++i)
10106 /* Find the final word in the name of this variant's type.
10107 That name can be used to look up the correct
10109 const char *variant_name
10110 = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type,
10113 auto iter = discriminant_map.find (variant_name);
10114 if (iter != discriminant_map.end ())
10115 disc->discriminants[i] = iter->second;
10117 /* Remove the discriminant field, if it exists. */
10118 struct type *sub_type = TYPE_FIELD_TYPE (union_type, i);
10119 if (TYPE_NFIELDS (sub_type) > 0)
10121 --TYPE_NFIELDS (sub_type);
10122 ++TYPE_FIELDS (sub_type);
10124 TYPE_FIELD_NAME (union_type, i) = variant_name;
10125 TYPE_NAME (sub_type)
10126 = rust_fully_qualify (&objfile->objfile_obstack,
10127 TYPE_NAME (type), variant_name);
10132 /* Rewrite some Rust unions to be structures with variants parts. */
10135 rust_union_quirks (struct dwarf2_cu *cu)
10137 gdb_assert (cu->language == language_rust);
10138 for (type *type_ : cu->rust_unions)
10139 quirk_rust_enum (type_, cu->per_cu->dwarf2_per_objfile->objfile);
10140 /* We don't need this any more. */
10141 cu->rust_unions.clear ();
10144 /* Return the symtab for PER_CU. This works properly regardless of
10145 whether we're using the index or psymtabs. */
10147 static struct compunit_symtab *
10148 get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
10150 return (per_cu->dwarf2_per_objfile->using_index
10151 ? per_cu->v.quick->compunit_symtab
10152 : per_cu->v.psymtab->compunit_symtab);
10155 /* A helper function for computing the list of all symbol tables
10156 included by PER_CU. */
10159 recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
10160 htab_t all_children, htab_t all_type_symtabs,
10161 struct dwarf2_per_cu_data *per_cu,
10162 struct compunit_symtab *immediate_parent)
10166 struct compunit_symtab *cust;
10167 struct dwarf2_per_cu_data *iter;
10169 slot = htab_find_slot (all_children, per_cu, INSERT);
10172 /* This inclusion and its children have been processed. */
10177 /* Only add a CU if it has a symbol table. */
10178 cust = get_compunit_symtab (per_cu);
10181 /* If this is a type unit only add its symbol table if we haven't
10182 seen it yet (type unit per_cu's can share symtabs). */
10183 if (per_cu->is_debug_types)
10185 slot = htab_find_slot (all_type_symtabs, cust, INSERT);
10189 result->push_back (cust);
10190 if (cust->user == NULL)
10191 cust->user = immediate_parent;
10196 result->push_back (cust);
10197 if (cust->user == NULL)
10198 cust->user = immediate_parent;
10203 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
10206 recursively_compute_inclusions (result, all_children,
10207 all_type_symtabs, iter, cust);
10211 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10215 compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
10217 gdb_assert (! per_cu->is_debug_types);
10219 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
10222 struct dwarf2_per_cu_data *per_cu_iter;
10223 std::vector<compunit_symtab *> result_symtabs;
10224 htab_t all_children, all_type_symtabs;
10225 struct compunit_symtab *cust = get_compunit_symtab (per_cu);
10227 /* If we don't have a symtab, we can just skip this case. */
10231 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10232 NULL, xcalloc, xfree);
10233 all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10234 NULL, xcalloc, xfree);
10237 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
10241 recursively_compute_inclusions (&result_symtabs, all_children,
10242 all_type_symtabs, per_cu_iter,
10246 /* Now we have a transitive closure of all the included symtabs. */
10247 len = result_symtabs.size ();
10249 = XOBNEWVEC (&per_cu->dwarf2_per_objfile->objfile->objfile_obstack,
10250 struct compunit_symtab *, len + 1);
10251 memcpy (cust->includes, result_symtabs.data (),
10252 len * sizeof (compunit_symtab *));
10253 cust->includes[len] = NULL;
10255 htab_delete (all_children);
10256 htab_delete (all_type_symtabs);
10260 /* Compute the 'includes' field for the symtabs of all the CUs we just
10264 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
10266 for (dwarf2_per_cu_data *iter : dwarf2_per_objfile->just_read_cus)
10268 if (! iter->is_debug_types)
10269 compute_compunit_symtab_includes (iter);
10272 dwarf2_per_objfile->just_read_cus.clear ();
10275 /* Generate full symbol information for PER_CU, whose DIEs have
10276 already been loaded into memory. */
10279 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
10280 enum language pretend_language)
10282 struct dwarf2_cu *cu = per_cu->cu;
10283 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10284 struct objfile *objfile = dwarf2_per_objfile->objfile;
10285 struct gdbarch *gdbarch = get_objfile_arch (objfile);
10286 CORE_ADDR lowpc, highpc;
10287 struct compunit_symtab *cust;
10288 CORE_ADDR baseaddr;
10289 struct block *static_block;
10292 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
10294 /* Clear the list here in case something was left over. */
10295 cu->method_list.clear ();
10297 cu->language = pretend_language;
10298 cu->language_defn = language_def (cu->language);
10300 /* Do line number decoding in read_file_scope () */
10301 process_die (cu->dies, cu);
10303 /* For now fudge the Go package. */
10304 if (cu->language == language_go)
10305 fixup_go_packaging (cu);
10307 /* Now that we have processed all the DIEs in the CU, all the types
10308 should be complete, and it should now be safe to compute all of the
10310 compute_delayed_physnames (cu);
10312 if (cu->language == language_rust)
10313 rust_union_quirks (cu);
10315 /* Some compilers don't define a DW_AT_high_pc attribute for the
10316 compilation unit. If the DW_AT_high_pc is missing, synthesize
10317 it, by scanning the DIE's below the compilation unit. */
10318 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
10320 addr = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
10321 static_block = cu->get_builder ()->end_symtab_get_static_block (addr, 0, 1);
10323 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10324 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10325 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
10326 addrmap to help ensure it has an accurate map of pc values belonging to
10328 dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
10330 cust = cu->get_builder ()->end_symtab_from_static_block (static_block,
10331 SECT_OFF_TEXT (objfile),
10336 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
10338 /* Set symtab language to language from DW_AT_language. If the
10339 compilation is from a C file generated by language preprocessors, do
10340 not set the language if it was already deduced by start_subfile. */
10341 if (!(cu->language == language_c
10342 && COMPUNIT_FILETABS (cust)->language != language_unknown))
10343 COMPUNIT_FILETABS (cust)->language = cu->language;
10345 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
10346 produce DW_AT_location with location lists but it can be possibly
10347 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
10348 there were bugs in prologue debug info, fixed later in GCC-4.5
10349 by "unwind info for epilogues" patch (which is not directly related).
10351 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10352 needed, it would be wrong due to missing DW_AT_producer there.
10354 Still one can confuse GDB by using non-standard GCC compilation
10355 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10357 if (cu->has_loclist && gcc_4_minor >= 5)
10358 cust->locations_valid = 1;
10360 if (gcc_4_minor >= 5)
10361 cust->epilogue_unwind_valid = 1;
10363 cust->call_site_htab = cu->call_site_htab;
10366 if (dwarf2_per_objfile->using_index)
10367 per_cu->v.quick->compunit_symtab = cust;
10370 struct partial_symtab *pst = per_cu->v.psymtab;
10371 pst->compunit_symtab = cust;
10375 /* Push it for inclusion processing later. */
10376 dwarf2_per_objfile->just_read_cus.push_back (per_cu);
10378 /* Not needed any more. */
10379 cu->reset_builder ();
10382 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10383 already been loaded into memory. */
10386 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
10387 enum language pretend_language)
10389 struct dwarf2_cu *cu = per_cu->cu;
10390 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10391 struct objfile *objfile = dwarf2_per_objfile->objfile;
10392 struct compunit_symtab *cust;
10393 struct signatured_type *sig_type;
10395 gdb_assert (per_cu->is_debug_types);
10396 sig_type = (struct signatured_type *) per_cu;
10398 /* Clear the list here in case something was left over. */
10399 cu->method_list.clear ();
10401 cu->language = pretend_language;
10402 cu->language_defn = language_def (cu->language);
10404 /* The symbol tables are set up in read_type_unit_scope. */
10405 process_die (cu->dies, cu);
10407 /* For now fudge the Go package. */
10408 if (cu->language == language_go)
10409 fixup_go_packaging (cu);
10411 /* Now that we have processed all the DIEs in the CU, all the types
10412 should be complete, and it should now be safe to compute all of the
10414 compute_delayed_physnames (cu);
10416 if (cu->language == language_rust)
10417 rust_union_quirks (cu);
10419 /* TUs share symbol tables.
10420 If this is the first TU to use this symtab, complete the construction
10421 of it with end_expandable_symtab. Otherwise, complete the addition of
10422 this TU's symbols to the existing symtab. */
10423 if (sig_type->type_unit_group->compunit_symtab == NULL)
10425 buildsym_compunit *builder = cu->get_builder ();
10426 cust = builder->end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
10427 sig_type->type_unit_group->compunit_symtab = cust;
10431 /* Set symtab language to language from DW_AT_language. If the
10432 compilation is from a C file generated by language preprocessors,
10433 do not set the language if it was already deduced by
10435 if (!(cu->language == language_c
10436 && COMPUNIT_FILETABS (cust)->language != language_c))
10437 COMPUNIT_FILETABS (cust)->language = cu->language;
10442 cu->get_builder ()->augment_type_symtab ();
10443 cust = sig_type->type_unit_group->compunit_symtab;
10446 if (dwarf2_per_objfile->using_index)
10447 per_cu->v.quick->compunit_symtab = cust;
10450 struct partial_symtab *pst = per_cu->v.psymtab;
10451 pst->compunit_symtab = cust;
10455 /* Not needed any more. */
10456 cu->reset_builder ();
10459 /* Process an imported unit DIE. */
10462 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
10464 struct attribute *attr;
10466 /* For now we don't handle imported units in type units. */
10467 if (cu->per_cu->is_debug_types)
10469 error (_("Dwarf Error: DW_TAG_imported_unit is not"
10470 " supported in type units [in module %s]"),
10471 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
10474 attr = dwarf2_attr (die, DW_AT_import, cu);
10477 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
10478 bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
10479 dwarf2_per_cu_data *per_cu
10480 = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
10481 cu->per_cu->dwarf2_per_objfile);
10483 /* If necessary, add it to the queue and load its DIEs. */
10484 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
10485 load_full_comp_unit (per_cu, false, cu->language);
10487 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
10492 /* RAII object that represents a process_die scope: i.e.,
10493 starts/finishes processing a DIE. */
10494 class process_die_scope
10497 process_die_scope (die_info *die, dwarf2_cu *cu)
10498 : m_die (die), m_cu (cu)
10500 /* We should only be processing DIEs not already in process. */
10501 gdb_assert (!m_die->in_process);
10502 m_die->in_process = true;
10505 ~process_die_scope ()
10507 m_die->in_process = false;
10509 /* If we're done processing the DIE for the CU that owns the line
10510 header, we don't need the line header anymore. */
10511 if (m_cu->line_header_die_owner == m_die)
10513 delete m_cu->line_header;
10514 m_cu->line_header = NULL;
10515 m_cu->line_header_die_owner = NULL;
10524 /* Process a die and its children. */
10527 process_die (struct die_info *die, struct dwarf2_cu *cu)
10529 process_die_scope scope (die, cu);
10533 case DW_TAG_padding:
10535 case DW_TAG_compile_unit:
10536 case DW_TAG_partial_unit:
10537 read_file_scope (die, cu);
10539 case DW_TAG_type_unit:
10540 read_type_unit_scope (die, cu);
10542 case DW_TAG_subprogram:
10543 case DW_TAG_inlined_subroutine:
10544 read_func_scope (die, cu);
10546 case DW_TAG_lexical_block:
10547 case DW_TAG_try_block:
10548 case DW_TAG_catch_block:
10549 read_lexical_block_scope (die, cu);
10551 case DW_TAG_call_site:
10552 case DW_TAG_GNU_call_site:
10553 read_call_site_scope (die, cu);
10555 case DW_TAG_class_type:
10556 case DW_TAG_interface_type:
10557 case DW_TAG_structure_type:
10558 case DW_TAG_union_type:
10559 process_structure_scope (die, cu);
10561 case DW_TAG_enumeration_type:
10562 process_enumeration_scope (die, cu);
10565 /* These dies have a type, but processing them does not create
10566 a symbol or recurse to process the children. Therefore we can
10567 read them on-demand through read_type_die. */
10568 case DW_TAG_subroutine_type:
10569 case DW_TAG_set_type:
10570 case DW_TAG_array_type:
10571 case DW_TAG_pointer_type:
10572 case DW_TAG_ptr_to_member_type:
10573 case DW_TAG_reference_type:
10574 case DW_TAG_rvalue_reference_type:
10575 case DW_TAG_string_type:
10578 case DW_TAG_base_type:
10579 case DW_TAG_subrange_type:
10580 case DW_TAG_typedef:
10581 /* Add a typedef symbol for the type definition, if it has a
10583 new_symbol (die, read_type_die (die, cu), cu);
10585 case DW_TAG_common_block:
10586 read_common_block (die, cu);
10588 case DW_TAG_common_inclusion:
10590 case DW_TAG_namespace:
10591 cu->processing_has_namespace_info = true;
10592 read_namespace (die, cu);
10594 case DW_TAG_module:
10595 cu->processing_has_namespace_info = true;
10596 read_module (die, cu);
10598 case DW_TAG_imported_declaration:
10599 cu->processing_has_namespace_info = true;
10600 if (read_namespace_alias (die, cu))
10602 /* The declaration is not a global namespace alias. */
10603 /* Fall through. */
10604 case DW_TAG_imported_module:
10605 cu->processing_has_namespace_info = true;
10606 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
10607 || cu->language != language_fortran))
10608 complaint (_("Tag '%s' has unexpected children"),
10609 dwarf_tag_name (die->tag));
10610 read_import_statement (die, cu);
10613 case DW_TAG_imported_unit:
10614 process_imported_unit_die (die, cu);
10617 case DW_TAG_variable:
10618 read_variable (die, cu);
10622 new_symbol (die, NULL, cu);
10627 /* DWARF name computation. */
10629 /* A helper function for dwarf2_compute_name which determines whether DIE
10630 needs to have the name of the scope prepended to the name listed in the
10634 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
10636 struct attribute *attr;
10640 case DW_TAG_namespace:
10641 case DW_TAG_typedef:
10642 case DW_TAG_class_type:
10643 case DW_TAG_interface_type:
10644 case DW_TAG_structure_type:
10645 case DW_TAG_union_type:
10646 case DW_TAG_enumeration_type:
10647 case DW_TAG_enumerator:
10648 case DW_TAG_subprogram:
10649 case DW_TAG_inlined_subroutine:
10650 case DW_TAG_member:
10651 case DW_TAG_imported_declaration:
10654 case DW_TAG_variable:
10655 case DW_TAG_constant:
10656 /* We only need to prefix "globally" visible variables. These include
10657 any variable marked with DW_AT_external or any variable that
10658 lives in a namespace. [Variables in anonymous namespaces
10659 require prefixing, but they are not DW_AT_external.] */
10661 if (dwarf2_attr (die, DW_AT_specification, cu))
10663 struct dwarf2_cu *spec_cu = cu;
10665 return die_needs_namespace (die_specification (die, &spec_cu),
10669 attr = dwarf2_attr (die, DW_AT_external, cu);
10670 if (attr == NULL && die->parent->tag != DW_TAG_namespace
10671 && die->parent->tag != DW_TAG_module)
10673 /* A variable in a lexical block of some kind does not need a
10674 namespace, even though in C++ such variables may be external
10675 and have a mangled name. */
10676 if (die->parent->tag == DW_TAG_lexical_block
10677 || die->parent->tag == DW_TAG_try_block
10678 || die->parent->tag == DW_TAG_catch_block
10679 || die->parent->tag == DW_TAG_subprogram)
10688 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10689 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10690 defined for the given DIE. */
10692 static struct attribute *
10693 dw2_linkage_name_attr (struct die_info *die, struct dwarf2_cu *cu)
10695 struct attribute *attr;
10697 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
10699 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
10704 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10705 or DW_AT_MIPS_linkage_name. Returns NULL if the attribute is not
10706 defined for the given DIE. */
10708 static const char *
10709 dw2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
10711 const char *linkage_name;
10713 linkage_name = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
10714 if (linkage_name == NULL)
10715 linkage_name = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
10717 return linkage_name;
10720 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
10721 compute the physname for the object, which include a method's:
10722 - formal parameters (C++),
10723 - receiver type (Go),
10725 The term "physname" is a bit confusing.
10726 For C++, for example, it is the demangled name.
10727 For Go, for example, it's the mangled name.
10729 For Ada, return the DIE's linkage name rather than the fully qualified
10730 name. PHYSNAME is ignored..
10732 The result is allocated on the objfile_obstack and canonicalized. */
10734 static const char *
10735 dwarf2_compute_name (const char *name,
10736 struct die_info *die, struct dwarf2_cu *cu,
10739 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10742 name = dwarf2_name (die, cu);
10744 /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10745 but otherwise compute it by typename_concat inside GDB.
10746 FIXME: Actually this is not really true, or at least not always true.
10747 It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
10748 Fortran names because there is no mangling standard. So new_symbol
10749 will set the demangled name to the result of dwarf2_full_name, and it is
10750 the demangled name that GDB uses if it exists. */
10751 if (cu->language == language_ada
10752 || (cu->language == language_fortran && physname))
10754 /* For Ada unit, we prefer the linkage name over the name, as
10755 the former contains the exported name, which the user expects
10756 to be able to reference. Ideally, we want the user to be able
10757 to reference this entity using either natural or linkage name,
10758 but we haven't started looking at this enhancement yet. */
10759 const char *linkage_name = dw2_linkage_name (die, cu);
10761 if (linkage_name != NULL)
10762 return linkage_name;
10765 /* These are the only languages we know how to qualify names in. */
10767 && (cu->language == language_cplus
10768 || cu->language == language_fortran || cu->language == language_d
10769 || cu->language == language_rust))
10771 if (die_needs_namespace (die, cu))
10773 const char *prefix;
10774 const char *canonical_name = NULL;
10778 prefix = determine_prefix (die, cu);
10779 if (*prefix != '\0')
10781 char *prefixed_name = typename_concat (NULL, prefix, name,
10784 buf.puts (prefixed_name);
10785 xfree (prefixed_name);
10790 /* Template parameters may be specified in the DIE's DW_AT_name, or
10791 as children with DW_TAG_template_type_param or
10792 DW_TAG_value_type_param. If the latter, add them to the name
10793 here. If the name already has template parameters, then
10794 skip this step; some versions of GCC emit both, and
10795 it is more efficient to use the pre-computed name.
10797 Something to keep in mind about this process: it is very
10798 unlikely, or in some cases downright impossible, to produce
10799 something that will match the mangled name of a function.
10800 If the definition of the function has the same debug info,
10801 we should be able to match up with it anyway. But fallbacks
10802 using the minimal symbol, for instance to find a method
10803 implemented in a stripped copy of libstdc++, will not work.
10804 If we do not have debug info for the definition, we will have to
10805 match them up some other way.
10807 When we do name matching there is a related problem with function
10808 templates; two instantiated function templates are allowed to
10809 differ only by their return types, which we do not add here. */
10811 if (cu->language == language_cplus && strchr (name, '<') == NULL)
10813 struct attribute *attr;
10814 struct die_info *child;
10817 die->building_fullname = 1;
10819 for (child = die->child; child != NULL; child = child->sibling)
10823 const gdb_byte *bytes;
10824 struct dwarf2_locexpr_baton *baton;
10827 if (child->tag != DW_TAG_template_type_param
10828 && child->tag != DW_TAG_template_value_param)
10839 attr = dwarf2_attr (child, DW_AT_type, cu);
10842 complaint (_("template parameter missing DW_AT_type"));
10843 buf.puts ("UNKNOWN_TYPE");
10846 type = die_type (child, cu);
10848 if (child->tag == DW_TAG_template_type_param)
10850 c_print_type (type, "", &buf, -1, 0, cu->language,
10851 &type_print_raw_options);
10855 attr = dwarf2_attr (child, DW_AT_const_value, cu);
10858 complaint (_("template parameter missing "
10859 "DW_AT_const_value"));
10860 buf.puts ("UNKNOWN_VALUE");
10864 dwarf2_const_value_attr (attr, type, name,
10865 &cu->comp_unit_obstack, cu,
10866 &value, &bytes, &baton);
10868 if (TYPE_NOSIGN (type))
10869 /* GDB prints characters as NUMBER 'CHAR'. If that's
10870 changed, this can use value_print instead. */
10871 c_printchar (value, type, &buf);
10874 struct value_print_options opts;
10877 v = dwarf2_evaluate_loc_desc (type, NULL,
10881 else if (bytes != NULL)
10883 v = allocate_value (type);
10884 memcpy (value_contents_writeable (v), bytes,
10885 TYPE_LENGTH (type));
10888 v = value_from_longest (type, value);
10890 /* Specify decimal so that we do not depend on
10892 get_formatted_print_options (&opts, 'd');
10894 value_print (v, &buf, &opts);
10899 die->building_fullname = 0;
10903 /* Close the argument list, with a space if necessary
10904 (nested templates). */
10905 if (!buf.empty () && buf.string ().back () == '>')
10912 /* For C++ methods, append formal parameter type
10913 information, if PHYSNAME. */
10915 if (physname && die->tag == DW_TAG_subprogram
10916 && cu->language == language_cplus)
10918 struct type *type = read_type_die (die, cu);
10920 c_type_print_args (type, &buf, 1, cu->language,
10921 &type_print_raw_options);
10923 if (cu->language == language_cplus)
10925 /* Assume that an artificial first parameter is
10926 "this", but do not crash if it is not. RealView
10927 marks unnamed (and thus unused) parameters as
10928 artificial; there is no way to differentiate
10930 if (TYPE_NFIELDS (type) > 0
10931 && TYPE_FIELD_ARTIFICIAL (type, 0)
10932 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
10933 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
10935 buf.puts (" const");
10939 const std::string &intermediate_name = buf.string ();
10941 if (cu->language == language_cplus)
10943 = dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
10944 &objfile->per_bfd->storage_obstack);
10946 /* If we only computed INTERMEDIATE_NAME, or if
10947 INTERMEDIATE_NAME is already canonical, then we need to
10948 copy it to the appropriate obstack. */
10949 if (canonical_name == NULL || canonical_name == intermediate_name.c_str ())
10950 name = ((const char *)
10951 obstack_copy0 (&objfile->per_bfd->storage_obstack,
10952 intermediate_name.c_str (),
10953 intermediate_name.length ()));
10955 name = canonical_name;
10962 /* Return the fully qualified name of DIE, based on its DW_AT_name.
10963 If scope qualifiers are appropriate they will be added. The result
10964 will be allocated on the storage_obstack, or NULL if the DIE does
10965 not have a name. NAME may either be from a previous call to
10966 dwarf2_name or NULL.
10968 The output string will be canonicalized (if C++). */
10970 static const char *
10971 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
10973 return dwarf2_compute_name (name, die, cu, 0);
10976 /* Construct a physname for the given DIE in CU. NAME may either be
10977 from a previous call to dwarf2_name or NULL. The result will be
10978 allocated on the objfile_objstack or NULL if the DIE does not have a
10981 The output string will be canonicalized (if C++). */
10983 static const char *
10984 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
10986 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10987 const char *retval, *mangled = NULL, *canon = NULL;
10990 /* In this case dwarf2_compute_name is just a shortcut not building anything
10992 if (!die_needs_namespace (die, cu))
10993 return dwarf2_compute_name (name, die, cu, 1);
10995 mangled = dw2_linkage_name (die, cu);
10997 /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
10998 See https://github.com/rust-lang/rust/issues/32925. */
10999 if (cu->language == language_rust && mangled != NULL
11000 && strchr (mangled, '{') != NULL)
11003 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11005 gdb::unique_xmalloc_ptr<char> demangled;
11006 if (mangled != NULL)
11009 if (language_def (cu->language)->la_store_sym_names_in_linkage_form_p)
11011 /* Do nothing (do not demangle the symbol name). */
11013 else if (cu->language == language_go)
11015 /* This is a lie, but we already lie to the caller new_symbol.
11016 new_symbol assumes we return the mangled name.
11017 This just undoes that lie until things are cleaned up. */
11021 /* Use DMGL_RET_DROP for C++ template functions to suppress
11022 their return type. It is easier for GDB users to search
11023 for such functions as `name(params)' than `long name(params)'.
11024 In such case the minimal symbol names do not match the full
11025 symbol names but for template functions there is never a need
11026 to look up their definition from their declaration so
11027 the only disadvantage remains the minimal symbol variant
11028 `long name(params)' does not have the proper inferior type. */
11029 demangled.reset (gdb_demangle (mangled,
11030 (DMGL_PARAMS | DMGL_ANSI
11031 | DMGL_RET_DROP)));
11034 canon = demangled.get ();
11042 if (canon == NULL || check_physname)
11044 const char *physname = dwarf2_compute_name (name, die, cu, 1);
11046 if (canon != NULL && strcmp (physname, canon) != 0)
11048 /* It may not mean a bug in GDB. The compiler could also
11049 compute DW_AT_linkage_name incorrectly. But in such case
11050 GDB would need to be bug-to-bug compatible. */
11052 complaint (_("Computed physname <%s> does not match demangled <%s> "
11053 "(from linkage <%s>) - DIE at %s [in module %s]"),
11054 physname, canon, mangled, sect_offset_str (die->sect_off),
11055 objfile_name (objfile));
11057 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11058 is available here - over computed PHYSNAME. It is safer
11059 against both buggy GDB and buggy compilers. */
11073 retval = ((const char *)
11074 obstack_copy0 (&objfile->per_bfd->storage_obstack,
11075 retval, strlen (retval)));
11080 /* Inspect DIE in CU for a namespace alias. If one exists, record
11081 a new symbol for it.
11083 Returns 1 if a namespace alias was recorded, 0 otherwise. */
11086 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
11088 struct attribute *attr;
11090 /* If the die does not have a name, this is not a namespace
11092 attr = dwarf2_attr (die, DW_AT_name, cu);
11096 struct die_info *d = die;
11097 struct dwarf2_cu *imported_cu = cu;
11099 /* If the compiler has nested DW_AT_imported_declaration DIEs,
11100 keep inspecting DIEs until we hit the underlying import. */
11101 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11102 for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
11104 attr = dwarf2_attr (d, DW_AT_import, cu);
11108 d = follow_die_ref (d, attr, &imported_cu);
11109 if (d->tag != DW_TAG_imported_declaration)
11113 if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
11115 complaint (_("DIE at %s has too many recursively imported "
11116 "declarations"), sect_offset_str (d->sect_off));
11123 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
11125 type = get_die_type_at_offset (sect_off, cu->per_cu);
11126 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
11128 /* This declaration is a global namespace alias. Add
11129 a symbol for it whose type is the aliased namespace. */
11130 new_symbol (die, type, cu);
11139 /* Return the using directives repository (global or local?) to use in the
11140 current context for CU.
11142 For Ada, imported declarations can materialize renamings, which *may* be
11143 global. However it is impossible (for now?) in DWARF to distinguish
11144 "external" imported declarations and "static" ones. As all imported
11145 declarations seem to be static in all other languages, make them all CU-wide
11146 global only in Ada. */
11148 static struct using_direct **
11149 using_directives (struct dwarf2_cu *cu)
11151 if (cu->language == language_ada
11152 && cu->get_builder ()->outermost_context_p ())
11153 return cu->get_builder ()->get_global_using_directives ();
11155 return cu->get_builder ()->get_local_using_directives ();
11158 /* Read the import statement specified by the given die and record it. */
11161 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
11163 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11164 struct attribute *import_attr;
11165 struct die_info *imported_die, *child_die;
11166 struct dwarf2_cu *imported_cu;
11167 const char *imported_name;
11168 const char *imported_name_prefix;
11169 const char *canonical_name;
11170 const char *import_alias;
11171 const char *imported_declaration = NULL;
11172 const char *import_prefix;
11173 std::vector<const char *> excludes;
11175 import_attr = dwarf2_attr (die, DW_AT_import, cu);
11176 if (import_attr == NULL)
11178 complaint (_("Tag '%s' has no DW_AT_import"),
11179 dwarf_tag_name (die->tag));
11184 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
11185 imported_name = dwarf2_name (imported_die, imported_cu);
11186 if (imported_name == NULL)
11188 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11190 The import in the following code:
11204 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11205 <52> DW_AT_decl_file : 1
11206 <53> DW_AT_decl_line : 6
11207 <54> DW_AT_import : <0x75>
11208 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11209 <59> DW_AT_name : B
11210 <5b> DW_AT_decl_file : 1
11211 <5c> DW_AT_decl_line : 2
11212 <5d> DW_AT_type : <0x6e>
11214 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11215 <76> DW_AT_byte_size : 4
11216 <77> DW_AT_encoding : 5 (signed)
11218 imports the wrong die ( 0x75 instead of 0x58 ).
11219 This case will be ignored until the gcc bug is fixed. */
11223 /* Figure out the local name after import. */
11224 import_alias = dwarf2_name (die, cu);
11226 /* Figure out where the statement is being imported to. */
11227 import_prefix = determine_prefix (die, cu);
11229 /* Figure out what the scope of the imported die is and prepend it
11230 to the name of the imported die. */
11231 imported_name_prefix = determine_prefix (imported_die, imported_cu);
11233 if (imported_die->tag != DW_TAG_namespace
11234 && imported_die->tag != DW_TAG_module)
11236 imported_declaration = imported_name;
11237 canonical_name = imported_name_prefix;
11239 else if (strlen (imported_name_prefix) > 0)
11240 canonical_name = obconcat (&objfile->objfile_obstack,
11241 imported_name_prefix,
11242 (cu->language == language_d ? "." : "::"),
11243 imported_name, (char *) NULL);
11245 canonical_name = imported_name;
11247 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
11248 for (child_die = die->child; child_die && child_die->tag;
11249 child_die = sibling_die (child_die))
11251 /* DWARF-4: A Fortran use statement with a “rename list” may be
11252 represented by an imported module entry with an import attribute
11253 referring to the module and owned entries corresponding to those
11254 entities that are renamed as part of being imported. */
11256 if (child_die->tag != DW_TAG_imported_declaration)
11258 complaint (_("child DW_TAG_imported_declaration expected "
11259 "- DIE at %s [in module %s]"),
11260 sect_offset_str (child_die->sect_off),
11261 objfile_name (objfile));
11265 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
11266 if (import_attr == NULL)
11268 complaint (_("Tag '%s' has no DW_AT_import"),
11269 dwarf_tag_name (child_die->tag));
11274 imported_die = follow_die_ref_or_sig (child_die, import_attr,
11276 imported_name = dwarf2_name (imported_die, imported_cu);
11277 if (imported_name == NULL)
11279 complaint (_("child DW_TAG_imported_declaration has unknown "
11280 "imported name - DIE at %s [in module %s]"),
11281 sect_offset_str (child_die->sect_off),
11282 objfile_name (objfile));
11286 excludes.push_back (imported_name);
11288 process_die (child_die, cu);
11291 add_using_directive (using_directives (cu),
11295 imported_declaration,
11298 &objfile->objfile_obstack);
11301 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11302 types, but gives them a size of zero. Starting with version 14,
11303 ICC is compatible with GCC. */
11306 producer_is_icc_lt_14 (struct dwarf2_cu *cu)
11308 if (!cu->checked_producer)
11309 check_producer (cu);
11311 return cu->producer_is_icc_lt_14;
11314 /* ICC generates a DW_AT_type for C void functions. This was observed on
11315 ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11316 which says that void functions should not have a DW_AT_type. */
11319 producer_is_icc (struct dwarf2_cu *cu)
11321 if (!cu->checked_producer)
11322 check_producer (cu);
11324 return cu->producer_is_icc;
11327 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11328 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11329 this, it was first present in GCC release 4.3.0. */
11332 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
11334 if (!cu->checked_producer)
11335 check_producer (cu);
11337 return cu->producer_is_gcc_lt_4_3;
11340 static file_and_directory
11341 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu)
11343 file_and_directory res;
11345 /* Find the filename. Do not use dwarf2_name here, since the filename
11346 is not a source language identifier. */
11347 res.name = dwarf2_string_attr (die, DW_AT_name, cu);
11348 res.comp_dir = dwarf2_string_attr (die, DW_AT_comp_dir, cu);
11350 if (res.comp_dir == NULL
11351 && producer_is_gcc_lt_4_3 (cu) && res.name != NULL
11352 && IS_ABSOLUTE_PATH (res.name))
11354 res.comp_dir_storage = ldirname (res.name);
11355 if (!res.comp_dir_storage.empty ())
11356 res.comp_dir = res.comp_dir_storage.c_str ();
11358 if (res.comp_dir != NULL)
11360 /* Irix 6.2 native cc prepends <machine>.: to the compilation
11361 directory, get rid of it. */
11362 const char *cp = strchr (res.comp_dir, ':');
11364 if (cp && cp != res.comp_dir && cp[-1] == '.' && cp[1] == '/')
11365 res.comp_dir = cp + 1;
11368 if (res.name == NULL)
11369 res.name = "<unknown>";
11374 /* Handle DW_AT_stmt_list for a compilation unit.
11375 DIE is the DW_TAG_compile_unit die for CU.
11376 COMP_DIR is the compilation directory. LOWPC is passed to
11377 dwarf_decode_lines. See dwarf_decode_lines comments about it. */
11380 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
11381 const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
11383 struct dwarf2_per_objfile *dwarf2_per_objfile
11384 = cu->per_cu->dwarf2_per_objfile;
11385 struct objfile *objfile = dwarf2_per_objfile->objfile;
11386 struct attribute *attr;
11387 struct line_header line_header_local;
11388 hashval_t line_header_local_hash;
11390 int decode_mapping;
11392 gdb_assert (! cu->per_cu->is_debug_types);
11394 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11398 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11400 /* The line header hash table is only created if needed (it exists to
11401 prevent redundant reading of the line table for partial_units).
11402 If we're given a partial_unit, we'll need it. If we're given a
11403 compile_unit, then use the line header hash table if it's already
11404 created, but don't create one just yet. */
11406 if (dwarf2_per_objfile->line_header_hash == NULL
11407 && die->tag == DW_TAG_partial_unit)
11409 dwarf2_per_objfile->line_header_hash
11410 = htab_create_alloc_ex (127, line_header_hash_voidp,
11411 line_header_eq_voidp,
11412 free_line_header_voidp,
11413 &objfile->objfile_obstack,
11414 hashtab_obstack_allocate,
11415 dummy_obstack_deallocate);
11418 line_header_local.sect_off = line_offset;
11419 line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
11420 line_header_local_hash = line_header_hash (&line_header_local);
11421 if (dwarf2_per_objfile->line_header_hash != NULL)
11423 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11424 &line_header_local,
11425 line_header_local_hash, NO_INSERT);
11427 /* For DW_TAG_compile_unit we need info like symtab::linetable which
11428 is not present in *SLOT (since if there is something in *SLOT then
11429 it will be for a partial_unit). */
11430 if (die->tag == DW_TAG_partial_unit && slot != NULL)
11432 gdb_assert (*slot != NULL);
11433 cu->line_header = (struct line_header *) *slot;
11438 /* dwarf_decode_line_header does not yet provide sufficient information.
11439 We always have to call also dwarf_decode_lines for it. */
11440 line_header_up lh = dwarf_decode_line_header (line_offset, cu);
11444 cu->line_header = lh.release ();
11445 cu->line_header_die_owner = die;
11447 if (dwarf2_per_objfile->line_header_hash == NULL)
11451 slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11452 &line_header_local,
11453 line_header_local_hash, INSERT);
11454 gdb_assert (slot != NULL);
11456 if (slot != NULL && *slot == NULL)
11458 /* This newly decoded line number information unit will be owned
11459 by line_header_hash hash table. */
11460 *slot = cu->line_header;
11461 cu->line_header_die_owner = NULL;
11465 /* We cannot free any current entry in (*slot) as that struct line_header
11466 may be already used by multiple CUs. Create only temporary decoded
11467 line_header for this CU - it may happen at most once for each line
11468 number information unit. And if we're not using line_header_hash
11469 then this is what we want as well. */
11470 gdb_assert (die->tag != DW_TAG_partial_unit);
11472 decode_mapping = (die->tag != DW_TAG_partial_unit);
11473 dwarf_decode_lines (cu->line_header, comp_dir, cu, NULL, lowpc,
11478 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
11481 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
11483 struct dwarf2_per_objfile *dwarf2_per_objfile
11484 = cu->per_cu->dwarf2_per_objfile;
11485 struct objfile *objfile = dwarf2_per_objfile->objfile;
11486 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11487 CORE_ADDR lowpc = ((CORE_ADDR) -1);
11488 CORE_ADDR highpc = ((CORE_ADDR) 0);
11489 struct attribute *attr;
11490 struct die_info *child_die;
11491 CORE_ADDR baseaddr;
11493 prepare_one_comp_unit (cu, die, cu->language);
11494 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11496 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
11498 /* If we didn't find a lowpc, set it to highpc to avoid complaints
11499 from finish_block. */
11500 if (lowpc == ((CORE_ADDR) -1))
11502 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11504 file_and_directory fnd = find_file_and_directory (die, cu);
11506 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11507 standardised yet. As a workaround for the language detection we fall
11508 back to the DW_AT_producer string. */
11509 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
11510 cu->language = language_opencl;
11512 /* Similar hack for Go. */
11513 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
11514 set_cu_language (DW_LANG_Go, cu);
11516 cu->start_symtab (fnd.name, fnd.comp_dir, lowpc);
11518 /* Decode line number information if present. We do this before
11519 processing child DIEs, so that the line header table is available
11520 for DW_AT_decl_file. */
11521 handle_DW_AT_stmt_list (die, cu, fnd.comp_dir, lowpc);
11523 /* Process all dies in compilation unit. */
11524 if (die->child != NULL)
11526 child_die = die->child;
11527 while (child_die && child_die->tag)
11529 process_die (child_die, cu);
11530 child_die = sibling_die (child_die);
11534 /* Decode macro information, if present. Dwarf 2 macro information
11535 refers to information in the line number info statement program
11536 header, so we can only read it if we've read the header
11538 attr = dwarf2_attr (die, DW_AT_macros, cu);
11540 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
11541 if (attr && cu->line_header)
11543 if (dwarf2_attr (die, DW_AT_macro_info, cu))
11544 complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11546 dwarf_decode_macros (cu, DW_UNSND (attr), 1);
11550 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
11551 if (attr && cu->line_header)
11553 unsigned int macro_offset = DW_UNSND (attr);
11555 dwarf_decode_macros (cu, macro_offset, 0);
11561 dwarf2_cu::setup_type_unit_groups (struct die_info *die)
11563 struct type_unit_group *tu_group;
11565 struct attribute *attr;
11567 struct signatured_type *sig_type;
11569 gdb_assert (per_cu->is_debug_types);
11570 sig_type = (struct signatured_type *) per_cu;
11572 attr = dwarf2_attr (die, DW_AT_stmt_list, this);
11574 /* If we're using .gdb_index (includes -readnow) then
11575 per_cu->type_unit_group may not have been set up yet. */
11576 if (sig_type->type_unit_group == NULL)
11577 sig_type->type_unit_group = get_type_unit_group (this, attr);
11578 tu_group = sig_type->type_unit_group;
11580 /* If we've already processed this stmt_list there's no real need to
11581 do it again, we could fake it and just recreate the part we need
11582 (file name,index -> symtab mapping). If data shows this optimization
11583 is useful we can do it then. */
11584 first_time = tu_group->compunit_symtab == NULL;
11586 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11591 sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11592 lh = dwarf_decode_line_header (line_offset, this);
11597 start_symtab ("", NULL, 0);
11600 gdb_assert (tu_group->symtabs == NULL);
11601 gdb_assert (m_builder == nullptr);
11602 struct compunit_symtab *cust = tu_group->compunit_symtab;
11603 m_builder.reset (new struct buildsym_compunit
11604 (COMPUNIT_OBJFILE (cust), "",
11605 COMPUNIT_DIRNAME (cust),
11606 compunit_language (cust),
11612 line_header = lh.release ();
11613 line_header_die_owner = die;
11617 struct compunit_symtab *cust = start_symtab ("", NULL, 0);
11619 /* Note: We don't assign tu_group->compunit_symtab yet because we're
11620 still initializing it, and our caller (a few levels up)
11621 process_full_type_unit still needs to know if this is the first
11624 tu_group->num_symtabs = line_header->file_names.size ();
11625 tu_group->symtabs = XNEWVEC (struct symtab *,
11626 line_header->file_names.size ());
11628 for (i = 0; i < line_header->file_names.size (); ++i)
11630 file_entry &fe = line_header->file_names[i];
11632 dwarf2_start_subfile (this, fe.name,
11633 fe.include_dir (line_header));
11634 buildsym_compunit *b = get_builder ();
11635 if (b->get_current_subfile ()->symtab == NULL)
11637 /* NOTE: start_subfile will recognize when it's been
11638 passed a file it has already seen. So we can't
11639 assume there's a simple mapping from
11640 cu->line_header->file_names to subfiles, plus
11641 cu->line_header->file_names may contain dups. */
11642 b->get_current_subfile ()->symtab
11643 = allocate_symtab (cust, b->get_current_subfile ()->name);
11646 fe.symtab = b->get_current_subfile ()->symtab;
11647 tu_group->symtabs[i] = fe.symtab;
11652 gdb_assert (m_builder == nullptr);
11653 struct compunit_symtab *cust = tu_group->compunit_symtab;
11654 m_builder.reset (new struct buildsym_compunit
11655 (COMPUNIT_OBJFILE (cust), "",
11656 COMPUNIT_DIRNAME (cust),
11657 compunit_language (cust),
11660 for (i = 0; i < line_header->file_names.size (); ++i)
11662 file_entry &fe = line_header->file_names[i];
11664 fe.symtab = tu_group->symtabs[i];
11668 /* The main symtab is allocated last. Type units don't have DW_AT_name
11669 so they don't have a "real" (so to speak) symtab anyway.
11670 There is later code that will assign the main symtab to all symbols
11671 that don't have one. We need to handle the case of a symbol with a
11672 missing symtab (DW_AT_decl_file) anyway. */
11675 /* Process DW_TAG_type_unit.
11676 For TUs we want to skip the first top level sibling if it's not the
11677 actual type being defined by this TU. In this case the first top
11678 level sibling is there to provide context only. */
11681 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
11683 struct die_info *child_die;
11685 prepare_one_comp_unit (cu, die, language_minimal);
11687 /* Initialize (or reinitialize) the machinery for building symtabs.
11688 We do this before processing child DIEs, so that the line header table
11689 is available for DW_AT_decl_file. */
11690 cu->setup_type_unit_groups (die);
11692 if (die->child != NULL)
11694 child_die = die->child;
11695 while (child_die && child_die->tag)
11697 process_die (child_die, cu);
11698 child_die = sibling_die (child_die);
11705 http://gcc.gnu.org/wiki/DebugFission
11706 http://gcc.gnu.org/wiki/DebugFissionDWP
11708 To simplify handling of both DWO files ("object" files with the DWARF info)
11709 and DWP files (a file with the DWOs packaged up into one file), we treat
11710 DWP files as having a collection of virtual DWO files. */
11713 hash_dwo_file (const void *item)
11715 const struct dwo_file *dwo_file = (const struct dwo_file *) item;
11718 hash = htab_hash_string (dwo_file->dwo_name);
11719 if (dwo_file->comp_dir != NULL)
11720 hash += htab_hash_string (dwo_file->comp_dir);
11725 eq_dwo_file (const void *item_lhs, const void *item_rhs)
11727 const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
11728 const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
11730 if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
11732 if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
11733 return lhs->comp_dir == rhs->comp_dir;
11734 return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
11737 /* Allocate a hash table for DWO files. */
11740 allocate_dwo_file_hash_table (struct objfile *objfile)
11742 auto delete_dwo_file = [] (void *item)
11744 struct dwo_file *dwo_file = (struct dwo_file *) item;
11749 return htab_up (htab_create_alloc_ex (41,
11753 &objfile->objfile_obstack,
11754 hashtab_obstack_allocate,
11755 dummy_obstack_deallocate));
11758 /* Lookup DWO file DWO_NAME. */
11761 lookup_dwo_file_slot (struct dwarf2_per_objfile *dwarf2_per_objfile,
11762 const char *dwo_name,
11763 const char *comp_dir)
11765 struct dwo_file find_entry;
11768 if (dwarf2_per_objfile->dwo_files == NULL)
11769 dwarf2_per_objfile->dwo_files
11770 = allocate_dwo_file_hash_table (dwarf2_per_objfile->objfile);
11772 find_entry.dwo_name = dwo_name;
11773 find_entry.comp_dir = comp_dir;
11774 slot = htab_find_slot (dwarf2_per_objfile->dwo_files.get (), &find_entry,
11781 hash_dwo_unit (const void *item)
11783 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
11785 /* This drops the top 32 bits of the id, but is ok for a hash. */
11786 return dwo_unit->signature;
11790 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
11792 const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
11793 const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
11795 /* The signature is assumed to be unique within the DWO file.
11796 So while object file CU dwo_id's always have the value zero,
11797 that's OK, assuming each object file DWO file has only one CU,
11798 and that's the rule for now. */
11799 return lhs->signature == rhs->signature;
11802 /* Allocate a hash table for DWO CUs,TUs.
11803 There is one of these tables for each of CUs,TUs for each DWO file. */
11806 allocate_dwo_unit_table (struct objfile *objfile)
11808 /* Start out with a pretty small number.
11809 Generally DWO files contain only one CU and maybe some TUs. */
11810 return htab_create_alloc_ex (3,
11814 &objfile->objfile_obstack,
11815 hashtab_obstack_allocate,
11816 dummy_obstack_deallocate);
11819 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
11821 struct create_dwo_cu_data
11823 struct dwo_file *dwo_file;
11824 struct dwo_unit dwo_unit;
11827 /* die_reader_func for create_dwo_cu. */
11830 create_dwo_cu_reader (const struct die_reader_specs *reader,
11831 const gdb_byte *info_ptr,
11832 struct die_info *comp_unit_die,
11836 struct dwarf2_cu *cu = reader->cu;
11837 sect_offset sect_off = cu->per_cu->sect_off;
11838 struct dwarf2_section_info *section = cu->per_cu->section;
11839 struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
11840 struct dwo_file *dwo_file = data->dwo_file;
11841 struct dwo_unit *dwo_unit = &data->dwo_unit;
11842 struct attribute *attr;
11844 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
11847 complaint (_("Dwarf Error: debug entry at offset %s is missing"
11848 " its dwo_id [in module %s]"),
11849 sect_offset_str (sect_off), dwo_file->dwo_name);
11853 dwo_unit->dwo_file = dwo_file;
11854 dwo_unit->signature = DW_UNSND (attr);
11855 dwo_unit->section = section;
11856 dwo_unit->sect_off = sect_off;
11857 dwo_unit->length = cu->per_cu->length;
11859 if (dwarf_read_debug)
11860 fprintf_unfiltered (gdb_stdlog, " offset %s, dwo_id %s\n",
11861 sect_offset_str (sect_off),
11862 hex_string (dwo_unit->signature));
11865 /* Create the dwo_units for the CUs in a DWO_FILE.
11866 Note: This function processes DWO files only, not DWP files. */
11869 create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
11870 struct dwo_file &dwo_file, dwarf2_section_info §ion,
11873 struct objfile *objfile = dwarf2_per_objfile->objfile;
11874 const gdb_byte *info_ptr, *end_ptr;
11876 dwarf2_read_section (objfile, §ion);
11877 info_ptr = section.buffer;
11879 if (info_ptr == NULL)
11882 if (dwarf_read_debug)
11884 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
11885 get_section_name (§ion),
11886 get_section_file_name (§ion));
11889 end_ptr = info_ptr + section.size;
11890 while (info_ptr < end_ptr)
11892 struct dwarf2_per_cu_data per_cu;
11893 struct create_dwo_cu_data create_dwo_cu_data;
11894 struct dwo_unit *dwo_unit;
11896 sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
11898 memset (&create_dwo_cu_data.dwo_unit, 0,
11899 sizeof (create_dwo_cu_data.dwo_unit));
11900 memset (&per_cu, 0, sizeof (per_cu));
11901 per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
11902 per_cu.is_debug_types = 0;
11903 per_cu.sect_off = sect_offset (info_ptr - section.buffer);
11904 per_cu.section = §ion;
11905 create_dwo_cu_data.dwo_file = &dwo_file;
11907 init_cutu_and_read_dies_no_follow (
11908 &per_cu, &dwo_file, create_dwo_cu_reader, &create_dwo_cu_data);
11909 info_ptr += per_cu.length;
11911 // If the unit could not be parsed, skip it.
11912 if (create_dwo_cu_data.dwo_unit.dwo_file == NULL)
11915 if (cus_htab == NULL)
11916 cus_htab = allocate_dwo_unit_table (objfile);
11918 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
11919 *dwo_unit = create_dwo_cu_data.dwo_unit;
11920 slot = htab_find_slot (cus_htab, dwo_unit, INSERT);
11921 gdb_assert (slot != NULL);
11924 const struct dwo_unit *dup_cu = (const struct dwo_unit *)*slot;
11925 sect_offset dup_sect_off = dup_cu->sect_off;
11927 complaint (_("debug cu entry at offset %s is duplicate to"
11928 " the entry at offset %s, signature %s"),
11929 sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
11930 hex_string (dwo_unit->signature));
11932 *slot = (void *)dwo_unit;
11936 /* DWP file .debug_{cu,tu}_index section format:
11937 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11941 Both index sections have the same format, and serve to map a 64-bit
11942 signature to a set of section numbers. Each section begins with a header,
11943 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11944 indexes, and a pool of 32-bit section numbers. The index sections will be
11945 aligned at 8-byte boundaries in the file.
11947 The index section header consists of:
11949 V, 32 bit version number
11951 N, 32 bit number of compilation units or type units in the index
11952 M, 32 bit number of slots in the hash table
11954 Numbers are recorded using the byte order of the application binary.
11956 The hash table begins at offset 16 in the section, and consists of an array
11957 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
11958 order of the application binary). Unused slots in the hash table are 0.
11959 (We rely on the extreme unlikeliness of a signature being exactly 0.)
11961 The parallel table begins immediately after the hash table
11962 (at offset 16 + 8 * M from the beginning of the section), and consists of an
11963 array of 32-bit indexes (using the byte order of the application binary),
11964 corresponding 1-1 with slots in the hash table. Each entry in the parallel
11965 table contains a 32-bit index into the pool of section numbers. For unused
11966 hash table slots, the corresponding entry in the parallel table will be 0.
11968 The pool of section numbers begins immediately following the hash table
11969 (at offset 16 + 12 * M from the beginning of the section). The pool of
11970 section numbers consists of an array of 32-bit words (using the byte order
11971 of the application binary). Each item in the array is indexed starting
11972 from 0. The hash table entry provides the index of the first section
11973 number in the set. Additional section numbers in the set follow, and the
11974 set is terminated by a 0 entry (section number 0 is not used in ELF).
11976 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
11977 section must be the first entry in the set, and the .debug_abbrev.dwo must
11978 be the second entry. Other members of the set may follow in any order.
11984 DWP Version 2 combines all the .debug_info, etc. sections into one,
11985 and the entries in the index tables are now offsets into these sections.
11986 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
11989 Index Section Contents:
11991 Hash Table of Signatures dwp_hash_table.hash_table
11992 Parallel Table of Indices dwp_hash_table.unit_table
11993 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
11994 Table of Section Sizes dwp_hash_table.v2.sizes
11996 The index section header consists of:
11998 V, 32 bit version number
11999 L, 32 bit number of columns in the table of section offsets
12000 N, 32 bit number of compilation units or type units in the index
12001 M, 32 bit number of slots in the hash table
12003 Numbers are recorded using the byte order of the application binary.
12005 The hash table has the same format as version 1.
12006 The parallel table of indices has the same format as version 1,
12007 except that the entries are origin-1 indices into the table of sections
12008 offsets and the table of section sizes.
12010 The table of offsets begins immediately following the parallel table
12011 (at offset 16 + 12 * M from the beginning of the section). The table is
12012 a two-dimensional array of 32-bit words (using the byte order of the
12013 application binary), with L columns and N+1 rows, in row-major order.
12014 Each row in the array is indexed starting from 0. The first row provides
12015 a key to the remaining rows: each column in this row provides an identifier
12016 for a debug section, and the offsets in the same column of subsequent rows
12017 refer to that section. The section identifiers are:
12019 DW_SECT_INFO 1 .debug_info.dwo
12020 DW_SECT_TYPES 2 .debug_types.dwo
12021 DW_SECT_ABBREV 3 .debug_abbrev.dwo
12022 DW_SECT_LINE 4 .debug_line.dwo
12023 DW_SECT_LOC 5 .debug_loc.dwo
12024 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
12025 DW_SECT_MACINFO 7 .debug_macinfo.dwo
12026 DW_SECT_MACRO 8 .debug_macro.dwo
12028 The offsets provided by the CU and TU index sections are the base offsets
12029 for the contributions made by each CU or TU to the corresponding section
12030 in the package file. Each CU and TU header contains an abbrev_offset
12031 field, used to find the abbreviations table for that CU or TU within the
12032 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12033 be interpreted as relative to the base offset given in the index section.
12034 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12035 should be interpreted as relative to the base offset for .debug_line.dwo,
12036 and offsets into other debug sections obtained from DWARF attributes should
12037 also be interpreted as relative to the corresponding base offset.
12039 The table of sizes begins immediately following the table of offsets.
12040 Like the table of offsets, it is a two-dimensional array of 32-bit words,
12041 with L columns and N rows, in row-major order. Each row in the array is
12042 indexed starting from 1 (row 0 is shared by the two tables).
12046 Hash table lookup is handled the same in version 1 and 2:
12048 We assume that N and M will not exceed 2^32 - 1.
12049 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12051 Given a 64-bit compilation unit signature or a type signature S, an entry
12052 in the hash table is located as follows:
12054 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12055 the low-order k bits all set to 1.
12057 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12059 3) If the hash table entry at index H matches the signature, use that
12060 entry. If the hash table entry at index H is unused (all zeroes),
12061 terminate the search: the signature is not present in the table.
12063 4) Let H = (H + H') modulo M. Repeat at Step 3.
12065 Because M > N and H' and M are relatively prime, the search is guaranteed
12066 to stop at an unused slot or find the match. */
12068 /* Create a hash table to map DWO IDs to their CU/TU entry in
12069 .debug_{info,types}.dwo in DWP_FILE.
12070 Returns NULL if there isn't one.
12071 Note: This function processes DWP files only, not DWO files. */
12073 static struct dwp_hash_table *
12074 create_dwp_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
12075 struct dwp_file *dwp_file, int is_debug_types)
12077 struct objfile *objfile = dwarf2_per_objfile->objfile;
12078 bfd *dbfd = dwp_file->dbfd.get ();
12079 const gdb_byte *index_ptr, *index_end;
12080 struct dwarf2_section_info *index;
12081 uint32_t version, nr_columns, nr_units, nr_slots;
12082 struct dwp_hash_table *htab;
12084 if (is_debug_types)
12085 index = &dwp_file->sections.tu_index;
12087 index = &dwp_file->sections.cu_index;
12089 if (dwarf2_section_empty_p (index))
12091 dwarf2_read_section (objfile, index);
12093 index_ptr = index->buffer;
12094 index_end = index_ptr + index->size;
12096 version = read_4_bytes (dbfd, index_ptr);
12099 nr_columns = read_4_bytes (dbfd, index_ptr);
12103 nr_units = read_4_bytes (dbfd, index_ptr);
12105 nr_slots = read_4_bytes (dbfd, index_ptr);
12108 if (version != 1 && version != 2)
12110 error (_("Dwarf Error: unsupported DWP file version (%s)"
12111 " [in module %s]"),
12112 pulongest (version), dwp_file->name);
12114 if (nr_slots != (nr_slots & -nr_slots))
12116 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12117 " is not power of 2 [in module %s]"),
12118 pulongest (nr_slots), dwp_file->name);
12121 htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
12122 htab->version = version;
12123 htab->nr_columns = nr_columns;
12124 htab->nr_units = nr_units;
12125 htab->nr_slots = nr_slots;
12126 htab->hash_table = index_ptr;
12127 htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
12129 /* Exit early if the table is empty. */
12130 if (nr_slots == 0 || nr_units == 0
12131 || (version == 2 && nr_columns == 0))
12133 /* All must be zero. */
12134 if (nr_slots != 0 || nr_units != 0
12135 || (version == 2 && nr_columns != 0))
12137 complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12138 " all zero [in modules %s]"),
12146 htab->section_pool.v1.indices =
12147 htab->unit_table + sizeof (uint32_t) * nr_slots;
12148 /* It's harder to decide whether the section is too small in v1.
12149 V1 is deprecated anyway so we punt. */
12153 const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
12154 int *ids = htab->section_pool.v2.section_ids;
12155 size_t sizeof_ids = sizeof (htab->section_pool.v2.section_ids);
12156 /* Reverse map for error checking. */
12157 int ids_seen[DW_SECT_MAX + 1];
12160 if (nr_columns < 2)
12162 error (_("Dwarf Error: bad DWP hash table, too few columns"
12163 " in section table [in module %s]"),
12166 if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
12168 error (_("Dwarf Error: bad DWP hash table, too many columns"
12169 " in section table [in module %s]"),
12172 memset (ids, 255, sizeof_ids);
12173 memset (ids_seen, 255, sizeof (ids_seen));
12174 for (i = 0; i < nr_columns; ++i)
12176 int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
12178 if (id < DW_SECT_MIN || id > DW_SECT_MAX)
12180 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12181 " in section table [in module %s]"),
12182 id, dwp_file->name);
12184 if (ids_seen[id] != -1)
12186 error (_("Dwarf Error: bad DWP hash table, duplicate section"
12187 " id %d in section table [in module %s]"),
12188 id, dwp_file->name);
12193 /* Must have exactly one info or types section. */
12194 if (((ids_seen[DW_SECT_INFO] != -1)
12195 + (ids_seen[DW_SECT_TYPES] != -1))
12198 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12199 " DWO info/types section [in module %s]"),
12202 /* Must have an abbrev section. */
12203 if (ids_seen[DW_SECT_ABBREV] == -1)
12205 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12206 " section [in module %s]"),
12209 htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
12210 htab->section_pool.v2.sizes =
12211 htab->section_pool.v2.offsets + (sizeof (uint32_t)
12212 * nr_units * nr_columns);
12213 if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
12214 * nr_units * nr_columns))
12217 error (_("Dwarf Error: DWP index section is corrupt (too small)"
12218 " [in module %s]"),
12226 /* Update SECTIONS with the data from SECTP.
12228 This function is like the other "locate" section routines that are
12229 passed to bfd_map_over_sections, but in this context the sections to
12230 read comes from the DWP V1 hash table, not the full ELF section table.
12232 The result is non-zero for success, or zero if an error was found. */
12235 locate_v1_virtual_dwo_sections (asection *sectp,
12236 struct virtual_v1_dwo_sections *sections)
12238 const struct dwop_section_names *names = &dwop_section_names;
12240 if (section_is_p (sectp->name, &names->abbrev_dwo))
12242 /* There can be only one. */
12243 if (sections->abbrev.s.section != NULL)
12245 sections->abbrev.s.section = sectp;
12246 sections->abbrev.size = bfd_get_section_size (sectp);
12248 else if (section_is_p (sectp->name, &names->info_dwo)
12249 || section_is_p (sectp->name, &names->types_dwo))
12251 /* There can be only one. */
12252 if (sections->info_or_types.s.section != NULL)
12254 sections->info_or_types.s.section = sectp;
12255 sections->info_or_types.size = bfd_get_section_size (sectp);
12257 else if (section_is_p (sectp->name, &names->line_dwo))
12259 /* There can be only one. */
12260 if (sections->line.s.section != NULL)
12262 sections->line.s.section = sectp;
12263 sections->line.size = bfd_get_section_size (sectp);
12265 else if (section_is_p (sectp->name, &names->loc_dwo))
12267 /* There can be only one. */
12268 if (sections->loc.s.section != NULL)
12270 sections->loc.s.section = sectp;
12271 sections->loc.size = bfd_get_section_size (sectp);
12273 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12275 /* There can be only one. */
12276 if (sections->macinfo.s.section != NULL)
12278 sections->macinfo.s.section = sectp;
12279 sections->macinfo.size = bfd_get_section_size (sectp);
12281 else if (section_is_p (sectp->name, &names->macro_dwo))
12283 /* There can be only one. */
12284 if (sections->macro.s.section != NULL)
12286 sections->macro.s.section = sectp;
12287 sections->macro.size = bfd_get_section_size (sectp);
12289 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12291 /* There can be only one. */
12292 if (sections->str_offsets.s.section != NULL)
12294 sections->str_offsets.s.section = sectp;
12295 sections->str_offsets.size = bfd_get_section_size (sectp);
12299 /* No other kind of section is valid. */
12306 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12307 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12308 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12309 This is for DWP version 1 files. */
12311 static struct dwo_unit *
12312 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12313 struct dwp_file *dwp_file,
12314 uint32_t unit_index,
12315 const char *comp_dir,
12316 ULONGEST signature, int is_debug_types)
12318 struct objfile *objfile = dwarf2_per_objfile->objfile;
12319 const struct dwp_hash_table *dwp_htab =
12320 is_debug_types ? dwp_file->tus : dwp_file->cus;
12321 bfd *dbfd = dwp_file->dbfd.get ();
12322 const char *kind = is_debug_types ? "TU" : "CU";
12323 struct dwo_file *dwo_file;
12324 struct dwo_unit *dwo_unit;
12325 struct virtual_v1_dwo_sections sections;
12326 void **dwo_file_slot;
12329 gdb_assert (dwp_file->version == 1);
12331 if (dwarf_read_debug)
12333 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
12335 pulongest (unit_index), hex_string (signature),
12339 /* Fetch the sections of this DWO unit.
12340 Put a limit on the number of sections we look for so that bad data
12341 doesn't cause us to loop forever. */
12343 #define MAX_NR_V1_DWO_SECTIONS \
12344 (1 /* .debug_info or .debug_types */ \
12345 + 1 /* .debug_abbrev */ \
12346 + 1 /* .debug_line */ \
12347 + 1 /* .debug_loc */ \
12348 + 1 /* .debug_str_offsets */ \
12349 + 1 /* .debug_macro or .debug_macinfo */ \
12350 + 1 /* trailing zero */)
12352 memset (§ions, 0, sizeof (sections));
12354 for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
12357 uint32_t section_nr =
12358 read_4_bytes (dbfd,
12359 dwp_htab->section_pool.v1.indices
12360 + (unit_index + i) * sizeof (uint32_t));
12362 if (section_nr == 0)
12364 if (section_nr >= dwp_file->num_sections)
12366 error (_("Dwarf Error: bad DWP hash table, section number too large"
12367 " [in module %s]"),
12371 sectp = dwp_file->elf_sections[section_nr];
12372 if (! locate_v1_virtual_dwo_sections (sectp, §ions))
12374 error (_("Dwarf Error: bad DWP hash table, invalid section found"
12375 " [in module %s]"),
12381 || dwarf2_section_empty_p (§ions.info_or_types)
12382 || dwarf2_section_empty_p (§ions.abbrev))
12384 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12385 " [in module %s]"),
12388 if (i == MAX_NR_V1_DWO_SECTIONS)
12390 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12391 " [in module %s]"),
12395 /* It's easier for the rest of the code if we fake a struct dwo_file and
12396 have dwo_unit "live" in that. At least for now.
12398 The DWP file can be made up of a random collection of CUs and TUs.
12399 However, for each CU + set of TUs that came from the same original DWO
12400 file, we can combine them back into a virtual DWO file to save space
12401 (fewer struct dwo_file objects to allocate). Remember that for really
12402 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12404 std::string virtual_dwo_name =
12405 string_printf ("virtual-dwo/%d-%d-%d-%d",
12406 get_section_id (§ions.abbrev),
12407 get_section_id (§ions.line),
12408 get_section_id (§ions.loc),
12409 get_section_id (§ions.str_offsets));
12410 /* Can we use an existing virtual DWO file? */
12411 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12412 virtual_dwo_name.c_str (),
12414 /* Create one if necessary. */
12415 if (*dwo_file_slot == NULL)
12417 if (dwarf_read_debug)
12419 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12420 virtual_dwo_name.c_str ());
12422 dwo_file = new struct dwo_file;
12424 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12425 virtual_dwo_name.c_str (),
12426 virtual_dwo_name.size ());
12427 dwo_file->comp_dir = comp_dir;
12428 dwo_file->sections.abbrev = sections.abbrev;
12429 dwo_file->sections.line = sections.line;
12430 dwo_file->sections.loc = sections.loc;
12431 dwo_file->sections.macinfo = sections.macinfo;
12432 dwo_file->sections.macro = sections.macro;
12433 dwo_file->sections.str_offsets = sections.str_offsets;
12434 /* The "str" section is global to the entire DWP file. */
12435 dwo_file->sections.str = dwp_file->sections.str;
12436 /* The info or types section is assigned below to dwo_unit,
12437 there's no need to record it in dwo_file.
12438 Also, we can't simply record type sections in dwo_file because
12439 we record a pointer into the vector in dwo_unit. As we collect more
12440 types we'll grow the vector and eventually have to reallocate space
12441 for it, invalidating all copies of pointers into the previous
12443 *dwo_file_slot = dwo_file;
12447 if (dwarf_read_debug)
12449 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12450 virtual_dwo_name.c_str ());
12452 dwo_file = (struct dwo_file *) *dwo_file_slot;
12455 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12456 dwo_unit->dwo_file = dwo_file;
12457 dwo_unit->signature = signature;
12458 dwo_unit->section =
12459 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12460 *dwo_unit->section = sections.info_or_types;
12461 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12466 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12467 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12468 piece within that section used by a TU/CU, return a virtual section
12469 of just that piece. */
12471 static struct dwarf2_section_info
12472 create_dwp_v2_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
12473 struct dwarf2_section_info *section,
12474 bfd_size_type offset, bfd_size_type size)
12476 struct dwarf2_section_info result;
12479 gdb_assert (section != NULL);
12480 gdb_assert (!section->is_virtual);
12482 memset (&result, 0, sizeof (result));
12483 result.s.containing_section = section;
12484 result.is_virtual = true;
12489 sectp = get_section_bfd_section (section);
12491 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12492 bounds of the real section. This is a pretty-rare event, so just
12493 flag an error (easier) instead of a warning and trying to cope. */
12495 || offset + size > bfd_get_section_size (sectp))
12497 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12498 " in section %s [in module %s]"),
12499 sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
12500 objfile_name (dwarf2_per_objfile->objfile));
12503 result.virtual_offset = offset;
12504 result.size = size;
12508 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12509 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12510 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12511 This is for DWP version 2 files. */
12513 static struct dwo_unit *
12514 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12515 struct dwp_file *dwp_file,
12516 uint32_t unit_index,
12517 const char *comp_dir,
12518 ULONGEST signature, int is_debug_types)
12520 struct objfile *objfile = dwarf2_per_objfile->objfile;
12521 const struct dwp_hash_table *dwp_htab =
12522 is_debug_types ? dwp_file->tus : dwp_file->cus;
12523 bfd *dbfd = dwp_file->dbfd.get ();
12524 const char *kind = is_debug_types ? "TU" : "CU";
12525 struct dwo_file *dwo_file;
12526 struct dwo_unit *dwo_unit;
12527 struct virtual_v2_dwo_sections sections;
12528 void **dwo_file_slot;
12531 gdb_assert (dwp_file->version == 2);
12533 if (dwarf_read_debug)
12535 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
12537 pulongest (unit_index), hex_string (signature),
12541 /* Fetch the section offsets of this DWO unit. */
12543 memset (§ions, 0, sizeof (sections));
12545 for (i = 0; i < dwp_htab->nr_columns; ++i)
12547 uint32_t offset = read_4_bytes (dbfd,
12548 dwp_htab->section_pool.v2.offsets
12549 + (((unit_index - 1) * dwp_htab->nr_columns
12551 * sizeof (uint32_t)));
12552 uint32_t size = read_4_bytes (dbfd,
12553 dwp_htab->section_pool.v2.sizes
12554 + (((unit_index - 1) * dwp_htab->nr_columns
12556 * sizeof (uint32_t)));
12558 switch (dwp_htab->section_pool.v2.section_ids[i])
12561 case DW_SECT_TYPES:
12562 sections.info_or_types_offset = offset;
12563 sections.info_or_types_size = size;
12565 case DW_SECT_ABBREV:
12566 sections.abbrev_offset = offset;
12567 sections.abbrev_size = size;
12570 sections.line_offset = offset;
12571 sections.line_size = size;
12574 sections.loc_offset = offset;
12575 sections.loc_size = size;
12577 case DW_SECT_STR_OFFSETS:
12578 sections.str_offsets_offset = offset;
12579 sections.str_offsets_size = size;
12581 case DW_SECT_MACINFO:
12582 sections.macinfo_offset = offset;
12583 sections.macinfo_size = size;
12585 case DW_SECT_MACRO:
12586 sections.macro_offset = offset;
12587 sections.macro_size = size;
12592 /* It's easier for the rest of the code if we fake a struct dwo_file and
12593 have dwo_unit "live" in that. At least for now.
12595 The DWP file can be made up of a random collection of CUs and TUs.
12596 However, for each CU + set of TUs that came from the same original DWO
12597 file, we can combine them back into a virtual DWO file to save space
12598 (fewer struct dwo_file objects to allocate). Remember that for really
12599 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
12601 std::string virtual_dwo_name =
12602 string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12603 (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
12604 (long) (sections.line_size ? sections.line_offset : 0),
12605 (long) (sections.loc_size ? sections.loc_offset : 0),
12606 (long) (sections.str_offsets_size
12607 ? sections.str_offsets_offset : 0));
12608 /* Can we use an existing virtual DWO file? */
12609 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12610 virtual_dwo_name.c_str (),
12612 /* Create one if necessary. */
12613 if (*dwo_file_slot == NULL)
12615 if (dwarf_read_debug)
12617 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12618 virtual_dwo_name.c_str ());
12620 dwo_file = new struct dwo_file;
12622 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12623 virtual_dwo_name.c_str (),
12624 virtual_dwo_name.size ());
12625 dwo_file->comp_dir = comp_dir;
12626 dwo_file->sections.abbrev =
12627 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,
12628 sections.abbrev_offset, sections.abbrev_size);
12629 dwo_file->sections.line =
12630 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.line,
12631 sections.line_offset, sections.line_size);
12632 dwo_file->sections.loc =
12633 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.loc,
12634 sections.loc_offset, sections.loc_size);
12635 dwo_file->sections.macinfo =
12636 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macinfo,
12637 sections.macinfo_offset, sections.macinfo_size);
12638 dwo_file->sections.macro =
12639 create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macro,
12640 sections.macro_offset, sections.macro_size);
12641 dwo_file->sections.str_offsets =
12642 create_dwp_v2_section (dwarf2_per_objfile,
12643 &dwp_file->sections.str_offsets,
12644 sections.str_offsets_offset,
12645 sections.str_offsets_size);
12646 /* The "str" section is global to the entire DWP file. */
12647 dwo_file->sections.str = dwp_file->sections.str;
12648 /* The info or types section is assigned below to dwo_unit,
12649 there's no need to record it in dwo_file.
12650 Also, we can't simply record type sections in dwo_file because
12651 we record a pointer into the vector in dwo_unit. As we collect more
12652 types we'll grow the vector and eventually have to reallocate space
12653 for it, invalidating all copies of pointers into the previous
12655 *dwo_file_slot = dwo_file;
12659 if (dwarf_read_debug)
12661 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12662 virtual_dwo_name.c_str ());
12664 dwo_file = (struct dwo_file *) *dwo_file_slot;
12667 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12668 dwo_unit->dwo_file = dwo_file;
12669 dwo_unit->signature = signature;
12670 dwo_unit->section =
12671 XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12672 *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
12674 ? &dwp_file->sections.types
12675 : &dwp_file->sections.info,
12676 sections.info_or_types_offset,
12677 sections.info_or_types_size);
12678 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
12683 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12684 Returns NULL if the signature isn't found. */
12686 static struct dwo_unit *
12687 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile *dwarf2_per_objfile,
12688 struct dwp_file *dwp_file, const char *comp_dir,
12689 ULONGEST signature, int is_debug_types)
12691 const struct dwp_hash_table *dwp_htab =
12692 is_debug_types ? dwp_file->tus : dwp_file->cus;
12693 bfd *dbfd = dwp_file->dbfd.get ();
12694 uint32_t mask = dwp_htab->nr_slots - 1;
12695 uint32_t hash = signature & mask;
12696 uint32_t hash2 = ((signature >> 32) & mask) | 1;
12699 struct dwo_unit find_dwo_cu;
12701 memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
12702 find_dwo_cu.signature = signature;
12703 slot = htab_find_slot (is_debug_types
12704 ? dwp_file->loaded_tus
12705 : dwp_file->loaded_cus,
12706 &find_dwo_cu, INSERT);
12709 return (struct dwo_unit *) *slot;
12711 /* Use a for loop so that we don't loop forever on bad debug info. */
12712 for (i = 0; i < dwp_htab->nr_slots; ++i)
12714 ULONGEST signature_in_table;
12716 signature_in_table =
12717 read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
12718 if (signature_in_table == signature)
12720 uint32_t unit_index =
12721 read_4_bytes (dbfd,
12722 dwp_htab->unit_table + hash * sizeof (uint32_t));
12724 if (dwp_file->version == 1)
12726 *slot = create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile,
12727 dwp_file, unit_index,
12728 comp_dir, signature,
12733 *slot = create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile,
12734 dwp_file, unit_index,
12735 comp_dir, signature,
12738 return (struct dwo_unit *) *slot;
12740 if (signature_in_table == 0)
12742 hash = (hash + hash2) & mask;
12745 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12746 " [in module %s]"),
12750 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12751 Open the file specified by FILE_NAME and hand it off to BFD for
12752 preliminary analysis. Return a newly initialized bfd *, which
12753 includes a canonicalized copy of FILE_NAME.
12754 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12755 SEARCH_CWD is true if the current directory is to be searched.
12756 It will be searched before debug-file-directory.
12757 If successful, the file is added to the bfd include table of the
12758 objfile's bfd (see gdb_bfd_record_inclusion).
12759 If unable to find/open the file, return NULL.
12760 NOTE: This function is derived from symfile_bfd_open. */
12762 static gdb_bfd_ref_ptr
12763 try_open_dwop_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12764 const char *file_name, int is_dwp, int search_cwd)
12767 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
12768 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
12769 to debug_file_directory. */
12770 const char *search_path;
12771 static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
12773 gdb::unique_xmalloc_ptr<char> search_path_holder;
12776 if (*debug_file_directory != '\0')
12778 search_path_holder.reset (concat (".", dirname_separator_string,
12779 debug_file_directory,
12781 search_path = search_path_holder.get ();
12787 search_path = debug_file_directory;
12789 openp_flags flags = OPF_RETURN_REALPATH;
12791 flags |= OPF_SEARCH_IN_PATH;
12793 gdb::unique_xmalloc_ptr<char> absolute_name;
12794 desc = openp (search_path, flags, file_name,
12795 O_RDONLY | O_BINARY, &absolute_name);
12799 gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (absolute_name.get (),
12801 if (sym_bfd == NULL)
12803 bfd_set_cacheable (sym_bfd.get (), 1);
12805 if (!bfd_check_format (sym_bfd.get (), bfd_object))
12808 /* Success. Record the bfd as having been included by the objfile's bfd.
12809 This is important because things like demangled_names_hash lives in the
12810 objfile's per_bfd space and may have references to things like symbol
12811 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
12812 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd.get ());
12817 /* Try to open DWO file FILE_NAME.
12818 COMP_DIR is the DW_AT_comp_dir attribute.
12819 The result is the bfd handle of the file.
12820 If there is a problem finding or opening the file, return NULL.
12821 Upon success, the canonicalized path of the file is stored in the bfd,
12822 same as symfile_bfd_open. */
12824 static gdb_bfd_ref_ptr
12825 open_dwo_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12826 const char *file_name, const char *comp_dir)
12828 if (IS_ABSOLUTE_PATH (file_name))
12829 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12830 0 /*is_dwp*/, 0 /*search_cwd*/);
12832 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
12834 if (comp_dir != NULL)
12836 char *path_to_try = concat (comp_dir, SLASH_STRING,
12837 file_name, (char *) NULL);
12839 /* NOTE: If comp_dir is a relative path, this will also try the
12840 search path, which seems useful. */
12841 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile,
12844 1 /*search_cwd*/));
12845 xfree (path_to_try);
12850 /* That didn't work, try debug-file-directory, which, despite its name,
12851 is a list of paths. */
12853 if (*debug_file_directory == '\0')
12856 return try_open_dwop_file (dwarf2_per_objfile, file_name,
12857 0 /*is_dwp*/, 1 /*search_cwd*/);
12860 /* This function is mapped across the sections and remembers the offset and
12861 size of each of the DWO debugging sections we are interested in. */
12864 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
12866 struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
12867 const struct dwop_section_names *names = &dwop_section_names;
12869 if (section_is_p (sectp->name, &names->abbrev_dwo))
12871 dwo_sections->abbrev.s.section = sectp;
12872 dwo_sections->abbrev.size = bfd_get_section_size (sectp);
12874 else if (section_is_p (sectp->name, &names->info_dwo))
12876 dwo_sections->info.s.section = sectp;
12877 dwo_sections->info.size = bfd_get_section_size (sectp);
12879 else if (section_is_p (sectp->name, &names->line_dwo))
12881 dwo_sections->line.s.section = sectp;
12882 dwo_sections->line.size = bfd_get_section_size (sectp);
12884 else if (section_is_p (sectp->name, &names->loc_dwo))
12886 dwo_sections->loc.s.section = sectp;
12887 dwo_sections->loc.size = bfd_get_section_size (sectp);
12889 else if (section_is_p (sectp->name, &names->macinfo_dwo))
12891 dwo_sections->macinfo.s.section = sectp;
12892 dwo_sections->macinfo.size = bfd_get_section_size (sectp);
12894 else if (section_is_p (sectp->name, &names->macro_dwo))
12896 dwo_sections->macro.s.section = sectp;
12897 dwo_sections->macro.size = bfd_get_section_size (sectp);
12899 else if (section_is_p (sectp->name, &names->str_dwo))
12901 dwo_sections->str.s.section = sectp;
12902 dwo_sections->str.size = bfd_get_section_size (sectp);
12904 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12906 dwo_sections->str_offsets.s.section = sectp;
12907 dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
12909 else if (section_is_p (sectp->name, &names->types_dwo))
12911 struct dwarf2_section_info type_section;
12913 memset (&type_section, 0, sizeof (type_section));
12914 type_section.s.section = sectp;
12915 type_section.size = bfd_get_section_size (sectp);
12916 dwo_sections->types.push_back (type_section);
12920 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12921 by PER_CU. This is for the non-DWP case.
12922 The result is NULL if DWO_NAME can't be found. */
12924 static struct dwo_file *
12925 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
12926 const char *dwo_name, const char *comp_dir)
12928 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
12930 gdb_bfd_ref_ptr dbfd = open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir);
12933 if (dwarf_read_debug)
12934 fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
12938 dwo_file_up dwo_file (new struct dwo_file);
12939 dwo_file->dwo_name = dwo_name;
12940 dwo_file->comp_dir = comp_dir;
12941 dwo_file->dbfd = std::move (dbfd);
12943 bfd_map_over_sections (dwo_file->dbfd.get (), dwarf2_locate_dwo_sections,
12944 &dwo_file->sections);
12946 create_cus_hash_table (dwarf2_per_objfile, *dwo_file, dwo_file->sections.info,
12949 create_debug_types_hash_table (dwarf2_per_objfile, dwo_file.get (),
12950 dwo_file->sections.types, dwo_file->tus);
12952 if (dwarf_read_debug)
12953 fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
12955 return dwo_file.release ();
12958 /* This function is mapped across the sections and remembers the offset and
12959 size of each of the DWP debugging sections common to version 1 and 2 that
12960 we are interested in. */
12963 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
12964 void *dwp_file_ptr)
12966 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
12967 const struct dwop_section_names *names = &dwop_section_names;
12968 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
12970 /* Record the ELF section number for later lookup: this is what the
12971 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
12972 gdb_assert (elf_section_nr < dwp_file->num_sections);
12973 dwp_file->elf_sections[elf_section_nr] = sectp;
12975 /* Look for specific sections that we need. */
12976 if (section_is_p (sectp->name, &names->str_dwo))
12978 dwp_file->sections.str.s.section = sectp;
12979 dwp_file->sections.str.size = bfd_get_section_size (sectp);
12981 else if (section_is_p (sectp->name, &names->cu_index))
12983 dwp_file->sections.cu_index.s.section = sectp;
12984 dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
12986 else if (section_is_p (sectp->name, &names->tu_index))
12988 dwp_file->sections.tu_index.s.section = sectp;
12989 dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
12993 /* This function is mapped across the sections and remembers the offset and
12994 size of each of the DWP version 2 debugging sections that we are interested
12995 in. This is split into a separate function because we don't know if we
12996 have version 1 or 2 until we parse the cu_index/tu_index sections. */
12999 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
13001 struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13002 const struct dwop_section_names *names = &dwop_section_names;
13003 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13005 /* Record the ELF section number for later lookup: this is what the
13006 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
13007 gdb_assert (elf_section_nr < dwp_file->num_sections);
13008 dwp_file->elf_sections[elf_section_nr] = sectp;
13010 /* Look for specific sections that we need. */
13011 if (section_is_p (sectp->name, &names->abbrev_dwo))
13013 dwp_file->sections.abbrev.s.section = sectp;
13014 dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
13016 else if (section_is_p (sectp->name, &names->info_dwo))
13018 dwp_file->sections.info.s.section = sectp;
13019 dwp_file->sections.info.size = bfd_get_section_size (sectp);
13021 else if (section_is_p (sectp->name, &names->line_dwo))
13023 dwp_file->sections.line.s.section = sectp;
13024 dwp_file->sections.line.size = bfd_get_section_size (sectp);
13026 else if (section_is_p (sectp->name, &names->loc_dwo))
13028 dwp_file->sections.loc.s.section = sectp;
13029 dwp_file->sections.loc.size = bfd_get_section_size (sectp);
13031 else if (section_is_p (sectp->name, &names->macinfo_dwo))
13033 dwp_file->sections.macinfo.s.section = sectp;
13034 dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
13036 else if (section_is_p (sectp->name, &names->macro_dwo))
13038 dwp_file->sections.macro.s.section = sectp;
13039 dwp_file->sections.macro.size = bfd_get_section_size (sectp);
13041 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
13043 dwp_file->sections.str_offsets.s.section = sectp;
13044 dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
13046 else if (section_is_p (sectp->name, &names->types_dwo))
13048 dwp_file->sections.types.s.section = sectp;
13049 dwp_file->sections.types.size = bfd_get_section_size (sectp);
13053 /* Hash function for dwp_file loaded CUs/TUs. */
13056 hash_dwp_loaded_cutus (const void *item)
13058 const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
13060 /* This drops the top 32 bits of the signature, but is ok for a hash. */
13061 return dwo_unit->signature;
13064 /* Equality function for dwp_file loaded CUs/TUs. */
13067 eq_dwp_loaded_cutus (const void *a, const void *b)
13069 const struct dwo_unit *dua = (const struct dwo_unit *) a;
13070 const struct dwo_unit *dub = (const struct dwo_unit *) b;
13072 return dua->signature == dub->signature;
13075 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
13078 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
13080 return htab_create_alloc_ex (3,
13081 hash_dwp_loaded_cutus,
13082 eq_dwp_loaded_cutus,
13084 &objfile->objfile_obstack,
13085 hashtab_obstack_allocate,
13086 dummy_obstack_deallocate);
13089 /* Try to open DWP file FILE_NAME.
13090 The result is the bfd handle of the file.
13091 If there is a problem finding or opening the file, return NULL.
13092 Upon success, the canonicalized path of the file is stored in the bfd,
13093 same as symfile_bfd_open. */
13095 static gdb_bfd_ref_ptr
13096 open_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
13097 const char *file_name)
13099 gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile, file_name,
13101 1 /*search_cwd*/));
13105 /* Work around upstream bug 15652.
13106 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13107 [Whether that's a "bug" is debatable, but it is getting in our way.]
13108 We have no real idea where the dwp file is, because gdb's realpath-ing
13109 of the executable's path may have discarded the needed info.
13110 [IWBN if the dwp file name was recorded in the executable, akin to
13111 .gnu_debuglink, but that doesn't exist yet.]
13112 Strip the directory from FILE_NAME and search again. */
13113 if (*debug_file_directory != '\0')
13115 /* Don't implicitly search the current directory here.
13116 If the user wants to search "." to handle this case,
13117 it must be added to debug-file-directory. */
13118 return try_open_dwop_file (dwarf2_per_objfile,
13119 lbasename (file_name), 1 /*is_dwp*/,
13126 /* Initialize the use of the DWP file for the current objfile.
13127 By convention the name of the DWP file is ${objfile}.dwp.
13128 The result is NULL if it can't be found. */
13130 static std::unique_ptr<struct dwp_file>
13131 open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13133 struct objfile *objfile = dwarf2_per_objfile->objfile;
13135 /* Try to find first .dwp for the binary file before any symbolic links
13138 /* If the objfile is a debug file, find the name of the real binary
13139 file and get the name of dwp file from there. */
13140 std::string dwp_name;
13141 if (objfile->separate_debug_objfile_backlink != NULL)
13143 struct objfile *backlink = objfile->separate_debug_objfile_backlink;
13144 const char *backlink_basename = lbasename (backlink->original_name);
13146 dwp_name = ldirname (objfile->original_name) + SLASH_STRING + backlink_basename;
13149 dwp_name = objfile->original_name;
13151 dwp_name += ".dwp";
13153 gdb_bfd_ref_ptr dbfd (open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ()));
13155 && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
13157 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
13158 dwp_name = objfile_name (objfile);
13159 dwp_name += ".dwp";
13160 dbfd = open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ());
13165 if (dwarf_read_debug)
13166 fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name.c_str ());
13167 return std::unique_ptr<dwp_file> ();
13170 const char *name = bfd_get_filename (dbfd.get ());
13171 std::unique_ptr<struct dwp_file> dwp_file
13172 (new struct dwp_file (name, std::move (dbfd)));
13174 dwp_file->num_sections = elf_numsections (dwp_file->dbfd);
13175 dwp_file->elf_sections =
13176 OBSTACK_CALLOC (&objfile->objfile_obstack,
13177 dwp_file->num_sections, asection *);
13179 bfd_map_over_sections (dwp_file->dbfd.get (),
13180 dwarf2_locate_common_dwp_sections,
13183 dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13186 dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13189 /* The DWP file version is stored in the hash table. Oh well. */
13190 if (dwp_file->cus && dwp_file->tus
13191 && dwp_file->cus->version != dwp_file->tus->version)
13193 /* Technically speaking, we should try to limp along, but this is
13194 pretty bizarre. We use pulongest here because that's the established
13195 portability solution (e.g, we cannot use %u for uint32_t). */
13196 error (_("Dwarf Error: DWP file CU version %s doesn't match"
13197 " TU version %s [in DWP file %s]"),
13198 pulongest (dwp_file->cus->version),
13199 pulongest (dwp_file->tus->version), dwp_name.c_str ());
13203 dwp_file->version = dwp_file->cus->version;
13204 else if (dwp_file->tus)
13205 dwp_file->version = dwp_file->tus->version;
13207 dwp_file->version = 2;
13209 if (dwp_file->version == 2)
13210 bfd_map_over_sections (dwp_file->dbfd.get (),
13211 dwarf2_locate_v2_dwp_sections,
13214 dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
13215 dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
13217 if (dwarf_read_debug)
13219 fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
13220 fprintf_unfiltered (gdb_stdlog,
13221 " %s CUs, %s TUs\n",
13222 pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
13223 pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
13229 /* Wrapper around open_and_init_dwp_file, only open it once. */
13231 static struct dwp_file *
13232 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13234 if (! dwarf2_per_objfile->dwp_checked)
13236 dwarf2_per_objfile->dwp_file
13237 = open_and_init_dwp_file (dwarf2_per_objfile);
13238 dwarf2_per_objfile->dwp_checked = 1;
13240 return dwarf2_per_objfile->dwp_file.get ();
13243 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13244 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13245 or in the DWP file for the objfile, referenced by THIS_UNIT.
13246 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13247 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13249 This is called, for example, when wanting to read a variable with a
13250 complex location. Therefore we don't want to do file i/o for every call.
13251 Therefore we don't want to look for a DWO file on every call.
13252 Therefore we first see if we've already seen SIGNATURE in a DWP file,
13253 then we check if we've already seen DWO_NAME, and only THEN do we check
13256 The result is a pointer to the dwo_unit object or NULL if we didn't find it
13257 (dwo_id mismatch or couldn't find the DWO/DWP file). */
13259 static struct dwo_unit *
13260 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
13261 const char *dwo_name, const char *comp_dir,
13262 ULONGEST signature, int is_debug_types)
13264 struct dwarf2_per_objfile *dwarf2_per_objfile = this_unit->dwarf2_per_objfile;
13265 struct objfile *objfile = dwarf2_per_objfile->objfile;
13266 const char *kind = is_debug_types ? "TU" : "CU";
13267 void **dwo_file_slot;
13268 struct dwo_file *dwo_file;
13269 struct dwp_file *dwp_file;
13271 /* First see if there's a DWP file.
13272 If we have a DWP file but didn't find the DWO inside it, don't
13273 look for the original DWO file. It makes gdb behave differently
13274 depending on whether one is debugging in the build tree. */
13276 dwp_file = get_dwp_file (dwarf2_per_objfile);
13277 if (dwp_file != NULL)
13279 const struct dwp_hash_table *dwp_htab =
13280 is_debug_types ? dwp_file->tus : dwp_file->cus;
13282 if (dwp_htab != NULL)
13284 struct dwo_unit *dwo_cutu =
13285 lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, comp_dir,
13286 signature, is_debug_types);
13288 if (dwo_cutu != NULL)
13290 if (dwarf_read_debug)
13292 fprintf_unfiltered (gdb_stdlog,
13293 "Virtual DWO %s %s found: @%s\n",
13294 kind, hex_string (signature),
13295 host_address_to_string (dwo_cutu));
13303 /* No DWP file, look for the DWO file. */
13305 dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
13306 dwo_name, comp_dir);
13307 if (*dwo_file_slot == NULL)
13309 /* Read in the file and build a table of the CUs/TUs it contains. */
13310 *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
13312 /* NOTE: This will be NULL if unable to open the file. */
13313 dwo_file = (struct dwo_file *) *dwo_file_slot;
13315 if (dwo_file != NULL)
13317 struct dwo_unit *dwo_cutu = NULL;
13319 if (is_debug_types && dwo_file->tus)
13321 struct dwo_unit find_dwo_cutu;
13323 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13324 find_dwo_cutu.signature = signature;
13326 = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
13328 else if (!is_debug_types && dwo_file->cus)
13330 struct dwo_unit find_dwo_cutu;
13332 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13333 find_dwo_cutu.signature = signature;
13334 dwo_cutu = (struct dwo_unit *)htab_find (dwo_file->cus,
13338 if (dwo_cutu != NULL)
13340 if (dwarf_read_debug)
13342 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
13343 kind, dwo_name, hex_string (signature),
13344 host_address_to_string (dwo_cutu));
13351 /* We didn't find it. This could mean a dwo_id mismatch, or
13352 someone deleted the DWO/DWP file, or the search path isn't set up
13353 correctly to find the file. */
13355 if (dwarf_read_debug)
13357 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
13358 kind, dwo_name, hex_string (signature));
13361 /* This is a warning and not a complaint because it can be caused by
13362 pilot error (e.g., user accidentally deleting the DWO). */
13364 /* Print the name of the DWP file if we looked there, helps the user
13365 better diagnose the problem. */
13366 std::string dwp_text;
13368 if (dwp_file != NULL)
13369 dwp_text = string_printf (" [in DWP file %s]",
13370 lbasename (dwp_file->name));
13372 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13373 " [in module %s]"),
13374 kind, dwo_name, hex_string (signature),
13376 this_unit->is_debug_types ? "TU" : "CU",
13377 sect_offset_str (this_unit->sect_off), objfile_name (objfile));
13382 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13383 See lookup_dwo_cutu_unit for details. */
13385 static struct dwo_unit *
13386 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
13387 const char *dwo_name, const char *comp_dir,
13388 ULONGEST signature)
13390 return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
13393 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13394 See lookup_dwo_cutu_unit for details. */
13396 static struct dwo_unit *
13397 lookup_dwo_type_unit (struct signatured_type *this_tu,
13398 const char *dwo_name, const char *comp_dir)
13400 return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
13403 /* Traversal function for queue_and_load_all_dwo_tus. */
13406 queue_and_load_dwo_tu (void **slot, void *info)
13408 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
13409 struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
13410 ULONGEST signature = dwo_unit->signature;
13411 struct signatured_type *sig_type =
13412 lookup_dwo_signatured_type (per_cu->cu, signature);
13414 if (sig_type != NULL)
13416 struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
13418 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13419 a real dependency of PER_CU on SIG_TYPE. That is detected later
13420 while processing PER_CU. */
13421 if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
13422 load_full_type_unit (sig_cu);
13423 VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
13429 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13430 The DWO may have the only definition of the type, though it may not be
13431 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
13432 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
13435 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
13437 struct dwo_unit *dwo_unit;
13438 struct dwo_file *dwo_file;
13440 gdb_assert (!per_cu->is_debug_types);
13441 gdb_assert (get_dwp_file (per_cu->dwarf2_per_objfile) == NULL);
13442 gdb_assert (per_cu->cu != NULL);
13444 dwo_unit = per_cu->cu->dwo_unit;
13445 gdb_assert (dwo_unit != NULL);
13447 dwo_file = dwo_unit->dwo_file;
13448 if (dwo_file->tus != NULL)
13449 htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
13452 /* Read in various DIEs. */
13454 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13455 Inherit only the children of the DW_AT_abstract_origin DIE not being
13456 already referenced by DW_AT_abstract_origin from the children of the
13460 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
13462 struct die_info *child_die;
13463 sect_offset *offsetp;
13464 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
13465 struct die_info *origin_die;
13466 /* Iterator of the ORIGIN_DIE children. */
13467 struct die_info *origin_child_die;
13468 struct attribute *attr;
13469 struct dwarf2_cu *origin_cu;
13470 struct pending **origin_previous_list_in_scope;
13472 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13476 /* Note that following die references may follow to a die in a
13480 origin_die = follow_die_ref (die, attr, &origin_cu);
13482 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13484 origin_previous_list_in_scope = origin_cu->list_in_scope;
13485 origin_cu->list_in_scope = cu->list_in_scope;
13487 if (die->tag != origin_die->tag
13488 && !(die->tag == DW_TAG_inlined_subroutine
13489 && origin_die->tag == DW_TAG_subprogram))
13490 complaint (_("DIE %s and its abstract origin %s have different tags"),
13491 sect_offset_str (die->sect_off),
13492 sect_offset_str (origin_die->sect_off));
13494 std::vector<sect_offset> offsets;
13496 for (child_die = die->child;
13497 child_die && child_die->tag;
13498 child_die = sibling_die (child_die))
13500 struct die_info *child_origin_die;
13501 struct dwarf2_cu *child_origin_cu;
13503 /* We are trying to process concrete instance entries:
13504 DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13505 it's not relevant to our analysis here. i.e. detecting DIEs that are
13506 present in the abstract instance but not referenced in the concrete
13508 if (child_die->tag == DW_TAG_call_site
13509 || child_die->tag == DW_TAG_GNU_call_site)
13512 /* For each CHILD_DIE, find the corresponding child of
13513 ORIGIN_DIE. If there is more than one layer of
13514 DW_AT_abstract_origin, follow them all; there shouldn't be,
13515 but GCC versions at least through 4.4 generate this (GCC PR
13517 child_origin_die = child_die;
13518 child_origin_cu = cu;
13521 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
13525 child_origin_die = follow_die_ref (child_origin_die, attr,
13529 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13530 counterpart may exist. */
13531 if (child_origin_die != child_die)
13533 if (child_die->tag != child_origin_die->tag
13534 && !(child_die->tag == DW_TAG_inlined_subroutine
13535 && child_origin_die->tag == DW_TAG_subprogram))
13536 complaint (_("Child DIE %s and its abstract origin %s have "
13538 sect_offset_str (child_die->sect_off),
13539 sect_offset_str (child_origin_die->sect_off));
13540 if (child_origin_die->parent != origin_die)
13541 complaint (_("Child DIE %s and its abstract origin %s have "
13542 "different parents"),
13543 sect_offset_str (child_die->sect_off),
13544 sect_offset_str (child_origin_die->sect_off));
13546 offsets.push_back (child_origin_die->sect_off);
13549 std::sort (offsets.begin (), offsets.end ());
13550 sect_offset *offsets_end = offsets.data () + offsets.size ();
13551 for (offsetp = offsets.data () + 1; offsetp < offsets_end; offsetp++)
13552 if (offsetp[-1] == *offsetp)
13553 complaint (_("Multiple children of DIE %s refer "
13554 "to DIE %s as their abstract origin"),
13555 sect_offset_str (die->sect_off), sect_offset_str (*offsetp));
13557 offsetp = offsets.data ();
13558 origin_child_die = origin_die->child;
13559 while (origin_child_die && origin_child_die->tag)
13561 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
13562 while (offsetp < offsets_end
13563 && *offsetp < origin_child_die->sect_off)
13565 if (offsetp >= offsets_end
13566 || *offsetp > origin_child_die->sect_off)
13568 /* Found that ORIGIN_CHILD_DIE is really not referenced.
13569 Check whether we're already processing ORIGIN_CHILD_DIE.
13570 This can happen with mutually referenced abstract_origins.
13572 if (!origin_child_die->in_process)
13573 process_die (origin_child_die, origin_cu);
13575 origin_child_die = sibling_die (origin_child_die);
13577 origin_cu->list_in_scope = origin_previous_list_in_scope;
13581 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
13583 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13584 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13585 struct context_stack *newobj;
13588 struct die_info *child_die;
13589 struct attribute *attr, *call_line, *call_file;
13591 CORE_ADDR baseaddr;
13592 struct block *block;
13593 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
13594 std::vector<struct symbol *> template_args;
13595 struct template_symbol *templ_func = NULL;
13599 /* If we do not have call site information, we can't show the
13600 caller of this inlined function. That's too confusing, so
13601 only use the scope for local variables. */
13602 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
13603 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
13604 if (call_line == NULL || call_file == NULL)
13606 read_lexical_block_scope (die, cu);
13611 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13613 name = dwarf2_name (die, cu);
13615 /* Ignore functions with missing or empty names. These are actually
13616 illegal according to the DWARF standard. */
13619 complaint (_("missing name for subprogram DIE at %s"),
13620 sect_offset_str (die->sect_off));
13624 /* Ignore functions with missing or invalid low and high pc attributes. */
13625 if (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL)
13626 <= PC_BOUNDS_INVALID)
13628 attr = dwarf2_attr (die, DW_AT_external, cu);
13629 if (!attr || !DW_UNSND (attr))
13630 complaint (_("cannot get low and high bounds "
13631 "for subprogram DIE at %s"),
13632 sect_offset_str (die->sect_off));
13636 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13637 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13639 /* If we have any template arguments, then we must allocate a
13640 different sort of symbol. */
13641 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
13643 if (child_die->tag == DW_TAG_template_type_param
13644 || child_die->tag == DW_TAG_template_value_param)
13646 templ_func = allocate_template_symbol (objfile);
13647 templ_func->subclass = SYMBOL_TEMPLATE;
13652 newobj = cu->get_builder ()->push_context (0, lowpc);
13653 newobj->name = new_symbol (die, read_type_die (die, cu), cu,
13654 (struct symbol *) templ_func);
13656 if (dwarf2_flag_true_p (die, DW_AT_main_subprogram, cu))
13657 set_objfile_main_name (objfile, SYMBOL_LINKAGE_NAME (newobj->name),
13660 /* If there is a location expression for DW_AT_frame_base, record
13662 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
13664 dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
13666 /* If there is a location for the static link, record it. */
13667 newobj->static_link = NULL;
13668 attr = dwarf2_attr (die, DW_AT_static_link, cu);
13671 newobj->static_link
13672 = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
13673 attr_to_dynamic_prop (attr, die, cu, newobj->static_link,
13674 dwarf2_per_cu_addr_type (cu->per_cu));
13677 cu->list_in_scope = cu->get_builder ()->get_local_symbols ();
13679 if (die->child != NULL)
13681 child_die = die->child;
13682 while (child_die && child_die->tag)
13684 if (child_die->tag == DW_TAG_template_type_param
13685 || child_die->tag == DW_TAG_template_value_param)
13687 struct symbol *arg = new_symbol (child_die, NULL, cu);
13690 template_args.push_back (arg);
13693 process_die (child_die, cu);
13694 child_die = sibling_die (child_die);
13698 inherit_abstract_dies (die, cu);
13700 /* If we have a DW_AT_specification, we might need to import using
13701 directives from the context of the specification DIE. See the
13702 comment in determine_prefix. */
13703 if (cu->language == language_cplus
13704 && dwarf2_attr (die, DW_AT_specification, cu))
13706 struct dwarf2_cu *spec_cu = cu;
13707 struct die_info *spec_die = die_specification (die, &spec_cu);
13711 child_die = spec_die->child;
13712 while (child_die && child_die->tag)
13714 if (child_die->tag == DW_TAG_imported_module)
13715 process_die (child_die, spec_cu);
13716 child_die = sibling_die (child_die);
13719 /* In some cases, GCC generates specification DIEs that
13720 themselves contain DW_AT_specification attributes. */
13721 spec_die = die_specification (spec_die, &spec_cu);
13725 struct context_stack cstk = cu->get_builder ()->pop_context ();
13726 /* Make a block for the local symbols within. */
13727 block = cu->get_builder ()->finish_block (cstk.name, cstk.old_blocks,
13728 cstk.static_link, lowpc, highpc);
13730 /* For C++, set the block's scope. */
13731 if ((cu->language == language_cplus
13732 || cu->language == language_fortran
13733 || cu->language == language_d
13734 || cu->language == language_rust)
13735 && cu->processing_has_namespace_info)
13736 block_set_scope (block, determine_prefix (die, cu),
13737 &objfile->objfile_obstack);
13739 /* If we have address ranges, record them. */
13740 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13742 gdbarch_make_symbol_special (gdbarch, cstk.name, objfile);
13744 /* Attach template arguments to function. */
13745 if (!template_args.empty ())
13747 gdb_assert (templ_func != NULL);
13749 templ_func->n_template_arguments = template_args.size ();
13750 templ_func->template_arguments
13751 = XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
13752 templ_func->n_template_arguments);
13753 memcpy (templ_func->template_arguments,
13754 template_args.data (),
13755 (templ_func->n_template_arguments * sizeof (struct symbol *)));
13757 /* Make sure that the symtab is set on the new symbols. Even
13758 though they don't appear in this symtab directly, other parts
13759 of gdb assume that symbols do, and this is reasonably
13761 for (symbol *sym : template_args)
13762 symbol_set_symtab (sym, symbol_symtab (templ_func));
13765 /* In C++, we can have functions nested inside functions (e.g., when
13766 a function declares a class that has methods). This means that
13767 when we finish processing a function scope, we may need to go
13768 back to building a containing block's symbol lists. */
13769 *cu->get_builder ()->get_local_symbols () = cstk.locals;
13770 cu->get_builder ()->set_local_using_directives (cstk.local_using_directives);
13772 /* If we've finished processing a top-level function, subsequent
13773 symbols go in the file symbol list. */
13774 if (cu->get_builder ()->outermost_context_p ())
13775 cu->list_in_scope = cu->get_builder ()->get_file_symbols ();
13778 /* Process all the DIES contained within a lexical block scope. Start
13779 a new scope, process the dies, and then close the scope. */
13782 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
13784 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13785 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13786 CORE_ADDR lowpc, highpc;
13787 struct die_info *child_die;
13788 CORE_ADDR baseaddr;
13790 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13792 /* Ignore blocks with missing or invalid low and high pc attributes. */
13793 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13794 as multiple lexical blocks? Handling children in a sane way would
13795 be nasty. Might be easier to properly extend generic blocks to
13796 describe ranges. */
13797 switch (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
13799 case PC_BOUNDS_NOT_PRESENT:
13800 /* DW_TAG_lexical_block has no attributes, process its children as if
13801 there was no wrapping by that DW_TAG_lexical_block.
13802 GCC does no longer produces such DWARF since GCC r224161. */
13803 for (child_die = die->child;
13804 child_die != NULL && child_die->tag;
13805 child_die = sibling_die (child_die))
13806 process_die (child_die, cu);
13808 case PC_BOUNDS_INVALID:
13811 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13812 highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13814 cu->get_builder ()->push_context (0, lowpc);
13815 if (die->child != NULL)
13817 child_die = die->child;
13818 while (child_die && child_die->tag)
13820 process_die (child_die, cu);
13821 child_die = sibling_die (child_die);
13824 inherit_abstract_dies (die, cu);
13825 struct context_stack cstk = cu->get_builder ()->pop_context ();
13827 if (*cu->get_builder ()->get_local_symbols () != NULL
13828 || (*cu->get_builder ()->get_local_using_directives ()) != NULL)
13830 struct block *block
13831 = cu->get_builder ()->finish_block (0, cstk.old_blocks, NULL,
13832 cstk.start_addr, highpc);
13834 /* Note that recording ranges after traversing children, as we
13835 do here, means that recording a parent's ranges entails
13836 walking across all its children's ranges as they appear in
13837 the address map, which is quadratic behavior.
13839 It would be nicer to record the parent's ranges before
13840 traversing its children, simply overriding whatever you find
13841 there. But since we don't even decide whether to create a
13842 block until after we've traversed its children, that's hard
13844 dwarf2_record_block_ranges (die, block, baseaddr, cu);
13846 *cu->get_builder ()->get_local_symbols () = cstk.locals;
13847 cu->get_builder ()->set_local_using_directives (cstk.local_using_directives);
13850 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
13853 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
13855 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13856 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13857 CORE_ADDR pc, baseaddr;
13858 struct attribute *attr;
13859 struct call_site *call_site, call_site_local;
13862 struct die_info *child_die;
13864 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13866 attr = dwarf2_attr (die, DW_AT_call_return_pc, cu);
13869 /* This was a pre-DWARF-5 GNU extension alias
13870 for DW_AT_call_return_pc. */
13871 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
13875 complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13876 "DIE %s [in module %s]"),
13877 sect_offset_str (die->sect_off), objfile_name (objfile));
13880 pc = attr_value_as_address (attr) + baseaddr;
13881 pc = gdbarch_adjust_dwarf2_addr (gdbarch, pc);
13883 if (cu->call_site_htab == NULL)
13884 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
13885 NULL, &objfile->objfile_obstack,
13886 hashtab_obstack_allocate, NULL);
13887 call_site_local.pc = pc;
13888 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
13891 complaint (_("Duplicate PC %s for DW_TAG_call_site "
13892 "DIE %s [in module %s]"),
13893 paddress (gdbarch, pc), sect_offset_str (die->sect_off),
13894 objfile_name (objfile));
13898 /* Count parameters at the caller. */
13901 for (child_die = die->child; child_die && child_die->tag;
13902 child_die = sibling_die (child_die))
13904 if (child_die->tag != DW_TAG_call_site_parameter
13905 && child_die->tag != DW_TAG_GNU_call_site_parameter)
13907 complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13908 "DW_TAG_call_site child DIE %s [in module %s]"),
13909 child_die->tag, sect_offset_str (child_die->sect_off),
13910 objfile_name (objfile));
13918 = ((struct call_site *)
13919 obstack_alloc (&objfile->objfile_obstack,
13920 sizeof (*call_site)
13921 + (sizeof (*call_site->parameter) * (nparams - 1))));
13923 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
13924 call_site->pc = pc;
13926 if (dwarf2_flag_true_p (die, DW_AT_call_tail_call, cu)
13927 || dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
13929 struct die_info *func_die;
13931 /* Skip also over DW_TAG_inlined_subroutine. */
13932 for (func_die = die->parent;
13933 func_die && func_die->tag != DW_TAG_subprogram
13934 && func_die->tag != DW_TAG_subroutine_type;
13935 func_die = func_die->parent);
13937 /* DW_AT_call_all_calls is a superset
13938 of DW_AT_call_all_tail_calls. */
13940 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_calls, cu)
13941 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
13942 && !dwarf2_flag_true_p (func_die, DW_AT_call_all_tail_calls, cu)
13943 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
13945 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
13946 not complete. But keep CALL_SITE for look ups via call_site_htab,
13947 both the initial caller containing the real return address PC and
13948 the final callee containing the current PC of a chain of tail
13949 calls do not need to have the tail call list complete. But any
13950 function candidate for a virtual tail call frame searched via
13951 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
13952 determined unambiguously. */
13956 struct type *func_type = NULL;
13959 func_type = get_die_type (func_die, cu);
13960 if (func_type != NULL)
13962 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
13964 /* Enlist this call site to the function. */
13965 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
13966 TYPE_TAIL_CALL_LIST (func_type) = call_site;
13969 complaint (_("Cannot find function owning DW_TAG_call_site "
13970 "DIE %s [in module %s]"),
13971 sect_offset_str (die->sect_off), objfile_name (objfile));
13975 attr = dwarf2_attr (die, DW_AT_call_target, cu);
13977 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
13979 attr = dwarf2_attr (die, DW_AT_call_origin, cu);
13982 /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin. */
13983 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13985 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
13986 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
13987 /* Keep NULL DWARF_BLOCK. */;
13988 else if (attr_form_is_block (attr))
13990 struct dwarf2_locexpr_baton *dlbaton;
13992 dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
13993 dlbaton->data = DW_BLOCK (attr)->data;
13994 dlbaton->size = DW_BLOCK (attr)->size;
13995 dlbaton->per_cu = cu->per_cu;
13997 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
13999 else if (attr_form_is_ref (attr))
14001 struct dwarf2_cu *target_cu = cu;
14002 struct die_info *target_die;
14004 target_die = follow_die_ref (die, attr, &target_cu);
14005 gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
14006 if (die_is_declaration (target_die, target_cu))
14008 const char *target_physname;
14010 /* Prefer the mangled name; otherwise compute the demangled one. */
14011 target_physname = dw2_linkage_name (target_die, target_cu);
14012 if (target_physname == NULL)
14013 target_physname = dwarf2_physname (NULL, target_die, target_cu);
14014 if (target_physname == NULL)
14015 complaint (_("DW_AT_call_target target DIE has invalid "
14016 "physname, for referencing DIE %s [in module %s]"),
14017 sect_offset_str (die->sect_off), objfile_name (objfile));
14019 SET_FIELD_PHYSNAME (call_site->target, target_physname);
14025 /* DW_AT_entry_pc should be preferred. */
14026 if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
14027 <= PC_BOUNDS_INVALID)
14028 complaint (_("DW_AT_call_target target DIE has invalid "
14029 "low pc, for referencing DIE %s [in module %s]"),
14030 sect_offset_str (die->sect_off), objfile_name (objfile));
14033 lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
14034 SET_FIELD_PHYSADDR (call_site->target, lowpc);
14039 complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14040 "block nor reference, for DIE %s [in module %s]"),
14041 sect_offset_str (die->sect_off), objfile_name (objfile));
14043 call_site->per_cu = cu->per_cu;
14045 for (child_die = die->child;
14046 child_die && child_die->tag;
14047 child_die = sibling_die (child_die))
14049 struct call_site_parameter *parameter;
14050 struct attribute *loc, *origin;
14052 if (child_die->tag != DW_TAG_call_site_parameter
14053 && child_die->tag != DW_TAG_GNU_call_site_parameter)
14055 /* Already printed the complaint above. */
14059 gdb_assert (call_site->parameter_count < nparams);
14060 parameter = &call_site->parameter[call_site->parameter_count];
14062 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14063 specifies DW_TAG_formal_parameter. Value of the data assumed for the
14064 register is contained in DW_AT_call_value. */
14066 loc = dwarf2_attr (child_die, DW_AT_location, cu);
14067 origin = dwarf2_attr (child_die, DW_AT_call_parameter, cu);
14068 if (origin == NULL)
14070 /* This was a pre-DWARF-5 GNU extension alias
14071 for DW_AT_call_parameter. */
14072 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
14074 if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
14076 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
14078 sect_offset sect_off
14079 = (sect_offset) dwarf2_get_ref_die_offset (origin);
14080 if (!offset_in_cu_p (&cu->header, sect_off))
14082 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14083 binding can be done only inside one CU. Such referenced DIE
14084 therefore cannot be even moved to DW_TAG_partial_unit. */
14085 complaint (_("DW_AT_call_parameter offset is not in CU for "
14086 "DW_TAG_call_site child DIE %s [in module %s]"),
14087 sect_offset_str (child_die->sect_off),
14088 objfile_name (objfile));
14091 parameter->u.param_cu_off
14092 = (cu_offset) (sect_off - cu->header.sect_off);
14094 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
14096 complaint (_("No DW_FORM_block* DW_AT_location for "
14097 "DW_TAG_call_site child DIE %s [in module %s]"),
14098 sect_offset_str (child_die->sect_off), objfile_name (objfile));
14103 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
14104 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
14105 if (parameter->u.dwarf_reg != -1)
14106 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
14107 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
14108 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
14109 ¶meter->u.fb_offset))
14110 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
14113 complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14114 "for DW_FORM_block* DW_AT_location is supported for "
14115 "DW_TAG_call_site child DIE %s "
14117 sect_offset_str (child_die->sect_off),
14118 objfile_name (objfile));
14123 attr = dwarf2_attr (child_die, DW_AT_call_value, cu);
14125 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
14126 if (!attr_form_is_block (attr))
14128 complaint (_("No DW_FORM_block* DW_AT_call_value for "
14129 "DW_TAG_call_site child DIE %s [in module %s]"),
14130 sect_offset_str (child_die->sect_off),
14131 objfile_name (objfile));
14134 parameter->value = DW_BLOCK (attr)->data;
14135 parameter->value_size = DW_BLOCK (attr)->size;
14137 /* Parameters are not pre-cleared by memset above. */
14138 parameter->data_value = NULL;
14139 parameter->data_value_size = 0;
14140 call_site->parameter_count++;
14142 attr = dwarf2_attr (child_die, DW_AT_call_data_value, cu);
14144 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
14147 if (!attr_form_is_block (attr))
14148 complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14149 "DW_TAG_call_site child DIE %s [in module %s]"),
14150 sect_offset_str (child_die->sect_off),
14151 objfile_name (objfile));
14154 parameter->data_value = DW_BLOCK (attr)->data;
14155 parameter->data_value_size = DW_BLOCK (attr)->size;
14161 /* Helper function for read_variable. If DIE represents a virtual
14162 table, then return the type of the concrete object that is
14163 associated with the virtual table. Otherwise, return NULL. */
14165 static struct type *
14166 rust_containing_type (struct die_info *die, struct dwarf2_cu *cu)
14168 struct attribute *attr = dwarf2_attr (die, DW_AT_type, cu);
14172 /* Find the type DIE. */
14173 struct die_info *type_die = NULL;
14174 struct dwarf2_cu *type_cu = cu;
14176 if (attr_form_is_ref (attr))
14177 type_die = follow_die_ref (die, attr, &type_cu);
14178 if (type_die == NULL)
14181 if (dwarf2_attr (type_die, DW_AT_containing_type, type_cu) == NULL)
14183 return die_containing_type (type_die, type_cu);
14186 /* Read a variable (DW_TAG_variable) DIE and create a new symbol. */
14189 read_variable (struct die_info *die, struct dwarf2_cu *cu)
14191 struct rust_vtable_symbol *storage = NULL;
14193 if (cu->language == language_rust)
14195 struct type *containing_type = rust_containing_type (die, cu);
14197 if (containing_type != NULL)
14199 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14201 storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
14202 struct rust_vtable_symbol);
14203 initialize_objfile_symbol (storage);
14204 storage->concrete_type = containing_type;
14205 storage->subclass = SYMBOL_RUST_VTABLE;
14209 struct symbol *res = new_symbol (die, NULL, cu, storage);
14210 struct attribute *abstract_origin
14211 = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14212 struct attribute *loc = dwarf2_attr (die, DW_AT_location, cu);
14213 if (res == NULL && loc && abstract_origin)
14215 /* We have a variable without a name, but with a location and an abstract
14216 origin. This may be a concrete instance of an abstract variable
14217 referenced from an DW_OP_GNU_variable_value, so save it to find it back
14219 struct dwarf2_cu *origin_cu = cu;
14220 struct die_info *origin_die
14221 = follow_die_ref (die, abstract_origin, &origin_cu);
14222 dwarf2_per_objfile *dpo = cu->per_cu->dwarf2_per_objfile;
14223 dpo->abstract_to_concrete[origin_die->sect_off].push_back (die->sect_off);
14227 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14228 reading .debug_rnglists.
14229 Callback's type should be:
14230 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14231 Return true if the attributes are present and valid, otherwise,
14234 template <typename Callback>
14236 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
14237 Callback &&callback)
14239 struct dwarf2_per_objfile *dwarf2_per_objfile
14240 = cu->per_cu->dwarf2_per_objfile;
14241 struct objfile *objfile = dwarf2_per_objfile->objfile;
14242 bfd *obfd = objfile->obfd;
14243 /* Base address selection entry. */
14246 const gdb_byte *buffer;
14247 CORE_ADDR baseaddr;
14248 bool overflow = false;
14250 found_base = cu->base_known;
14251 base = cu->base_address;
14253 dwarf2_read_section (objfile, &dwarf2_per_objfile->rnglists);
14254 if (offset >= dwarf2_per_objfile->rnglists.size)
14256 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14260 buffer = dwarf2_per_objfile->rnglists.buffer + offset;
14262 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14266 /* Initialize it due to a false compiler warning. */
14267 CORE_ADDR range_beginning = 0, range_end = 0;
14268 const gdb_byte *buf_end = (dwarf2_per_objfile->rnglists.buffer
14269 + dwarf2_per_objfile->rnglists.size);
14270 unsigned int bytes_read;
14272 if (buffer == buf_end)
14277 const auto rlet = static_cast<enum dwarf_range_list_entry>(*buffer++);
14280 case DW_RLE_end_of_list:
14282 case DW_RLE_base_address:
14283 if (buffer + cu->header.addr_size > buf_end)
14288 base = read_address (obfd, buffer, cu, &bytes_read);
14290 buffer += bytes_read;
14292 case DW_RLE_start_length:
14293 if (buffer + cu->header.addr_size > buf_end)
14298 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14299 buffer += bytes_read;
14300 range_end = (range_beginning
14301 + read_unsigned_leb128 (obfd, buffer, &bytes_read));
14302 buffer += bytes_read;
14303 if (buffer > buf_end)
14309 case DW_RLE_offset_pair:
14310 range_beginning = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14311 buffer += bytes_read;
14312 if (buffer > buf_end)
14317 range_end = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14318 buffer += bytes_read;
14319 if (buffer > buf_end)
14325 case DW_RLE_start_end:
14326 if (buffer + 2 * cu->header.addr_size > buf_end)
14331 range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14332 buffer += bytes_read;
14333 range_end = read_address (obfd, buffer, cu, &bytes_read);
14334 buffer += bytes_read;
14337 complaint (_("Invalid .debug_rnglists data (no base address)"));
14340 if (rlet == DW_RLE_end_of_list || overflow)
14342 if (rlet == DW_RLE_base_address)
14347 /* We have no valid base address for the ranges
14349 complaint (_("Invalid .debug_rnglists data (no base address)"));
14353 if (range_beginning > range_end)
14355 /* Inverted range entries are invalid. */
14356 complaint (_("Invalid .debug_rnglists data (inverted range)"));
14360 /* Empty range entries have no effect. */
14361 if (range_beginning == range_end)
14364 range_beginning += base;
14367 /* A not-uncommon case of bad debug info.
14368 Don't pollute the addrmap with bad data. */
14369 if (range_beginning + baseaddr == 0
14370 && !dwarf2_per_objfile->has_section_at_zero)
14372 complaint (_(".debug_rnglists entry has start address of zero"
14373 " [in module %s]"), objfile_name (objfile));
14377 callback (range_beginning, range_end);
14382 complaint (_("Offset %d is not terminated "
14383 "for DW_AT_ranges attribute"),
14391 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14392 Callback's type should be:
14393 void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14394 Return 1 if the attributes are present and valid, otherwise, return 0. */
14396 template <typename Callback>
14398 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
14399 Callback &&callback)
14401 struct dwarf2_per_objfile *dwarf2_per_objfile
14402 = cu->per_cu->dwarf2_per_objfile;
14403 struct objfile *objfile = dwarf2_per_objfile->objfile;
14404 struct comp_unit_head *cu_header = &cu->header;
14405 bfd *obfd = objfile->obfd;
14406 unsigned int addr_size = cu_header->addr_size;
14407 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
14408 /* Base address selection entry. */
14411 unsigned int dummy;
14412 const gdb_byte *buffer;
14413 CORE_ADDR baseaddr;
14415 if (cu_header->version >= 5)
14416 return dwarf2_rnglists_process (offset, cu, callback);
14418 found_base = cu->base_known;
14419 base = cu->base_address;
14421 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
14422 if (offset >= dwarf2_per_objfile->ranges.size)
14424 complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14428 buffer = dwarf2_per_objfile->ranges.buffer + offset;
14430 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14434 CORE_ADDR range_beginning, range_end;
14436 range_beginning = read_address (obfd, buffer, cu, &dummy);
14437 buffer += addr_size;
14438 range_end = read_address (obfd, buffer, cu, &dummy);
14439 buffer += addr_size;
14440 offset += 2 * addr_size;
14442 /* An end of list marker is a pair of zero addresses. */
14443 if (range_beginning == 0 && range_end == 0)
14444 /* Found the end of list entry. */
14447 /* Each base address selection entry is a pair of 2 values.
14448 The first is the largest possible address, the second is
14449 the base address. Check for a base address here. */
14450 if ((range_beginning & mask) == mask)
14452 /* If we found the largest possible address, then we already
14453 have the base address in range_end. */
14461 /* We have no valid base address for the ranges
14463 complaint (_("Invalid .debug_ranges data (no base address)"));
14467 if (range_beginning > range_end)
14469 /* Inverted range entries are invalid. */
14470 complaint (_("Invalid .debug_ranges data (inverted range)"));
14474 /* Empty range entries have no effect. */
14475 if (range_beginning == range_end)
14478 range_beginning += base;
14481 /* A not-uncommon case of bad debug info.
14482 Don't pollute the addrmap with bad data. */
14483 if (range_beginning + baseaddr == 0
14484 && !dwarf2_per_objfile->has_section_at_zero)
14486 complaint (_(".debug_ranges entry has start address of zero"
14487 " [in module %s]"), objfile_name (objfile));
14491 callback (range_beginning, range_end);
14497 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14498 Return 1 if the attributes are present and valid, otherwise, return 0.
14499 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
14502 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
14503 CORE_ADDR *high_return, struct dwarf2_cu *cu,
14504 struct partial_symtab *ranges_pst)
14506 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14507 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14508 const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
14509 SECT_OFF_TEXT (objfile));
14512 CORE_ADDR high = 0;
14515 retval = dwarf2_ranges_process (offset, cu,
14516 [&] (CORE_ADDR range_beginning, CORE_ADDR range_end)
14518 if (ranges_pst != NULL)
14523 lowpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14524 range_beginning + baseaddr)
14526 highpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14527 range_end + baseaddr)
14529 addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
14530 lowpc, highpc - 1, ranges_pst);
14533 /* FIXME: This is recording everything as a low-high
14534 segment of consecutive addresses. We should have a
14535 data structure for discontiguous block ranges
14539 low = range_beginning;
14545 if (range_beginning < low)
14546 low = range_beginning;
14547 if (range_end > high)
14555 /* If the first entry is an end-of-list marker, the range
14556 describes an empty scope, i.e. no instructions. */
14562 *high_return = high;
14566 /* Get low and high pc attributes from a die. See enum pc_bounds_kind
14567 definition for the return value. *LOWPC and *HIGHPC are set iff
14568 neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
14570 static enum pc_bounds_kind
14571 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
14572 CORE_ADDR *highpc, struct dwarf2_cu *cu,
14573 struct partial_symtab *pst)
14575 struct dwarf2_per_objfile *dwarf2_per_objfile
14576 = cu->per_cu->dwarf2_per_objfile;
14577 struct attribute *attr;
14578 struct attribute *attr_high;
14580 CORE_ADDR high = 0;
14581 enum pc_bounds_kind ret;
14583 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14586 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14589 low = attr_value_as_address (attr);
14590 high = attr_value_as_address (attr_high);
14591 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14595 /* Found high w/o low attribute. */
14596 return PC_BOUNDS_INVALID;
14598 /* Found consecutive range of addresses. */
14599 ret = PC_BOUNDS_HIGH_LOW;
14603 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14606 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14607 We take advantage of the fact that DW_AT_ranges does not appear
14608 in DW_TAG_compile_unit of DWO files. */
14609 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14610 unsigned int ranges_offset = (DW_UNSND (attr)
14611 + (need_ranges_base
14615 /* Value of the DW_AT_ranges attribute is the offset in the
14616 .debug_ranges section. */
14617 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
14618 return PC_BOUNDS_INVALID;
14619 /* Found discontinuous range of addresses. */
14620 ret = PC_BOUNDS_RANGES;
14623 return PC_BOUNDS_NOT_PRESENT;
14626 /* partial_die_info::read has also the strict LOW < HIGH requirement. */
14628 return PC_BOUNDS_INVALID;
14630 /* When using the GNU linker, .gnu.linkonce. sections are used to
14631 eliminate duplicate copies of functions and vtables and such.
14632 The linker will arbitrarily choose one and discard the others.
14633 The AT_*_pc values for such functions refer to local labels in
14634 these sections. If the section from that file was discarded, the
14635 labels are not in the output, so the relocs get a value of 0.
14636 If this is a discarded function, mark the pc bounds as invalid,
14637 so that GDB will ignore it. */
14638 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
14639 return PC_BOUNDS_INVALID;
14647 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14648 its low and high PC addresses. Do nothing if these addresses could not
14649 be determined. Otherwise, set LOWPC to the low address if it is smaller,
14650 and HIGHPC to the high address if greater than HIGHPC. */
14653 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
14654 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14655 struct dwarf2_cu *cu)
14657 CORE_ADDR low, high;
14658 struct die_info *child = die->child;
14660 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL) >= PC_BOUNDS_RANGES)
14662 *lowpc = std::min (*lowpc, low);
14663 *highpc = std::max (*highpc, high);
14666 /* If the language does not allow nested subprograms (either inside
14667 subprograms or lexical blocks), we're done. */
14668 if (cu->language != language_ada)
14671 /* Check all the children of the given DIE. If it contains nested
14672 subprograms, then check their pc bounds. Likewise, we need to
14673 check lexical blocks as well, as they may also contain subprogram
14675 while (child && child->tag)
14677 if (child->tag == DW_TAG_subprogram
14678 || child->tag == DW_TAG_lexical_block)
14679 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
14680 child = sibling_die (child);
14684 /* Get the low and high pc's represented by the scope DIE, and store
14685 them in *LOWPC and *HIGHPC. If the correct values can't be
14686 determined, set *LOWPC to -1 and *HIGHPC to 0. */
14689 get_scope_pc_bounds (struct die_info *die,
14690 CORE_ADDR *lowpc, CORE_ADDR *highpc,
14691 struct dwarf2_cu *cu)
14693 CORE_ADDR best_low = (CORE_ADDR) -1;
14694 CORE_ADDR best_high = (CORE_ADDR) 0;
14695 CORE_ADDR current_low, current_high;
14697 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL)
14698 >= PC_BOUNDS_RANGES)
14700 best_low = current_low;
14701 best_high = current_high;
14705 struct die_info *child = die->child;
14707 while (child && child->tag)
14709 switch (child->tag) {
14710 case DW_TAG_subprogram:
14711 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
14713 case DW_TAG_namespace:
14714 case DW_TAG_module:
14715 /* FIXME: carlton/2004-01-16: Should we do this for
14716 DW_TAG_class_type/DW_TAG_structure_type, too? I think
14717 that current GCC's always emit the DIEs corresponding
14718 to definitions of methods of classes as children of a
14719 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14720 the DIEs giving the declarations, which could be
14721 anywhere). But I don't see any reason why the
14722 standards says that they have to be there. */
14723 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu);
14725 if (current_low != ((CORE_ADDR) -1))
14727 best_low = std::min (best_low, current_low);
14728 best_high = std::max (best_high, current_high);
14736 child = sibling_die (child);
14741 *highpc = best_high;
14744 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14748 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
14749 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
14751 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14752 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14753 struct attribute *attr;
14754 struct attribute *attr_high;
14756 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14759 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14762 CORE_ADDR low = attr_value_as_address (attr);
14763 CORE_ADDR high = attr_value_as_address (attr_high);
14765 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14768 low = gdbarch_adjust_dwarf2_addr (gdbarch, low + baseaddr);
14769 high = gdbarch_adjust_dwarf2_addr (gdbarch, high + baseaddr);
14770 cu->get_builder ()->record_block_range (block, low, high - 1);
14774 attr = dwarf2_attr (die, DW_AT_ranges, cu);
14777 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14778 We take advantage of the fact that DW_AT_ranges does not appear
14779 in DW_TAG_compile_unit of DWO files. */
14780 int need_ranges_base = die->tag != DW_TAG_compile_unit;
14782 /* The value of the DW_AT_ranges attribute is the offset of the
14783 address range list in the .debug_ranges section. */
14784 unsigned long offset = (DW_UNSND (attr)
14785 + (need_ranges_base ? cu->ranges_base : 0));
14787 std::vector<blockrange> blockvec;
14788 dwarf2_ranges_process (offset, cu,
14789 [&] (CORE_ADDR start, CORE_ADDR end)
14793 start = gdbarch_adjust_dwarf2_addr (gdbarch, start);
14794 end = gdbarch_adjust_dwarf2_addr (gdbarch, end);
14795 cu->get_builder ()->record_block_range (block, start, end - 1);
14796 blockvec.emplace_back (start, end);
14799 BLOCK_RANGES(block) = make_blockranges (objfile, blockvec);
14803 /* Check whether the producer field indicates either of GCC < 4.6, or the
14804 Intel C/C++ compiler, and cache the result in CU. */
14807 check_producer (struct dwarf2_cu *cu)
14811 if (cu->producer == NULL)
14813 /* For unknown compilers expect their behavior is DWARF version
14816 GCC started to support .debug_types sections by -gdwarf-4 since
14817 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
14818 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14819 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14820 interpreted incorrectly by GDB now - GCC PR debug/48229. */
14822 else if (producer_is_gcc (cu->producer, &major, &minor))
14824 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
14825 cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
14827 else if (producer_is_icc (cu->producer, &major, &minor))
14829 cu->producer_is_icc = true;
14830 cu->producer_is_icc_lt_14 = major < 14;
14832 else if (startswith (cu->producer, "CodeWarrior S12/L-ISA"))
14833 cu->producer_is_codewarrior = true;
14836 /* For other non-GCC compilers, expect their behavior is DWARF version
14840 cu->checked_producer = true;
14843 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14844 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14845 during 4.6.0 experimental. */
14848 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
14850 if (!cu->checked_producer)
14851 check_producer (cu);
14853 return cu->producer_is_gxx_lt_4_6;
14857 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14858 with incorrect is_stmt attributes. */
14861 producer_is_codewarrior (struct dwarf2_cu *cu)
14863 if (!cu->checked_producer)
14864 check_producer (cu);
14866 return cu->producer_is_codewarrior;
14869 /* Return the default accessibility type if it is not overriden by
14870 DW_AT_accessibility. */
14872 static enum dwarf_access_attribute
14873 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
14875 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
14877 /* The default DWARF 2 accessibility for members is public, the default
14878 accessibility for inheritance is private. */
14880 if (die->tag != DW_TAG_inheritance)
14881 return DW_ACCESS_public;
14883 return DW_ACCESS_private;
14887 /* DWARF 3+ defines the default accessibility a different way. The same
14888 rules apply now for DW_TAG_inheritance as for the members and it only
14889 depends on the container kind. */
14891 if (die->parent->tag == DW_TAG_class_type)
14892 return DW_ACCESS_private;
14894 return DW_ACCESS_public;
14898 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
14899 offset. If the attribute was not found return 0, otherwise return
14900 1. If it was found but could not properly be handled, set *OFFSET
14904 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
14907 struct attribute *attr;
14909 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
14914 /* Note that we do not check for a section offset first here.
14915 This is because DW_AT_data_member_location is new in DWARF 4,
14916 so if we see it, we can assume that a constant form is really
14917 a constant and not a section offset. */
14918 if (attr_form_is_constant (attr))
14919 *offset = dwarf2_get_attr_constant_value (attr, 0);
14920 else if (attr_form_is_section_offset (attr))
14921 dwarf2_complex_location_expr_complaint ();
14922 else if (attr_form_is_block (attr))
14923 *offset = decode_locdesc (DW_BLOCK (attr), cu);
14925 dwarf2_complex_location_expr_complaint ();
14933 /* Add an aggregate field to the field list. */
14936 dwarf2_add_field (struct field_info *fip, struct die_info *die,
14937 struct dwarf2_cu *cu)
14939 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14940 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14941 struct nextfield *new_field;
14942 struct attribute *attr;
14944 const char *fieldname = "";
14946 if (die->tag == DW_TAG_inheritance)
14948 fip->baseclasses.emplace_back ();
14949 new_field = &fip->baseclasses.back ();
14953 fip->fields.emplace_back ();
14954 new_field = &fip->fields.back ();
14959 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
14961 new_field->accessibility = DW_UNSND (attr);
14963 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
14964 if (new_field->accessibility != DW_ACCESS_public)
14965 fip->non_public_fields = 1;
14967 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
14969 new_field->virtuality = DW_UNSND (attr);
14971 new_field->virtuality = DW_VIRTUALITY_none;
14973 fp = &new_field->field;
14975 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
14979 /* Data member other than a C++ static data member. */
14981 /* Get type of field. */
14982 fp->type = die_type (die, cu);
14984 SET_FIELD_BITPOS (*fp, 0);
14986 /* Get bit size of field (zero if none). */
14987 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
14990 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
14994 FIELD_BITSIZE (*fp) = 0;
14997 /* Get bit offset of field. */
14998 if (handle_data_member_location (die, cu, &offset))
14999 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15000 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
15003 if (gdbarch_bits_big_endian (gdbarch))
15005 /* For big endian bits, the DW_AT_bit_offset gives the
15006 additional bit offset from the MSB of the containing
15007 anonymous object to the MSB of the field. We don't
15008 have to do anything special since we don't need to
15009 know the size of the anonymous object. */
15010 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
15014 /* For little endian bits, compute the bit offset to the
15015 MSB of the anonymous object, subtract off the number of
15016 bits from the MSB of the field to the MSB of the
15017 object, and then subtract off the number of bits of
15018 the field itself. The result is the bit offset of
15019 the LSB of the field. */
15020 int anonymous_size;
15021 int bit_offset = DW_UNSND (attr);
15023 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15026 /* The size of the anonymous object containing
15027 the bit field is explicit, so use the
15028 indicated size (in bytes). */
15029 anonymous_size = DW_UNSND (attr);
15033 /* The size of the anonymous object containing
15034 the bit field must be inferred from the type
15035 attribute of the data member containing the
15037 anonymous_size = TYPE_LENGTH (fp->type);
15039 SET_FIELD_BITPOS (*fp,
15040 (FIELD_BITPOS (*fp)
15041 + anonymous_size * bits_per_byte
15042 - bit_offset - FIELD_BITSIZE (*fp)));
15045 attr = dwarf2_attr (die, DW_AT_data_bit_offset, cu);
15047 SET_FIELD_BITPOS (*fp, (FIELD_BITPOS (*fp)
15048 + dwarf2_get_attr_constant_value (attr, 0)));
15050 /* Get name of field. */
15051 fieldname = dwarf2_name (die, cu);
15052 if (fieldname == NULL)
15055 /* The name is already allocated along with this objfile, so we don't
15056 need to duplicate it for the type. */
15057 fp->name = fieldname;
15059 /* Change accessibility for artificial fields (e.g. virtual table
15060 pointer or virtual base class pointer) to private. */
15061 if (dwarf2_attr (die, DW_AT_artificial, cu))
15063 FIELD_ARTIFICIAL (*fp) = 1;
15064 new_field->accessibility = DW_ACCESS_private;
15065 fip->non_public_fields = 1;
15068 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
15070 /* C++ static member. */
15072 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15073 is a declaration, but all versions of G++ as of this writing
15074 (so through at least 3.2.1) incorrectly generate
15075 DW_TAG_variable tags. */
15077 const char *physname;
15079 /* Get name of field. */
15080 fieldname = dwarf2_name (die, cu);
15081 if (fieldname == NULL)
15084 attr = dwarf2_attr (die, DW_AT_const_value, cu);
15086 /* Only create a symbol if this is an external value.
15087 new_symbol checks this and puts the value in the global symbol
15088 table, which we want. If it is not external, new_symbol
15089 will try to put the value in cu->list_in_scope which is wrong. */
15090 && dwarf2_flag_true_p (die, DW_AT_external, cu))
15092 /* A static const member, not much different than an enum as far as
15093 we're concerned, except that we can support more types. */
15094 new_symbol (die, NULL, cu);
15097 /* Get physical name. */
15098 physname = dwarf2_physname (fieldname, die, cu);
15100 /* The name is already allocated along with this objfile, so we don't
15101 need to duplicate it for the type. */
15102 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
15103 FIELD_TYPE (*fp) = die_type (die, cu);
15104 FIELD_NAME (*fp) = fieldname;
15106 else if (die->tag == DW_TAG_inheritance)
15110 /* C++ base class field. */
15111 if (handle_data_member_location (die, cu, &offset))
15112 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15113 FIELD_BITSIZE (*fp) = 0;
15114 FIELD_TYPE (*fp) = die_type (die, cu);
15115 FIELD_NAME (*fp) = TYPE_NAME (fp->type);
15117 else if (die->tag == DW_TAG_variant_part)
15119 /* process_structure_scope will treat this DIE as a union. */
15120 process_structure_scope (die, cu);
15122 /* The variant part is relative to the start of the enclosing
15124 SET_FIELD_BITPOS (*fp, 0);
15125 fp->type = get_die_type (die, cu);
15126 fp->artificial = 1;
15127 fp->name = "<<variant>>";
15129 /* Normally a DW_TAG_variant_part won't have a size, but our
15130 representation requires one, so set it to the maximum of the
15132 if (TYPE_LENGTH (fp->type) == 0)
15135 for (int i = 0; i < TYPE_NFIELDS (fp->type); ++i)
15136 if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i)) > max)
15137 max = TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i));
15138 TYPE_LENGTH (fp->type) = max;
15142 gdb_assert_not_reached ("missing case in dwarf2_add_field");
15145 /* Can the type given by DIE define another type? */
15148 type_can_define_types (const struct die_info *die)
15152 case DW_TAG_typedef:
15153 case DW_TAG_class_type:
15154 case DW_TAG_structure_type:
15155 case DW_TAG_union_type:
15156 case DW_TAG_enumeration_type:
15164 /* Add a type definition defined in the scope of the FIP's class. */
15167 dwarf2_add_type_defn (struct field_info *fip, struct die_info *die,
15168 struct dwarf2_cu *cu)
15170 struct decl_field fp;
15171 memset (&fp, 0, sizeof (fp));
15173 gdb_assert (type_can_define_types (die));
15175 /* Get name of field. NULL is okay here, meaning an anonymous type. */
15176 fp.name = dwarf2_name (die, cu);
15177 fp.type = read_type_die (die, cu);
15179 /* Save accessibility. */
15180 enum dwarf_access_attribute accessibility;
15181 struct attribute *attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15183 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15185 accessibility = dwarf2_default_access_attribute (die, cu);
15186 switch (accessibility)
15188 case DW_ACCESS_public:
15189 /* The assumed value if neither private nor protected. */
15191 case DW_ACCESS_private:
15194 case DW_ACCESS_protected:
15195 fp.is_protected = 1;
15198 complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility);
15201 if (die->tag == DW_TAG_typedef)
15202 fip->typedef_field_list.push_back (fp);
15204 fip->nested_types_list.push_back (fp);
15207 /* Create the vector of fields, and attach it to the type. */
15210 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
15211 struct dwarf2_cu *cu)
15213 int nfields = fip->nfields;
15215 /* Record the field count, allocate space for the array of fields,
15216 and create blank accessibility bitfields if necessary. */
15217 TYPE_NFIELDS (type) = nfields;
15218 TYPE_FIELDS (type) = (struct field *)
15219 TYPE_ZALLOC (type, sizeof (struct field) * nfields);
15221 if (fip->non_public_fields && cu->language != language_ada)
15223 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15225 TYPE_FIELD_PRIVATE_BITS (type) =
15226 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15227 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
15229 TYPE_FIELD_PROTECTED_BITS (type) =
15230 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15231 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
15233 TYPE_FIELD_IGNORE_BITS (type) =
15234 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15235 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
15238 /* If the type has baseclasses, allocate and clear a bit vector for
15239 TYPE_FIELD_VIRTUAL_BITS. */
15240 if (!fip->baseclasses.empty () && cu->language != language_ada)
15242 int num_bytes = B_BYTES (fip->baseclasses.size ());
15243 unsigned char *pointer;
15245 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15246 pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes);
15247 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
15248 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->baseclasses.size ());
15249 TYPE_N_BASECLASSES (type) = fip->baseclasses.size ();
15252 if (TYPE_FLAG_DISCRIMINATED_UNION (type))
15254 struct discriminant_info *di = alloc_discriminant_info (type, -1, -1);
15256 for (int index = 0; index < nfields; ++index)
15258 struct nextfield &field = fip->fields[index];
15260 if (field.variant.is_discriminant)
15261 di->discriminant_index = index;
15262 else if (field.variant.default_branch)
15263 di->default_index = index;
15265 di->discriminants[index] = field.variant.discriminant_value;
15269 /* Copy the saved-up fields into the field vector. */
15270 for (int i = 0; i < nfields; ++i)
15272 struct nextfield &field
15273 = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i]
15274 : fip->fields[i - fip->baseclasses.size ()]);
15276 TYPE_FIELD (type, i) = field.field;
15277 switch (field.accessibility)
15279 case DW_ACCESS_private:
15280 if (cu->language != language_ada)
15281 SET_TYPE_FIELD_PRIVATE (type, i);
15284 case DW_ACCESS_protected:
15285 if (cu->language != language_ada)
15286 SET_TYPE_FIELD_PROTECTED (type, i);
15289 case DW_ACCESS_public:
15293 /* Unknown accessibility. Complain and treat it as public. */
15295 complaint (_("unsupported accessibility %d"),
15296 field.accessibility);
15300 if (i < fip->baseclasses.size ())
15302 switch (field.virtuality)
15304 case DW_VIRTUALITY_virtual:
15305 case DW_VIRTUALITY_pure_virtual:
15306 if (cu->language == language_ada)
15307 error (_("unexpected virtuality in component of Ada type"));
15308 SET_TYPE_FIELD_VIRTUAL (type, i);
15315 /* Return true if this member function is a constructor, false
15319 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
15321 const char *fieldname;
15322 const char *type_name;
15325 if (die->parent == NULL)
15328 if (die->parent->tag != DW_TAG_structure_type
15329 && die->parent->tag != DW_TAG_union_type
15330 && die->parent->tag != DW_TAG_class_type)
15333 fieldname = dwarf2_name (die, cu);
15334 type_name = dwarf2_name (die->parent, cu);
15335 if (fieldname == NULL || type_name == NULL)
15338 len = strlen (fieldname);
15339 return (strncmp (fieldname, type_name, len) == 0
15340 && (type_name[len] == '\0' || type_name[len] == '<'));
15343 /* Add a member function to the proper fieldlist. */
15346 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
15347 struct type *type, struct dwarf2_cu *cu)
15349 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15350 struct attribute *attr;
15352 struct fnfieldlist *flp = nullptr;
15353 struct fn_field *fnp;
15354 const char *fieldname;
15355 struct type *this_type;
15356 enum dwarf_access_attribute accessibility;
15358 if (cu->language == language_ada)
15359 error (_("unexpected member function in Ada type"));
15361 /* Get name of member function. */
15362 fieldname = dwarf2_name (die, cu);
15363 if (fieldname == NULL)
15366 /* Look up member function name in fieldlist. */
15367 for (i = 0; i < fip->fnfieldlists.size (); i++)
15369 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
15371 flp = &fip->fnfieldlists[i];
15376 /* Create a new fnfieldlist if necessary. */
15377 if (flp == nullptr)
15379 fip->fnfieldlists.emplace_back ();
15380 flp = &fip->fnfieldlists.back ();
15381 flp->name = fieldname;
15382 i = fip->fnfieldlists.size () - 1;
15385 /* Create a new member function field and add it to the vector of
15387 flp->fnfields.emplace_back ();
15388 fnp = &flp->fnfields.back ();
15390 /* Delay processing of the physname until later. */
15391 if (cu->language == language_cplus)
15392 add_to_method_list (type, i, flp->fnfields.size () - 1, fieldname,
15396 const char *physname = dwarf2_physname (fieldname, die, cu);
15397 fnp->physname = physname ? physname : "";
15400 fnp->type = alloc_type (objfile);
15401 this_type = read_type_die (die, cu);
15402 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
15404 int nparams = TYPE_NFIELDS (this_type);
15406 /* TYPE is the domain of this method, and THIS_TYPE is the type
15407 of the method itself (TYPE_CODE_METHOD). */
15408 smash_to_method_type (fnp->type, type,
15409 TYPE_TARGET_TYPE (this_type),
15410 TYPE_FIELDS (this_type),
15411 TYPE_NFIELDS (this_type),
15412 TYPE_VARARGS (this_type));
15414 /* Handle static member functions.
15415 Dwarf2 has no clean way to discern C++ static and non-static
15416 member functions. G++ helps GDB by marking the first
15417 parameter for non-static member functions (which is the this
15418 pointer) as artificial. We obtain this information from
15419 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
15420 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
15421 fnp->voffset = VOFFSET_STATIC;
15424 complaint (_("member function type missing for '%s'"),
15425 dwarf2_full_name (fieldname, die, cu));
15427 /* Get fcontext from DW_AT_containing_type if present. */
15428 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
15429 fnp->fcontext = die_containing_type (die, cu);
15431 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15432 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
15434 /* Get accessibility. */
15435 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15437 accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15439 accessibility = dwarf2_default_access_attribute (die, cu);
15440 switch (accessibility)
15442 case DW_ACCESS_private:
15443 fnp->is_private = 1;
15445 case DW_ACCESS_protected:
15446 fnp->is_protected = 1;
15450 /* Check for artificial methods. */
15451 attr = dwarf2_attr (die, DW_AT_artificial, cu);
15452 if (attr && DW_UNSND (attr) != 0)
15453 fnp->is_artificial = 1;
15455 fnp->is_constructor = dwarf2_is_constructor (die, cu);
15457 /* Get index in virtual function table if it is a virtual member
15458 function. For older versions of GCC, this is an offset in the
15459 appropriate virtual table, as specified by DW_AT_containing_type.
15460 For everyone else, it is an expression to be evaluated relative
15461 to the object address. */
15463 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
15466 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
15468 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
15470 /* Old-style GCC. */
15471 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
15473 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
15474 || (DW_BLOCK (attr)->size > 1
15475 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
15476 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
15478 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
15479 if ((fnp->voffset % cu->header.addr_size) != 0)
15480 dwarf2_complex_location_expr_complaint ();
15482 fnp->voffset /= cu->header.addr_size;
15486 dwarf2_complex_location_expr_complaint ();
15488 if (!fnp->fcontext)
15490 /* If there is no `this' field and no DW_AT_containing_type,
15491 we cannot actually find a base class context for the
15493 if (TYPE_NFIELDS (this_type) == 0
15494 || !TYPE_FIELD_ARTIFICIAL (this_type, 0))
15496 complaint (_("cannot determine context for virtual member "
15497 "function \"%s\" (offset %s)"),
15498 fieldname, sect_offset_str (die->sect_off));
15503 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
15507 else if (attr_form_is_section_offset (attr))
15509 dwarf2_complex_location_expr_complaint ();
15513 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15519 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15520 if (attr && DW_UNSND (attr))
15522 /* GCC does this, as of 2008-08-25; PR debug/37237. */
15523 complaint (_("Member function \"%s\" (offset %s) is virtual "
15524 "but the vtable offset is not specified"),
15525 fieldname, sect_offset_str (die->sect_off));
15526 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15527 TYPE_CPLUS_DYNAMIC (type) = 1;
15532 /* Create the vector of member function fields, and attach it to the type. */
15535 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
15536 struct dwarf2_cu *cu)
15538 if (cu->language == language_ada)
15539 error (_("unexpected member functions in Ada type"));
15541 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15542 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
15544 sizeof (struct fn_fieldlist) * fip->fnfieldlists.size ());
15546 for (int i = 0; i < fip->fnfieldlists.size (); i++)
15548 struct fnfieldlist &nf = fip->fnfieldlists[i];
15549 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
15551 TYPE_FN_FIELDLIST_NAME (type, i) = nf.name;
15552 TYPE_FN_FIELDLIST_LENGTH (type, i) = nf.fnfields.size ();
15553 fn_flp->fn_fields = (struct fn_field *)
15554 TYPE_ALLOC (type, sizeof (struct fn_field) * nf.fnfields.size ());
15556 for (int k = 0; k < nf.fnfields.size (); ++k)
15557 fn_flp->fn_fields[k] = nf.fnfields[k];
15560 TYPE_NFN_FIELDS (type) = fip->fnfieldlists.size ();
15563 /* Returns non-zero if NAME is the name of a vtable member in CU's
15564 language, zero otherwise. */
15566 is_vtable_name (const char *name, struct dwarf2_cu *cu)
15568 static const char vptr[] = "_vptr";
15570 /* Look for the C++ form of the vtable. */
15571 if (startswith (name, vptr) && is_cplus_marker (name[sizeof (vptr) - 1]))
15577 /* GCC outputs unnamed structures that are really pointers to member
15578 functions, with the ABI-specified layout. If TYPE describes
15579 such a structure, smash it into a member function type.
15581 GCC shouldn't do this; it should just output pointer to member DIEs.
15582 This is GCC PR debug/28767. */
15585 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
15587 struct type *pfn_type, *self_type, *new_type;
15589 /* Check for a structure with no name and two children. */
15590 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
15593 /* Check for __pfn and __delta members. */
15594 if (TYPE_FIELD_NAME (type, 0) == NULL
15595 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
15596 || TYPE_FIELD_NAME (type, 1) == NULL
15597 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
15600 /* Find the type of the method. */
15601 pfn_type = TYPE_FIELD_TYPE (type, 0);
15602 if (pfn_type == NULL
15603 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
15604 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
15607 /* Look for the "this" argument. */
15608 pfn_type = TYPE_TARGET_TYPE (pfn_type);
15609 if (TYPE_NFIELDS (pfn_type) == 0
15610 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15611 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
15614 self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
15615 new_type = alloc_type (objfile);
15616 smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
15617 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
15618 TYPE_VARARGS (pfn_type));
15619 smash_to_methodptr_type (type, new_type);
15622 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15623 appropriate error checking and issuing complaints if there is a
15627 get_alignment (struct dwarf2_cu *cu, struct die_info *die)
15629 struct attribute *attr = dwarf2_attr (die, DW_AT_alignment, cu);
15631 if (attr == nullptr)
15634 if (!attr_form_is_constant (attr))
15636 complaint (_("DW_AT_alignment must have constant form"
15637 " - DIE at %s [in module %s]"),
15638 sect_offset_str (die->sect_off),
15639 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15644 if (attr->form == DW_FORM_sdata)
15646 LONGEST val = DW_SND (attr);
15649 complaint (_("DW_AT_alignment value must not be negative"
15650 " - DIE at %s [in module %s]"),
15651 sect_offset_str (die->sect_off),
15652 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15658 align = DW_UNSND (attr);
15662 complaint (_("DW_AT_alignment value must not be zero"
15663 " - DIE at %s [in module %s]"),
15664 sect_offset_str (die->sect_off),
15665 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15668 if ((align & (align - 1)) != 0)
15670 complaint (_("DW_AT_alignment value must be a power of 2"
15671 " - DIE at %s [in module %s]"),
15672 sect_offset_str (die->sect_off),
15673 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15680 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15681 the alignment for TYPE. */
15684 maybe_set_alignment (struct dwarf2_cu *cu, struct die_info *die,
15687 if (!set_type_align (type, get_alignment (cu, die)))
15688 complaint (_("DW_AT_alignment value too large"
15689 " - DIE at %s [in module %s]"),
15690 sect_offset_str (die->sect_off),
15691 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15694 /* Called when we find the DIE that starts a structure or union scope
15695 (definition) to create a type for the structure or union. Fill in
15696 the type's name and general properties; the members will not be
15697 processed until process_structure_scope. A symbol table entry for
15698 the type will also not be done until process_structure_scope (assuming
15699 the type has a name).
15701 NOTE: we need to call these functions regardless of whether or not the
15702 DIE has a DW_AT_name attribute, since it might be an anonymous
15703 structure or union. This gets the type entered into our set of
15704 user defined types. */
15706 static struct type *
15707 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
15709 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15711 struct attribute *attr;
15714 /* If the definition of this type lives in .debug_types, read that type.
15715 Don't follow DW_AT_specification though, that will take us back up
15716 the chain and we want to go down. */
15717 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
15720 type = get_DW_AT_signature_type (die, attr, cu);
15722 /* The type's CU may not be the same as CU.
15723 Ensure TYPE is recorded with CU in die_type_hash. */
15724 return set_die_type (die, type, cu);
15727 type = alloc_type (objfile);
15728 INIT_CPLUS_SPECIFIC (type);
15730 name = dwarf2_name (die, cu);
15733 if (cu->language == language_cplus
15734 || cu->language == language_d
15735 || cu->language == language_rust)
15737 const char *full_name = dwarf2_full_name (name, die, cu);
15739 /* dwarf2_full_name might have already finished building the DIE's
15740 type. If so, there is no need to continue. */
15741 if (get_die_type (die, cu) != NULL)
15742 return get_die_type (die, cu);
15744 TYPE_NAME (type) = full_name;
15748 /* The name is already allocated along with this objfile, so
15749 we don't need to duplicate it for the type. */
15750 TYPE_NAME (type) = name;
15754 if (die->tag == DW_TAG_structure_type)
15756 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15758 else if (die->tag == DW_TAG_union_type)
15760 TYPE_CODE (type) = TYPE_CODE_UNION;
15762 else if (die->tag == DW_TAG_variant_part)
15764 TYPE_CODE (type) = TYPE_CODE_UNION;
15765 TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
15769 TYPE_CODE (type) = TYPE_CODE_STRUCT;
15772 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
15773 TYPE_DECLARED_CLASS (type) = 1;
15775 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15778 if (attr_form_is_constant (attr))
15779 TYPE_LENGTH (type) = DW_UNSND (attr);
15782 /* For the moment, dynamic type sizes are not supported
15783 by GDB's struct type. The actual size is determined
15784 on-demand when resolving the type of a given object,
15785 so set the type's length to zero for now. Otherwise,
15786 we record an expression as the length, and that expression
15787 could lead to a very large value, which could eventually
15788 lead to us trying to allocate that much memory when creating
15789 a value of that type. */
15790 TYPE_LENGTH (type) = 0;
15795 TYPE_LENGTH (type) = 0;
15798 maybe_set_alignment (cu, die, type);
15800 if (producer_is_icc_lt_14 (cu) && (TYPE_LENGTH (type) == 0))
15802 /* ICC<14 does not output the required DW_AT_declaration on
15803 incomplete types, but gives them a size of zero. */
15804 TYPE_STUB (type) = 1;
15807 TYPE_STUB_SUPPORTED (type) = 1;
15809 if (die_is_declaration (die, cu))
15810 TYPE_STUB (type) = 1;
15811 else if (attr == NULL && die->child == NULL
15812 && producer_is_realview (cu->producer))
15813 /* RealView does not output the required DW_AT_declaration
15814 on incomplete types. */
15815 TYPE_STUB (type) = 1;
15817 /* We need to add the type field to the die immediately so we don't
15818 infinitely recurse when dealing with pointers to the structure
15819 type within the structure itself. */
15820 set_die_type (die, type, cu);
15822 /* set_die_type should be already done. */
15823 set_descriptive_type (type, die, cu);
15828 /* A helper for process_structure_scope that handles a single member
15832 handle_struct_member_die (struct die_info *child_die, struct type *type,
15833 struct field_info *fi,
15834 std::vector<struct symbol *> *template_args,
15835 struct dwarf2_cu *cu)
15837 if (child_die->tag == DW_TAG_member
15838 || child_die->tag == DW_TAG_variable
15839 || child_die->tag == DW_TAG_variant_part)
15841 /* NOTE: carlton/2002-11-05: A C++ static data member
15842 should be a DW_TAG_member that is a declaration, but
15843 all versions of G++ as of this writing (so through at
15844 least 3.2.1) incorrectly generate DW_TAG_variable
15845 tags for them instead. */
15846 dwarf2_add_field (fi, child_die, cu);
15848 else if (child_die->tag == DW_TAG_subprogram)
15850 /* Rust doesn't have member functions in the C++ sense.
15851 However, it does emit ordinary functions as children
15852 of a struct DIE. */
15853 if (cu->language == language_rust)
15854 read_func_scope (child_die, cu);
15857 /* C++ member function. */
15858 dwarf2_add_member_fn (fi, child_die, type, cu);
15861 else if (child_die->tag == DW_TAG_inheritance)
15863 /* C++ base class field. */
15864 dwarf2_add_field (fi, child_die, cu);
15866 else if (type_can_define_types (child_die))
15867 dwarf2_add_type_defn (fi, child_die, cu);
15868 else if (child_die->tag == DW_TAG_template_type_param
15869 || child_die->tag == DW_TAG_template_value_param)
15871 struct symbol *arg = new_symbol (child_die, NULL, cu);
15874 template_args->push_back (arg);
15876 else if (child_die->tag == DW_TAG_variant)
15878 /* In a variant we want to get the discriminant and also add a
15879 field for our sole member child. */
15880 struct attribute *discr = dwarf2_attr (child_die, DW_AT_discr_value, cu);
15882 for (die_info *variant_child = child_die->child;
15883 variant_child != NULL;
15884 variant_child = sibling_die (variant_child))
15886 if (variant_child->tag == DW_TAG_member)
15888 handle_struct_member_die (variant_child, type, fi,
15889 template_args, cu);
15890 /* Only handle the one. */
15895 /* We don't handle this but we might as well report it if we see
15897 if (dwarf2_attr (child_die, DW_AT_discr_list, cu) != nullptr)
15898 complaint (_("DW_AT_discr_list is not supported yet"
15899 " - DIE at %s [in module %s]"),
15900 sect_offset_str (child_die->sect_off),
15901 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15903 /* The first field was just added, so we can stash the
15904 discriminant there. */
15905 gdb_assert (!fi->fields.empty ());
15907 fi->fields.back ().variant.default_branch = true;
15909 fi->fields.back ().variant.discriminant_value = DW_UNSND (discr);
15913 /* Finish creating a structure or union type, including filling in
15914 its members and creating a symbol for it. */
15917 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
15919 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15920 struct die_info *child_die;
15923 type = get_die_type (die, cu);
15925 type = read_structure_type (die, cu);
15927 /* When reading a DW_TAG_variant_part, we need to notice when we
15928 read the discriminant member, so we can record it later in the
15929 discriminant_info. */
15930 bool is_variant_part = TYPE_FLAG_DISCRIMINATED_UNION (type);
15931 sect_offset discr_offset;
15932 bool has_template_parameters = false;
15934 if (is_variant_part)
15936 struct attribute *discr = dwarf2_attr (die, DW_AT_discr, cu);
15939 /* Maybe it's a univariant form, an extension we support.
15940 In this case arrange not to check the offset. */
15941 is_variant_part = false;
15943 else if (attr_form_is_ref (discr))
15945 struct dwarf2_cu *target_cu = cu;
15946 struct die_info *target_die = follow_die_ref (die, discr, &target_cu);
15948 discr_offset = target_die->sect_off;
15952 complaint (_("DW_AT_discr does not have DIE reference form"
15953 " - DIE at %s [in module %s]"),
15954 sect_offset_str (die->sect_off),
15955 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15956 is_variant_part = false;
15960 if (die->child != NULL && ! die_is_declaration (die, cu))
15962 struct field_info fi;
15963 std::vector<struct symbol *> template_args;
15965 child_die = die->child;
15967 while (child_die && child_die->tag)
15969 handle_struct_member_die (child_die, type, &fi, &template_args, cu);
15971 if (is_variant_part && discr_offset == child_die->sect_off)
15972 fi.fields.back ().variant.is_discriminant = true;
15974 child_die = sibling_die (child_die);
15977 /* Attach template arguments to type. */
15978 if (!template_args.empty ())
15980 has_template_parameters = true;
15981 ALLOCATE_CPLUS_STRUCT_TYPE (type);
15982 TYPE_N_TEMPLATE_ARGUMENTS (type) = template_args.size ();
15983 TYPE_TEMPLATE_ARGUMENTS (type)
15984 = XOBNEWVEC (&objfile->objfile_obstack,
15986 TYPE_N_TEMPLATE_ARGUMENTS (type));
15987 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
15988 template_args.data (),
15989 (TYPE_N_TEMPLATE_ARGUMENTS (type)
15990 * sizeof (struct symbol *)));
15993 /* Attach fields and member functions to the type. */
15995 dwarf2_attach_fields_to_type (&fi, type, cu);
15996 if (!fi.fnfieldlists.empty ())
15998 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
16000 /* Get the type which refers to the base class (possibly this
16001 class itself) which contains the vtable pointer for the current
16002 class from the DW_AT_containing_type attribute. This use of
16003 DW_AT_containing_type is a GNU extension. */
16005 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
16007 struct type *t = die_containing_type (die, cu);
16009 set_type_vptr_basetype (type, t);
16014 /* Our own class provides vtbl ptr. */
16015 for (i = TYPE_NFIELDS (t) - 1;
16016 i >= TYPE_N_BASECLASSES (t);
16019 const char *fieldname = TYPE_FIELD_NAME (t, i);
16021 if (is_vtable_name (fieldname, cu))
16023 set_type_vptr_fieldno (type, i);
16028 /* Complain if virtual function table field not found. */
16029 if (i < TYPE_N_BASECLASSES (t))
16030 complaint (_("virtual function table pointer "
16031 "not found when defining class '%s'"),
16032 TYPE_NAME (type) ? TYPE_NAME (type) : "");
16036 set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
16039 else if (cu->producer
16040 && startswith (cu->producer, "IBM(R) XL C/C++ Advanced Edition"))
16042 /* The IBM XLC compiler does not provide direct indication
16043 of the containing type, but the vtable pointer is
16044 always named __vfp. */
16048 for (i = TYPE_NFIELDS (type) - 1;
16049 i >= TYPE_N_BASECLASSES (type);
16052 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
16054 set_type_vptr_fieldno (type, i);
16055 set_type_vptr_basetype (type, type);
16062 /* Copy fi.typedef_field_list linked list elements content into the
16063 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
16064 if (!fi.typedef_field_list.empty ())
16066 int count = fi.typedef_field_list.size ();
16068 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16069 TYPE_TYPEDEF_FIELD_ARRAY (type)
16070 = ((struct decl_field *)
16072 sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * count));
16073 TYPE_TYPEDEF_FIELD_COUNT (type) = count;
16075 for (int i = 0; i < fi.typedef_field_list.size (); ++i)
16076 TYPE_TYPEDEF_FIELD (type, i) = fi.typedef_field_list[i];
16079 /* Copy fi.nested_types_list linked list elements content into the
16080 allocated array TYPE_NESTED_TYPES_ARRAY (type). */
16081 if (!fi.nested_types_list.empty () && cu->language != language_ada)
16083 int count = fi.nested_types_list.size ();
16085 ALLOCATE_CPLUS_STRUCT_TYPE (type);
16086 TYPE_NESTED_TYPES_ARRAY (type)
16087 = ((struct decl_field *)
16088 TYPE_ALLOC (type, sizeof (struct decl_field) * count));
16089 TYPE_NESTED_TYPES_COUNT (type) = count;
16091 for (int i = 0; i < fi.nested_types_list.size (); ++i)
16092 TYPE_NESTED_TYPES_FIELD (type, i) = fi.nested_types_list[i];
16096 quirk_gcc_member_function_pointer (type, objfile);
16097 if (cu->language == language_rust && die->tag == DW_TAG_union_type)
16098 cu->rust_unions.push_back (type);
16100 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16101 snapshots) has been known to create a die giving a declaration
16102 for a class that has, as a child, a die giving a definition for a
16103 nested class. So we have to process our children even if the
16104 current die is a declaration. Normally, of course, a declaration
16105 won't have any children at all. */
16107 child_die = die->child;
16109 while (child_die != NULL && child_die->tag)
16111 if (child_die->tag == DW_TAG_member
16112 || child_die->tag == DW_TAG_variable
16113 || child_die->tag == DW_TAG_inheritance
16114 || child_die->tag == DW_TAG_template_value_param
16115 || child_die->tag == DW_TAG_template_type_param)
16120 process_die (child_die, cu);
16122 child_die = sibling_die (child_die);
16125 /* Do not consider external references. According to the DWARF standard,
16126 these DIEs are identified by the fact that they have no byte_size
16127 attribute, and a declaration attribute. */
16128 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
16129 || !die_is_declaration (die, cu))
16131 struct symbol *sym = new_symbol (die, type, cu);
16133 if (has_template_parameters)
16135 struct symtab *symtab;
16136 if (sym != nullptr)
16137 symtab = symbol_symtab (sym);
16138 else if (cu->line_header != nullptr)
16140 /* Any related symtab will do. */
16142 = cu->line_header->file_name_at (file_name_index (1))->symtab;
16147 complaint (_("could not find suitable "
16148 "symtab for template parameter"
16149 " - DIE at %s [in module %s]"),
16150 sect_offset_str (die->sect_off),
16151 objfile_name (objfile));
16154 if (symtab != nullptr)
16156 /* Make sure that the symtab is set on the new symbols.
16157 Even though they don't appear in this symtab directly,
16158 other parts of gdb assume that symbols do, and this is
16159 reasonably true. */
16160 for (int i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
16161 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type, i), symtab);
16167 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16168 update TYPE using some information only available in DIE's children. */
16171 update_enumeration_type_from_children (struct die_info *die,
16173 struct dwarf2_cu *cu)
16175 struct die_info *child_die;
16176 int unsigned_enum = 1;
16180 auto_obstack obstack;
16182 for (child_die = die->child;
16183 child_die != NULL && child_die->tag;
16184 child_die = sibling_die (child_die))
16186 struct attribute *attr;
16188 const gdb_byte *bytes;
16189 struct dwarf2_locexpr_baton *baton;
16192 if (child_die->tag != DW_TAG_enumerator)
16195 attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
16199 name = dwarf2_name (child_die, cu);
16201 name = "<anonymous enumerator>";
16203 dwarf2_const_value_attr (attr, type, name, &obstack, cu,
16204 &value, &bytes, &baton);
16210 else if ((mask & value) != 0)
16215 /* If we already know that the enum type is neither unsigned, nor
16216 a flag type, no need to look at the rest of the enumerates. */
16217 if (!unsigned_enum && !flag_enum)
16222 TYPE_UNSIGNED (type) = 1;
16224 TYPE_FLAG_ENUM (type) = 1;
16227 /* Given a DW_AT_enumeration_type die, set its type. We do not
16228 complete the type's fields yet, or create any symbols. */
16230 static struct type *
16231 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
16233 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16235 struct attribute *attr;
16238 /* If the definition of this type lives in .debug_types, read that type.
16239 Don't follow DW_AT_specification though, that will take us back up
16240 the chain and we want to go down. */
16241 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
16244 type = get_DW_AT_signature_type (die, attr, cu);
16246 /* The type's CU may not be the same as CU.
16247 Ensure TYPE is recorded with CU in die_type_hash. */
16248 return set_die_type (die, type, cu);
16251 type = alloc_type (objfile);
16253 TYPE_CODE (type) = TYPE_CODE_ENUM;
16254 name = dwarf2_full_name (NULL, die, cu);
16256 TYPE_NAME (type) = name;
16258 attr = dwarf2_attr (die, DW_AT_type, cu);
16261 struct type *underlying_type = die_type (die, cu);
16263 TYPE_TARGET_TYPE (type) = underlying_type;
16266 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16269 TYPE_LENGTH (type) = DW_UNSND (attr);
16273 TYPE_LENGTH (type) = 0;
16276 maybe_set_alignment (cu, die, type);
16278 /* The enumeration DIE can be incomplete. In Ada, any type can be
16279 declared as private in the package spec, and then defined only
16280 inside the package body. Such types are known as Taft Amendment
16281 Types. When another package uses such a type, an incomplete DIE
16282 may be generated by the compiler. */
16283 if (die_is_declaration (die, cu))
16284 TYPE_STUB (type) = 1;
16286 /* Finish the creation of this type by using the enum's children.
16287 We must call this even when the underlying type has been provided
16288 so that we can determine if we're looking at a "flag" enum. */
16289 update_enumeration_type_from_children (die, type, cu);
16291 /* If this type has an underlying type that is not a stub, then we
16292 may use its attributes. We always use the "unsigned" attribute
16293 in this situation, because ordinarily we guess whether the type
16294 is unsigned -- but the guess can be wrong and the underlying type
16295 can tell us the reality. However, we defer to a local size
16296 attribute if one exists, because this lets the compiler override
16297 the underlying type if needed. */
16298 if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
16300 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
16301 if (TYPE_LENGTH (type) == 0)
16302 TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
16303 if (TYPE_RAW_ALIGN (type) == 0
16304 && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)) != 0)
16305 set_type_align (type, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)));
16308 TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
16310 return set_die_type (die, type, cu);
16313 /* Given a pointer to a die which begins an enumeration, process all
16314 the dies that define the members of the enumeration, and create the
16315 symbol for the enumeration type.
16317 NOTE: We reverse the order of the element list. */
16320 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
16322 struct type *this_type;
16324 this_type = get_die_type (die, cu);
16325 if (this_type == NULL)
16326 this_type = read_enumeration_type (die, cu);
16328 if (die->child != NULL)
16330 struct die_info *child_die;
16331 struct symbol *sym;
16332 struct field *fields = NULL;
16333 int num_fields = 0;
16336 child_die = die->child;
16337 while (child_die && child_die->tag)
16339 if (child_die->tag != DW_TAG_enumerator)
16341 process_die (child_die, cu);
16345 name = dwarf2_name (child_die, cu);
16348 sym = new_symbol (child_die, this_type, cu);
16350 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
16352 fields = (struct field *)
16354 (num_fields + DW_FIELD_ALLOC_CHUNK)
16355 * sizeof (struct field));
16358 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
16359 FIELD_TYPE (fields[num_fields]) = NULL;
16360 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
16361 FIELD_BITSIZE (fields[num_fields]) = 0;
16367 child_die = sibling_die (child_die);
16372 TYPE_NFIELDS (this_type) = num_fields;
16373 TYPE_FIELDS (this_type) = (struct field *)
16374 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
16375 memcpy (TYPE_FIELDS (this_type), fields,
16376 sizeof (struct field) * num_fields);
16381 /* If we are reading an enum from a .debug_types unit, and the enum
16382 is a declaration, and the enum is not the signatured type in the
16383 unit, then we do not want to add a symbol for it. Adding a
16384 symbol would in some cases obscure the true definition of the
16385 enum, giving users an incomplete type when the definition is
16386 actually available. Note that we do not want to do this for all
16387 enums which are just declarations, because C++0x allows forward
16388 enum declarations. */
16389 if (cu->per_cu->is_debug_types
16390 && die_is_declaration (die, cu))
16392 struct signatured_type *sig_type;
16394 sig_type = (struct signatured_type *) cu->per_cu;
16395 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
16396 if (sig_type->type_offset_in_section != die->sect_off)
16400 new_symbol (die, this_type, cu);
16403 /* Extract all information from a DW_TAG_array_type DIE and put it in
16404 the DIE's type field. For now, this only handles one dimensional
16407 static struct type *
16408 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
16410 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16411 struct die_info *child_die;
16413 struct type *element_type, *range_type, *index_type;
16414 struct attribute *attr;
16416 struct dynamic_prop *byte_stride_prop = NULL;
16417 unsigned int bit_stride = 0;
16419 element_type = die_type (die, cu);
16421 /* The die_type call above may have already set the type for this DIE. */
16422 type = get_die_type (die, cu);
16426 attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
16430 struct type *prop_type
16431 = dwarf2_per_cu_addr_sized_int_type (cu->per_cu, false);
16434 = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
16435 stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop,
16439 complaint (_("unable to read array DW_AT_byte_stride "
16440 " - DIE at %s [in module %s]"),
16441 sect_offset_str (die->sect_off),
16442 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16443 /* Ignore this attribute. We will likely not be able to print
16444 arrays of this type correctly, but there is little we can do
16445 to help if we cannot read the attribute's value. */
16446 byte_stride_prop = NULL;
16450 attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
16452 bit_stride = DW_UNSND (attr);
16454 /* Irix 6.2 native cc creates array types without children for
16455 arrays with unspecified length. */
16456 if (die->child == NULL)
16458 index_type = objfile_type (objfile)->builtin_int;
16459 range_type = create_static_range_type (NULL, index_type, 0, -1);
16460 type = create_array_type_with_stride (NULL, element_type, range_type,
16461 byte_stride_prop, bit_stride);
16462 return set_die_type (die, type, cu);
16465 std::vector<struct type *> range_types;
16466 child_die = die->child;
16467 while (child_die && child_die->tag)
16469 if (child_die->tag == DW_TAG_subrange_type)
16471 struct type *child_type = read_type_die (child_die, cu);
16473 if (child_type != NULL)
16475 /* The range type was succesfully read. Save it for the
16476 array type creation. */
16477 range_types.push_back (child_type);
16480 child_die = sibling_die (child_die);
16483 /* Dwarf2 dimensions are output from left to right, create the
16484 necessary array types in backwards order. */
16486 type = element_type;
16488 if (read_array_order (die, cu) == DW_ORD_col_major)
16492 while (i < range_types.size ())
16493 type = create_array_type_with_stride (NULL, type, range_types[i++],
16494 byte_stride_prop, bit_stride);
16498 size_t ndim = range_types.size ();
16500 type = create_array_type_with_stride (NULL, type, range_types[ndim],
16501 byte_stride_prop, bit_stride);
16504 /* Understand Dwarf2 support for vector types (like they occur on
16505 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
16506 array type. This is not part of the Dwarf2/3 standard yet, but a
16507 custom vendor extension. The main difference between a regular
16508 array and the vector variant is that vectors are passed by value
16510 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
16512 make_vector_type (type);
16514 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
16515 implementation may choose to implement triple vectors using this
16517 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16520 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
16521 TYPE_LENGTH (type) = DW_UNSND (attr);
16523 complaint (_("DW_AT_byte_size for array type smaller "
16524 "than the total size of elements"));
16527 name = dwarf2_name (die, cu);
16529 TYPE_NAME (type) = name;
16531 maybe_set_alignment (cu, die, type);
16533 /* Install the type in the die. */
16534 set_die_type (die, type, cu);
16536 /* set_die_type should be already done. */
16537 set_descriptive_type (type, die, cu);
16542 static enum dwarf_array_dim_ordering
16543 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
16545 struct attribute *attr;
16547 attr = dwarf2_attr (die, DW_AT_ordering, cu);
16550 return (enum dwarf_array_dim_ordering) DW_SND (attr);
16552 /* GNU F77 is a special case, as at 08/2004 array type info is the
16553 opposite order to the dwarf2 specification, but data is still
16554 laid out as per normal fortran.
16556 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16557 version checking. */
16559 if (cu->language == language_fortran
16560 && cu->producer && strstr (cu->producer, "GNU F77"))
16562 return DW_ORD_row_major;
16565 switch (cu->language_defn->la_array_ordering)
16567 case array_column_major:
16568 return DW_ORD_col_major;
16569 case array_row_major:
16571 return DW_ORD_row_major;
16575 /* Extract all information from a DW_TAG_set_type DIE and put it in
16576 the DIE's type field. */
16578 static struct type *
16579 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
16581 struct type *domain_type, *set_type;
16582 struct attribute *attr;
16584 domain_type = die_type (die, cu);
16586 /* The die_type call above may have already set the type for this DIE. */
16587 set_type = get_die_type (die, cu);
16591 set_type = create_set_type (NULL, domain_type);
16593 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16595 TYPE_LENGTH (set_type) = DW_UNSND (attr);
16597 maybe_set_alignment (cu, die, set_type);
16599 return set_die_type (die, set_type, cu);
16602 /* A helper for read_common_block that creates a locexpr baton.
16603 SYM is the symbol which we are marking as computed.
16604 COMMON_DIE is the DIE for the common block.
16605 COMMON_LOC is the location expression attribute for the common
16607 MEMBER_LOC is the location expression attribute for the particular
16608 member of the common block that we are processing.
16609 CU is the CU from which the above come. */
16612 mark_common_block_symbol_computed (struct symbol *sym,
16613 struct die_info *common_die,
16614 struct attribute *common_loc,
16615 struct attribute *member_loc,
16616 struct dwarf2_cu *cu)
16618 struct dwarf2_per_objfile *dwarf2_per_objfile
16619 = cu->per_cu->dwarf2_per_objfile;
16620 struct objfile *objfile = dwarf2_per_objfile->objfile;
16621 struct dwarf2_locexpr_baton *baton;
16623 unsigned int cu_off;
16624 enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
16625 LONGEST offset = 0;
16627 gdb_assert (common_loc && member_loc);
16628 gdb_assert (attr_form_is_block (common_loc));
16629 gdb_assert (attr_form_is_block (member_loc)
16630 || attr_form_is_constant (member_loc));
16632 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
16633 baton->per_cu = cu->per_cu;
16634 gdb_assert (baton->per_cu);
16636 baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16638 if (attr_form_is_constant (member_loc))
16640 offset = dwarf2_get_attr_constant_value (member_loc, 0);
16641 baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
16644 baton->size += DW_BLOCK (member_loc)->size;
16646 ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
16649 *ptr++ = DW_OP_call4;
16650 cu_off = common_die->sect_off - cu->per_cu->sect_off;
16651 store_unsigned_integer (ptr, 4, byte_order, cu_off);
16654 if (attr_form_is_constant (member_loc))
16656 *ptr++ = DW_OP_addr;
16657 store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
16658 ptr += cu->header.addr_size;
16662 /* We have to copy the data here, because DW_OP_call4 will only
16663 use a DW_AT_location attribute. */
16664 memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
16665 ptr += DW_BLOCK (member_loc)->size;
16668 *ptr++ = DW_OP_plus;
16669 gdb_assert (ptr - baton->data == baton->size);
16671 SYMBOL_LOCATION_BATON (sym) = baton;
16672 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
16675 /* Create appropriate locally-scoped variables for all the
16676 DW_TAG_common_block entries. Also create a struct common_block
16677 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
16678 is used to sepate the common blocks name namespace from regular
16682 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
16684 struct attribute *attr;
16686 attr = dwarf2_attr (die, DW_AT_location, cu);
16689 /* Support the .debug_loc offsets. */
16690 if (attr_form_is_block (attr))
16694 else if (attr_form_is_section_offset (attr))
16696 dwarf2_complex_location_expr_complaint ();
16701 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16702 "common block member");
16707 if (die->child != NULL)
16709 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16710 struct die_info *child_die;
16711 size_t n_entries = 0, size;
16712 struct common_block *common_block;
16713 struct symbol *sym;
16715 for (child_die = die->child;
16716 child_die && child_die->tag;
16717 child_die = sibling_die (child_die))
16720 size = (sizeof (struct common_block)
16721 + (n_entries - 1) * sizeof (struct symbol *));
16723 = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
16725 memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
16726 common_block->n_entries = 0;
16728 for (child_die = die->child;
16729 child_die && child_die->tag;
16730 child_die = sibling_die (child_die))
16732 /* Create the symbol in the DW_TAG_common_block block in the current
16734 sym = new_symbol (child_die, NULL, cu);
16737 struct attribute *member_loc;
16739 common_block->contents[common_block->n_entries++] = sym;
16741 member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
16745 /* GDB has handled this for a long time, but it is
16746 not specified by DWARF. It seems to have been
16747 emitted by gfortran at least as recently as:
16748 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
16749 complaint (_("Variable in common block has "
16750 "DW_AT_data_member_location "
16751 "- DIE at %s [in module %s]"),
16752 sect_offset_str (child_die->sect_off),
16753 objfile_name (objfile));
16755 if (attr_form_is_section_offset (member_loc))
16756 dwarf2_complex_location_expr_complaint ();
16757 else if (attr_form_is_constant (member_loc)
16758 || attr_form_is_block (member_loc))
16761 mark_common_block_symbol_computed (sym, die, attr,
16765 dwarf2_complex_location_expr_complaint ();
16770 sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
16771 SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
16775 /* Create a type for a C++ namespace. */
16777 static struct type *
16778 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
16780 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16781 const char *previous_prefix, *name;
16785 /* For extensions, reuse the type of the original namespace. */
16786 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
16788 struct die_info *ext_die;
16789 struct dwarf2_cu *ext_cu = cu;
16791 ext_die = dwarf2_extension (die, &ext_cu);
16792 type = read_type_die (ext_die, ext_cu);
16794 /* EXT_CU may not be the same as CU.
16795 Ensure TYPE is recorded with CU in die_type_hash. */
16796 return set_die_type (die, type, cu);
16799 name = namespace_name (die, &is_anonymous, cu);
16801 /* Now build the name of the current namespace. */
16803 previous_prefix = determine_prefix (die, cu);
16804 if (previous_prefix[0] != '\0')
16805 name = typename_concat (&objfile->objfile_obstack,
16806 previous_prefix, name, 0, cu);
16808 /* Create the type. */
16809 type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
16811 return set_die_type (die, type, cu);
16814 /* Read a namespace scope. */
16817 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
16819 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16822 /* Add a symbol associated to this if we haven't seen the namespace
16823 before. Also, add a using directive if it's an anonymous
16826 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
16830 type = read_type_die (die, cu);
16831 new_symbol (die, type, cu);
16833 namespace_name (die, &is_anonymous, cu);
16836 const char *previous_prefix = determine_prefix (die, cu);
16838 std::vector<const char *> excludes;
16839 add_using_directive (using_directives (cu),
16840 previous_prefix, TYPE_NAME (type), NULL,
16841 NULL, excludes, 0, &objfile->objfile_obstack);
16845 if (die->child != NULL)
16847 struct die_info *child_die = die->child;
16849 while (child_die && child_die->tag)
16851 process_die (child_die, cu);
16852 child_die = sibling_die (child_die);
16857 /* Read a Fortran module as type. This DIE can be only a declaration used for
16858 imported module. Still we need that type as local Fortran "use ... only"
16859 declaration imports depend on the created type in determine_prefix. */
16861 static struct type *
16862 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
16864 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16865 const char *module_name;
16868 module_name = dwarf2_name (die, cu);
16869 type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
16871 return set_die_type (die, type, cu);
16874 /* Read a Fortran module. */
16877 read_module (struct die_info *die, struct dwarf2_cu *cu)
16879 struct die_info *child_die = die->child;
16882 type = read_type_die (die, cu);
16883 new_symbol (die, type, cu);
16885 while (child_die && child_die->tag)
16887 process_die (child_die, cu);
16888 child_die = sibling_die (child_die);
16892 /* Return the name of the namespace represented by DIE. Set
16893 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16896 static const char *
16897 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
16899 struct die_info *current_die;
16900 const char *name = NULL;
16902 /* Loop through the extensions until we find a name. */
16904 for (current_die = die;
16905 current_die != NULL;
16906 current_die = dwarf2_extension (die, &cu))
16908 /* We don't use dwarf2_name here so that we can detect the absence
16909 of a name -> anonymous namespace. */
16910 name = dwarf2_string_attr (die, DW_AT_name, cu);
16916 /* Is it an anonymous namespace? */
16918 *is_anonymous = (name == NULL);
16920 name = CP_ANONYMOUS_NAMESPACE_STR;
16925 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16926 the user defined type vector. */
16928 static struct type *
16929 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
16931 struct gdbarch *gdbarch
16932 = get_objfile_arch (cu->per_cu->dwarf2_per_objfile->objfile);
16933 struct comp_unit_head *cu_header = &cu->header;
16935 struct attribute *attr_byte_size;
16936 struct attribute *attr_address_class;
16937 int byte_size, addr_class;
16938 struct type *target_type;
16940 target_type = die_type (die, cu);
16942 /* The die_type call above may have already set the type for this DIE. */
16943 type = get_die_type (die, cu);
16947 type = lookup_pointer_type (target_type);
16949 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
16950 if (attr_byte_size)
16951 byte_size = DW_UNSND (attr_byte_size);
16953 byte_size = cu_header->addr_size;
16955 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
16956 if (attr_address_class)
16957 addr_class = DW_UNSND (attr_address_class);
16959 addr_class = DW_ADDR_none;
16961 ULONGEST alignment = get_alignment (cu, die);
16963 /* If the pointer size, alignment, or address class is different
16964 than the default, create a type variant marked as such and set
16965 the length accordingly. */
16966 if (TYPE_LENGTH (type) != byte_size
16967 || (alignment != 0 && TYPE_RAW_ALIGN (type) != 0
16968 && alignment != TYPE_RAW_ALIGN (type))
16969 || addr_class != DW_ADDR_none)
16971 if (gdbarch_address_class_type_flags_p (gdbarch))
16975 type_flags = gdbarch_address_class_type_flags
16976 (gdbarch, byte_size, addr_class);
16977 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
16979 type = make_type_with_address_space (type, type_flags);
16981 else if (TYPE_LENGTH (type) != byte_size)
16983 complaint (_("invalid pointer size %d"), byte_size);
16985 else if (TYPE_RAW_ALIGN (type) != alignment)
16987 complaint (_("Invalid DW_AT_alignment"
16988 " - DIE at %s [in module %s]"),
16989 sect_offset_str (die->sect_off),
16990 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16994 /* Should we also complain about unhandled address classes? */
16998 TYPE_LENGTH (type) = byte_size;
16999 set_type_align (type, alignment);
17000 return set_die_type (die, type, cu);
17003 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17004 the user defined type vector. */
17006 static struct type *
17007 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
17010 struct type *to_type;
17011 struct type *domain;
17013 to_type = die_type (die, cu);
17014 domain = die_containing_type (die, cu);
17016 /* The calls above may have already set the type for this DIE. */
17017 type = get_die_type (die, cu);
17021 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
17022 type = lookup_methodptr_type (to_type);
17023 else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
17025 struct type *new_type
17026 = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
17028 smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
17029 TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
17030 TYPE_VARARGS (to_type));
17031 type = lookup_methodptr_type (new_type);
17034 type = lookup_memberptr_type (to_type, domain);
17036 return set_die_type (die, type, cu);
17039 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17040 the user defined type vector. */
17042 static struct type *
17043 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
17044 enum type_code refcode)
17046 struct comp_unit_head *cu_header = &cu->header;
17047 struct type *type, *target_type;
17048 struct attribute *attr;
17050 gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
17052 target_type = die_type (die, cu);
17054 /* The die_type call above may have already set the type for this DIE. */
17055 type = get_die_type (die, cu);
17059 type = lookup_reference_type (target_type, refcode);
17060 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17063 TYPE_LENGTH (type) = DW_UNSND (attr);
17067 TYPE_LENGTH (type) = cu_header->addr_size;
17069 maybe_set_alignment (cu, die, type);
17070 return set_die_type (die, type, cu);
17073 /* Add the given cv-qualifiers to the element type of the array. GCC
17074 outputs DWARF type qualifiers that apply to an array, not the
17075 element type. But GDB relies on the array element type to carry
17076 the cv-qualifiers. This mimics section 6.7.3 of the C99
17079 static struct type *
17080 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
17081 struct type *base_type, int cnst, int voltl)
17083 struct type *el_type, *inner_array;
17085 base_type = copy_type (base_type);
17086 inner_array = base_type;
17088 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
17090 TYPE_TARGET_TYPE (inner_array) =
17091 copy_type (TYPE_TARGET_TYPE (inner_array));
17092 inner_array = TYPE_TARGET_TYPE (inner_array);
17095 el_type = TYPE_TARGET_TYPE (inner_array);
17096 cnst |= TYPE_CONST (el_type);
17097 voltl |= TYPE_VOLATILE (el_type);
17098 TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
17100 return set_die_type (die, base_type, cu);
17103 static struct type *
17104 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
17106 struct type *base_type, *cv_type;
17108 base_type = die_type (die, cu);
17110 /* The die_type call above may have already set the type for this DIE. */
17111 cv_type = get_die_type (die, cu);
17115 /* In case the const qualifier is applied to an array type, the element type
17116 is so qualified, not the array type (section 6.7.3 of C99). */
17117 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17118 return add_array_cv_type (die, cu, base_type, 1, 0);
17120 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
17121 return set_die_type (die, cv_type, cu);
17124 static struct type *
17125 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
17127 struct type *base_type, *cv_type;
17129 base_type = die_type (die, cu);
17131 /* The die_type call above may have already set the type for this DIE. */
17132 cv_type = get_die_type (die, cu);
17136 /* In case the volatile qualifier is applied to an array type, the
17137 element type is so qualified, not the array type (section 6.7.3
17139 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17140 return add_array_cv_type (die, cu, base_type, 0, 1);
17142 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
17143 return set_die_type (die, cv_type, cu);
17146 /* Handle DW_TAG_restrict_type. */
17148 static struct type *
17149 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
17151 struct type *base_type, *cv_type;
17153 base_type = die_type (die, cu);
17155 /* The die_type call above may have already set the type for this DIE. */
17156 cv_type = get_die_type (die, cu);
17160 cv_type = make_restrict_type (base_type);
17161 return set_die_type (die, cv_type, cu);
17164 /* Handle DW_TAG_atomic_type. */
17166 static struct type *
17167 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
17169 struct type *base_type, *cv_type;
17171 base_type = die_type (die, cu);
17173 /* The die_type call above may have already set the type for this DIE. */
17174 cv_type = get_die_type (die, cu);
17178 cv_type = make_atomic_type (base_type);
17179 return set_die_type (die, cv_type, cu);
17182 /* Extract all information from a DW_TAG_string_type DIE and add to
17183 the user defined type vector. It isn't really a user defined type,
17184 but it behaves like one, with other DIE's using an AT_user_def_type
17185 attribute to reference it. */
17187 static struct type *
17188 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
17190 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17191 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17192 struct type *type, *range_type, *index_type, *char_type;
17193 struct attribute *attr;
17194 unsigned int length;
17196 attr = dwarf2_attr (die, DW_AT_string_length, cu);
17199 length = DW_UNSND (attr);
17203 /* Check for the DW_AT_byte_size attribute. */
17204 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17207 length = DW_UNSND (attr);
17215 index_type = objfile_type (objfile)->builtin_int;
17216 range_type = create_static_range_type (NULL, index_type, 1, length);
17217 char_type = language_string_char_type (cu->language_defn, gdbarch);
17218 type = create_string_type (NULL, char_type, range_type);
17220 return set_die_type (die, type, cu);
17223 /* Assuming that DIE corresponds to a function, returns nonzero
17224 if the function is prototyped. */
17227 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
17229 struct attribute *attr;
17231 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
17232 if (attr && (DW_UNSND (attr) != 0))
17235 /* The DWARF standard implies that the DW_AT_prototyped attribute
17236 is only meaninful for C, but the concept also extends to other
17237 languages that allow unprototyped functions (Eg: Objective C).
17238 For all other languages, assume that functions are always
17240 if (cu->language != language_c
17241 && cu->language != language_objc
17242 && cu->language != language_opencl)
17245 /* RealView does not emit DW_AT_prototyped. We can not distinguish
17246 prototyped and unprototyped functions; default to prototyped,
17247 since that is more common in modern code (and RealView warns
17248 about unprototyped functions). */
17249 if (producer_is_realview (cu->producer))
17255 /* Handle DIES due to C code like:
17259 int (*funcp)(int a, long l);
17263 ('funcp' generates a DW_TAG_subroutine_type DIE). */
17265 static struct type *
17266 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
17268 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17269 struct type *type; /* Type that this function returns. */
17270 struct type *ftype; /* Function that returns above type. */
17271 struct attribute *attr;
17273 type = die_type (die, cu);
17275 /* The die_type call above may have already set the type for this DIE. */
17276 ftype = get_die_type (die, cu);
17280 ftype = lookup_function_type (type);
17282 if (prototyped_function_p (die, cu))
17283 TYPE_PROTOTYPED (ftype) = 1;
17285 /* Store the calling convention in the type if it's available in
17286 the subroutine die. Otherwise set the calling convention to
17287 the default value DW_CC_normal. */
17288 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
17290 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
17291 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
17292 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
17294 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
17296 /* Record whether the function returns normally to its caller or not
17297 if the DWARF producer set that information. */
17298 attr = dwarf2_attr (die, DW_AT_noreturn, cu);
17299 if (attr && (DW_UNSND (attr) != 0))
17300 TYPE_NO_RETURN (ftype) = 1;
17302 /* We need to add the subroutine type to the die immediately so
17303 we don't infinitely recurse when dealing with parameters
17304 declared as the same subroutine type. */
17305 set_die_type (die, ftype, cu);
17307 if (die->child != NULL)
17309 struct type *void_type = objfile_type (objfile)->builtin_void;
17310 struct die_info *child_die;
17311 int nparams, iparams;
17313 /* Count the number of parameters.
17314 FIXME: GDB currently ignores vararg functions, but knows about
17315 vararg member functions. */
17317 child_die = die->child;
17318 while (child_die && child_die->tag)
17320 if (child_die->tag == DW_TAG_formal_parameter)
17322 else if (child_die->tag == DW_TAG_unspecified_parameters)
17323 TYPE_VARARGS (ftype) = 1;
17324 child_die = sibling_die (child_die);
17327 /* Allocate storage for parameters and fill them in. */
17328 TYPE_NFIELDS (ftype) = nparams;
17329 TYPE_FIELDS (ftype) = (struct field *)
17330 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
17332 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
17333 even if we error out during the parameters reading below. */
17334 for (iparams = 0; iparams < nparams; iparams++)
17335 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
17338 child_die = die->child;
17339 while (child_die && child_die->tag)
17341 if (child_die->tag == DW_TAG_formal_parameter)
17343 struct type *arg_type;
17345 /* DWARF version 2 has no clean way to discern C++
17346 static and non-static member functions. G++ helps
17347 GDB by marking the first parameter for non-static
17348 member functions (which is the this pointer) as
17349 artificial. We pass this information to
17350 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17352 DWARF version 3 added DW_AT_object_pointer, which GCC
17353 4.5 does not yet generate. */
17354 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
17356 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
17358 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
17359 arg_type = die_type (child_die, cu);
17361 /* RealView does not mark THIS as const, which the testsuite
17362 expects. GCC marks THIS as const in method definitions,
17363 but not in the class specifications (GCC PR 43053). */
17364 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
17365 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
17368 struct dwarf2_cu *arg_cu = cu;
17369 const char *name = dwarf2_name (child_die, cu);
17371 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
17374 /* If the compiler emits this, use it. */
17375 if (follow_die_ref (die, attr, &arg_cu) == child_die)
17378 else if (name && strcmp (name, "this") == 0)
17379 /* Function definitions will have the argument names. */
17381 else if (name == NULL && iparams == 0)
17382 /* Declarations may not have the names, so like
17383 elsewhere in GDB, assume an artificial first
17384 argument is "this". */
17388 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
17392 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
17395 child_die = sibling_die (child_die);
17402 static struct type *
17403 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
17405 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17406 const char *name = NULL;
17407 struct type *this_type, *target_type;
17409 name = dwarf2_full_name (NULL, die, cu);
17410 this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
17411 TYPE_TARGET_STUB (this_type) = 1;
17412 set_die_type (die, this_type, cu);
17413 target_type = die_type (die, cu);
17414 if (target_type != this_type)
17415 TYPE_TARGET_TYPE (this_type) = target_type;
17418 /* Self-referential typedefs are, it seems, not allowed by the DWARF
17419 spec and cause infinite loops in GDB. */
17420 complaint (_("Self-referential DW_TAG_typedef "
17421 "- DIE at %s [in module %s]"),
17422 sect_offset_str (die->sect_off), objfile_name (objfile));
17423 TYPE_TARGET_TYPE (this_type) = NULL;
17428 /* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
17429 (which may be different from NAME) to the architecture back-end to allow
17430 it to guess the correct format if necessary. */
17432 static struct type *
17433 dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
17434 const char *name_hint)
17436 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17437 const struct floatformat **format;
17440 format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
17442 type = init_float_type (objfile, bits, name, format);
17444 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17449 /* Allocate an integer type of size BITS and name NAME. */
17451 static struct type *
17452 dwarf2_init_integer_type (struct dwarf2_cu *cu, struct objfile *objfile,
17453 int bits, int unsigned_p, const char *name)
17457 /* Versions of Intel's C Compiler generate an integer type called "void"
17458 instead of using DW_TAG_unspecified_type. This has been seen on
17459 at least versions 14, 17, and 18. */
17460 if (bits == 0 && producer_is_icc (cu) && name != nullptr
17461 && strcmp (name, "void") == 0)
17462 type = objfile_type (objfile)->builtin_void;
17464 type = init_integer_type (objfile, bits, unsigned_p, name);
17469 /* Initialise and return a floating point type of size BITS suitable for
17470 use as a component of a complex number. The NAME_HINT is passed through
17471 when initialising the floating point type and is the name of the complex
17474 As DWARF doesn't currently provide an explicit name for the components
17475 of a complex number, but it can be helpful to have these components
17476 named, we try to select a suitable name based on the size of the
17478 static struct type *
17479 dwarf2_init_complex_target_type (struct dwarf2_cu *cu,
17480 struct objfile *objfile,
17481 int bits, const char *name_hint)
17483 gdbarch *gdbarch = get_objfile_arch (objfile);
17484 struct type *tt = nullptr;
17486 /* Try to find a suitable floating point builtin type of size BITS.
17487 We're going to use the name of this type as the name for the complex
17488 target type that we are about to create. */
17489 switch (cu->language)
17491 case language_fortran:
17495 tt = builtin_f_type (gdbarch)->builtin_real;
17498 tt = builtin_f_type (gdbarch)->builtin_real_s8;
17500 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17502 tt = builtin_f_type (gdbarch)->builtin_real_s16;
17510 tt = builtin_type (gdbarch)->builtin_float;
17513 tt = builtin_type (gdbarch)->builtin_double;
17515 case 96: /* The x86-32 ABI specifies 96-bit long double. */
17517 tt = builtin_type (gdbarch)->builtin_long_double;
17523 /* If the type we found doesn't match the size we were looking for, then
17524 pretend we didn't find a type at all, the complex target type we
17525 create will then be nameless. */
17526 if (tt != nullptr && TYPE_LENGTH (tt) * TARGET_CHAR_BIT != bits)
17529 const char *name = (tt == nullptr) ? nullptr : TYPE_NAME (tt);
17530 return dwarf2_init_float_type (objfile, bits, name, name_hint);
17533 /* Find a representation of a given base type and install
17534 it in the TYPE field of the die. */
17536 static struct type *
17537 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
17539 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17541 struct attribute *attr;
17542 int encoding = 0, bits = 0;
17545 attr = dwarf2_attr (die, DW_AT_encoding, cu);
17548 encoding = DW_UNSND (attr);
17550 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17553 bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
17555 name = dwarf2_name (die, cu);
17558 complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17563 case DW_ATE_address:
17564 /* Turn DW_ATE_address into a void * pointer. */
17565 type = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
17566 type = init_pointer_type (objfile, bits, name, type);
17568 case DW_ATE_boolean:
17569 type = init_boolean_type (objfile, bits, 1, name);
17571 case DW_ATE_complex_float:
17572 type = dwarf2_init_complex_target_type (cu, objfile, bits / 2, name);
17573 type = init_complex_type (objfile, name, type);
17575 case DW_ATE_decimal_float:
17576 type = init_decfloat_type (objfile, bits, name);
17579 type = dwarf2_init_float_type (objfile, bits, name, name);
17581 case DW_ATE_signed:
17582 type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17584 case DW_ATE_unsigned:
17585 if (cu->language == language_fortran
17587 && startswith (name, "character("))
17588 type = init_character_type (objfile, bits, 1, name);
17590 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17592 case DW_ATE_signed_char:
17593 if (cu->language == language_ada || cu->language == language_m2
17594 || cu->language == language_pascal
17595 || cu->language == language_fortran)
17596 type = init_character_type (objfile, bits, 0, name);
17598 type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17600 case DW_ATE_unsigned_char:
17601 if (cu->language == language_ada || cu->language == language_m2
17602 || cu->language == language_pascal
17603 || cu->language == language_fortran
17604 || cu->language == language_rust)
17605 type = init_character_type (objfile, bits, 1, name);
17607 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17611 gdbarch *arch = get_objfile_arch (objfile);
17614 type = builtin_type (arch)->builtin_char16;
17615 else if (bits == 32)
17616 type = builtin_type (arch)->builtin_char32;
17619 complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17621 type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17623 return set_die_type (die, type, cu);
17628 complaint (_("unsupported DW_AT_encoding: '%s'"),
17629 dwarf_type_encoding_name (encoding));
17630 type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17634 if (name && strcmp (name, "char") == 0)
17635 TYPE_NOSIGN (type) = 1;
17637 maybe_set_alignment (cu, die, type);
17639 return set_die_type (die, type, cu);
17642 /* Parse dwarf attribute if it's a block, reference or constant and put the
17643 resulting value of the attribute into struct bound_prop.
17644 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
17647 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
17648 struct dwarf2_cu *cu, struct dynamic_prop *prop,
17649 struct type *default_type)
17651 struct dwarf2_property_baton *baton;
17652 struct obstack *obstack
17653 = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
17655 gdb_assert (default_type != NULL);
17657 if (attr == NULL || prop == NULL)
17660 if (attr_form_is_block (attr))
17662 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17663 baton->property_type = default_type;
17664 baton->locexpr.per_cu = cu->per_cu;
17665 baton->locexpr.size = DW_BLOCK (attr)->size;
17666 baton->locexpr.data = DW_BLOCK (attr)->data;
17667 baton->locexpr.is_reference = false;
17668 prop->data.baton = baton;
17669 prop->kind = PROP_LOCEXPR;
17670 gdb_assert (prop->data.baton != NULL);
17672 else if (attr_form_is_ref (attr))
17674 struct dwarf2_cu *target_cu = cu;
17675 struct die_info *target_die;
17676 struct attribute *target_attr;
17678 target_die = follow_die_ref (die, attr, &target_cu);
17679 target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
17680 if (target_attr == NULL)
17681 target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
17683 if (target_attr == NULL)
17686 switch (target_attr->name)
17688 case DW_AT_location:
17689 if (attr_form_is_section_offset (target_attr))
17691 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17692 baton->property_type = die_type (target_die, target_cu);
17693 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
17694 prop->data.baton = baton;
17695 prop->kind = PROP_LOCLIST;
17696 gdb_assert (prop->data.baton != NULL);
17698 else if (attr_form_is_block (target_attr))
17700 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17701 baton->property_type = die_type (target_die, target_cu);
17702 baton->locexpr.per_cu = cu->per_cu;
17703 baton->locexpr.size = DW_BLOCK (target_attr)->size;
17704 baton->locexpr.data = DW_BLOCK (target_attr)->data;
17705 baton->locexpr.is_reference = true;
17706 prop->data.baton = baton;
17707 prop->kind = PROP_LOCEXPR;
17708 gdb_assert (prop->data.baton != NULL);
17712 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17713 "dynamic property");
17717 case DW_AT_data_member_location:
17721 if (!handle_data_member_location (target_die, target_cu,
17725 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17726 baton->property_type = read_type_die (target_die->parent,
17728 baton->offset_info.offset = offset;
17729 baton->offset_info.type = die_type (target_die, target_cu);
17730 prop->data.baton = baton;
17731 prop->kind = PROP_ADDR_OFFSET;
17736 else if (attr_form_is_constant (attr))
17738 prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
17739 prop->kind = PROP_CONST;
17743 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
17744 dwarf2_name (die, cu));
17751 /* Find an integer type the same size as the address size given in the
17752 compilation unit header for PER_CU. UNSIGNED_P controls if the integer
17753 is unsigned or not. */
17755 static struct type *
17756 dwarf2_per_cu_addr_sized_int_type (struct dwarf2_per_cu_data *per_cu,
17759 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
17760 int addr_size = dwarf2_per_cu_addr_size (per_cu);
17761 struct type *int_type;
17763 /* Helper macro to examine the various builtin types. */
17764 #define TRY_TYPE(F) \
17765 int_type = (unsigned_p \
17766 ? objfile_type (objfile)->builtin_unsigned_ ## F \
17767 : objfile_type (objfile)->builtin_ ## F); \
17768 if (int_type != NULL && TYPE_LENGTH (int_type) == addr_size) \
17775 TRY_TYPE (long_long);
17779 gdb_assert_not_reached ("unable to find suitable integer type");
17782 /* Read the DW_AT_type attribute for a sub-range. If this attribute is not
17783 present (which is valid) then compute the default type based on the
17784 compilation units address size. */
17786 static struct type *
17787 read_subrange_index_type (struct die_info *die, struct dwarf2_cu *cu)
17789 struct type *index_type = die_type (die, cu);
17791 /* Dwarf-2 specifications explicitly allows to create subrange types
17792 without specifying a base type.
17793 In that case, the base type must be set to the type of
17794 the lower bound, upper bound or count, in that order, if any of these
17795 three attributes references an object that has a type.
17796 If no base type is found, the Dwarf-2 specifications say that
17797 a signed integer type of size equal to the size of an address should
17799 For the following C code: `extern char gdb_int [];'
17800 GCC produces an empty range DIE.
17801 FIXME: muller/2010-05-28: Possible references to object for low bound,
17802 high bound or count are not yet handled by this code. */
17803 if (TYPE_CODE (index_type) == TYPE_CODE_VOID)
17804 index_type = dwarf2_per_cu_addr_sized_int_type (cu->per_cu, false);
17809 /* Read the given DW_AT_subrange DIE. */
17811 static struct type *
17812 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
17814 struct type *base_type, *orig_base_type;
17815 struct type *range_type;
17816 struct attribute *attr;
17817 struct dynamic_prop low, high;
17818 int low_default_is_valid;
17819 int high_bound_is_count = 0;
17821 ULONGEST negative_mask;
17823 orig_base_type = read_subrange_index_type (die, cu);
17825 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17826 whereas the real type might be. So, we use ORIG_BASE_TYPE when
17827 creating the range type, but we use the result of check_typedef
17828 when examining properties of the type. */
17829 base_type = check_typedef (orig_base_type);
17831 /* The die_type call above may have already set the type for this DIE. */
17832 range_type = get_die_type (die, cu);
17836 low.kind = PROP_CONST;
17837 high.kind = PROP_CONST;
17838 high.data.const_val = 0;
17840 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17841 omitting DW_AT_lower_bound. */
17842 switch (cu->language)
17845 case language_cplus:
17846 low.data.const_val = 0;
17847 low_default_is_valid = 1;
17849 case language_fortran:
17850 low.data.const_val = 1;
17851 low_default_is_valid = 1;
17854 case language_objc:
17855 case language_rust:
17856 low.data.const_val = 0;
17857 low_default_is_valid = (cu->header.version >= 4);
17861 case language_pascal:
17862 low.data.const_val = 1;
17863 low_default_is_valid = (cu->header.version >= 4);
17866 low.data.const_val = 0;
17867 low_default_is_valid = 0;
17871 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
17873 attr_to_dynamic_prop (attr, die, cu, &low, base_type);
17874 else if (!low_default_is_valid)
17875 complaint (_("Missing DW_AT_lower_bound "
17876 "- DIE at %s [in module %s]"),
17877 sect_offset_str (die->sect_off),
17878 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17880 struct attribute *attr_ub, *attr_count;
17881 attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);
17882 if (!attr_to_dynamic_prop (attr, die, cu, &high, base_type))
17884 attr = attr_count = dwarf2_attr (die, DW_AT_count, cu);
17885 if (attr_to_dynamic_prop (attr, die, cu, &high, base_type))
17887 /* If bounds are constant do the final calculation here. */
17888 if (low.kind == PROP_CONST && high.kind == PROP_CONST)
17889 high.data.const_val = low.data.const_val + high.data.const_val - 1;
17891 high_bound_is_count = 1;
17895 if (attr_ub != NULL)
17896 complaint (_("Unresolved DW_AT_upper_bound "
17897 "- DIE at %s [in module %s]"),
17898 sect_offset_str (die->sect_off),
17899 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17900 if (attr_count != NULL)
17901 complaint (_("Unresolved DW_AT_count "
17902 "- DIE at %s [in module %s]"),
17903 sect_offset_str (die->sect_off),
17904 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17908 /* Normally, the DWARF producers are expected to use a signed
17909 constant form (Eg. DW_FORM_sdata) to express negative bounds.
17910 But this is unfortunately not always the case, as witnessed
17911 with GCC, for instance, where the ambiguous DW_FORM_dataN form
17912 is used instead. To work around that ambiguity, we treat
17913 the bounds as signed, and thus sign-extend their values, when
17914 the base type is signed. */
17916 -((ULONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
17917 if (low.kind == PROP_CONST
17918 && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
17919 low.data.const_val |= negative_mask;
17920 if (high.kind == PROP_CONST
17921 && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
17922 high.data.const_val |= negative_mask;
17924 range_type = create_range_type (NULL, orig_base_type, &low, &high);
17926 if (high_bound_is_count)
17927 TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
17929 /* Ada expects an empty array on no boundary attributes. */
17930 if (attr == NULL && cu->language != language_ada)
17931 TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
17933 name = dwarf2_name (die, cu);
17935 TYPE_NAME (range_type) = name;
17937 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17939 TYPE_LENGTH (range_type) = DW_UNSND (attr);
17941 maybe_set_alignment (cu, die, range_type);
17943 set_die_type (die, range_type, cu);
17945 /* set_die_type should be already done. */
17946 set_descriptive_type (range_type, die, cu);
17951 static struct type *
17952 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
17956 type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
17958 TYPE_NAME (type) = dwarf2_name (die, cu);
17960 /* In Ada, an unspecified type is typically used when the description
17961 of the type is defered to a different unit. When encountering
17962 such a type, we treat it as a stub, and try to resolve it later on,
17964 if (cu->language == language_ada)
17965 TYPE_STUB (type) = 1;
17967 return set_die_type (die, type, cu);
17970 /* Read a single die and all its descendents. Set the die's sibling
17971 field to NULL; set other fields in the die correctly, and set all
17972 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
17973 location of the info_ptr after reading all of those dies. PARENT
17974 is the parent of the die in question. */
17976 static struct die_info *
17977 read_die_and_children (const struct die_reader_specs *reader,
17978 const gdb_byte *info_ptr,
17979 const gdb_byte **new_info_ptr,
17980 struct die_info *parent)
17982 struct die_info *die;
17983 const gdb_byte *cur_ptr;
17986 cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
17989 *new_info_ptr = cur_ptr;
17992 store_in_ref_table (die, reader->cu);
17995 die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
17999 *new_info_ptr = cur_ptr;
18002 die->sibling = NULL;
18003 die->parent = parent;
18007 /* Read a die, all of its descendents, and all of its siblings; set
18008 all of the fields of all of the dies correctly. Arguments are as
18009 in read_die_and_children. */
18011 static struct die_info *
18012 read_die_and_siblings_1 (const struct die_reader_specs *reader,
18013 const gdb_byte *info_ptr,
18014 const gdb_byte **new_info_ptr,
18015 struct die_info *parent)
18017 struct die_info *first_die, *last_sibling;
18018 const gdb_byte *cur_ptr;
18020 cur_ptr = info_ptr;
18021 first_die = last_sibling = NULL;
18025 struct die_info *die
18026 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
18030 *new_info_ptr = cur_ptr;
18037 last_sibling->sibling = die;
18039 last_sibling = die;
18043 /* Read a die, all of its descendents, and all of its siblings; set
18044 all of the fields of all of the dies correctly. Arguments are as
18045 in read_die_and_children.
18046 This the main entry point for reading a DIE and all its children. */
18048 static struct die_info *
18049 read_die_and_siblings (const struct die_reader_specs *reader,
18050 const gdb_byte *info_ptr,
18051 const gdb_byte **new_info_ptr,
18052 struct die_info *parent)
18054 struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
18055 new_info_ptr, parent);
18057 if (dwarf_die_debug)
18059 fprintf_unfiltered (gdb_stdlog,
18060 "Read die from %s@0x%x of %s:\n",
18061 get_section_name (reader->die_section),
18062 (unsigned) (info_ptr - reader->die_section->buffer),
18063 bfd_get_filename (reader->abfd));
18064 dump_die (die, dwarf_die_debug);
18070 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18072 The caller is responsible for filling in the extra attributes
18073 and updating (*DIEP)->num_attrs.
18074 Set DIEP to point to a newly allocated die with its information,
18075 except for its child, sibling, and parent fields.
18076 Set HAS_CHILDREN to tell whether the die has children or not. */
18078 static const gdb_byte *
18079 read_full_die_1 (const struct die_reader_specs *reader,
18080 struct die_info **diep, const gdb_byte *info_ptr,
18081 int *has_children, int num_extra_attrs)
18083 unsigned int abbrev_number, bytes_read, i;
18084 struct abbrev_info *abbrev;
18085 struct die_info *die;
18086 struct dwarf2_cu *cu = reader->cu;
18087 bfd *abfd = reader->abfd;
18089 sect_offset sect_off = (sect_offset) (info_ptr - reader->buffer);
18090 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
18091 info_ptr += bytes_read;
18092 if (!abbrev_number)
18099 abbrev = reader->abbrev_table->lookup_abbrev (abbrev_number);
18101 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18103 bfd_get_filename (abfd));
18105 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
18106 die->sect_off = sect_off;
18107 die->tag = abbrev->tag;
18108 die->abbrev = abbrev_number;
18110 /* Make the result usable.
18111 The caller needs to update num_attrs after adding the extra
18113 die->num_attrs = abbrev->num_attrs;
18115 for (i = 0; i < abbrev->num_attrs; ++i)
18116 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
18120 *has_children = abbrev->has_children;
18124 /* Read a die and all its attributes.
18125 Set DIEP to point to a newly allocated die with its information,
18126 except for its child, sibling, and parent fields.
18127 Set HAS_CHILDREN to tell whether the die has children or not. */
18129 static const gdb_byte *
18130 read_full_die (const struct die_reader_specs *reader,
18131 struct die_info **diep, const gdb_byte *info_ptr,
18134 const gdb_byte *result;
18136 result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
18138 if (dwarf_die_debug)
18140 fprintf_unfiltered (gdb_stdlog,
18141 "Read die from %s@0x%x of %s:\n",
18142 get_section_name (reader->die_section),
18143 (unsigned) (info_ptr - reader->die_section->buffer),
18144 bfd_get_filename (reader->abfd));
18145 dump_die (*diep, dwarf_die_debug);
18151 /* Abbreviation tables.
18153 In DWARF version 2, the description of the debugging information is
18154 stored in a separate .debug_abbrev section. Before we read any
18155 dies from a section we read in all abbreviations and install them
18156 in a hash table. */
18158 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
18160 struct abbrev_info *
18161 abbrev_table::alloc_abbrev ()
18163 struct abbrev_info *abbrev;
18165 abbrev = XOBNEW (&abbrev_obstack, struct abbrev_info);
18166 memset (abbrev, 0, sizeof (struct abbrev_info));
18171 /* Add an abbreviation to the table. */
18174 abbrev_table::add_abbrev (unsigned int abbrev_number,
18175 struct abbrev_info *abbrev)
18177 unsigned int hash_number;
18179 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18180 abbrev->next = m_abbrevs[hash_number];
18181 m_abbrevs[hash_number] = abbrev;
18184 /* Look up an abbrev in the table.
18185 Returns NULL if the abbrev is not found. */
18187 struct abbrev_info *
18188 abbrev_table::lookup_abbrev (unsigned int abbrev_number)
18190 unsigned int hash_number;
18191 struct abbrev_info *abbrev;
18193 hash_number = abbrev_number % ABBREV_HASH_SIZE;
18194 abbrev = m_abbrevs[hash_number];
18198 if (abbrev->number == abbrev_number)
18200 abbrev = abbrev->next;
18205 /* Read in an abbrev table. */
18207 static abbrev_table_up
18208 abbrev_table_read_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
18209 struct dwarf2_section_info *section,
18210 sect_offset sect_off)
18212 struct objfile *objfile = dwarf2_per_objfile->objfile;
18213 bfd *abfd = get_section_bfd_owner (section);
18214 const gdb_byte *abbrev_ptr;
18215 struct abbrev_info *cur_abbrev;
18216 unsigned int abbrev_number, bytes_read, abbrev_name;
18217 unsigned int abbrev_form;
18218 struct attr_abbrev *cur_attrs;
18219 unsigned int allocated_attrs;
18221 abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
18223 dwarf2_read_section (objfile, section);
18224 abbrev_ptr = section->buffer + to_underlying (sect_off);
18225 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18226 abbrev_ptr += bytes_read;
18228 allocated_attrs = ATTR_ALLOC_CHUNK;
18229 cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
18231 /* Loop until we reach an abbrev number of 0. */
18232 while (abbrev_number)
18234 cur_abbrev = abbrev_table->alloc_abbrev ();
18236 /* read in abbrev header */
18237 cur_abbrev->number = abbrev_number;
18239 = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18240 abbrev_ptr += bytes_read;
18241 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
18244 /* now read in declarations */
18247 LONGEST implicit_const;
18249 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18250 abbrev_ptr += bytes_read;
18251 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18252 abbrev_ptr += bytes_read;
18253 if (abbrev_form == DW_FORM_implicit_const)
18255 implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
18257 abbrev_ptr += bytes_read;
18261 /* Initialize it due to a false compiler warning. */
18262 implicit_const = -1;
18265 if (abbrev_name == 0)
18268 if (cur_abbrev->num_attrs == allocated_attrs)
18270 allocated_attrs += ATTR_ALLOC_CHUNK;
18272 = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
18275 cur_attrs[cur_abbrev->num_attrs].name
18276 = (enum dwarf_attribute) abbrev_name;
18277 cur_attrs[cur_abbrev->num_attrs].form
18278 = (enum dwarf_form) abbrev_form;
18279 cur_attrs[cur_abbrev->num_attrs].implicit_const = implicit_const;
18280 ++cur_abbrev->num_attrs;
18283 cur_abbrev->attrs =
18284 XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
18285 cur_abbrev->num_attrs);
18286 memcpy (cur_abbrev->attrs, cur_attrs,
18287 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
18289 abbrev_table->add_abbrev (abbrev_number, cur_abbrev);
18291 /* Get next abbreviation.
18292 Under Irix6 the abbreviations for a compilation unit are not
18293 always properly terminated with an abbrev number of 0.
18294 Exit loop if we encounter an abbreviation which we have
18295 already read (which means we are about to read the abbreviations
18296 for the next compile unit) or if the end of the abbreviation
18297 table is reached. */
18298 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
18300 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18301 abbrev_ptr += bytes_read;
18302 if (abbrev_table->lookup_abbrev (abbrev_number) != NULL)
18307 return abbrev_table;
18310 /* Returns nonzero if TAG represents a type that we might generate a partial
18314 is_type_tag_for_partial (int tag)
18319 /* Some types that would be reasonable to generate partial symbols for,
18320 that we don't at present. */
18321 case DW_TAG_array_type:
18322 case DW_TAG_file_type:
18323 case DW_TAG_ptr_to_member_type:
18324 case DW_TAG_set_type:
18325 case DW_TAG_string_type:
18326 case DW_TAG_subroutine_type:
18328 case DW_TAG_base_type:
18329 case DW_TAG_class_type:
18330 case DW_TAG_interface_type:
18331 case DW_TAG_enumeration_type:
18332 case DW_TAG_structure_type:
18333 case DW_TAG_subrange_type:
18334 case DW_TAG_typedef:
18335 case DW_TAG_union_type:
18342 /* Load all DIEs that are interesting for partial symbols into memory. */
18344 static struct partial_die_info *
18345 load_partial_dies (const struct die_reader_specs *reader,
18346 const gdb_byte *info_ptr, int building_psymtab)
18348 struct dwarf2_cu *cu = reader->cu;
18349 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18350 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
18351 unsigned int bytes_read;
18352 unsigned int load_all = 0;
18353 int nesting_level = 1;
18358 gdb_assert (cu->per_cu != NULL);
18359 if (cu->per_cu->load_all_dies)
18363 = htab_create_alloc_ex (cu->header.length / 12,
18367 &cu->comp_unit_obstack,
18368 hashtab_obstack_allocate,
18369 dummy_obstack_deallocate);
18373 abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
18375 /* A NULL abbrev means the end of a series of children. */
18376 if (abbrev == NULL)
18378 if (--nesting_level == 0)
18381 info_ptr += bytes_read;
18382 last_die = parent_die;
18383 parent_die = parent_die->die_parent;
18387 /* Check for template arguments. We never save these; if
18388 they're seen, we just mark the parent, and go on our way. */
18389 if (parent_die != NULL
18390 && cu->language == language_cplus
18391 && (abbrev->tag == DW_TAG_template_type_param
18392 || abbrev->tag == DW_TAG_template_value_param))
18394 parent_die->has_template_arguments = 1;
18398 /* We don't need a partial DIE for the template argument. */
18399 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18404 /* We only recurse into c++ subprograms looking for template arguments.
18405 Skip their other children. */
18407 && cu->language == language_cplus
18408 && parent_die != NULL
18409 && parent_die->tag == DW_TAG_subprogram)
18411 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18415 /* Check whether this DIE is interesting enough to save. Normally
18416 we would not be interested in members here, but there may be
18417 later variables referencing them via DW_AT_specification (for
18418 static members). */
18420 && !is_type_tag_for_partial (abbrev->tag)
18421 && abbrev->tag != DW_TAG_constant
18422 && abbrev->tag != DW_TAG_enumerator
18423 && abbrev->tag != DW_TAG_subprogram
18424 && abbrev->tag != DW_TAG_inlined_subroutine
18425 && abbrev->tag != DW_TAG_lexical_block
18426 && abbrev->tag != DW_TAG_variable
18427 && abbrev->tag != DW_TAG_namespace
18428 && abbrev->tag != DW_TAG_module
18429 && abbrev->tag != DW_TAG_member
18430 && abbrev->tag != DW_TAG_imported_unit
18431 && abbrev->tag != DW_TAG_imported_declaration)
18433 /* Otherwise we skip to the next sibling, if any. */
18434 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18438 struct partial_die_info pdi ((sect_offset) (info_ptr - reader->buffer),
18441 info_ptr = pdi.read (reader, *abbrev, info_ptr + bytes_read);
18443 /* This two-pass algorithm for processing partial symbols has a
18444 high cost in cache pressure. Thus, handle some simple cases
18445 here which cover the majority of C partial symbols. DIEs
18446 which neither have specification tags in them, nor could have
18447 specification tags elsewhere pointing at them, can simply be
18448 processed and discarded.
18450 This segment is also optional; scan_partial_symbols and
18451 add_partial_symbol will handle these DIEs if we chain
18452 them in normally. When compilers which do not emit large
18453 quantities of duplicate debug information are more common,
18454 this code can probably be removed. */
18456 /* Any complete simple types at the top level (pretty much all
18457 of them, for a language without namespaces), can be processed
18459 if (parent_die == NULL
18460 && pdi.has_specification == 0
18461 && pdi.is_declaration == 0
18462 && ((pdi.tag == DW_TAG_typedef && !pdi.has_children)
18463 || pdi.tag == DW_TAG_base_type
18464 || pdi.tag == DW_TAG_subrange_type))
18466 if (building_psymtab && pdi.name != NULL)
18467 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18468 VAR_DOMAIN, LOC_TYPEDEF, -1,
18469 psymbol_placement::STATIC,
18470 0, cu->language, objfile);
18471 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18475 /* The exception for DW_TAG_typedef with has_children above is
18476 a workaround of GCC PR debug/47510. In the case of this complaint
18477 type_name_or_error will error on such types later.
18479 GDB skipped children of DW_TAG_typedef by the shortcut above and then
18480 it could not find the child DIEs referenced later, this is checked
18481 above. In correct DWARF DW_TAG_typedef should have no children. */
18483 if (pdi.tag == DW_TAG_typedef && pdi.has_children)
18484 complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18485 "- DIE at %s [in module %s]"),
18486 sect_offset_str (pdi.sect_off), objfile_name (objfile));
18488 /* If we're at the second level, and we're an enumerator, and
18489 our parent has no specification (meaning possibly lives in a
18490 namespace elsewhere), then we can add the partial symbol now
18491 instead of queueing it. */
18492 if (pdi.tag == DW_TAG_enumerator
18493 && parent_die != NULL
18494 && parent_die->die_parent == NULL
18495 && parent_die->tag == DW_TAG_enumeration_type
18496 && parent_die->has_specification == 0)
18498 if (pdi.name == NULL)
18499 complaint (_("malformed enumerator DIE ignored"));
18500 else if (building_psymtab)
18501 add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18502 VAR_DOMAIN, LOC_CONST, -1,
18503 cu->language == language_cplus
18504 ? psymbol_placement::GLOBAL
18505 : psymbol_placement::STATIC,
18506 0, cu->language, objfile);
18508 info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18512 struct partial_die_info *part_die
18513 = new (&cu->comp_unit_obstack) partial_die_info (pdi);
18515 /* We'll save this DIE so link it in. */
18516 part_die->die_parent = parent_die;
18517 part_die->die_sibling = NULL;
18518 part_die->die_child = NULL;
18520 if (last_die && last_die == parent_die)
18521 last_die->die_child = part_die;
18523 last_die->die_sibling = part_die;
18525 last_die = part_die;
18527 if (first_die == NULL)
18528 first_die = part_die;
18530 /* Maybe add the DIE to the hash table. Not all DIEs that we
18531 find interesting need to be in the hash table, because we
18532 also have the parent/sibling/child chains; only those that we
18533 might refer to by offset later during partial symbol reading.
18535 For now this means things that might have be the target of a
18536 DW_AT_specification, DW_AT_abstract_origin, or
18537 DW_AT_extension. DW_AT_extension will refer only to
18538 namespaces; DW_AT_abstract_origin refers to functions (and
18539 many things under the function DIE, but we do not recurse
18540 into function DIEs during partial symbol reading) and
18541 possibly variables as well; DW_AT_specification refers to
18542 declarations. Declarations ought to have the DW_AT_declaration
18543 flag. It happens that GCC forgets to put it in sometimes, but
18544 only for functions, not for types.
18546 Adding more things than necessary to the hash table is harmless
18547 except for the performance cost. Adding too few will result in
18548 wasted time in find_partial_die, when we reread the compilation
18549 unit with load_all_dies set. */
18552 || abbrev->tag == DW_TAG_constant
18553 || abbrev->tag == DW_TAG_subprogram
18554 || abbrev->tag == DW_TAG_variable
18555 || abbrev->tag == DW_TAG_namespace
18556 || part_die->is_declaration)
18560 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
18561 to_underlying (part_die->sect_off),
18566 /* For some DIEs we want to follow their children (if any). For C
18567 we have no reason to follow the children of structures; for other
18568 languages we have to, so that we can get at method physnames
18569 to infer fully qualified class names, for DW_AT_specification,
18570 and for C++ template arguments. For C++, we also look one level
18571 inside functions to find template arguments (if the name of the
18572 function does not already contain the template arguments).
18574 For Ada, we need to scan the children of subprograms and lexical
18575 blocks as well because Ada allows the definition of nested
18576 entities that could be interesting for the debugger, such as
18577 nested subprograms for instance. */
18578 if (last_die->has_children
18580 || last_die->tag == DW_TAG_namespace
18581 || last_die->tag == DW_TAG_module
18582 || last_die->tag == DW_TAG_enumeration_type
18583 || (cu->language == language_cplus
18584 && last_die->tag == DW_TAG_subprogram
18585 && (last_die->name == NULL
18586 || strchr (last_die->name, '<') == NULL))
18587 || (cu->language != language_c
18588 && (last_die->tag == DW_TAG_class_type
18589 || last_die->tag == DW_TAG_interface_type
18590 || last_die->tag == DW_TAG_structure_type
18591 || last_die->tag == DW_TAG_union_type))
18592 || (cu->language == language_ada
18593 && (last_die->tag == DW_TAG_subprogram
18594 || last_die->tag == DW_TAG_lexical_block))))
18597 parent_die = last_die;
18601 /* Otherwise we skip to the next sibling, if any. */
18602 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
18604 /* Back to the top, do it again. */
18608 partial_die_info::partial_die_info (sect_offset sect_off_,
18609 struct abbrev_info *abbrev)
18610 : partial_die_info (sect_off_, abbrev->tag, abbrev->has_children)
18614 /* Read a minimal amount of information into the minimal die structure.
18615 INFO_PTR should point just after the initial uleb128 of a DIE. */
18618 partial_die_info::read (const struct die_reader_specs *reader,
18619 const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
18621 struct dwarf2_cu *cu = reader->cu;
18622 struct dwarf2_per_objfile *dwarf2_per_objfile
18623 = cu->per_cu->dwarf2_per_objfile;
18625 int has_low_pc_attr = 0;
18626 int has_high_pc_attr = 0;
18627 int high_pc_relative = 0;
18629 for (i = 0; i < abbrev.num_attrs; ++i)
18631 struct attribute attr;
18633 info_ptr = read_attribute (reader, &attr, &abbrev.attrs[i], info_ptr);
18635 /* Store the data if it is of an attribute we want to keep in a
18636 partial symbol table. */
18642 case DW_TAG_compile_unit:
18643 case DW_TAG_partial_unit:
18644 case DW_TAG_type_unit:
18645 /* Compilation units have a DW_AT_name that is a filename, not
18646 a source language identifier. */
18647 case DW_TAG_enumeration_type:
18648 case DW_TAG_enumerator:
18649 /* These tags always have simple identifiers already; no need
18650 to canonicalize them. */
18651 name = DW_STRING (&attr);
18655 struct objfile *objfile = dwarf2_per_objfile->objfile;
18658 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
18659 &objfile->per_bfd->storage_obstack);
18664 case DW_AT_linkage_name:
18665 case DW_AT_MIPS_linkage_name:
18666 /* Note that both forms of linkage name might appear. We
18667 assume they will be the same, and we only store the last
18669 linkage_name = DW_STRING (&attr);
18672 has_low_pc_attr = 1;
18673 lowpc = attr_value_as_address (&attr);
18675 case DW_AT_high_pc:
18676 has_high_pc_attr = 1;
18677 highpc = attr_value_as_address (&attr);
18678 if (cu->header.version >= 4 && attr_form_is_constant (&attr))
18679 high_pc_relative = 1;
18681 case DW_AT_location:
18682 /* Support the .debug_loc offsets. */
18683 if (attr_form_is_block (&attr))
18685 d.locdesc = DW_BLOCK (&attr);
18687 else if (attr_form_is_section_offset (&attr))
18689 dwarf2_complex_location_expr_complaint ();
18693 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18694 "partial symbol information");
18697 case DW_AT_external:
18698 is_external = DW_UNSND (&attr);
18700 case DW_AT_declaration:
18701 is_declaration = DW_UNSND (&attr);
18706 case DW_AT_abstract_origin:
18707 case DW_AT_specification:
18708 case DW_AT_extension:
18709 has_specification = 1;
18710 spec_offset = dwarf2_get_ref_die_offset (&attr);
18711 spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18712 || cu->per_cu->is_dwz);
18714 case DW_AT_sibling:
18715 /* Ignore absolute siblings, they might point outside of
18716 the current compile unit. */
18717 if (attr.form == DW_FORM_ref_addr)
18718 complaint (_("ignoring absolute DW_AT_sibling"));
18721 const gdb_byte *buffer = reader->buffer;
18722 sect_offset off = dwarf2_get_ref_die_offset (&attr);
18723 const gdb_byte *sibling_ptr = buffer + to_underlying (off);
18725 if (sibling_ptr < info_ptr)
18726 complaint (_("DW_AT_sibling points backwards"));
18727 else if (sibling_ptr > reader->buffer_end)
18728 dwarf2_section_buffer_overflow_complaint (reader->die_section);
18730 sibling = sibling_ptr;
18733 case DW_AT_byte_size:
18736 case DW_AT_const_value:
18737 has_const_value = 1;
18739 case DW_AT_calling_convention:
18740 /* DWARF doesn't provide a way to identify a program's source-level
18741 entry point. DW_AT_calling_convention attributes are only meant
18742 to describe functions' calling conventions.
18744 However, because it's a necessary piece of information in
18745 Fortran, and before DWARF 4 DW_CC_program was the only
18746 piece of debugging information whose definition refers to
18747 a 'main program' at all, several compilers marked Fortran
18748 main programs with DW_CC_program --- even when those
18749 functions use the standard calling conventions.
18751 Although DWARF now specifies a way to provide this
18752 information, we support this practice for backward
18754 if (DW_UNSND (&attr) == DW_CC_program
18755 && cu->language == language_fortran)
18756 main_subprogram = 1;
18759 if (DW_UNSND (&attr) == DW_INL_inlined
18760 || DW_UNSND (&attr) == DW_INL_declared_inlined)
18761 may_be_inlined = 1;
18765 if (tag == DW_TAG_imported_unit)
18767 d.sect_off = dwarf2_get_ref_die_offset (&attr);
18768 is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18769 || cu->per_cu->is_dwz);
18773 case DW_AT_main_subprogram:
18774 main_subprogram = DW_UNSND (&attr);
18779 /* It would be nice to reuse dwarf2_get_pc_bounds here,
18780 but that requires a full DIE, so instead we just
18782 int need_ranges_base = tag != DW_TAG_compile_unit;
18783 unsigned int ranges_offset = (DW_UNSND (&attr)
18784 + (need_ranges_base
18788 /* Value of the DW_AT_ranges attribute is the offset in the
18789 .debug_ranges section. */
18790 if (dwarf2_ranges_read (ranges_offset, &lowpc, &highpc, cu,
18801 /* For Ada, if both the name and the linkage name appear, we prefer
18802 the latter. This lets "catch exception" work better, regardless
18803 of the order in which the name and linkage name were emitted.
18804 Really, though, this is just a workaround for the fact that gdb
18805 doesn't store both the name and the linkage name. */
18806 if (cu->language == language_ada && linkage_name != nullptr)
18807 name = linkage_name;
18809 if (high_pc_relative)
18812 if (has_low_pc_attr && has_high_pc_attr)
18814 /* When using the GNU linker, .gnu.linkonce. sections are used to
18815 eliminate duplicate copies of functions and vtables and such.
18816 The linker will arbitrarily choose one and discard the others.
18817 The AT_*_pc values for such functions refer to local labels in
18818 these sections. If the section from that file was discarded, the
18819 labels are not in the output, so the relocs get a value of 0.
18820 If this is a discarded function, mark the pc bounds as invalid,
18821 so that GDB will ignore it. */
18822 if (lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
18824 struct objfile *objfile = dwarf2_per_objfile->objfile;
18825 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18827 complaint (_("DW_AT_low_pc %s is zero "
18828 "for DIE at %s [in module %s]"),
18829 paddress (gdbarch, lowpc),
18830 sect_offset_str (sect_off),
18831 objfile_name (objfile));
18833 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
18834 else if (lowpc >= highpc)
18836 struct objfile *objfile = dwarf2_per_objfile->objfile;
18837 struct gdbarch *gdbarch = get_objfile_arch (objfile);
18839 complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18840 "for DIE at %s [in module %s]"),
18841 paddress (gdbarch, lowpc),
18842 paddress (gdbarch, highpc),
18843 sect_offset_str (sect_off),
18844 objfile_name (objfile));
18853 /* Find a cached partial DIE at OFFSET in CU. */
18855 struct partial_die_info *
18856 dwarf2_cu::find_partial_die (sect_offset sect_off)
18858 struct partial_die_info *lookup_die = NULL;
18859 struct partial_die_info part_die (sect_off);
18861 lookup_die = ((struct partial_die_info *)
18862 htab_find_with_hash (partial_dies, &part_die,
18863 to_underlying (sect_off)));
18868 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18869 except in the case of .debug_types DIEs which do not reference
18870 outside their CU (they do however referencing other types via
18871 DW_FORM_ref_sig8). */
18873 static const struct cu_partial_die_info
18874 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
18876 struct dwarf2_per_objfile *dwarf2_per_objfile
18877 = cu->per_cu->dwarf2_per_objfile;
18878 struct objfile *objfile = dwarf2_per_objfile->objfile;
18879 struct dwarf2_per_cu_data *per_cu = NULL;
18880 struct partial_die_info *pd = NULL;
18882 if (offset_in_dwz == cu->per_cu->is_dwz
18883 && offset_in_cu_p (&cu->header, sect_off))
18885 pd = cu->find_partial_die (sect_off);
18888 /* We missed recording what we needed.
18889 Load all dies and try again. */
18890 per_cu = cu->per_cu;
18894 /* TUs don't reference other CUs/TUs (except via type signatures). */
18895 if (cu->per_cu->is_debug_types)
18897 error (_("Dwarf Error: Type Unit at offset %s contains"
18898 " external reference to offset %s [in module %s].\n"),
18899 sect_offset_str (cu->header.sect_off), sect_offset_str (sect_off),
18900 bfd_get_filename (objfile->obfd));
18902 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
18903 dwarf2_per_objfile);
18905 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
18906 load_partial_comp_unit (per_cu);
18908 per_cu->cu->last_used = 0;
18909 pd = per_cu->cu->find_partial_die (sect_off);
18912 /* If we didn't find it, and not all dies have been loaded,
18913 load them all and try again. */
18915 if (pd == NULL && per_cu->load_all_dies == 0)
18917 per_cu->load_all_dies = 1;
18919 /* This is nasty. When we reread the DIEs, somewhere up the call chain
18920 THIS_CU->cu may already be in use. So we can't just free it and
18921 replace its DIEs with the ones we read in. Instead, we leave those
18922 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18923 and clobber THIS_CU->cu->partial_dies with the hash table for the new
18925 load_partial_comp_unit (per_cu);
18927 pd = per_cu->cu->find_partial_die (sect_off);
18931 internal_error (__FILE__, __LINE__,
18932 _("could not find partial DIE %s "
18933 "in cache [from module %s]\n"),
18934 sect_offset_str (sect_off), bfd_get_filename (objfile->obfd));
18935 return { per_cu->cu, pd };
18938 /* See if we can figure out if the class lives in a namespace. We do
18939 this by looking for a member function; its demangled name will
18940 contain namespace info, if there is any. */
18943 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
18944 struct dwarf2_cu *cu)
18946 /* NOTE: carlton/2003-10-07: Getting the info this way changes
18947 what template types look like, because the demangler
18948 frequently doesn't give the same name as the debug info. We
18949 could fix this by only using the demangled name to get the
18950 prefix (but see comment in read_structure_type). */
18952 struct partial_die_info *real_pdi;
18953 struct partial_die_info *child_pdi;
18955 /* If this DIE (this DIE's specification, if any) has a parent, then
18956 we should not do this. We'll prepend the parent's fully qualified
18957 name when we create the partial symbol. */
18959 real_pdi = struct_pdi;
18960 while (real_pdi->has_specification)
18962 auto res = find_partial_die (real_pdi->spec_offset,
18963 real_pdi->spec_is_dwz, cu);
18964 real_pdi = res.pdi;
18968 if (real_pdi->die_parent != NULL)
18971 for (child_pdi = struct_pdi->die_child;
18973 child_pdi = child_pdi->die_sibling)
18975 if (child_pdi->tag == DW_TAG_subprogram
18976 && child_pdi->linkage_name != NULL)
18978 char *actual_class_name
18979 = language_class_name_from_physname (cu->language_defn,
18980 child_pdi->linkage_name);
18981 if (actual_class_name != NULL)
18983 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18986 obstack_copy0 (&objfile->per_bfd->storage_obstack,
18988 strlen (actual_class_name)));
18989 xfree (actual_class_name);
18997 partial_die_info::fixup (struct dwarf2_cu *cu)
18999 /* Once we've fixed up a die, there's no point in doing so again.
19000 This also avoids a memory leak if we were to call
19001 guess_partial_die_structure_name multiple times. */
19005 /* If we found a reference attribute and the DIE has no name, try
19006 to find a name in the referred to DIE. */
19008 if (name == NULL && has_specification)
19010 struct partial_die_info *spec_die;
19012 auto res = find_partial_die (spec_offset, spec_is_dwz, cu);
19013 spec_die = res.pdi;
19016 spec_die->fixup (cu);
19018 if (spec_die->name)
19020 name = spec_die->name;
19022 /* Copy DW_AT_external attribute if it is set. */
19023 if (spec_die->is_external)
19024 is_external = spec_die->is_external;
19028 /* Set default names for some unnamed DIEs. */
19030 if (name == NULL && tag == DW_TAG_namespace)
19031 name = CP_ANONYMOUS_NAMESPACE_STR;
19033 /* If there is no parent die to provide a namespace, and there are
19034 children, see if we can determine the namespace from their linkage
19036 if (cu->language == language_cplus
19037 && !cu->per_cu->dwarf2_per_objfile->types.empty ()
19038 && die_parent == NULL
19040 && (tag == DW_TAG_class_type
19041 || tag == DW_TAG_structure_type
19042 || tag == DW_TAG_union_type))
19043 guess_partial_die_structure_name (this, cu);
19045 /* GCC might emit a nameless struct or union that has a linkage
19046 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19048 && (tag == DW_TAG_class_type
19049 || tag == DW_TAG_interface_type
19050 || tag == DW_TAG_structure_type
19051 || tag == DW_TAG_union_type)
19052 && linkage_name != NULL)
19056 demangled = gdb_demangle (linkage_name, DMGL_TYPES);
19061 /* Strip any leading namespaces/classes, keep only the base name.
19062 DW_AT_name for named DIEs does not contain the prefixes. */
19063 base = strrchr (demangled, ':');
19064 if (base && base > demangled && base[-1] == ':')
19069 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
19072 obstack_copy0 (&objfile->per_bfd->storage_obstack,
19073 base, strlen (base)));
19081 /* Read an attribute value described by an attribute form. */
19083 static const gdb_byte *
19084 read_attribute_value (const struct die_reader_specs *reader,
19085 struct attribute *attr, unsigned form,
19086 LONGEST implicit_const, const gdb_byte *info_ptr)
19088 struct dwarf2_cu *cu = reader->cu;
19089 struct dwarf2_per_objfile *dwarf2_per_objfile
19090 = cu->per_cu->dwarf2_per_objfile;
19091 struct objfile *objfile = dwarf2_per_objfile->objfile;
19092 struct gdbarch *gdbarch = get_objfile_arch (objfile);
19093 bfd *abfd = reader->abfd;
19094 struct comp_unit_head *cu_header = &cu->header;
19095 unsigned int bytes_read;
19096 struct dwarf_block *blk;
19098 attr->form = (enum dwarf_form) form;
19101 case DW_FORM_ref_addr:
19102 if (cu->header.version == 2)
19103 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19105 DW_UNSND (attr) = read_offset (abfd, info_ptr,
19106 &cu->header, &bytes_read);
19107 info_ptr += bytes_read;
19109 case DW_FORM_GNU_ref_alt:
19110 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19111 info_ptr += bytes_read;
19114 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19115 DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
19116 info_ptr += bytes_read;
19118 case DW_FORM_block2:
19119 blk = dwarf_alloc_block (cu);
19120 blk->size = read_2_bytes (abfd, info_ptr);
19122 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19123 info_ptr += blk->size;
19124 DW_BLOCK (attr) = blk;
19126 case DW_FORM_block4:
19127 blk = dwarf_alloc_block (cu);
19128 blk->size = read_4_bytes (abfd, info_ptr);
19130 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19131 info_ptr += blk->size;
19132 DW_BLOCK (attr) = blk;
19134 case DW_FORM_data2:
19135 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
19138 case DW_FORM_data4:
19139 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
19142 case DW_FORM_data8:
19143 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
19146 case DW_FORM_data16:
19147 blk = dwarf_alloc_block (cu);
19149 blk->data = read_n_bytes (abfd, info_ptr, 16);
19151 DW_BLOCK (attr) = blk;
19153 case DW_FORM_sec_offset:
19154 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19155 info_ptr += bytes_read;
19157 case DW_FORM_string:
19158 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
19159 DW_STRING_IS_CANONICAL (attr) = 0;
19160 info_ptr += bytes_read;
19163 if (!cu->per_cu->is_dwz)
19165 DW_STRING (attr) = read_indirect_string (dwarf2_per_objfile,
19166 abfd, info_ptr, cu_header,
19168 DW_STRING_IS_CANONICAL (attr) = 0;
19169 info_ptr += bytes_read;
19173 case DW_FORM_line_strp:
19174 if (!cu->per_cu->is_dwz)
19176 DW_STRING (attr) = read_indirect_line_string (dwarf2_per_objfile,
19178 cu_header, &bytes_read);
19179 DW_STRING_IS_CANONICAL (attr) = 0;
19180 info_ptr += bytes_read;
19184 case DW_FORM_GNU_strp_alt:
19186 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19187 LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
19190 DW_STRING (attr) = read_indirect_string_from_dwz (objfile,
19192 DW_STRING_IS_CANONICAL (attr) = 0;
19193 info_ptr += bytes_read;
19196 case DW_FORM_exprloc:
19197 case DW_FORM_block:
19198 blk = dwarf_alloc_block (cu);
19199 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19200 info_ptr += bytes_read;
19201 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19202 info_ptr += blk->size;
19203 DW_BLOCK (attr) = blk;
19205 case DW_FORM_block1:
19206 blk = dwarf_alloc_block (cu);
19207 blk->size = read_1_byte (abfd, info_ptr);
19209 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19210 info_ptr += blk->size;
19211 DW_BLOCK (attr) = blk;
19213 case DW_FORM_data1:
19214 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19218 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19221 case DW_FORM_flag_present:
19222 DW_UNSND (attr) = 1;
19224 case DW_FORM_sdata:
19225 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19226 info_ptr += bytes_read;
19228 case DW_FORM_udata:
19229 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19230 info_ptr += bytes_read;
19233 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19234 + read_1_byte (abfd, info_ptr));
19238 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19239 + read_2_bytes (abfd, info_ptr));
19243 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19244 + read_4_bytes (abfd, info_ptr));
19248 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19249 + read_8_bytes (abfd, info_ptr));
19252 case DW_FORM_ref_sig8:
19253 DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
19256 case DW_FORM_ref_udata:
19257 DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19258 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
19259 info_ptr += bytes_read;
19261 case DW_FORM_indirect:
19262 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19263 info_ptr += bytes_read;
19264 if (form == DW_FORM_implicit_const)
19266 implicit_const = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19267 info_ptr += bytes_read;
19269 info_ptr = read_attribute_value (reader, attr, form, implicit_const,
19272 case DW_FORM_implicit_const:
19273 DW_SND (attr) = implicit_const;
19275 case DW_FORM_addrx:
19276 case DW_FORM_GNU_addr_index:
19277 if (reader->dwo_file == NULL)
19279 /* For now flag a hard error.
19280 Later we can turn this into a complaint. */
19281 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19282 dwarf_form_name (form),
19283 bfd_get_filename (abfd));
19285 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
19286 info_ptr += bytes_read;
19289 case DW_FORM_strx1:
19290 case DW_FORM_strx2:
19291 case DW_FORM_strx3:
19292 case DW_FORM_strx4:
19293 case DW_FORM_GNU_str_index:
19294 if (reader->dwo_file == NULL)
19296 /* For now flag a hard error.
19297 Later we can turn this into a complaint if warranted. */
19298 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19299 dwarf_form_name (form),
19300 bfd_get_filename (abfd));
19303 ULONGEST str_index;
19304 if (form == DW_FORM_strx1)
19306 str_index = read_1_byte (abfd, info_ptr);
19309 else if (form == DW_FORM_strx2)
19311 str_index = read_2_bytes (abfd, info_ptr);
19314 else if (form == DW_FORM_strx3)
19316 str_index = read_3_bytes (abfd, info_ptr);
19319 else if (form == DW_FORM_strx4)
19321 str_index = read_4_bytes (abfd, info_ptr);
19326 str_index = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19327 info_ptr += bytes_read;
19329 DW_STRING (attr) = read_str_index (reader, str_index);
19330 DW_STRING_IS_CANONICAL (attr) = 0;
19334 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19335 dwarf_form_name (form),
19336 bfd_get_filename (abfd));
19340 if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
19341 attr->form = DW_FORM_GNU_ref_alt;
19343 /* We have seen instances where the compiler tried to emit a byte
19344 size attribute of -1 which ended up being encoded as an unsigned
19345 0xffffffff. Although 0xffffffff is technically a valid size value,
19346 an object of this size seems pretty unlikely so we can relatively
19347 safely treat these cases as if the size attribute was invalid and
19348 treat them as zero by default. */
19349 if (attr->name == DW_AT_byte_size
19350 && form == DW_FORM_data4
19351 && DW_UNSND (attr) >= 0xffffffff)
19354 (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19355 hex_string (DW_UNSND (attr)));
19356 DW_UNSND (attr) = 0;
19362 /* Read an attribute described by an abbreviated attribute. */
19364 static const gdb_byte *
19365 read_attribute (const struct die_reader_specs *reader,
19366 struct attribute *attr, struct attr_abbrev *abbrev,
19367 const gdb_byte *info_ptr)
19369 attr->name = abbrev->name;
19370 return read_attribute_value (reader, attr, abbrev->form,
19371 abbrev->implicit_const, info_ptr);
19374 /* Read dwarf information from a buffer. */
19376 static unsigned int
19377 read_1_byte (bfd *abfd, const gdb_byte *buf)
19379 return bfd_get_8 (abfd, buf);
19383 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
19385 return bfd_get_signed_8 (abfd, buf);
19388 static unsigned int
19389 read_2_bytes (bfd *abfd, const gdb_byte *buf)
19391 return bfd_get_16 (abfd, buf);
19395 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
19397 return bfd_get_signed_16 (abfd, buf);
19400 static unsigned int
19401 read_3_bytes (bfd *abfd, const gdb_byte *buf)
19403 unsigned int result = 0;
19404 for (int i = 0; i < 3; ++i)
19406 unsigned char byte = bfd_get_8 (abfd, buf);
19408 result |= ((unsigned int) byte << (i * 8));
19413 static unsigned int
19414 read_4_bytes (bfd *abfd, const gdb_byte *buf)
19416 return bfd_get_32 (abfd, buf);
19420 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
19422 return bfd_get_signed_32 (abfd, buf);
19426 read_8_bytes (bfd *abfd, const gdb_byte *buf)
19428 return bfd_get_64 (abfd, buf);
19432 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
19433 unsigned int *bytes_read)
19435 struct comp_unit_head *cu_header = &cu->header;
19436 CORE_ADDR retval = 0;
19438 if (cu_header->signed_addr_p)
19440 switch (cu_header->addr_size)
19443 retval = bfd_get_signed_16 (abfd, buf);
19446 retval = bfd_get_signed_32 (abfd, buf);
19449 retval = bfd_get_signed_64 (abfd, buf);
19452 internal_error (__FILE__, __LINE__,
19453 _("read_address: bad switch, signed [in module %s]"),
19454 bfd_get_filename (abfd));
19459 switch (cu_header->addr_size)
19462 retval = bfd_get_16 (abfd, buf);
19465 retval = bfd_get_32 (abfd, buf);
19468 retval = bfd_get_64 (abfd, buf);
19471 internal_error (__FILE__, __LINE__,
19472 _("read_address: bad switch, "
19473 "unsigned [in module %s]"),
19474 bfd_get_filename (abfd));
19478 *bytes_read = cu_header->addr_size;
19482 /* Read the initial length from a section. The (draft) DWARF 3
19483 specification allows the initial length to take up either 4 bytes
19484 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
19485 bytes describe the length and all offsets will be 8 bytes in length
19488 An older, non-standard 64-bit format is also handled by this
19489 function. The older format in question stores the initial length
19490 as an 8-byte quantity without an escape value. Lengths greater
19491 than 2^32 aren't very common which means that the initial 4 bytes
19492 is almost always zero. Since a length value of zero doesn't make
19493 sense for the 32-bit format, this initial zero can be considered to
19494 be an escape value which indicates the presence of the older 64-bit
19495 format. As written, the code can't detect (old format) lengths
19496 greater than 4GB. If it becomes necessary to handle lengths
19497 somewhat larger than 4GB, we could allow other small values (such
19498 as the non-sensical values of 1, 2, and 3) to also be used as
19499 escape values indicating the presence of the old format.
19501 The value returned via bytes_read should be used to increment the
19502 relevant pointer after calling read_initial_length().
19504 [ Note: read_initial_length() and read_offset() are based on the
19505 document entitled "DWARF Debugging Information Format", revision
19506 3, draft 8, dated November 19, 2001. This document was obtained
19509 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19511 This document is only a draft and is subject to change. (So beware.)
19513 Details regarding the older, non-standard 64-bit format were
19514 determined empirically by examining 64-bit ELF files produced by
19515 the SGI toolchain on an IRIX 6.5 machine.
19517 - Kevin, July 16, 2002
19521 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
19523 LONGEST length = bfd_get_32 (abfd, buf);
19525 if (length == 0xffffffff)
19527 length = bfd_get_64 (abfd, buf + 4);
19530 else if (length == 0)
19532 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
19533 length = bfd_get_64 (abfd, buf);
19544 /* Cover function for read_initial_length.
19545 Returns the length of the object at BUF, and stores the size of the
19546 initial length in *BYTES_READ and stores the size that offsets will be in
19548 If the initial length size is not equivalent to that specified in
19549 CU_HEADER then issue a complaint.
19550 This is useful when reading non-comp-unit headers. */
19553 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
19554 const struct comp_unit_head *cu_header,
19555 unsigned int *bytes_read,
19556 unsigned int *offset_size)
19558 LONGEST length = read_initial_length (abfd, buf, bytes_read);
19560 gdb_assert (cu_header->initial_length_size == 4
19561 || cu_header->initial_length_size == 8
19562 || cu_header->initial_length_size == 12);
19564 if (cu_header->initial_length_size != *bytes_read)
19565 complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19567 *offset_size = (*bytes_read == 4) ? 4 : 8;
19571 /* Read an offset from the data stream. The size of the offset is
19572 given by cu_header->offset_size. */
19575 read_offset (bfd *abfd, const gdb_byte *buf,
19576 const struct comp_unit_head *cu_header,
19577 unsigned int *bytes_read)
19579 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
19581 *bytes_read = cu_header->offset_size;
19585 /* Read an offset from the data stream. */
19588 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
19590 LONGEST retval = 0;
19592 switch (offset_size)
19595 retval = bfd_get_32 (abfd, buf);
19598 retval = bfd_get_64 (abfd, buf);
19601 internal_error (__FILE__, __LINE__,
19602 _("read_offset_1: bad switch [in module %s]"),
19603 bfd_get_filename (abfd));
19609 static const gdb_byte *
19610 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
19612 /* If the size of a host char is 8 bits, we can return a pointer
19613 to the buffer, otherwise we have to copy the data to a buffer
19614 allocated on the temporary obstack. */
19615 gdb_assert (HOST_CHAR_BIT == 8);
19619 static const char *
19620 read_direct_string (bfd *abfd, const gdb_byte *buf,
19621 unsigned int *bytes_read_ptr)
19623 /* If the size of a host char is 8 bits, we can return a pointer
19624 to the string, otherwise we have to copy the string to a buffer
19625 allocated on the temporary obstack. */
19626 gdb_assert (HOST_CHAR_BIT == 8);
19629 *bytes_read_ptr = 1;
19632 *bytes_read_ptr = strlen ((const char *) buf) + 1;
19633 return (const char *) buf;
19636 /* Return pointer to string at section SECT offset STR_OFFSET with error
19637 reporting strings FORM_NAME and SECT_NAME. */
19639 static const char *
19640 read_indirect_string_at_offset_from (struct objfile *objfile,
19641 bfd *abfd, LONGEST str_offset,
19642 struct dwarf2_section_info *sect,
19643 const char *form_name,
19644 const char *sect_name)
19646 dwarf2_read_section (objfile, sect);
19647 if (sect->buffer == NULL)
19648 error (_("%s used without %s section [in module %s]"),
19649 form_name, sect_name, bfd_get_filename (abfd));
19650 if (str_offset >= sect->size)
19651 error (_("%s pointing outside of %s section [in module %s]"),
19652 form_name, sect_name, bfd_get_filename (abfd));
19653 gdb_assert (HOST_CHAR_BIT == 8);
19654 if (sect->buffer[str_offset] == '\0')
19656 return (const char *) (sect->buffer + str_offset);
19659 /* Return pointer to string at .debug_str offset STR_OFFSET. */
19661 static const char *
19662 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19663 bfd *abfd, LONGEST str_offset)
19665 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19667 &dwarf2_per_objfile->str,
19668 "DW_FORM_strp", ".debug_str");
19671 /* Return pointer to string at .debug_line_str offset STR_OFFSET. */
19673 static const char *
19674 read_indirect_line_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19675 bfd *abfd, LONGEST str_offset)
19677 return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19679 &dwarf2_per_objfile->line_str,
19680 "DW_FORM_line_strp",
19681 ".debug_line_str");
19684 /* Read a string at offset STR_OFFSET in the .debug_str section from
19685 the .dwz file DWZ. Throw an error if the offset is too large. If
19686 the string consists of a single NUL byte, return NULL; otherwise
19687 return a pointer to the string. */
19689 static const char *
19690 read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz,
19691 LONGEST str_offset)
19693 dwarf2_read_section (objfile, &dwz->str);
19695 if (dwz->str.buffer == NULL)
19696 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19697 "section [in module %s]"),
19698 bfd_get_filename (dwz->dwz_bfd));
19699 if (str_offset >= dwz->str.size)
19700 error (_("DW_FORM_GNU_strp_alt pointing outside of "
19701 ".debug_str section [in module %s]"),
19702 bfd_get_filename (dwz->dwz_bfd));
19703 gdb_assert (HOST_CHAR_BIT == 8);
19704 if (dwz->str.buffer[str_offset] == '\0')
19706 return (const char *) (dwz->str.buffer + str_offset);
19709 /* Return pointer to string at .debug_str offset as read from BUF.
19710 BUF is assumed to be in a compilation unit described by CU_HEADER.
19711 Return *BYTES_READ_PTR count of bytes read from BUF. */
19713 static const char *
19714 read_indirect_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
19715 const gdb_byte *buf,
19716 const struct comp_unit_head *cu_header,
19717 unsigned int *bytes_read_ptr)
19719 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19721 return read_indirect_string_at_offset (dwarf2_per_objfile, abfd, str_offset);
19724 /* Return pointer to string at .debug_line_str offset as read from BUF.
19725 BUF is assumed to be in a compilation unit described by CU_HEADER.
19726 Return *BYTES_READ_PTR count of bytes read from BUF. */
19728 static const char *
19729 read_indirect_line_string (struct dwarf2_per_objfile *dwarf2_per_objfile,
19730 bfd *abfd, const gdb_byte *buf,
19731 const struct comp_unit_head *cu_header,
19732 unsigned int *bytes_read_ptr)
19734 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19736 return read_indirect_line_string_at_offset (dwarf2_per_objfile, abfd,
19741 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
19742 unsigned int *bytes_read_ptr)
19745 unsigned int num_read;
19747 unsigned char byte;
19754 byte = bfd_get_8 (abfd, buf);
19757 result |= ((ULONGEST) (byte & 127) << shift);
19758 if ((byte & 128) == 0)
19764 *bytes_read_ptr = num_read;
19769 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
19770 unsigned int *bytes_read_ptr)
19773 int shift, num_read;
19774 unsigned char byte;
19781 byte = bfd_get_8 (abfd, buf);
19784 result |= ((ULONGEST) (byte & 127) << shift);
19786 if ((byte & 128) == 0)
19791 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
19792 result |= -(((ULONGEST) 1) << shift);
19793 *bytes_read_ptr = num_read;
19797 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19798 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19799 ADDR_SIZE is the size of addresses from the CU header. */
19802 read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
19803 unsigned int addr_index, ULONGEST addr_base, int addr_size)
19805 struct objfile *objfile = dwarf2_per_objfile->objfile;
19806 bfd *abfd = objfile->obfd;
19807 const gdb_byte *info_ptr;
19809 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
19810 if (dwarf2_per_objfile->addr.buffer == NULL)
19811 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19812 objfile_name (objfile));
19813 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
19814 error (_("DW_FORM_addr_index pointing outside of "
19815 ".debug_addr section [in module %s]"),
19816 objfile_name (objfile));
19817 info_ptr = (dwarf2_per_objfile->addr.buffer
19818 + addr_base + addr_index * addr_size);
19819 if (addr_size == 4)
19820 return bfd_get_32 (abfd, info_ptr);
19822 return bfd_get_64 (abfd, info_ptr);
19825 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
19828 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
19830 return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
19831 cu->addr_base, cu->header.addr_size);
19834 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
19837 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
19838 unsigned int *bytes_read)
19840 bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
19841 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
19843 return read_addr_index (cu, addr_index);
19846 /* Data structure to pass results from dwarf2_read_addr_index_reader
19847 back to dwarf2_read_addr_index. */
19849 struct dwarf2_read_addr_index_data
19851 ULONGEST addr_base;
19855 /* die_reader_func for dwarf2_read_addr_index. */
19858 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
19859 const gdb_byte *info_ptr,
19860 struct die_info *comp_unit_die,
19864 struct dwarf2_cu *cu = reader->cu;
19865 struct dwarf2_read_addr_index_data *aidata =
19866 (struct dwarf2_read_addr_index_data *) data;
19868 aidata->addr_base = cu->addr_base;
19869 aidata->addr_size = cu->header.addr_size;
19872 /* Given an index in .debug_addr, fetch the value.
19873 NOTE: This can be called during dwarf expression evaluation,
19874 long after the debug information has been read, and thus per_cu->cu
19875 may no longer exist. */
19878 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
19879 unsigned int addr_index)
19881 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
19882 struct dwarf2_cu *cu = per_cu->cu;
19883 ULONGEST addr_base;
19886 /* We need addr_base and addr_size.
19887 If we don't have PER_CU->cu, we have to get it.
19888 Nasty, but the alternative is storing the needed info in PER_CU,
19889 which at this point doesn't seem justified: it's not clear how frequently
19890 it would get used and it would increase the size of every PER_CU.
19891 Entry points like dwarf2_per_cu_addr_size do a similar thing
19892 so we're not in uncharted territory here.
19893 Alas we need to be a bit more complicated as addr_base is contained
19896 We don't need to read the entire CU(/TU).
19897 We just need the header and top level die.
19899 IWBN to use the aging mechanism to let us lazily later discard the CU.
19900 For now we skip this optimization. */
19904 addr_base = cu->addr_base;
19905 addr_size = cu->header.addr_size;
19909 struct dwarf2_read_addr_index_data aidata;
19911 /* Note: We can't use init_cutu_and_read_dies_simple here,
19912 we need addr_base. */
19913 init_cutu_and_read_dies (per_cu, NULL, 0, 0, false,
19914 dwarf2_read_addr_index_reader, &aidata);
19915 addr_base = aidata.addr_base;
19916 addr_size = aidata.addr_size;
19919 return read_addr_index_1 (dwarf2_per_objfile, addr_index, addr_base,
19923 /* Given a DW_FORM_GNU_str_index or DW_FORM_strx, fetch the string.
19924 This is only used by the Fission support. */
19926 static const char *
19927 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
19929 struct dwarf2_cu *cu = reader->cu;
19930 struct dwarf2_per_objfile *dwarf2_per_objfile
19931 = cu->per_cu->dwarf2_per_objfile;
19932 struct objfile *objfile = dwarf2_per_objfile->objfile;
19933 const char *objf_name = objfile_name (objfile);
19934 bfd *abfd = objfile->obfd;
19935 struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
19936 struct dwarf2_section_info *str_offsets_section =
19937 &reader->dwo_file->sections.str_offsets;
19938 const gdb_byte *info_ptr;
19939 ULONGEST str_offset;
19940 static const char form_name[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
19942 dwarf2_read_section (objfile, str_section);
19943 dwarf2_read_section (objfile, str_offsets_section);
19944 if (str_section->buffer == NULL)
19945 error (_("%s used without .debug_str.dwo section"
19946 " in CU at offset %s [in module %s]"),
19947 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19948 if (str_offsets_section->buffer == NULL)
19949 error (_("%s used without .debug_str_offsets.dwo section"
19950 " in CU at offset %s [in module %s]"),
19951 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19952 if (str_index * cu->header.offset_size >= str_offsets_section->size)
19953 error (_("%s pointing outside of .debug_str_offsets.dwo"
19954 " section in CU at offset %s [in module %s]"),
19955 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19956 info_ptr = (str_offsets_section->buffer
19957 + str_index * cu->header.offset_size);
19958 if (cu->header.offset_size == 4)
19959 str_offset = bfd_get_32 (abfd, info_ptr);
19961 str_offset = bfd_get_64 (abfd, info_ptr);
19962 if (str_offset >= str_section->size)
19963 error (_("Offset from %s pointing outside of"
19964 " .debug_str.dwo section in CU at offset %s [in module %s]"),
19965 form_name, sect_offset_str (cu->header.sect_off), objf_name);
19966 return (const char *) (str_section->buffer + str_offset);
19969 /* Return the length of an LEB128 number in BUF. */
19972 leb128_size (const gdb_byte *buf)
19974 const gdb_byte *begin = buf;
19980 if ((byte & 128) == 0)
19981 return buf - begin;
19986 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
19995 cu->language = language_c;
19998 case DW_LANG_C_plus_plus:
19999 case DW_LANG_C_plus_plus_11:
20000 case DW_LANG_C_plus_plus_14:
20001 cu->language = language_cplus;
20004 cu->language = language_d;
20006 case DW_LANG_Fortran77:
20007 case DW_LANG_Fortran90:
20008 case DW_LANG_Fortran95:
20009 case DW_LANG_Fortran03:
20010 case DW_LANG_Fortran08:
20011 cu->language = language_fortran;
20014 cu->language = language_go;
20016 case DW_LANG_Mips_Assembler:
20017 cu->language = language_asm;
20019 case DW_LANG_Ada83:
20020 case DW_LANG_Ada95:
20021 cu->language = language_ada;
20023 case DW_LANG_Modula2:
20024 cu->language = language_m2;
20026 case DW_LANG_Pascal83:
20027 cu->language = language_pascal;
20030 cu->language = language_objc;
20033 case DW_LANG_Rust_old:
20034 cu->language = language_rust;
20036 case DW_LANG_Cobol74:
20037 case DW_LANG_Cobol85:
20039 cu->language = language_minimal;
20042 cu->language_defn = language_def (cu->language);
20045 /* Return the named attribute or NULL if not there. */
20047 static struct attribute *
20048 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
20053 struct attribute *spec = NULL;
20055 for (i = 0; i < die->num_attrs; ++i)
20057 if (die->attrs[i].name == name)
20058 return &die->attrs[i];
20059 if (die->attrs[i].name == DW_AT_specification
20060 || die->attrs[i].name == DW_AT_abstract_origin)
20061 spec = &die->attrs[i];
20067 die = follow_die_ref (die, spec, &cu);
20073 /* Return the named attribute or NULL if not there,
20074 but do not follow DW_AT_specification, etc.
20075 This is for use in contexts where we're reading .debug_types dies.
20076 Following DW_AT_specification, DW_AT_abstract_origin will take us
20077 back up the chain, and we want to go down. */
20079 static struct attribute *
20080 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
20084 for (i = 0; i < die->num_attrs; ++i)
20085 if (die->attrs[i].name == name)
20086 return &die->attrs[i];
20091 /* Return the string associated with a string-typed attribute, or NULL if it
20092 is either not found or is of an incorrect type. */
20094 static const char *
20095 dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
20097 struct attribute *attr;
20098 const char *str = NULL;
20100 attr = dwarf2_attr (die, name, cu);
20104 if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp
20105 || attr->form == DW_FORM_string
20106 || attr->form == DW_FORM_strx
20107 || attr->form == DW_FORM_GNU_str_index
20108 || attr->form == DW_FORM_GNU_strp_alt)
20109 str = DW_STRING (attr);
20111 complaint (_("string type expected for attribute %s for "
20112 "DIE at %s in module %s"),
20113 dwarf_attr_name (name), sect_offset_str (die->sect_off),
20114 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
20120 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20121 and holds a non-zero value. This function should only be used for
20122 DW_FORM_flag or DW_FORM_flag_present attributes. */
20125 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
20127 struct attribute *attr = dwarf2_attr (die, name, cu);
20129 return (attr && DW_UNSND (attr));
20133 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
20135 /* A DIE is a declaration if it has a DW_AT_declaration attribute
20136 which value is non-zero. However, we have to be careful with
20137 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20138 (via dwarf2_flag_true_p) follows this attribute. So we may
20139 end up accidently finding a declaration attribute that belongs
20140 to a different DIE referenced by the specification attribute,
20141 even though the given DIE does not have a declaration attribute. */
20142 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
20143 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
20146 /* Return the die giving the specification for DIE, if there is
20147 one. *SPEC_CU is the CU containing DIE on input, and the CU
20148 containing the return value on output. If there is no
20149 specification, but there is an abstract origin, that is
20152 static struct die_info *
20153 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
20155 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
20158 if (spec_attr == NULL)
20159 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
20161 if (spec_attr == NULL)
20164 return follow_die_ref (die, spec_attr, spec_cu);
20167 /* Stub for free_line_header to match void * callback types. */
20170 free_line_header_voidp (void *arg)
20172 struct line_header *lh = (struct line_header *) arg;
20178 line_header::add_include_dir (const char *include_dir)
20180 if (dwarf_line_debug >= 2)
20181 fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
20182 include_dirs.size () + 1, include_dir);
20184 include_dirs.push_back (include_dir);
20188 line_header::add_file_name (const char *name,
20190 unsigned int mod_time,
20191 unsigned int length)
20193 if (dwarf_line_debug >= 2)
20194 fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
20195 (unsigned) file_names.size () + 1, name);
20197 file_names.emplace_back (name, d_index, mod_time, length);
20200 /* A convenience function to find the proper .debug_line section for a CU. */
20202 static struct dwarf2_section_info *
20203 get_debug_line_section (struct dwarf2_cu *cu)
20205 struct dwarf2_section_info *section;
20206 struct dwarf2_per_objfile *dwarf2_per_objfile
20207 = cu->per_cu->dwarf2_per_objfile;
20209 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20211 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20212 section = &cu->dwo_unit->dwo_file->sections.line;
20213 else if (cu->per_cu->is_dwz)
20215 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
20217 section = &dwz->line;
20220 section = &dwarf2_per_objfile->line;
20225 /* Read directory or file name entry format, starting with byte of
20226 format count entries, ULEB128 pairs of entry formats, ULEB128 of
20227 entries count and the entries themselves in the described entry
20231 read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
20232 bfd *abfd, const gdb_byte **bufp,
20233 struct line_header *lh,
20234 const struct comp_unit_head *cu_header,
20235 void (*callback) (struct line_header *lh,
20238 unsigned int mod_time,
20239 unsigned int length))
20241 gdb_byte format_count, formati;
20242 ULONGEST data_count, datai;
20243 const gdb_byte *buf = *bufp;
20244 const gdb_byte *format_header_data;
20245 unsigned int bytes_read;
20247 format_count = read_1_byte (abfd, buf);
20249 format_header_data = buf;
20250 for (formati = 0; formati < format_count; formati++)
20252 read_unsigned_leb128 (abfd, buf, &bytes_read);
20254 read_unsigned_leb128 (abfd, buf, &bytes_read);
20258 data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
20260 for (datai = 0; datai < data_count; datai++)
20262 const gdb_byte *format = format_header_data;
20263 struct file_entry fe;
20265 for (formati = 0; formati < format_count; formati++)
20267 ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
20268 format += bytes_read;
20270 ULONGEST form = read_unsigned_leb128 (abfd, format, &bytes_read);
20271 format += bytes_read;
20273 gdb::optional<const char *> string;
20274 gdb::optional<unsigned int> uint;
20278 case DW_FORM_string:
20279 string.emplace (read_direct_string (abfd, buf, &bytes_read));
20283 case DW_FORM_line_strp:
20284 string.emplace (read_indirect_line_string (dwarf2_per_objfile,
20291 case DW_FORM_data1:
20292 uint.emplace (read_1_byte (abfd, buf));
20296 case DW_FORM_data2:
20297 uint.emplace (read_2_bytes (abfd, buf));
20301 case DW_FORM_data4:
20302 uint.emplace (read_4_bytes (abfd, buf));
20306 case DW_FORM_data8:
20307 uint.emplace (read_8_bytes (abfd, buf));
20311 case DW_FORM_udata:
20312 uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
20316 case DW_FORM_block:
20317 /* It is valid only for DW_LNCT_timestamp which is ignored by
20322 switch (content_type)
20325 if (string.has_value ())
20328 case DW_LNCT_directory_index:
20329 if (uint.has_value ())
20330 fe.d_index = (dir_index) *uint;
20332 case DW_LNCT_timestamp:
20333 if (uint.has_value ())
20334 fe.mod_time = *uint;
20337 if (uint.has_value ())
20343 complaint (_("Unknown format content type %s"),
20344 pulongest (content_type));
20348 callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
20354 /* Read the statement program header starting at OFFSET in
20355 .debug_line, or .debug_line.dwo. Return a pointer
20356 to a struct line_header, allocated using xmalloc.
20357 Returns NULL if there is a problem reading the header, e.g., if it
20358 has a version we don't understand.
20360 NOTE: the strings in the include directory and file name tables of
20361 the returned object point into the dwarf line section buffer,
20362 and must not be freed. */
20364 static line_header_up
20365 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
20367 const gdb_byte *line_ptr;
20368 unsigned int bytes_read, offset_size;
20370 const char *cur_dir, *cur_file;
20371 struct dwarf2_section_info *section;
20373 struct dwarf2_per_objfile *dwarf2_per_objfile
20374 = cu->per_cu->dwarf2_per_objfile;
20376 section = get_debug_line_section (cu);
20377 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20378 if (section->buffer == NULL)
20380 if (cu->dwo_unit && cu->per_cu->is_debug_types)
20381 complaint (_("missing .debug_line.dwo section"));
20383 complaint (_("missing .debug_line section"));
20387 /* We can't do this until we know the section is non-empty.
20388 Only then do we know we have such a section. */
20389 abfd = get_section_bfd_owner (section);
20391 /* Make sure that at least there's room for the total_length field.
20392 That could be 12 bytes long, but we're just going to fudge that. */
20393 if (to_underlying (sect_off) + 4 >= section->size)
20395 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20399 line_header_up lh (new line_header ());
20401 lh->sect_off = sect_off;
20402 lh->offset_in_dwz = cu->per_cu->is_dwz;
20404 line_ptr = section->buffer + to_underlying (sect_off);
20406 /* Read in the header. */
20408 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
20409 &bytes_read, &offset_size);
20410 line_ptr += bytes_read;
20411 if (line_ptr + lh->total_length > (section->buffer + section->size))
20413 dwarf2_statement_list_fits_in_line_number_section_complaint ();
20416 lh->statement_program_end = line_ptr + lh->total_length;
20417 lh->version = read_2_bytes (abfd, line_ptr);
20419 if (lh->version > 5)
20421 /* This is a version we don't understand. The format could have
20422 changed in ways we don't handle properly so just punt. */
20423 complaint (_("unsupported version in .debug_line section"));
20426 if (lh->version >= 5)
20428 gdb_byte segment_selector_size;
20430 /* Skip address size. */
20431 read_1_byte (abfd, line_ptr);
20434 segment_selector_size = read_1_byte (abfd, line_ptr);
20436 if (segment_selector_size != 0)
20438 complaint (_("unsupported segment selector size %u "
20439 "in .debug_line section"),
20440 segment_selector_size);
20444 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
20445 line_ptr += offset_size;
20446 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
20448 if (lh->version >= 4)
20450 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
20454 lh->maximum_ops_per_instruction = 1;
20456 if (lh->maximum_ops_per_instruction == 0)
20458 lh->maximum_ops_per_instruction = 1;
20459 complaint (_("invalid maximum_ops_per_instruction "
20460 "in `.debug_line' section"));
20463 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
20465 lh->line_base = read_1_signed_byte (abfd, line_ptr);
20467 lh->line_range = read_1_byte (abfd, line_ptr);
20469 lh->opcode_base = read_1_byte (abfd, line_ptr);
20471 lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
20473 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
20474 for (i = 1; i < lh->opcode_base; ++i)
20476 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
20480 if (lh->version >= 5)
20482 /* Read directory table. */
20483 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20485 [] (struct line_header *header, const char *name,
20486 dir_index d_index, unsigned int mod_time,
20487 unsigned int length)
20489 header->add_include_dir (name);
20492 /* Read file name table. */
20493 read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20495 [] (struct line_header *header, const char *name,
20496 dir_index d_index, unsigned int mod_time,
20497 unsigned int length)
20499 header->add_file_name (name, d_index, mod_time, length);
20504 /* Read directory table. */
20505 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20507 line_ptr += bytes_read;
20508 lh->add_include_dir (cur_dir);
20510 line_ptr += bytes_read;
20512 /* Read file name table. */
20513 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20515 unsigned int mod_time, length;
20518 line_ptr += bytes_read;
20519 d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20520 line_ptr += bytes_read;
20521 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20522 line_ptr += bytes_read;
20523 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20524 line_ptr += bytes_read;
20526 lh->add_file_name (cur_file, d_index, mod_time, length);
20528 line_ptr += bytes_read;
20530 lh->statement_program_start = line_ptr;
20532 if (line_ptr > (section->buffer + section->size))
20533 complaint (_("line number info header doesn't "
20534 "fit in `.debug_line' section"));
20539 /* Subroutine of dwarf_decode_lines to simplify it.
20540 Return the file name of the psymtab for included file FILE_INDEX
20541 in line header LH of PST.
20542 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20543 If space for the result is malloc'd, *NAME_HOLDER will be set.
20544 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
20546 static const char *
20547 psymtab_include_file_name (const struct line_header *lh, int file_index,
20548 const struct partial_symtab *pst,
20549 const char *comp_dir,
20550 gdb::unique_xmalloc_ptr<char> *name_holder)
20552 const file_entry &fe = lh->file_names[file_index];
20553 const char *include_name = fe.name;
20554 const char *include_name_to_compare = include_name;
20555 const char *pst_filename;
20558 const char *dir_name = fe.include_dir (lh);
20560 gdb::unique_xmalloc_ptr<char> hold_compare;
20561 if (!IS_ABSOLUTE_PATH (include_name)
20562 && (dir_name != NULL || comp_dir != NULL))
20564 /* Avoid creating a duplicate psymtab for PST.
20565 We do this by comparing INCLUDE_NAME and PST_FILENAME.
20566 Before we do the comparison, however, we need to account
20567 for DIR_NAME and COMP_DIR.
20568 First prepend dir_name (if non-NULL). If we still don't
20569 have an absolute path prepend comp_dir (if non-NULL).
20570 However, the directory we record in the include-file's
20571 psymtab does not contain COMP_DIR (to match the
20572 corresponding symtab(s)).
20577 bash$ gcc -g ./hello.c
20578 include_name = "hello.c"
20580 DW_AT_comp_dir = comp_dir = "/tmp"
20581 DW_AT_name = "./hello.c"
20585 if (dir_name != NULL)
20587 name_holder->reset (concat (dir_name, SLASH_STRING,
20588 include_name, (char *) NULL));
20589 include_name = name_holder->get ();
20590 include_name_to_compare = include_name;
20592 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
20594 hold_compare.reset (concat (comp_dir, SLASH_STRING,
20595 include_name, (char *) NULL));
20596 include_name_to_compare = hold_compare.get ();
20600 pst_filename = pst->filename;
20601 gdb::unique_xmalloc_ptr<char> copied_name;
20602 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
20604 copied_name.reset (concat (pst->dirname, SLASH_STRING,
20605 pst_filename, (char *) NULL));
20606 pst_filename = copied_name.get ();
20609 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
20613 return include_name;
20616 /* State machine to track the state of the line number program. */
20618 class lnp_state_machine
20621 /* Initialize a machine state for the start of a line number
20623 lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch, line_header *lh,
20624 bool record_lines_p);
20626 file_entry *current_file ()
20628 /* lh->file_names is 0-based, but the file name numbers in the
20629 statement program are 1-based. */
20630 return m_line_header->file_name_at (m_file);
20633 /* Record the line in the state machine. END_SEQUENCE is true if
20634 we're processing the end of a sequence. */
20635 void record_line (bool end_sequence);
20637 /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20638 nop-out rest of the lines in this sequence. */
20639 void check_line_address (struct dwarf2_cu *cu,
20640 const gdb_byte *line_ptr,
20641 CORE_ADDR unrelocated_lowpc, CORE_ADDR address);
20643 void handle_set_discriminator (unsigned int discriminator)
20645 m_discriminator = discriminator;
20646 m_line_has_non_zero_discriminator |= discriminator != 0;
20649 /* Handle DW_LNE_set_address. */
20650 void handle_set_address (CORE_ADDR baseaddr, CORE_ADDR address)
20653 address += baseaddr;
20654 m_address = gdbarch_adjust_dwarf2_line (m_gdbarch, address, false);
20657 /* Handle DW_LNS_advance_pc. */
20658 void handle_advance_pc (CORE_ADDR adjust);
20660 /* Handle a special opcode. */
20661 void handle_special_opcode (unsigned char op_code);
20663 /* Handle DW_LNS_advance_line. */
20664 void handle_advance_line (int line_delta)
20666 advance_line (line_delta);
20669 /* Handle DW_LNS_set_file. */
20670 void handle_set_file (file_name_index file);
20672 /* Handle DW_LNS_negate_stmt. */
20673 void handle_negate_stmt ()
20675 m_is_stmt = !m_is_stmt;
20678 /* Handle DW_LNS_const_add_pc. */
20679 void handle_const_add_pc ();
20681 /* Handle DW_LNS_fixed_advance_pc. */
20682 void handle_fixed_advance_pc (CORE_ADDR addr_adj)
20684 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20688 /* Handle DW_LNS_copy. */
20689 void handle_copy ()
20691 record_line (false);
20692 m_discriminator = 0;
20695 /* Handle DW_LNE_end_sequence. */
20696 void handle_end_sequence ()
20698 m_currently_recording_lines = true;
20702 /* Advance the line by LINE_DELTA. */
20703 void advance_line (int line_delta)
20705 m_line += line_delta;
20707 if (line_delta != 0)
20708 m_line_has_non_zero_discriminator = m_discriminator != 0;
20711 struct dwarf2_cu *m_cu;
20713 gdbarch *m_gdbarch;
20715 /* True if we're recording lines.
20716 Otherwise we're building partial symtabs and are just interested in
20717 finding include files mentioned by the line number program. */
20718 bool m_record_lines_p;
20720 /* The line number header. */
20721 line_header *m_line_header;
20723 /* These are part of the standard DWARF line number state machine,
20724 and initialized according to the DWARF spec. */
20726 unsigned char m_op_index = 0;
20727 /* The line table index (1-based) of the current file. */
20728 file_name_index m_file = (file_name_index) 1;
20729 unsigned int m_line = 1;
20731 /* These are initialized in the constructor. */
20733 CORE_ADDR m_address;
20735 unsigned int m_discriminator;
20737 /* Additional bits of state we need to track. */
20739 /* The last file that we called dwarf2_start_subfile for.
20740 This is only used for TLLs. */
20741 unsigned int m_last_file = 0;
20742 /* The last file a line number was recorded for. */
20743 struct subfile *m_last_subfile = NULL;
20745 /* When true, record the lines we decode. */
20746 bool m_currently_recording_lines = false;
20748 /* The last line number that was recorded, used to coalesce
20749 consecutive entries for the same line. This can happen, for
20750 example, when discriminators are present. PR 17276. */
20751 unsigned int m_last_line = 0;
20752 bool m_line_has_non_zero_discriminator = false;
20756 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust)
20758 CORE_ADDR addr_adj = (((m_op_index + adjust)
20759 / m_line_header->maximum_ops_per_instruction)
20760 * m_line_header->minimum_instruction_length);
20761 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20762 m_op_index = ((m_op_index + adjust)
20763 % m_line_header->maximum_ops_per_instruction);
20767 lnp_state_machine::handle_special_opcode (unsigned char op_code)
20769 unsigned char adj_opcode = op_code - m_line_header->opcode_base;
20770 CORE_ADDR addr_adj = (((m_op_index
20771 + (adj_opcode / m_line_header->line_range))
20772 / m_line_header->maximum_ops_per_instruction)
20773 * m_line_header->minimum_instruction_length);
20774 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20775 m_op_index = ((m_op_index + (adj_opcode / m_line_header->line_range))
20776 % m_line_header->maximum_ops_per_instruction);
20778 int line_delta = (m_line_header->line_base
20779 + (adj_opcode % m_line_header->line_range));
20780 advance_line (line_delta);
20781 record_line (false);
20782 m_discriminator = 0;
20786 lnp_state_machine::handle_set_file (file_name_index file)
20790 const file_entry *fe = current_file ();
20792 dwarf2_debug_line_missing_file_complaint ();
20793 else if (m_record_lines_p)
20795 const char *dir = fe->include_dir (m_line_header);
20797 m_last_subfile = m_cu->get_builder ()->get_current_subfile ();
20798 m_line_has_non_zero_discriminator = m_discriminator != 0;
20799 dwarf2_start_subfile (m_cu, fe->name, dir);
20804 lnp_state_machine::handle_const_add_pc ()
20807 = (255 - m_line_header->opcode_base) / m_line_header->line_range;
20810 = (((m_op_index + adjust)
20811 / m_line_header->maximum_ops_per_instruction)
20812 * m_line_header->minimum_instruction_length);
20814 m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20815 m_op_index = ((m_op_index + adjust)
20816 % m_line_header->maximum_ops_per_instruction);
20819 /* Return non-zero if we should add LINE to the line number table.
20820 LINE is the line to add, LAST_LINE is the last line that was added,
20821 LAST_SUBFILE is the subfile for LAST_LINE.
20822 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20823 had a non-zero discriminator.
20825 We have to be careful in the presence of discriminators.
20826 E.g., for this line:
20828 for (i = 0; i < 100000; i++);
20830 clang can emit four line number entries for that one line,
20831 each with a different discriminator.
20832 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20834 However, we want gdb to coalesce all four entries into one.
20835 Otherwise the user could stepi into the middle of the line and
20836 gdb would get confused about whether the pc really was in the
20837 middle of the line.
20839 Things are further complicated by the fact that two consecutive
20840 line number entries for the same line is a heuristic used by gcc
20841 to denote the end of the prologue. So we can't just discard duplicate
20842 entries, we have to be selective about it. The heuristic we use is
20843 that we only collapse consecutive entries for the same line if at least
20844 one of those entries has a non-zero discriminator. PR 17276.
20846 Note: Addresses in the line number state machine can never go backwards
20847 within one sequence, thus this coalescing is ok. */
20850 dwarf_record_line_p (struct dwarf2_cu *cu,
20851 unsigned int line, unsigned int last_line,
20852 int line_has_non_zero_discriminator,
20853 struct subfile *last_subfile)
20855 if (cu->get_builder ()->get_current_subfile () != last_subfile)
20857 if (line != last_line)
20859 /* Same line for the same file that we've seen already.
20860 As a last check, for pr 17276, only record the line if the line
20861 has never had a non-zero discriminator. */
20862 if (!line_has_non_zero_discriminator)
20867 /* Use the CU's builder to record line number LINE beginning at
20868 address ADDRESS in the line table of subfile SUBFILE. */
20871 dwarf_record_line_1 (struct gdbarch *gdbarch, struct subfile *subfile,
20872 unsigned int line, CORE_ADDR address,
20873 struct dwarf2_cu *cu)
20875 CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
20877 if (dwarf_line_debug)
20879 fprintf_unfiltered (gdb_stdlog,
20880 "Recording line %u, file %s, address %s\n",
20881 line, lbasename (subfile->name),
20882 paddress (gdbarch, address));
20886 cu->get_builder ()->record_line (subfile, line, addr);
20889 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20890 Mark the end of a set of line number records.
20891 The arguments are the same as for dwarf_record_line_1.
20892 If SUBFILE is NULL the request is ignored. */
20895 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
20896 CORE_ADDR address, struct dwarf2_cu *cu)
20898 if (subfile == NULL)
20901 if (dwarf_line_debug)
20903 fprintf_unfiltered (gdb_stdlog,
20904 "Finishing current line, file %s, address %s\n",
20905 lbasename (subfile->name),
20906 paddress (gdbarch, address));
20909 dwarf_record_line_1 (gdbarch, subfile, 0, address, cu);
20913 lnp_state_machine::record_line (bool end_sequence)
20915 if (dwarf_line_debug)
20917 fprintf_unfiltered (gdb_stdlog,
20918 "Processing actual line %u: file %u,"
20919 " address %s, is_stmt %u, discrim %u\n",
20920 m_line, to_underlying (m_file),
20921 paddress (m_gdbarch, m_address),
20922 m_is_stmt, m_discriminator);
20925 file_entry *fe = current_file ();
20928 dwarf2_debug_line_missing_file_complaint ();
20929 /* For now we ignore lines not starting on an instruction boundary.
20930 But not when processing end_sequence for compatibility with the
20931 previous version of the code. */
20932 else if (m_op_index == 0 || end_sequence)
20934 fe->included_p = 1;
20935 if (m_record_lines_p && (producer_is_codewarrior (m_cu) || m_is_stmt))
20937 if (m_last_subfile != m_cu->get_builder ()->get_current_subfile ()
20940 dwarf_finish_line (m_gdbarch, m_last_subfile, m_address,
20941 m_currently_recording_lines ? m_cu : nullptr);
20946 if (dwarf_record_line_p (m_cu, m_line, m_last_line,
20947 m_line_has_non_zero_discriminator,
20950 buildsym_compunit *builder = m_cu->get_builder ();
20951 dwarf_record_line_1 (m_gdbarch,
20952 builder->get_current_subfile (),
20954 m_currently_recording_lines ? m_cu : nullptr);
20956 m_last_subfile = m_cu->get_builder ()->get_current_subfile ();
20957 m_last_line = m_line;
20963 lnp_state_machine::lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch,
20964 line_header *lh, bool record_lines_p)
20968 m_record_lines_p = record_lines_p;
20969 m_line_header = lh;
20971 m_currently_recording_lines = true;
20973 /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20974 was a line entry for it so that the backend has a chance to adjust it
20975 and also record it in case it needs it. This is currently used by MIPS
20976 code, cf. `mips_adjust_dwarf2_line'. */
20977 m_address = gdbarch_adjust_dwarf2_line (arch, 0, 0);
20978 m_is_stmt = lh->default_is_stmt;
20979 m_discriminator = 0;
20983 lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
20984 const gdb_byte *line_ptr,
20985 CORE_ADDR unrelocated_lowpc, CORE_ADDR address)
20987 /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
20988 the pc range of the CU. However, we restrict the test to only ADDRESS
20989 values of zero to preserve GDB's previous behaviour which is to handle
20990 the specific case of a function being GC'd by the linker. */
20992 if (address == 0 && address < unrelocated_lowpc)
20994 /* This line table is for a function which has been
20995 GCd by the linker. Ignore it. PR gdb/12528 */
20997 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20998 long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
21000 complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21001 line_offset, objfile_name (objfile));
21002 m_currently_recording_lines = false;
21003 /* Note: m_currently_recording_lines is left as false until we see
21004 DW_LNE_end_sequence. */
21008 /* Subroutine of dwarf_decode_lines to simplify it.
21009 Process the line number information in LH.
21010 If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21011 program in order to set included_p for every referenced header. */
21014 dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
21015 const int decode_for_pst_p, CORE_ADDR lowpc)
21017 const gdb_byte *line_ptr, *extended_end;
21018 const gdb_byte *line_end;
21019 unsigned int bytes_read, extended_len;
21020 unsigned char op_code, extended_op;
21021 CORE_ADDR baseaddr;
21022 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21023 bfd *abfd = objfile->obfd;
21024 struct gdbarch *gdbarch = get_objfile_arch (objfile);
21025 /* True if we're recording line info (as opposed to building partial
21026 symtabs and just interested in finding include files mentioned by
21027 the line number program). */
21028 bool record_lines_p = !decode_for_pst_p;
21030 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21032 line_ptr = lh->statement_program_start;
21033 line_end = lh->statement_program_end;
21035 /* Read the statement sequences until there's nothing left. */
21036 while (line_ptr < line_end)
21038 /* The DWARF line number program state machine. Reset the state
21039 machine at the start of each sequence. */
21040 lnp_state_machine state_machine (cu, gdbarch, lh, record_lines_p);
21041 bool end_sequence = false;
21043 if (record_lines_p)
21045 /* Start a subfile for the current file of the state
21047 const file_entry *fe = state_machine.current_file ();
21050 dwarf2_start_subfile (cu, fe->name, fe->include_dir (lh));
21053 /* Decode the table. */
21054 while (line_ptr < line_end && !end_sequence)
21056 op_code = read_1_byte (abfd, line_ptr);
21059 if (op_code >= lh->opcode_base)
21061 /* Special opcode. */
21062 state_machine.handle_special_opcode (op_code);
21064 else switch (op_code)
21066 case DW_LNS_extended_op:
21067 extended_len = read_unsigned_leb128 (abfd, line_ptr,
21069 line_ptr += bytes_read;
21070 extended_end = line_ptr + extended_len;
21071 extended_op = read_1_byte (abfd, line_ptr);
21073 switch (extended_op)
21075 case DW_LNE_end_sequence:
21076 state_machine.handle_end_sequence ();
21077 end_sequence = true;
21079 case DW_LNE_set_address:
21082 = read_address (abfd, line_ptr, cu, &bytes_read);
21083 line_ptr += bytes_read;
21085 state_machine.check_line_address (cu, line_ptr,
21086 lowpc - baseaddr, address);
21087 state_machine.handle_set_address (baseaddr, address);
21090 case DW_LNE_define_file:
21092 const char *cur_file;
21093 unsigned int mod_time, length;
21096 cur_file = read_direct_string (abfd, line_ptr,
21098 line_ptr += bytes_read;
21099 dindex = (dir_index)
21100 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21101 line_ptr += bytes_read;
21103 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21104 line_ptr += bytes_read;
21106 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21107 line_ptr += bytes_read;
21108 lh->add_file_name (cur_file, dindex, mod_time, length);
21111 case DW_LNE_set_discriminator:
21113 /* The discriminator is not interesting to the
21114 debugger; just ignore it. We still need to
21115 check its value though:
21116 if there are consecutive entries for the same
21117 (non-prologue) line we want to coalesce them.
21120 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21121 line_ptr += bytes_read;
21123 state_machine.handle_set_discriminator (discr);
21127 complaint (_("mangled .debug_line section"));
21130 /* Make sure that we parsed the extended op correctly. If e.g.
21131 we expected a different address size than the producer used,
21132 we may have read the wrong number of bytes. */
21133 if (line_ptr != extended_end)
21135 complaint (_("mangled .debug_line section"));
21140 state_machine.handle_copy ();
21142 case DW_LNS_advance_pc:
21145 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21146 line_ptr += bytes_read;
21148 state_machine.handle_advance_pc (adjust);
21151 case DW_LNS_advance_line:
21154 = read_signed_leb128 (abfd, line_ptr, &bytes_read);
21155 line_ptr += bytes_read;
21157 state_machine.handle_advance_line (line_delta);
21160 case DW_LNS_set_file:
21162 file_name_index file
21163 = (file_name_index) read_unsigned_leb128 (abfd, line_ptr,
21165 line_ptr += bytes_read;
21167 state_machine.handle_set_file (file);
21170 case DW_LNS_set_column:
21171 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21172 line_ptr += bytes_read;
21174 case DW_LNS_negate_stmt:
21175 state_machine.handle_negate_stmt ();
21177 case DW_LNS_set_basic_block:
21179 /* Add to the address register of the state machine the
21180 address increment value corresponding to special opcode
21181 255. I.e., this value is scaled by the minimum
21182 instruction length since special opcode 255 would have
21183 scaled the increment. */
21184 case DW_LNS_const_add_pc:
21185 state_machine.handle_const_add_pc ();
21187 case DW_LNS_fixed_advance_pc:
21189 CORE_ADDR addr_adj = read_2_bytes (abfd, line_ptr);
21192 state_machine.handle_fixed_advance_pc (addr_adj);
21197 /* Unknown standard opcode, ignore it. */
21200 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
21202 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21203 line_ptr += bytes_read;
21210 dwarf2_debug_line_missing_end_sequence_complaint ();
21212 /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21213 in which case we still finish recording the last line). */
21214 state_machine.record_line (true);
21218 /* Decode the Line Number Program (LNP) for the given line_header
21219 structure and CU. The actual information extracted and the type
21220 of structures created from the LNP depends on the value of PST.
21222 1. If PST is NULL, then this procedure uses the data from the program
21223 to create all necessary symbol tables, and their linetables.
21225 2. If PST is not NULL, this procedure reads the program to determine
21226 the list of files included by the unit represented by PST, and
21227 builds all the associated partial symbol tables.
21229 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21230 It is used for relative paths in the line table.
21231 NOTE: When processing partial symtabs (pst != NULL),
21232 comp_dir == pst->dirname.
21234 NOTE: It is important that psymtabs have the same file name (via strcmp)
21235 as the corresponding symtab. Since COMP_DIR is not used in the name of the
21236 symtab we don't use it in the name of the psymtabs we create.
21237 E.g. expand_line_sal requires this when finding psymtabs to expand.
21238 A good testcase for this is mb-inline.exp.
21240 LOWPC is the lowest address in CU (or 0 if not known).
21242 Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21243 for its PC<->lines mapping information. Otherwise only the filename
21244 table is read in. */
21247 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
21248 struct dwarf2_cu *cu, struct partial_symtab *pst,
21249 CORE_ADDR lowpc, int decode_mapping)
21251 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21252 const int decode_for_pst_p = (pst != NULL);
21254 if (decode_mapping)
21255 dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
21257 if (decode_for_pst_p)
21261 /* Now that we're done scanning the Line Header Program, we can
21262 create the psymtab of each included file. */
21263 for (file_index = 0; file_index < lh->file_names.size (); file_index++)
21264 if (lh->file_names[file_index].included_p == 1)
21266 gdb::unique_xmalloc_ptr<char> name_holder;
21267 const char *include_name =
21268 psymtab_include_file_name (lh, file_index, pst, comp_dir,
21270 if (include_name != NULL)
21271 dwarf2_create_include_psymtab (include_name, pst, objfile);
21276 /* Make sure a symtab is created for every file, even files
21277 which contain only variables (i.e. no code with associated
21279 buildsym_compunit *builder = cu->get_builder ();
21280 struct compunit_symtab *cust = builder->get_compunit_symtab ();
21283 for (i = 0; i < lh->file_names.size (); i++)
21285 file_entry &fe = lh->file_names[i];
21287 dwarf2_start_subfile (cu, fe.name, fe.include_dir (lh));
21289 if (builder->get_current_subfile ()->symtab == NULL)
21291 builder->get_current_subfile ()->symtab
21292 = allocate_symtab (cust,
21293 builder->get_current_subfile ()->name);
21295 fe.symtab = builder->get_current_subfile ()->symtab;
21300 /* Start a subfile for DWARF. FILENAME is the name of the file and
21301 DIRNAME the name of the source directory which contains FILENAME
21302 or NULL if not known.
21303 This routine tries to keep line numbers from identical absolute and
21304 relative file names in a common subfile.
21306 Using the `list' example from the GDB testsuite, which resides in
21307 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21308 of /srcdir/list0.c yields the following debugging information for list0.c:
21310 DW_AT_name: /srcdir/list0.c
21311 DW_AT_comp_dir: /compdir
21312 files.files[0].name: list0.h
21313 files.files[0].dir: /srcdir
21314 files.files[1].name: list0.c
21315 files.files[1].dir: /srcdir
21317 The line number information for list0.c has to end up in a single
21318 subfile, so that `break /srcdir/list0.c:1' works as expected.
21319 start_subfile will ensure that this happens provided that we pass the
21320 concatenation of files.files[1].dir and files.files[1].name as the
21324 dwarf2_start_subfile (struct dwarf2_cu *cu, const char *filename,
21325 const char *dirname)
21329 /* In order not to lose the line information directory,
21330 we concatenate it to the filename when it makes sense.
21331 Note that the Dwarf3 standard says (speaking of filenames in line
21332 information): ``The directory index is ignored for file names
21333 that represent full path names''. Thus ignoring dirname in the
21334 `else' branch below isn't an issue. */
21336 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
21338 copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
21342 cu->get_builder ()->start_subfile (filename);
21348 /* Start a symtab for DWARF. NAME, COMP_DIR, LOW_PC are passed to the
21349 buildsym_compunit constructor. */
21351 struct compunit_symtab *
21352 dwarf2_cu::start_symtab (const char *name, const char *comp_dir,
21355 gdb_assert (m_builder == nullptr);
21357 m_builder.reset (new struct buildsym_compunit
21358 (per_cu->dwarf2_per_objfile->objfile,
21359 name, comp_dir, language, low_pc));
21361 list_in_scope = get_builder ()->get_file_symbols ();
21363 get_builder ()->record_debugformat ("DWARF 2");
21364 get_builder ()->record_producer (producer);
21366 processing_has_namespace_info = false;
21368 return get_builder ()->get_compunit_symtab ();
21372 var_decode_location (struct attribute *attr, struct symbol *sym,
21373 struct dwarf2_cu *cu)
21375 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21376 struct comp_unit_head *cu_header = &cu->header;
21378 /* NOTE drow/2003-01-30: There used to be a comment and some special
21379 code here to turn a symbol with DW_AT_external and a
21380 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
21381 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21382 with some versions of binutils) where shared libraries could have
21383 relocations against symbols in their debug information - the
21384 minimal symbol would have the right address, but the debug info
21385 would not. It's no longer necessary, because we will explicitly
21386 apply relocations when we read in the debug information now. */
21388 /* A DW_AT_location attribute with no contents indicates that a
21389 variable has been optimized away. */
21390 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
21392 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21396 /* Handle one degenerate form of location expression specially, to
21397 preserve GDB's previous behavior when section offsets are
21398 specified. If this is just a DW_OP_addr, DW_OP_addrx, or
21399 DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC. */
21401 if (attr_form_is_block (attr)
21402 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
21403 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
21404 || ((DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
21405 || DW_BLOCK (attr)->data[0] == DW_OP_addrx)
21406 && (DW_BLOCK (attr)->size
21407 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
21409 unsigned int dummy;
21411 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
21412 SYMBOL_VALUE_ADDRESS (sym) =
21413 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
21415 SYMBOL_VALUE_ADDRESS (sym) =
21416 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
21417 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
21418 fixup_symbol_section (sym, objfile);
21419 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
21420 SYMBOL_SECTION (sym));
21424 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21425 expression evaluator, and use LOC_COMPUTED only when necessary
21426 (i.e. when the value of a register or memory location is
21427 referenced, or a thread-local block, etc.). Then again, it might
21428 not be worthwhile. I'm assuming that it isn't unless performance
21429 or memory numbers show me otherwise. */
21431 dwarf2_symbol_mark_computed (attr, sym, cu, 0);
21433 if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
21434 cu->has_loclist = true;
21437 /* Given a pointer to a DWARF information entry, figure out if we need
21438 to make a symbol table entry for it, and if so, create a new entry
21439 and return a pointer to it.
21440 If TYPE is NULL, determine symbol type from the die, otherwise
21441 used the passed type.
21442 If SPACE is not NULL, use it to hold the new symbol. If it is
21443 NULL, allocate a new symbol on the objfile's obstack. */
21445 static struct symbol *
21446 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
21447 struct symbol *space)
21449 struct dwarf2_per_objfile *dwarf2_per_objfile
21450 = cu->per_cu->dwarf2_per_objfile;
21451 struct objfile *objfile = dwarf2_per_objfile->objfile;
21452 struct gdbarch *gdbarch = get_objfile_arch (objfile);
21453 struct symbol *sym = NULL;
21455 struct attribute *attr = NULL;
21456 struct attribute *attr2 = NULL;
21457 CORE_ADDR baseaddr;
21458 struct pending **list_to_add = NULL;
21460 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
21462 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21464 name = dwarf2_name (die, cu);
21467 const char *linkagename;
21468 int suppress_add = 0;
21473 sym = allocate_symbol (objfile);
21474 OBJSTAT (objfile, n_syms++);
21476 /* Cache this symbol's name and the name's demangled form (if any). */
21477 SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
21478 linkagename = dwarf2_physname (name, die, cu);
21479 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
21481 /* Fortran does not have mangling standard and the mangling does differ
21482 between gfortran, iFort etc. */
21483 if (cu->language == language_fortran
21484 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
21485 symbol_set_demangled_name (&(sym->ginfo),
21486 dwarf2_full_name (name, die, cu),
21489 /* Default assumptions.
21490 Use the passed type or decode it from the die. */
21491 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21492 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21494 SYMBOL_TYPE (sym) = type;
21496 SYMBOL_TYPE (sym) = die_type (die, cu);
21497 attr = dwarf2_attr (die,
21498 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
21502 SYMBOL_LINE (sym) = DW_UNSND (attr);
21505 attr = dwarf2_attr (die,
21506 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
21510 file_name_index file_index = (file_name_index) DW_UNSND (attr);
21511 struct file_entry *fe;
21513 if (cu->line_header != NULL)
21514 fe = cu->line_header->file_name_at (file_index);
21519 complaint (_("file index out of range"));
21521 symbol_set_symtab (sym, fe->symtab);
21527 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
21532 addr = attr_value_as_address (attr);
21533 addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
21534 SYMBOL_VALUE_ADDRESS (sym) = addr;
21536 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
21537 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
21538 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
21539 add_symbol_to_list (sym, cu->list_in_scope);
21541 case DW_TAG_subprogram:
21542 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21544 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21545 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21546 if ((attr2 && (DW_UNSND (attr2) != 0))
21547 || cu->language == language_ada)
21549 /* Subprograms marked external are stored as a global symbol.
21550 Ada subprograms, whether marked external or not, are always
21551 stored as a global symbol, because we want to be able to
21552 access them globally. For instance, we want to be able
21553 to break on a nested subprogram without having to
21554 specify the context. */
21555 list_to_add = cu->get_builder ()->get_global_symbols ();
21559 list_to_add = cu->list_in_scope;
21562 case DW_TAG_inlined_subroutine:
21563 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21565 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21566 SYMBOL_INLINED (sym) = 1;
21567 list_to_add = cu->list_in_scope;
21569 case DW_TAG_template_value_param:
21571 /* Fall through. */
21572 case DW_TAG_constant:
21573 case DW_TAG_variable:
21574 case DW_TAG_member:
21575 /* Compilation with minimal debug info may result in
21576 variables with missing type entries. Change the
21577 misleading `void' type to something sensible. */
21578 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
21579 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
21581 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21582 /* In the case of DW_TAG_member, we should only be called for
21583 static const members. */
21584 if (die->tag == DW_TAG_member)
21586 /* dwarf2_add_field uses die_is_declaration,
21587 so we do the same. */
21588 gdb_assert (die_is_declaration (die, cu));
21593 dwarf2_const_value (attr, sym, cu);
21594 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21597 if (attr2 && (DW_UNSND (attr2) != 0))
21598 list_to_add = cu->get_builder ()->get_global_symbols ();
21600 list_to_add = cu->list_in_scope;
21604 attr = dwarf2_attr (die, DW_AT_location, cu);
21607 var_decode_location (attr, sym, cu);
21608 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21610 /* Fortran explicitly imports any global symbols to the local
21611 scope by DW_TAG_common_block. */
21612 if (cu->language == language_fortran && die->parent
21613 && die->parent->tag == DW_TAG_common_block)
21616 if (SYMBOL_CLASS (sym) == LOC_STATIC
21617 && SYMBOL_VALUE_ADDRESS (sym) == 0
21618 && !dwarf2_per_objfile->has_section_at_zero)
21620 /* When a static variable is eliminated by the linker,
21621 the corresponding debug information is not stripped
21622 out, but the variable address is set to null;
21623 do not add such variables into symbol table. */
21625 else if (attr2 && (DW_UNSND (attr2) != 0))
21627 /* Workaround gfortran PR debug/40040 - it uses
21628 DW_AT_location for variables in -fPIC libraries which may
21629 get overriden by other libraries/executable and get
21630 a different address. Resolve it by the minimal symbol
21631 which may come from inferior's executable using copy
21632 relocation. Make this workaround only for gfortran as for
21633 other compilers GDB cannot guess the minimal symbol
21634 Fortran mangling kind. */
21635 if (cu->language == language_fortran && die->parent
21636 && die->parent->tag == DW_TAG_module
21638 && startswith (cu->producer, "GNU Fortran"))
21639 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21641 /* A variable with DW_AT_external is never static,
21642 but it may be block-scoped. */
21644 = ((cu->list_in_scope
21645 == cu->get_builder ()->get_file_symbols ())
21646 ? cu->get_builder ()->get_global_symbols ()
21647 : cu->list_in_scope);
21650 list_to_add = cu->list_in_scope;
21654 /* We do not know the address of this symbol.
21655 If it is an external symbol and we have type information
21656 for it, enter the symbol as a LOC_UNRESOLVED symbol.
21657 The address of the variable will then be determined from
21658 the minimal symbol table whenever the variable is
21660 attr2 = dwarf2_attr (die, DW_AT_external, cu);
21662 /* Fortran explicitly imports any global symbols to the local
21663 scope by DW_TAG_common_block. */
21664 if (cu->language == language_fortran && die->parent
21665 && die->parent->tag == DW_TAG_common_block)
21667 /* SYMBOL_CLASS doesn't matter here because
21668 read_common_block is going to reset it. */
21670 list_to_add = cu->list_in_scope;
21672 else if (attr2 && (DW_UNSND (attr2) != 0)
21673 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
21675 /* A variable with DW_AT_external is never static, but it
21676 may be block-scoped. */
21678 = ((cu->list_in_scope
21679 == cu->get_builder ()->get_file_symbols ())
21680 ? cu->get_builder ()->get_global_symbols ()
21681 : cu->list_in_scope);
21683 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21685 else if (!die_is_declaration (die, cu))
21687 /* Use the default LOC_OPTIMIZED_OUT class. */
21688 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
21690 list_to_add = cu->list_in_scope;
21694 case DW_TAG_formal_parameter:
21696 /* If we are inside a function, mark this as an argument. If
21697 not, we might be looking at an argument to an inlined function
21698 when we do not have enough information to show inlined frames;
21699 pretend it's a local variable in that case so that the user can
21701 struct context_stack *curr
21702 = cu->get_builder ()->get_current_context_stack ();
21703 if (curr != nullptr && curr->name != nullptr)
21704 SYMBOL_IS_ARGUMENT (sym) = 1;
21705 attr = dwarf2_attr (die, DW_AT_location, cu);
21708 var_decode_location (attr, sym, cu);
21710 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21713 dwarf2_const_value (attr, sym, cu);
21716 list_to_add = cu->list_in_scope;
21719 case DW_TAG_unspecified_parameters:
21720 /* From varargs functions; gdb doesn't seem to have any
21721 interest in this information, so just ignore it for now.
21724 case DW_TAG_template_type_param:
21726 /* Fall through. */
21727 case DW_TAG_class_type:
21728 case DW_TAG_interface_type:
21729 case DW_TAG_structure_type:
21730 case DW_TAG_union_type:
21731 case DW_TAG_set_type:
21732 case DW_TAG_enumeration_type:
21733 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21734 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
21737 /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21738 really ever be static objects: otherwise, if you try
21739 to, say, break of a class's method and you're in a file
21740 which doesn't mention that class, it won't work unless
21741 the check for all static symbols in lookup_symbol_aux
21742 saves you. See the OtherFileClass tests in
21743 gdb.c++/namespace.exp. */
21747 buildsym_compunit *builder = cu->get_builder ();
21749 = (cu->list_in_scope == builder->get_file_symbols ()
21750 && cu->language == language_cplus
21751 ? builder->get_global_symbols ()
21752 : cu->list_in_scope);
21754 /* The semantics of C++ state that "struct foo {
21755 ... }" also defines a typedef for "foo". */
21756 if (cu->language == language_cplus
21757 || cu->language == language_ada
21758 || cu->language == language_d
21759 || cu->language == language_rust)
21761 /* The symbol's name is already allocated along
21762 with this objfile, so we don't need to
21763 duplicate it for the type. */
21764 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
21765 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
21770 case DW_TAG_typedef:
21771 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21772 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21773 list_to_add = cu->list_in_scope;
21775 case DW_TAG_base_type:
21776 case DW_TAG_subrange_type:
21777 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21778 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21779 list_to_add = cu->list_in_scope;
21781 case DW_TAG_enumerator:
21782 attr = dwarf2_attr (die, DW_AT_const_value, cu);
21785 dwarf2_const_value (attr, sym, cu);
21788 /* NOTE: carlton/2003-11-10: See comment above in the
21789 DW_TAG_class_type, etc. block. */
21792 = (cu->list_in_scope == cu->get_builder ()->get_file_symbols ()
21793 && cu->language == language_cplus
21794 ? cu->get_builder ()->get_global_symbols ()
21795 : cu->list_in_scope);
21798 case DW_TAG_imported_declaration:
21799 case DW_TAG_namespace:
21800 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21801 list_to_add = cu->get_builder ()->get_global_symbols ();
21803 case DW_TAG_module:
21804 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21805 SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
21806 list_to_add = cu->get_builder ()->get_global_symbols ();
21808 case DW_TAG_common_block:
21809 SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
21810 SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
21811 add_symbol_to_list (sym, cu->list_in_scope);
21814 /* Not a tag we recognize. Hopefully we aren't processing
21815 trash data, but since we must specifically ignore things
21816 we don't recognize, there is nothing else we should do at
21818 complaint (_("unsupported tag: '%s'"),
21819 dwarf_tag_name (die->tag));
21825 sym->hash_next = objfile->template_symbols;
21826 objfile->template_symbols = sym;
21827 list_to_add = NULL;
21830 if (list_to_add != NULL)
21831 add_symbol_to_list (sym, list_to_add);
21833 /* For the benefit of old versions of GCC, check for anonymous
21834 namespaces based on the demangled name. */
21835 if (!cu->processing_has_namespace_info
21836 && cu->language == language_cplus)
21837 cp_scan_for_anonymous_namespaces (cu->get_builder (), sym, objfile);
21842 /* Given an attr with a DW_FORM_dataN value in host byte order,
21843 zero-extend it as appropriate for the symbol's type. The DWARF
21844 standard (v4) is not entirely clear about the meaning of using
21845 DW_FORM_dataN for a constant with a signed type, where the type is
21846 wider than the data. The conclusion of a discussion on the DWARF
21847 list was that this is unspecified. We choose to always zero-extend
21848 because that is the interpretation long in use by GCC. */
21851 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
21852 struct dwarf2_cu *cu, LONGEST *value, int bits)
21854 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21855 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
21856 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
21857 LONGEST l = DW_UNSND (attr);
21859 if (bits < sizeof (*value) * 8)
21861 l &= ((LONGEST) 1 << bits) - 1;
21864 else if (bits == sizeof (*value) * 8)
21868 gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
21869 store_unsigned_integer (bytes, bits / 8, byte_order, l);
21876 /* Read a constant value from an attribute. Either set *VALUE, or if
21877 the value does not fit in *VALUE, set *BYTES - either already
21878 allocated on the objfile obstack, or newly allocated on OBSTACK,
21879 or, set *BATON, if we translated the constant to a location
21883 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
21884 const char *name, struct obstack *obstack,
21885 struct dwarf2_cu *cu,
21886 LONGEST *value, const gdb_byte **bytes,
21887 struct dwarf2_locexpr_baton **baton)
21889 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21890 struct comp_unit_head *cu_header = &cu->header;
21891 struct dwarf_block *blk;
21892 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
21893 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
21899 switch (attr->form)
21902 case DW_FORM_addrx:
21903 case DW_FORM_GNU_addr_index:
21907 if (TYPE_LENGTH (type) != cu_header->addr_size)
21908 dwarf2_const_value_length_mismatch_complaint (name,
21909 cu_header->addr_size,
21910 TYPE_LENGTH (type));
21911 /* Symbols of this form are reasonably rare, so we just
21912 piggyback on the existing location code rather than writing
21913 a new implementation of symbol_computed_ops. */
21914 *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
21915 (*baton)->per_cu = cu->per_cu;
21916 gdb_assert ((*baton)->per_cu);
21918 (*baton)->size = 2 + cu_header->addr_size;
21919 data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
21920 (*baton)->data = data;
21922 data[0] = DW_OP_addr;
21923 store_unsigned_integer (&data[1], cu_header->addr_size,
21924 byte_order, DW_ADDR (attr));
21925 data[cu_header->addr_size + 1] = DW_OP_stack_value;
21928 case DW_FORM_string:
21931 case DW_FORM_GNU_str_index:
21932 case DW_FORM_GNU_strp_alt:
21933 /* DW_STRING is already allocated on the objfile obstack, point
21935 *bytes = (const gdb_byte *) DW_STRING (attr);
21937 case DW_FORM_block1:
21938 case DW_FORM_block2:
21939 case DW_FORM_block4:
21940 case DW_FORM_block:
21941 case DW_FORM_exprloc:
21942 case DW_FORM_data16:
21943 blk = DW_BLOCK (attr);
21944 if (TYPE_LENGTH (type) != blk->size)
21945 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
21946 TYPE_LENGTH (type));
21947 *bytes = blk->data;
21950 /* The DW_AT_const_value attributes are supposed to carry the
21951 symbol's value "represented as it would be on the target
21952 architecture." By the time we get here, it's already been
21953 converted to host endianness, so we just need to sign- or
21954 zero-extend it as appropriate. */
21955 case DW_FORM_data1:
21956 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
21958 case DW_FORM_data2:
21959 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
21961 case DW_FORM_data4:
21962 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
21964 case DW_FORM_data8:
21965 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
21968 case DW_FORM_sdata:
21969 case DW_FORM_implicit_const:
21970 *value = DW_SND (attr);
21973 case DW_FORM_udata:
21974 *value = DW_UNSND (attr);
21978 complaint (_("unsupported const value attribute form: '%s'"),
21979 dwarf_form_name (attr->form));
21986 /* Copy constant value from an attribute to a symbol. */
21989 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
21990 struct dwarf2_cu *cu)
21992 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21994 const gdb_byte *bytes;
21995 struct dwarf2_locexpr_baton *baton;
21997 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
21998 SYMBOL_PRINT_NAME (sym),
21999 &objfile->objfile_obstack, cu,
22000 &value, &bytes, &baton);
22004 SYMBOL_LOCATION_BATON (sym) = baton;
22005 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
22007 else if (bytes != NULL)
22009 SYMBOL_VALUE_BYTES (sym) = bytes;
22010 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
22014 SYMBOL_VALUE (sym) = value;
22015 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
22019 /* Return the type of the die in question using its DW_AT_type attribute. */
22021 static struct type *
22022 die_type (struct die_info *die, struct dwarf2_cu *cu)
22024 struct attribute *type_attr;
22026 type_attr = dwarf2_attr (die, DW_AT_type, cu);
22029 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22030 /* A missing DW_AT_type represents a void type. */
22031 return objfile_type (objfile)->builtin_void;
22034 return lookup_die_type (die, type_attr, cu);
22037 /* True iff CU's producer generates GNAT Ada auxiliary information
22038 that allows to find parallel types through that information instead
22039 of having to do expensive parallel lookups by type name. */
22042 need_gnat_info (struct dwarf2_cu *cu)
22044 /* Assume that the Ada compiler was GNAT, which always produces
22045 the auxiliary information. */
22046 return (cu->language == language_ada);
22049 /* Return the auxiliary type of the die in question using its
22050 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
22051 attribute is not present. */
22053 static struct type *
22054 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
22056 struct attribute *type_attr;
22058 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
22062 return lookup_die_type (die, type_attr, cu);
22065 /* If DIE has a descriptive_type attribute, then set the TYPE's
22066 descriptive type accordingly. */
22069 set_descriptive_type (struct type *type, struct die_info *die,
22070 struct dwarf2_cu *cu)
22072 struct type *descriptive_type = die_descriptive_type (die, cu);
22074 if (descriptive_type)
22076 ALLOCATE_GNAT_AUX_TYPE (type);
22077 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
22081 /* Return the containing type of the die in question using its
22082 DW_AT_containing_type attribute. */
22084 static struct type *
22085 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
22087 struct attribute *type_attr;
22088 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22090 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
22092 error (_("Dwarf Error: Problem turning containing type into gdb type "
22093 "[in module %s]"), objfile_name (objfile));
22095 return lookup_die_type (die, type_attr, cu);
22098 /* Return an error marker type to use for the ill formed type in DIE/CU. */
22100 static struct type *
22101 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
22103 struct dwarf2_per_objfile *dwarf2_per_objfile
22104 = cu->per_cu->dwarf2_per_objfile;
22105 struct objfile *objfile = dwarf2_per_objfile->objfile;
22108 std::string message
22109 = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22110 objfile_name (objfile),
22111 sect_offset_str (cu->header.sect_off),
22112 sect_offset_str (die->sect_off));
22113 saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
22114 message.c_str (), message.length ());
22116 return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
22119 /* Look up the type of DIE in CU using its type attribute ATTR.
22120 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22121 DW_AT_containing_type.
22122 If there is no type substitute an error marker. */
22124 static struct type *
22125 lookup_die_type (struct die_info *die, const struct attribute *attr,
22126 struct dwarf2_cu *cu)
22128 struct dwarf2_per_objfile *dwarf2_per_objfile
22129 = cu->per_cu->dwarf2_per_objfile;
22130 struct objfile *objfile = dwarf2_per_objfile->objfile;
22131 struct type *this_type;
22133 gdb_assert (attr->name == DW_AT_type
22134 || attr->name == DW_AT_GNAT_descriptive_type
22135 || attr->name == DW_AT_containing_type);
22137 /* First see if we have it cached. */
22139 if (attr->form == DW_FORM_GNU_ref_alt)
22141 struct dwarf2_per_cu_data *per_cu;
22142 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22144 per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
22145 dwarf2_per_objfile);
22146 this_type = get_die_type_at_offset (sect_off, per_cu);
22148 else if (attr_form_is_ref (attr))
22150 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22152 this_type = get_die_type_at_offset (sect_off, cu->per_cu);
22154 else if (attr->form == DW_FORM_ref_sig8)
22156 ULONGEST signature = DW_SIGNATURE (attr);
22158 return get_signatured_type (die, signature, cu);
22162 complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22163 " at %s [in module %s]"),
22164 dwarf_attr_name (attr->name), sect_offset_str (die->sect_off),
22165 objfile_name (objfile));
22166 return build_error_marker_type (cu, die);
22169 /* If not cached we need to read it in. */
22171 if (this_type == NULL)
22173 struct die_info *type_die = NULL;
22174 struct dwarf2_cu *type_cu = cu;
22176 if (attr_form_is_ref (attr))
22177 type_die = follow_die_ref (die, attr, &type_cu);
22178 if (type_die == NULL)
22179 return build_error_marker_type (cu, die);
22180 /* If we find the type now, it's probably because the type came
22181 from an inter-CU reference and the type's CU got expanded before
22183 this_type = read_type_die (type_die, type_cu);
22186 /* If we still don't have a type use an error marker. */
22188 if (this_type == NULL)
22189 return build_error_marker_type (cu, die);
22194 /* Return the type in DIE, CU.
22195 Returns NULL for invalid types.
22197 This first does a lookup in die_type_hash,
22198 and only reads the die in if necessary.
22200 NOTE: This can be called when reading in partial or full symbols. */
22202 static struct type *
22203 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
22205 struct type *this_type;
22207 this_type = get_die_type (die, cu);
22211 return read_type_die_1 (die, cu);
22214 /* Read the type in DIE, CU.
22215 Returns NULL for invalid types. */
22217 static struct type *
22218 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
22220 struct type *this_type = NULL;
22224 case DW_TAG_class_type:
22225 case DW_TAG_interface_type:
22226 case DW_TAG_structure_type:
22227 case DW_TAG_union_type:
22228 this_type = read_structure_type (die, cu);
22230 case DW_TAG_enumeration_type:
22231 this_type = read_enumeration_type (die, cu);
22233 case DW_TAG_subprogram:
22234 case DW_TAG_subroutine_type:
22235 case DW_TAG_inlined_subroutine:
22236 this_type = read_subroutine_type (die, cu);
22238 case DW_TAG_array_type:
22239 this_type = read_array_type (die, cu);
22241 case DW_TAG_set_type:
22242 this_type = read_set_type (die, cu);
22244 case DW_TAG_pointer_type:
22245 this_type = read_tag_pointer_type (die, cu);
22247 case DW_TAG_ptr_to_member_type:
22248 this_type = read_tag_ptr_to_member_type (die, cu);
22250 case DW_TAG_reference_type:
22251 this_type = read_tag_reference_type (die, cu, TYPE_CODE_REF);
22253 case DW_TAG_rvalue_reference_type:
22254 this_type = read_tag_reference_type (die, cu, TYPE_CODE_RVALUE_REF);
22256 case DW_TAG_const_type:
22257 this_type = read_tag_const_type (die, cu);
22259 case DW_TAG_volatile_type:
22260 this_type = read_tag_volatile_type (die, cu);
22262 case DW_TAG_restrict_type:
22263 this_type = read_tag_restrict_type (die, cu);
22265 case DW_TAG_string_type:
22266 this_type = read_tag_string_type (die, cu);
22268 case DW_TAG_typedef:
22269 this_type = read_typedef (die, cu);
22271 case DW_TAG_subrange_type:
22272 this_type = read_subrange_type (die, cu);
22274 case DW_TAG_base_type:
22275 this_type = read_base_type (die, cu);
22277 case DW_TAG_unspecified_type:
22278 this_type = read_unspecified_type (die, cu);
22280 case DW_TAG_namespace:
22281 this_type = read_namespace_type (die, cu);
22283 case DW_TAG_module:
22284 this_type = read_module_type (die, cu);
22286 case DW_TAG_atomic_type:
22287 this_type = read_tag_atomic_type (die, cu);
22290 complaint (_("unexpected tag in read_type_die: '%s'"),
22291 dwarf_tag_name (die->tag));
22298 /* See if we can figure out if the class lives in a namespace. We do
22299 this by looking for a member function; its demangled name will
22300 contain namespace info, if there is any.
22301 Return the computed name or NULL.
22302 Space for the result is allocated on the objfile's obstack.
22303 This is the full-die version of guess_partial_die_structure_name.
22304 In this case we know DIE has no useful parent. */
22307 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
22309 struct die_info *spec_die;
22310 struct dwarf2_cu *spec_cu;
22311 struct die_info *child;
22312 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22315 spec_die = die_specification (die, &spec_cu);
22316 if (spec_die != NULL)
22322 for (child = die->child;
22324 child = child->sibling)
22326 if (child->tag == DW_TAG_subprogram)
22328 const char *linkage_name = dw2_linkage_name (child, cu);
22330 if (linkage_name != NULL)
22333 = language_class_name_from_physname (cu->language_defn,
22337 if (actual_name != NULL)
22339 const char *die_name = dwarf2_name (die, cu);
22341 if (die_name != NULL
22342 && strcmp (die_name, actual_name) != 0)
22344 /* Strip off the class name from the full name.
22345 We want the prefix. */
22346 int die_name_len = strlen (die_name);
22347 int actual_name_len = strlen (actual_name);
22349 /* Test for '::' as a sanity check. */
22350 if (actual_name_len > die_name_len + 2
22351 && actual_name[actual_name_len
22352 - die_name_len - 1] == ':')
22353 name = (char *) obstack_copy0 (
22354 &objfile->per_bfd->storage_obstack,
22355 actual_name, actual_name_len - die_name_len - 2);
22358 xfree (actual_name);
22367 /* GCC might emit a nameless typedef that has a linkage name. Determine the
22368 prefix part in such case. See
22369 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22371 static const char *
22372 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
22374 struct attribute *attr;
22377 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
22378 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
22381 if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
22384 attr = dw2_linkage_name_attr (die, cu);
22385 if (attr == NULL || DW_STRING (attr) == NULL)
22388 /* dwarf2_name had to be already called. */
22389 gdb_assert (DW_STRING_IS_CANONICAL (attr));
22391 /* Strip the base name, keep any leading namespaces/classes. */
22392 base = strrchr (DW_STRING (attr), ':');
22393 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
22396 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22397 return (char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
22399 &base[-1] - DW_STRING (attr));
22402 /* Return the name of the namespace/class that DIE is defined within,
22403 or "" if we can't tell. The caller should not xfree the result.
22405 For example, if we're within the method foo() in the following
22415 then determine_prefix on foo's die will return "N::C". */
22417 static const char *
22418 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
22420 struct dwarf2_per_objfile *dwarf2_per_objfile
22421 = cu->per_cu->dwarf2_per_objfile;
22422 struct die_info *parent, *spec_die;
22423 struct dwarf2_cu *spec_cu;
22424 struct type *parent_type;
22425 const char *retval;
22427 if (cu->language != language_cplus
22428 && cu->language != language_fortran && cu->language != language_d
22429 && cu->language != language_rust)
22432 retval = anonymous_struct_prefix (die, cu);
22436 /* We have to be careful in the presence of DW_AT_specification.
22437 For example, with GCC 3.4, given the code
22441 // Definition of N::foo.
22445 then we'll have a tree of DIEs like this:
22447 1: DW_TAG_compile_unit
22448 2: DW_TAG_namespace // N
22449 3: DW_TAG_subprogram // declaration of N::foo
22450 4: DW_TAG_subprogram // definition of N::foo
22451 DW_AT_specification // refers to die #3
22453 Thus, when processing die #4, we have to pretend that we're in
22454 the context of its DW_AT_specification, namely the contex of die
22457 spec_die = die_specification (die, &spec_cu);
22458 if (spec_die == NULL)
22459 parent = die->parent;
22462 parent = spec_die->parent;
22466 if (parent == NULL)
22468 else if (parent->building_fullname)
22471 const char *parent_name;
22473 /* It has been seen on RealView 2.2 built binaries,
22474 DW_TAG_template_type_param types actually _defined_ as
22475 children of the parent class:
22478 template class <class Enum> Class{};
22479 Class<enum E> class_e;
22481 1: DW_TAG_class_type (Class)
22482 2: DW_TAG_enumeration_type (E)
22483 3: DW_TAG_enumerator (enum1:0)
22484 3: DW_TAG_enumerator (enum2:1)
22486 2: DW_TAG_template_type_param
22487 DW_AT_type DW_FORM_ref_udata (E)
22489 Besides being broken debug info, it can put GDB into an
22490 infinite loop. Consider:
22492 When we're building the full name for Class<E>, we'll start
22493 at Class, and go look over its template type parameters,
22494 finding E. We'll then try to build the full name of E, and
22495 reach here. We're now trying to build the full name of E,
22496 and look over the parent DIE for containing scope. In the
22497 broken case, if we followed the parent DIE of E, we'd again
22498 find Class, and once again go look at its template type
22499 arguments, etc., etc. Simply don't consider such parent die
22500 as source-level parent of this die (it can't be, the language
22501 doesn't allow it), and break the loop here. */
22502 name = dwarf2_name (die, cu);
22503 parent_name = dwarf2_name (parent, cu);
22504 complaint (_("template param type '%s' defined within parent '%s'"),
22505 name ? name : "<unknown>",
22506 parent_name ? parent_name : "<unknown>");
22510 switch (parent->tag)
22512 case DW_TAG_namespace:
22513 parent_type = read_type_die (parent, cu);
22514 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22515 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22516 Work around this problem here. */
22517 if (cu->language == language_cplus
22518 && strcmp (TYPE_NAME (parent_type), "::") == 0)
22520 /* We give a name to even anonymous namespaces. */
22521 return TYPE_NAME (parent_type);
22522 case DW_TAG_class_type:
22523 case DW_TAG_interface_type:
22524 case DW_TAG_structure_type:
22525 case DW_TAG_union_type:
22526 case DW_TAG_module:
22527 parent_type = read_type_die (parent, cu);
22528 if (TYPE_NAME (parent_type) != NULL)
22529 return TYPE_NAME (parent_type);
22531 /* An anonymous structure is only allowed non-static data
22532 members; no typedefs, no member functions, et cetera.
22533 So it does not need a prefix. */
22535 case DW_TAG_compile_unit:
22536 case DW_TAG_partial_unit:
22537 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
22538 if (cu->language == language_cplus
22539 && !dwarf2_per_objfile->types.empty ()
22540 && die->child != NULL
22541 && (die->tag == DW_TAG_class_type
22542 || die->tag == DW_TAG_structure_type
22543 || die->tag == DW_TAG_union_type))
22545 char *name = guess_full_die_structure_name (die, cu);
22550 case DW_TAG_enumeration_type:
22551 parent_type = read_type_die (parent, cu);
22552 if (TYPE_DECLARED_CLASS (parent_type))
22554 if (TYPE_NAME (parent_type) != NULL)
22555 return TYPE_NAME (parent_type);
22558 /* Fall through. */
22560 return determine_prefix (parent, cu);
22564 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22565 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
22566 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
22567 an obconcat, otherwise allocate storage for the result. The CU argument is
22568 used to determine the language and hence, the appropriate separator. */
22570 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
22573 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
22574 int physname, struct dwarf2_cu *cu)
22576 const char *lead = "";
22579 if (suffix == NULL || suffix[0] == '\0'
22580 || prefix == NULL || prefix[0] == '\0')
22582 else if (cu->language == language_d)
22584 /* For D, the 'main' function could be defined in any module, but it
22585 should never be prefixed. */
22586 if (strcmp (suffix, "D main") == 0)
22594 else if (cu->language == language_fortran && physname)
22596 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
22597 DW_AT_MIPS_linkage_name is preferred and used instead. */
22605 if (prefix == NULL)
22607 if (suffix == NULL)
22614 xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
22616 strcpy (retval, lead);
22617 strcat (retval, prefix);
22618 strcat (retval, sep);
22619 strcat (retval, suffix);
22624 /* We have an obstack. */
22625 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
22629 /* Return sibling of die, NULL if no sibling. */
22631 static struct die_info *
22632 sibling_die (struct die_info *die)
22634 return die->sibling;
22637 /* Get name of a die, return NULL if not found. */
22639 static const char *
22640 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
22641 struct obstack *obstack)
22643 if (name && cu->language == language_cplus)
22645 std::string canon_name = cp_canonicalize_string (name);
22647 if (!canon_name.empty ())
22649 if (canon_name != name)
22650 name = (const char *) obstack_copy0 (obstack,
22651 canon_name.c_str (),
22652 canon_name.length ());
22659 /* Get name of a die, return NULL if not found.
22660 Anonymous namespaces are converted to their magic string. */
22662 static const char *
22663 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
22665 struct attribute *attr;
22666 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22668 attr = dwarf2_attr (die, DW_AT_name, cu);
22669 if ((!attr || !DW_STRING (attr))
22670 && die->tag != DW_TAG_namespace
22671 && die->tag != DW_TAG_class_type
22672 && die->tag != DW_TAG_interface_type
22673 && die->tag != DW_TAG_structure_type
22674 && die->tag != DW_TAG_union_type)
22679 case DW_TAG_compile_unit:
22680 case DW_TAG_partial_unit:
22681 /* Compilation units have a DW_AT_name that is a filename, not
22682 a source language identifier. */
22683 case DW_TAG_enumeration_type:
22684 case DW_TAG_enumerator:
22685 /* These tags always have simple identifiers already; no need
22686 to canonicalize them. */
22687 return DW_STRING (attr);
22689 case DW_TAG_namespace:
22690 if (attr != NULL && DW_STRING (attr) != NULL)
22691 return DW_STRING (attr);
22692 return CP_ANONYMOUS_NAMESPACE_STR;
22694 case DW_TAG_class_type:
22695 case DW_TAG_interface_type:
22696 case DW_TAG_structure_type:
22697 case DW_TAG_union_type:
22698 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22699 structures or unions. These were of the form "._%d" in GCC 4.1,
22700 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22701 and GCC 4.4. We work around this problem by ignoring these. */
22702 if (attr && DW_STRING (attr)
22703 && (startswith (DW_STRING (attr), "._")
22704 || startswith (DW_STRING (attr), "<anonymous")))
22707 /* GCC might emit a nameless typedef that has a linkage name. See
22708 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
22709 if (!attr || DW_STRING (attr) == NULL)
22711 char *demangled = NULL;
22713 attr = dw2_linkage_name_attr (die, cu);
22714 if (attr == NULL || DW_STRING (attr) == NULL)
22717 /* Avoid demangling DW_STRING (attr) the second time on a second
22718 call for the same DIE. */
22719 if (!DW_STRING_IS_CANONICAL (attr))
22720 demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
22726 /* FIXME: we already did this for the partial symbol... */
22729 obstack_copy0 (&objfile->per_bfd->storage_obstack,
22730 demangled, strlen (demangled)));
22731 DW_STRING_IS_CANONICAL (attr) = 1;
22734 /* Strip any leading namespaces/classes, keep only the base name.
22735 DW_AT_name for named DIEs does not contain the prefixes. */
22736 base = strrchr (DW_STRING (attr), ':');
22737 if (base && base > DW_STRING (attr) && base[-1] == ':')
22740 return DW_STRING (attr);
22749 if (!DW_STRING_IS_CANONICAL (attr))
22752 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
22753 &objfile->per_bfd->storage_obstack);
22754 DW_STRING_IS_CANONICAL (attr) = 1;
22756 return DW_STRING (attr);
22759 /* Return the die that this die in an extension of, or NULL if there
22760 is none. *EXT_CU is the CU containing DIE on input, and the CU
22761 containing the return value on output. */
22763 static struct die_info *
22764 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
22766 struct attribute *attr;
22768 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
22772 return follow_die_ref (die, attr, ext_cu);
22775 /* A convenience function that returns an "unknown" DWARF name,
22776 including the value of V. STR is the name of the entity being
22777 printed, e.g., "TAG". */
22779 static const char *
22780 dwarf_unknown (const char *str, unsigned v)
22782 char *cell = get_print_cell ();
22783 xsnprintf (cell, PRINT_CELL_SIZE, "DW_%s_<unknown: %u>", str, v);
22787 /* Convert a DIE tag into its string name. */
22789 static const char *
22790 dwarf_tag_name (unsigned tag)
22792 const char *name = get_DW_TAG_name (tag);
22795 return dwarf_unknown ("TAG", tag);
22800 /* Convert a DWARF attribute code into its string name. */
22802 static const char *
22803 dwarf_attr_name (unsigned attr)
22807 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22808 if (attr == DW_AT_MIPS_fde)
22809 return "DW_AT_MIPS_fde";
22811 if (attr == DW_AT_HP_block_index)
22812 return "DW_AT_HP_block_index";
22815 name = get_DW_AT_name (attr);
22818 return dwarf_unknown ("AT", attr);
22823 /* Convert a DWARF value form code into its string name. */
22825 static const char *
22826 dwarf_form_name (unsigned form)
22828 const char *name = get_DW_FORM_name (form);
22831 return dwarf_unknown ("FORM", form);
22836 static const char *
22837 dwarf_bool_name (unsigned mybool)
22845 /* Convert a DWARF type code into its string name. */
22847 static const char *
22848 dwarf_type_encoding_name (unsigned enc)
22850 const char *name = get_DW_ATE_name (enc);
22853 return dwarf_unknown ("ATE", enc);
22859 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
22863 print_spaces (indent, f);
22864 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset %s)\n",
22865 dwarf_tag_name (die->tag), die->abbrev,
22866 sect_offset_str (die->sect_off));
22868 if (die->parent != NULL)
22870 print_spaces (indent, f);
22871 fprintf_unfiltered (f, " parent at offset: %s\n",
22872 sect_offset_str (die->parent->sect_off));
22875 print_spaces (indent, f);
22876 fprintf_unfiltered (f, " has children: %s\n",
22877 dwarf_bool_name (die->child != NULL));
22879 print_spaces (indent, f);
22880 fprintf_unfiltered (f, " attributes:\n");
22882 for (i = 0; i < die->num_attrs; ++i)
22884 print_spaces (indent, f);
22885 fprintf_unfiltered (f, " %s (%s) ",
22886 dwarf_attr_name (die->attrs[i].name),
22887 dwarf_form_name (die->attrs[i].form));
22889 switch (die->attrs[i].form)
22892 case DW_FORM_addrx:
22893 case DW_FORM_GNU_addr_index:
22894 fprintf_unfiltered (f, "address: ");
22895 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
22897 case DW_FORM_block2:
22898 case DW_FORM_block4:
22899 case DW_FORM_block:
22900 case DW_FORM_block1:
22901 fprintf_unfiltered (f, "block: size %s",
22902 pulongest (DW_BLOCK (&die->attrs[i])->size));
22904 case DW_FORM_exprloc:
22905 fprintf_unfiltered (f, "expression: size %s",
22906 pulongest (DW_BLOCK (&die->attrs[i])->size));
22908 case DW_FORM_data16:
22909 fprintf_unfiltered (f, "constant of 16 bytes");
22911 case DW_FORM_ref_addr:
22912 fprintf_unfiltered (f, "ref address: ");
22913 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22915 case DW_FORM_GNU_ref_alt:
22916 fprintf_unfiltered (f, "alt ref address: ");
22917 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22923 case DW_FORM_ref_udata:
22924 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
22925 (long) (DW_UNSND (&die->attrs[i])));
22927 case DW_FORM_data1:
22928 case DW_FORM_data2:
22929 case DW_FORM_data4:
22930 case DW_FORM_data8:
22931 case DW_FORM_udata:
22932 case DW_FORM_sdata:
22933 fprintf_unfiltered (f, "constant: %s",
22934 pulongest (DW_UNSND (&die->attrs[i])));
22936 case DW_FORM_sec_offset:
22937 fprintf_unfiltered (f, "section offset: %s",
22938 pulongest (DW_UNSND (&die->attrs[i])));
22940 case DW_FORM_ref_sig8:
22941 fprintf_unfiltered (f, "signature: %s",
22942 hex_string (DW_SIGNATURE (&die->attrs[i])));
22944 case DW_FORM_string:
22946 case DW_FORM_line_strp:
22948 case DW_FORM_GNU_str_index:
22949 case DW_FORM_GNU_strp_alt:
22950 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
22951 DW_STRING (&die->attrs[i])
22952 ? DW_STRING (&die->attrs[i]) : "",
22953 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
22956 if (DW_UNSND (&die->attrs[i]))
22957 fprintf_unfiltered (f, "flag: TRUE");
22959 fprintf_unfiltered (f, "flag: FALSE");
22961 case DW_FORM_flag_present:
22962 fprintf_unfiltered (f, "flag: TRUE");
22964 case DW_FORM_indirect:
22965 /* The reader will have reduced the indirect form to
22966 the "base form" so this form should not occur. */
22967 fprintf_unfiltered (f,
22968 "unexpected attribute form: DW_FORM_indirect");
22970 case DW_FORM_implicit_const:
22971 fprintf_unfiltered (f, "constant: %s",
22972 plongest (DW_SND (&die->attrs[i])));
22975 fprintf_unfiltered (f, "unsupported attribute form: %d.",
22976 die->attrs[i].form);
22979 fprintf_unfiltered (f, "\n");
22984 dump_die_for_error (struct die_info *die)
22986 dump_die_shallow (gdb_stderr, 0, die);
22990 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
22992 int indent = level * 4;
22994 gdb_assert (die != NULL);
22996 if (level >= max_level)
22999 dump_die_shallow (f, indent, die);
23001 if (die->child != NULL)
23003 print_spaces (indent, f);
23004 fprintf_unfiltered (f, " Children:");
23005 if (level + 1 < max_level)
23007 fprintf_unfiltered (f, "\n");
23008 dump_die_1 (f, level + 1, max_level, die->child);
23012 fprintf_unfiltered (f,
23013 " [not printed, max nesting level reached]\n");
23017 if (die->sibling != NULL && level > 0)
23019 dump_die_1 (f, level, max_level, die->sibling);
23023 /* This is called from the pdie macro in gdbinit.in.
23024 It's not static so gcc will keep a copy callable from gdb. */
23027 dump_die (struct die_info *die, int max_level)
23029 dump_die_1 (gdb_stdlog, 0, max_level, die);
23033 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
23037 slot = htab_find_slot_with_hash (cu->die_hash, die,
23038 to_underlying (die->sect_off),
23044 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
23048 dwarf2_get_ref_die_offset (const struct attribute *attr)
23050 if (attr_form_is_ref (attr))
23051 return (sect_offset) DW_UNSND (attr);
23053 complaint (_("unsupported die ref attribute form: '%s'"),
23054 dwarf_form_name (attr->form));
23058 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
23059 * the value held by the attribute is not constant. */
23062 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
23064 if (attr->form == DW_FORM_sdata || attr->form == DW_FORM_implicit_const)
23065 return DW_SND (attr);
23066 else if (attr->form == DW_FORM_udata
23067 || attr->form == DW_FORM_data1
23068 || attr->form == DW_FORM_data2
23069 || attr->form == DW_FORM_data4
23070 || attr->form == DW_FORM_data8)
23071 return DW_UNSND (attr);
23074 /* For DW_FORM_data16 see attr_form_is_constant. */
23075 complaint (_("Attribute value is not a constant (%s)"),
23076 dwarf_form_name (attr->form));
23077 return default_value;
23081 /* Follow reference or signature attribute ATTR of SRC_DIE.
23082 On entry *REF_CU is the CU of SRC_DIE.
23083 On exit *REF_CU is the CU of the result. */
23085 static struct die_info *
23086 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
23087 struct dwarf2_cu **ref_cu)
23089 struct die_info *die;
23091 if (attr_form_is_ref (attr))
23092 die = follow_die_ref (src_die, attr, ref_cu);
23093 else if (attr->form == DW_FORM_ref_sig8)
23094 die = follow_die_sig (src_die, attr, ref_cu);
23097 dump_die_for_error (src_die);
23098 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23099 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23105 /* Follow reference OFFSET.
23106 On entry *REF_CU is the CU of the source die referencing OFFSET.
23107 On exit *REF_CU is the CU of the result.
23108 Returns NULL if OFFSET is invalid. */
23110 static struct die_info *
23111 follow_die_offset (sect_offset sect_off, int offset_in_dwz,
23112 struct dwarf2_cu **ref_cu)
23114 struct die_info temp_die;
23115 struct dwarf2_cu *target_cu, *cu = *ref_cu;
23116 struct dwarf2_per_objfile *dwarf2_per_objfile
23117 = cu->per_cu->dwarf2_per_objfile;
23119 gdb_assert (cu->per_cu != NULL);
23123 if (cu->per_cu->is_debug_types)
23125 /* .debug_types CUs cannot reference anything outside their CU.
23126 If they need to, they have to reference a signatured type via
23127 DW_FORM_ref_sig8. */
23128 if (!offset_in_cu_p (&cu->header, sect_off))
23131 else if (offset_in_dwz != cu->per_cu->is_dwz
23132 || !offset_in_cu_p (&cu->header, sect_off))
23134 struct dwarf2_per_cu_data *per_cu;
23136 per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
23137 dwarf2_per_objfile);
23139 /* If necessary, add it to the queue and load its DIEs. */
23140 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
23141 load_full_comp_unit (per_cu, false, cu->language);
23143 target_cu = per_cu->cu;
23145 else if (cu->dies == NULL)
23147 /* We're loading full DIEs during partial symbol reading. */
23148 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
23149 load_full_comp_unit (cu->per_cu, false, language_minimal);
23152 *ref_cu = target_cu;
23153 temp_die.sect_off = sect_off;
23155 if (target_cu != cu)
23156 target_cu->ancestor = cu;
23158 return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
23160 to_underlying (sect_off));
23163 /* Follow reference attribute ATTR of SRC_DIE.
23164 On entry *REF_CU is the CU of SRC_DIE.
23165 On exit *REF_CU is the CU of the result. */
23167 static struct die_info *
23168 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
23169 struct dwarf2_cu **ref_cu)
23171 sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
23172 struct dwarf2_cu *cu = *ref_cu;
23173 struct die_info *die;
23175 die = follow_die_offset (sect_off,
23176 (attr->form == DW_FORM_GNU_ref_alt
23177 || cu->per_cu->is_dwz),
23180 error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23181 "at %s [in module %s]"),
23182 sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
23183 objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
23188 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23189 Returned value is intended for DW_OP_call*. Returned
23190 dwarf2_locexpr_baton->data has lifetime of
23191 PER_CU->DWARF2_PER_OBJFILE->OBJFILE. */
23193 struct dwarf2_locexpr_baton
23194 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
23195 struct dwarf2_per_cu_data *per_cu,
23196 CORE_ADDR (*get_frame_pc) (void *baton),
23197 void *baton, bool resolve_abstract_p)
23199 struct dwarf2_cu *cu;
23200 struct die_info *die;
23201 struct attribute *attr;
23202 struct dwarf2_locexpr_baton retval;
23203 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
23204 struct objfile *objfile = dwarf2_per_objfile->objfile;
23206 if (per_cu->cu == NULL)
23207 load_cu (per_cu, false);
23211 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23212 Instead just throw an error, not much else we can do. */
23213 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23214 sect_offset_str (sect_off), objfile_name (objfile));
23217 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23219 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23220 sect_offset_str (sect_off), objfile_name (objfile));
23222 attr = dwarf2_attr (die, DW_AT_location, cu);
23223 if (!attr && resolve_abstract_p
23224 && (dwarf2_per_objfile->abstract_to_concrete.find (die->sect_off)
23225 != dwarf2_per_objfile->abstract_to_concrete.end ()))
23227 CORE_ADDR pc = (*get_frame_pc) (baton);
23229 for (const auto &cand_off
23230 : dwarf2_per_objfile->abstract_to_concrete[die->sect_off])
23232 struct dwarf2_cu *cand_cu = cu;
23233 struct die_info *cand
23234 = follow_die_offset (cand_off, per_cu->is_dwz, &cand_cu);
23237 || cand->parent->tag != DW_TAG_subprogram)
23240 CORE_ADDR pc_low, pc_high;
23241 get_scope_pc_bounds (cand->parent, &pc_low, &pc_high, cu);
23242 if (pc_low == ((CORE_ADDR) -1)
23243 || !(pc_low <= pc && pc < pc_high))
23247 attr = dwarf2_attr (die, DW_AT_location, cu);
23254 /* DWARF: "If there is no such attribute, then there is no effect.".
23255 DATA is ignored if SIZE is 0. */
23257 retval.data = NULL;
23260 else if (attr_form_is_section_offset (attr))
23262 struct dwarf2_loclist_baton loclist_baton;
23263 CORE_ADDR pc = (*get_frame_pc) (baton);
23266 fill_in_loclist_baton (cu, &loclist_baton, attr);
23268 retval.data = dwarf2_find_location_expression (&loclist_baton,
23270 retval.size = size;
23274 if (!attr_form_is_block (attr))
23275 error (_("Dwarf Error: DIE at %s referenced in module %s "
23276 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23277 sect_offset_str (sect_off), objfile_name (objfile));
23279 retval.data = DW_BLOCK (attr)->data;
23280 retval.size = DW_BLOCK (attr)->size;
23282 retval.per_cu = cu->per_cu;
23284 age_cached_comp_units (dwarf2_per_objfile);
23289 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23292 struct dwarf2_locexpr_baton
23293 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
23294 struct dwarf2_per_cu_data *per_cu,
23295 CORE_ADDR (*get_frame_pc) (void *baton),
23298 sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
23300 return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
23303 /* Write a constant of a given type as target-ordered bytes into
23306 static const gdb_byte *
23307 write_constant_as_bytes (struct obstack *obstack,
23308 enum bfd_endian byte_order,
23315 *len = TYPE_LENGTH (type);
23316 result = (gdb_byte *) obstack_alloc (obstack, *len);
23317 store_unsigned_integer (result, *len, byte_order, value);
23322 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23323 pointer to the constant bytes and set LEN to the length of the
23324 data. If memory is needed, allocate it on OBSTACK. If the DIE
23325 does not have a DW_AT_const_value, return NULL. */
23328 dwarf2_fetch_constant_bytes (sect_offset sect_off,
23329 struct dwarf2_per_cu_data *per_cu,
23330 struct obstack *obstack,
23333 struct dwarf2_cu *cu;
23334 struct die_info *die;
23335 struct attribute *attr;
23336 const gdb_byte *result = NULL;
23339 enum bfd_endian byte_order;
23340 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23342 if (per_cu->cu == NULL)
23343 load_cu (per_cu, false);
23347 /* We shouldn't get here for a dummy CU, but don't crash on the user.
23348 Instead just throw an error, not much else we can do. */
23349 error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23350 sect_offset_str (sect_off), objfile_name (objfile));
23353 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23355 error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23356 sect_offset_str (sect_off), objfile_name (objfile));
23358 attr = dwarf2_attr (die, DW_AT_const_value, cu);
23362 byte_order = (bfd_big_endian (objfile->obfd)
23363 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
23365 switch (attr->form)
23368 case DW_FORM_addrx:
23369 case DW_FORM_GNU_addr_index:
23373 *len = cu->header.addr_size;
23374 tem = (gdb_byte *) obstack_alloc (obstack, *len);
23375 store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
23379 case DW_FORM_string:
23382 case DW_FORM_GNU_str_index:
23383 case DW_FORM_GNU_strp_alt:
23384 /* DW_STRING is already allocated on the objfile obstack, point
23386 result = (const gdb_byte *) DW_STRING (attr);
23387 *len = strlen (DW_STRING (attr));
23389 case DW_FORM_block1:
23390 case DW_FORM_block2:
23391 case DW_FORM_block4:
23392 case DW_FORM_block:
23393 case DW_FORM_exprloc:
23394 case DW_FORM_data16:
23395 result = DW_BLOCK (attr)->data;
23396 *len = DW_BLOCK (attr)->size;
23399 /* The DW_AT_const_value attributes are supposed to carry the
23400 symbol's value "represented as it would be on the target
23401 architecture." By the time we get here, it's already been
23402 converted to host endianness, so we just need to sign- or
23403 zero-extend it as appropriate. */
23404 case DW_FORM_data1:
23405 type = die_type (die, cu);
23406 result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
23407 if (result == NULL)
23408 result = write_constant_as_bytes (obstack, byte_order,
23411 case DW_FORM_data2:
23412 type = die_type (die, cu);
23413 result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
23414 if (result == NULL)
23415 result = write_constant_as_bytes (obstack, byte_order,
23418 case DW_FORM_data4:
23419 type = die_type (die, cu);
23420 result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
23421 if (result == NULL)
23422 result = write_constant_as_bytes (obstack, byte_order,
23425 case DW_FORM_data8:
23426 type = die_type (die, cu);
23427 result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
23428 if (result == NULL)
23429 result = write_constant_as_bytes (obstack, byte_order,
23433 case DW_FORM_sdata:
23434 case DW_FORM_implicit_const:
23435 type = die_type (die, cu);
23436 result = write_constant_as_bytes (obstack, byte_order,
23437 type, DW_SND (attr), len);
23440 case DW_FORM_udata:
23441 type = die_type (die, cu);
23442 result = write_constant_as_bytes (obstack, byte_order,
23443 type, DW_UNSND (attr), len);
23447 complaint (_("unsupported const value attribute form: '%s'"),
23448 dwarf_form_name (attr->form));
23455 /* Return the type of the die at OFFSET in PER_CU. Return NULL if no
23456 valid type for this die is found. */
23459 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
23460 struct dwarf2_per_cu_data *per_cu)
23462 struct dwarf2_cu *cu;
23463 struct die_info *die;
23465 if (per_cu->cu == NULL)
23466 load_cu (per_cu, false);
23471 die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23475 return die_type (die, cu);
23478 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23482 dwarf2_get_die_type (cu_offset die_offset,
23483 struct dwarf2_per_cu_data *per_cu)
23485 sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
23486 return get_die_type_at_offset (die_offset_sect, per_cu);
23489 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23490 On entry *REF_CU is the CU of SRC_DIE.
23491 On exit *REF_CU is the CU of the result.
23492 Returns NULL if the referenced DIE isn't found. */
23494 static struct die_info *
23495 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
23496 struct dwarf2_cu **ref_cu)
23498 struct die_info temp_die;
23499 struct dwarf2_cu *sig_cu, *cu = *ref_cu;
23500 struct die_info *die;
23502 /* While it might be nice to assert sig_type->type == NULL here,
23503 we can get here for DW_AT_imported_declaration where we need
23504 the DIE not the type. */
23506 /* If necessary, add it to the queue and load its DIEs. */
23508 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
23509 read_signatured_type (sig_type);
23511 sig_cu = sig_type->per_cu.cu;
23512 gdb_assert (sig_cu != NULL);
23513 gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
23514 temp_die.sect_off = sig_type->type_offset_in_section;
23515 die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
23516 to_underlying (temp_die.sect_off));
23519 struct dwarf2_per_objfile *dwarf2_per_objfile
23520 = (*ref_cu)->per_cu->dwarf2_per_objfile;
23522 /* For .gdb_index version 7 keep track of included TUs.
23523 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
23524 if (dwarf2_per_objfile->index_table != NULL
23525 && dwarf2_per_objfile->index_table->version <= 7)
23527 VEC_safe_push (dwarf2_per_cu_ptr,
23528 (*ref_cu)->per_cu->imported_symtabs,
23534 sig_cu->ancestor = cu;
23542 /* Follow signatured type referenced by ATTR in SRC_DIE.
23543 On entry *REF_CU is the CU of SRC_DIE.
23544 On exit *REF_CU is the CU of the result.
23545 The result is the DIE of the type.
23546 If the referenced type cannot be found an error is thrown. */
23548 static struct die_info *
23549 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
23550 struct dwarf2_cu **ref_cu)
23552 ULONGEST signature = DW_SIGNATURE (attr);
23553 struct signatured_type *sig_type;
23554 struct die_info *die;
23556 gdb_assert (attr->form == DW_FORM_ref_sig8);
23558 sig_type = lookup_signatured_type (*ref_cu, signature);
23559 /* sig_type will be NULL if the signatured type is missing from
23561 if (sig_type == NULL)
23563 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23564 " from DIE at %s [in module %s]"),
23565 hex_string (signature), sect_offset_str (src_die->sect_off),
23566 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23569 die = follow_die_sig_1 (src_die, sig_type, ref_cu);
23572 dump_die_for_error (src_die);
23573 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23574 " from DIE at %s [in module %s]"),
23575 hex_string (signature), sect_offset_str (src_die->sect_off),
23576 objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23582 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23583 reading in and processing the type unit if necessary. */
23585 static struct type *
23586 get_signatured_type (struct die_info *die, ULONGEST signature,
23587 struct dwarf2_cu *cu)
23589 struct dwarf2_per_objfile *dwarf2_per_objfile
23590 = cu->per_cu->dwarf2_per_objfile;
23591 struct signatured_type *sig_type;
23592 struct dwarf2_cu *type_cu;
23593 struct die_info *type_die;
23596 sig_type = lookup_signatured_type (cu, signature);
23597 /* sig_type will be NULL if the signatured type is missing from
23599 if (sig_type == NULL)
23601 complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23602 " from DIE at %s [in module %s]"),
23603 hex_string (signature), sect_offset_str (die->sect_off),
23604 objfile_name (dwarf2_per_objfile->objfile));
23605 return build_error_marker_type (cu, die);
23608 /* If we already know the type we're done. */
23609 if (sig_type->type != NULL)
23610 return sig_type->type;
23613 type_die = follow_die_sig_1 (die, sig_type, &type_cu);
23614 if (type_die != NULL)
23616 /* N.B. We need to call get_die_type to ensure only one type for this DIE
23617 is created. This is important, for example, because for c++ classes
23618 we need TYPE_NAME set which is only done by new_symbol. Blech. */
23619 type = read_type_die (type_die, type_cu);
23622 complaint (_("Dwarf Error: Cannot build signatured type %s"
23623 " referenced from DIE at %s [in module %s]"),
23624 hex_string (signature), sect_offset_str (die->sect_off),
23625 objfile_name (dwarf2_per_objfile->objfile));
23626 type = build_error_marker_type (cu, die);
23631 complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23632 " from DIE at %s [in module %s]"),
23633 hex_string (signature), sect_offset_str (die->sect_off),
23634 objfile_name (dwarf2_per_objfile->objfile));
23635 type = build_error_marker_type (cu, die);
23637 sig_type->type = type;
23642 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23643 reading in and processing the type unit if necessary. */
23645 static struct type *
23646 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
23647 struct dwarf2_cu *cu) /* ARI: editCase function */
23649 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
23650 if (attr_form_is_ref (attr))
23652 struct dwarf2_cu *type_cu = cu;
23653 struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
23655 return read_type_die (type_die, type_cu);
23657 else if (attr->form == DW_FORM_ref_sig8)
23659 return get_signatured_type (die, DW_SIGNATURE (attr), cu);
23663 struct dwarf2_per_objfile *dwarf2_per_objfile
23664 = cu->per_cu->dwarf2_per_objfile;
23666 complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23667 " at %s [in module %s]"),
23668 dwarf_form_name (attr->form), sect_offset_str (die->sect_off),
23669 objfile_name (dwarf2_per_objfile->objfile));
23670 return build_error_marker_type (cu, die);
23674 /* Load the DIEs associated with type unit PER_CU into memory. */
23677 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
23679 struct signatured_type *sig_type;
23681 /* Caller is responsible for ensuring type_unit_groups don't get here. */
23682 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
23684 /* We have the per_cu, but we need the signatured_type.
23685 Fortunately this is an easy translation. */
23686 gdb_assert (per_cu->is_debug_types);
23687 sig_type = (struct signatured_type *) per_cu;
23689 gdb_assert (per_cu->cu == NULL);
23691 read_signatured_type (sig_type);
23693 gdb_assert (per_cu->cu != NULL);
23696 /* die_reader_func for read_signatured_type.
23697 This is identical to load_full_comp_unit_reader,
23698 but is kept separate for now. */
23701 read_signatured_type_reader (const struct die_reader_specs *reader,
23702 const gdb_byte *info_ptr,
23703 struct die_info *comp_unit_die,
23707 struct dwarf2_cu *cu = reader->cu;
23709 gdb_assert (cu->die_hash == NULL);
23711 htab_create_alloc_ex (cu->header.length / 12,
23715 &cu->comp_unit_obstack,
23716 hashtab_obstack_allocate,
23717 dummy_obstack_deallocate);
23720 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
23721 &info_ptr, comp_unit_die);
23722 cu->dies = comp_unit_die;
23723 /* comp_unit_die is not stored in die_hash, no need. */
23725 /* We try not to read any attributes in this function, because not
23726 all CUs needed for references have been loaded yet, and symbol
23727 table processing isn't initialized. But we have to set the CU language,
23728 or we won't be able to build types correctly.
23729 Similarly, if we do not read the producer, we can not apply
23730 producer-specific interpretation. */
23731 prepare_one_comp_unit (cu, cu->dies, language_minimal);
23734 /* Read in a signatured type and build its CU and DIEs.
23735 If the type is a stub for the real type in a DWO file,
23736 read in the real type from the DWO file as well. */
23739 read_signatured_type (struct signatured_type *sig_type)
23741 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
23743 gdb_assert (per_cu->is_debug_types);
23744 gdb_assert (per_cu->cu == NULL);
23746 init_cutu_and_read_dies (per_cu, NULL, 0, 1, false,
23747 read_signatured_type_reader, NULL);
23748 sig_type->per_cu.tu_read = 1;
23751 /* Decode simple location descriptions.
23752 Given a pointer to a dwarf block that defines a location, compute
23753 the location and return the value.
23755 NOTE drow/2003-11-18: This function is called in two situations
23756 now: for the address of static or global variables (partial symbols
23757 only) and for offsets into structures which are expected to be
23758 (more or less) constant. The partial symbol case should go away,
23759 and only the constant case should remain. That will let this
23760 function complain more accurately. A few special modes are allowed
23761 without complaint for global variables (for instance, global
23762 register values and thread-local values).
23764 A location description containing no operations indicates that the
23765 object is optimized out. The return value is 0 for that case.
23766 FIXME drow/2003-11-16: No callers check for this case any more; soon all
23767 callers will only want a very basic result and this can become a
23770 Note that stack[0] is unused except as a default error return. */
23773 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
23775 struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
23777 size_t size = blk->size;
23778 const gdb_byte *data = blk->data;
23779 CORE_ADDR stack[64];
23781 unsigned int bytes_read, unsnd;
23787 stack[++stacki] = 0;
23826 stack[++stacki] = op - DW_OP_lit0;
23861 stack[++stacki] = op - DW_OP_reg0;
23863 dwarf2_complex_location_expr_complaint ();
23867 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
23869 stack[++stacki] = unsnd;
23871 dwarf2_complex_location_expr_complaint ();
23875 stack[++stacki] = read_address (objfile->obfd, &data[i],
23880 case DW_OP_const1u:
23881 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
23885 case DW_OP_const1s:
23886 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
23890 case DW_OP_const2u:
23891 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
23895 case DW_OP_const2s:
23896 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
23900 case DW_OP_const4u:
23901 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
23905 case DW_OP_const4s:
23906 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
23910 case DW_OP_const8u:
23911 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
23916 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
23922 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
23927 stack[stacki + 1] = stack[stacki];
23932 stack[stacki - 1] += stack[stacki];
23936 case DW_OP_plus_uconst:
23937 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
23943 stack[stacki - 1] -= stack[stacki];
23948 /* If we're not the last op, then we definitely can't encode
23949 this using GDB's address_class enum. This is valid for partial
23950 global symbols, although the variable's address will be bogus
23953 dwarf2_complex_location_expr_complaint ();
23956 case DW_OP_GNU_push_tls_address:
23957 case DW_OP_form_tls_address:
23958 /* The top of the stack has the offset from the beginning
23959 of the thread control block at which the variable is located. */
23960 /* Nothing should follow this operator, so the top of stack would
23962 /* This is valid for partial global symbols, but the variable's
23963 address will be bogus in the psymtab. Make it always at least
23964 non-zero to not look as a variable garbage collected by linker
23965 which have DW_OP_addr 0. */
23967 dwarf2_complex_location_expr_complaint ();
23971 case DW_OP_GNU_uninit:
23975 case DW_OP_GNU_addr_index:
23976 case DW_OP_GNU_const_index:
23977 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
23984 const char *name = get_DW_OP_name (op);
23987 complaint (_("unsupported stack op: '%s'"),
23990 complaint (_("unsupported stack op: '%02x'"),
23994 return (stack[stacki]);
23997 /* Enforce maximum stack depth of SIZE-1 to avoid writing
23998 outside of the allocated space. Also enforce minimum>0. */
23999 if (stacki >= ARRAY_SIZE (stack) - 1)
24001 complaint (_("location description stack overflow"));
24007 complaint (_("location description stack underflow"));
24011 return (stack[stacki]);
24014 /* memory allocation interface */
24016 static struct dwarf_block *
24017 dwarf_alloc_block (struct dwarf2_cu *cu)
24019 return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
24022 static struct die_info *
24023 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
24025 struct die_info *die;
24026 size_t size = sizeof (struct die_info);
24029 size += (num_attrs - 1) * sizeof (struct attribute);
24031 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
24032 memset (die, 0, sizeof (struct die_info));
24037 /* Macro support. */
24039 /* Return file name relative to the compilation directory of file number I in
24040 *LH's file name table. The result is allocated using xmalloc; the caller is
24041 responsible for freeing it. */
24044 file_file_name (int file, struct line_header *lh)
24046 /* Is the file number a valid index into the line header's file name
24047 table? Remember that file numbers start with one, not zero. */
24048 if (1 <= file && file <= lh->file_names.size ())
24050 const file_entry &fe = lh->file_names[file - 1];
24052 if (!IS_ABSOLUTE_PATH (fe.name))
24054 const char *dir = fe.include_dir (lh);
24056 return concat (dir, SLASH_STRING, fe.name, (char *) NULL);
24058 return xstrdup (fe.name);
24062 /* The compiler produced a bogus file number. We can at least
24063 record the macro definitions made in the file, even if we
24064 won't be able to find the file by name. */
24065 char fake_name[80];
24067 xsnprintf (fake_name, sizeof (fake_name),
24068 "<bad macro file number %d>", file);
24070 complaint (_("bad file number in macro information (%d)"),
24073 return xstrdup (fake_name);
24077 /* Return the full name of file number I in *LH's file name table.
24078 Use COMP_DIR as the name of the current directory of the
24079 compilation. The result is allocated using xmalloc; the caller is
24080 responsible for freeing it. */
24082 file_full_name (int file, struct line_header *lh, const char *comp_dir)
24084 /* Is the file number a valid index into the line header's file name
24085 table? Remember that file numbers start with one, not zero. */
24086 if (1 <= file && file <= lh->file_names.size ())
24088 char *relative = file_file_name (file, lh);
24090 if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
24092 return reconcat (relative, comp_dir, SLASH_STRING,
24093 relative, (char *) NULL);
24096 return file_file_name (file, lh);
24100 static struct macro_source_file *
24101 macro_start_file (struct dwarf2_cu *cu,
24102 int file, int line,
24103 struct macro_source_file *current_file,
24104 struct line_header *lh)
24106 /* File name relative to the compilation directory of this source file. */
24107 char *file_name = file_file_name (file, lh);
24109 if (! current_file)
24111 /* Note: We don't create a macro table for this compilation unit
24112 at all until we actually get a filename. */
24113 struct macro_table *macro_table = cu->get_builder ()->get_macro_table ();
24115 /* If we have no current file, then this must be the start_file
24116 directive for the compilation unit's main source file. */
24117 current_file = macro_set_main (macro_table, file_name);
24118 macro_define_special (macro_table);
24121 current_file = macro_include (current_file, line, file_name);
24125 return current_file;
24128 static const char *
24129 consume_improper_spaces (const char *p, const char *body)
24133 complaint (_("macro definition contains spaces "
24134 "in formal argument list:\n`%s'"),
24146 parse_macro_definition (struct macro_source_file *file, int line,
24151 /* The body string takes one of two forms. For object-like macro
24152 definitions, it should be:
24154 <macro name> " " <definition>
24156 For function-like macro definitions, it should be:
24158 <macro name> "() " <definition>
24160 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24162 Spaces may appear only where explicitly indicated, and in the
24165 The Dwarf 2 spec says that an object-like macro's name is always
24166 followed by a space, but versions of GCC around March 2002 omit
24167 the space when the macro's definition is the empty string.
24169 The Dwarf 2 spec says that there should be no spaces between the
24170 formal arguments in a function-like macro's formal argument list,
24171 but versions of GCC around March 2002 include spaces after the
24175 /* Find the extent of the macro name. The macro name is terminated
24176 by either a space or null character (for an object-like macro) or
24177 an opening paren (for a function-like macro). */
24178 for (p = body; *p; p++)
24179 if (*p == ' ' || *p == '(')
24182 if (*p == ' ' || *p == '\0')
24184 /* It's an object-like macro. */
24185 int name_len = p - body;
24186 char *name = savestring (body, name_len);
24187 const char *replacement;
24190 replacement = body + name_len + 1;
24193 dwarf2_macro_malformed_definition_complaint (body);
24194 replacement = body + name_len;
24197 macro_define_object (file, line, name, replacement);
24201 else if (*p == '(')
24203 /* It's a function-like macro. */
24204 char *name = savestring (body, p - body);
24207 char **argv = XNEWVEC (char *, argv_size);
24211 p = consume_improper_spaces (p, body);
24213 /* Parse the formal argument list. */
24214 while (*p && *p != ')')
24216 /* Find the extent of the current argument name. */
24217 const char *arg_start = p;
24219 while (*p && *p != ',' && *p != ')' && *p != ' ')
24222 if (! *p || p == arg_start)
24223 dwarf2_macro_malformed_definition_complaint (body);
24226 /* Make sure argv has room for the new argument. */
24227 if (argc >= argv_size)
24230 argv = XRESIZEVEC (char *, argv, argv_size);
24233 argv[argc++] = savestring (arg_start, p - arg_start);
24236 p = consume_improper_spaces (p, body);
24238 /* Consume the comma, if present. */
24243 p = consume_improper_spaces (p, body);
24252 /* Perfectly formed definition, no complaints. */
24253 macro_define_function (file, line, name,
24254 argc, (const char **) argv,
24256 else if (*p == '\0')
24258 /* Complain, but do define it. */
24259 dwarf2_macro_malformed_definition_complaint (body);
24260 macro_define_function (file, line, name,
24261 argc, (const char **) argv,
24265 /* Just complain. */
24266 dwarf2_macro_malformed_definition_complaint (body);
24269 /* Just complain. */
24270 dwarf2_macro_malformed_definition_complaint (body);
24276 for (i = 0; i < argc; i++)
24282 dwarf2_macro_malformed_definition_complaint (body);
24285 /* Skip some bytes from BYTES according to the form given in FORM.
24286 Returns the new pointer. */
24288 static const gdb_byte *
24289 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
24290 enum dwarf_form form,
24291 unsigned int offset_size,
24292 struct dwarf2_section_info *section)
24294 unsigned int bytes_read;
24298 case DW_FORM_data1:
24303 case DW_FORM_data2:
24307 case DW_FORM_data4:
24311 case DW_FORM_data8:
24315 case DW_FORM_data16:
24319 case DW_FORM_string:
24320 read_direct_string (abfd, bytes, &bytes_read);
24321 bytes += bytes_read;
24324 case DW_FORM_sec_offset:
24326 case DW_FORM_GNU_strp_alt:
24327 bytes += offset_size;
24330 case DW_FORM_block:
24331 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
24332 bytes += bytes_read;
24335 case DW_FORM_block1:
24336 bytes += 1 + read_1_byte (abfd, bytes);
24338 case DW_FORM_block2:
24339 bytes += 2 + read_2_bytes (abfd, bytes);
24341 case DW_FORM_block4:
24342 bytes += 4 + read_4_bytes (abfd, bytes);
24345 case DW_FORM_addrx:
24346 case DW_FORM_sdata:
24348 case DW_FORM_udata:
24349 case DW_FORM_GNU_addr_index:
24350 case DW_FORM_GNU_str_index:
24351 bytes = gdb_skip_leb128 (bytes, buffer_end);
24354 dwarf2_section_buffer_overflow_complaint (section);
24359 case DW_FORM_implicit_const:
24364 complaint (_("invalid form 0x%x in `%s'"),
24365 form, get_section_name (section));
24373 /* A helper for dwarf_decode_macros that handles skipping an unknown
24374 opcode. Returns an updated pointer to the macro data buffer; or,
24375 on error, issues a complaint and returns NULL. */
24377 static const gdb_byte *
24378 skip_unknown_opcode (unsigned int opcode,
24379 const gdb_byte **opcode_definitions,
24380 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24382 unsigned int offset_size,
24383 struct dwarf2_section_info *section)
24385 unsigned int bytes_read, i;
24387 const gdb_byte *defn;
24389 if (opcode_definitions[opcode] == NULL)
24391 complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24396 defn = opcode_definitions[opcode];
24397 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
24398 defn += bytes_read;
24400 for (i = 0; i < arg; ++i)
24402 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end,
24403 (enum dwarf_form) defn[i], offset_size,
24405 if (mac_ptr == NULL)
24407 /* skip_form_bytes already issued the complaint. */
24415 /* A helper function which parses the header of a macro section.
24416 If the macro section is the extended (for now called "GNU") type,
24417 then this updates *OFFSET_SIZE. Returns a pointer to just after
24418 the header, or issues a complaint and returns NULL on error. */
24420 static const gdb_byte *
24421 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
24423 const gdb_byte *mac_ptr,
24424 unsigned int *offset_size,
24425 int section_is_gnu)
24427 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
24429 if (section_is_gnu)
24431 unsigned int version, flags;
24433 version = read_2_bytes (abfd, mac_ptr);
24434 if (version != 4 && version != 5)
24436 complaint (_("unrecognized version `%d' in .debug_macro section"),
24442 flags = read_1_byte (abfd, mac_ptr);
24444 *offset_size = (flags & 1) ? 8 : 4;
24446 if ((flags & 2) != 0)
24447 /* We don't need the line table offset. */
24448 mac_ptr += *offset_size;
24450 /* Vendor opcode descriptions. */
24451 if ((flags & 4) != 0)
24453 unsigned int i, count;
24455 count = read_1_byte (abfd, mac_ptr);
24457 for (i = 0; i < count; ++i)
24459 unsigned int opcode, bytes_read;
24462 opcode = read_1_byte (abfd, mac_ptr);
24464 opcode_definitions[opcode] = mac_ptr;
24465 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24466 mac_ptr += bytes_read;
24475 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24476 including DW_MACRO_import. */
24479 dwarf_decode_macro_bytes (struct dwarf2_cu *cu,
24481 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24482 struct macro_source_file *current_file,
24483 struct line_header *lh,
24484 struct dwarf2_section_info *section,
24485 int section_is_gnu, int section_is_dwz,
24486 unsigned int offset_size,
24487 htab_t include_hash)
24489 struct dwarf2_per_objfile *dwarf2_per_objfile
24490 = cu->per_cu->dwarf2_per_objfile;
24491 struct objfile *objfile = dwarf2_per_objfile->objfile;
24492 enum dwarf_macro_record_type macinfo_type;
24493 int at_commandline;
24494 const gdb_byte *opcode_definitions[256];
24496 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24497 &offset_size, section_is_gnu);
24498 if (mac_ptr == NULL)
24500 /* We already issued a complaint. */
24504 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
24505 GDB is still reading the definitions from command line. First
24506 DW_MACINFO_start_file will need to be ignored as it was already executed
24507 to create CURRENT_FILE for the main source holding also the command line
24508 definitions. On first met DW_MACINFO_start_file this flag is reset to
24509 normally execute all the remaining DW_MACINFO_start_file macinfos. */
24511 at_commandline = 1;
24515 /* Do we at least have room for a macinfo type byte? */
24516 if (mac_ptr >= mac_end)
24518 dwarf2_section_buffer_overflow_complaint (section);
24522 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24525 /* Note that we rely on the fact that the corresponding GNU and
24526 DWARF constants are the same. */
24528 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24529 switch (macinfo_type)
24531 /* A zero macinfo type indicates the end of the macro
24536 case DW_MACRO_define:
24537 case DW_MACRO_undef:
24538 case DW_MACRO_define_strp:
24539 case DW_MACRO_undef_strp:
24540 case DW_MACRO_define_sup:
24541 case DW_MACRO_undef_sup:
24543 unsigned int bytes_read;
24548 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24549 mac_ptr += bytes_read;
24551 if (macinfo_type == DW_MACRO_define
24552 || macinfo_type == DW_MACRO_undef)
24554 body = read_direct_string (abfd, mac_ptr, &bytes_read);
24555 mac_ptr += bytes_read;
24559 LONGEST str_offset;
24561 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
24562 mac_ptr += offset_size;
24564 if (macinfo_type == DW_MACRO_define_sup
24565 || macinfo_type == DW_MACRO_undef_sup
24568 struct dwz_file *dwz
24569 = dwarf2_get_dwz_file (dwarf2_per_objfile);
24571 body = read_indirect_string_from_dwz (objfile,
24575 body = read_indirect_string_at_offset (dwarf2_per_objfile,
24579 is_define = (macinfo_type == DW_MACRO_define
24580 || macinfo_type == DW_MACRO_define_strp
24581 || macinfo_type == DW_MACRO_define_sup);
24582 if (! current_file)
24584 /* DWARF violation as no main source is present. */
24585 complaint (_("debug info with no main source gives macro %s "
24587 is_define ? _("definition") : _("undefinition"),
24591 if ((line == 0 && !at_commandline)
24592 || (line != 0 && at_commandline))
24593 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24594 at_commandline ? _("command-line") : _("in-file"),
24595 is_define ? _("definition") : _("undefinition"),
24596 line == 0 ? _("zero") : _("non-zero"), line, body);
24600 /* Fedora's rpm-build's "debugedit" binary
24601 corrupted .debug_macro sections.
24604 https://bugzilla.redhat.com/show_bug.cgi?id=1708786 */
24605 complaint (_("debug info gives %s invalid macro %s "
24606 "without body (corrupted?) at line %d "
24608 at_commandline ? _("command-line") : _("in-file"),
24609 is_define ? _("definition") : _("undefinition"),
24610 line, current_file->filename);
24612 else if (is_define)
24613 parse_macro_definition (current_file, line, body);
24616 gdb_assert (macinfo_type == DW_MACRO_undef
24617 || macinfo_type == DW_MACRO_undef_strp
24618 || macinfo_type == DW_MACRO_undef_sup);
24619 macro_undef (current_file, line, body);
24624 case DW_MACRO_start_file:
24626 unsigned int bytes_read;
24629 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24630 mac_ptr += bytes_read;
24631 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24632 mac_ptr += bytes_read;
24634 if ((line == 0 && !at_commandline)
24635 || (line != 0 && at_commandline))
24636 complaint (_("debug info gives source %d included "
24637 "from %s at %s line %d"),
24638 file, at_commandline ? _("command-line") : _("file"),
24639 line == 0 ? _("zero") : _("non-zero"), line);
24641 if (at_commandline)
24643 /* This DW_MACRO_start_file was executed in the
24645 at_commandline = 0;
24648 current_file = macro_start_file (cu, file, line, current_file,
24653 case DW_MACRO_end_file:
24654 if (! current_file)
24655 complaint (_("macro debug info has an unmatched "
24656 "`close_file' directive"));
24659 current_file = current_file->included_by;
24660 if (! current_file)
24662 enum dwarf_macro_record_type next_type;
24664 /* GCC circa March 2002 doesn't produce the zero
24665 type byte marking the end of the compilation
24666 unit. Complain if it's not there, but exit no
24669 /* Do we at least have room for a macinfo type byte? */
24670 if (mac_ptr >= mac_end)
24672 dwarf2_section_buffer_overflow_complaint (section);
24676 /* We don't increment mac_ptr here, so this is just
24679 = (enum dwarf_macro_record_type) read_1_byte (abfd,
24681 if (next_type != 0)
24682 complaint (_("no terminating 0-type entry for "
24683 "macros in `.debug_macinfo' section"));
24690 case DW_MACRO_import:
24691 case DW_MACRO_import_sup:
24695 bfd *include_bfd = abfd;
24696 struct dwarf2_section_info *include_section = section;
24697 const gdb_byte *include_mac_end = mac_end;
24698 int is_dwz = section_is_dwz;
24699 const gdb_byte *new_mac_ptr;
24701 offset = read_offset_1 (abfd, mac_ptr, offset_size);
24702 mac_ptr += offset_size;
24704 if (macinfo_type == DW_MACRO_import_sup)
24706 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
24708 dwarf2_read_section (objfile, &dwz->macro);
24710 include_section = &dwz->macro;
24711 include_bfd = get_section_bfd_owner (include_section);
24712 include_mac_end = dwz->macro.buffer + dwz->macro.size;
24716 new_mac_ptr = include_section->buffer + offset;
24717 slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
24721 /* This has actually happened; see
24722 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
24723 complaint (_("recursive DW_MACRO_import in "
24724 ".debug_macro section"));
24728 *slot = (void *) new_mac_ptr;
24730 dwarf_decode_macro_bytes (cu, include_bfd, new_mac_ptr,
24731 include_mac_end, current_file, lh,
24732 section, section_is_gnu, is_dwz,
24733 offset_size, include_hash);
24735 htab_remove_elt (include_hash, (void *) new_mac_ptr);
24740 case DW_MACINFO_vendor_ext:
24741 if (!section_is_gnu)
24743 unsigned int bytes_read;
24745 /* This reads the constant, but since we don't recognize
24746 any vendor extensions, we ignore it. */
24747 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24748 mac_ptr += bytes_read;
24749 read_direct_string (abfd, mac_ptr, &bytes_read);
24750 mac_ptr += bytes_read;
24752 /* We don't recognize any vendor extensions. */
24758 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24759 mac_ptr, mac_end, abfd, offset_size,
24761 if (mac_ptr == NULL)
24766 } while (macinfo_type != 0);
24770 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
24771 int section_is_gnu)
24773 struct dwarf2_per_objfile *dwarf2_per_objfile
24774 = cu->per_cu->dwarf2_per_objfile;
24775 struct objfile *objfile = dwarf2_per_objfile->objfile;
24776 struct line_header *lh = cu->line_header;
24778 const gdb_byte *mac_ptr, *mac_end;
24779 struct macro_source_file *current_file = 0;
24780 enum dwarf_macro_record_type macinfo_type;
24781 unsigned int offset_size = cu->header.offset_size;
24782 const gdb_byte *opcode_definitions[256];
24784 struct dwarf2_section_info *section;
24785 const char *section_name;
24787 if (cu->dwo_unit != NULL)
24789 if (section_is_gnu)
24791 section = &cu->dwo_unit->dwo_file->sections.macro;
24792 section_name = ".debug_macro.dwo";
24796 section = &cu->dwo_unit->dwo_file->sections.macinfo;
24797 section_name = ".debug_macinfo.dwo";
24802 if (section_is_gnu)
24804 section = &dwarf2_per_objfile->macro;
24805 section_name = ".debug_macro";
24809 section = &dwarf2_per_objfile->macinfo;
24810 section_name = ".debug_macinfo";
24814 dwarf2_read_section (objfile, section);
24815 if (section->buffer == NULL)
24817 complaint (_("missing %s section"), section_name);
24820 abfd = get_section_bfd_owner (section);
24822 /* First pass: Find the name of the base filename.
24823 This filename is needed in order to process all macros whose definition
24824 (or undefinition) comes from the command line. These macros are defined
24825 before the first DW_MACINFO_start_file entry, and yet still need to be
24826 associated to the base file.
24828 To determine the base file name, we scan the macro definitions until we
24829 reach the first DW_MACINFO_start_file entry. We then initialize
24830 CURRENT_FILE accordingly so that any macro definition found before the
24831 first DW_MACINFO_start_file can still be associated to the base file. */
24833 mac_ptr = section->buffer + offset;
24834 mac_end = section->buffer + section->size;
24836 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24837 &offset_size, section_is_gnu);
24838 if (mac_ptr == NULL)
24840 /* We already issued a complaint. */
24846 /* Do we at least have room for a macinfo type byte? */
24847 if (mac_ptr >= mac_end)
24849 /* Complaint is printed during the second pass as GDB will probably
24850 stop the first pass earlier upon finding
24851 DW_MACINFO_start_file. */
24855 macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24858 /* Note that we rely on the fact that the corresponding GNU and
24859 DWARF constants are the same. */
24861 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24862 switch (macinfo_type)
24864 /* A zero macinfo type indicates the end of the macro
24869 case DW_MACRO_define:
24870 case DW_MACRO_undef:
24871 /* Only skip the data by MAC_PTR. */
24873 unsigned int bytes_read;
24875 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24876 mac_ptr += bytes_read;
24877 read_direct_string (abfd, mac_ptr, &bytes_read);
24878 mac_ptr += bytes_read;
24882 case DW_MACRO_start_file:
24884 unsigned int bytes_read;
24887 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24888 mac_ptr += bytes_read;
24889 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24890 mac_ptr += bytes_read;
24892 current_file = macro_start_file (cu, file, line, current_file, lh);
24896 case DW_MACRO_end_file:
24897 /* No data to skip by MAC_PTR. */
24900 case DW_MACRO_define_strp:
24901 case DW_MACRO_undef_strp:
24902 case DW_MACRO_define_sup:
24903 case DW_MACRO_undef_sup:
24905 unsigned int bytes_read;
24907 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24908 mac_ptr += bytes_read;
24909 mac_ptr += offset_size;
24913 case DW_MACRO_import:
24914 case DW_MACRO_import_sup:
24915 /* Note that, according to the spec, a transparent include
24916 chain cannot call DW_MACRO_start_file. So, we can just
24917 skip this opcode. */
24918 mac_ptr += offset_size;
24921 case DW_MACINFO_vendor_ext:
24922 /* Only skip the data by MAC_PTR. */
24923 if (!section_is_gnu)
24925 unsigned int bytes_read;
24927 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24928 mac_ptr += bytes_read;
24929 read_direct_string (abfd, mac_ptr, &bytes_read);
24930 mac_ptr += bytes_read;
24935 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24936 mac_ptr, mac_end, abfd, offset_size,
24938 if (mac_ptr == NULL)
24943 } while (macinfo_type != 0 && current_file == NULL);
24945 /* Second pass: Process all entries.
24947 Use the AT_COMMAND_LINE flag to determine whether we are still processing
24948 command-line macro definitions/undefinitions. This flag is unset when we
24949 reach the first DW_MACINFO_start_file entry. */
24951 htab_up include_hash (htab_create_alloc (1, htab_hash_pointer,
24953 NULL, xcalloc, xfree));
24954 mac_ptr = section->buffer + offset;
24955 slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT);
24956 *slot = (void *) mac_ptr;
24957 dwarf_decode_macro_bytes (cu, abfd, mac_ptr, mac_end,
24958 current_file, lh, section,
24959 section_is_gnu, 0, offset_size,
24960 include_hash.get ());
24963 /* Check if the attribute's form is a DW_FORM_block*
24964 if so return true else false. */
24967 attr_form_is_block (const struct attribute *attr)
24969 return (attr == NULL ? 0 :
24970 attr->form == DW_FORM_block1
24971 || attr->form == DW_FORM_block2
24972 || attr->form == DW_FORM_block4
24973 || attr->form == DW_FORM_block
24974 || attr->form == DW_FORM_exprloc);
24977 /* Return non-zero if ATTR's value is a section offset --- classes
24978 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24979 You may use DW_UNSND (attr) to retrieve such offsets.
24981 Section 7.5.4, "Attribute Encodings", explains that no attribute
24982 may have a value that belongs to more than one of these classes; it
24983 would be ambiguous if we did, because we use the same forms for all
24987 attr_form_is_section_offset (const struct attribute *attr)
24989 return (attr->form == DW_FORM_data4
24990 || attr->form == DW_FORM_data8
24991 || attr->form == DW_FORM_sec_offset);
24994 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24995 zero otherwise. When this function returns true, you can apply
24996 dwarf2_get_attr_constant_value to it.
24998 However, note that for some attributes you must check
24999 attr_form_is_section_offset before using this test. DW_FORM_data4
25000 and DW_FORM_data8 are members of both the constant class, and of
25001 the classes that contain offsets into other debug sections
25002 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
25003 that, if an attribute's can be either a constant or one of the
25004 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
25005 taken as section offsets, not constants.
25007 DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
25008 cannot handle that. */
25011 attr_form_is_constant (const struct attribute *attr)
25013 switch (attr->form)
25015 case DW_FORM_sdata:
25016 case DW_FORM_udata:
25017 case DW_FORM_data1:
25018 case DW_FORM_data2:
25019 case DW_FORM_data4:
25020 case DW_FORM_data8:
25021 case DW_FORM_implicit_const:
25029 /* DW_ADDR is always stored already as sect_offset; despite for the forms
25030 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
25033 attr_form_is_ref (const struct attribute *attr)
25035 switch (attr->form)
25037 case DW_FORM_ref_addr:
25042 case DW_FORM_ref_udata:
25043 case DW_FORM_GNU_ref_alt:
25050 /* Return the .debug_loc section to use for CU.
25051 For DWO files use .debug_loc.dwo. */
25053 static struct dwarf2_section_info *
25054 cu_debug_loc_section (struct dwarf2_cu *cu)
25056 struct dwarf2_per_objfile *dwarf2_per_objfile
25057 = cu->per_cu->dwarf2_per_objfile;
25061 struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections;
25063 return cu->header.version >= 5 ? §ions->loclists : §ions->loc;
25065 return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
25066 : &dwarf2_per_objfile->loc);
25069 /* A helper function that fills in a dwarf2_loclist_baton. */
25072 fill_in_loclist_baton (struct dwarf2_cu *cu,
25073 struct dwarf2_loclist_baton *baton,
25074 const struct attribute *attr)
25076 struct dwarf2_per_objfile *dwarf2_per_objfile
25077 = cu->per_cu->dwarf2_per_objfile;
25078 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
25080 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
25082 baton->per_cu = cu->per_cu;
25083 gdb_assert (baton->per_cu);
25084 /* We don't know how long the location list is, but make sure we
25085 don't run off the edge of the section. */
25086 baton->size = section->size - DW_UNSND (attr);
25087 baton->data = section->buffer + DW_UNSND (attr);
25088 baton->base_address = cu->base_address;
25089 baton->from_dwo = cu->dwo_unit != NULL;
25093 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
25094 struct dwarf2_cu *cu, int is_block)
25096 struct dwarf2_per_objfile *dwarf2_per_objfile
25097 = cu->per_cu->dwarf2_per_objfile;
25098 struct objfile *objfile = dwarf2_per_objfile->objfile;
25099 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
25101 if (attr_form_is_section_offset (attr)
25102 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
25103 the section. If so, fall through to the complaint in the
25105 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
25107 struct dwarf2_loclist_baton *baton;
25109 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
25111 fill_in_loclist_baton (cu, baton, attr);
25113 if (cu->base_known == 0)
25114 complaint (_("Location list used without "
25115 "specifying the CU base address."));
25117 SYMBOL_ACLASS_INDEX (sym) = (is_block
25118 ? dwarf2_loclist_block_index
25119 : dwarf2_loclist_index);
25120 SYMBOL_LOCATION_BATON (sym) = baton;
25124 struct dwarf2_locexpr_baton *baton;
25126 baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
25127 baton->per_cu = cu->per_cu;
25128 gdb_assert (baton->per_cu);
25130 if (attr_form_is_block (attr))
25132 /* Note that we're just copying the block's data pointer
25133 here, not the actual data. We're still pointing into the
25134 info_buffer for SYM's objfile; right now we never release
25135 that buffer, but when we do clean up properly this may
25137 baton->size = DW_BLOCK (attr)->size;
25138 baton->data = DW_BLOCK (attr)->data;
25142 dwarf2_invalid_attrib_class_complaint ("location description",
25143 SYMBOL_NATURAL_NAME (sym));
25147 SYMBOL_ACLASS_INDEX (sym) = (is_block
25148 ? dwarf2_locexpr_block_index
25149 : dwarf2_locexpr_index);
25150 SYMBOL_LOCATION_BATON (sym) = baton;
25154 /* Return the OBJFILE associated with the compilation unit CU. If CU
25155 came from a separate debuginfo file, then the master objfile is
25159 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
25161 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25163 /* Return the master objfile, so that we can report and look up the
25164 correct file containing this variable. */
25165 if (objfile->separate_debug_objfile_backlink)
25166 objfile = objfile->separate_debug_objfile_backlink;
25171 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25172 (CU_HEADERP is unused in such case) or prepare a temporary copy at
25173 CU_HEADERP first. */
25175 static const struct comp_unit_head *
25176 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
25177 struct dwarf2_per_cu_data *per_cu)
25179 const gdb_byte *info_ptr;
25182 return &per_cu->cu->header;
25184 info_ptr = per_cu->section->buffer + to_underlying (per_cu->sect_off);
25186 memset (cu_headerp, 0, sizeof (*cu_headerp));
25187 read_comp_unit_head (cu_headerp, info_ptr, per_cu->section,
25188 rcuh_kind::COMPILE);
25193 /* Return the address size given in the compilation unit header for CU. */
25196 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
25198 struct comp_unit_head cu_header_local;
25199 const struct comp_unit_head *cu_headerp;
25201 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25203 return cu_headerp->addr_size;
25206 /* Return the offset size given in the compilation unit header for CU. */
25209 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
25211 struct comp_unit_head cu_header_local;
25212 const struct comp_unit_head *cu_headerp;
25214 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25216 return cu_headerp->offset_size;
25219 /* See its dwarf2loc.h declaration. */
25222 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
25224 struct comp_unit_head cu_header_local;
25225 const struct comp_unit_head *cu_headerp;
25227 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25229 if (cu_headerp->version == 2)
25230 return cu_headerp->addr_size;
25232 return cu_headerp->offset_size;
25235 /* Return the text offset of the CU. The returned offset comes from
25236 this CU's objfile. If this objfile came from a separate debuginfo
25237 file, then the offset may be different from the corresponding
25238 offset in the parent objfile. */
25241 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
25243 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25245 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
25248 /* Return a type that is a generic pointer type, the size of which matches
25249 the address size given in the compilation unit header for PER_CU. */
25250 static struct type *
25251 dwarf2_per_cu_addr_type (struct dwarf2_per_cu_data *per_cu)
25253 struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25254 struct type *void_type = objfile_type (objfile)->builtin_void;
25255 struct type *addr_type = lookup_pointer_type (void_type);
25256 int addr_size = dwarf2_per_cu_addr_size (per_cu);
25258 if (TYPE_LENGTH (addr_type) == addr_size)
25262 = dwarf2_per_cu_addr_sized_int_type (per_cu, TYPE_UNSIGNED (addr_type));
25266 /* Return DWARF version number of PER_CU. */
25269 dwarf2_version (struct dwarf2_per_cu_data *per_cu)
25271 return per_cu->dwarf_version;
25274 /* Locate the .debug_info compilation unit from CU's objfile which contains
25275 the DIE at OFFSET. Raises an error on failure. */
25277 static struct dwarf2_per_cu_data *
25278 dwarf2_find_containing_comp_unit (sect_offset sect_off,
25279 unsigned int offset_in_dwz,
25280 struct dwarf2_per_objfile *dwarf2_per_objfile)
25282 struct dwarf2_per_cu_data *this_cu;
25286 high = dwarf2_per_objfile->all_comp_units.size () - 1;
25289 struct dwarf2_per_cu_data *mid_cu;
25290 int mid = low + (high - low) / 2;
25292 mid_cu = dwarf2_per_objfile->all_comp_units[mid];
25293 if (mid_cu->is_dwz > offset_in_dwz
25294 || (mid_cu->is_dwz == offset_in_dwz
25295 && mid_cu->sect_off + mid_cu->length >= sect_off))
25300 gdb_assert (low == high);
25301 this_cu = dwarf2_per_objfile->all_comp_units[low];
25302 if (this_cu->is_dwz != offset_in_dwz || this_cu->sect_off > sect_off)
25304 if (low == 0 || this_cu->is_dwz != offset_in_dwz)
25305 error (_("Dwarf Error: could not find partial DIE containing "
25306 "offset %s [in module %s]"),
25307 sect_offset_str (sect_off),
25308 bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
25310 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
25312 return dwarf2_per_objfile->all_comp_units[low-1];
25316 if (low == dwarf2_per_objfile->all_comp_units.size () - 1
25317 && sect_off >= this_cu->sect_off + this_cu->length)
25318 error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
25319 gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
25324 /* Initialize dwarf2_cu CU, owned by PER_CU. */
25326 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data *per_cu_)
25327 : per_cu (per_cu_),
25329 has_loclist (false),
25330 checked_producer (false),
25331 producer_is_gxx_lt_4_6 (false),
25332 producer_is_gcc_lt_4_3 (false),
25333 producer_is_icc (false),
25334 producer_is_icc_lt_14 (false),
25335 producer_is_codewarrior (false),
25336 processing_has_namespace_info (false)
25341 /* Destroy a dwarf2_cu. */
25343 dwarf2_cu::~dwarf2_cu ()
25348 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
25351 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
25352 enum language pretend_language)
25354 struct attribute *attr;
25356 /* Set the language we're debugging. */
25357 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
25359 set_cu_language (DW_UNSND (attr), cu);
25362 cu->language = pretend_language;
25363 cu->language_defn = language_def (cu->language);
25366 cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
25369 /* Increase the age counter on each cached compilation unit, and free
25370 any that are too old. */
25373 age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
25375 struct dwarf2_per_cu_data *per_cu, **last_chain;
25377 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
25378 per_cu = dwarf2_per_objfile->read_in_chain;
25379 while (per_cu != NULL)
25381 per_cu->cu->last_used ++;
25382 if (per_cu->cu->last_used <= dwarf_max_cache_age)
25383 dwarf2_mark (per_cu->cu);
25384 per_cu = per_cu->cu->read_in_chain;
25387 per_cu = dwarf2_per_objfile->read_in_chain;
25388 last_chain = &dwarf2_per_objfile->read_in_chain;
25389 while (per_cu != NULL)
25391 struct dwarf2_per_cu_data *next_cu;
25393 next_cu = per_cu->cu->read_in_chain;
25395 if (!per_cu->cu->mark)
25398 *last_chain = next_cu;
25401 last_chain = &per_cu->cu->read_in_chain;
25407 /* Remove a single compilation unit from the cache. */
25410 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
25412 struct dwarf2_per_cu_data *per_cu, **last_chain;
25413 struct dwarf2_per_objfile *dwarf2_per_objfile
25414 = target_per_cu->dwarf2_per_objfile;
25416 per_cu = dwarf2_per_objfile->read_in_chain;
25417 last_chain = &dwarf2_per_objfile->read_in_chain;
25418 while (per_cu != NULL)
25420 struct dwarf2_per_cu_data *next_cu;
25422 next_cu = per_cu->cu->read_in_chain;
25424 if (per_cu == target_per_cu)
25428 *last_chain = next_cu;
25432 last_chain = &per_cu->cu->read_in_chain;
25438 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25439 We store these in a hash table separate from the DIEs, and preserve them
25440 when the DIEs are flushed out of cache.
25442 The CU "per_cu" pointer is needed because offset alone is not enough to
25443 uniquely identify the type. A file may have multiple .debug_types sections,
25444 or the type may come from a DWO file. Furthermore, while it's more logical
25445 to use per_cu->section+offset, with Fission the section with the data is in
25446 the DWO file but we don't know that section at the point we need it.
25447 We have to use something in dwarf2_per_cu_data (or the pointer to it)
25448 because we can enter the lookup routine, get_die_type_at_offset, from
25449 outside this file, and thus won't necessarily have PER_CU->cu.
25450 Fortunately, PER_CU is stable for the life of the objfile. */
25452 struct dwarf2_per_cu_offset_and_type
25454 const struct dwarf2_per_cu_data *per_cu;
25455 sect_offset sect_off;
25459 /* Hash function for a dwarf2_per_cu_offset_and_type. */
25462 per_cu_offset_and_type_hash (const void *item)
25464 const struct dwarf2_per_cu_offset_and_type *ofs
25465 = (const struct dwarf2_per_cu_offset_and_type *) item;
25467 return (uintptr_t) ofs->per_cu + to_underlying (ofs->sect_off);
25470 /* Equality function for a dwarf2_per_cu_offset_and_type. */
25473 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
25475 const struct dwarf2_per_cu_offset_and_type *ofs_lhs
25476 = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
25477 const struct dwarf2_per_cu_offset_and_type *ofs_rhs
25478 = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
25480 return (ofs_lhs->per_cu == ofs_rhs->per_cu
25481 && ofs_lhs->sect_off == ofs_rhs->sect_off);
25484 /* Set the type associated with DIE to TYPE. Save it in CU's hash
25485 table if necessary. For convenience, return TYPE.
25487 The DIEs reading must have careful ordering to:
25488 * Not cause infite loops trying to read in DIEs as a prerequisite for
25489 reading current DIE.
25490 * Not trying to dereference contents of still incompletely read in types
25491 while reading in other DIEs.
25492 * Enable referencing still incompletely read in types just by a pointer to
25493 the type without accessing its fields.
25495 Therefore caller should follow these rules:
25496 * Try to fetch any prerequisite types we may need to build this DIE type
25497 before building the type and calling set_die_type.
25498 * After building type call set_die_type for current DIE as soon as
25499 possible before fetching more types to complete the current type.
25500 * Make the type as complete as possible before fetching more types. */
25502 static struct type *
25503 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
25505 struct dwarf2_per_objfile *dwarf2_per_objfile
25506 = cu->per_cu->dwarf2_per_objfile;
25507 struct dwarf2_per_cu_offset_and_type **slot, ofs;
25508 struct objfile *objfile = dwarf2_per_objfile->objfile;
25509 struct attribute *attr;
25510 struct dynamic_prop prop;
25512 /* For Ada types, make sure that the gnat-specific data is always
25513 initialized (if not already set). There are a few types where
25514 we should not be doing so, because the type-specific area is
25515 already used to hold some other piece of info (eg: TYPE_CODE_FLT
25516 where the type-specific area is used to store the floatformat).
25517 But this is not a problem, because the gnat-specific information
25518 is actually not needed for these types. */
25519 if (need_gnat_info (cu)
25520 && TYPE_CODE (type) != TYPE_CODE_FUNC
25521 && TYPE_CODE (type) != TYPE_CODE_FLT
25522 && TYPE_CODE (type) != TYPE_CODE_METHODPTR
25523 && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
25524 && TYPE_CODE (type) != TYPE_CODE_METHOD
25525 && !HAVE_GNAT_AUX_INFO (type))
25526 INIT_GNAT_SPECIFIC (type);
25528 /* Read DW_AT_allocated and set in type. */
25529 attr = dwarf2_attr (die, DW_AT_allocated, cu);
25530 if (attr_form_is_block (attr))
25532 struct type *prop_type
25533 = dwarf2_per_cu_addr_sized_int_type (cu->per_cu, false);
25534 if (attr_to_dynamic_prop (attr, die, cu, &prop, prop_type))
25535 add_dyn_prop (DYN_PROP_ALLOCATED, prop, type);
25537 else if (attr != NULL)
25539 complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25540 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25541 sect_offset_str (die->sect_off));
25544 /* Read DW_AT_associated and set in type. */
25545 attr = dwarf2_attr (die, DW_AT_associated, cu);
25546 if (attr_form_is_block (attr))
25548 struct type *prop_type
25549 = dwarf2_per_cu_addr_sized_int_type (cu->per_cu, false);
25550 if (attr_to_dynamic_prop (attr, die, cu, &prop, prop_type))
25551 add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type);
25553 else if (attr != NULL)
25555 complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25556 (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25557 sect_offset_str (die->sect_off));
25560 /* Read DW_AT_data_location and set in type. */
25561 attr = dwarf2_attr (die, DW_AT_data_location, cu);
25562 if (attr_to_dynamic_prop (attr, die, cu, &prop,
25563 dwarf2_per_cu_addr_type (cu->per_cu)))
25564 add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type);
25566 if (dwarf2_per_objfile->die_type_hash == NULL)
25568 dwarf2_per_objfile->die_type_hash =
25569 htab_create_alloc_ex (127,
25570 per_cu_offset_and_type_hash,
25571 per_cu_offset_and_type_eq,
25573 &objfile->objfile_obstack,
25574 hashtab_obstack_allocate,
25575 dummy_obstack_deallocate);
25578 ofs.per_cu = cu->per_cu;
25579 ofs.sect_off = die->sect_off;
25581 slot = (struct dwarf2_per_cu_offset_and_type **)
25582 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
25584 complaint (_("A problem internal to GDB: DIE %s has type already set"),
25585 sect_offset_str (die->sect_off));
25586 *slot = XOBNEW (&objfile->objfile_obstack,
25587 struct dwarf2_per_cu_offset_and_type);
25592 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25593 or return NULL if the die does not have a saved type. */
25595 static struct type *
25596 get_die_type_at_offset (sect_offset sect_off,
25597 struct dwarf2_per_cu_data *per_cu)
25599 struct dwarf2_per_cu_offset_and_type *slot, ofs;
25600 struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
25602 if (dwarf2_per_objfile->die_type_hash == NULL)
25605 ofs.per_cu = per_cu;
25606 ofs.sect_off = sect_off;
25607 slot = ((struct dwarf2_per_cu_offset_and_type *)
25608 htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
25615 /* Look up the type for DIE in CU in die_type_hash,
25616 or return NULL if DIE does not have a saved type. */
25618 static struct type *
25619 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
25621 return get_die_type_at_offset (die->sect_off, cu->per_cu);
25624 /* Add a dependence relationship from CU to REF_PER_CU. */
25627 dwarf2_add_dependence (struct dwarf2_cu *cu,
25628 struct dwarf2_per_cu_data *ref_per_cu)
25632 if (cu->dependencies == NULL)
25634 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
25635 NULL, &cu->comp_unit_obstack,
25636 hashtab_obstack_allocate,
25637 dummy_obstack_deallocate);
25639 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
25641 *slot = ref_per_cu;
25644 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25645 Set the mark field in every compilation unit in the
25646 cache that we must keep because we are keeping CU. */
25649 dwarf2_mark_helper (void **slot, void *data)
25651 struct dwarf2_per_cu_data *per_cu;
25653 per_cu = (struct dwarf2_per_cu_data *) *slot;
25655 /* cu->dependencies references may not yet have been ever read if QUIT aborts
25656 reading of the chain. As such dependencies remain valid it is not much
25657 useful to track and undo them during QUIT cleanups. */
25658 if (per_cu->cu == NULL)
25661 if (per_cu->cu->mark)
25663 per_cu->cu->mark = true;
25665 if (per_cu->cu->dependencies != NULL)
25666 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
25671 /* Set the mark field in CU and in every other compilation unit in the
25672 cache that we must keep because we are keeping CU. */
25675 dwarf2_mark (struct dwarf2_cu *cu)
25680 if (cu->dependencies != NULL)
25681 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
25685 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
25689 per_cu->cu->mark = false;
25690 per_cu = per_cu->cu->read_in_chain;
25694 /* Trivial hash function for partial_die_info: the hash value of a DIE
25695 is its offset in .debug_info for this objfile. */
25698 partial_die_hash (const void *item)
25700 const struct partial_die_info *part_die
25701 = (const struct partial_die_info *) item;
25703 return to_underlying (part_die->sect_off);
25706 /* Trivial comparison function for partial_die_info structures: two DIEs
25707 are equal if they have the same offset. */
25710 partial_die_eq (const void *item_lhs, const void *item_rhs)
25712 const struct partial_die_info *part_die_lhs
25713 = (const struct partial_die_info *) item_lhs;
25714 const struct partial_die_info *part_die_rhs
25715 = (const struct partial_die_info *) item_rhs;
25717 return part_die_lhs->sect_off == part_die_rhs->sect_off;
25720 struct cmd_list_element *set_dwarf_cmdlist;
25721 struct cmd_list_element *show_dwarf_cmdlist;
25724 set_dwarf_cmd (const char *args, int from_tty)
25726 help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
25731 show_dwarf_cmd (const char *args, int from_tty)
25733 cmd_show_list (show_dwarf_cmdlist, from_tty, "");
25736 int dwarf_always_disassemble;
25739 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
25740 struct cmd_list_element *c, const char *value)
25742 fprintf_filtered (file,
25743 _("Whether to always disassemble "
25744 "DWARF expressions is %s.\n"),
25749 show_check_physname (struct ui_file *file, int from_tty,
25750 struct cmd_list_element *c, const char *value)
25752 fprintf_filtered (file,
25753 _("Whether to check \"physname\" is %s.\n"),
25758 _initialize_dwarf2_read (void)
25760 add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
25761 Set DWARF specific variables.\n\
25762 Configure DWARF variables such as the cache size"),
25763 &set_dwarf_cmdlist, "maintenance set dwarf ",
25764 0/*allow-unknown*/, &maintenance_set_cmdlist);
25766 add_prefix_cmd ("dwarf", class_maintenance, show_dwarf_cmd, _("\
25767 Show DWARF specific variables\n\
25768 Show DWARF variables such as the cache size"),
25769 &show_dwarf_cmdlist, "maintenance show dwarf ",
25770 0/*allow-unknown*/, &maintenance_show_cmdlist);
25772 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
25773 &dwarf_max_cache_age, _("\
25774 Set the upper bound on the age of cached DWARF compilation units."), _("\
25775 Show the upper bound on the age of cached DWARF compilation units."), _("\
25776 A higher limit means that cached compilation units will be stored\n\
25777 in memory longer, and more total memory will be used. Zero disables\n\
25778 caching, which can slow down startup."),
25780 show_dwarf_max_cache_age,
25781 &set_dwarf_cmdlist,
25782 &show_dwarf_cmdlist);
25784 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
25785 &dwarf_always_disassemble, _("\
25786 Set whether `info address' always disassembles DWARF expressions."), _("\
25787 Show whether `info address' always disassembles DWARF expressions."), _("\
25788 When enabled, DWARF expressions are always printed in an assembly-like\n\
25789 syntax. When disabled, expressions will be printed in a more\n\
25790 conversational style, when possible."),
25792 show_dwarf_always_disassemble,
25793 &set_dwarf_cmdlist,
25794 &show_dwarf_cmdlist);
25796 add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
25797 Set debugging of the DWARF reader."), _("\
25798 Show debugging of the DWARF reader."), _("\
25799 When enabled (non-zero), debugging messages are printed during DWARF\n\
25800 reading and symtab expansion. A value of 1 (one) provides basic\n\
25801 information. A value greater than 1 provides more verbose information."),
25804 &setdebuglist, &showdebuglist);
25806 add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
25807 Set debugging of the DWARF DIE reader."), _("\
25808 Show debugging of the DWARF DIE reader."), _("\
25809 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25810 The value is the maximum depth to print."),
25813 &setdebuglist, &showdebuglist);
25815 add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
25816 Set debugging of the dwarf line reader."), _("\
25817 Show debugging of the dwarf line reader."), _("\
25818 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25819 A value of 1 (one) provides basic information.\n\
25820 A value greater than 1 provides more verbose information."),
25823 &setdebuglist, &showdebuglist);
25825 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
25826 Set cross-checking of \"physname\" code against demangler."), _("\
25827 Show cross-checking of \"physname\" code against demangler."), _("\
25828 When enabled, GDB's internal \"physname\" code is checked against\n\
25830 NULL, show_check_physname,
25831 &setdebuglist, &showdebuglist);
25833 add_setshow_boolean_cmd ("use-deprecated-index-sections",
25834 no_class, &use_deprecated_index_sections, _("\
25835 Set whether to use deprecated gdb_index sections."), _("\
25836 Show whether to use deprecated gdb_index sections."), _("\
25837 When enabled, deprecated .gdb_index sections are used anyway.\n\
25838 Normally they are ignored either because of a missing feature or\n\
25839 performance issue.\n\
25840 Warning: This option must be enabled before gdb reads the file."),
25843 &setlist, &showlist);
25845 dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
25846 &dwarf2_locexpr_funcs);
25847 dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
25848 &dwarf2_loclist_funcs);
25850 dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
25851 &dwarf2_block_frame_base_locexpr_funcs);
25852 dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
25853 &dwarf2_block_frame_base_loclist_funcs);
25856 selftests::register_test ("dw2_expand_symtabs_matching",
25857 selftests::dw2_expand_symtabs_matching::run_test);